Beispiel #1
0
        private void TestReportedResult(PracticeDeckViewModel viewModel, PracticeResultKind expectedResult,
                                        ApiConnectorMock mock, long cardId, int fieldId)
        {
            PracticeHistoryEntry entry = mock.Parameters.Pop() as PracticeHistoryEntry;

            Assert.AreEqual(HttpMethod.Post, mock.Methods.Pop());
            Assert.AreEqual(DateTime.Today, entry.PracticeDate);
            Assert.AreEqual(cardId, entry.CardId);
            Assert.AreEqual(fieldId, entry.FieldId);
            Assert.AreEqual(deck.DeckId, entry.DeckId);

            int correct = expectedResult == PracticeResultKind.Easy ? 1 : 0;
            int hard    = expectedResult == PracticeResultKind.Hard ? 1 : 0;
            int wrong   = expectedResult == PracticeResultKind.Wrong ? 1 : 0;

            Assert.AreEqual(correct, entry.CorrectCount);
            Assert.AreEqual(hard, entry.HardCount);
            Assert.AreEqual(wrong, entry.WrongCount);
            Assert.AreEqual(correct, viewModel.PracticeResults[cardId].Correct);
            Assert.AreEqual(hard, viewModel.PracticeResults[cardId].Difficult);
            Assert.AreEqual(wrong, viewModel.PracticeResults[cardId].Wrong);
            Assert.AreEqual(correct, viewModel.PracticeResults[cardId].FieldResults[fieldId].Correct);
            Assert.AreEqual(hard, viewModel.PracticeResults[cardId].FieldResults[fieldId].Difficult);
            Assert.AreEqual(wrong, viewModel.PracticeResults[cardId].FieldResults[fieldId].Wrong);
        }
Beispiel #2
0
        private async Task ResultCommandTestCore(PracticeResultKind expectedResult)
        {
            ApiConnectorMock      mock      = CreateMockForInitialize(true, deck);
            PracticeDeckViewModel viewModel = new PracticeDeckViewModel(navigationManagerMock, mock)
            {
                IsShowingSolution = true
            };
            await viewModel.InitializeAsync();

            mock.Replies.Push(new ApiReply <PracticeHistoryEntry>()
            {
                WasSuccessful = true, Result = new PracticeHistoryEntry()
            });
            long      cardId        = viewModel.Current.CardId;
            int       fieldId       = viewModel.Current.FieldId;
            CardField previousField = viewModel.Current;

            switch (expectedResult)
            {
            case PracticeResultKind.Easy:
                viewModel.EasyResultCommand.ExecuteCommand();
                break;

            case PracticeResultKind.Hard:
                viewModel.DifficultResultCommand.ExecuteCommand();
                break;

            case PracticeResultKind.Wrong:
                viewModel.DoesNotKnowResultCommand.ExecuteCommand();
                break;

            default:
                break;
            }

            TestReportedResult(viewModel, expectedResult, mock, cardId, fieldId);

            Assert.AreEqual(1, viewModel.PracticeResults.Count);
            Assert.AreEqual(1, viewModel.PracticeResults[cardId].FieldResults.Count);
            Assert.IsFalse(viewModel.IsShowingSolution);
            if (expectedResult == PracticeResultKind.Wrong)
            {
                Assert.AreEqual(4, viewModel.PracticeFields.Count);
            }
            else
            {
                Assert.AreEqual(3, viewModel.PracticeFields.Count);
                //Because field is added again when wrong or don't know could be same field again
                Assert.AreNotSame(previousField, viewModel.Current);
            }
            Assert.IsNotNull(viewModel.Current);
            Assert.IsFalse(viewModel.IsSummary);
        }