public void Add_OneElement_SendAddNotification()
{
// Arrange
var limitation = new CountLimitationVM {
Model = new CountLicenseLimitation {
Enabled = false, Maximum = 1
}
};
col.Limitation = limitation;
col.Model.AddRange(players);
col.ViewModels.CollectionChanged += HandleCollectionChanged;
var vmToAdd = new DummyPlayerVM {
Model = new Utils.PlayerDummy()
};
// Act
col.ViewModels.Add(vmToAdd);
col.ViewModels.CollectionChanged -= HandleCollectionChanged;
// Assert
Assert.AreEqual(1, actionsNotified.Count());
Assert.AreEqual(NotifyCollectionChangedAction.Add, actionsNotified [0]);
}
public async Task ShowState_Limitation_LimitedLoadedProjects()
{
licenseLimitationMock.Reset();
CountLimitationVM countLimitation = new CountLimitationVM {
Model = limitedLimitation,
};
licenseLimitationMock.Setup(ls => ls.CreateBarChartVM(It.IsAny <string> (), -1, null)).Returns(
new CountLimitationBarChartVM {
Limitation = countLimitation,
BarChart = new TwoBarChartVM(new SeriesVM(), new SeriesVM(), 4)
}
);
storageMock.Setup(s => s.RetrieveAll <LMProject> ()).Returns(projectList);
var sortedProjectList = new RangeObservableCollection <LMProject> {
futureProject,
nowProject,
pastProject,
};
await state.LoadState(null);
await state.ShowState();
CollectionAssert.AreNotEqual(sortedProjectList, state.ViewModel.ViewModels.Select(p => p.Model));
Assert.AreNotEqual(limitedLimitation.Maximum, state.ViewModel.Model.Count());
Assert.AreEqual(limitedLimitation.Maximum, state.ViewModel.ViewModels.Count());
}
void CreateViewModels(int max, int count, bool enabled, int showOnRemaining = -1)
{
countLimitationVM = new CountLimitationVM {
Model = new CountLicenseLimitation {
Maximum = max,
Count = count,
Enabled = enabled,
DisplayName = "testLimitation",
RegisterName = "test"
}
};
twoBarChartVM = new TwoBarChartVM(new SeriesVM {
Title = "Remaining", Elements = countLimitationVM.Remaining,
Color = Color.Green1
},
new SeriesVM {
Title = "Current", Elements = countLimitationVM.Count,
Color = Color.Transparent
}, countLimitationVM.Maximum);
viewModel = new CountLimitationBarChartVM(showOnRemaining)
{
Limitation = countLimitationVM,
BarChart = twoBarChartVM
};
}
public void LimitationService_GetNonExistingCountLimitation_ReturnsNull()
{
CountLimitationVM limit = service.Get <CountLimitationVM> ("Non-existing limitation");
IEnumerable <LimitationVM> allLimitations = service.GetAll();
Assert.AreEqual(0, allLimitations.Count());
Assert.IsNull(limit);
}
/// <summary>
/// Fills the menu item "Add to playlist" with all the playlist options
/// </summary>
/// <param name="addToPlaylistMenu">Add to playlist menu.</param>
/// <param name = "playlistList">List of playlists to show in the menu</param>
/// <param name="events">Timeline events.</param>
//FIXME: Convert this to ViewModels (both Playlist & TimelineEvent)
static public void FillAddToPlaylistMenu(MenuItem addToPlaylistMenu, IEnumerable <PlaylistVM> playlistList,
IEnumerable <IPlayable> events)
{
if (!events.Any())
{
addToPlaylistMenu.Visible = false;
return;
}
addToPlaylistMenu.Visible = true;
var label = String.Format("{0} ({1})", Catalog.GetString("Add to playlist"), events.Count());
addToPlaylistMenu.SetLabel(label);
Menu plMenu = new Menu();
MenuItem item;
foreach (PlaylistVM pl in playlistList)
{
item = new MenuItem(pl.Name);
plMenu.Append(item);
item.Activated += (sender, e) => {
item.PublishEvent(
new AddPlaylistElementEvent {
Playlist = pl,
PlaylistElements = events.ToList()
}
);
};
}
item = new MenuItem(Catalog.GetString("Create new playlist..."));
// FIXME: Longomatch has not implemented the limitation service, remove the null check when it is done
if (App.Current.LicenseLimitationsService != null)
{
//FIXME: Longomatch can have playlist at project level and application level, this should be reworked when count limitation
//applies to project (playlist) and application level (presentations)
CountLimitationVM limitation = App.Current.LicenseLimitationsService.Get <CountLimitationVM> ("Presentations");
if (limitation != null)
{
item.Sensitive = limitation.Count < limitation.Maximum;
}
}
plMenu.Append(item);
item.Activated += (sender, e) => {
item.PublishEvent(
new AddPlaylistElementEvent {
Playlist = null,
PlaylistElements = events.ToList()
}
);
};
plMenu.ShowAll();
addToPlaylistMenu.Submenu = plMenu;
}
public void Timeline_SetLimitation_SetsInFullTimeline()
{
TimelineVM viewModel = new TimelineVM();
viewModel.Model = new RangeObservableCollection <TimelineEvent> ();
var countLimitation = new CountLimitationVM();
var countLimitationChart = new CountLimitationBarChartVM {
Limitation = countLimitation
};
viewModel.LimitationChart = countLimitationChart;
Assert.AreSame(countLimitation, viewModel.FullTimeline.Limitation);
}
public void OneWayPropertyBinding_ChangedSource_BindedWithLast()
{
// Arrange
CountLimitationVM source = new CountLimitationVM {
Model = new CountLicenseLimitation {
DisplayName = "source",
RegisterName = "source",
Count = 1,
Maximum = 5,
Enabled = true
}
};
CountLimitationVM source2 = new CountLimitationVM {
Model = new CountLicenseLimitation {
DisplayName = "source2",
RegisterName = "source2",
Count = 2,
Maximum = 10,
Enabled = true
}
};
CountLimitationVM destination = new CountLimitationVM {
Model = new CountLicenseLimitation {
DisplayName = "destination",
RegisterName = "destination",
Count = 0,
Maximum = 0,
Enabled = false
}
};
var binding = new OneWayPropertyBinding <int, int> (destination,
(vm) => ((CountLimitationVM)vm).Count,
(vm) => ((CountLimitationVM)vm).Count);
// Act
binding.ViewModel = source;
binding.ViewModel = source2;
source.Count = 777;
source2.Count = 999;
// Assert
Assert.AreEqual("destination", destination.DisplayName);
Assert.AreEqual("source", source.DisplayName);
Assert.AreEqual("source2", source2.DisplayName);
Assert.AreEqual(source2, binding.ViewModel);
Assert.AreEqual(source2.Count, destination.Count);
Assert.AreNotEqual(source.Count, source2.Count);
}
public void LimitationService_AddCountLimitations()
{
service.Add(limitationPlayers);
service.Add(limitationTeams);
CountLimitationVM testLimitationPlayers = service.Get <CountLimitationVM> ("RAPlayers");
CountLimitationVM testLimitationTeams = service.Get <CountLimitationVM> ("Teams");
IEnumerable <LimitationVM> allLimitations = service.GetAll();
Assert.AreEqual(2, allLimitations.Count());
Assert.IsTrue(testLimitationPlayers.Enabled);
Assert.AreEqual(10, testLimitationPlayers.Maximum);
Assert.IsTrue(testLimitationTeams.Enabled);
Assert.AreEqual(5, testLimitationTeams.Maximum);
}
public void FixtureSetUp()
{
WibuInit.InitDependencies();
DashboardDummy dashboard = new DashboardDummy {
Name = "Dashboard 1"
};
mockGuiToolkit = new Mock <IGUIToolkit> ();
mockDialogs = new Mock <IDialogs> ();
mockProvider = new Mock <ICategoriesTemplatesProvider> ();
mockGuiToolkit.SetupGet(x => x.DeviceScaleFactor).Returns(1.0f);
mockGuiToolkit.Setup(x => x.CreateNewTemplate <Dashboard> (It.IsAny <IList <Dashboard> > (),
It.IsAny <string> (),
It.IsAny <string> (),
It.IsAny <string> (),
It.IsAny <CreateEvent <Dashboard> > ()
)).ReturnsAsync(true);
mockDialogs.Setup(x => x.OpenFile(It.IsAny <string> (), It.IsAny <string> (), It.IsAny <string> (),
It.IsAny <string> (), It.IsAny <string []> ())).Returns("Dashboard.lct");
mockDialogs.Setup(x => x.QuestionMessage(It.IsAny <string> (), It.IsAny <string> (), It.IsAny <object> ()))
.ReturnsAsync(true);
mockDialogs.Setup(m => m.QueryMessage(It.IsAny <string> (), null, It.IsAny <string> (),
It.IsAny <object> ())).Returns(AsyncHelpers.Return("dashboard_copy"));
mockProvider.Setup(x => x.LoadFile(It.IsAny <string> ())).Returns(dashboard);
mockProvider.Setup(x => x.Templates).Returns(new List <Dashboard> {
dashboard
});
mockLimitationService = new Mock <ILicenseLimitationsService> ();
countLimitationVM = new CountLimitationVM()
{
Model = new CountLicenseLimitation {
RegisterName = LongoMatchCountLimitedObjects.Team.ToString(),
Enabled = true,
Maximum = 2
}
};
mockLimitationService.Setup(x => x.Get <CountLimitationVM> (It.IsAny <string> ())).Returns(countLimitationVM);
App.Current.LicenseLimitationsService = mockLimitationService.Object;
App.Current.GUIToolkit = mockGuiToolkit.Object;
App.Current.Dialogs = mockDialogs.Object;
App.Current.CategoriesTemplatesProvider = mockProvider.Object;
controller = new DashboardsController();
}
/// <summary>
/// Add the specified limitation by name.
/// </summary>
/// <param name="limitation">Limitation.</param>
public void Add(CountLicenseLimitation limitation, Command command = null)
{
if (Limitations.ContainsKey(limitation.RegisterName))
{
throw new InvalidOperationException("Limitations cannot be overwritten");
}
CountLimitationVM viewModel = new CountLimitationVM {
Model = limitation,
};
if (command != null)
{
viewModel.UpgradeCommand = command;
}
Limitations [limitation.RegisterName] = viewModel;
}
public void LimitationService_GetDisabledLimitation()
{
service.Add(new CountLicenseLimitation {
Enabled = false,
Maximum = 10,
Count = 8,
RegisterName = "Disabled"
});
CountLimitationVM limitation = service.Get <CountLimitationVM> ("Disabled");
IEnumerable <CountLimitationVM> allLimitations = service.GetAll <CountLimitationVM> ();
Assert.AreEqual(1, allLimitations.Count());
Assert.IsFalse(limitation.Enabled);
Assert.AreEqual(int.MaxValue, limitation.Maximum);
Assert.AreEqual(8, limitation.Count);
}
public void FixtureSetUp()
{
WibuInit.InitDependencies();
DummyTeam team = new DummyTeam {
Name = "Team 1"
};
mockGuiToolkit = new Mock <IGUIToolkit> ();
mockDialogs = new Mock <IDialogs> ();
mockProvider = new Mock <ITeamTemplatesProvider> ();
mockGuiToolkit.Setup(x => x.CreateNewTemplate <Team> (It.IsAny <IList <Team> > (),
It.IsAny <string> (),
It.IsAny <string> (),
It.IsAny <string> (),
It.IsAny <CreateEvent <Team> > ()
)).ReturnsAsync(true);
mockDialogs.Setup(x => x.OpenFile(It.IsAny <string> (), It.IsAny <string> (), It.IsAny <string> (),
It.IsAny <string> (), It.IsAny <string []> ())).Returns("Team.ltt");
mockDialogs.Setup(m => m.QueryMessage(It.IsAny <string> (), null, It.IsAny <string> (),
It.IsAny <object> ())).Returns(AsyncHelpers.Return("team_copy"));
mockDialogs.Setup(x => x.QuestionMessage(It.IsAny <string> (), It.IsAny <string> (), It.IsAny <object> ()))
.ReturnsAsync(true);
mockProvider.Setup(x => x.LoadFile(It.IsAny <string> ())).Returns(team);
mockProvider.Setup(x => x.Templates).Returns(new List <Team> ());
App.Current.GUIToolkit = mockGuiToolkit.Object;
App.Current.Dialogs = mockDialogs.Object;
App.Current.TeamTemplatesProvider = mockProvider.Object;
mockLimitationService = new Mock <ILicenseLimitationsService> ();
countLimitationVM = new CountLimitationVM()
{
Model = new CountLicenseLimitation {
RegisterName = LongoMatchCountLimitedObjects.Team.ToString(),
Enabled = true,
Maximum = 2
}
};
mockLimitationService.Setup(x => x.Get <CountLimitationVM> (It.IsAny <string> ())).Returns(countLimitationVM);
App.Current.LicenseLimitationsService = mockLimitationService.Object;
controller = new TeamsController();
}
public async Task LoadState_NoLimited_ListAllDashboardsAndTeams()
{
CountLimitationVM countLimitation = new CountLimitationVM {
Model = new CountLicenseLimitation {
Enabled = false,
Maximum = 3
}
};
mockLimitationService.Setup(ls => ls.CreateBarChartVM(It.IsAny <string> (), -1, null)).Returns(
new CountLimitationBarChartVM {
Limitation = countLimitation
}
);
await state.LoadState(null);
Assert.AreEqual(teams.Count, state.ViewModel.Teams.ViewModels.Count);
Assert.AreEqual(dashboards.Count, state.ViewModel.Dashboards.ViewModels.Count);
}
public void OneWayPropertyBinding_RemovedSourceAfterTrigger_Unbinded()
{
// Arrange
CountLimitationVM source = new CountLimitationVM {
Model = new CountLicenseLimitation {
DisplayName = "source",
RegisterName = "source",
Count = 1,
Maximum = 5,
Enabled = true
}
};
CountLimitationVM destination = new CountLimitationVM {
Model = new CountLicenseLimitation {
DisplayName = "destination",
RegisterName = "destination",
Count = 0,
Maximum = 0,
Enabled = false
}
};
var binding = new OneWayPropertyBinding <int, int> (destination,
(vm) => ((CountLimitationVM)vm).Count,
(vm) => ((CountLimitationVM)vm).Count);
// Act
binding.ViewModel = source;
source.Count = 999;
binding.ViewModel = null;
source.Count = 777;
// Assert
Assert.AreEqual("destination", destination.DisplayName);
Assert.AreEqual("source", source.DisplayName);
Assert.AreEqual(null, binding.ViewModel);
Assert.AreNotEqual(source.Count, destination.Count);
Assert.AreEqual(999, destination.Count);
}
public void EnableLimitation_ViewModelsLimited_SendOneResetNotification()
{
// Arrange
var limitation = new CountLimitationVM {
Model = new CountLicenseLimitation {
Enabled = false, Maximum = 1
}
};
col.Limitation = limitation;
col.Model.AddRange(players);
col.ViewModels.CollectionChanged += HandleCollectionChanged;
// Act
limitation.Model.Enabled = true;
col.ViewModels.CollectionChanged -= HandleCollectionChanged;
// Assert
Assert.AreEqual(1, actionsNotified.Count());
Assert.AreEqual(NotifyCollectionChangedAction.Reset, actionsNotified [0]);
}
public void Delete_OneElement_SendRemoveNotification()
{
// Arrange
var limitation = new CountLimitationVM {
Model = new CountLicenseLimitation {
Enabled = false, Maximum = 1
}
};
col.Limitation = limitation;
col.Model.AddRange(players);
col.ViewModels.CollectionChanged += HandleCollectionChanged;
// Act
col.ViewModels.RemoveAt(0);
col.ViewModels.CollectionChanged -= HandleCollectionChanged;
// Assert
Assert.AreEqual(1, actionsNotified.Count());
Assert.AreEqual(NotifyCollectionChangedAction.Remove, actionsNotified [0]);
}
public void OneWayPropertyBinding_SetSource_DestinationUpdated()
{
// Arrange
CountLimitationVM source = new CountLimitationVM {
Model = new CountLicenseLimitation {
DisplayName = "source",
RegisterName = "source",
Count = 1,
Maximum = 5,
Enabled = true
}
};
CountLimitationVM destination = new CountLimitationVM {
Model = new CountLicenseLimitation {
DisplayName = "destination",
RegisterName = "destination",
Count = 0,
Maximum = 0,
Enabled = false
}
};
var binding = new OneWayPropertyBinding <int, int> (destination,
(vm) => ((CountLimitationVM)vm).Count,
(vm) => ((CountLimitationVM)vm).Count);
// Act
binding.ViewModel = source;
// Assert
Assert.AreEqual("destination", destination.DisplayName);
Assert.AreEqual("source", source.DisplayName);
Assert.AreEqual(source, binding.ViewModel);
Assert.AreEqual(source.Count, destination.Count);
Assert.AreEqual(1, destination.Count);
}
