public void SaveDeckTest003_SaveMinor()
{
Mock <ITrackerFactory> trackerFactory = new Mock <ITrackerFactory>();
Mock <ITracker> tracker = new Mock <ITracker>();
ObservableCollection <Deck> deckList = new ObservableCollection <Deck>();
tracker.Setup(t => t.Decks).Returns(deckList);
trackerFactory.Setup(tf => tf.GetTracker()).Returns(tracker.Object);
CardInstance card = new CardInstance(new Card(trackerFactory.Object));
Deck deck = Deck.CreateNewDeck(trackerFactory.Object, "test deck");
deck.Class = DataModel.Enums.DeckClass.Assassin; //any
deck.SelectedVersion.Cards.Add(card);
DeckEditViewModel model = new DeckEditViewModel();
model.Deck = deck;
model.BeginEdit();
deck.SelectedVersion.Cards.Add(new CardInstance(Card.Unknown));
deck.SelectedVersion.Cards.Add(new CardInstance(new Card(trackerFactory.Object)));
model.SaveDeck(tracker.Object, new SerializableVersion(0, 1), deck.SelectedVersion.Cards);
Assert.AreEqual(3, model.Deck.SelectedVersion.Cards.Count);
Assert.AreEqual(new SerializableVersion(1, 1), model.Deck.SelectedVersion.Version);
Assert.AreEqual(1, model.Deck.History[0].Cards.Count);
Assert.AreEqual(2, model.Deck.History.Count);
//endsure inial card has ebeen cloned
Assert.IsFalse(model.Deck.SelectedVersion.Cards.Contains(card));
}
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 void SaveDeckTest001_OverwriteCurrent()
{
Mock <ITrackerFactory> trackerFactory = new Mock <ITrackerFactory>();
Mock <ITracker> tracker = new Mock <ITracker>();
ObservableCollection <Deck> deckList = new ObservableCollection <Deck>();
tracker.Setup(t => t.Decks).Returns(deckList);
trackerFactory.Setup(tf => tf.GetTracker()).Returns(tracker.Object);
CardInstance card = new CardInstance(new Card(trackerFactory.Object));
Deck deck = Deck.CreateNewDeck(trackerFactory.Object, "test deck");
deck.SelectedVersion.Cards.Add(card);
// List<CardInstance> modifiedCollection = new List<CardInstance>()
{
// card, //include this and ensure it has been cloned
deck.SelectedVersion.Cards.Add(new CardInstance(Card.Unknown));
deck.SelectedVersion.Cards.Add(new CardInstance(new Card(trackerFactory.Object)));
};
DeckEditViewModel model = new DeckEditViewModel();
model.Deck = deck;
model.SaveDeck(tracker.Object, new SerializableVersion(0, 0), deck.SelectedVersion.Cards);
Assert.AreEqual(3, model.Deck.SelectedVersion.Cards.Count);
Assert.AreEqual(1, model.Deck.History.Count);
}
public void LimitCardCountForDeckTest001_SoloArena()
{
DeckEditViewModel model = new DeckEditViewModel();
bool actual = model.LimitCardCountForDeck(new Deck()
{
Type = DataModel.Enums.DeckType.SoloArena
});
Assert.AreEqual(false, actual);
}
public void LimitCardCountForDeckTest001_Constructed()
{
DeckEditViewModel model = new DeckEditViewModel();
bool actual = model.LimitCardCountForDeck(new Deck()
{
Type = DataModel.Enums.DeckType.Constructed
});
Assert.AreEqual(true, actual);
}
public void EditDeckStartTest001()
{
Deck deck = Deck.CreateNewDeck();
DeckEditViewModel model = new DeckEditViewModel();
model.EditDeckStart(new Utils.Messages.EditDeck()
{
Deck = deck
});
Assert.AreEqual(deck, model.Deck);
Assert.AreEqual(deck, model.savedState);
}
public async Task CommandsAreInitializedCorrectlyTest()
{
Deck deck = new Deck()
{
DeckId = 1, Title = "test", DefaultCardTemplateId = 1
};
deck.Cards.Add(new Card()
{
CardId = 1
});
CardTemplate template = new CardTemplate()
{
CardTemplateId = 1, Title = "test"
};
ApiConnectorMock mock = CreateMockForInitialize(true, true, deck, new List <CardTemplate>()
{
template
});
DeckEditViewModel viewModel = new DeckEditViewModel(navigationManagerMock, mock, new EntityChangeValidator <Deck>());
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.EditCardCommand.CommandText);
Assert.IsNotNull(viewModel.EditCardCommand.ToolTip);
Assert.AreEqual("/Cards/1", viewModel.EditCardCommand.TargetUriFactory.Invoke(deck.Cards[0]));
Assert.IsTrue(viewModel.EditCardCommand.IsRelative);
Assert.IsNotNull(viewModel.NewCardCommand.CommandText);
Assert.IsNotNull(viewModel.NewCardCommand.ToolTip);
Assert.AreEqual("/Cards/New", viewModel.NewCardCommand.TargetUri);
Assert.IsTrue(viewModel.NewCardCommand.IsRelative);
Assert.IsNotNull(viewModel.PracticeDeckCommand.CommandText);
Assert.IsNotNull(viewModel.PracticeDeckCommand.ToolTip);
Assert.AreEqual("/Practice", viewModel.PracticeDeckCommand.TargetUri);
Assert.IsTrue(viewModel.PracticeDeckCommand.IsRelative);
Assert.IsNotNull(viewModel.DeleteCommand.CommandText);
Assert.IsNotNull(viewModel.DeleteCommand.ToolTip);
Assert.IsNotNull(viewModel.DeleteCardCommand.CommandText);
Assert.IsNotNull(viewModel.DeleteCardCommand.ToolTip);
Assert.IsNotNull(viewModel.SaveChangesCommand.CommandText);
Assert.IsNotNull(viewModel.SaveChangesCommand.ToolTip);
}
public DeckEditPage(DeckEditViewModel viewModel)
{
InitializeComponent();
BindingContext = this.viewModel = viewModel;
if (viewModel.EditMode)
{
var toolbarItem = new ToolbarItem()
{
Text = "Save", Icon = "icon_save.png"
};
toolbarItem.Clicked += SaveToolbarItem_Click;
ToolbarItems.Add(toolbarItem);
}
}
public async Task LoadsAvailableCardTemplatesOnInitializeTest()
{
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>());
bool result = await viewModel.InitializeAsync();
Assert.IsTrue(result);
Assert.AreEqual(1, viewModel.AvailableCardTemplates.Count);
Assert.AreEqual("test", viewModel.AvailableCardTemplates[0]);
}
public async Task LoadsAvailableCardTemplatesOnInitializeErrorTest()
{
CardTemplate template = new CardTemplate()
{
CardTemplateId = 1, Title = "test"
};
ApiConnectorMock mock = CreateMockForInitialize(false, false, null, new List <CardTemplate>()
{
template
});
DeckEditViewModel viewModel = new DeckEditViewModel(navigationManagerMock, mock, new EntityChangeValidator <Deck>());
bool result = await viewModel.InitializeAsync();
Assert.IsFalse(result);
Assert.AreEqual(0, viewModel.AvailableCardTemplates.Count);
Assert.AreEqual(NotificationKind.ErrorNotification, notificationProviderMock.NotificationKind);
Assert.AreEqual("test-error", notificationProviderMock.Message);
}
public async Task CreateNewDeckOnInitializeTest()
{
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>());
bool result = await viewModel.InitializeAsync();
Assert.IsTrue(result);
Assert.IsNotNull(viewModel.Entity);
//Load default template
Assert.AreEqual(1, viewModel.CardTemplateId);
Assert.AreEqual(1, viewModel.Entity.DefaultCardTemplateId);
Assert.AreEqual("test", viewModel.CardTemplateTitle);
}
public async Task DoesValidateTitlePropertyTest()
{
EntityChangeValidator <Deck> validator = new EntityChangeValidator <Deck>();
validator.Register(nameof(Deck.Title), new DeckTitleValidator());
CardTemplate template = new CardTemplate()
{
CardTemplateId = 1, Title = "test"
};
ApiConnectorMock mock = CreateMockForInitialize(false, true, null, new List <CardTemplate>()
{
template
});
DeckEditViewModel viewModel = new DeckEditViewModel(navigationManagerMock, mock, validator);
await viewModel.InitializeAsync();
viewModel.TitleProperty.Value = null;
Assert.IsFalse(string.IsNullOrEmpty(viewModel.TitleProperty.ErrorText));
viewModel.TitleProperty.Value = "test";
Assert.IsTrue(string.IsNullOrEmpty(viewModel.TitleProperty.ErrorText));
}
public void CancelEditTest001()
{
Mock <ITrackerFactory> trackerFactory = new Mock <ITrackerFactory>();
trackerFactory.Setup(tf => tf.GetNewGuid()).Returns(() => Guid.NewGuid());
DeckEditViewModel model = new DeckEditViewModel();
Deck deck = Deck.CreateNewDeck(trackerFactory.Object);
model.Deck = deck;
PopulateObject(deck, StartProp);
//fix up selected version id - otherwise it would be some random guid
deck.History.Last().VersionId = deck.SelectedVersionId;
TestContext.WriteLine("Begin Edit");
model.BeginEdit();
PopulateObject(deck, EditProp);
TestContext.WriteLine("Cancel Edit");
model.CancelEdit();
foreach (PropertyInfo p in deck.GetType().GetProperties())
{
if (p.CanWrite)
{
if (p.PropertyType.GetInterface(nameof(ICollection)) != null)
{
CollectionAssert.AreEqual(StartProp[p.PropertyType] as ICollection, p.GetValue(deck) as ICollection, "Failed validation of prop {0} of type {1}", p.Name, p.PropertyType);
}
else
{
Assert.AreEqual(StartProp[p.PropertyType], p.GetValue(deck), "Failed validation of prop {0} of type {1}", p.Name, p.PropertyType);
}
}
}
}
public void SaveDeckTest005_SaveNotLatestVersion_EnsureNewMajorHaveMinor_0()
{
Mock <ITrackerFactory> trackerFactory = new Mock <ITrackerFactory>();
trackerFactory.Setup(tf => tf.GetDateTimeNow()).Returns(DateTime.Now);
Mock <ITracker> tracker = new Mock <ITracker>();
ObservableCollection <Deck> deckList = new ObservableCollection <Deck>();
tracker.Setup(t => t.Decks).Returns(deckList);
trackerFactory.Setup(tf => tf.GetTracker()).Returns(tracker.Object);
CardInstance card = new CardInstance(new Card(trackerFactory.Object));
Deck deck = Deck.CreateNewDeck(trackerFactory.Object, "test deck");
deck.Class = DataModel.Enums.DeckClass.Assassin; //any
deck.CreateVersion(1, 3, trackerFactory.Object.GetDateTimeNow()); //ensure its not ordered :)
Guid selectedVersion = deck.CreateVersion(1, 1, trackerFactory.Object.GetDateTimeNow()).VersionId;
deck.CreateVersion(1, 2, trackerFactory.Object.GetDateTimeNow());
deck.SelectedVersionId = selectedVersion; //select 1.1
DeckEditViewModel model = new DeckEditViewModel();
model.Deck = deck;
model.BeginEdit();
//tray save as 1.2
model.SaveDeck(tracker.Object, new SerializableVersion(1, 0), deck.SelectedVersion.Cards);
Assert.AreEqual(new SerializableVersion(2, 0), model.Deck.SelectedVersion.Version);
Assert.AreEqual(5, model.Deck.History.Count);
}
public DeckEditPage()
{
InitializeComponent();
viewModel = BindingContext as DeckEditViewModel;
}
public async Task CommandsEnabledTest()
{
CardTemplate template = new CardTemplate()
{
CardTemplateId = 1, Title = "test"
};
//New Entity
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);
//Existing entity
Deck deck = new Deck()
{
DeckId = 1, Title = "test", DefaultCardTemplateId = 1
};
mock = CreateMockForInitialize(true, true, deck, new List <CardTemplate>()
{
template
});
viewModel = new DeckEditViewModel(navigationManagerMock, mock, new EntityChangeValidator <Deck>())
{
Id = 1
};
await viewModel.InitializeAsync();
Assert.IsFalse(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);
//Existing entity with cards
deck.Cards.Add(new Card());
mock = CreateMockForInitialize(true, true, deck, new List <CardTemplate>()
{
template
});
viewModel = new DeckEditViewModel(navigationManagerMock, mock, new EntityChangeValidator <Deck>())
{
Id = 1
};
await viewModel.InitializeAsync();
Assert.IsTrue(viewModel.PracticeDeckCommand.IsEnabled);
}
public void CalculateDeckChangesTest001()
{
Card c1 = new Card()
{
Name = "c1", Id = Guid.NewGuid()
};
Card c2 = new Card()
{
Name = "c2", Id = Guid.NewGuid()
};
Card c3 = new Card()
{
Name = "c3", Id = Guid.NewGuid()
};
Card c4 = new Card()
{
Name = "c4", Id = Guid.NewGuid()
};
Card c5 = new Card()
{
Name = "c5", Id = Guid.NewGuid()
};
ObservableCollection <CardInstance> coll1 = new ObservableCollection <CardInstance>();
coll1.Add(new CardInstance(c1)
{
Quantity = 2
});
coll1.Add(new CardInstance(c2)
{
Quantity = 2
});
coll1.Add(new CardInstance(c3)
{
Quantity = 3
});
coll1.Add(new CardInstance(c4)
{
Quantity = 3
});
ObservableCollection <CardInstance> coll2 = new ObservableCollection <CardInstance>();
coll2.Add(new CardInstance(c2)
{
Quantity = 2
});
coll2.Add(new CardInstance(c3)
{
Quantity = 1
});
coll2.Add(new CardInstance(c4)
{
Quantity = 3
});
coll2.Add(new CardInstance(c5)
{
Quantity = 2
});
ObservableCollection <CardInstance> expected = new ObservableCollection <CardInstance>();
expected.Add(new CardInstance(c1)
{
Quantity = 2
});
//c2 - no changes not in a list
expected.Add(new CardInstance(c3)
{
Quantity = 2
});
//c4 - no changes not in a list
expected.Add(new CardInstance(c5)
{
Quantity = -2
});
var actual = new DeckEditViewModel().CalculateDeckChanges(coll1, coll2);
CollectionAssert.AreEqual(expected, actual,
Comparer <CardInstance> .Create((x, y) => x.CardId == y.CardId && x.Quantity == y.Quantity ? 0 : 1),
"{0}Actual:{0}{1}; {0}Expected:{0}{2}",
Environment.NewLine,
String.Join(Environment.NewLine, actual.Select(c => c.DebuggerInfo)),
String.Join(Environment.NewLine, expected.Select(c => c.DebuggerInfo)));
}
