gpaste/http_test.go

package gpaste_test

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"net/http/httptest"
	"testing"

	"git.t-juice.club/torjus/gpaste"
	"git.t-juice.club/torjus/gpaste/users"
)

func TestHandlers(t *testing.T) {
	cfg := &gpaste.ServerConfig{
		SigningSecret: "abc123",
		Store: &gpaste.ServerStoreConfig{
			Type: "memory",
		},
		URL: "http://localhost:8080",
	}
	hs := gpaste.NewHTTPServer(cfg)

	t.Run("HandlerIndex", func(t *testing.T) {
		rr := httptest.NewRecorder()
		req := httptest.NewRequest(http.MethodGet, "/", nil)

		hs.Handler.ServeHTTP(rr, req)

		if status := rr.Code; status != http.StatusOK {
			t.Errorf("Returned unexpected status")
		}

		expectedBody := "index"
		if body := rr.Body.String(); body != expectedBody {
			t.Errorf("Body does not match expected. Got %s want %s", body, expectedBody)
		}
	})
	t.Run("HandlerAPIFilePost", func(t *testing.T) {
		rr := httptest.NewRecorder()
		buf := &bytes.Buffer{}
		mw := multipart.NewWriter(buf)
		fw, err := mw.CreateFormFile("test", "test.txt")
		if err != nil {
			t.Fatalf("Unable to create form file: %s", err)
		}
		expectedData := "Test OMEGALUL PLS."
		if _, err := io.WriteString(fw, expectedData); err != nil {
			t.Fatalf("Unable to write body to buffer: %s", err)
		}
		mw.Close()

		req := httptest.NewRequest(http.MethodPost, "/api/file", buf)
		req.Header.Add("Content-Type", mw.FormDataContentType())

		hs.Handler.ServeHTTP(rr, req)

		if status := rr.Code; status != http.StatusAccepted {
			t.Errorf("Returned unexpected status. Got %d want %d", status, http.StatusAccepted)
		}

		var expectedResp []struct {
			Message string `json:"message"`
			ID      string `json:"id"`
			URL     string `json:"url"`
		}

		decoder := json.NewDecoder(rr.Result().Body)
		if err := decoder.Decode(&expectedResp); err != nil {
			t.Fatalf("error decoding response: %s", err)
		}

		if l := len(expectedResp); l != 1 {
			t.Errorf("Response has wrong length. Got %d want %d", l, 1)
		}

		uploadID := expectedResp[0].ID
		if uploadID == "" {
			t.Errorf("Response has empty id")
		}

		t.Run("HandlerAPIFileGet", func(t *testing.T) {
			rr := httptest.NewRecorder()
			url := fmt.Sprintf("/api/file/%s", uploadID)
			req := httptest.NewRequest(http.MethodGet, url, nil)

			hs.Handler.ServeHTTP(rr, req)

			if status := rr.Code; status != http.StatusOK {
				t.Errorf("Returned unexpected status. Got %d want %d", status, http.StatusAccepted)
				t.Logf(url)
			}
			if body := rr.Body.String(); body != expectedData {
				t.Errorf("Returned body does not match expected.")
			}
		})
	})
	t.Run("HandlerAPILogin", func(t *testing.T) {
		// TODO: Add test
		username := "admin"
		password := "admin"
		user := &users.User{Username: username}
		if err := user.SetPassword(password); err != nil {
			t.Fatalf("Error setting user password: %s", err)
		}
		if err := hs.Users.Store(user); err != nil {
			t.Fatalf("Error storing user: %s", err)
		}

		requestData := struct {
			Username string `json:"username"`
			Password string `json:"password"`
		}{
			Username: username,
			Password: password,
		}

		body := new(bytes.Buffer)
		encoder := json.NewEncoder(body)
		if err := encoder.Encode(&requestData); err != nil {
			t.Fatalf("Error encoding request body: %s", err)
		}

		rr := httptest.NewRecorder()
		req := httptest.NewRequest(http.MethodPost, "/api/login", body)

		hs.Handler.ServeHTTP(rr, req)

		responseData := struct {
			Token string `json:"token"`
		}{}

		decoder := json.NewDecoder(rr.Body)
		if err := decoder.Decode(&responseData); err != nil {
			t.Fatalf("Error decoding response: %s", err)
		}

		if _, err := hs.Auth.ValidateToken(responseData.Token); err != nil {
			t.Fatalf("Unable to validate received token: %s", err)
		}
	})
}