Merge pull request #14 from dpouris/tests

Add Initial Testing Files

Author: dpouris

goster_test.go

@@ -0,0 +1,95 @@
+package goster
+
+import (
+	"testing"
+)
+
+type IsDynamicMatchCase struct {
+	name           string
+	url            string
+	dynPath        string
+	expectedResult bool
+}
+
+func TestIsDynamicRouteMatch(t *testing.T) {
+	ctx := Ctx{
+		Meta: Meta{
+			Query: Params{
+				values: make(map[string]string),
+			},
+			Path: Path{
+				values: make(map[string]string),
+			},
+		},
+	}
+
+	testCases := []IsDynamicMatchCase{
+		{
+			name:           "Depth 1",
+			dynPath:        "path/another_path/:var",
+			url:            "path/another_path/something",
+			expectedResult: true,
+		},
+		{
+			name:           "Depth 1 (with '/' suffix on URL)",
+			dynPath:        "path/another_path/:var",
+			url:            "path/another_path/something/",
+			expectedResult: true,
+		},
+		{
+			name:           "Depth 1 (with '/' suffix on dynPath)",
+			dynPath:        "path/another_path/:var/",
+			url:            "path/another_path/something",
+			expectedResult: true,
+		},
+		{
+			name:           "Depth 1 (with Depth 2 URL)",
+			dynPath:        "path/another_path/:var",
+			url:            "path/another_path/something/something2",
+			expectedResult: false,
+		},
+		{
+			name:           "Depth 2",
+			dynPath:        "path/another_path/:var/:var2",
+			url:            "path/another_path/something/something2",
+			expectedResult: true,
+		},
+		{
+			name:           "Depth 2 (with Depth 1 URL)",
+			dynPath:        "path/another_path/:var/:var2",
+			url:            "path/another_path/something",
+			expectedResult: false,
+		},
+		{
+			name:           "Depth 2 (with '/' suffix on dynPath)",
+			dynPath:        "path/another_path/:var/:var2/",
+			url:            "path/another_path/something/something2",
+			expectedResult: true,
+		},
+		{
+			name:           "Depth 2 (with '/' suffix on URL)",
+			dynPath:        "path/another_path/:var/:var2",
+			url:            "path/another_path/something/something2/",
+			expectedResult: true,
+		},
+	}
+
+	failedCases := make(map[int]IsDynamicMatchCase, 0)
+	for i, c := range testCases {
+		if isDynamicRouteMatch(&ctx, c.url, c.dynPath) != c.expectedResult {
+			failedCases[i] = c
+		} else {
+			t.Logf("PASSED [%d] - %s\n", i, c.name)
+		}
+	}
+
+	// Space
+	t.Log("")
+
+	for i, c := range failedCases {
+		t.Errorf("FAILED [%d] - %s\n", i, c.name)
+	}
+
+	t.Logf("TOTAL CASES: %d\n", len(testCases))
+	t.Logf("FAILED CASES: %d\n", len(failedCases))
+}

meta_test.go

@@ -0,0 +1,73 @@
+package goster
+
+import (
+	"testing"
+)
+
+type ParseUrlCase struct {
+	name        string
+	url         string
+	expectedUrl string
+	shouldFail  bool
+}
+
+func TestParseUrl(t *testing.T) {
+	meta := Meta{
+		Query: Params{
+			values: make(map[string]string),
+		},
+	}
+	testCases := []ParseUrlCase{
+		{
+			name:        "1",
+			url:         "/home/var/",
+			expectedUrl: "/home/var",
+			shouldFail:  false,
+		},
+		{
+			name:        "2",
+			url:         "/home/var/",
+			expectedUrl: "/home/var/",
+			shouldFail:  true,
+		},
+		{
+			name:        "3",
+			url:         "/home/var///",
+			expectedUrl: "/home/var///",
+			shouldFail:  true,
+		},
+		{
+			name:        "4",
+			url:         "/home/var///",
+			expectedUrl: "/home/var//",
+			shouldFail:  false,
+		},
+		{
+			name:        "5",
+			url:         "////",
+			expectedUrl: "///",
+			shouldFail:  false,
+		},
+	}
+
+	failedCases := make(map[int]ParseUrlCase, 0)
+	for i, c := range testCases {
+		meta.ParseUrl(&c.url)
+		if (c.url != c.expectedUrl) == !c.shouldFail {
+			failedCases[i] = c
+		} else {
+			t.Logf("PASSED [%d] - %s\n", i, c.name)
+		}
+	}
+
+	// Space
+	t.Log("")
+
+	for i, c := range failedCases {
+		t.Errorf("FAILED [%d] - %s\n", i, c.name)
+		t.Errorf("Expected '%s' path, but got '%s'", c.expectedUrl, c.url)
+	}
+
+	t.Logf("TOTAL CASES: %d\n", len(testCases))
+	t.Logf("FAILED CASES: %d\n", len(failedCases))
+}

