Esempio n. 1
0
            public async Task ReturnsOnlyOnceEvenWhenMultipleWorkspacesAreInaccessible()
            {
                var workspaces = new[]
                {
                    new MockWorkspace {
                        Id = 1, IsInaccessible = false
                    },
                    new MockWorkspace {
                        Id = 2, IsInaccessible = true
                    },
                    new MockWorkspace {
                        Id = 3, IsInaccessible = true
                    },
                    new MockWorkspace {
                        Id = 4, IsInaccessible = true
                    },
                };

                dataSource.Workspaces.GetAll(Arg.Any <Func <IDatabaseWorkspace, bool> >(), Arg.Is(true))
                .Returns(callInfo =>
                {
                    var predicate         = callInfo[0] as Func <IDatabaseWorkspace, bool>;
                    var filteredWorkspace = workspaces.Where(predicate);
                    return(Observable.Return(filteredWorkspace.Cast <IThreadSafeWorkspace>()));
                });

                var state      = new TrackInaccessibleWorkspacesAfterCleanUpState(dataSource, analyticsService);
                var transition = await state.Start().SingleAsync();

                transition.Result.Should().Be(state.Done);
            }
Esempio n. 2
0
        private static void configureCleanUpTransitions(
            ITransitionConfigurator transitions,
            ITimeService timeService,
            ITogglDataSource dataSource,
            IAnalyticsService analyticsService,
            StateResult entryPoint)
        {
            var deleteOlderEntries = new DeleteOldTimeEntriesState(timeService, dataSource.TimeEntries);
            var deleteUnsnecessaryProjectPlaceholders = new DeleteUnnecessaryProjectPlaceholdersState(dataSource.Projects, dataSource.TimeEntries);

            var checkForInaccessibleWorkspaces = new CheckForInaccessibleWorkspacesState(dataSource);

            var deleteInaccessibleTimeEntries = new DeleteInaccessibleTimeEntriesState(dataSource.TimeEntries);
            var deleteInaccessibleTags        = new DeleteNonReferencedInaccessibleTagsState(dataSource.Tags, dataSource.TimeEntries);
            var deleteInaccessibleTasks       = new DeleteNonReferencedInaccessibleTasksState(dataSource.Tasks, dataSource.TimeEntries);
            var deleteInaccessibleProjects    = new DeleteNonReferencedInaccessibleProjectsState(dataSource.Projects, dataSource.Tasks, dataSource.TimeEntries);
            var deleteInaccessibleClients     = new DeleteNonReferencedInaccessibleClientsState(dataSource.Clients, dataSource.Projects);
            var deleteInaccessibleWorkspaces  = new DeleteNonReferencedInaccessibleWorkspacesState(
                dataSource.Workspaces,
                dataSource.TimeEntries,
                dataSource.Projects,
                dataSource.Tasks,
                dataSource.Clients,
                dataSource.Tags);

            var trackInaccesssibleDataAfterCleanUp       = new TrackInaccessibleDataAfterCleanUpState(dataSource, analyticsService);
            var trackInaccesssibleWorkspacesAfterCleanUp = new TrackInaccessibleWorkspacesAfterCleanUpState(dataSource, analyticsService);

            transitions.ConfigureTransition(entryPoint, deleteOlderEntries);
            transitions.ConfigureTransition(deleteOlderEntries.Done, deleteUnsnecessaryProjectPlaceholders);

            transitions.ConfigureTransition(deleteUnsnecessaryProjectPlaceholders.Done, checkForInaccessibleWorkspaces);
            transitions.ConfigureTransition(checkForInaccessibleWorkspaces.NoInaccessibleWorkspaceFound, new DeadEndState());
            transitions.ConfigureTransition(checkForInaccessibleWorkspaces.FoundInaccessibleWorkspaces, deleteInaccessibleTimeEntries);

            transitions.ConfigureTransition(deleteInaccessibleTimeEntries.Done, deleteInaccessibleTags);
            transitions.ConfigureTransition(deleteInaccessibleTags.Done, deleteInaccessibleTasks);
            transitions.ConfigureTransition(deleteInaccessibleTasks.Done, deleteInaccessibleProjects);
            transitions.ConfigureTransition(deleteInaccessibleProjects.Done, deleteInaccessibleClients);
            transitions.ConfigureTransition(deleteInaccessibleClients.Done, trackInaccesssibleDataAfterCleanUp);
            transitions.ConfigureTransition(trackInaccesssibleDataAfterCleanUp.Done, deleteInaccessibleWorkspaces);
            transitions.ConfigureTransition(deleteInaccessibleWorkspaces.Done, trackInaccesssibleWorkspacesAfterCleanUp);
            transitions.ConfigureTransition(trackInaccesssibleWorkspacesAfterCleanUp.Done, new DeadEndState());
        }
Esempio n. 3
0
            public async Task TracksInaccessibleWorkspaces()
            {
                var workspaces = new[] {
                    inaccessibleWorkspace,
                    accessibleWorkspace
                };

                dataSource.Workspaces.GetAll(Arg.Any <Func <IDatabaseWorkspace, bool> >(), Arg.Is(true))
                .Returns(callInfo =>
                {
                    var predicate         = callInfo[0] as Func <IDatabaseWorkspace, bool>;
                    var filteredWorkspace = workspaces.Where(predicate);
                    return(Observable.Return(filteredWorkspace.Cast <IThreadSafeWorkspace>()));
                });

                var state = new TrackInaccessibleWorkspacesAfterCleanUpState(dataSource, analyticsService);

                var transition = await state.Start();

                analyticsService.WorkspacesInaccesibleAfterCleanUp.Received().Track(1);
            }