cmd_serve_test.go

// Simple testing of the HTTP-server
package main

import (
	"bytes"
	"fmt"
	"io/ioutil"
	"net/http"
	"net/http/httptest"
	"net/url"
	"os"
	"strconv"
	"strings"
	"testing"
	"unicode"

	"github.com/gorilla/mux"
)

// Report IDs must be numeric.  Submit some bogus requests to
// ensure they fail with a suitable error-message.
func TestNonNumericReport(t *testing.T) {
	router := mux.NewRouter()
	router.HandleFunc("/report/{id}/", ReportHandler).Methods("GET")
	router.HandleFunc("/report/{id}", ReportHandler).Methods("GET")

	// Table driven test
	ids := []string{"/report/1a", "/report/steve", "/report/bob/", "/report/3a.3/"}

	for _, id := range ids {
		req, err := http.NewRequest("GET", id, nil)
		if err != nil {
			t.Fatal(err)
		}

		rr := httptest.NewRecorder()
		router.ServeHTTP(rr, req)

		// Check the status code is what we expect.
		if status := rr.Code; status != http.StatusInternalServerError {
			t.Errorf("Unexpected status-code: %v", status)
		}

		// Check the response body is what we expect.
		expected := "the report ID must be numeric\n"
		if rr.Body.String() != expected {
			t.Errorf("handler returned unexpected body: got '%v' want '%v'",
				rr.Body.String(), expected)
		}
	}
}

// API-state must use known values.  Submit some bogus values to ensure
// a suitable error is returned.
func TestUknownAPIState(t *testing.T) {

	// Wire up the route
	r := mux.NewRouter()
	r.HandleFunc("/api/state/{state}", APIState).Methods("GET")
	r.HandleFunc("/api/state/{state}/", APIState).Methods("GET")

	// Get the test-server
	ts := httptest.NewServer(r)
	defer ts.Close()

	// These are all bogus
	states := []string{"foo", "bart", "liza", "moi kissa", "steve/"}

	for _, state := range states {
		url := ts.URL + "/api/state/" + state

		resp, err := http.Get(url)
		if err != nil {
			t.Fatal(err)
		}

		//
		// Get the body
		//
		defer resp.Body.Close()
		body, err := ioutil.ReadAll(resp.Body)

		if err != nil {
			t.Errorf("Failed to read response-body %v\n", err)
		}

		content := string(body)
		if status := resp.StatusCode; status != http.StatusInternalServerError {
			t.Errorf("Unexpected status-code: %v", status)
		}
		if content != "invalid state supplied\n" {
			t.Fatalf("Unexpected body: '%s'", body)
		}
	}

}

// Test that our report-view returns content that seems reasonable,
// in all three cases:
//
//   - text/html
//   - application/json
//   - application/xml
func TestReportView(t *testing.T) {

	// Create a fake database
	FakeDB()

	// Add some data.
	addFakeReports()

	//
	// We'll make one test for each supported content-type
	//
	type TestCase struct {
		Type     string
		Response string
	}

	//
	// The tests
	//
	tests := []TestCase{
		{"text/html", "Report of execution against www.steve.org.uk in production, at 2017-07-29 23:17:01"},
		{"application/json", "\"State\":\"unchanged\","},
		{"application/xml", "<State>unchanged</State>"}}

	//
	// Run each one.
	//
	for _, test := range tests {

		//
		// Create a router.
		//
		router := mux.NewRouter()
		router.HandleFunc("/report/{id}/", ReportHandler).Methods("GET")
		router.HandleFunc("/report/{id}", ReportHandler).Methods("GET")

		//
		// Get a valid report ID, and use it to build a URL.
		//
		id, _ := validReportID()
		url := fmt.Sprintf("/report/%d", id)

		//
		// Make the request, with the appropriate Accept: header
		//
		req, err := http.NewRequest("GET", url, nil)
		if err != nil {
			t.Fatal(err)
		}
		req.Header.Add("Accept", test.Type)

		//
		// Fake out the request
		//
		rr := httptest.NewRecorder()
		router.ServeHTTP(rr, req)

		//
		// Test the status-code is OK
		//
		if status := rr.Code; status != http.StatusOK {
			t.Errorf("Unexpected status-code: %v", status)
		}

		//
		// Test that the body contained our expected content.
		//
		if !strings.Contains(rr.Body.String(), test.Response) {
			t.Fatalf("Unexpected body: '%s'", rr.Body.String())
		}
	}

	//
	// Cleanup here because otherwise later tests will
	// see an active/valid DB-handle.
	//
	db.Close()
	db = nil
	os.RemoveAll(path)
}

