qv/cmd/web/handlers_test.go

package main

import (
	"bytes"
	"code.dlmw.ch/dlmw/qv/internal"
	"encoding/json"
	"fmt"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/mock"
	"net/http"
	"testing"
	"time"
)

func TestCreateElection(t *testing.T) {
	app := newTestApplication(t)
	server := newTestServer(t, app.routes())
	defer server.Close()

	mockElections := app.elections.(*mockElectionModel)
	mockElections.
		On("Insert", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
		Return(1, nil)

	path := "/election"

	tests := []struct {
		name         string
		urlPath      string
		body         any
		expectedCode int
	}{
		{
			name:    "Valid request (small name, other language)",
			urlPath: path,
			body: api.CreateElectionRequest{
				Choices:        []string{"宮本武蔵", "伊東一刀斎"},
				ExpiresAt:      time.Now().Add(24 * time.Hour),
				AreVotersKnown: false,
				MaxVoters:      0,
				Name:           "強",
				Tokens:         100,
			},
			expectedCode: http.StatusOK,
		},
		{
			name:    "Valid request (voters unknown with unlimited voters)",
			urlPath: path,
			body: api.CreateElectionRequest{
				Choices:        []string{"Gandhi", "Buddha"},
				ExpiresAt:      time.Now().Add(24 * time.Hour),
				AreVotersKnown: false,
				MaxVoters:      0,
				Name:           "Guy of the year",
				Tokens:         100,
			},
			expectedCode: http.StatusOK,
		},
		{
			name:    "Valid request (with 3 choices)",
			urlPath: path,
			body: api.CreateElectionRequest{
				Choices:        []string{"Gandhi", "Buddha", "You"},
				ExpiresAt:      time.Now().Add(24 * time.Hour),
				AreVotersKnown: false,
				MaxVoters:      0,
				Name:           "Guy of the year",
				Tokens:         100,
			},
			expectedCode: http.StatusOK,
		},
		{
			name:    "Valid request (voters unknown with max voters)",
			urlPath: path,
			body: api.CreateElectionRequest{
				Choices:        []string{"Gandhi", "Buddha"},
				ExpiresAt:      time.Now().Add(24 * time.Hour),
				AreVotersKnown: false,
				MaxVoters:      10,
				Name:           "Guy of the year",
				Tokens:         100,
			},
			expectedCode: http.StatusOK,
		},
		{
			name:    "Valid request (voters known with max voters)",
			urlPath: path,
			body: api.CreateElectionRequest{
				Choices:        []string{"Gandhi", "Buddha"},
				ExpiresAt:      time.Now().Add(24 * time.Hour),
				AreVotersKnown: false,
				MaxVoters:      10,
				Name:           "Guy of the year",
				Tokens:         100,
			},
			expectedCode: http.StatusOK,
		},
		{
			name:    "Invalid request (not enough choices)",
			urlPath: path,
			body: api.CreateElectionRequest{
				Choices:        []string{"Gandhi"},
				ExpiresAt:      time.Unix(0, 0),
				AreVotersKnown: false,
				MaxVoters:      0,
				Name:           "Guy of the year",
				Tokens:         100,
			},
			expectedCode: http.StatusUnprocessableEntity,
		},
		{
			name:    "Invalid request (expiresAt is not in the future)",
			urlPath: path,
			body: api.CreateElectionRequest{
				Choices:        []string{"Gandhi", "Buddha"},
				ExpiresAt:      time.Unix(0, 0),
				AreVotersKnown: false,
				MaxVoters:      0,
				Name:           "Guy of the year",
				Tokens:         100,
			},
			expectedCode: http.StatusUnprocessableEntity,
		},
		{
			name:    "Invalid request (max voters must be greater than 0 for known elections)",
			urlPath: path,
			body: api.CreateElectionRequest{
				Choices:        []string{"Gandhi", "Buddha"},
				ExpiresAt:      time.Unix(0, 0),
				AreVotersKnown: true,
				MaxVoters:      0,
				Name:           "Guy of the year",
				Tokens:         100,
			},
			expectedCode: http.StatusUnprocessableEntity,
		},
		{
			name:    "Invalid request (blank name)",
			urlPath: path,
			body: api.CreateElectionRequest{
				Choices:        []string{"Gandhi", "Buddha"},
				ExpiresAt:      time.Unix(0, 0),
				AreVotersKnown: true,
				MaxVoters:      0,
				Name:           "",
				Tokens:         100,
			},
			expectedCode: http.StatusUnprocessableEntity,
		},
		{
			name:    "Invalid request (choices are not unique)",
			urlPath: path,
			body: api.CreateElectionRequest{
				Choices:        []string{"Gandhi", "Gandhi"},
				ExpiresAt:      time.Now().Add(24 * time.Hour),
				AreVotersKnown: false,
				MaxVoters:      0,
				Name:           "Guy of the year",
				Tokens:         100,
			},
			expectedCode: http.StatusUnprocessableEntity,
		},
		{
			name:    "Invalid request (choices contain blank entries)",
			urlPath: path,
			body: api.CreateElectionRequest{
				Choices:        []string{"Gandhi", "Buddha", ""},
				ExpiresAt:      time.Now().Add(24 * time.Hour),
				AreVotersKnown: false,
				MaxVoters:      0,
				Name:           "Guy of the year",
				Tokens:         100,
			},
			expectedCode: http.StatusUnprocessableEntity,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			requestBody, err := json.Marshal(tt.body)
			if err != nil {
				t.Fatal(err)
			}

			code, _, _ := server.post(t, tt.urlPath, bytes.NewReader(requestBody))
			assert.Equal(t, tt.expectedCode, code)
		})
	}
}

func TestCreateElection_ServerError(t *testing.T) {
	app := newTestApplication(t)
	server := newTestServer(t, app.routes())
	defer server.Close()

	mockElections := app.elections.(*mockElectionModel)
	mockElections.
		On("Insert", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
		Return(0, fmt.Errorf(""))

	path := "/election"
	requestBody := api.CreateElectionRequest{
		Choices:        []string{"宮本武蔵", "伊東一刀斎"},
		ExpiresAt:      time.Now().Add(24 * time.Hour),
		AreVotersKnown: false,
		MaxVoters:      0,
		Name:           "強",
		Tokens:         100,
	}
	requestBodyJson, err := json.Marshal(requestBody)
	if err != nil {
		t.Fatal(err)
	}

	code, _, _ := server.post(t, path, bytes.NewReader(requestBodyJson))

	assert.Equal(t, 500, code)
}