github-mirror/caddy
2
0
Fork 0
mirror of https://github.com/caddyserver/caddy.git synced 2024-12-01 21:24:23 +08:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity
3ce3f3a96a
caddy/caddyhttp/templates/templates_test.go

141 lines
3.5 KiB
Go
Raw Normal View History

Apply Apache license to all .go source files (closes #1865) I am not a lawyer, but according to the appendix of the license, these boilerplate notices should be included with every source file.
2017-09-23 13:56:58 +08:00
// Copyright 2015 Light Code Labs, LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
Migrate remaining middleware packages
2016-06-06 12:39:23 +08:00
package templates
import (
mitm, templates, context: Pool buffers to reduce allocations Also disable some tests on context.Hostname because they're not portable
2017-04-22 09:54:25 +08:00
"bytes"
templates: Execute template loaded by later middlewares (#1649) * templates: Execute template loaded by later middlewares This is the beginning of an attempt to make the staticfiles file server the only middleware that hits the disk and loads content. This may have unknown implications. But the goal is to reduce duplication without sacrificing performance. (We now call ServeContent here.) This change loses about 15% of the req/sec of the old way of doing it, but this way is arguably more correct since the file server is good at serving static files; duplicating that logic in every middleware that needs to hit the disk is not practical. * httpserver: Introduce ResponseRecorder as per Tw's suggestions It implements io.ReaderFrom and has some allocation-reducing optimizations baked into it * templates: Increase execution speed by ~10-15% after perf regression By using httpserver.ResponseBuffer, we can reduce allocations and still get what we want. It's a little tricky but it works so far.
2017-08-24 21:13:53 +08:00
"context"
Migrate remaining middleware packages
2016-06-06 12:39:23 +08:00
"net/http"
"net/http/httptest"
mitm, templates, context: Pool buffers to reduce allocations Also disable some tests on context.Hostname because they're not portable
2017-04-22 09:54:25 +08:00
"sync"
Migrate remaining middleware packages
2016-06-06 12:39:23 +08:00
"testing"
"github.com/mholt/caddy/caddyhttp/httpserver"
templates: Execute template loaded by later middlewares (#1649) * templates: Execute template loaded by later middlewares This is the beginning of an attempt to make the staticfiles file server the only middleware that hits the disk and loads content. This may have unknown implications. But the goal is to reduce duplication without sacrificing performance. (We now call ServeContent here.) This change loses about 15% of the req/sec of the old way of doing it, but this way is arguably more correct since the file server is good at serving static files; duplicating that logic in every middleware that needs to hit the disk is not practical. * httpserver: Introduce ResponseRecorder as per Tw's suggestions It implements io.ReaderFrom and has some allocation-reducing optimizations baked into it * templates: Increase execution speed by ~10-15% after perf regression By using httpserver.ResponseBuffer, we can reduce allocations and still get what we want. It's a little tricky but it works so far.
2017-08-24 21:13:53 +08:00
"github.com/mholt/caddy/caddyhttp/staticfiles"
Migrate remaining middleware packages
2016-06-06 12:39:23 +08:00
)
func TestTemplates(t *testing.T) {
templates: Execute template loaded by later middlewares (#1649) * templates: Execute template loaded by later middlewares This is the beginning of an attempt to make the staticfiles file server the only middleware that hits the disk and loads content. This may have unknown implications. But the goal is to reduce duplication without sacrificing performance. (We now call ServeContent here.) This change loses about 15% of the req/sec of the old way of doing it, but this way is arguably more correct since the file server is good at serving static files; duplicating that logic in every middleware that needs to hit the disk is not practical. * httpserver: Introduce ResponseRecorder as per Tw's suggestions It implements io.ReaderFrom and has some allocation-reducing optimizations baked into it * templates: Increase execution speed by ~10-15% after perf regression By using httpserver.ResponseBuffer, we can reduce allocations and still get what we want. It's a little tricky but it works so far.
2017-08-24 21:13:53 +08:00
siteRoot := "./testdata"
Migrate remaining middleware packages
2016-06-06 12:39:23 +08:00
tmpl := Templates{
templates: Execute template loaded by later middlewares (#1649) * templates: Execute template loaded by later middlewares This is the beginning of an attempt to make the staticfiles file server the only middleware that hits the disk and loads content. This may have unknown implications. But the goal is to reduce duplication without sacrificing performance. (We now call ServeContent here.) This change loses about 15% of the req/sec of the old way of doing it, but this way is arguably more correct since the file server is good at serving static files; duplicating that logic in every middleware that needs to hit the disk is not practical. * httpserver: Introduce ResponseRecorder as per Tw's suggestions It implements io.ReaderFrom and has some allocation-reducing optimizations baked into it * templates: Increase execution speed by ~10-15% after perf regression By using httpserver.ResponseBuffer, we can reduce allocations and still get what we want. It's a little tricky but it works so far.
2017-08-24 21:13:53 +08:00
Next: staticfiles.FileServer{Root: http.Dir(siteRoot)},
Migrate remaining middleware packages
2016-06-06 12:39:23 +08:00
Rules: []Rule{
{
Extensions: []string{".html"},
IndexFiles: []string{"index.html"},
Path: "/photos",
},
{
Extensions: []string{".html", ".htm"},
IndexFiles: []string{"index.html", "index.htm"},
Path: "/images",
Delims: [2]string{"{%", "%}"},
},
},
templates: Execute template loaded by later middlewares (#1649) * templates: Execute template loaded by later middlewares This is the beginning of an attempt to make the staticfiles file server the only middleware that hits the disk and loads content. This may have unknown implications. But the goal is to reduce duplication without sacrificing performance. (We now call ServeContent here.) This change loses about 15% of the req/sec of the old way of doing it, but this way is arguably more correct since the file server is good at serving static files; duplicating that logic in every middleware that needs to hit the disk is not practical. * httpserver: Introduce ResponseRecorder as per Tw's suggestions It implements io.ReaderFrom and has some allocation-reducing optimizations baked into it * templates: Increase execution speed by ~10-15% after perf regression By using httpserver.ResponseBuffer, we can reduce allocations and still get what we want. It's a little tricky but it works so far.
2017-08-24 21:13:53 +08:00
Root: siteRoot,
FileSys: http.Dir(siteRoot),
mitm, templates, context: Pool buffers to reduce allocations Also disable some tests on context.Hostname because they're not portable
2017-04-22 09:54:25 +08:00
BufPool: &sync.Pool{New: func() interface{} { return new(bytes.Buffer) }},
Migrate remaining middleware packages
2016-06-06 12:39:23 +08:00
}
tmplroot := Templates{
templates: Execute template loaded by later middlewares (#1649) * templates: Execute template loaded by later middlewares This is the beginning of an attempt to make the staticfiles file server the only middleware that hits the disk and loads content. This may have unknown implications. But the goal is to reduce duplication without sacrificing performance. (We now call ServeContent here.) This change loses about 15% of the req/sec of the old way of doing it, but this way is arguably more correct since the file server is good at serving static files; duplicating that logic in every middleware that needs to hit the disk is not practical. * httpserver: Introduce ResponseRecorder as per Tw's suggestions It implements io.ReaderFrom and has some allocation-reducing optimizations baked into it * templates: Increase execution speed by ~10-15% after perf regression By using httpserver.ResponseBuffer, we can reduce allocations and still get what we want. It's a little tricky but it works so far.
2017-08-24 21:13:53 +08:00
Next: staticfiles.FileServer{Root: http.Dir(siteRoot)},
Migrate remaining middleware packages
2016-06-06 12:39:23 +08:00
Rules: []Rule{
{
Extensions: []string{".html"},
IndexFiles: []string{"index.html"},
Path: "/",
},
},
templates: Execute template loaded by later middlewares (#1649) * templates: Execute template loaded by later middlewares This is the beginning of an attempt to make the staticfiles file server the only middleware that hits the disk and loads content. This may have unknown implications. But the goal is to reduce duplication without sacrificing performance. (We now call ServeContent here.) This change loses about 15% of the req/sec of the old way of doing it, but this way is arguably more correct since the file server is good at serving static files; duplicating that logic in every middleware that needs to hit the disk is not practical. * httpserver: Introduce ResponseRecorder as per Tw's suggestions It implements io.ReaderFrom and has some allocation-reducing optimizations baked into it * templates: Increase execution speed by ~10-15% after perf regression By using httpserver.ResponseBuffer, we can reduce allocations and still get what we want. It's a little tricky but it works so far.
2017-08-24 21:13:53 +08:00
Root: siteRoot,
FileSys: http.Dir(siteRoot),
mitm, templates, context: Pool buffers to reduce allocations Also disable some tests on context.Hostname because they're not portable
2017-04-22 09:54:25 +08:00
BufPool: &sync.Pool{New: func() interface{} { return new(bytes.Buffer) }},
Migrate remaining middleware packages
2016-06-06 12:39:23 +08:00
}
template: add extension filter test and simplify test code (#1996) Signed-off-by: Tw <tw19881113@gmail.com>
2018-01-16 09:27:55 +08:00
// register custom function which is used in template
httpserver.TemplateFuncs["root"] = func() string { return "root" }
Migrate remaining middleware packages
2016-06-06 12:39:23 +08:00
template: add extension filter test and simplify test code (#1996) Signed-off-by: Tw <tw19881113@gmail.com>
2018-01-16 09:27:55 +08:00
for _, c := range []struct {
tpl Templates
req string
respCode int
res string
}{
{
tpl: tmpl,
req: "/photos/test.html",
respCode: http.StatusOK,
res: `<!DOCTYPE html><html><head><title>test page</title></head><body><h1>Header title</h1>
Migrate remaining middleware packages
2016-06-06 12:39:23 +08:00
</body></html>
template: add extension filter test and simplify test code (#1996) Signed-off-by: Tw <tw19881113@gmail.com>
2018-01-16 09:27:55 +08:00
`,
},
Migrate remaining middleware packages
2016-06-06 12:39:23 +08:00
template: add extension filter test and simplify test code (#1996) Signed-off-by: Tw <tw19881113@gmail.com>
2018-01-16 09:27:55 +08:00
{
tpl: tmpl,
req: "/images/img.htm",
respCode: http.StatusOK,
res: `<!DOCTYPE html><html><head><title>img</title></head><body><h1>Header title</h1>
Migrate remaining middleware packages
2016-06-06 12:39:23 +08:00
</body></html>
template: add extension filter test and simplify test code (#1996) Signed-off-by: Tw <tw19881113@gmail.com>
2018-01-16 09:27:55 +08:00
`,
},
Migrate remaining middleware packages
2016-06-06 12:39:23 +08:00
template: add extension filter test and simplify test code (#1996) Signed-off-by: Tw <tw19881113@gmail.com>
2018-01-16 09:27:55 +08:00
{
tpl: tmpl,
req: "/images/img2.htm",
respCode: http.StatusOK,
res: `<!DOCTYPE html><html><head><title>img</title></head><body>{{.Include "header.html"}}</body></html>
`,
},
Migrate remaining middleware packages
2016-06-06 12:39:23 +08:00
template: add extension filter test and simplify test code (#1996) Signed-off-by: Tw <tw19881113@gmail.com>
2018-01-16 09:27:55 +08:00
{
tpl: tmplroot,
req: "/root.html",
respCode: http.StatusOK,
res: `<!DOCTYPE html><html><head><title>root</title></head><body><h1>Header title</h1>
Migrate remaining middleware packages
2016-06-06 12:39:23 +08:00
</body></html>
template: add extension filter test and simplify test code (#1996) Signed-off-by: Tw <tw19881113@gmail.com>
2018-01-16 09:27:55 +08:00
`,
},
Migrate remaining middleware packages
2016-06-06 12:39:23 +08:00
template: add extension filter test and simplify test code (#1996) Signed-off-by: Tw <tw19881113@gmail.com>
2018-01-16 09:27:55 +08:00
// test extension filter
{
tpl: tmplroot,
req: "/as_it_is.txt",
respCode: http.StatusOK,
res: `<!DOCTYPE html><html><head><title>as it is</title></head><body>{{.Include "header.html"}}</body></html>
`,
},
} {
c := c
t.Run("", func(t *testing.T) {
req, err := http.NewRequest("GET", c.req, nil)
if err != nil {
t.Fatalf("Test: Could not create HTTP request: %v", err)
}
req = req.WithContext(context.WithValue(req.Context(), httpserver.OriginalURLCtxKey, *req.URL))
rec := httptest.NewRecorder()
c.tpl.ServeHTTP(rec, req)
if rec.Code != c.respCode {
t.Fatalf("Test: Wrong response code: %d, should be %d", rec.Code, c.respCode)
}
respBody := rec.Body.String()
if respBody != c.res {
t.Fatalf("Test: the expected body %v is different from the response one: %v", c.res, respBody)
}
})
Migrate remaining middleware packages
2016-06-06 12:39:23 +08:00
}
}
Reference in New Issue Copy Permalink