// API state must be known.
func TestKnownAPIState(t *testing.T) {

	// Create a fake database
	FakeDB()

	// Add some data.
	addFakeNodes()

	// Wire up the router.
	r := mux.NewRouter()
	r.HandleFunc("/api/state/{state}", APIState).Methods("GET")
	r.HandleFunc("/api/state/{state}/", APIState).Methods("GET")

	// Get the test-server
	ts := httptest.NewServer(r)
	defer ts.Close()

	//
	// We'll make one test for each known-state
	//
	type TestCase struct {
		State    string
		Response string
	}

	tests := []TestCase{
		{"changed", "[\"foo.example.com\"]"},
		{"unchanged", "[]"},
		{"failed", "[\"bar.example.com\"]"},
		{"orphaned", "[]"}}

	//
	// Run each one.
	//
	for _, test := range tests {

		//
		// Make the request
		//
		url := ts.URL + "/api/state/" + test.State

		resp, err := http.Get(url)
		if err != nil {
			t.Fatal(err)
		}

		//
		// Get the body
		//
		defer resp.Body.Close()
		body, err := ioutil.ReadAll(resp.Body)

		if err != nil {
			t.Errorf("Failed to read response-body %v\n", err)
		}

		content := string(body)

		if status := resp.StatusCode; status != http.StatusOK {
			t.Errorf("Unexpected status-code: %v", status)
		}
		if content != test.Response {
			t.Fatalf("Unexpected body: '%s'", body)
		}
	}

	//
	// Cleanup here because otherwise later tests will
	// see an active/valid DB-handle.
	//
	db.Close()
	db = nil
	os.RemoveAll(path)

}

// API state should accept XML, JSON, and plain-text
func TestAPITypes(t *testing.T) {

	// Create a fake database
	FakeDB()

	// Add some data.
	addFakeNodes()

	// Wire up the router.
	r := mux.NewRouter()
	r.HandleFunc("/api/state/{state}", APIState).Methods("GET")
	r.HandleFunc("/api/state/{state}/", APIState).Methods("GET")

	// Get the test-server
	ts := httptest.NewServer(r)
	defer ts.Close()

	//
	// We'll make one test for each known-state
	//
	type TestCase struct {
		Type     string
		Response string
	}

	tests := []TestCase{
		{"application/json", "[\"foo.example.com\"]"},
		{"application/xml", "<string>foo.example.com</string>"},
		{"text/plain", "foo.example.com\n"},
		{"", "[\"foo.example.com\"]"},
	}

	//
	// Run each one.
	//
	for _, test := range tests {

		//
		// Make the request
		//
		url := ts.URL + "/api/state/changed?accept=" + test.Type

		resp, err := http.Get(url)
		if err != nil {
			t.Fatal(err)
		}

		//
		// Get the body
		//
		defer resp.Body.Close()
		body, err := ioutil.ReadAll(resp.Body)

		if err != nil {
			t.Errorf("Failed to read response-body %v\n", err)
		}

		content := string(body)

		if status := resp.StatusCode; status != http.StatusOK {
			t.Errorf("Unexpected status-code: %v", status)
		}
		if content != test.Response {
			t.Fatalf("Unexpected body for %s: '%s'", test.Type, body)
		}
	}

	//
	// Cleanup here because otherwise later tests will
	// see an active/valid DB-handle.
	//
	db.Close()
	db = nil
	os.RemoveAll(path)

}

// Searching must be done via a POST.
func TestSearchMethod(t *testing.T) {

	req, err := http.NewRequest("GET", "/search", nil)
	if err != nil {
		t.Fatal(err)
	}

	rr := httptest.NewRecorder()
	handler := http.HandlerFunc(SearchHandler)

	handler.ServeHTTP(rr, req)

	// Check the status code is what we expect.
	if status := rr.Code; status != http.StatusInternalServerError {
		t.Errorf("Unexpected status-code: %v", status)
	}

	// Check the response body is what we expect.
	expected := "must be called via HTTP-POST\n"
	if rr.Body.String() != expected {
		t.Errorf("handler returned unexpected body: got '%v' want '%v'",
			rr.Body.String(), expected)
	}

}

// The search handler must have a term-parameter.
func TestSearchEmpty(t *testing.T) {

	req, err := http.NewRequest("POST", "/search", bytes.NewReader(nil))
	if err != nil {
		t.Fatal(err)
	}

	rr := httptest.NewRecorder()
	handler := http.HandlerFunc(SearchHandler)

	// Our handlers satisfy http.Handler, so we can call
	// their ServeHTTP method directly and pass in our
	// Request and ResponseRecorder.
	handler.ServeHTTP(rr, req)

	// Check the status code is what we expect.
	if status := rr.Code; status != http.StatusInternalServerError {
		t.Errorf("Unexpected status-code: %v", status)
	}

	// Check the response body is what we expect.
	expected := "missing search term\n"
	if rr.Body.String() != expected {
		t.Errorf("handler returned unexpected body: got '%v' want '%v'",
			rr.Body.String(), expected)
	}
}

