Migrate remaining middleware packages

caddyhttp/httpserver/context.go

@@ -0,0 +1,263 @@
+package httpserver
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"net/url"
+	"strings"
+	"text/template"
+	"time"
+
+	"github.com/russross/blackfriday"
+)
+
+// This file contains the context and functions available for
+// use in the templates.
+
+// Context is the context with which Caddy templates are executed.
+type Context struct {
+	Root http.FileSystem
+	Req  *http.Request
+	URL  *url.URL
+}
+
+// Include returns the contents of filename relative to the site root.
+func (c Context) Include(filename string) (string, error) {
+	return ContextInclude(filename, c, c.Root)
+}
+
+// Now returns the current timestamp in the specified format.
+func (c Context) Now(format string) string {
+	return time.Now().Format(format)
+}
+
+// NowDate returns the current date/time that can be used
+// in other time functions.
+func (c Context) NowDate() time.Time {
+	return time.Now()
+}
+
+// Cookie gets the value of a cookie with name name.
+func (c Context) Cookie(name string) string {
+	cookies := c.Req.Cookies()
+	for _, cookie := range cookies {
+		if cookie.Name == name {
+			return cookie.Value
+		}
+	}
+	return ""
+}
+
+// Header gets the value of a request header with field name.
+func (c Context) Header(name string) string {
+	return c.Req.Header.Get(name)
+}
+
+// IP gets the (remote) IP address of the client making the request.
+func (c Context) IP() string {
+	ip, _, err := net.SplitHostPort(c.Req.RemoteAddr)
+	if err != nil {
+		return c.Req.RemoteAddr
+	}
+	return ip
+}
+
+// URI returns the raw, unprocessed request URI (including query
+// string and hash) obtained directly from the Request-Line of
+// the HTTP request.
+func (c Context) URI() string {
+	return c.Req.RequestURI
+}
+
+// Host returns the hostname portion of the Host header
+// from the HTTP request.
+func (c Context) Host() (string, error) {
+	host, _, err := net.SplitHostPort(c.Req.Host)
+	if err != nil {
+		if !strings.Contains(c.Req.Host, ":") {
+			// common with sites served on the default port 80
+			return c.Req.Host, nil
+		}
+		return "", err
+	}
+	return host, nil
+}
+
+// Port returns the port portion of the Host header if specified.
+func (c Context) Port() (string, error) {
+	_, port, err := net.SplitHostPort(c.Req.Host)
+	if err != nil {
+		if !strings.Contains(c.Req.Host, ":") {
+			// common with sites served on the default port 80
+			return "80", nil
+		}
+		return "", err
+	}
+	return port, nil
+}
+
+// Method returns the method (GET, POST, etc.) of the request.
+func (c Context) Method() string {
+	return c.Req.Method
+}
+
+// PathMatches returns true if the path portion of the request
+// URL matches pattern.
+func (c Context) PathMatches(pattern string) bool {
+	return Path(c.Req.URL.Path).Matches(pattern)
+}
+
+// Truncate truncates the input string to the given length.
+// If length is negative, it returns that many characters
+// starting from the end of the string. If the absolute value
+// of length is greater than len(input), the whole input is
+// returned.
+func (c Context) Truncate(input string, length int) string {
+	if length < 0 && len(input)+length > 0 {
+		return input[len(input)+length:]
+	}
+	if length >= 0 && len(input) > length {
+		return input[:length]
+	}
+	return input
+}
+
+// StripHTML returns s without HTML tags. It is fairly naive
+// but works with most valid HTML inputs.
+func (c Context) StripHTML(s string) string {
+	var buf bytes.Buffer
+	var inTag, inQuotes bool
+	var tagStart int
+	for i, ch := range s {
+		if inTag {
+			if ch == '>' && !inQuotes {
+				inTag = false
+			} else if ch == '<' && !inQuotes {
+				// false start
+				buf.WriteString(s[tagStart:i])
+				tagStart = i
+			} else if ch == '"' {
+				inQuotes = !inQuotes
+			}
+			continue
+		}
+		if ch == '<' {
+			inTag = true
+			tagStart = i
+			continue
+		}
+		buf.WriteRune(ch)
+	}
+	if inTag {
+		// false start
+		buf.WriteString(s[tagStart:])
+	}
+	return buf.String()
+}
+
+// StripExt returns the input string without the extension,
+// which is the suffix starting with the final '.' character
+// but not before the final path separator ('/') character.
+// If there is no extension, the whole input is returned.
+func (c Context) StripExt(path string) string {
+	for i := len(path) - 1; i >= 0 && path[i] != '/'; i-- {
+		if path[i] == '.' {
+			return path[:i]
+		}
+	}
+	return path
+}
+
+// Replace replaces instances of find in input with replacement.
+func (c Context) Replace(input, find, replacement string) string {
+	return strings.Replace(input, find, replacement, -1)
+}
+
+// Markdown returns the HTML contents of the markdown contained in filename
+// (relative to the site root).
+func (c Context) Markdown(filename string) (string, error) {
+	body, err := c.Include(filename)
+	if err != nil {
+		return "", err
+	}
+	renderer := blackfriday.HtmlRenderer(0, "", "")
+	extns := 0
+	extns |= blackfriday.EXTENSION_TABLES
+	extns |= blackfriday.EXTENSION_FENCED_CODE
+	extns |= blackfriday.EXTENSION_STRIKETHROUGH
+	extns |= blackfriday.EXTENSION_DEFINITION_LISTS
+	markdown := blackfriday.Markdown([]byte(body), renderer, extns)
+
+	return string(markdown), nil
+}
+
+// ContextInclude opens filename using fs and executes a template with the context ctx.
+// This does the same thing that Context.Include() does, but with the ability to provide
+// your own context so that the included files can have access to additional fields your
+// type may provide. You can embed Context in your type, then override its Include method
+// to call this function with ctx being the instance of your type, and fs being Context.Root.
+func ContextInclude(filename string, ctx interface{}, fs http.FileSystem) (string, error) {
+	file, err := fs.Open(filename)
+	if err != nil {
+		return "", err
+	}
+	defer file.Close()
+
+	body, err := ioutil.ReadAll(file)
+	if err != nil {
+		return "", err
+	}
+
+	tpl, err := template.New(filename).Parse(string(body))
+	if err != nil {
+		return "", err
+	}
+
+	var buf bytes.Buffer
+	err = tpl.Execute(&buf, ctx)
+	if err != nil {
+		return "", err
+	}
+
+	return buf.String(), nil
+}
+
+// ToLower will convert the given string to lower case.
+func (c Context) ToLower(s string) string {
+	return strings.ToLower(s)
+}
+
+// ToUpper will convert the given string to upper case.
+func (c Context) ToUpper(s string) string {
+	return strings.ToUpper(s)
+}
+
+// Split is a passthrough to strings.Split. It will split the first argument at each instance of the separator and return a slice of strings.
+func (c Context) Split(s string, sep string) []string {
+	return strings.Split(s, sep)
+}
+
+// Slice will convert the given arguments into a slice.
+func (c Context) Slice(elems ...interface{}) []interface{} {
+	return elems
+}
+
+// Map will convert the arguments into a map. It expects alternating string keys and values. This is useful for building more complicated data structures
+// if you are using subtemplates or things like that.
+func (c Context) Map(values ...interface{}) (map[string]interface{}, error) {
+	if len(values)%2 != 0 {
+		return nil, fmt.Errorf("Map expects an even number of arguments")
+	}
+	dict := make(map[string]interface{}, len(values)/2)
+	for i := 0; i < len(values); i += 2 {
+		key, ok := values[i].(string)
+		if !ok {
+			return nil, fmt.Errorf("Map keys must be strings")
+		}
+		dict[key] = values[i+1]
+	}
+	return dict, nil
+}

