From 40105094e7a3ef7330f31588852a93746791721f Mon Sep 17 00:00:00 2001 From: Matthew Holt Date: Thu, 7 May 2015 13:10:48 -0600 Subject: [PATCH] Some tests and utilities for setup functions --- config/setup/basicauth_test.go | 100 ++++++++++++++++++++++++++++++++ config/setup/controller_test.go | 15 +++++ config/setup/gzip_test.go | 29 +++++++++ config/setup/rewrite_test.go | 85 +++++++++++++++++++++++++++ 4 files changed, 229 insertions(+) create mode 100644 config/setup/basicauth_test.go create mode 100644 config/setup/gzip_test.go create mode 100644 config/setup/rewrite_test.go diff --git a/config/setup/basicauth_test.go b/config/setup/basicauth_test.go new file mode 100644 index 000000000..0f9d044e8 --- /dev/null +++ b/config/setup/basicauth_test.go @@ -0,0 +1,100 @@ +package setup + +import ( + "fmt" + "testing" + + "github.com/mholt/caddy/middleware/basicauth" +) + +func TestBasicAuth(t *testing.T) { + c := newTestController(`basicauth user pwd`) + + mid, err := BasicAuth(c) + if err != nil { + t.Errorf("Expected no errors, but got: %v", err) + } + if mid == nil { + t.Fatal("Expected middleware, was nil instead") + } + + handler := mid(emptyNext) + myHandler, ok := handler.(basicauth.BasicAuth) + if !ok { + t.Fatalf("Expected handler to be type BasicAuth, got: %#v", handler) + } + + if !sameNext(myHandler.Next, emptyNext) { + t.Error("'Next' field of handler was not set properly") + } +} + +func TestBasicAuthParse(t *testing.T) { + tests := []struct { + input string + shouldErr bool + expected []basicauth.Rule + }{ + {`basicauth user pwd`, false, []basicauth.Rule{ + {Username: "user", Password: "pwd"}, + }}, + {`basicauth user pwd { + }`, false, []basicauth.Rule{ + {Username: "user", Password: "pwd"}, + }}, + {`basicauth user pwd { + /resource1 + /resource2 + }`, false, []basicauth.Rule{ + {Username: "user", Password: "pwd", Resources: []string{"/resource1", "/resource2"}}, + }}, + {`basicauth /resource user pwd`, false, []basicauth.Rule{ + {Username: "user", Password: "pwd", Resources: []string{"/resource"}}, + }}, + {`basicauth /res1 user1 pwd1 + basicauth /res2 user2 pwd2`, false, []basicauth.Rule{ + {Username: "user1", Password: "pwd1", Resources: []string{"/res1"}}, + {Username: "user2", Password: "pwd2", Resources: []string{"/res2"}}, + }}, + {`basicauth user`, true, []basicauth.Rule{}}, + {`basicauth`, true, []basicauth.Rule{}}, + {`basicauth /resource user pwd asdf`, true, []basicauth.Rule{}}, + } + + for i, test := range tests { + c := newTestController(test.input) + actual, err := basicAuthParse(c) + + if err == nil && test.shouldErr { + t.Errorf("Test %d didn't error, but it should have", i) + } else if err != nil && !test.shouldErr { + t.Errorf("Test %d errored, but it shouldn't have; got '%v'", i, err) + } + + if len(actual) != len(test.expected) { + t.Fatalf("Test %d expected %d rules, but got %d", + i, len(test.expected), len(actual)) + } + + for j, expectedRule := range test.expected { + actualRule := actual[j] + + if actualRule.Username != expectedRule.Username { + t.Errorf("Test %d, rule %d: Expected username '%s', got '%s'", + i, j, expectedRule.Username, actualRule.Username) + } + + if actualRule.Password != expectedRule.Password { + t.Errorf("Test %d, rule %d: Expected password '%s', got '%s'", + i, j, expectedRule.Password, actualRule.Password) + } + + expectedRes := fmt.Sprintf("%v", expectedRule.Resources) + actualRes := fmt.Sprintf("%v", actualRule.Resources) + if actualRes != expectedRes { + t.Errorf("Test %d, rule %d: Expected resource list %s, but got %s", + i, j, expectedRes, actualRes) + } + } + } +} diff --git a/config/setup/controller_test.go b/config/setup/controller_test.go index 7d0b0ec57..225d031e3 100644 --- a/config/setup/controller_test.go +++ b/config/setup/controller_test.go @@ -1,9 +1,12 @@ package setup import ( + "fmt" + "net/http" "strings" "github.com/mholt/caddy/config/parse" + "github.com/mholt/caddy/middleware" "github.com/mholt/caddy/server" ) @@ -15,3 +18,15 @@ func newTestController(input string) *Controller { Dispenser: parse.NewDispenser("Testfile", strings.NewReader(input)), } } + +// emptyNext is a no-op function that can be passed into +// middleware.Middleware functions so that the assignment +// to the Next field of the Handler can be tested. +var emptyNext = middleware.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) { + return 0, nil +}) + +// sameNext does a pointer comparison between next1 and next2. +func sameNext(next1, next2 middleware.Handler) bool { + return fmt.Sprintf("%p", next1) == fmt.Sprintf("%p", next2) +} diff --git a/config/setup/gzip_test.go b/config/setup/gzip_test.go new file mode 100644 index 000000000..d9978184a --- /dev/null +++ b/config/setup/gzip_test.go @@ -0,0 +1,29 @@ +package setup + +import ( + "testing" + + "github.com/mholt/caddy/middleware/gzip" +) + +func TestGzip(t *testing.T) { + c := newTestController(`gzip`) + + mid, err := Gzip(c) + if err != nil { + t.Errorf("Expected no errors, but got: %v", err) + } + if mid == nil { + t.Fatal("Expected middleware, was nil instead") + } + + handler := mid(emptyNext) + myHandler, ok := handler.(gzip.Gzip) + if !ok { + t.Fatalf("Expected handler to be type Gzip, got: %#v", handler) + } + + if !sameNext(myHandler.Next, emptyNext) { + t.Error("'Next' field of handler was not set properly") + } +} diff --git a/config/setup/rewrite_test.go b/config/setup/rewrite_test.go new file mode 100644 index 000000000..17a0e97b5 --- /dev/null +++ b/config/setup/rewrite_test.go @@ -0,0 +1,85 @@ +package setup + +import ( + "testing" + + "github.com/mholt/caddy/middleware/rewrite" +) + +func TestRewrite(t *testing.T) { + c := newTestController(`rewrite /from /to`) + + mid, err := Rewrite(c) + if err != nil { + t.Errorf("Expected no errors, but got: %v", err) + } + if mid == nil { + t.Fatal("Expected middleware, was nil instead") + } + + handler := mid(emptyNext) + myHandler, ok := handler.(rewrite.Rewrite) + if !ok { + t.Fatalf("Expected handler to be type Rewrite, got: %#v", handler) + } + + if !sameNext(myHandler.Next, emptyNext) { + t.Error("'Next' field of handler was not set properly") + } + + if len(myHandler.Rules) != 1 { + t.Errorf("Expected handler to have %d rule, has %d instead", 1, len(myHandler.Rules)) + } +} + +func TestRewriteParse(t *testing.T) { + tests := []struct { + input string + shouldErr bool + expected []rewrite.Rule + }{ + {`rewrite /from /to`, false, []rewrite.Rule{ + {From: "/from", To: "/to"}, + }}, + {`rewrite /from /to + rewrite a b`, false, []rewrite.Rule{ + {From: "/from", To: "/to"}, + {From: "a", To: "b"}, + }}, + {`rewrite a`, true, []rewrite.Rule{}}, + {`rewrite`, true, []rewrite.Rule{}}, + {`rewrite a b c`, true, []rewrite.Rule{ + {From: "a", To: "b"}, + }}, + } + + for i, test := range tests { + c := newTestController(test.input) + actual, err := rewriteParse(c) + + if err == nil && test.shouldErr { + t.Errorf("Test %d didn't error, but it should have", i) + } else if err != nil && !test.shouldErr { + t.Errorf("Test %d errored, but it shouldn't have; got '%v'", i, err) + } + + if len(actual) != len(test.expected) { + t.Fatalf("Test %d expected %d rules, but got %d", + i, len(test.expected), len(actual)) + } + + for j, expectedRule := range test.expected { + actualRule := actual[j] + + if actualRule.From != expectedRule.From { + t.Errorf("Test %d, rule %d: Expected From=%s, got %s", + i, j, expectedRule.From, actualRule.From) + } + + if actualRule.To != expectedRule.To { + t.Errorf("Test %d, rule %d: Expected To=%s, got %s", + i, j, expectedRule.To, actualRule.To) + } + } + } +}