// The search handler should run a search
func TestSearch(t *testing.T) {

	// Create a fake database
	FakeDB()

	// Add some data.
	addFakeNodes()

	// The term we're going to search for: "example"
	data := url.Values{}
	data.Set("term", "example")

	req, err := http.NewRequest("POST", "/search", bytes.NewBufferString(data.Encode()))
	if err != nil {
		t.Fatal(err)
	}

	//
	// Ensure we're POSTing a FORM
	//
	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
	req.Header.Add("Content-Length", strconv.Itoa(len(data.Encode())))

	rr := httptest.NewRecorder()
	handler := http.HandlerFunc(SearchHandler)

	// Our handlers satisfy http.Handler, so we can call
	// their ServeHTTP method directly and pass in our
	// Request and ResponseRecorder.
	handler.ServeHTTP(rr, req)

	// Check the status code is what we expect.
	if status := rr.Code; status != http.StatusOK {
		t.Errorf("Unexpected status-code: %v", status)
	}

	// Check the response body is what we expect.
	expected := "/node/bar.example.com"
	if !strings.Contains(rr.Body.String(), expected) {
		t.Fatalf("Unexpected body: '%s'", rr.Body.String())
	}

	//
	// Cleanup here because otherwise later tests will
	// see an active/valid DB-handle.
	//
	db.Close()
	db = nil
	os.RemoveAll(path)
}

// Submitting reports must be done via a POST.
func TestUploadReportMethod(t *testing.T) {

	req, err := http.NewRequest("GET", "/upload", nil)
	if err != nil {
		t.Fatal(err)
	}

	rr := httptest.NewRecorder()
	handler := http.HandlerFunc(ReportSubmissionHandler)

	handler.ServeHTTP(rr, req)

	// Check the status code is what we expect.
	if status := rr.Code; status != http.StatusInternalServerError {
		t.Errorf("Unexpected status-code: %v", status)
	}

	// Check the response body is what we expect.
	expected := "must be called via HTTP-POST\n"
	if rr.Body.String() != expected {
		t.Errorf("handler returned unexpected body: got '%v' want '%v'",
			rr.Body.String(), expected)
	}

}

// Submitting a pre-cooked report should succeed.
func TestUploadReport(t *testing.T) {

	// Create a fake database
	FakeDB()

	// Ensure we point our report-upload directory at
	// our temporary location.
	ReportPrefix = path

	//
	// Read the YAML file.
	//
	tmpl, err := getResource("data/valid.yaml")
	if err != nil {
		t.Fatal(err)
	}

	//
	// Call this two times.
	//
	count := 0

	//
	// The two expected results
	//
	expected := []string{"{\"host\":\"www.steve.org.uk\"}", "Ignoring duplicate submission"}

	for count < 2 {
		req, err := http.NewRequest("POST", "/upload", bytes.NewReader(tmpl))
		if err != nil {
			t.Fatal(err)
		}

		rr := httptest.NewRecorder()
		handler := http.HandlerFunc(ReportSubmissionHandler)

		// Our handlers satisfy http.Handler, so we can call their ServeHTTP method
		// directly and pass in our Request and ResponseRecorder.
		handler.ServeHTTP(rr, req)

		// Check the status code is what we expect.
		if status := rr.Code; status != http.StatusOK {
			t.Errorf("Unexpected status-code: %v", status)
		}

		if rr.Body.String() != expected[count] {
			t.Errorf("Body was '%v' we wanted '%v'",
				rr.Body.String(), expected[count])
		}

		count++
	}

	//
	// Cleanup here because otherwise later tests will
	// see an active/valid DB-handle.
	//
	db.Close()
	db = nil
	os.RemoveAll(path)
}

