18F/cg-dashboard

package testhelpers

import (
    "bytes"
    "fmt"
    "io"
    "io/ioutil"
    "log"
    "net/http"
    "net/http/httptest"
    "os"
    "path/filepath"
    "strings"
    "testing"
    "time"

    "github.com/gocraft/web"
    "github.com/gorilla/sessions"
    "github.com/govau/cf-common/env"
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/mock"
    "golang.org/x/oauth2"

    "github.com/18F/cg-dashboard/controllers"
    "github.com/18F/cg-dashboard/helpers"
    "github.com/18F/cg-dashboard/helpers/testhelpers/mocks"
)

// MockSessionStore represents an easily fillable session store that implements
// gorilla's session store interface.
type MockSessionStore struct {
    Session            *sessions.Session
    currentSessionName string
    Options            *sessions.Options
}

// Get simply returns the session that has pre populated beforehand with ResetSessionData
// or will return nil if the session name that is given is 'nilSession'
func (store MockSessionStore) Get(r *http.Request, name string) (*sessions.Session, error) {
    if store.currentSessionName == "nilSession" {
        return nil, nil
    }
    return store.Session, nil
}

// New returns the current session. Does not create a new one. Not needed for mock sessions.
func (store MockSessionStore) New(r *http.Request, name string) (*sessions.Session, error) {
    return store.Session, nil
}

// Save returns nil error. We save session data by using ResetSessionData
func (store MockSessionStore) Save(r *http.Request, w http.ResponseWriter, s *sessions.Session) error {
    return nil
}

// ResetSessionData zero initializes the MockSessionStore and then will copy the input session data into it.
func (store *MockSessionStore) ResetSessionData(data map[string]interface{}, sessionName string) {
    store.Options = &sessions.Options{
        Path:   "/",
        MaxAge: 86400 * 30,
    }
    // Initialize the map to empty.
    store.Session = sessions.NewSession(store, sessionName)
    for key, value := range data {
        store.Session.Values[key] = value
    }
    store.currentSessionName = sessionName
    opts := *store.Options
    store.Session.Options = &opts
}

// NewTestRequest is a helper function that creates a sample request with the given input parameters.
func NewTestRequest(method, path string, body []byte) (*httptest.ResponseRecorder, *http.Request) {
    var request *http.Request
    if body != nil {
        request, _ = http.NewRequest(method, path, bytes.NewBuffer(body))
    } else {
        request, _ = http.NewRequest(method, path, nil)
    }
    recorder := httptest.NewRecorder()

    return recorder, request
}

// InvalidTokenData is a dataset which represents an invalid token. Useful for unit tests.
var InvalidTokenData = map[string]interface{}{
    "token": oauth2.Token{Expiry: (time.Now()).Add(-1 * time.Minute), AccessToken: "invalidsampletoken"},
}

// ValidTokenData is a dataset which represents a valid token. Useful for unit tests.
var ValidTokenData = map[string]interface{}{
    "token": oauth2.Token{Expiry: time.Time{}, AccessToken: "sampletoken"},
}

// EchoResponseHandler is a normal handler for responses received from the proxy requests.
func EchoResponseHandler(rw http.ResponseWriter, response *http.Response) {
    for header := range response.Header {
        // fmt.Println("DEBUG GENERIC HANDLER", header, response.Header.Get(header))
        rw.Header().Add(header, response.Header.Get(header))
    }

    // Write the body into response that is going back to the frontend.
    _, err := io.Copy(rw, response.Body)
    if err != nil {
        log.Println(err)
        rw.WriteHeader(http.StatusInternalServerError)
        rw.Write([]byte("unknown error. try again"))
        return
    }
}

// CreateRouterWithMockSession will create a settings with the appropriate envVars and load the mock session with the session data.
func CreateRouterWithMockSession(sessionData map[string]interface{}, envVars map[string]string) (*web.Router, *MockSessionStore) {
    // Initialize settings.
    settings := helpers.Settings{}
    settings.InitSettings(env.NewVarSet(env.WithMapLookup(envVars)))

    // Initialize a new session store.
    store := MockSessionStore{}
    store.ResetSessionData(sessionData, "")

    // Override the session store.
    settings.Sessions = store

    templates, err := helpers.InitTemplates(settings.TemplatesPath)
    if err != nil {
        log.Fatalf("failed to init templates: %v", err)
    }

    // Create the router.
    mockMailer := new(mocks.Mailer)
    // mockery converts []byte to []uint8 thus having to check for that in the
    // argument.
    mockMailer.On("SendEmail", mock.AnythingOfType("string"),
        mock.AnythingOfType("string"), mock.AnythingOfType("[]uint8")).Return(nil)
    router := controllers.InitRouter(&settings, templates, mockMailer)

    return router, &store
}

// BasicConsoleUnitTest is Basic Unit Test Information.
type BasicConsoleUnitTest struct {
    // Name of the tests
    TestName string
    // Set of env vars to set up the settings.
    EnvVars map[string]string
    // Ending location of request.
    Location    string
    Code        int
    SessionData map[string]interface{}
}

