thanksgiving/tgd-backend
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

TGD-58

Browse source
This commit is contained in:
Kirill Ivlev 2024-11-24 22:45:59 +04:00
parent 5bd0760e2c
commit 13cf1a9c2f
3 changed files with 130 additions and 20 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/Consts/FeatureFlags.consts.ts
View file

@ -2,4 +2,5 @@ export class FeatureFlagsConsts {
static EnableEndgamePoints = 'EnableEndgamePoints';
static DontMarkQuestionsAsCompleted = 'DontMarkQuestionsAsCompleted';
static DisableVoice = 'DisableVoice';
static StartVersusIfPlayersAnsweredInSameTime = 'StartVersusIfPlayersAnsweredInSameTime';
}

130
src/quiz/quiz.service.spec.ts
View file

@ -8,16 +8,19 @@ import {GuestsService} from "../guests/guests.service";
import {GuestsServiceMock} from "../mocks/guests-service.mock";
import {SharedService} from "../shared/shared.service";
import {SharedServiceMock} from "../mocks/shared-service.mock";
import {CommandBus, EventBus} from "@nestjs/cqrs";
import {CommandBus, EventBus, ICommand} from "@nestjs/cqrs";
import {EventbusMock} from "../mocks/eventbus.mock";
import {CommandbusMock} from "../mocks/commandbus.mock";
import {FeatureflagService} from "../featureflag/featureflag.service";
import {FeatureflagService, IFeatureFlagStatus} from "../featureflag/featureflag.service";
import {FeatureflagServiceMock} from "../mocks/featureflag-service.mock";
import {IncreasePlayerWinningRateCommand} from "../game/commands/increase-player-winning-rate.command";
import {IncreasePlayerScoreCommand} from "../guests/command/increase-player-score.command";
import {getRandomInt} from "../helpers/rand-number";
import {CreateNewQueueItemCommand} from "../game/commands/create-new-queue-item.command";
import {GameQueueTypes} from "../schemas/game-queue.schema";
import {BeginVersusCommand} from "../game/commands/begin-versus.command"
import spyOn = jest.spyOn;
import clearAllMocks = jest.clearAllMocks;
jest.mock('../../src/helpers/rand-number');
@ -25,24 +28,26 @@ describe('QuizService', () => {
let service: QuizService;
let cmdBus: CommandBus;
let guestService: GuestsService;
let featureFlagService: FeatureflagService;
beforeEach(async () => {
const module: TestingModule = await Test.createTestingModule({
providers: [
QuizService,
{ provide: getModelToken(Question.name), useValue: Model },
{ provide: getModelToken(QuestionStorage.name), useValue: Model},
{ provide: GuestsService, useValue: GuestsServiceMock },
{ provide: SharedService, useValue: SharedServiceMock },
{ provide: EventBus, useValue: EventbusMock },
{ provide: CommandBus, useValue: CommandbusMock },
{ provide: FeatureflagService, useValue: FeatureflagServiceMock }
{provide: getModelToken(Question.name), useValue: Model},
{provide: getModelToken(QuestionStorage.name), useValue: Model},
{provide: GuestsService, useValue: GuestsServiceMock},
{provide: SharedService, useValue: SharedServiceMock},
{provide: EventBus, useValue: EventbusMock},
{provide: CommandBus, useValue: CommandbusMock},
{provide: FeatureflagService, useValue: FeatureflagServiceMock}
],
}).compile();
service = await module.resolve<QuizService>(QuizService);
cmdBus = await module.resolve<CommandBus>(CommandBus);
guestService = await module.resolve<GuestsService>(GuestsService);
featureFlagService = await module.resolve<FeatureflagService>(FeatureflagService);
});
it('should be defined', () => {
@ -50,6 +55,8 @@ describe('QuizService', () => {
});
describe('calculateScore()', () => {
let cmdBusExecSpy: jest.SpyInstance<Promise<unknown>, [command: ICommand], any>;
let getSpy;
const questionDocumentMock = {
text: 'test question',
answered: false,
@ -70,16 +77,22 @@ describe('QuizService', () => {
user: 3,
time: new Date(),
valid: true,
}, {
user: 4,
time: new Date(),
valid: false,
}],
scoreCalculated: false,
save: jest.fn(),
};
beforeEach(() => {
cmdBusExecSpy = jest.spyOn(cmdBus, 'execute').mockResolvedValue(null);
getSpy = jest.spyOn(service,'get').mockResolvedValue(questionDocumentMock as any);
});
it('should not calculate score if it is already calculated', async () => {
// setup
questionDocumentMock.scoreCalculated = true;
const getSpy = jest.spyOn(service,'get').mockResolvedValue(questionDocumentMock as any);
const cmdBusExecSpy = jest.spyOn(cmdBus, 'execute').mockResolvedValue(null);
// act
await service.calculateScore();
@ -92,8 +105,6 @@ describe('QuizService', () => {
it('should assign points to winner', async () => {
//setup
questionDocumentMock.scoreCalculated = false;
const getSpy = jest.spyOn(service, 'get').mockResolvedValue(questionDocumentMock as any);
const cmdBusExecSpy = jest.spyOn(cmdBus, 'execute');
// act
await service.calculateScore();
@ -110,8 +121,6 @@ describe('QuizService', () => {
// setup
(getRandomInt as jest.Mock).mockReturnValue(65);
questionDocumentMock.scoreCalculated = false;
const getSpy = jest.spyOn(service, 'get').mockResolvedValue(questionDocumentMock as any);
const cmdBusExecSpy = jest.spyOn(cmdBus, 'execute');
const whoShouldGetPenalty = questionDocumentMock.userAnswers.find(x => x.user == 2);
//act
@ -127,8 +136,6 @@ describe('QuizService', () => {
jest.clearAllMocks();
(getRandomInt as jest.Mock).mockReturnValue(10);
questionDocumentMock.scoreCalculated = false;
jest.spyOn(service, 'get').mockResolvedValue(questionDocumentMock as any);
const cmdBusExecSpy = jest.spyOn(cmdBus, 'execute');
const whoShouldGetPenalty = questionDocumentMock.userAnswers.find(x => x.user == 2);
//act
@ -141,16 +148,15 @@ describe('QuizService', () => {
})
it('should set score calculated after calculation', async () => {
// setup
questionDocumentMock.scoreCalculated = false;
const saveSpy = jest.spyOn(questionDocumentMock,'save').mockResolvedValue(true);
jest.spyOn(service, 'get').mockResolvedValue(questionDocumentMock as any);
// act
await service.calculateScore();
//validate
expect(saveSpy).toHaveBeenCalled();
})
});
it('should add show results in queue', async () => {
// setup
@ -165,6 +171,90 @@ describe('QuizService', () => {
// validate
expect(cmdBusExecSpy).toHaveBeenCalledWith(new CreateNewQueueItemCommand(expect.anything(), GameQueueTypes.showresults));
});
it('should start versus if user replied in less than 5 seconds if ff enabled', async () => {
// setup
questionDocumentMock.scoreCalculated = false;
const ffstate: IFeatureFlagStatus = {
name: '',
state: true,
}
spyOn(featureFlagService,'getFeatureFlag').mockResolvedValue(ffstate);
questionDocumentMock.userAnswers = [{
user: 1,
time: new Date(new Date().setSeconds(new Date().getSeconds() - 5)),
valid: true,
},
{
user: 2,
time: new Date(),
valid: true,
}
]
getSpy = jest.spyOn(service,'get').mockResolvedValue(questionDocumentMock as any);
// act
await service.calculateScore();
// validate
expect(cmdBusExecSpy).toHaveBeenCalledWith(new BeginVersusCommand(expect.anything(), expect.anything()));
});
it('should not start versus if FF is off and gap less than 5', async () => {
// setup
jest.clearAllMocks();
questionDocumentMock.scoreCalculated = false;
const ffstate: IFeatureFlagStatus = {
name: '',
state: false,
}
spyOn(featureFlagService,'getFeatureFlag').mockResolvedValue(ffstate);
questionDocumentMock.userAnswers = [{
user: 1,
time: new Date(new Date().setSeconds(new Date().getSeconds() - 3)),
valid: true,
},
{
user: 2,
time: new Date(),
valid: true,
}
]
getSpy = jest.spyOn(service,'get').mockResolvedValue(questionDocumentMock as any);
// act
await service.calculateScore();
// validate
expect(cmdBusExecSpy).not.toHaveBeenCalledWith(new BeginVersusCommand(expect.anything(), expect.anything()));
});
it('should not start versus if gap more than 5 seconds', async () => {
// setup
questionDocumentMock.scoreCalculated = false;
questionDocumentMock.userAnswers = [{
user: 1,
time: new Date(new Date().setSeconds(new Date().getSeconds() - 7)),
valid: true,
},
{
user: 2,
time: new Date(),
valid: true,
}
]
getSpy = jest.spyOn(service,'get').mockResolvedValue(questionDocumentMock as any);
// act
await service.calculateScore();
// validate
expect(cmdBusExecSpy).not.toHaveBeenCalledWith(new BeginVersusCommand(expect.anything(), expect.anything()));
});
it('should not start versus if only one player answered correctly', () => {
})
});
});

19
src/quiz/quiz.service.ts
View file

@ -20,6 +20,7 @@ import {FeatureflagService} from "../featureflag/featureflag.service";
import {FeatureFlagsConsts} from "../Consts/FeatureFlags.consts";
import {QuizEndGameResults} from "./quiz.types";
import {ClientNotificationType} from "../socket/socket.gateway";
import {BeginVersusCommand} from "../game/commands/begin-versus.command";
@Injectable({ scope: Scope.TRANSIENT })
export class QuizService {
@ -120,6 +121,14 @@ export class QuizService {
return Promise.resolve(true);
}
private checkIfWeShouldStartVersus(answers: { valid: boolean; time: number; user: number }[]) {
if(answers.length === 0 && answers.length <= 2) {
return false;
}
const diff = Math.abs(new Date(answers[0].time).getTime() - new Date(answers[1].time).getTime()) / 1000;
return diff <= 5;
}
async calculateScore() {
const question = await this.get();
if(question.scoreCalculated) {
@ -148,6 +157,16 @@ export class QuizService {
totalWinningScore / sortedAnswers.filter((answer) => answer.valid).length));
this.commandBus.execute(new IncreasePlayerScoreCommand(answer.user,1));
});
const ffState = await this.featureFlagService.getFeatureFlag(FeatureFlagsConsts.StartVersusIfPlayersAnsweredInSameTime)
if(ffState.state) {
if(this.checkIfWeShouldStartVersus(sortedAnswers.filter(x => x.valid))) {
await this.commandBus.execute(
new BeginVersusCommand(
sortedAnswers.filter(x => x.valid)[0].user,
sortedAnswers.filter(x => x.valid)[1].user,
));
}
}
await this.commandBus.execute(new IncreasePlayerWinningRateCommand(sortedAnswers[0].user, 15));
this.logger.debug(`Giving 1 point to first`);
await this.commandBus.execute(new IncreasePlayerScoreCommand(winner.user,1));