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>()); }