public async Task DeletesUnreferencedClientsInInaccessibleWorkspaces()
{
var accessibleWorkspace = new MockWorkspace(1000, isInaccessible: false);
var inaccessibleWorkspace = new MockWorkspace(2000, isInaccessible: true);
var client1 = new MockClient(1001, accessibleWorkspace, SyncStatus.InSync);
var client2 = new MockClient(1002, accessibleWorkspace, SyncStatus.SyncNeeded);
var client3 = new MockClient(2001, inaccessibleWorkspace, SyncStatus.SyncNeeded);
var client4 = new MockClient(2002, inaccessibleWorkspace, SyncStatus.InSync);
var project1 = new MockProject(101, accessibleWorkspace, client1, syncStatus: SyncStatus.InSync);
var project2 = new MockProject(102, accessibleWorkspace, client2, syncStatus: SyncStatus.InSync);
var project3 = new MockProject(201, inaccessibleWorkspace, client3, syncStatus: SyncStatus.InSync);
var clients = new[] { client1, client2, client3, client4 };
var projects = new[] { project1, project2, project3 };
var unreferencedClients = new[] { client4 };
var neededClients = clients.Where(client => !unreferencedClients.Contains(client));
configureDataSource(clients, projects);
await state.Start().SingleAsync();
clientsDataSource.Received().DeleteAll(Arg.Is <IEnumerable <IThreadSafeClient> >(arg =>
arg.All(client => unreferencedClients.Contains(client)) &&
arg.None(client => neededClients.Contains(client))));
}
public async Task ReturnsNullIfTheWorkspaceIsNotPro(bool billableByDefault)
{
const long workspaceId = 11;
var workspace = new MockWorkspace {
ProjectsBillableByDefault = billableByDefault
};
var feature = new MockWorkspaceFeature {
Enabled = false, FeatureId = WorkspaceFeatureId.Pro
};
var featureCollection = new MockWorkspaceFeatureCollection {
Features = new[] { feature }
};
Database.WorkspaceFeatures
.GetById(workspaceId)
.Returns(Observable.Return(featureCollection));
Database.Workspaces
.GetById(workspaceId)
.Returns(Observable.Return(workspace));
var projectsAreBillableByDefault =
await InteractorFactory.AreProjectsBillableByDefault(workspaceId).Execute();
projectsAreBillableByDefault.Should().Be(null);
}
public async Task IsSetToTrueWhenTheUserSelectsAWorkspaceInWhichTheyAreNotAdmins()
{
var mockWorkspace = new MockWorkspace {
Admin = false
};
var interactor = Substitute.For <IInteractor <IObservable <IThreadSafeWorkspace> > >();
interactor.Execute().Returns(Observable.Return(mockWorkspace));
InteractorFactory.GetWorkspaceById(Arg.Is(1L)).Returns(interactor);
View.Select(
Arg.Any <string>(),
Arg.Any <IEnumerable <SelectOption <IThreadSafeWorkspace> > >(),
Arg.Any <int>())
.Returns(Observable.Return(new MockWorkspace {
Id = 1L
}));
ViewModel.CanCreatePublicProjects.Subscribe();
ViewModel.IsPrivate.Accept(false);
var awaitable = ViewModel.PickWorkspace.ExecuteWithCompletion(Unit.Default);
TestScheduler.Start();
await awaitable;
ViewModel.IsPrivate.Value.Should().BeTrue();
}
public async ThreadingTask UpdatesTheInaccessibleRunningTimeEntry()
{
var workspace = new MockWorkspace(1, isInaccessible: true);
var start = now.AddHours(-2);
var duration = (long)(now - start).TotalSeconds;
var timeEntries = new List <IDatabaseTimeEntry>
{
new MockTimeEntry(33, workspace, start: start),
new MockTimeEntry(11, workspace, start: start, duration: duration),
new MockTimeEntry(22, workspace, start: start, duration: duration),
};
DataSource
.TimeEntries
.GetAll(Arg.Any <Func <IDatabaseTimeEntry, bool> >(), Arg.Is(true))
.Returns(callInfo =>
Observable
.Return(timeEntries)
.Select(x => x.Where(callInfo.Arg <Func <IDatabaseTimeEntry, bool> >()).Cast <IThreadSafeTimeEntry>()));
await interactor.Execute();
await DataSource.Received().TimeEntries.Update(Arg.Is <IThreadSafeTimeEntry>(te => te.IsInaccessible == true));
}
public async Task DeleteProjectsUnreferencedByTimeEntriesInInaccessibleWorkspace()
{
var accessibleWorkspace = new MockWorkspace(1000, isInaccessible: false);
var inaccessibleWorkspace = new MockWorkspace(2000, isInaccessible: true);
var project1 = new MockProject(101, accessibleWorkspace, syncStatus: SyncStatus.InSync);
var project2 = new MockProject(102, accessibleWorkspace, syncStatus: SyncStatus.RefetchingNeeded);
var project3 = new MockProject(201, inaccessibleWorkspace, syncStatus: SyncStatus.InSync);
var project4 = new MockProject(202, inaccessibleWorkspace, syncStatus: SyncStatus.SyncNeeded);
var project5 = new MockProject(203, inaccessibleWorkspace, syncStatus: SyncStatus.SyncNeeded);
var project6 = new MockProject(204, inaccessibleWorkspace, syncStatus: SyncStatus.InSync);
var project7 = new MockProject(205, inaccessibleWorkspace, syncStatus: SyncStatus.InSync);
var te1 = new MockTimeEntry(10001, accessibleWorkspace, project: project1, syncStatus: SyncStatus.InSync);
var te2 = new MockTimeEntry(10002, accessibleWorkspace, project: project2, syncStatus: SyncStatus.SyncNeeded);
var te3 = new MockTimeEntry(20001, inaccessibleWorkspace, project: project3, syncStatus: SyncStatus.InSync);
var te4 = new MockTimeEntry(20002, inaccessibleWorkspace, project: project4, syncStatus: SyncStatus.SyncNeeded);
var te5 = new MockTimeEntry(20003, inaccessibleWorkspace, project: project4, syncStatus: SyncStatus.SyncFailed);
var te6 = new MockTimeEntry(20004, inaccessibleWorkspace, project: project4, syncStatus: SyncStatus.InSync);
var projects = new[] { project1, project2, project3, project4, project5, project6, project7 };
var tasks = new IThreadSafeTask[] { };
var timeEntries = new[] { te1, te2, te3, te4, te5, te6 };
var unreferencedProjects = new[] { project6, project7 };
var neededProjects = projects.Where(project => !unreferencedProjects.Contains(project));
configureDataSource(projects, tasks, timeEntries);
await state.Start().SingleAsync();
projectsDataSource.Received().DeleteAll(Arg.Is <IEnumerable <IThreadSafeProject> >(arg =>
arg.All(project => unreferencedProjects.Contains(project)) &&
arg.None(project => neededProjects.Contains(project))));
}
public void AddForReasonShowsTheAddCustomerToQueueView()
{
TestableRootWorkItem workItem = new TestableRootWorkItem();
workItem.Services.AddNew <MockMessageBoxService, IMessageBoxService>();
MockWorkspace workspace = workItem.Workspaces.AddNew <MockWorkspace>(WorkspaceNames.ModalWindows);
MockFindCustomerResultsView view = workItem.SmartParts.AddNew <MockFindCustomerResultsView>();
WorkspaceLocatorService locatorService =
workItem.Services.AddNew <WorkspaceLocatorService, IWorkspaceLocatorService>();
MockCustomerQueueService queueService = workItem.Services.AddNew <MockCustomerQueueService, ICustomerQueueService>();
Customer customer = new Customer();
Customer[] response = new Customer[] { customer };
workItem.Items.Add(response, "FindCustomerResponse");
workspace.Show(view);
FindCustomerResultsViewPresenter presenter = workItem.Items.AddNew <FindCustomerResultsViewPresenter>();
presenter.View = view;
presenter.AddReasonForVisit(customer);
Assert.IsTrue(CollectionUtilities.ContainsOneOf(workspace.SmartParts, typeof(IAddVisitorToQueueView)));
}
protected CalendarViewModelTest()
{
CalendarInteractor = Substitute.For <IInteractor <IObservable <IEnumerable <CalendarItem> > > >();
var workspace = new MockWorkspace {
Id = DefaultWorkspaceId
};
var timeEntry = new MockTimeEntry {
Id = TimeEntryId
};
TimeService.CurrentDateTime.Returns(Now);
InteractorFactory
.GetCalendarItemsForDate(Arg.Any <DateTime>())
.Returns(CalendarInteractor);
InteractorFactory
.GetDefaultWorkspace()
.Execute()
.Returns(Observable.Return(workspace));
InteractorFactory
.CreateTimeEntry(Arg.Any <ITimeEntryPrototype>())
.Execute()
.Returns(Observable.Return(timeEntry));
InteractorFactory
.UpdateTimeEntry(Arg.Any <EditTimeEntryDto>())
.Execute()
.Returns(Observable.Return(timeEntry));
}
public async Task GetsAllChangesToWorkspaces()
{
var createSubject = new Subject <IThreadSafeWorkspace>();
DataSource.Workspaces.Created.Returns(createSubject.AsObservable());
DataSource.Workspaces.Updated.Returns(Observable.Never <EntityUpdate <IThreadSafeWorkspace> >());
DataSource.Workspaces.Deleted.Returns(Observable.Never <long>());
var workspaces = Enumerable.Range(0, 10)
.Select(id => new MockWorkspace {
Id = id
});
DataSource.Workspaces.GetAll().Returns(Observable.Return(workspaces));
var testScheduler = new TestScheduler();
var observer = testScheduler.CreateObserver <IEnumerable <IThreadSafeWorkspace> >();
InteractorFactory.ObserveAllWorkspaces().Execute()
.Subscribe(observer);
var mockWorkspace = new MockWorkspace {
Id = 42
};
var newWorkspaces = workspaces.Append(mockWorkspace);
DataSource.Workspaces.GetAll().Returns(Observable.Return(newWorkspaces));
createSubject.OnNext(mockWorkspace);
observer.Messages.Should().HaveCount(2);
observer.Messages.First().Value.Value.Should().BeEquivalentTo(workspaces);
observer.LastEmittedValue().Should().BeEquivalentTo(newWorkspaces);
}
public async Task OnlyDeletesSyncedInaccessibleTimeEntries()
{
var workspaceA = new MockWorkspace(1000, isInaccessible: true);
var workspaceB = new MockWorkspace(2000, isInaccessible: true);
var workspaceC = new MockWorkspace(3000, isInaccessible: false);
var syncedInaccessibleTimeEntries = getSyncedTimeEntries(workspaceA)
.Concat(getSyncedTimeEntries(workspaceB));
var undeletableTimeEntries = getUnsyncedTimeEntries(workspaceA)
.Concat(getUnsyncedTimeEntries(workspaceB))
.Concat(getSyncedTimeEntries(workspaceC))
.Concat(getUnsyncedTimeEntries(workspaceC));
var allTimeEntries = syncedInaccessibleTimeEntries.Concat(undeletableTimeEntries);
configureDataSource(allTimeEntries);
await state.Start().SingleAsync();
dataSource
.Received()
.DeleteAll(Arg.Is <IEnumerable <IThreadSafeTimeEntry> >(
arg => arg.All(te => syncedInaccessibleTimeEntries.Contains(te)) &&
arg.None(te => undeletableTimeEntries.Contains(te))));
}
public async Task DeleteUnreferencedTagsInInaccessibleWorkspace()
{
var accessibleWorkspace = new MockWorkspace(1000);
var inaccessibleWorkspace = new MockWorkspace(2000, isInaccessible: true);
var tag1 = new MockTag(1001, accessibleWorkspace);
var tag2 = new MockTag(1002, accessibleWorkspace, SyncStatus.SyncFailed);
var tag3 = new MockTag(1003, accessibleWorkspace, SyncStatus.RefetchingNeeded);
var tag4 = new MockTag(2001, inaccessibleWorkspace);
var tag5 = new MockTag(2002, inaccessibleWorkspace, SyncStatus.SyncNeeded);
var tag6 = new MockTag(2003, inaccessibleWorkspace, SyncStatus.RefetchingNeeded);
var tag7 = new MockTag(2004, inaccessibleWorkspace);
var tag8 = new MockTag(2005, inaccessibleWorkspace);
var te1 = new MockTimeEntry(10001, accessibleWorkspace, tags: new[] { tag1 });
var te2 = new MockTimeEntry(10002, accessibleWorkspace, tags: new[] { tag2 });
var te3 = new MockTimeEntry(20001, inaccessibleWorkspace, tags: new[] { tag4 });
var te4 = new MockTimeEntry(20002, inaccessibleWorkspace, tags: new[] { tag5 });
var tags = new[] { tag1, tag2, tag3, tag4, tag5, tag6, tag7, tag8 };
var timeEntries = new[] { te1, te2, te3, te4 };
var unreferencedTags = new[] { tag7, tag8 };
var neededTags = tags.Where(tag => !unreferencedTags.Contains(tag));
configureDataSource(tags, timeEntries);
await state.Start().SingleAsync();
tagsDataSource.Received().DeleteAll(Arg.Is <IEnumerable <IThreadSafeTag> >(arg =>
arg.All(tag => unreferencedTags.Contains(tag)) &&
arg.None(tag => neededTags.Contains(tag))));
}
public async Task ShouldChangeCurrentWorkspaceName()
{
TimeService.CurrentDateTime.Returns(DateTimeOffset.Now);
var observer = TestScheduler.CreateObserver <string>();
ViewModel.WorkspaceNameObservable.Subscribe(observer);
var mockWorkspace = new MockWorkspace {
Id = WorkspaceId + 1, Name = "Selected workspace"
};
DialogService.Select(Arg.Any <string>(), Arg.Any <IEnumerable <(string, IThreadSafeWorkspace)> >(), Arg.Any <int>())
.Returns(Observable.Return(mockWorkspace));
InteractorFactory.GetDefaultWorkspace().Execute().Returns(Observable.Return(mockWorkspace));
await ViewModel.Initialize();
ViewModel.SelectWorkspace.Execute();
TestScheduler.Start();
observer.Messages.AssertEqual(
ReactiveTest.OnNext(1, ""),
ReactiveTest.OnNext(2, mockWorkspace.Name)
);
}
public async Task ChecksIfTheWorkspacesBillableByDefaultPropertyIfTheWorkspaceIsPro(bool billableByDefault)
{
const long workspaceId = 11;
var workspace = new MockWorkspace {
ProjectsBillableByDefault = billableByDefault
};
var feature = new MockWorkspaceFeature {
Enabled = true, FeatureId = WorkspaceFeatureId.Pro
};
var featureCollection = new MockWorkspaceFeatureCollection {
Features = new[] { feature }
};
InteractorFactory.GetWorkspaceFeaturesById(workspaceId)
.Execute()
.Returns(Observable.Return(featureCollection));
InteractorFactory.GetWorkspaceById(workspaceId)
.Execute()
.Returns(Observable.Return(workspace));
var projectsAreBillableByDefault =
await InteractorFactory.AreProjectsBillableByDefault(workspaceId).Execute();
projectsAreBillableByDefault.Should().Be(billableByDefault);
}
public void Initialize()
{
workItem = new TestableRootWorkItem();
mockWorkspace = workItem.Workspaces.AddNew <MockWorkspace>(WorkspaceNames.ModalWindows);
mockService = workItem.Services.AddNew <MockCustomerFinderService, ICustomerFinderService>();
mockQueueService = workItem.Services.AddNew <MockCustomerQueueService, ICustomerQueueService>();
locatorService = workItem.Services.AddNew <WorkspaceLocatorService, IWorkspaceLocatorService>();
}
private IThreadSafeWorkspace setupWorkspace(int id, bool isEligibleForProjectCreation)
{
var workspace = new MockWorkspace {
Id = id, Name = "ws", Admin = false, OnlyAdminsMayCreateProjects = !isEligibleForProjectCreation
};
InteractorFactory.GetAllWorkspaces().Execute().Returns(Observable.Return(new[] { workspace }));
return(workspace);
}
public void Initialize()
{
workItem = new TestableRootWorkItem();
workItem.Services.AddNew <WorkspaceLocatorService, IWorkspaceLocatorService>();
finderService = workItem.Services.AddNew <MockCustomerFinderService, ICustomerFinderService>();
queueService = workItem.Services.AddNew <MockCustomerQueueService, ICustomerQueueService>();
currentEntryService = workItem.Services.AddNew <Mocks.MockCurrentQueueEntryService, ICurrentQueueEntryService>();
workspace = workItem.Workspaces.AddNew <MockWorkspace>(WorkspaceNames.ModalWindows);
}
public void ShowWithNoSPIAndNoWorkItemSetCreatesNew()
{
MockWorkspace ws = new MockWorkspace();
ws.Show(new MockSP());
Assert.AreEqual(1, ws.ShowCalls);
Assert.IsNotNull(ws.LastSPI);
}
public void ResolveToProviderIfNoWorkItem()
{
MockSPI spi = new MockSPI();
MockSPProvider sp = new MockSPProvider(spi);
MockWorkspace ws = new MockWorkspace();
ws.Show(sp);
Assert.AreSame(spi, ws.LastSPI);
}
public void Initialize()
{
workItem = new TestableRootWorkItem();
workItem.Services.AddNew <WorkspaceLocatorService, IWorkspaceLocatorService>();
mockWorkspace = workItem.Workspaces.AddNew <MockWorkspace>(WorkspaceNames.ModalWindows);
queueService = workItem.Services.AddNew <MockCustomerQueueService, ICustomerQueueService>();
mockView = workItem.SmartParts.AddNew <MockAddVisitorToQueueView>();
presenter = workItem.Items.AddNew <AddVisitorToQueueViewPresenter>();
mockWorkspace.Show(mockView);
presenter.View = mockView;
}
public async Task ReturnsTheWorkspaceWithPassedId()
{
const long workspaceId = 10;
var workspace = new MockWorkspace();
DataSource.Workspaces.GetById(workspaceId).Returns(Observable.Return(workspace));
var returnedWorkspace = await InteractorFactory.GetWorkspaceById(workspaceId).Execute();
returnedWorkspace.Should().BeSameAs(workspace);
}
public void Initialize()
{
workItem = new TestableRootWorkItem();
queueService = workItem.Services.AddNew <MockCustomerQueueService, ICustomerQueueService>();
workItem.Services.AddNew <MockCustomerFinderService, ICustomerFinderService>();
currentEntryService = workItem.Services.AddNew <MockCurrentQueueEntryService, ICurrentQueueEntryService>();
workspace = workItem.Workspaces.AddNew <MockWorkspace>(WorkspaceNames.BranchSystemsWorkspace);
presenter = workItem.Items.AddNew <OfficerPanelViewPresenter>();
view = workItem.Items.AddNew <MockOfficerOperationsView>();
presenter.View = view;
}
public async Task ReturnsFalseIfNoWorkspaceIsEligible()
{
var workspace = new MockWorkspace {
Id = 1, Name = "ws", Admin = false, OnlyAdminsMayCreateProjects = true
};
InteractorFactory.GetAllWorkspaces().Execute().Returns(Observable.Return(new[] { workspace }));
await ViewModel.Initialize();
ViewModel.SuggestCreation.Should().BeFalse();
}
public async Task ChangesUsersDefaultWorkspace()
{
var workspace = new MockWorkspace {
Id = 123456
};
DataSource.Workspaces.Create(Arg.Any <IThreadSafeWorkspace>()).Returns(Observable.Return(workspace));
var interactor = InteractorFactory.CreateDefaultWorkspace();
await interactor.Execute();
await DataSource.User.Received().Update(Arg.Is <IThreadSafeUser>(
user => user.DefaultWorkspaceId == workspace.Id));
}
public async Task ReturnsTrueIfTheTextIsValid()
{
var workspace = new MockWorkspace {
Id = 1, Name = "ws", Admin = true
};
InteractorFactory.GetAllWorkspaces().Execute().Returns(Observable.Return(new[] { workspace }));
await ViewModel.Initialize();
ViewModel.Text = "playing bongo";
ViewModel.SuggestCreation.Should().BeTrue();
}
public async Task ReturnsTrueEvenIfAProjectWithSameNameExist()
{
var workspace = new MockWorkspace {
Id = 1, Name = "ws", Admin = true
};
InteractorFactory.GetAllWorkspaces().Execute().Returns(Observable.Return(new[] { workspace }));
await ViewModel.Initialize();
ViewModel.Text = name;
ViewModel.SuggestCreation.Should().BeTrue();
}
public void TestDeleteDocument()
{
//Given
using (var space = new MockWorkspace())
{
var doc = space.CreateDocument("MyClass.cs");
//When
space.DeleteDocument(doc.FullName);
//Then
Assert.False(doc.Exists);
Assert.Throws <InvalidOperationException>(() => doc.OpenRead());
}
}
public void SmartPartShowInChildWorkItemParentWorkspaceUsesChildSmartPartInfo()
{
WorkItem workItemA = new TestableRootWorkItem();
WorkItem workItemB = workItemA.WorkItems.AddNew <WorkItem>();
MockSP sp = new MockSP();
MockSPI spi = new MockSPI("Title", "Description");
MockWorkspace workspace = workItemA.Workspaces.AddNew <MockWorkspace>();
workItemB.RegisterSmartPartInfo(sp, spi);
workspace.Show(sp);
Assert.AreSame(spi, workspace.LastSPI);
}
public void TestDocumentAddedEvent()
{
//Given
var addedItem = (Document)null;
using (var space = new MockWorkspace())
{
space.Documents.ItemsAdded += d => addedItem = d.Single();
//When
space.CreateDocument("MyClass.cs");
//Then
Assert.Equal("MyClass.cs", addedItem.Name);
}
}
public async Task ReturnsUsersDefaultWorkspace()
{
const long workspaceId = 11;
var workspace = new MockWorkspace {
Id = workspaceId
};
var user = new MockUser {
DefaultWorkspaceId = workspaceId
};
DataSource.User.Get().Returns(Observable.Return(user));
DataSource.Workspaces.GetById(workspaceId).Returns(Observable.Return(workspace));
var defaultWorkspace = await InteractorFactory.GetDefaultWorkspace().Execute();
defaultWorkspace.Should().BeEquivalentTo(workspace, options => options.IncludingProperties());
}
public void SmartPartInfoIsRemovedWhenChildWorkItemIsDisposed()
{
WorkItem workItemA = new TestableRootWorkItem();
WorkItem workItemB = workItemA.WorkItems.AddNew <WorkItem>();
MockSP sp = new MockSP();
MockSPI spi = new MockSPI("Title", "Description");
MockWorkspace workspace = workItemA.Workspaces.AddNew <MockWorkspace>();
workItemB.RegisterSmartPartInfo(sp, spi);
workItemB.Dispose();
workspace.Show(sp);
Assert.IsFalse(spi == workspace.LastSPI);
}
public async Task ShouldNotTriggerAReportReloadWhenTheSameWorkspaceIsSelected()
{
TimeService.CurrentDateTime.Returns(DateTimeOffset.Now);
await ViewModel.Initialize();
var mockWorkspace = new MockWorkspace {
Id = WorkspaceId
};
DialogService.Select(Arg.Any <string>(), Arg.Any <IEnumerable <(string, IThreadSafeWorkspace)> >(), Arg.Any <int>())
.Returns(Observable.Return <IThreadSafeWorkspace>(mockWorkspace));
ViewModel.SelectWorkspace.Execute();
TestScheduler.Start();
InteractorFactory.DidNotReceive().GetProjectSummary(Arg.Any <long>(), Arg.Any <DateTimeOffset>(),
Arg.Any <DateTimeOffset>());
}
