Esempio n. 1
0
// TestFileServeHandler tests the serving of files.
func TestFileServeHandler(t *testing.T) {
	assert := audit.NewTestingAssertion(t, true)
	// Setup the test file.
	dir, err := ioutil.TempDir("", "gont-web")
	assert.Nil(err)
	defer os.RemoveAll(dir)
	filename := filepath.Join(dir, "foo.txt")
	f, err := os.Create(filename)
	assert.Nil(err)
	_, err = f.WriteString("Been there, done that!")
	assert.Nil(err)
	assert.Logf("written %s", f.Name())
	err = f.Close()
	assert.Nil(err)
	// Setup the test server.
	mux, ts, err := web.StartTestServer()
	assert.Nil(err)
	defer ts.Close()
	err = mux.Register("test", "files", web.NewFileServeHandler("files", dir))
	assert.Nil(err)
	// Perform test requests.
	resp, err := web.DoTestRequest(ts, &web.TestRequest{
		Method: "GET",
		Path:   "/test/files/foo.txt",
	})
	assert.Nil(err)
	assert.Equal(string(resp.Body), "Been there, done that!")
	resp, err = web.DoTestRequest(ts, &web.TestRequest{
		Method: "GET",
		Path:   "/test/files/does.not.exist",
	})
	assert.Nil(err)
	assert.Equal(string(resp.Body), "404 page not found\n")
}
Esempio n. 2
0
// TestPutGOB tests the PUT command with a GOB payload and result.
func TestPutGOB(t *testing.T) {
	assert := audit.NewTestingAssertion(t, true)
	// Setup the test server.
	mux, ts, err := web.StartTestServer()
	assert.Nil(err)
	defer ts.Close()
	err = mux.Register("test", "gob", NewTestHandler("putgob", assert))
	assert.Nil(err)
	// Perform test requests.
	reqData := TestCounterData{"test", 4711}
	reqBuf := new(bytes.Buffer)
	err = gob.NewEncoder(reqBuf).Encode(reqData)
	assert.Nil(err, "GOB encode.")
	t.Logf("%q", reqBuf.String())
	resp, err := web.DoTestRequest(ts, &web.TestRequest{
		Method: "POST",
		Path:   "/test/gob",
		Header: web.TestSettings{"Content-Type": "application/vnd.tideland.gob"},
		Body:   reqBuf.Bytes(),
	})
	var respData TestCounterData
	err = gob.NewDecoder(bytes.NewBuffer(resp.Body)).Decode(&respData)
	assert.Nil(err, "GOB decode.")
	assert.Equal(respData.ID, "test", "GOB decoded 'id'.")
	assert.Equal(respData.Count, int64(4711), "GOB decoded 'count'.")
}
Esempio n. 3
0
// TestHandlerStack tests a complete handler stack.
func TestHandlerStack(t *testing.T) {
	assert := audit.NewTestingAssertion(t, true)
	// Setup the test server.
	sm := web.NewCookieSceneManager(5 * time.Minute)
	mux, ts, err := web.StartTestServer(web.Scenes(sm))
	assert.Nil(err)
	defer ts.Close()
	err = mux.RegisterAll(web.Registrations{
		{"authentication", "login", NewTestHandler("login", assert)},
		{"test", "stack", NewAuthHandler("foo", assert)},
		{"test", "stack", NewTestHandler("stack", assert)},
	})
	assert.Nil(err)
	// Perform test requests.
	resp, err := web.DoTestRequest(ts, &web.TestRequest{
		Method: "GET",
		Path:   "/test/stack",
	})
	sceneID := resp.Cookies["sceneID"]
	assert.Substring("<li>Resource: login</li>", string(resp.Body))
	resp, err = web.DoTestRequest(ts, &web.TestRequest{
		Method:  "GET",
		Path:    "/test/stack",
		Cookies: web.TestSettings{"sceneID": sceneID},
		Header:  web.TestSettings{"password": "******"},
	})
	assert.Nil(err)
	assert.Substring("<li>Resource: stack</li>", string(resp.Body))
	resp, err = web.DoTestRequest(ts, &web.TestRequest{
		Method:  "GET",
		Path:    "/test/stack",
		Cookies: web.TestSettings{"sceneID": sceneID},
		Header:  web.TestSettings{"password": "******"},
	})
	assert.Nil(err)
	assert.Substring("<li>Resource: stack</li>", string(resp.Body))
}
Esempio n. 4
0
// TestMethodNotSupported tests the handling of a not support HTTP method.
func TestMethodNotSupported(t *testing.T) {
	assert := audit.NewTestingAssertion(t, true)
	// Setup the test server.
	mux, ts, err := web.StartTestServer()
	assert.Nil(err)
	defer ts.Close()
	err = mux.Register("test", "method", NewTestHandler("method", assert))
	assert.Nil(err)
	// Perform test requests.
	resp, err := web.DoTestRequest(ts, &web.TestRequest{
		Method: "OPTION",
		Path:   "/test/method",
	})
	assert.Nil(err)
	assert.Substring("OPTION", string(resp.Body))
}
Esempio n. 5
0
// TestFallbackDefault tests the fallback to default.
func TestFallbackDefault(t *testing.T) {
	assert := audit.NewTestingAssertion(t, true)
	// Setup the test server.
	mux, ts, err := web.StartTestServer()
	assert.Nil(err)
	defer ts.Close()
	err = mux.Register("default", "default", NewTestHandler("default", assert))
	assert.Nil(err)
	// Perform test requests.
	resp, err := web.DoTestRequest(ts, &web.TestRequest{
		Method: "GET",
		Path:   "/x/y",
	})
	assert.Nil(err)
	assert.Substring("<li>Resource: y</li>", string(resp.Body))
}
Esempio n. 6
0
// TestLongPath tests the setting of long path tail as resource ID.
func TestLongPath(t *testing.T) {
	assert := audit.NewTestingAssertion(t, true)
	// Setup the test server.
	mux, ts, err := web.StartTestServer()
	assert.Nil(err)
	defer ts.Close()
	err = mux.Register("content", "blog", NewTestHandler("default", assert))
	assert.Nil(err)
	// Perform test requests.
	resp, err := web.DoTestRequest(ts, &web.TestRequest{
		Method: "GET",
		Path:   "/content/blog/2014/09/30/just-a-test",
	})
	assert.Nil(err)
	assert.Substring("<li>Resource ID: 2014/09/30/just-a-test</li>", string(resp.Body))
}
Esempio n. 7
0
// TestGetXML tests the GET command with an XML result.
func TestGetXML(t *testing.T) {
	assert := audit.NewTestingAssertion(t, true)
	// Setup the test server.
	mux, ts, err := web.StartTestServer()
	assert.Nil(err)
	defer ts.Close()
	err = mux.Register("test", "xml", NewTestHandler("xml", assert))
	assert.Nil(err)
	// Perform test requests.
	resp, err := web.DoTestRequest(ts, &web.TestRequest{
		Method: "GET",
		Path:   "/test/xml/4711",
		Header: web.TestSettings{"Accept": "application/xml"},
	})
	assert.Nil(err)
	assert.Substring("<ResourceID>4711</ResourceID>", string(resp.Body))
}
Esempio n. 8
0
// TestWrapperHandler tests the usage of standard handler funcs
// wrapped to be used inside the package context.
func TestWrapperHandler(t *testing.T) {
	assert := audit.NewTestingAssertion(t, true)
	// Setup the test server.
	mux, ts, err := web.StartTestServer()
	assert.Nil(err)
	defer ts.Close()
	handler := func(rw http.ResponseWriter, r *http.Request) {
		rw.Write([]byte("Been there, done that!"))
	}
	err = mux.Register("test", "wrapper", web.NewWrapperHandler("wrapper", handler))
	assert.Nil(err)
	// Perform test requests.
	resp, err := web.DoTestRequest(ts, &web.TestRequest{
		Method: "GET",
		Path:   "/test/wrapper",
	})
	assert.Nil(err)
	assert.Equal(string(resp.Body), "Been there, done that!")
}
Esempio n. 9
0
// TestGetJSON tests the GET command with a JSON result.
func TestGetJSON(t *testing.T) {
	assert := audit.NewTestingAssertion(t, true)
	// Setup the test server.
	mux, ts, err := web.StartTestServer()
	assert.Nil(err)
	defer ts.Close()
	err = mux.Register("test", "json", NewTestHandler("json", assert))
	assert.Nil(err)
	// Perform test requests.
	resp, err := web.DoTestRequest(ts, &web.TestRequest{
		Method: "GET",
		Path:   "/test/json/4711",
		Header: web.TestSettings{"Accept": "application/json"},
	})
	assert.Nil(err, "Local JSON GET.")
	var data TestRequestData
	err = json.Unmarshal(resp.Body, &data)
	assert.Nil(err)
	assert.Equal(data.ResourceID, "4711")
}
Esempio n. 10
0
// TestPutJSON tests the PUT command with a JSON payload and result.
func TestPutJSON(t *testing.T) {
	assert := audit.NewTestingAssertion(t, true)
	// Setup the test server.
	mux, ts, err := web.StartTestServer()
	assert.Nil(err)
	defer ts.Close()
	err = mux.Register("test", "json", NewTestHandler("json", assert))
	assert.Nil(err)
	// Perform test requests.
	reqData := TestRequestData{"foo", "bar", "4711"}
	reqBuf, _ := json.Marshal(reqData)
	resp, err := web.DoTestRequest(ts, &web.TestRequest{
		Method: "PUT",
		Path:   "/test/json/4711",
		Header: web.TestSettings{"Content-Type": "application/json", "Accept": "application/json"},
		Body:   reqBuf,
	})
	assert.Nil(err)
	var recvData TestRequestData
	err = json.Unmarshal(resp.Body, &recvData)
	assert.Nil(err)
	assert.Equal(recvData, reqData)
}