public void IsInTransactionIsTrueBecauseStartTransactionHasBeenCalled() { _transactionalMock.Expect("BeginTransaction"); _session.BeginTransaction(); Assert.IsTrue(_session.IsInTransaction); _transactionalMock.Verify(); }
public void NotifyUser() { // setup notifier.Expect("NotifyUser", "joe", "Order 123 has been dispatched"); // execute orderProcessor.Process((Order)order.MockInstance); // verify notifier.Verify(); }
public void ShouldNotRunBuildIfResultShouldNotBuild() { SetupPreambleExpections(); resultMock.ExpectAndReturn("ShouldRunBuild", false); targetMock.Expect("Activity", ProjectActivity.Sleeping); IIntegrationResult returnedResult = runner.Integrate(request); Assert.AreEqual(result, returnedResult); Assert.IsTrue(Directory.Exists(result.WorkingDirectory)); Assert.IsTrue(Directory.Exists(result.ArtifactDirectory)); mockery.Verify(); }
public void CommitTransactionHappyPath() { beginTransaction(); _transactionMock.Expect("Commit"); _connectionMock.Expect("Close"); _connectionMock.ExpectAndReturn("State", ConnectionState.Open); _executionState.CommitTransaction(); _transactionMock.Verify(); _connectionMock.Verify(); }
public void SavingCurrentIntegrationShouldSetItToLastIntegrationResult() { IIntegrationResult lastResult = new IntegrationResult(); ExpectToLoadState(lastResult); IIntegrationResult expected = manager.StartNewIntegration(ModificationExistRequest()); Assert.AreEqual(lastResult, manager.LastIntegrationResult); mockStateManager.Expect("SaveState", expected); manager.FinishIntegration(); Assert.AreEqual(expected, manager.LastIntegrationResult); }
public void WhenThereIsAModificationWithinTheDelayPeriodSleepsUntilTheEndOfThePeriodAndTriesAgain() { quietPeriod.ModificationDelaySeconds = 45; // last build was at 12:01:00, current build is at 12:02:00, modification at 12:01:30 mockSourceControl.ExpectAndReturn("GetModifications", mods, lastBuild, thisBuild); mockDateTimeProvider.Expect("Sleep", TimeSpan.FromSeconds(15)); mockDateTimeProvider.ExpectAndReturn("Now", CreateDateTime(12, 02, 15)); mockSourceControl.ExpectAndReturn("GetModifications", mods, lastBuild, IntegrationResultMother.CreateSuccessful(CreateDateTime(12, 02, 15))); Modification[] actualMods = quietPeriod.GetModifications((ISourceControl)mockSourceControl.MockInstance, lastBuild, thisBuild); Assert.AreEqual(mods, actualMods); }
public void ExecuteHappyPath() { _commandMock.Expect("Connection", _connection); _commandMock.ExpectAndReturn("ExecuteNonQuery", 1); _commandMock.Expect("Connection", new IsNull()); _connectionMock.Strict = true; // no calls to connection. int recordCount = _executionState.Execute((IDbCommand)_commandMock.MockInstance); Assert.AreEqual(1, recordCount); _commandMock.Verify(); _connectionMock.Verify(); }
public static StringWriter SwitchWriterToStringWriter(this IMock <ViewContext> mockViewContext) { StringWriter writer = new StringWriter(); mockViewContext.Expect(c => c.Writer).Returns(writer); return(writer); }
public void ShouldPlotChartForAvailableStatistics() { mockPlotter.Expect("DrawGraph", new IsAnything(), new IsAnything(), new IsAnything()); mockPlotter.ExpectNoCall("WriteToStream", typeof(IList), typeof(IList), typeof(Stream)); chartGenerator.RelevantStats = new string[]{"TestCount"}; chartGenerator.Process(statistics, "dummy"); }
public void ExecuteHappyPath() { _connectionMock.Expect("Open"); _commandMock.Expect("Connection", _connectionMock.MockInstance); _commandMock.ExpectAndReturn("ExecuteNonQuery", 1); _commandMock.Expect("Connection", new IsNull()); _connectionMock.Expect("Close"); IDbCommand command = (IDbCommand)_commandMock.MockInstance; int recordCount = _executionState.Execute(command); Assert.AreEqual(1, recordCount); _commandMock.Verify(); _connectionMock.Verify(); }
public static StringBuilder SwitchResponseMockOutputToStringBuilder(this IMock <HttpResponseBase> responseMock) { var sb = new StringBuilder(); responseMock.Expect(response => response.Write(It.IsAny <string>())).Callback <string>(output => sb.Append(output)); return(sb); }
private void View(IMock <IStory> story) { var user = new Mock <IUser>(); story.Expect(s => s.View(It.IsAny <DateTime>(), It.IsAny <string>())).Verifiable(); _userScoreService.Expect(us => us.StoryViewed(It.IsAny <IStory>(), It.IsAny <IUser>())).Verifiable(); _storyService.View(story.Object, user.Object, "192.168.0.1"); }
public void ShouldCreateWorkingDirectoryIfItDoesntExistOrIsNotARepository() { hg = new Mercurial((IHistoryParser)mockHistoryParser.MockInstance, (ProcessExecutor)mockProcessExecutor.MockInstance, (IFileSystem)mockFileSystem.MockInstance, (IFileDirectoryDeleter)mockFileDirectoryDeleter.MockInstance); hg.WorkingDirectory = tempWorkDir; hg.Repository = @"C:\foo"; mockFileSystem.Expect("EnsureFolderExists", tempWorkDir); mockFileSystem.Expect("EnsureFolderExists", tempHgDir); mockFileSystem.ExpectAndReturn("DirectoryExists", true, tempWorkDir); mockFileSystem.ExpectAndReturn("DirectoryExists", false, tempHgDir); mockFileDirectoryDeleter.Expect("DeleteIncludingReadOnlyObjects", new object[] { tempWorkDir }); mockFileSystem.ExpectAndReturn("DirectoryExists", false, tempWorkDir); ExpectToExecuteArguments(@"init " + StringUtil.AutoDoubleQuoteString(tempWorkDir), Directory.GetParent(Path.GetFullPath(tempWorkDir)).FullName); ExpectToExecuteArguments(@"pull C:\foo", tempWorkDir); hg.GetModifications(IntegrationResult(from), IntegrationResult(to)); }
public void ShouldStillPublishResultsIfPrebuildThrowsException() { SetupPreambleExpections(); resultMock.ExpectAndReturn("ShouldRunBuild", true); resultMock.ExpectAndReturn("LastIntegrationStatus", IntegrationStatus.Success); targetMock.Expect("Activity", ProjectActivity.Building); sourceControlMock.Expect("GetSource", result); targetMock.ExpectAndThrow("Prebuild", new CruiseControlException("expected exception"), result); resultMock.Expect("ExceptionResult"); resultMock.Expect("MarkEndTime"); targetMock.Expect("Activity", ProjectActivity.Sleeping); resultMock.ExpectAndReturn("EndTime", endTime); resultMock.ExpectAndReturn("Status", IntegrationStatus.Exception); targetMock.Expect("PublishResults", result); resultManagerMock.Expect("FinishIntegration"); runner.Integrate(ModificationExistRequest()); mockery.Verify(); }
public void FailWhenMockedMethodNotVirtual() { try { full.Expect("Bar", "test"); Fail(); } catch (ArgumentException e) { AssertEquals("Method <Bar> is not virtual", e.Message); } }
public void ExpectWithMissingMethod() { try { empty.Expect("Foo"); Fail(); } catch (MissingMethodException e) { AssertEquals("method <Foo> not defined", e.Message); } }
public void ShouldWriteOutModificationsToFileAsXml() { mockIO.Expect("Save", @"artifactDir\modifications.xml", new IsValidXml().And(new HasChildElements(2))); IntegrationResult result = IntegrationResultMother.CreateSuccessful(); result.ArtifactDirectory = "artifactDir"; result.Modifications = new Modification[] { ModificationMother.CreateModification("foo.txt", @"c\src"), ModificationMother.CreateModification("bar.txt", @"c\src") }; task.Run(result); }
public void can_make_partial_mocks() { var moqFactory = new MoqFactory(); var testPartials = (TestPartials)moqFactory.CreateMockThatCallsBase(typeof(TestPartials), new object[0]); testPartials.ShouldNotBeNull(); testPartials.Concrete().ShouldEqual("Concrete"); testPartials.Virtual().ShouldEqual("Virtual"); IMock <TestPartials> mock = Mock.Get(testPartials); mock.Expect(t => t.Virtual()).Returns("MOQed!"); testPartials.Virtual().ShouldEqual("MOQed!"); }
public void DisposeControllerFactoryWithDisposableController() { // Arrange IControllerFactory factory = new DefaultControllerFactory(); Mock <ControllerBase> mockController = new Mock <ControllerBase>(); IMock <IDisposable> mockDisposable = mockController.As <IDisposable>(); mockDisposable.Expect(d => d.Dispose()).Verifiable(); // Act factory.ReleaseController(mockController.Object); // Assert mockDisposable.Verify(); }
private void SpamComment(IMock <IStory> story) { var postedBy = new Mock <IUser>(); var comment = new Mock <IComment>(); comment.ExpectGet(c => c.ByUser).Returns(postedBy.Object); comment.ExpectGet(c => c.ForStory).Returns(story.Object); story.Expect(s => s.DeleteComment(It.IsAny <IComment>())).Verifiable(); _userScoreService.Expect(us => us.CommentSpammed(It.IsAny <IUser>())).Verifiable(); _emailSender.Expect(es => es.NotifyConfirmSpamComment(It.IsAny <string>(), It.IsAny <IComment>(), It.IsAny <IUser>())).Verifiable(); var byUser = new Mock <IUser>(); _storyService.Spam(comment.Object, "http://dotnetshoutout.com/Dummy-Story", byUser.Object); }
public void ShouldCloneAndDeleteWorkingDirIfGitDirectoryDoesNotExist() { mockFileSystem.ExpectAndReturn("DirectoryExists", true, DefaultWorkingDirectory); mockFileSystem.ExpectAndReturn("DirectoryExists", false, Path.Combine(DefaultWorkingDirectory, ".git")); mockFileDirectoryDeleter.Expect("DeleteIncludingReadOnlyObjects", DefaultWorkingDirectory); mockFileSystem.ExpectAndReturn("DirectoryExists", false, DefaultWorkingDirectory); ExpectCloneAndInitialiseRepository(); ExpectToExecuteArguments(GIT_LOG_REMOTE_COMMITS); ExpectLogRemoteHead(TO_COMMIT); mockHistoryParser.ExpectAndReturn("Parse", new Modification[] { }, new IsAnything(), new IsAnything(), new IsAnything()); IIntegrationResult to = IntegrationResult(); git.GetModifications(IntegrationResult(FROM_COMMIT), to); AssertIntegrationResultTaggedWithCommit(to, TO_COMMIT); }
[Test] public void CallMethodIsCalled() { mock.Expect("NoArgs"); thingy.NoArgs(); mock.Verify(); }
public void ShouldDelegateIntegrationCompletedCallToInnerTrigger() { mockTrigger.Expect("IntegrationCompleted"); trigger.IntegrationCompleted(); }