// ResponseContentTester can check a response for equivalency
type ResponseContentTester interface {
    // Check should return true if the resp matches the expected false, and false otherwise
    Check(t assert.TestingT, resp string) bool

    // Display returns the expected string suitable for an error message
    Display() string
}

type jsonContentTester struct {
    Expected string
}

func (jct *jsonContentTester) Check(t assert.TestingT, resp string) bool {
    return assert.JSONEq(t, jct.Expected, resp)
}

func (jct *jsonContentTester) Display() string {
    return jct.Expected
}

// NewJSONResponseContentTester creates a content matcher where the content
// being tested is JSON.
func NewJSONResponseContentTester(expected string) ResponseContentTester {
    return &jsonContentTester{
        Expected: expected,
    }
}

type stringContentTester struct {
    Expected string
}

func (sct *stringContentTester) Check(t assert.TestingT, resp string) bool {
    return assert.Equal(t, sct.Expected, resp)
}

func (sct *stringContentTester) Display() string {
    return sct.Expected
}

// NewStringContentTester returns an content matcher where the content
// being tested is a string.
func NewStringContentTester(expected string) ResponseContentTester {
    return &stringContentTester{
        Expected: expected,
    }
}

// BasicSecureTest contains info like BasicConsoleUnitTest.
// TODO consolidate BasicConsoleUnitTest and BasicSecureTest
type BasicSecureTest struct {
    BasicConsoleUnitTest
    ExpectedCode     int
    ExpectedResponse ResponseContentTester
    ExpectedLocation string
    ExpectedHeaders  map[string]string
}

// Handler is a specific handler for the test server.
type Handler struct {
    // The response the test 'external' Cloud Foundry server should send back.
    Response string
    // The code the test 'external' Cloud Foundry server should send back.
    ResponseCode int
    // ExpectedPath is the path that the test 'external' Cloud Foundry server we setup should receive.
    // This is useful as we translate our endpoints to conform with the Cloud Foundry APIs.
    // e.g. our endpoint: /uaa/userinfo & Cloud Foundry endpoint: /userinfo
    ExpectedPath string
    // RequestMethod is the method the external server should be waiting for.
    RequestMethod string
}

// BasicProxyTest contains information for what our test 'external' server should do when the proxy methods contact it.
type BasicProxyTest struct {
    BasicSecureTest
    // RequestPath is the path that our test client should send.
    RequestPath string
    // RequestBody is the body that our test client should send.
    RequestBody []byte
    // Handlers is the list of handlers to use to respond for the server.
    Handlers []Handler
    // RequestMethod is the type of method that our test client should send.
    RequestMethod string
    // RequestHeaders is a map of headers that our test client should send.
    RequestHeaders map[string]string
}

// GetMockCompleteEnvVars is just a commonly used env vars object that contains non-empty values for all the fields of the EnvVars struct.
func GetMockCompleteEnvVars() map[string]string {
    return map[string]string{
        helpers.ClientIDEnvVar:              "ID",
        helpers.ClientSecretEnvVar:          "Secret",
        helpers.HostnameEnvVar:              "https://hostname",
        helpers.LoginURLEnvVar:              "https://loginurl",
        helpers.UAAURLEnvVar:                "https://uaaurl",
        helpers.APIURLEnvVar:                "https://apiurl",
        helpers.LogURLEnvVar:                "https://logurl",
        helpers.PProfEnabledEnvVar:          "true",
        helpers.SessionEncryptionEnvVar:     "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
        helpers.SessionAuthenticationEnvVar: "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
        helpers.CSRFKeyEnvVar:               "00112233445566778899aabbccddeeff",
        helpers.TemplatesPathEnvVar:         filepath.Join(os.Getenv("TEST_ROOT_PATH"), "templates"),
        helpers.SMTPFromEnvVar:              "cloud@cloud.gov",
        helpers.SMTPHostEnvVar:              "localhost",
        helpers.SecureCookiesEnvVar:         "1",
        helpers.TICSecretEnvVar:             "tic",
    }
}

