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