methods_test.go

@@ -0,0 +1,59 @@
+package goster
+
+import (
+	"errors"
+	"testing"
+)
+
+type MethodNewCase struct {
+	name         string
+	method       string
+	url          string
+	expectedPath string
+	handler      RequestHandler
+}
+
+func TestMethodNew(t *testing.T) {
+	g := NewServer()
+	testCases := []MethodNewCase{
+		{
+			name:         "1",
+			method:       "GET",
+			url:          "/home/var",
+			expectedPath: "/home/var",
+			handler:      func(ctx *Ctx) error { return errors.New("test error") },
+		},
+		{
+			name:         "2",
+			method:       "GET",
+			url:          "/home/var////",
+			expectedPath: "/home/var///",
+			handler:      func(ctx *Ctx) error { return errors.New("test error") },
+		},
+	}
+
+	failedCases := make(map[int]MethodNewCase, 0)
+	for i, c := range testCases {
+		g.New(c.method, c.url, c.handler)
+		if _, exists := g.Routes[c.method][c.expectedPath]; exists {
+			t.Logf("PASSED [%d] - %s\n", i, c.name)
+		} else {
+			failedCases[i] = c
+		}
+	}
+
+	// Space
+	t.Log("")
+
+	for i, c := range failedCases {
+		t.Errorf("FAILED [%d] - %s\n", i, c.name)
+	}
+
+	// Space
+	t.Log("")
+	t.Logf("Routes: ")
+	t.Log(g.Routes)
+
+	t.Logf("TOTAL CASES: %d\n", len(testCases))
+	t.Logf("FAILED CASES: %d\n", len(failedCases))
+}

utils_test.go

@@ -0,0 +1,64 @@
+package goster
+
+import "testing"
+
+type CleanPathCase struct {
+	name         string
+	path         string
+	expectedPath string
+}
+
+func TestCleanPath(t *testing.T) {
+	testCases := []CleanPathCase{
+		{
+			name:         "Same path",
+			path:         "home/var",
+			expectedPath: "/home/var",
+		},
+		{
+			name:         "No path",
+			path:         "",
+			expectedPath: "",
+		},
+		{
+			name:         "Single slash",
+			path:         "/",
+			expectedPath: "",
+		},
+		{
+			name:         "A lot of slashes",
+			path:         "/////",
+			expectedPath: "////",
+		},
+		{
+			name:         "Trailing slash",
+			path:         "home/var/",
+			expectedPath: "/home/var",
+		},
+		{
+			name:         "A lot of trailing slashes",
+			path:         "home/var///////",
+			expectedPath: "/home/var//////",
+		},
+	}
+
+	failedCases := make(map[int]CleanPathCase, 0)
+	for i, c := range testCases {
+		cleanPath(&c.path)
+		if c.path != c.expectedPath {
+			failedCases[i] = c
+		} else {
+			t.Logf("PASSED [%d] - %s\n", i, c.name)
+		}
+	}
+
+	// Space
+	t.Log("")
+
+	for i, c := range failedCases {
+		t.Errorf("FAILED [%d] - %s\n", i, c.name)
+	}
+
+	t.Logf("TOTAL CASES: %d\n", len(testCases))
+	t.Logf("FAILED CASES: %d\n", len(failedCases))
+}