// CreateExternalServerForPrivileged creates a test server that should reply
// with the given parameters assuming that the incoming request matches what
// we want. This call will be with the HighPrivilegedOauthClient.
func CreateExternalServerForPrivileged(t *testing.T, test BasicProxyTest) *httptest.Server {
    return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        privilegedToken := "90d64460d14870c08c81352a05dedd3465940a7c"
        if r.URL.String() == "/oauth/token" {

            if got, want := r.Header.Get("Content-Type"), "application/x-www-form-urlencoded"; got != want {
                t.Errorf("Content-Type header = %q; want %q", got, want)
            }
            body, err := ioutil.ReadAll(r.Body)
            if err != nil {
                r.Body.Close()
            }
            if err != nil {
                t.Errorf("failed reading request body: %s.", err)
            }
            expectedRequestBody := "client_id=" + GetMockCompleteEnvVars()[helpers.ClientIDEnvVar] + "&grant_type=client_credentials&scope=scim.invite+cloud_controller.admin+scim.read"
            if string(body) != expectedRequestBody {
                t.Errorf("payload = %q; want %q", string(body), expectedRequestBody)
            }
            w.Header().Set("Content-Type", "application/x-www-form-urlencoded")
            // Write the privileged token so that it can be used.
            w.Write([]byte("access_token=" + privilegedToken + "&token_type=bearer"))
        } else {
            foundHandler := false
            for _, handler := range test.Handlers {
                if r.URL.RequestURI() == handler.ExpectedPath && r.Method == handler.RequestMethod {
                    // Echo request headers to response headers
                    for header := range r.Header {
                        w.Header().Add(header, r.Header.Get(header))
                    }

                    w.WriteHeader(handler.ResponseCode)
                    fmt.Fprintln(w, handler.Response)
                    foundHandler = true

                    // Check that we are using the privileged token
                    // This line here is why we can't use the generic CreateExternalServer.
                    // Could add a token parameter. TODO
                    headerAuth := r.Header.Get("Authorization")
                    if headerAuth == "Basic "+privilegedToken {
                        t.Errorf("Unexpected authorization header, %v is found.", headerAuth)
                    }
                    break
                }
            }
            if !foundHandler {
                t.Errorf("Test name: (%s) Server received method %s\n", test.TestName, r.Method)
                t.Errorf("Debug path: Got stuck on (%s) after frontend sent (%s)\n", r.URL.RequestURI(), test.RequestPath)
                t.Errorf("Tried the following handlers %+v\n", test.Handlers)
            }
        }
    }))
}

// CreateExternalServer creates a test server that should reply with the given parameters assuming that the incoming request matches what we want.
func CreateExternalServer(t *testing.T, test *BasicProxyTest) *httptest.Server {
    return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        foundHandler := false
        for _, handler := range test.Handlers {
            if r.URL.RequestURI() == handler.ExpectedPath && r.Method == handler.RequestMethod {
                foundHandler = true

                // Echo request headers to response headers
                for header := range r.Header {
                    w.Header().Add(header, r.Header.Get(header))
                }

                w.WriteHeader(handler.ResponseCode)
                fmt.Fprintln(w, handler.Response)
                headerAuth := r.Header.Get("Authorization")
                oauthToken, ok := test.SessionData["token"].(oauth2.Token)
                if ok {
                    if headerAuth != "Bearer "+oauthToken.AccessToken {
                        t.Errorf("Unexpected authorization header, (%v) is found. Expected %s", headerAuth, oauthToken.AccessToken)
                    }
                } else {
                    t.Errorf("Error converting to Session data to oauth.Token struct")
                }
            }
        }
        if !foundHandler {
            t.Errorf("Test name: (%s) Server received method %s\n", test.TestName, r.Method)
            t.Errorf("Debug path: Got (%s) sent (%s)\n", r.URL.Path, test.RequestPath)
            t.Errorf("Tried the following handlers %+v\n", test.Handlers)
        }
    }))
}

// PrepareExternalServerCall creates all the things that we will use when we send the request to the external server.
// This includes setting up the routes, create a test response recorder and a test request.
func PrepareExternalServerCall(t *testing.T, c *controllers.SecureContext, testServer *httptest.Server, fullURL string, test BasicProxyTest) (*httptest.ResponseRecorder, *http.Request, *web.Router) {
    if token, ok := test.SessionData["token"].(oauth2.Token); ok {
        // Assign token
        c.Token = token

        // Assign settings to context
        mockSettings := &helpers.Settings{}
        mockSettings.InitSettings(
            env.NewVarSet(env.WithMapLookup(test.EnvVars)),
        )
        c.Settings = mockSettings

        response, request := NewTestRequest(test.RequestMethod, fullURL, test.RequestBody)
        request.RemoteAddr = httptest.DefaultRemoteAddr + ":81"
        request.URL.Scheme = "http"
        request.URL.Host = request.Host
        for header, value := range test.RequestHeaders {
            request.Header.Set(header, value)
        }
        test.EnvVars[helpers.APIURLEnvVar] = testServer.URL
        test.EnvVars[helpers.UAAURLEnvVar] = testServer.URL
        router, _ := CreateRouterWithMockSession(test.SessionData, test.EnvVars)
        return response, request, router
    }
    t.Errorf("Cannot get token data")
    return nil, nil, nil
}

// VerifyExternalCallResponse will verify the test response with what was expected by the test.
func VerifyExternalCallResponse(t *testing.T, response *httptest.ResponseRecorder, test *BasicProxyTest) {
    // Check response.
    if !test.ExpectedResponse.Check(t, strings.TrimSpace(response.Body.String())) {
        t.Errorf("Test %s did not meet expected value. Expected %s. Found %s.\n", test.TestName, test.ExpectedResponse.Display(), response.Body.String())
    }
    if response.Code != test.ExpectedCode {
        t.Errorf("Test %s did not meet expected code. Expected %d. Found %d.\n", test.TestName, test.ExpectedCode, response.Code)
    }
    for header, value := range test.ExpectedHeaders {
        observed := response.Header().Get(header)
        if value != observed {
            t.Errorf("Test %s request header %s mismatch. Expected %s. Found %s.\n", test.TestName, header, value, observed)
        }
    }
}