// Submitting a pre-cooked report which is bogus should fail.
func TestUploadBogusReport(t *testing.T) {

	// Create a fake database
	FakeDB()

	// Ensure we point our report-upload directory at
	// our temporary location.
	ReportPrefix = path

	//
	// Read the YAML file.
	//
	tmpl, err := getResource("data/valid.yaml")
	if err != nil {
		t.Fatal(err)
	}

	//
	// Upper-case the YAML
	//
	for i := range tmpl {
		tmpl[i] = byte(unicode.ToUpper(rune(tmpl[i])))
	}

	req, err := http.NewRequest("POST", "/upload", bytes.NewReader(tmpl))
	if err != nil {
		t.Fatal(err)
	}

	rr := httptest.NewRecorder()
	handler := http.HandlerFunc(ReportSubmissionHandler)

	// Our handlers satisfy http.Handler, so we can call their ServeHTTP method
	// directly and pass in our Request and ResponseRecorder.
	handler.ServeHTTP(rr, req)

	// Check the status code is what we expect.
	if status := rr.Code; status != http.StatusInternalServerError {
		t.Errorf("Unexpected status-code: %v", status)
	}

	// Check the response body is what we expect.
	expected := "failed to get 'host' from YAML\n"
	if rr.Body.String() != expected {
		t.Errorf("handler returned unexpected body: got '%v' want '%v'",
			rr.Body.String(), expected)
	}

	//
	// Cleanup here because otherwise later tests will
	// see an active/valid DB-handle.
	//
	db.Close()
	db = nil
	os.RemoveAll(path)
}

// Unknown-nodes are handled.
func TestUnknownNode(t *testing.T) {

	// Create a fake database
	FakeDB()

	// Add some data.
	addFakeNodes()

	// Wire up the router.
	r := mux.NewRouter()
	r.HandleFunc("/node/{fqdn}", NodeHandler).Methods("GET")

	// Get the test-server
	ts := httptest.NewServer(r)
	defer ts.Close()

	//
	// Test a bogus name.
	//
	url := ts.URL + "/node/missing.invalid.tld"

	resp, err := http.Get(url)
	if err != nil {
		t.Fatal(err)
	}

	//
	// Get the body
	//
	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)

	if err != nil {
		t.Errorf("Failed to read response-body %v\n", err)
	}

	content := string(body)

	if status := resp.StatusCode; status != http.StatusNotFound {
		t.Errorf("Unexpected status-code: %v", status)
	}
	if content != "Failed to find reports for missing.invalid.tld\n" {
		t.Fatalf("Unexpected body: '%s'", body)
	}

	//
	// Cleanup here because otherwise later tests will
	// see an active/valid DB-handle.
	//
	db.Close()
	db = nil
	os.RemoveAll(path)

}

// Test that our node-view returns content that seems reasonable,
// in all three cases:
//
//   - text/html
//   - application/json
//   - application/xml
func TestKnownNode(t *testing.T) {

	// Create a fake database
	FakeDB()

	// Add some data.
	addFakeNodes()

	//
	// We'll make one test for each supported content-type
	//
	type TestCase struct {
		Type     string
		Response string
	}

	//
	// The tests
	//
	tests := []TestCase{
		{"text/html", "3.134"},
		{"application/json", "\"State\":\"unchanged\","},
		{"application/xml", "<PuppetReportSummary>"}}

	//
	// Run each one.
	//
	for _, test := range tests {

		//
		// Create a router.
		//
		router := mux.NewRouter()
		router.HandleFunc("/node/{fqdn}/", NodeHandler).Methods("GET")
		router.HandleFunc("/node/{fqdn}", NodeHandler).Methods("GET")

		//
		// Make the request, with the appropriate Accept: header
		//
		req, err := http.NewRequest("GET", "/node/foo.example.com", nil)
		if err != nil {
			t.Fatal(err)
		}
		req.Header.Add("Accept", test.Type)

		//
		// Fake out the request
		//
		rr := httptest.NewRecorder()
		router.ServeHTTP(rr, req)

		//
		// Test the status-code is OK
		//
		if status := rr.Code; status != http.StatusOK {
			t.Errorf("Unexpected status-code: %v", status)
		}

		//
		// Test that the body contained our expected content.
		//
		if !strings.Contains(rr.Body.String(), test.Response) {
			t.Fatalf("Unexpected body: '%s'", rr.Body.String())
		}
	}

	//
	// Cleanup here because otherwise later tests will
	// see an active/valid DB-handle.
	//
	db.Close()
	db = nil
	os.RemoveAll(path)

}

