public void InFailoverModeTests( bool failoverEntriesRecent , bool failoverEntriesThreshold , bool failoverModeEnabled ) { var failoverEntries = new List <FailoverEntry>(GenerateFailoverEntries(failoverEntriesRecent, failoverEntriesThreshold)); A.CallTo(() => _failoverRepository.GetFailOverEntries()).Returns(failoverEntries); A.CallTo(() => _configuration.IsFailoverModeEnabled).Returns(failoverModeEnabled); bool expectedResult = failoverEntriesRecent && failoverEntriesThreshold && failoverModeEnabled; var result = _sut.InFailoverMode(); Assert.AreEqual(expectedResult, result); if (failoverModeEnabled) { A.CallTo(() => _failoverRepository.GetFailOverEntries()).MustHaveHappenedOnceExactly(); } else { A.CallTo(() => _failoverRepository.GetFailOverEntries()).MustNotHaveHappened(); } }
public Learner GetLearner(int learnerId, bool isLearnerArchived) { Func <int, Learner> strategy = GetStrategy(isLearnerArchived, () => _failoverService.InFailoverMode()); return(strategy(learnerId)); }
public void GetLearnerTests( bool isLearnerArchived , bool inFailoverMode , bool learnerResponseArchived ) { var archiveLearner = new Learner(); A.CallTo(() => _archiveService.GetLearner(A <int> ._)).Returns(archiveLearner); var failoverLearner = new Learner(); var failoverLearnerResponse = new LearnerResponse { IsArchived = learnerResponseArchived, Learner = failoverLearner }; A.CallTo(() => _failoverDataService.GetLearner(A <int> ._)).Returns(failoverLearnerResponse); var liveLearner = new Learner(); var liveLearnerResponse = new LearnerResponse { IsArchived = learnerResponseArchived, Learner = liveLearner }; A.CallTo(() => _liveDataService.GetLearner(A <int> ._)).Returns(liveLearnerResponse); A.CallTo(() => _failoverService.InFailoverMode()).Returns(inFailoverMode); LearnerSource learnerSource = isLearnerArchived || learnerResponseArchived ? LearnerSource.Archive : inFailoverMode ? LearnerSource.Failover : LearnerSource.Live; bool archiveDataAccessed = isLearnerArchived || learnerResponseArchived; bool failoverDataAccessed = !isLearnerArchived && inFailoverMode; bool liveDataAccessed = !isLearnerArchived && !inFailoverMode; bool failoverServiceAccessed = !isLearnerArchived; var learner = _sut.GetLearner(1, isLearnerArchived); Learner expectedLearner; switch (learnerSource) { case LearnerSource.Archive: expectedLearner = archiveLearner; break; case LearnerSource.Failover: expectedLearner = failoverLearner; break; case LearnerSource.Live: expectedLearner = liveLearner; break; default: throw new ArgumentOutOfRangeException(nameof(learnerSource)); } Assert.AreSame(expectedLearner, learner); if (archiveDataAccessed) { A.CallTo(() => _archiveService.GetLearner(A <int> ._)).MustHaveHappenedOnceExactly(); } else { A.CallTo(() => _archiveService.GetLearner(A <int> ._)).MustNotHaveHappened(); } if (failoverDataAccessed) { A.CallTo(() => _failoverDataService.GetLearner(A <int> ._)).MustHaveHappenedOnceExactly(); } else { A.CallTo(() => _failoverDataService.GetLearner(A <int> ._)).MustNotHaveHappened(); } if (liveDataAccessed) { A.CallTo(() => _liveDataService.GetLearner(A <int> ._)).MustHaveHappenedOnceExactly(); } else { A.CallTo(() => _liveDataService.GetLearner(A <int> ._)).MustNotHaveHappened(); } if (failoverServiceAccessed) { A.CallTo(() => _failoverService.InFailoverMode()).MustHaveHappenedOnceExactly(); } else { A.CallTo(() => _failoverService.InFailoverMode()).MustNotHaveHappened(); } }