Wrote tests for browse.go and redir.go

caddy/setup/browse_test.go

+package setup
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/mholt/caddy/caddy/parse"
+	"github.com/mholt/caddy/middleware/browse"
+	"github.com/mholt/caddy/server"
+)
+
+func TestBrowse(t *testing.T) {
+
+	tempDirPath, err := getTempDirPath()
+	if err != nil {
+		t.Fatalf("BeforeTest: Failed to find an existing directory for testing! Error was: %v", err)
+	}
+	nonExistantDirPath := filepath.Join(tempDirPath, strconv.Itoa(int(time.Now().UnixNano())))
+
+	tempTemplate, err := ioutil.TempFile(".", "tempTemplate")
+	if err != nil {
+		t.Fatalf("BeforeTest: Failed to create a temporary file in the working directory! Error was: %v", err)
+	}
+	defer os.Remove(tempTemplate.Name())
+
+	tempTemplatePath := filepath.Join(".", tempTemplate.Name())
+
+	testTokens := []string{
+		"browse " + tempDirPath + "\n browse .",
+		"browse /",
+		"browse . " + tempTemplatePath,
+		"browse . " + nonExistantDirPath,
+		"browse " + tempDirPath + "\n browse " + tempDirPath,
+	}
+
+	tests := []struct {
+		expectedPathScope []string
+		shouldErr         bool
+	}{
+		// test case #0 tests handling of multiple pathscopes
+		{[]string{tempDirPath, "."}, false},
+
+		// test case #1 tests instantiation of browse.Config with default values
+		{[]string{"/"}, false},
+
+		// test case #2 tests detectaction of custom template
+		{[]string{"."}, false},
+
+		// test case #3 tests detection of non-existant template
+		{nil, true},
+
+		// test case #4 tests detection of duplicate pathscopes
+		{nil, true},
+	}
+
+	for i, test := range tests {
+		c := &Controller{Config: &server.Config{Root: "."}, Dispenser: parse.NewDispenser("", strings.NewReader(testTokens[i]))}
+		retrievedFunc, err := Browse(c)
+		if err != nil && !test.shouldErr {
+			t.Errorf("Test case #%d recieved an error of %v", i, err)
+		}
+		if test.expectedPathScope == nil {
+			continue
+		}
+		retrievedConfigs := retrievedFunc(nil).(browse.Browse).Configs
+		for j, config := range retrievedConfigs {
+			if config.PathScope != test.expectedPathScope[j] {
+				t.Errorf("Test case #%d expected a pathscope of %v, but got %v", i, test.expectedPathScope, config.PathScope)
+			}
+		}
+	}
+}

caddy/setup/redir_test.go

+package setup
+
+import (
+	"testing"
+
+	"github.com/mholt/caddy/middleware/redirect"
+)
+
+func TestRedir(t *testing.T) {
+
+	tests := []struct {
+		testToken     string
+		shouldErr     bool
+		expectedRules []redirect.Rule
+	}{
+		// test case #0 tests the recognition of a valid HTTP status code defined outside of block statement
+		{"redir 300 {\n/ /foo\n}", false, []redirect.Rule{redirect.Rule{FromPath: "/", To: "/foo", Code: 300}}},
+
+		// test case #1 tests the recognition of an invalid HTTP status code defined outside of block statement
+		{"redir 9000 {\n/ /foo\n}", true, []redirect.Rule{redirect.Rule{}}},
+
+		// test case #2 tests the detection of a valid HTTP status code outside of a block statement being overriden by an invalid HTTP status code inside statement of a block statement
+		{"redir 300 {\n/ /foo 9000\n}", true, []redirect.Rule{redirect.Rule{}}},
+
+		// test case #3 tests the detection of an invalid HTTP status code outside of a block statement being overriden by a valid HTTP status code inside statement of a block statement
+		{"redir 9000 {\n/ /foo 300\n}", true, []redirect.Rule{redirect.Rule{}}},
+
+		// test case #4 tests the recognition of a TO redirection in a block statement.The HTTP status code is set to the default of 301 - MovedPermanently
+		{"redir 302 {\n/foo\n}", false, []redirect.Rule{redirect.Rule{FromPath: "/", To: "/foo", Code: 302}}},
+
+		// test case #5 tests the recognition of a TO and From redirection in a block statement
+		{"redir {\n/bar /foo 303\n}", false, []redirect.Rule{redirect.Rule{FromPath: "/bar", To: "/foo", Code: 303}}},
+
+		// test case #6 tests the recognition of a TO redirection in a non-block statement. The HTTP status code is set to the default of 301 - MovedPermanently
+		{"redir /foo", false, []redirect.Rule{redirect.Rule{FromPath: "/", To: "/foo", Code: 301}}},
+
+		// test case #7 tests the recognition of a TO and From redirection in a non-block statement
+		{"redir /bar /foo 303", false, []redirect.Rule{redirect.Rule{FromPath: "/bar", To: "/foo", Code: 303}}},
+
+		// test case #8 tests the recognition of multiple redirections
+		{"redir {\n / /foo 304 \n} \n redir {\n /bar /foobar 305 \n}", false, []redirect.Rule{redirect.Rule{FromPath: "/", To: "/foo", Code: 304}, redirect.Rule{FromPath: "/bar", To: "/foobar", Code: 305}}},
+
+		// test case #9 tests the detection of duplicate redirections
+		{"redir {\n /bar /foo 304 \n} redir {\n /bar /foo 304 \n}", true, []redirect.Rule{redirect.Rule{}}},
+	}
+
+	for j, test := range tests {
+		c := NewTestController(test.testToken)
+		retrievedFunc, err := Redir(c)
+		if err != nil && !test.shouldErr {
+			t.Errorf("Test case #%d recieved an error of %v", j, err)
+		} else if test.shouldErr {
+			continue
+		}
+		retrievedRules := retrievedFunc(nil).(redirect.Redirect).Rules
+
+		for i, retrievedRule := range retrievedRules {
+			if retrievedRule.FromPath != test.expectedRules[i].FromPath {
+				t.Errorf("Test case #%d.%d expected a from path of %s, but recieved a from path of %s", j, i, test.expectedRules[i].FromPath, retrievedRule.FromPath)
+			}
+			if retrievedRule.To != test.expectedRules[i].To {
+				t.Errorf("Test case #%d.%d expected a TO path of %s, but recieved a TO path of %s", j, i, test.expectedRules[i].To, retrievedRule.To)
+			}
+			if retrievedRule.Code != test.expectedRules[i].Code {
+				t.Errorf("Test case #%d.%d expected a HTTP status code of %d, but recieved a code of %d", j, i, test.expectedRules[i].Code, retrievedRule.Code)
+			}
+		}
+	}
+
+}