caddyhttp/httpserver/context_test.go

@@ -0,0 +1,650 @@
+package httpserver
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"text/template"
+)
+
+func TestInclude(t *testing.T) {
+	context := getContextOrFail(t)
+
+	inputFilename := "test_file"
+	absInFilePath := filepath.Join(fmt.Sprintf("%s", context.Root), inputFilename)
+	defer func() {
+		err := os.Remove(absInFilePath)
+		if err != nil && !os.IsNotExist(err) {
+			t.Fatalf("Failed to clean test file!")
+		}
+	}()
+
+	tests := []struct {
+		fileContent          string
+		expectedContent      string
+		shouldErr            bool
+		expectedErrorContent string
+	}{
+		// Test 0 - all good
+		{
+			fileContent:          `str1 {{ .Root }} str2`,
+			expectedContent:      fmt.Sprintf("str1 %s str2", context.Root),
+			shouldErr:            false,
+			expectedErrorContent: "",
+		},
+		// Test 1 - failure on template.Parse
+		{
+			fileContent:          `str1 {{ .Root } str2`,
+			expectedContent:      "",
+			shouldErr:            true,
+			expectedErrorContent: `unexpected "}" in operand`,
+		},
+		// Test 3 - failure on template.Execute
+		{
+			fileContent:          `str1 {{ .InvalidField }} str2`,
+			expectedContent:      "",
+			shouldErr:            true,
+			expectedErrorContent: `InvalidField`,
+		},
+		{
+			fileContent:          `str1 {{ .InvalidField }} str2`,
+			expectedContent:      "",
+			shouldErr:            true,
+			expectedErrorContent: `type httpserver.Context`,
+		},
+	}
+
+	for i, test := range tests {
+		testPrefix := getTestPrefix(i)
+
+		// WriteFile truncates the contentt
+		err := ioutil.WriteFile(absInFilePath, []byte(test.fileContent), os.ModePerm)
+		if err != nil {
+			t.Fatal(testPrefix+"Failed to create test file. Error was: %v", err)
+		}
+
+		content, err := context.Include(inputFilename)
+		if err != nil {
+			if !test.shouldErr {
+				t.Errorf(testPrefix+"Expected no error, found [%s]", test.expectedErrorContent, err.Error())
+			}
+			if !strings.Contains(err.Error(), test.expectedErrorContent) {
+				t.Errorf(testPrefix+"Expected error content [%s], found [%s]", test.expectedErrorContent, err.Error())
+			}
+		}
+
+		if err == nil && test.shouldErr {
+			t.Errorf(testPrefix+"Expected error [%s] but found nil. Input file was: %s", test.expectedErrorContent, inputFilename)
+		}
+
+		if content != test.expectedContent {
+			t.Errorf(testPrefix+"Expected content [%s] but found [%s]. Input file was: %s", test.expectedContent, content, inputFilename)
+		}
+	}
+}
+
+func TestIncludeNotExisting(t *testing.T) {
+	context := getContextOrFail(t)
+
+	_, err := context.Include("not_existing")
+	if err == nil {
+		t.Errorf("Expected error but found nil!")
+	}
+}
+
+func TestMarkdown(t *testing.T) {
+	context := getContextOrFail(t)
+
+	inputFilename := "test_file"
+	absInFilePath := filepath.Join(fmt.Sprintf("%s", context.Root), inputFilename)
+	defer func() {
+		err := os.Remove(absInFilePath)
+		if err != nil && !os.IsNotExist(err) {
+			t.Fatalf("Failed to clean test file!")
+		}
+	}()
+
+	tests := []struct {
+		fileContent     string
+		expectedContent string
+	}{
+		// Test 0 - test parsing of markdown
+		{
+			fileContent:     "* str1\n* str2\n",
+			expectedContent: "<ul>\n<li>str1</li>\n<li>str2</li>\n</ul>\n",
+		},
+	}
+
+	for i, test := range tests {
+		testPrefix := getTestPrefix(i)
+
+		// WriteFile truncates the contentt
+		err := ioutil.WriteFile(absInFilePath, []byte(test.fileContent), os.ModePerm)
+		if err != nil {
+			t.Fatal(testPrefix+"Failed to create test file. Error was: %v", err)
+		}
+
+		content, _ := context.Markdown(inputFilename)
+		if content != test.expectedContent {
+			t.Errorf(testPrefix+"Expected content [%s] but found [%s]. Input file was: %s", test.expectedContent, content, inputFilename)
+		}
+	}
+}
+
+func TestCookie(t *testing.T) {
+
+	tests := []struct {
+		cookie        *http.Cookie
+		cookieName    string
+		expectedValue string
+	}{
+		// Test 0 - happy path
+		{
+			cookie:        &http.Cookie{Name: "cookieName", Value: "cookieValue"},
+			cookieName:    "cookieName",
+			expectedValue: "cookieValue",
+		},
+		// Test 1 - try to get a non-existing cookie
+		{
+			cookie:        &http.Cookie{Name: "cookieName", Value: "cookieValue"},
+			cookieName:    "notExisting",
+			expectedValue: "",
+		},
+		// Test 2 - partial name match
+		{
+			cookie:        &http.Cookie{Name: "cookie", Value: "cookieValue"},
+			cookieName:    "cook",
+			expectedValue: "",
+		},
+		// Test 3 - cookie with optional fields
+		{
+			cookie:        &http.Cookie{Name: "cookie", Value: "cookieValue", Path: "/path", Domain: "https://localhost", Expires: (time.Now().Add(10 * time.Minute)), MaxAge: 120},
+			cookieName:    "cookie",
+			expectedValue: "cookieValue",
+		},
+	}
+
+	for i, test := range tests {
+		testPrefix := getTestPrefix(i)
+
+		// reinitialize the context for each test
+		context := getContextOrFail(t)
+
+		context.Req.AddCookie(test.cookie)
+
+		actualCookieVal := context.Cookie(test.cookieName)
+
+		if actualCookieVal != test.expectedValue {
+			t.Errorf(testPrefix+"Expected cookie value [%s] but found [%s] for cookie with name %s", test.expectedValue, actualCookieVal, test.cookieName)
+		}
+	}
+}
+
+func TestCookieMultipleCookies(t *testing.T) {
+	context := getContextOrFail(t)
+
+	cookieNameBase, cookieValueBase := "cookieName", "cookieValue"
+
+	// make sure that there's no state and multiple requests for different cookies return the correct result
+	for i := 0; i < 10; i++ {
+		context.Req.AddCookie(&http.Cookie{Name: fmt.Sprintf("%s%d", cookieNameBase, i), Value: fmt.Sprintf("%s%d", cookieValueBase, i)})
+	}
+
+	for i := 0; i < 10; i++ {
+		expectedCookieVal := fmt.Sprintf("%s%d", cookieValueBase, i)
+		actualCookieVal := context.Cookie(fmt.Sprintf("%s%d", cookieNameBase, i))
+		if actualCookieVal != expectedCookieVal {
+			t.Fatalf("Expected cookie value %s, found %s", expectedCookieVal, actualCookieVal)
+		}
+	}
+}
+
+func TestHeader(t *testing.T) {
+	context := getContextOrFail(t)
+
+	headerKey, headerVal := "Header1", "HeaderVal1"
+	context.Req.Header.Add(headerKey, headerVal)
+
+	actualHeaderVal := context.Header(headerKey)
+	if actualHeaderVal != headerVal {
+		t.Errorf("Expected header %s, found %s", headerVal, actualHeaderVal)
+	}
+
+	missingHeaderVal := context.Header("not-existing")
+	if missingHeaderVal != "" {
+		t.Errorf("Expected empty header value, found %s", missingHeaderVal)
+	}
+}
+
+func TestIP(t *testing.T) {
+	context := getContextOrFail(t)
+
+	tests := []struct {
+		inputRemoteAddr string
+		expectedIP      string
+	}{
+		// Test 0 - ipv4 with port
+		{"1.1.1.1:1111", "1.1.1.1"},
+		// Test 1 - ipv4 without port
+		{"1.1.1.1", "1.1.1.1"},
+		// Test 2 - ipv6 with port
+		{"[::1]:11", "::1"},
+		// Test 3 - ipv6 without port and brackets
+		{"[2001:db8:a0b:12f0::1]", "[2001:db8:a0b:12f0::1]"},
+		// Test 4 - ipv6 with zone and port
+		{`[fe80:1::3%eth0]:44`, `fe80:1::3%eth0`},
+	}
+
+	for i, test := range tests {
+		testPrefix := getTestPrefix(i)
+
+		context.Req.RemoteAddr = test.inputRemoteAddr
+		actualIP := context.IP()
+
+		if actualIP != test.expectedIP {
+			t.Errorf(testPrefix+"Expected IP %s, found %s", test.expectedIP, actualIP)
+		}
+	}
+}
+
+func TestURL(t *testing.T) {
+	context := getContextOrFail(t)
+
+	inputURL := "http://localhost"
+	context.Req.RequestURI = inputURL
+
+	if inputURL != context.URI() {
+		t.Errorf("Expected url %s, found %s", inputURL, context.URI())
+	}
+}
+
+func TestHost(t *testing.T) {
+	tests := []struct {
+		input        string
+		expectedHost string
+		shouldErr    bool
+	}{
+		{
+			input:        "localhost:123",
+			expectedHost: "localhost",
+			shouldErr:    false,
+		},
+		{
+			input:        "localhost",
+			expectedHost: "localhost",
+			shouldErr:    false,
+		},
+		{
+			input:        "[::]",
+			expectedHost: "",
+			shouldErr:    true,
+		},
+	}
+
+	for _, test := range tests {
+		testHostOrPort(t, true, test.input, test.expectedHost, test.shouldErr)
+	}
+}
+
+func TestPort(t *testing.T) {
+	tests := []struct {
+		input        string
+		expectedPort string
+		shouldErr    bool
+	}{
+		{
+			input:        "localhost:123",
+			expectedPort: "123",
+			shouldErr:    false,
+		},
+		{
+			input:        "localhost",
+			expectedPort: "80", // assuming 80 is the default port
+			shouldErr:    false,
+		},
+		{
+			input:        ":8080",
+			expectedPort: "8080",
+			shouldErr:    false,
+		},
+		{
+			input:        "[::]",
+			expectedPort: "",
+			shouldErr:    true,
+		},
+	}
+
+	for _, test := range tests {
+		testHostOrPort(t, false, test.input, test.expectedPort, test.shouldErr)
+	}
+}
+
+func testHostOrPort(t *testing.T, isTestingHost bool, input, expectedResult string, shouldErr bool) {
+	context := getContextOrFail(t)
+
+	context.Req.Host = input
+	var actualResult, testedObject string
+	var err error
+
+	if isTestingHost {
+		actualResult, err = context.Host()
+		testedObject = "host"
+	} else {
+		actualResult, err = context.Port()
+		testedObject = "port"
+	}
+
+	if shouldErr && err == nil {
+		t.Errorf("Expected error, found nil!")
+		return
+	}
+
+	if !shouldErr && err != nil {
+		t.Errorf("Expected no error, found %s", err)
+		return
+	}
+
+	if actualResult != expectedResult {
+		t.Errorf("Expected %s %s, found %s", testedObject, expectedResult, actualResult)
+	}
+}
+
+func TestMethod(t *testing.T) {
+	context := getContextOrFail(t)
+
+	method := "POST"
+	context.Req.Method = method
+
+	if method != context.Method() {
+		t.Errorf("Expected method %s, found %s", method, context.Method())
+	}
+
+}
+
+func TestPathMatches(t *testing.T) {
+	context := getContextOrFail(t)
+
+	tests := []struct {
+		urlStr      string
+		pattern     string
+		shouldMatch bool
+	}{
+		// Test 0
+		{
+			urlStr:      "http://localhost/",
+			pattern:     "",
+			shouldMatch: true,
+		},
+		// Test 1
+		{
+			urlStr:      "http://localhost",
+			pattern:     "",
+			shouldMatch: true,
+		},
+		// Test 1
+		{
+			urlStr:      "http://localhost/",
+			pattern:     "/",
+			shouldMatch: true,
+		},
+		// Test 3
+		{
+			urlStr:      "http://localhost/?param=val",
+			pattern:     "/",
+			shouldMatch: true,
+		},
+		// Test 4
+		{
+			urlStr:      "http://localhost/dir1/dir2",
+			pattern:     "/dir2",
+			shouldMatch: false,
+		},
+		// Test 5
+		{
+			urlStr:      "http://localhost/dir1/dir2",
+			pattern:     "/dir1",
+			shouldMatch: true,
+		},
+		// Test 6
+		{
+			urlStr:      "http://localhost:444/dir1/dir2",
+			pattern:     "/dir1",
+			shouldMatch: true,
+		},
+		// Test 7
+		{
+			urlStr:      "http://localhost/dir1/dir2",
+			pattern:     "*/dir2",
+			shouldMatch: false,
+		},
+	}
+
+	for i, test := range tests {
+		testPrefix := getTestPrefix(i)
+		var err error
+		context.Req.URL, err = url.Parse(test.urlStr)
+		if err != nil {
+			t.Fatalf("Failed to prepare test URL from string %s! Error was: %s", test.urlStr, err)
+		}
+
+		matches := context.PathMatches(test.pattern)
+		if matches != test.shouldMatch {
+			t.Errorf(testPrefix+"Expected and actual result differ: expected to match [%t], actual matches [%t]", test.shouldMatch, matches)
+		}
+	}
+}
+
+func TestTruncate(t *testing.T) {
+	context := getContextOrFail(t)
+	tests := []struct {
+		inputString string
+		inputLength int
+		expected    string
+	}{
+		// Test 0 - small length
+		{
+			inputString: "string",
+			inputLength: 1,
+			expected:    "s",
+		},
+		// Test 1 - exact length
+		{
+			inputString: "string",
+			inputLength: 6,
+			expected:    "string",
+		},
+		// Test 2 - bigger length
+		{
+			inputString: "string",
+			inputLength: 10,
+			expected:    "string",
+		},
+		// Test 3 - zero length
+		{
+			inputString: "string",
+			inputLength: 0,
+			expected:    "",
+		},
+		// Test 4 - negative, smaller length
+		{
+			inputString: "string",
+			inputLength: -5,
+			expected:    "tring",
+		},
+		// Test 5 - negative, exact length
+		{
+			inputString: "string",
+			inputLength: -6,
+			expected:    "string",
+		},
+		// Test 6 - negative, bigger length
+		{
+			inputString: "string",
+			inputLength: -7,
+			expected:    "string",
+		},
+	}
+
+	for i, test := range tests {
+		actual := context.Truncate(test.inputString, test.inputLength)
+		if actual != test.expected {
+			t.Errorf(getTestPrefix(i)+"Expected '%s', found '%s'. Input was Truncate(%q, %d)", test.expected, actual, test.inputString, test.inputLength)
+		}
+	}
+}
+
+func TestStripHTML(t *testing.T) {
+	context := getContextOrFail(t)
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		// Test 0 - no tags
+		{
+			input:    `h1`,
+			expected: `h1`,
+		},
+		// Test 1 - happy path
+		{
+			input:    `<h1>h1</h1>`,
+			expected: `h1`,
+		},
+		// Test 2 - tag in quotes
+		{
+			input:    `<h1">">h1</h1>`,
+			expected: `h1`,
+		},
+		// Test 3 - multiple tags
+		{
+			input:    `<h1><b>h1</b></h1>`,
+			expected: `h1`,
+		},
+		// Test 4 - tags not closed
+		{
+			input:    `<h1`,
+			expected: `<h1`,
+		},
+		// Test 5 - false start
+		{
+			input:    `<h1<b>hi`,
+			expected: `<h1hi`,
+		},
+	}
+
+	for i, test := range tests {
+		actual := context.StripHTML(test.input)
+		if actual != test.expected {
+			t.Errorf(getTestPrefix(i)+"Expected %s, found %s. Input was StripHTML(%s)", test.expected, actual, test.input)
+		}
+	}
+}
+
+func TestStripExt(t *testing.T) {
+	context := getContextOrFail(t)
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		// Test 0 - empty input
+		{
+			input:    "",
+			expected: "",
+		},
+		// Test 1 - relative file with ext
+		{
+			input:    "file.ext",
+			expected: "file",
+		},
+		// Test 2 - relative file without ext
+		{
+			input:    "file",
+			expected: "file",
+		},
+		// Test 3 - absolute file without ext
+		{
+			input:    "/file",
+			expected: "/file",
+		},
+		// Test 4 - absolute file with ext
+		{
+			input:    "/file.ext",
+			expected: "/file",
+		},
+		// Test 5 - with ext but ends with /
+		{
+			input:    "/dir.ext/",
+			expected: "/dir.ext/",
+		},
+		// Test 6 - file with ext under dir with ext
+		{
+			input:    "/dir.ext/file.ext",
+			expected: "/dir.ext/file",
+		},
+	}
+
+	for i, test := range tests {
+		actual := context.StripExt(test.input)
+		if actual != test.expected {
+			t.Errorf(getTestPrefix(i)+"Expected %s, found %s. Input was StripExt(%q)", test.expected, actual, test.input)
+		}
+	}
+}
+
+func initTestContext() (Context, error) {
+	body := bytes.NewBufferString("request body")
+	request, err := http.NewRequest("GET", "https://localhost", body)
+	if err != nil {
+		return Context{}, err
+	}
+
+	return Context{Root: http.Dir(os.TempDir()), Req: request}, nil
+}
+
+func getContextOrFail(t *testing.T) Context {
+	context, err := initTestContext()
+	if err != nil {
+		t.Fatalf("Failed to prepare test context")
+	}
+	return context
+}
+
+func getTestPrefix(testN int) string {
+	return fmt.Sprintf("Test [%d]: ", testN)
+}
+
+func TestTemplates(t *testing.T) {
+	tests := []struct{ tmpl, expected string }{
+		{`{{.ToUpper "aAA"}}`, "AAA"},
+		{`{{"bbb" | .ToUpper}}`, "BBB"},
+		{`{{.ToLower "CCc"}}`, "ccc"},
+		{`{{range (.Split "a,b,c" ",")}}{{.}}{{end}}`, "abc"},
+		{`{{range .Split "a,b,c" ","}}{{.}}{{end}}`, "abc"},
+		{`{{range .Slice "a" "b" "c"}}{{.}}{{end}}`, "abc"},
+		{`{{with .Map "A" "a" "B" "b" "c" "d"}}{{.A}}{{.B}}{{.c}}{{end}}`, "abd"},
+	}
+	for i, test := range tests {
+		ctx := getContextOrFail(t)
+		tmpl, err := template.New("").Parse(test.tmpl)
+		if err != nil {
+			t.Errorf("Test %d: %s", i, err)
+			continue
+		}
+		buf := &bytes.Buffer{}
+		err = tmpl.Execute(buf, ctx)
+		if err != nil {
+			t.Errorf("Test %d: %s", i, err)
+			continue
+		}
+		if buf.String() != test.expected {
+			t.Errorf("Test %d: Results do not match. '%s' != '%s'", i, buf.String(), test.expected)
+		}
+	}
+}