public async Task CommandsAreInitializedCorrectlyTest()
{
CardTemplate template = new CardTemplate()
{
CardTemplateId = 2
};
ApiConnectorMock mock = CreateMockForInitialize(new List <CardTemplate>());
CardTemplateSearchViewModel viewModel = new CardTemplateSearchViewModel(navigationManagerMock, mock)
{
SelectedEntity = template
};
await viewModel.InitializeAsync();
Assert.IsNotNull(viewModel.NewCommand.CommandText);
Assert.IsNotNull(viewModel.NewCommand.ToolTip);
Assert.AreEqual("/New", viewModel.NewCommand.TargetUri);
Assert.IsTrue(viewModel.NewCommand.IsRelative);
Assert.IsNotNull(viewModel.EditCommand.CommandText);
Assert.IsNotNull(viewModel.EditCommand.ToolTip);
Assert.AreEqual("/2", viewModel.EditCommand.TargetUriFactory.Invoke(template));
Assert.IsTrue(viewModel.EditCommand.IsRelative);
Assert.IsNotNull(viewModel.DeleteCommand.CommandText);
Assert.IsNotNull(viewModel.DeleteCommand.ToolTip);
}
public async Task GetProblemWordsOnInitializeTest()
{
Deck deck = new Deck()
{
Title = "test", DeckId = 1
};
PracticeHistoryEntry entry = new PracticeHistoryEntry()
{
DeckId = deck.DeckId
};
ApiConnectorMock mock = IntializeApiConnectorMock(new List <Deck>(), new List <PracticeHistoryEntry>()
{
entry
}, deck);
HomeViewModel viewModel = new HomeViewModel(navigationManagerMock, mock);
await viewModel.InitializeAsync();
Assert.AreEqual(1, viewModel.ProblemWords.Count);
Assert.AreSame(entry, viewModel.ProblemWords[0]);
Assert.AreEqual(1, viewModel.ProblemWordDecks.Count);
Assert.AreSame(deck, viewModel.ProblemWordDecks[1]);
Assert.AreEqual(1, (long)mock.Parameters.Pop());
Assert.AreEqual(HttpMethod.Get, mock.Methods.Pop());
Dictionary <string, object> parameters = mock.Parameters.Pop() as Dictionary <string, object>;
Assert.IsTrue(parameters.ContainsKey(nameof(HomeViewModel.ProblemWords)));
Assert.AreEqual(HttpMethod.Get, mock.Methods.Pop());
}
public void LoginAsGuestUserCommandTest()
{
User user = new User()
{
Email = "*****@*****.**", Password = "******"
};
ApiConnectorMock mock = new ApiConnectorMock();
mock.Replies.Push(new ApiReply <User>()
{
WasSuccessful = true,
Result = User.GuestUser,
});
LocalStorageServiceMock localStorageServiceMock = new LocalStorageServiceMock();
CustomAuthenticationStateProvider authenticationStateProvider
= new CustomAuthenticationStateProvider(localStorageServiceMock, mock, navigationManagerMock);
LoginViewModel viewModel = new LoginViewModel(navigationManagerMock, authenticationStateProvider, mock, new EntityChangeValidator <User>())
{
User = user
};
viewModel.LoginAsGuestUserCommand.ExecuteCommand();
Assert.AreSame(User.GuestUser, mock.Parameters.Pop());
Assert.AreEqual("Users/Login", mock.Routes.Pop());
Assert.AreEqual(HttpMethod.Post, mock.Methods.Pop());
}
public async Task InitializeAsyncTest()
{
ApiConnectorMock mock = new ApiConnectorMock();
LocalStorageServiceMock localStorageServiceMock = new LocalStorageServiceMock();
CustomAuthenticationStateProvider authenticationStateProvider
= new CustomAuthenticationStateProvider(localStorageServiceMock, mock, navigationManagerMock);
//Not Authenticated
LoginViewModel viewModel = new LoginViewModel(navigationManagerMock, authenticationStateProvider, mock, new EntityChangeValidator <User>())
{
AuthenticationStateTask = Task.FromResult(new AuthenticationState(new ClaimsPrincipal(new ClaimsIdentity())))
};
bool result = await viewModel.InitializeAsync();
Assert.IsTrue(result);
Assert.IsNotNull(viewModel.User);
//Authenticated
ClaimsIdentity identity = new ClaimsIdentity(new[] { new Claim(ClaimTypes.Name, "test") }, "apiauth_type");
viewModel.AuthenticationStateTask = Task.FromResult(new AuthenticationState(new ClaimsPrincipal(identity)));
result = await viewModel.InitializeAsync();
Assert.IsFalse(result);
}
public void TestInitialize()
{
notificationProviderMock = new NotificationProviderMock();
NotificationMessageProvider.Initialize(notificationProviderMock, 1000000);
apiConnectorMock = new ApiConnectorMock();
navigationManagerMock = new NavigationManagerMock();
}
public void EntityController_Update_WithNoFieldsAltered_Succeeds()
{
var controllerMock = new ApiConnectionEntityControllerMock();
var connector = new ApiConnectorMock();
var controllerList = new ControllerList(connector, "https://start.exactonline.nl/api/v1/");
var invoice = new SalesInvoice {
Description = "New Description"
};
var line = new SalesInvoiceLine {
Description = "Invoice Line"
};
invoice.SalesInvoiceLines = new List <SalesInvoiceLine> {
line
};
var controller = (Controller <SalesInvoice>)controllerList.GetController <SalesInvoice>();
var entityController = new EntityController(invoice, "ID", invoice.InvoiceID.ToString(), controllerMock, controller.GetEntityController);
var returnValue = controller.AddEntityToManagedEntitiesCollection(invoice);
Assert.IsTrue(returnValue);
entityController.Update(invoice);
string data = controllerMock.Data;
Assert.AreEqual("", data);
}
public async Task LoadDataOnInitializeTest()
{
card1.Fields.Add(new CardField()
{
DueDate = DateTime.Today, FieldName = "FieldWithoutValue"
});
ApiConnectorMock mock = CreateMockForInitialize(true, deck);
PracticeDeckViewModel viewModel = new PracticeDeckViewModel(navigationManagerMock, mock);
bool result = await viewModel.InitializeAsync();
Assert.IsTrue(result);
Assert.AreSame(deck, viewModel.Entity);
Assert.AreEqual(3, viewModel.PracticeFields.Count); //Only fields that are due and have a value
Assert.IsTrue(viewModel.PracticeFields.Contains(field1));
Assert.IsTrue(viewModel.PracticeFields.Contains(field2));
Assert.IsTrue(viewModel.PracticeFields.Contains(field3));
Assert.AreSame(viewModel.PracticeFields[0], viewModel.Current);
Assert.AreEqual(viewModel.Current.FieldName, viewModel.CurrentFieldName);
CardField expectedDisplayField = viewModel.Current.Card.Fields
.Single(field => field.Value != null && field != viewModel.Current);
Assert.AreSame(expectedDisplayField, viewModel.DisplayedCardField);
Assert.IsFalse(viewModel.IsSummary);
Assert.IsFalse(viewModel.IsShowingSolution);
}
public async Task CommandsAreInitializedCorrectlyTest()
{
Card card = new Card()
{
CardId = 1, DeckId = 2
};
ApiConnectorMock mock = CreateMockForInitialize(true, true, new List <Card>()
{
card
}, new List <Deck>());
CardSearchViewModel viewModel = new CardSearchViewModel(navigationManagerMock, mock)
{
SelectedEntity = card
};
await viewModel.InitializeAsync();
Assert.IsNotNull(viewModel.NewCommand.CommandText);
Assert.IsNotNull(viewModel.NewCommand.ToolTip);
Assert.AreEqual("/Decks/2/Cards/New", viewModel.NewCommand.TargetUriFactory.Invoke(null));
Assert.IsNotNull(viewModel.EditCommand.CommandText);
Assert.IsNotNull(viewModel.EditCommand.ToolTip);
Assert.AreEqual("/Decks/2/Cards/1", viewModel.EditCommand.TargetUriFactory.Invoke(card));
Assert.IsNotNull(viewModel.ShowStatisticsCommand.CommandText);
Assert.IsNotNull(viewModel.ShowStatisticsCommand.ToolTip);
Assert.AreEqual("/Decks/2/Cards/1/Statistics", viewModel.ShowStatisticsCommand.TargetUriFactory.Invoke(card));
Assert.IsNotNull(viewModel.DeleteCommand.CommandText);
Assert.IsNotNull(viewModel.DeleteCommand.ToolTip);
}
public async Task CreateNewCardOnInitializeTest()
{
Deck deck = new Deck()
{
DeckId = 1, Title = "test", DefaultCardTemplateId = 2
};
CardTemplate template1 = new CardTemplate()
{
CardTemplateId = 1, Title = "test1"
};
CardTemplate template2 = new CardTemplate()
{
CardTemplateId = 2, Title = "test2"
};
ApiConnectorMock mock = CreateMockForInitialize(false, true, deck, null, new List <CardTemplate>()
{
template1, template2
});
CardEditViewModel viewModel = new CardEditViewModel(navigationManagerMock, mock, new EntityChangeValidator <Card>());
bool result = await viewModel.InitializeAsync();
Assert.IsTrue(result);
Assert.IsNotNull(viewModel.Entity);
//Load default template
Assert.AreEqual(2, viewModel.CardTemplateId);
Assert.AreEqual(2, viewModel.Entity.CardTemplateId);
Assert.AreEqual("test2", viewModel.CardTemplateTitle);
}
public async Task InitializeFailsForWrongDeckIdTest()
{
Deck deck = new Deck()
{
DeckId = 1, Title = "test", DefaultCardTemplateId = 2
};
CardTemplate template1 = new CardTemplate()
{
CardTemplateId = 1, Title = "test"
};
ApiConnectorMock mock = CreateMockForInitialize(true, true, deck, new Card()
{
DeckId = 1
}, new List <CardTemplate>()
{
template1
});
CardEditViewModel viewModel = new CardEditViewModel(navigationManagerMock, mock, new EntityChangeValidator <Card>())
{
Id = 1, DeckId = 2
};
bool result = await viewModel.InitializeAsync();
Assert.IsFalse(result);
Assert.AreEqual(NotificationKind.ErrorNotification, notificationProviderMock.NotificationKind);
Assert.IsFalse(string.IsNullOrEmpty(notificationProviderMock.Message));
}
private ApiConnectorMock CreateMockForInitialize(bool loadEntity, bool loadTemplatesSuccessful, Deck deck, Card card, List <CardTemplate> templates)
{
ApiConnectorMock mock = new ApiConnectorMock();
mock.Replies.Push(new ApiReply <Deck>()
{
WasSuccessful = true,
Result = deck
});
if (loadEntity)
{
mock.Replies.Push(new ApiReply <Card>()
{
WasSuccessful = true,
Result = card
});
}
mock.Replies.Push(new ApiReply <List <CardTemplate> >()
{
ResultMessage = loadTemplatesSuccessful ? null : "test-error",
WasSuccessful = loadTemplatesSuccessful,
Result = templates,
});
return(mock);
}
public void EntityController_Update_WithOnlyLinkedEntityFieldsAltered_Succeeds()
{
var controllerMock = new ApiConnectionEntityControllerMock();
var connector = new ApiConnectorMock();
var controllerList = new ControllerList(connector, "https://start.exactonline.nl/api/v1/");
var invoice = new SalesInvoice {
Description = "New Description"
};
var line = new SalesInvoiceLine {
Description = "InvoiceLine"
};
invoice.SalesInvoiceLines = new List <SalesInvoiceLine> {
line
};
var controller = (Controller <SalesInvoice>)controllerList.GetController <SalesInvoice>();
var ec = new EntityController(invoice, "ID", invoice.InvoiceID.ToString(), controllerMock, controller.GetEntityController);
Assert.IsTrue(controller.AddEntityToManagedEntitiesCollection(invoice));
// Change State
line.Description = "InvoiceLine2";
ec.Update(invoice);
string result = controllerMock.Data;
const string expected = "{\"SalesInvoiceLines\":[{\"Description\":\"InvoiceLine2\"}]}";
Assert.AreEqual(expected, result);
}
public async Task DoesValidateFieldValuePropertiesTest()
{
Deck deck = new Deck()
{
DeckId = 1, Title = "test", DefaultCardTemplateId = 1
};
CardFieldDefinition field = new CardFieldDefinition()
{
CardTemplateId = 1, FieldId = 1, FieldName = "Field 1", IsRequired = true
};
CardTemplate template = new CardTemplate()
{
CardTemplateId = 1, Title = "test1"
};
template.FieldDefinitions.Add(field);
EntityChangeValidator <CardField> fieldChangeValidator = new EntityChangeValidator <CardField>();
fieldChangeValidator.Register(nameof(CardField.Value), new CardFieldValueValidator());
CardChangeValidator validator = new CardChangeValidator(fieldChangeValidator);
ApiConnectorMock mock = CreateMockForInitialize(false, true, deck, null, new List <CardTemplate>()
{
template
});
CardEditViewModel viewModel = new CardEditViewModel(navigationManagerMock, mock, validator);
await viewModel.InitializeAsync();
viewModel.FieldValueProperties[0].Value = null;
Assert.IsFalse(string.IsNullOrEmpty(viewModel.FieldValueProperties[0].ErrorText));
viewModel.FieldValueProperties[0].Value = "test";
Assert.IsTrue(string.IsNullOrEmpty(viewModel.FieldValueProperties[0].ErrorText));
}
public async Task DoesValidateCardTemplateTitlePropertyTest()
{
Deck deck = new Deck()
{
DeckId = 1, Title = "test", DefaultCardTemplateId = 2
};
CardTemplate template1 = new CardTemplate()
{
CardTemplateId = 1, Title = "test"
};
ApiConnectorMock mock = CreateMockForInitialize(false, true, deck, null, new List <CardTemplate>()
{
template1
});
CardEditViewModel viewModel = new CardEditViewModel(navigationManagerMock, mock, new EntityChangeValidator <Card>());
await viewModel.InitializeAsync();
viewModel.CardTemplateTitleProperty.Value = null;
Assert.IsFalse(string.IsNullOrEmpty(viewModel.CardTemplateTitleProperty.ErrorText));
mock = CreateMockForInitialize(false, true, deck, null, new List <CardTemplate>()
{
template1
});
viewModel = new CardEditViewModel(navigationManagerMock, mock, new EntityChangeValidator <Card>());
await viewModel.InitializeAsync();
viewModel.CardTemplateTitleProperty.Value = "test";
Assert.IsTrue(string.IsNullOrEmpty(viewModel.CardTemplateTitleProperty.ErrorText));
}
public async Task CommandsAreInitializedCorrectlyTest()
{
ApiConnectorMock mock = CreateMockForInitialize(true, deck);
PracticeDeckViewModel viewModel = new PracticeDeckViewModel(navigationManagerMock, mock);
await viewModel.InitializeAsync();
Assert.IsNotNull(viewModel.CloseCommand.ToolTip);
Assert.IsNotNull(viewModel.CloseSummaryCommand.CommandText);
Assert.IsNotNull(viewModel.CloseSummaryCommand.ToolTip);
Assert.AreEqual("/", viewModel.CloseSummaryCommand.TargetUri);
Assert.IsNotNull(viewModel.EasyResultCommand.CommandText);
Assert.IsNotNull(viewModel.EasyResultCommand.ToolTip);
Assert.IsNotNull(viewModel.DifficultResultCommand.CommandText);
Assert.IsNotNull(viewModel.DifficultResultCommand.ToolTip);
Assert.IsNotNull(viewModel.DoesNotKnowResultCommand.CommandText);
Assert.IsNotNull(viewModel.DoesNotKnowResultCommand.ToolTip);
Assert.IsNotNull(viewModel.ShowSolutionCommand.CommandText);
Assert.IsNotNull(viewModel.ShowSolutionCommand.ToolTip);
Assert.IsNotNull(viewModel.NextCommand.CommandText);
Assert.IsNotNull(viewModel.NextCommand.ToolTip);
}
public async Task LoadsAvailableCardTemplatesOnInitializeTest()
{
Deck deck = new Deck()
{
DeckId = 1, Title = "test", DefaultCardTemplateId = 1
};
CardFieldDefinition field = new CardFieldDefinition()
{
CardTemplateId = 1, FieldId = 1, FieldName = "Field 1"
};
CardTemplate template = new CardTemplate()
{
CardTemplateId = 1, Title = "test1"
};
template.FieldDefinitions.Add(field);
ApiConnectorMock mock = CreateMockForInitialize(false, true, deck, null, new List <CardTemplate>()
{
template
});
CardEditViewModel viewModel = new CardEditViewModel(navigationManagerMock, mock, new EntityChangeValidator <Card>());
bool result = await viewModel.InitializeAsync();
Assert.IsTrue(result);
Assert.AreEqual(1, viewModel.AvailableCardTemplates.Count);
Assert.AreEqual("test1", viewModel.AvailableCardTemplates[0]);
Assert.AreEqual(1, viewModel.CardTemplateId);
Assert.AreEqual("test1", viewModel.CardTemplateTitle);
Assert.AreEqual(1, viewModel.Entity.Fields.Count);
Assert.AreEqual(1, viewModel.FieldValueProperties.Count);
}
public void EntityController_Update_WithExistingLinkedEntity_Succeeds()
{
var controllerMock = new ApiConnectionEntityControllerMock();
var connector = new ApiConnectorMock();
var controllerList = new ControllerList(connector, "https://start.exactonline.nl/api/v1/");
var invoice = new SalesInvoice {
Description = "New Description"
};
var line = new SalesInvoiceLine {
Description = "InvoiceLine"
};
invoice.SalesInvoiceLines = new List <SalesInvoiceLine> {
line
};
var controller = (Controller <SalesInvoice>)controllerList.GetController <SalesInvoice>();
var entityController = new EntityController(invoice, "ID", invoice.InvoiceID.ToString(), controllerMock, controller.GetEntityController);
Assert.IsTrue(controller.AddEntityToManagedEntitiesCollection(invoice));
// Change State
invoice.Description = "Description2";
line.Description = "InvoiceLine2";
entityController.Update(invoice);
string data = controllerMock.Data;
Assert.AreEqual(@"{""Description"":""Description2"",""SalesInvoiceLines"":[{""Description"":""InvoiceLine2""}]}", data);
}
public async Task UpdateTagsTest()
{
Deck deck = new Deck()
{
DeckId = 1, Title = "test", DefaultCardTemplateId = 1
};
CardTemplate template1 = new CardTemplate()
{
CardTemplateId = 1, Title = "test1"
};
Card card = new Card()
{
CardId = 1, CardTemplateId = 1, DeckId = 1
};
ApiConnectorMock mock = CreateMockForInitialize(true, true, deck, card, new List <CardTemplate>()
{
template1
});
CardEditViewModel viewModel = new CardEditViewModel(navigationManagerMock, mock, new EntityChangeValidator <Card>())
{
Id = 1, DeckId = 1
};
bool result = await viewModel.InitializeAsync();
Assert.IsTrue(result);
Assert.AreEqual(0, viewModel.Tags.Count);
viewModel.Tags.Add("tag1");
Assert.AreEqual("tag1", viewModel.Entity.Tags);
viewModel.Tags.Add("tag2");
Assert.AreEqual("tag1,tag2", viewModel.Entity.Tags);
viewModel.Tags.RemoveAt(0);
Assert.AreEqual("tag2", viewModel.Entity.Tags);
}
public async Task CommandEnabledIsUpdatedOnSavingEntityTest()
{
CardTemplate template = new CardTemplate()
{
CardTemplateId = 1, Title = "test"
};
ApiConnectorMock mock = CreateMockForInitialize(false, true, null, new List <CardTemplate>()
{
template
});
DeckEditViewModel viewModel = new DeckEditViewModel(navigationManagerMock, mock, new EntityChangeValidator <Deck>());
await viewModel.InitializeAsync();
Assert.IsFalse(viewModel.PracticeDeckCommand.IsEnabled);
Assert.IsFalse(viewModel.ShowStatisticsCommand.IsEnabled);
Assert.IsFalse(viewModel.DeleteCommand.IsEnabled);
Assert.IsFalse(viewModel.EditCardCommand.IsEnabled);
Assert.IsFalse(viewModel.DeleteCardCommand.IsEnabled);
Assert.IsFalse(viewModel.NewCardCommand.IsEnabled);
Assert.IsTrue(viewModel.SaveChangesCommand.IsEnabled);
Assert.IsTrue(viewModel.CloseCommand.IsEnabled);
Deck deck = new Deck();
deck.Cards.Add(new Card());
viewModel.SaveChangesCommand.OnSavedAction.Invoke(deck);
Assert.IsTrue(viewModel.PracticeDeckCommand.IsEnabled);
Assert.IsTrue(viewModel.ShowStatisticsCommand.IsEnabled);
Assert.IsTrue(viewModel.DeleteCommand.IsEnabled);
Assert.IsTrue(viewModel.EditCardCommand.IsEnabled);
Assert.IsTrue(viewModel.DeleteCardCommand.IsEnabled);
Assert.IsTrue(viewModel.NewCardCommand.IsEnabled);
Assert.IsTrue(viewModel.SaveChangesCommand.IsEnabled);
Assert.IsTrue(viewModel.CloseCommand.IsEnabled);
}
public async Task ValidatesConfirmPasswordTest()
{
User user = new User()
{
Email = "*****@*****.**", Password = "******"
};
ApiConnectorMock mock = new ApiConnectorMock();
LocalStorageServiceMock localStorageServiceMock = new LocalStorageServiceMock();
CustomAuthenticationStateProvider authenticationStateProvider
= new CustomAuthenticationStateProvider(localStorageServiceMock, mock, navigationManagerMock);
SignupViewModel viewModel = new SignupViewModel(navigationManagerMock, authenticationStateProvider, mock, new EntityChangeValidator <User>())
{
User = user,
ConfirmPassword = "******"
};
await viewModel.SubmitAsync();
Assert.IsTrue(viewModel.HasConfirmPasswordError);
Assert.IsFalse(string.IsNullOrEmpty(viewModel.ErrorMessage));
viewModel.ConfirmPassword = "******";
mock.Replies.Push(new ApiReply <User>()
{
WasSuccessful = true,
Result = user
});
await viewModel.SubmitAsync();
Assert.IsFalse(viewModel.HasConfirmPasswordError);
Assert.IsTrue(string.IsNullOrEmpty(viewModel.ErrorMessage));
}
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);
}
public async Task NextCommandTest()
{
ApiConnectorMock mock = CreateMockForInitialize(true, deck);
PracticeDeckViewModel viewModel = new PracticeDeckViewModel(navigationManagerMock, mock)
{
InputText = "test123",
IsShowingSolution = true,
WasInputCorrect = true
};
await viewModel.InitializeAsync();
CardField previous = viewModel.Current;
viewModel.NextCommand.ExecuteCommand();
Assert.IsTrue(string.IsNullOrEmpty(viewModel.InputText));
Assert.IsNull(viewModel.WasInputCorrect);
Assert.IsFalse(viewModel.IsShowingSolution);
Assert.AreNotSame(previous, viewModel.Current);
Assert.IsFalse(viewModel.IsSummary);
viewModel.NextCommand.ExecuteCommand();
viewModel.NextCommand.ExecuteCommand();
Assert.IsTrue(viewModel.IsSummary);
}
public async Task DoesNotReportResultWhenNotActivePracticeTest()
{
Deck deck = new Deck()
{
Title = "test", DeckId = 1
};
Card card = new Card()
{
CardId = 1, DeckId = 1
};
deck.Cards.Add(card);
card.Fields.Add(new CardField()
{
FieldId = 1, Value = "test 1", FieldName = "test1", DueDate = DateTime.Today.AddDays(1)
});
card.Fields.Add(new CardField()
{
FieldId = 2, Value = "test 2", FieldName = "test2", DueDate = DateTime.Today.AddDays(1)
});
ApiConnectorMock mock = CreateMockForInitialize(true, deck);
PracticeDeckViewModel viewModel = new PracticeDeckViewModel(navigationManagerMock, mock)
{
IsShowingSolution = true
};
await viewModel.InitializeAsync();
mock.Methods.Clear();
mock.Parameters.Clear();
viewModel.EasyResultCommand.ExecuteCommand();
Assert.AreEqual(0, mock.Methods.Count);
Assert.AreEqual(0, mock.Parameters.Count);
}
public void EntityController_Update_WithNewLinkedEntity_Succeeds()
{
var controllerMock = new ApiConnectionEntityControllerMock();
var apiConnectorMock = new ApiConnectorMock();
var controllerList = new ControllerList(apiConnectorMock, "https://start.exactonline.nl/api/v1/");
var controller = (Controller <SalesInvoice>)controllerList.GetController <SalesInvoice>();
var invoice = new SalesInvoice {
Description = "New Description"
};
var entityController = new EntityController(invoice, "ID", invoice.InvoiceID.ToString(), controllerMock, controller.GetEntityController);
// Change State
invoice.Description = "Description2";
var line = new SalesInvoiceLine {
Description = "InvoiceLine2"
};
invoice.SalesInvoiceLines = new List <SalesInvoiceLine> {
line
};
entityController.Update(invoice);
string data = controllerMock.Data;
Assert.IsTrue(data.Contains(@"""Description"":""Description2"""));
Assert.IsTrue(data.Contains(@"""Description"":""InvoiceLine2"""));
}
public async Task CommandsAreInitializedCorrectlyTest()
{
Deck deck = new Deck()
{
DeckId = 1, Title = "test", DefaultCardTemplateId = 2
};
CardTemplate template1 = new CardTemplate()
{
CardTemplateId = 1, Title = "test"
};
ApiConnectorMock mock = CreateMockForInitialize(false, true, deck, null, new List <CardTemplate>()
{
template1
});
CardEditViewModel viewModel = new CardEditViewModel(navigationManagerMock, mock, new EntityChangeValidator <Card>());
await viewModel.InitializeAsync();
Assert.IsNotNull(viewModel.ShowStatisticsCommand.CommandText);
Assert.IsNotNull(viewModel.ShowStatisticsCommand.ToolTip);
Assert.AreEqual("/Statistics", viewModel.ShowStatisticsCommand.TargetUri);
Assert.IsTrue(viewModel.ShowStatisticsCommand.IsRelative);
Assert.IsNotNull(viewModel.DeleteCommand.CommandText);
Assert.IsNotNull(viewModel.DeleteCommand.ToolTip);
Assert.IsNotNull(viewModel.SaveChangesCommand.CommandText);
Assert.IsNotNull(viewModel.SaveChangesCommand.ToolTip);
}
public async Task LoadsPracticeHistoryEntriesOnIntializeTest()
{
Card card = new Card()
{
CardId = 1
};
card.Fields.Add(new CardField()
{
FieldId = 1, FieldName = "Field 1"
});
card.Fields.Add(new CardField()
{
FieldId = 2, FieldName = "Field 2"
});
PracticeHistoryEntry entry1 = new PracticeHistoryEntry()
{
Field = new CardField()
{
FieldName = "Field 1"
}
};
PracticeHistoryEntry entry2 = new PracticeHistoryEntry()
{
Field = new CardField()
{
FieldName = "Field 2"
}
};
ApiConnectorMock mock = new ApiConnectorMock();
mock.Replies.Push(new ApiReply <List <PracticeHistoryEntry> >()
{
WasSuccessful = true,
Result = new List <PracticeHistoryEntry>()
{
entry1, entry2
}
});
mock.Replies.Push(new ApiReply <Card>()
{
WasSuccessful = true,
Result = card
});
CardStatisticsViewModel viewModel = new CardStatisticsViewModel(navigationManagerMock, mock);
bool result = await viewModel.InitializeAsync();
Assert.IsTrue(result);
Assert.AreEqual(HttpMethod.Get, mock.Methods.Pop());
Dictionary <string, object> parameters = mock.Parameters.Pop() as Dictionary <string, object>;
Assert.AreEqual((long)1, parameters[nameof(Card.CardId)]);
Assert.IsTrue(viewModel.PracticeHistoryEntries.Contains(entry1));
Assert.IsTrue(viewModel.PracticeHistoryEntries.Contains(entry2));
Assert.AreEqual(EntityNameHelper.GetName <Card>(), viewModel.SelectableDisplayUnits[0]);
Assert.AreEqual(EntityNameHelper.GetName <Card>(), viewModel.SelectedDisplayUnit);
Assert.IsTrue(viewModel.SelectableDisplayUnits.Contains("Field 1"));
Assert.IsTrue(viewModel.SelectableDisplayUnits.Contains("Field 2"));
}
public async Task InitializeFailsOnErrorWhenLoadingDeckTest()
{
ApiConnectorMock mock = CreateMockForInitialize(false, null);
PracticeDeckViewModel viewModel = new PracticeDeckViewModel(navigationManagerMock, mock);
bool result = await viewModel.InitializeAsync();
Assert.IsFalse(result);
Assert.AreEqual(NotificationKind.ErrorNotification, notificationProviderMock.NotificationKind);
Assert.AreEqual("test-error", notificationProviderMock.Message);
}
public async Task NewCommandEnabledTest()
{
ApiConnectorMock mock = CreateMockForInitialize(true, true, new List <Card>(), new List <Deck>());
CardSearchViewModel viewModel = new CardSearchViewModel(navigationManagerMock, mock);
await viewModel.InitializeAsync();
Assert.IsFalse(viewModel.NewCommand.IsEnabled);
viewModel.SelectedEntity = new Card();
Assert.IsTrue(viewModel.NewCommand.IsEnabled);
}
public void TestInitialize()
{
notificationProviderMock = new NotificationProviderMock();
NotificationMessageProvider.Initialize(notificationProviderMock, 1000000);
mock = new ApiConnectorMock();
saveCommand = new EntitySaveCommand <Card>(mock)
{
Entity = card
};
}
public void TestInitialize()
{
notificationProviderMock = new NotificationProviderMock();
NotificationMessageProvider.Initialize(notificationProviderMock, 1000000);
apiConnectorMock = new ApiConnectorMock();
navigationManagerMock = new NavigationManagerMock();
viewModel = new TestViewModel(navigationManagerMock, apiConnectorMock)
{
Id = 12
};
}
