func Test_Render_NoRace(t *testing.T) {
// This test used to fail if run with -race
m := martini.Classic()
m.Use(Renderer(Options{
Directory: "fixtures/basic",
}))
// routing
m.Get("/foobar", func(r Render) {
r.HTML(200, "hello", "world")
})
done := make(chan bool)
doreq := func() {
res := httptest.NewRecorder()
req, _ := http.NewRequest("GET", "/foobar", nil)
m.ServeHTTP(res, req)
expect(t, res.Code, 200)
expect(t, res.Header().Get(ContentType), ContentHTML+"; charset=UTF-8")
// ContentLength should be deferred to the ResponseWriter and not Render
expect(t, res.Header().Get(ContentLength), "")
expect(t, res.Body.String(), "<h1>Hello world</h1>\n")
done <- true
}
// Run two requests to check there is no race condition
go doreq()
go doreq()
<-done
<-done
}
func Test_Render_Funcs(t *testing.T) {
m := martini.Classic()
m.Use(Renderer(Options{
Directory: "fixtures/custom_funcs",
Funcs: []template.FuncMap{
{
"myCustomFunc": func() string {
return "My custom function"
},
},
},
}))
// routing
m.Get("/foobar", func(r Render) {
r.HTML(200, "index", "jeremy")
})
res := httptest.NewRecorder()
req, _ := http.NewRequest("GET", "/foobar", nil)
m.ServeHTTP(res, req)
expect(t, res.Body.String(), "My custom function\n")
}
func main() {
port := os.Getenv("PORT")
if len(port) < 1 {
port = "8080"
}
wufooConfig.Account = os.Getenv("WUFOO_ACCOUNT")
wufooConfig.ApiKey = os.Getenv("WUFOO_API_KEY")
wufooConfig.Password = "******"
wufooConfig.FormIds = strings.Split(os.Getenv("WUFOO_FORM_IDS"), ",")
m := martini.Classic()
m.Use(render.Renderer())
m.Use(cors.Allow(&cors.Options{
AllowAllOrigins: true,
}))
m.Get("/", func(r render.Render) {
count, err := count()
if err != nil {
r.JSON(200, map[string]interface{}{"error": "can't fetch information"})
} else {
r.JSON(200, map[string]interface{}{"count": count})
}
})
m.RunOnAddr(":" + port)
}
func Test_Render_Layout_Current(t *testing.T) {
m := martini.Classic()
m.Use(Renderer(Options{
Directory: "fixtures/basic",
Layout: "current_layout",
}))
// routing
m.Get("/foobar", func(r Render) {
r.HTML(200, "content", "jeremy")
})
res := httptest.NewRecorder()
req, _ := http.NewRequest("GET", "/foobar", nil)
m.ServeHTTP(res, req)
expect(t, res.Body.String(), "content head\n<h1>jeremy</h1>\n\ncontent foot\n")
}
func Test_Render_Bad_HTML(t *testing.T) {
m := martini.Classic()
m.Use(Renderer(Options{
Directory: "fixtures/basic",
}))
// routing
m.Get("/foobar", func(r Render) {
r.HTML(200, "nope", nil)
})
res := httptest.NewRecorder()
req, _ := http.NewRequest("GET", "/foobar", nil)
m.ServeHTTP(res, req)
expect(t, res.Code, 500)
expect(t, res.Body.String(), "html/template: \"nope\" is undefined\n")
}
func Test_Preflight(t *testing.T) {
recorder := NewRecorder()
m := martini.Classic()
m.Use(Allow(&Options{
AllowAllOrigins: true,
AllowMethods: []string{"PUT", "PATCH"},
AllowHeaders: []string{"Origin", "X-whatever", "X-CaseSensitive"},
}))
m.Options("foo", func(res http.ResponseWriter) {
res.WriteHeader(500)
})
r, _ := http.NewRequest("OPTIONS", "foo", nil)
r.Header.Add(headerRequestMethod, "PUT")
r.Header.Add(headerRequestHeaders, "X-whatever, x-casesensitive")
m.ServeHTTP(recorder, r)
headers := recorder.Header()
methodsVal := headers.Get(headerAllowMethods)
headersVal := headers.Get(headerAllowHeaders)
originVal := headers.Get(headerAllowOrigin)
if methodsVal != "PUT,PATCH" {
t.Errorf("Allow-Methods is expected to be PUT,PATCH, found %v", methodsVal)
}
if !strings.Contains(headersVal, "X-whatever") {
t.Errorf("Allow-Headers is expected to contain X-whatever, found %v", headersVal)
}
if !strings.Contains(headersVal, "x-casesensitive") {
t.Errorf("Allow-Headers is expected to contain x-casesensitive, found %v", headersVal)
}
if originVal != "*" {
t.Errorf("Allow-Origin is expected to be *, found %v", originVal)
}
if recorder.Code != http.StatusOK {
t.Errorf("Status code is expected to be 200, found %d", recorder.Code)
}
}
func Test_Render_XML(t *testing.T) {
m := martini.Classic()
m.Use(Renderer(Options{
// nothing here to configure
}))
// routing
m.Get("/foobar", func(r Render) {
r.XML(300, GreetingXML{One: "hello", Two: "world"})
})
res := httptest.NewRecorder()
req, _ := http.NewRequest("GET", "/foobar", nil)
m.ServeHTTP(res, req)
expect(t, res.Code, 300)
expect(t, res.Header().Get(ContentType), ContentXML+"; charset=UTF-8")
expect(t, res.Body.String(), `<greeting one="hello" two="world"></greeting>`)
}
func Test_Render_Charset_JSON(t *testing.T) {
m := martini.Classic()
m.Use(Renderer(Options{
Charset: "foobar",
}))
// routing
m.Get("/foobar", func(r Render) {
r.JSON(300, Greeting{"hello", "world"})
})
res := httptest.NewRecorder()
req, _ := http.NewRequest("GET", "/foobar", nil)
m.ServeHTTP(res, req)
expect(t, res.Code, 300)
expect(t, res.Header().Get(ContentType), ContentJSON+"; charset=foobar")
expect(t, res.Body.String(), `{"one":"hello","two":"world"}`)
}
func Test_Render_BinaryData(t *testing.T) {
m := martini.Classic()
m.Use(Renderer(Options{
// nothing here to configure
}))
// routing
m.Get("/foobar", func(r Render) {
r.Data(200, []byte("hello there"))
})
res := httptest.NewRecorder()
req, _ := http.NewRequest("GET", "/foobar", nil)
m.ServeHTTP(res, req)
expect(t, res.Code, 200)
expect(t, res.Header().Get(ContentType), ContentBinary)
expect(t, res.Body.String(), "hello there")
}
func Test_Render_Nested_HTML(t *testing.T) {
m := martini.Classic()
m.Use(Renderer(Options{
Directory: "fixtures/basic",
}))
// routing
m.Get("/foobar", func(r Render) {
r.HTML(200, "admin/index", "jeremy")
})
res := httptest.NewRecorder()
req, _ := http.NewRequest("GET", "/foobar", nil)
m.ServeHTTP(res, req)
expect(t, res.Code, 200)
expect(t, res.Header().Get(ContentType), ContentHTML+"; charset=UTF-8")
expect(t, res.Body.String(), "<h1>Admin jeremy</h1>\n")
}
func Test_Render_JSON_Prefix(t *testing.T) {
m := martini.Classic()
prefix := ")]}',\n"
m.Use(Renderer(Options{
PrefixJSON: []byte(prefix),
}))
// routing
m.Get("/foobar", func(r Render) {
r.JSON(300, Greeting{"hello", "world"})
})
res := httptest.NewRecorder()
req, _ := http.NewRequest("GET", "/foobar", nil)
m.ServeHTTP(res, req)
expect(t, res.Code, 300)
expect(t, res.Header().Get(ContentType), ContentJSON+"; charset=UTF-8")
expect(t, res.Body.String(), prefix+`{"one":"hello","two":"world"}`)
}
func Test_Render_Delimiters(t *testing.T) {
m := martini.Classic()
m.Use(Renderer(Options{
Delims: Delims{"{[{", "}]}"},
Directory: "fixtures/basic",
}))
// routing
m.Get("/foobar", func(r Render) {
r.HTML(200, "delims", "jeremy")
})
res := httptest.NewRecorder()
req, _ := http.NewRequest("GET", "/foobar", nil)
m.ServeHTTP(res, req)
expect(t, res.Code, 200)
expect(t, res.Header().Get(ContentType), ContentHTML+"; charset=UTF-8")
expect(t, res.Body.String(), "<h1>Hello jeremy</h1>")
}
func Test_Render_Extensions(t *testing.T) {
m := martini.Classic()
m.Use(Renderer(Options{
Directory: "fixtures/basic",
Extensions: []string{".tmpl", ".html"},
}))
// routing
m.Get("/foobar", func(r Render) {
r.HTML(200, "hypertext", nil)
})
res := httptest.NewRecorder()
req, _ := http.NewRequest("GET", "/foobar", nil)
m.ServeHTTP(res, req)
expect(t, res.Code, 200)
expect(t, res.Header().Get(ContentType), ContentHTML+"; charset=UTF-8")
expect(t, res.Body.String(), "Hypertext!\n")
}
func Test_Render_Default_Charset_HTML(t *testing.T) {
m := martini.Classic()
m.Use(Renderer(Options{
Directory: "fixtures/basic",
}))
// routing
m.Get("/foobar", func(r Render) {
r.HTML(200, "hello", "jeremy")
})
res := httptest.NewRecorder()
req, _ := http.NewRequest("GET", "/foobar", nil)
m.ServeHTTP(res, req)
expect(t, res.Code, 200)
expect(t, res.Header().Get(ContentType), ContentHTML+"; charset=UTF-8")
// ContentLength should be deferred to the ResponseWriter and not Render
expect(t, res.Header().Get(ContentLength), "")
expect(t, res.Body.String(), "<h1>Hello jeremy</h1>\n")
}
func Test_Render_Override_Layout(t *testing.T) {
m := martini.Classic()
m.Use(Renderer(Options{
Directory: "fixtures/basic",
Layout: "layout",
}))
// routing
m.Get("/foobar", func(r Render) {
r.HTML(200, "content", "jeremy", HTMLOptions{
Layout: "another_layout",
})
})
res := httptest.NewRecorder()
req, _ := http.NewRequest("GET", "/foobar", nil)
m.ServeHTTP(res, req)
expect(t, res.Code, 200)
expect(t, res.Header().Get(ContentType), ContentHTML+"; charset=UTF-8")
expect(t, res.Body.String(), "another head\n<h1>jeremy</h1>\n\nanother foot\n")
}