144 lines
3.6 KiB
Go
144 lines
3.6 KiB
Go
package gpaste_test
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"mime/multipart"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
|
|
"git.t-juice.club/torjus/gpaste"
|
|
)
|
|
|
|
func TestHandlers(t *testing.T) {
|
|
cfg := &gpaste.ServerConfig{
|
|
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 := &gpaste.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)
|
|
}
|
|
})
|
|
}
|