added tests for new canceled status

Author: Matin Gohar Far

server/src/api/votings_test.go

@@ -114,6 +114,43 @@ func (suite *VotingTestSuite) TestCloseVoting() {
 
 }
 
+func (suite *VotingTestSuite) TestCancelVoting() {
+
+	testParameterBundles := *TestParameterBundles{}.
+		Append("all ok", http.StatusOK, nil, false, false, nil).
+		Append("unexpected error", http.StatusInternalServerError, errors.New("oops"), false, false, nil)
+
+	for _, tt := range testParameterBundles {
+		suite.Run(tt.name, func() {
+			s := new(Server)
+			//s.basePath = "/"
+			votingMock := votings.NewMockVotingService(suite.T())
+			notesMock := notes.NewMockNotesService(suite.T())
+
+			boardId, _ := uuid.NewRandom()
+			votingId, _ := uuid.NewRandom()
+			s.votings = votingMock
+			s.notes = notesMock
+
+			req := technical_helper.NewTestRequestBuilder("PUT", "/", strings.NewReader(`{"status": "ABORTED"}`))
+			req.Req = logger.InitTestLoggerRequest(req.Request())
+			req.AddToContext(identifiers.BoardIdentifier, boardId).
+				AddToContext(identifiers.VotingIdentifier, votingId)
+
+			notesMock.EXPECT().GetAll(mock.Anything, boardId).Return([]*notes.Note{}, nil)
+
+			votingMock.EXPECT().Cancel(mock.Anything, votingId, boardId, []votings.Note(nil)).
+				Return(&votings.Voting{Status: votings.Canceled}, tt.err)
+
+			rr := httptest.NewRecorder()
+			s.updateVoting(rr, req.Request())
+			suite.Equal(tt.expectedCode, rr.Result().StatusCode)
+			votingMock.AssertExpectations(suite.T())
+			votingMock.AssertNumberOfCalls(suite.T(), "Cancel", 1)
+		})
+	}
+}
+
 func (suite *VotingTestSuite) TestGetVoting() {
 	s := new(Server)
 	votingMock := votings.NewMockVotingService(suite.T())

server/src/votings/database_test.go

@@ -283,6 +283,46 @@ func (suite *DatabaseVotingTestSuite) Test_Database_GetVotes() {
 	assert.Len(t, dbVotes, 18)
 }
 
+func (suite *DatabaseVotingTestSuite) Test_Database_Cancel() {
+	t := suite.T()
+	database := NewVotingDatabase(suite.db)
+
+	votingId := suite.baseData.Votings["Update"].ID
+	boardId := suite.baseData.Boards["Update"].ID
+
+	dbVoting, err := database.Close(context.Background(),
+		DatabaseVotingUpdate{
+			ID:     votingId,
+			Board:  boardId,
+			Status: Canceled,
+		},
+	)
+
+	assert.Nil(t, err)
+	assert.Equal(t, votingId, dbVoting.ID)
+	assert.Equal(t, boardId, dbVoting.Board)
+	assert.Equal(t, Canceled, dbVoting.Status)
+	assert.Equal(t, 7, dbVoting.VoteLimit)
+	assert.True(t, dbVoting.AllowMultipleVotes)
+	assert.False(t, dbVoting.ShowVotesOfOthers)
+	assert.False(t, dbVoting.IsAnonymous)
+	assert.NotNil(t, dbVoting.CreatedAt)
+
+	// Verify notes are NOT re-ranked after cancel
+	noteDatabase := notes.NewNotesDatabase(suite.db)
+	dbNotes, notesErr := noteDatabase.GetAll(context.Background(), boardId)
+	assert.Nil(t, notesErr)
+
+	noteRankMap := make(map[uuid.UUID]int)
+	for _, n := range dbNotes {
+		noteRankMap[n.ID] = n.Rank
+	}
+
+	assert.Equal(t, 0, noteRankMap[suite.baseData.Notes["Update2"].ID])
+	assert.Equal(t, 0, noteRankMap[suite.baseData.Notes["Update1"].ID])
+	assert.Equal(t, 0, noteRankMap[suite.baseData.Notes["Update3"].ID])
+}
+
 func (suite *DatabaseVotingTestSuite) seedVotes(db *bun.DB) {
 	log.Println("Seeding voting database test votes")
 

server/src/votings/service_integration_test.go

@@ -226,6 +226,35 @@ func (suite *VotingServiceIntegrationTestSuite) Test_CloseVoting() {
 	assert.Equal(t, 6, votingData.Voting.VotingResults.Total)
 }
 
+func (suite *VotingServiceIntegrationTestSuite) Test_CancelVoting() {
+	t := suite.T()
+	ctx := context.Background()
+
+	votingId := suite.baseData.Votings["Update"].ID
+	boardId := suite.baseData.Boards["Update"].ID
+
+	events := suite.broker.GetBoardChannel(ctx, boardId)
+
+	affectedNotes := []Note{
+		{ID: suite.baseData.Notes["Update1"].ID, Author: suite.baseData.Notes["Update1"].AuthorID, Text: suite.baseData.Notes["Update1"].Text, Position: NotePosition{Column: suite.baseData.Notes["Update1"].ColumnID}},
+		{ID: suite.baseData.Notes["Update2"].ID, Author: suite.baseData.Notes["Update2"].AuthorID, Text: suite.baseData.Notes["Update2"].Text, Position: NotePosition{Column: suite.baseData.Notes["Update2"].ColumnID}},
+		{ID: suite.baseData.Notes["Update3"].ID, Author: suite.baseData.Notes["Update3"].AuthorID, Text: suite.baseData.Notes["Update3"].Text, Position: NotePosition{Column: suite.baseData.Notes["Update3"].ColumnID}},
+	}
+	voting, err := suite.votingService.Cancel(ctx, votingId, boardId, affectedNotes)
+
+	require.NoError(t, err)
+	assert.Equal(t, votingId, voting.ID)
+	assert.Equal(t, Canceled, voting.Status)
+	assert.Nil(t, voting.VotingResults)
+
+	msg := <-events
+	assert.Equal(t, realtime.BoardEventVotingUpdated, msg.Type)
+	votingData, err := technical_helper.Unmarshal[UpdateVoting](msg.Data)
+	require.NoError(t, err)
+	assert.Equal(t, Canceled, votingData.Voting.Status)
+	assert.Nil(t, votingData.Voting.VotingResults)
+}
+
 func (suite *VotingServiceIntegrationTestSuite) Test_CloseVoting_Sorted_Cards() {
 	t := suite.T()
 	ctx := context.Background()

server/src/votings/service_test.go

@@ -281,6 +281,72 @@ func TestCloseVoting(t *testing.T) {
 	assert.Equal(t, Closed, voting.Status)
 }
 
+func TestCancelVoting(t *testing.T) {
+	boardId := uuid.New()
+	votingID := uuid.New()
+
+	mockDb := NewMockVotingDatabase(t)
+	mockDb.EXPECT().Close(mock.Anything, DatabaseVotingUpdate{ID: votingID, Board: boardId, Status: Canceled}).
+		Return(DatabaseVoting{ID: votingID, Board: boardId, Status: Canceled}, nil)
+
+	mockBroker := realtime.NewMockClient(t)
+	mockBroker.EXPECT().Publish(mock.Anything, mock.AnythingOfType("string"), mock.Anything).Return(nil)
+	broker := new(realtime.Broker)
+	broker.Con = mockBroker
+
+	service := NewVotingService(mockDb, broker)
+	voting, err := service.Cancel(context.Background(), votingID, boardId, nil)
+
+	assert.NoError(t, err)
+	assert.NotNil(t, voting)
+	assert.Equal(t, Canceled, voting.Status)
+}
+
+func TestCancelVoting_NotFound(t *testing.T) {
+	boardId := uuid.New()
+	votingID := uuid.New()
+
+	mockDb := NewMockVotingDatabase(t)
+	mockDb.EXPECT().Close(mock.Anything, DatabaseVotingUpdate{ID: votingID, Board: boardId, Status: Canceled}).
+		Return(DatabaseVoting{}, sql.ErrNoRows)
+
+	mockBroker := realtime.NewMockClient(t)
+	broker := new(realtime.Broker)
+	broker.Con = mockBroker
+
+	service := NewVotingService(mockDb, broker)
+	voting, err := service.Cancel(context.Background(), votingID, boardId, nil)
+
+	assert.Nil(t, voting)
+	assert.NotNil(t, err)
+
+	var votingErr VotingError
+	assert.ErrorAs(t, err, &votingErr)
+
+	assert.Equal(t, NotFound, votingErr.Category)
+}
+
+func TestCancelVoting_Failed(t *testing.T) {
+	boardId := uuid.New()
+	votingID := uuid.New()
+	dbError := errors.New("failed to cancel")
+
+	mockDb := NewMockVotingDatabase(t)
+	mockDb.EXPECT().Close(mock.Anything, DatabaseVotingUpdate{ID: votingID, Board: boardId, Status: Canceled}).
+		Return(DatabaseVoting{}, dbError)
+
+	mockBroker := realtime.NewMockClient(t)
+	broker := new(realtime.Broker)
+	broker.Con = mockBroker
+
+	service := NewVotingService(mockDb, broker)
+	voting, err := service.Cancel(context.Background(), votingID, boardId, nil)
+
+	assert.Nil(t, voting)
+	assert.NotNil(t, err)
+	assert.ErrorIs(t, err, dbError)
+}
+
 func TestCloseVoting_NotFound(t *testing.T) {
 	boardId := uuid.New()
 	votingID := uuid.New()

server/src/votings/voting_status_test.go

@@ -8,7 +8,7 @@ import (
 )
 
 func TestVotingStatusEnum(t *testing.T) {
-	values := []VotingStatus{Open, Closed}
+	values := []VotingStatus{Open, Closed, Canceled}
 	for _, value := range values {
 		var votingStatus VotingStatus
 		err := votingStatus.UnmarshalJSON(fmt.Appendf(nil, "\"%s\"", value))