// Test that our index-view returns content that seems reasonable,
// in all three cases:
//
//   - text/html
//   - application/json
//   - application/xml
func TestIndexView(t *testing.T) {

	// Create a fake database
	FakeDB()

	// Add some data.
	addFakeNodes()

	//
	// We'll make one test for each supported content-type
	//
	type TestCase struct {
		Type     string
		Response string
	}

	//
	// The tests
	//
	tests := []TestCase{
		{"text/html", "foo.example.com"},
		{"application/json", "\"State\":\"failed\","},
		{"application/xml", "<PuppetRuns>"}}

	//
	// Run each one.
	//
	for _, test := range tests {

		//
		// Make the request, with the appropriate Accept: header
		//
		req, err := http.NewRequest("GET", "/", nil)
		if err != nil {
			t.Fatal(err)
		}
		req.Header.Add("Accept", test.Type)

		//
		// Fake it out
		//
		rr := httptest.NewRecorder()
		handler := http.HandlerFunc(IndexHandler)
		handler.ServeHTTP(rr, req)

		//
		// Test the status-code is OK
		//
		if status := rr.Code; status != http.StatusOK {
			t.Errorf("Unexpected status-code: %v", status)
		}

		//
		// Test that the body contained our expected content.
		//
		if !strings.Contains(rr.Body.String(), test.Response) {
			t.Fatalf("Unexpected body: '%s'", rr.Body.String())
		}
	}

	//
	// Cleanup here because otherwise later tests will
	// see an active/valid DB-handle.
	//
	db.Close()
	db = nil
	os.RemoveAll(path)

}

// Test that static-resources work:
//
//  1. They produce content
//  2. They have sensible MIME-types
func TestStaticResources(t *testing.T) {

	// Test-cases
	type TestCase struct {
		path string
		mime string
	}

	tests := []TestCase{
		TestCase{path: "/favicon.ico", mime: "image/vnd.microsoft.icon"},
		TestCase{path: "/robots.txt", mime: "text/plain"},
		TestCase{path: "/js/jquery.tablesorter.min.js", mime: "text/javascript"},
		TestCase{path: "/css/bootstrap.min.css", mime: "text/css"},
		TestCase{path: "/fonts/glyphicons-halflings-regular.woff2", mime: "font/woff2"},
	}

	// Wire up the router.
	r := mux.NewRouter()
	r.NotFoundHandler = http.HandlerFunc(StaticHandler)

	for _, test := range tests {

		// Get the test-server
		ts := httptest.NewServer(r)
		defer ts.Close()

		// Make a request
		url := ts.URL + test.path

		resp, err := http.Get(url)
		if err != nil {
			t.Fatal(err)
		}

		defer resp.Body.Close()
		body, err := ioutil.ReadAll(resp.Body)

		if err != nil {
			t.Errorf("Failed to read response-body %v\n", err)
		}

		if len(body) < 10 {
			t.Errorf("too-short body reading %s: %d\n", test.path, len(body))
		}

		//
		// Test that the content-type was what we expect.
		//
		headers := resp.Header
		ctype := headers["Content-Type"][0]

		// Content-type might have a character-set, so we can
		// expect either of these:
		//
		//    Content-Type: text/plain
		//    Content-Type: text/css; charset=utf-8
		//
		// Strip anything after the ";" to avoid caring about this
		if strings.Contains(ctype, ";") {
			pieces := strings.Split(ctype, ";")
			ctype = pieces[0]
		}

		if ctype != test.mime {
			t.Errorf("expected %s for %s - got %s", test.mime, test.path, ctype)
		}
	}
}

// Test that our radiator-view returns content that seems reasonable,
// in all three cases:
//
//   - text/html
//   - application/json
//   - application/xml
func TestRadiatorView(t *testing.T) {

	// Create a fake database
	FakeDB()

	// Add some data.
	addFakeNodes()

	//
	// We'll make one test for each supported content-type
	//
	type TestCase struct {
		Type     string
		Response string
	}

	//
	// The tests
	//
	tests := []TestCase{
		{"text/html", "<p class=\"percent\" style=\"width: 50%\">"},
		{"application/json", "\"State\":\"failed\","},
		{"application/xml", "<PuppetState>"}}

	//
	// Run each one.
	//
	for _, test := range tests {

		//
		// Make the request, with the appropriate Accept: header
		//
		req, err := http.NewRequest("GET", "/radiator/", nil)
		if err != nil {
			t.Fatal(err)
		}
		req.Header.Add("Accept", test.Type)

		//
		// Fake it out
		//
		rr := httptest.NewRecorder()
		handler := http.HandlerFunc(RadiatorView)
		handler.ServeHTTP(rr, req)

		//
		// Test the status-code is OK
		//
		if status := rr.Code; status != http.StatusOK {
			t.Errorf("Unexpected status-code: %v", status)
		}

		//
		// Test that the body contained our expected content.
		//
		if !strings.Contains(rr.Body.String(), test.Response) {
			t.Fatalf("Unexpected body: '%s'", rr.Body.String())
		}
	}

	//
	// Cleanup here because otherwise later tests will
	// see an active/valid DB-handle.
	//
	db.Close()
	db = nil
	os.RemoveAll(path)

}