Add tests

Author: neoxelox

README.md

@@ -62,10 +62,10 @@ States.Aliases()  // [COMMITTED IN_PROGRESS DONE]
 **`Check if Value is in Enum`**
 
 ```go
-States.Is("COMMITTED")  // true
-States.Is("BLOCKED")  // true
-States.Is("IN_PROGRESS")  // false
-States.Is("COMPLETED")  // false
+States.In(State("COMMITTED"))  // true
+States.In(State("BLOCKED"))  // true
+States.In(State("IN_PROGRESS"))  // false
+States.In(State("COMPLETED"))  // false
 ```
 
 **`Get Enum Values`**

enum_test.go

@@ -1,28 +1,198 @@
 package enum_test
 
 import (
+	"reflect"
 	"testing"
 
 	"github.com/neoxelox/enum"
 )
 
-type State string
+type LiteState string
 
-type enumStates = struct {
-	COMMITTED   State
-	IN_PROGRESS State
-	DONE        State
+type enumLiteStates = struct {
+	COMMITTED   LiteState
+	IN_PROGRESS LiteState
+	DONE        LiteState
 	enum.Enum
 }
 
-func TestNew(t *testing.T) {
-	States := enum.New(&enumStates{
+func TestNewLite(t *testing.T) {
+	liteStates := enum.New(&enumLiteStates{
 		COMMITTED:   "COMMITTED",
 		IN_PROGRESS: "BLOCKED",
 		DONE:        "DONE",
-	}).(*enumStates)
+	}).(*enumLiteStates)
 
-	if States.COMMITTED != "COMMITTED" {
-		t.Fatalf("Failed committed test")
+	if reflect.TypeOf(liteStates.COMMITTED).Kind() != reflect.String {
+		t.Fatalf("Type of Lite enum is not a primitive string")
+	}
+
+	if liteStates.COMMITTED != "COMMITTED" {
+		t.Fatalf("Lite enum is not a comparable with an string literal")
+	}
+}
+
+func TestIsLite(t *testing.T) {
+	liteStates := enum.New(&enumLiteStates{
+		COMMITTED:   "COMMITTED",
+		IN_PROGRESS: "BLOCKED",
+		DONE:        "DONE",
+	}).(*enumLiteStates)
+
+	if !liteStates.Is("IN_PROGRESS") {
+		t.Fatalf("IN_PROGRESS should be an alias of Lite enum")
+	}
+
+	if liteStates.Is("BLOCKED") {
+		t.Fatalf("BLOCKED should not be an alias of Lite enum")
+	}
+}
+
+func TestAliasesLite(t *testing.T) {
+	liteStates := enum.New(&enumLiteStates{
+		COMMITTED:   "COMMITTED",
+		IN_PROGRESS: "BLOCKED",
+		DONE:        "DONE",
+	}).(*enumLiteStates)
+
+	aliases := liteStates.Aliases()
+	if len(aliases) != 3 {
+		t.Fatalf("Aliases of Lite enum should be three")
+	}
+
+	expectedAliases := []string{"COMMITTED", "IN_PROGRESS", "DONE"}
+	for i := range aliases {
+		if aliases[i] != expectedAliases[i] {
+			t.Fatalf("Expected alias: %v, instead got: %v, in Lite enum", expectedAliases[i], aliases[i])
+		}
+	}
+}
+
+func TestInLite(t *testing.T) {
+	liteStates := enum.New(&enumLiteStates{
+		COMMITTED:   "COMMITTED",
+		IN_PROGRESS: "BLOCKED",
+		DONE:        "DONE",
+	}).(*enumLiteStates)
+
+	if !liteStates.In(LiteState("BLOCKED")) {
+		t.Fatalf("BLOCKED should be a value of Lite enum")
+	}
+
+	if liteStates.In(LiteState("IN_PROGRESS")) {
+		t.Fatalf("IN_PROGRESS should not be a value of Lite enum")
+	}
+}
+
+func TestValuesLite(t *testing.T) {
+	liteStates := enum.New(&enumLiteStates{
+		COMMITTED:   "COMMITTED",
+		IN_PROGRESS: "BLOCKED",
+		DONE:        "DONE",
+	}).(*enumLiteStates)
+
+	values := liteStates.Values()
+	if len(values) != 3 {
+		t.Fatalf("Values of Lite enum should be three")
+	}
+
+	expectedValues := []LiteState{LiteState("COMMITTED"), LiteState("BLOCKED"), LiteState("DONE")}
+	for i := range values {
+		if alias := (values[i]).(LiteState); alias != expectedValues[i] {
+			t.Fatalf("Expected alias: %v, instead got: %v, in Lite enum", expectedValues[i], alias)
+		}
+	}
+}
+
+type StrongState struct{ string }
+
+type enumStrongStates = struct {
+	COMMITTED   StrongState
+	IN_PROGRESS StrongState
+	DONE        StrongState
+	enum.Enum
+}
+
+func TestNewStrong(t *testing.T) {
+	strongStates := enum.New(&enumStrongStates{
+		COMMITTED:   StrongState{"COMMITTED"},
+		IN_PROGRESS: StrongState{"BLOCKED"},
+		DONE:        StrongState{"DONE"},
+	}).(*enumStrongStates)
+
+	if reflect.TypeOf(strongStates.COMMITTED).Kind() != reflect.Struct {
+		t.Fatalf("Type of Strong enum is not a primitive struct")
+	}
+}
+
+func TestIsStrong(t *testing.T) {
+	strongStates := enum.New(&enumStrongStates{
+		COMMITTED:   StrongState{"COMMITTED"},
+		IN_PROGRESS: StrongState{"BLOCKED"},
+		DONE:        StrongState{"DONE"},
+	}).(*enumStrongStates)
+
+	if !strongStates.Is("IN_PROGRESS") {
+		t.Fatalf("IN_PROGRESS should be an alias of Strong enum")
+	}
+
+	if strongStates.Is("BLOCKED") {
+		t.Fatalf("BLOCKED should not be an alias of Strong enum")
+	}
+}
+
+func TestAliasesStrong(t *testing.T) {
+	strongStates := enum.New(&enumStrongStates{
+		COMMITTED:   StrongState{"COMMITTED"},
+		IN_PROGRESS: StrongState{"BLOCKED"},
+		DONE:        StrongState{"DONE"},
+	}).(*enumStrongStates)
+
+	aliases := strongStates.Aliases()
+	if len(aliases) != 3 {
+		t.Fatalf("Aliases of Strong enum should be three")
+	}
+
+	expectedAliases := []string{"COMMITTED", "IN_PROGRESS", "DONE"}
+	for i := range aliases {
+		if aliases[i] != expectedAliases[i] {
+			t.Fatalf("Expected alias: %v, instead got: %v, in Strong enum", expectedAliases[i], aliases[i])
+		}
+	}
+}
+
+func TestInStrong(t *testing.T) {
+	strongStates := enum.New(&enumStrongStates{
+		COMMITTED:   StrongState{"COMMITTED"},
+		IN_PROGRESS: StrongState{"BLOCKED"},
+		DONE:        StrongState{"DONE"},
+	}).(*enumStrongStates)
+
+	if !strongStates.In(StrongState{"BLOCKED"}) {
+		t.Fatalf("BLOCKED should be a value of Strong enum")
+	}
+
+	if strongStates.In(StrongState{"IN_PROGRESS"}) {
+		t.Fatalf("IN_PROGRESS should not be a value of Strong enum")
+	}
+}
+
+func TestValuesStrong(t *testing.T) {
+	strongStates := enum.New(&enumStrongStates{
+		COMMITTED:   StrongState{"COMMITTED"},
+		IN_PROGRESS: StrongState{"BLOCKED"},
+		DONE:        StrongState{"DONE"},
+	}).(*enumStrongStates)
+
+	values := strongStates.Values()
+	if len(values) != 3 {
+		t.Fatalf("Values of Strong enum should be three")
+	}
+
+	expectedValues := []StrongState{StrongState{"COMMITTED"}, StrongState{"BLOCKED"}, StrongState{"DONE"}}
+	for i := range values {
+		if alias := (values[i]).(StrongState); alias != expectedValues[i] {
+			t.Fatalf("Expected alias: %v, instead got: %v, in Strong enum", expectedValues[i], alias)
+		}
 	}
 }

tasks.py

@@ -15,18 +15,21 @@ def fail(message):
 @task(
     help={
         "test": "<PACKAGE_PATH>::<TEST_NAME>. If empty, it will run all tests.",
+        "verbose": "Show stdout of tests.",
         "show": "Show coverprofile page.",
     }
 )
-def test(c, test="", show=False):
+def test(c, test="", verbose=False, show=False):
     """Run tests."""
     test_regex = "./..."
 
     test = test.split("::")
     if len(test) == 2:
         test_regex = f"-run {test[1]} {test[0]}"
 
-    r = c.run(f"go test -race -count=1 -cover {'-coverprofile=coverage.out' if show else ''} {test_regex}")
+    r = c.run(
+        f"go test {'-v' if verbose else ''} -race -count=1 -cover {'-coverprofile=coverage.out' if show else ''} {test_regex}"
+    )
 
     packages = 0
     coverage = 0.0