public void StartCruiseServerProject()
{
ConsoleRunnerArguments consoleArgs = new ConsoleRunnerArguments();
Mock mockCruiseServer = new DynamicMock(typeof(ICruiseServer));
mockCruiseServer.Expect("Start");
mockCruiseServer.Expect("WaitForExit");
Mock mockCruiseServerFactory = new DynamicMock(typeof(ICruiseServerFactory));
mockCruiseServerFactory.ExpectAndReturn("Create", mockCruiseServer.MockInstance, consoleArgs.UseRemoting, consoleArgs.ConfigFile);
new ConsoleRunner(consoleArgs, (ICruiseServerFactory)mockCruiseServerFactory.MockInstance).Run();
mockCruiseServer.Verify();
}
public void SetupAndTeardownRemotingInfrastructure()
{
string configFile = CreateTemporaryConfigurationFile();
IMock mockCruiseManager = new RemotingMock(typeof (ICruiseManager));
IMock mockCruiseServer = new DynamicMock(typeof (ICruiseServer));
mockCruiseServer.ExpectAndReturn("CruiseManager", mockCruiseManager.MockInstance);
mockCruiseServer.ExpectAndReturn("CruiseManager", mockCruiseManager.MockInstance);
mockCruiseServer.Expect("Dispose");
using (new RemoteCruiseServer((ICruiseServer) mockCruiseServer.MockInstance, configFile))
{
Assert.AreEqual(2, ChannelServices.RegisteredChannels.Length);
Assert.IsNotNull(ChannelServices.GetChannel("ccnet"), "ccnet channel is missing");
Assert.IsNotNull(ChannelServices.GetChannel("ccnet2"), "ccnet2 channel is missing");
ICruiseManager remoteManager = (ICruiseManager) RemotingServices.Connect(typeof (ICruiseManager), "tcp://localhost:35354/" + RemoteCruiseServer.ManagerUri);
Assert.IsNotNull(remoteManager, "cruiseserver should be registered on tcp channel");
remoteManager = (ICruiseManager) RemotingServices.Connect(typeof (ICruiseManager), "http://localhost:35355/" + RemoteCruiseServer.ManagerUri);
Assert.IsNotNull(remoteManager, "cruiseserver should be registered on http channel");
}
Assert.AreEqual(0, ChannelServices.RegisteredChannels.Length, "all registered channels should be closed.");
mockCruiseServer.Verify();
mockCruiseManager.Verify();
}
public void AdjustScrollRange()
{
DynamicMock rootBox = new DynamicMock(typeof(IVwRootBox));
// This was taken out because it doesn't seem like the views code does this
// anymore. It just calls AdjustScrollRange for the original view that changed.
// Done as a part of TE-3576
//// result for style pane
//rootBox.ExpectAndReturn("Height", 900);
//rootBox.ExpectAndReturn("Width", 100);
//rootBox.ExpectAndReturn("Height", 1000);
//rootBox.ExpectAndReturn("Width", 100);
//rootBox.ExpectAndReturn("Height", 1000);
//rootBox.ExpectAndReturn("Width", 100);
//// result for draft pane
//rootBox.ExpectAndReturn("Height", 950);
//rootBox.ExpectAndReturn("Width", 100);
//rootBox.ExpectAndReturn("Height", 900);
//rootBox.ExpectAndReturn("Width", 100);
//rootBox.ExpectAndReturn("Height", 1000);
//rootBox.ExpectAndReturn("Width", 100);
// result for bt pane
rootBox.ExpectAndReturn("Height", 1100);
rootBox.ExpectAndReturn("Width", 100);
rootBox.ExpectAndReturn("Height", 900);
rootBox.ExpectAndReturn("Width", 100);
rootBox.ExpectAndReturn("Height", 950);
rootBox.ExpectAndReturn("Width", 100);
using (RootSiteGroup group = new RootSiteGroup())
{
DummyBasicView stylePane = new DummyBasicView();
DummyBasicView draftPane = new DummyBasicView();
DummyBasicView btPane = new DummyBasicView();
PrepareView(stylePane, 50, 300, (IVwRootBox)rootBox.MockInstance);
PrepareView(draftPane, 150, 300, (IVwRootBox)rootBox.MockInstance);
PrepareView(btPane, 150, 300, (IVwRootBox)rootBox.MockInstance);
group.AddToSyncGroup(stylePane);
group.AddToSyncGroup(draftPane);
group.AddToSyncGroup(btPane);
group.ScrollingController = btPane;
group.Controls.AddRange(new Control[] { stylePane, draftPane, btPane } );
btPane.ScrollMinSize = new Size(100, 1000);
btPane.ScrollPosition = new Point(0, 700);
// now call AdjustScrollRange on each of the panes.
// This simulates what the views code does.
// This was taken out because it doesn't seem like the views code does this
// anymore. It just calls AdjustScrollRange for the original view that changed.
// Done as a part of TE-3576
//stylePane.AdjustScrollRange(null, 0, 0, -100, 500);
//draftPane.AdjustScrollRange(null, 0, 0, -50, 500);
btPane.AdjustScrollRange(null, 0, 0, 100, 500);
Assert.AreEqual(1108, btPane.ScrollMinSize.Height, "Wrong ScrollMinSize");
Assert.AreEqual(800, -btPane.ScrollPosition.Y, "Wrong scroll position");
}
}
public void ViewManagerCreateView()
{
#region Mock intialization
DynamicMock useCase = new DynamicMock(typeof(IUseCase));
DynamicMock engine = new DynamicMock(typeof(IRegexEngine));
DynamicMock view = new DynamicMock(typeof(IRegexView));
IRegexView viewMockInstance = (IRegexView)view.MockInstance;
IUseCase useCaseMockInstance = (IUseCase)useCase.MockInstance;
IRegexEngine engineMockInstance = (IRegexEngine)engine.MockInstance;
#endregion
useCase.ExpectAndReturn("CreateNewView", viewMockInstance);
useCase.ExpectAndReturn("CreateNewEngine", engineMockInstance);
engine.Expect("AttachView", withSameObjectAs(viewMockInstance));
view.Expect("Init", withSameObjectAs(engineMockInstance));
ViewManager factory = new ViewManager();
IRegexView newView = factory.CreateView(useCaseMockInstance);
useCase.Verify();
engine.Verify();
view.Verify();
Assert.AreSame(newView, viewMockInstance,"Returned view is not the same instance as expected");
}
public void InvalidPortName()
{
Mock source = new DynamicMock(typeof(IUnmanagedSource));
source.ExpectAndReturn("CreateFile", new IntPtr(2), null, null, null, null, null, null, null, null);
source.ExpectAndReturn("GetFileType", FileType.Disk, new IntPtr(2));
UnmanagedProvider.Source = (IUnmanagedSource) source.MockInstance;
new PortStream("xpto");
source.Verify();
}
public void DefaultPowerShellShouldBe1IfNothingNewerInstalled()
{
IMock mockRegistry2 = new DynamicMock(typeof(IRegistry));
PowerShellTask task = new PowerShellTask((IRegistry)mockRegistry2.MockInstance, (ProcessExecutor)mockProcessExecutor.MockInstance);
mockRegistry2.ExpectAndReturn("GetLocalMachineSubKeyValue", null, PowerShellTask.regkeypowershell2, PowerShellTask.regkeyholder);
mockRegistry2.ExpectAndReturn("GetLocalMachineSubKeyValue", POWERSHELL1_PATH,
PowerShellTask.regkeypowershell1, PowerShellTask.regkeyholder);
Assert.AreEqual(POWERSHELL1_PATH + "\\powershell.exe", task.Executable);
mockRegistry2.Verify();
mockProcessExecutor.Verify();
}
public void ShouldDelegateForEachFileAndSeparateWithLineBreaks()
{
DynamicMock delegateMock = new DynamicMock(typeof(ITransformer));
HtmlAwareMultiTransformer transformer = new HtmlAwareMultiTransformer((ITransformer) delegateMock.MockInstance);
string input = "myinput";
delegateMock.ExpectAndReturn("Transform", @"<p>MyFirstOutput<p>", input, "xslFile1", null);
delegateMock.ExpectAndReturn("Transform", @"<p>MySecondOutput<p>", input, "xslFile2", null);
Assert.AreEqual(@"<p>MyFirstOutput<p><p>MySecondOutput<p>", transformer.Transform(input, new string[] { "xslFile1", "xslFile2" }, null));
delegateMock.Verify();
}
public void ShouldUseBuildLogTransformerToGenerateView()
{
DynamicMock buildLogTransformerMock = new DynamicMock(typeof(IBuildLogTransformer));
DynamicMock cruiseRequestMock = new DynamicMock(typeof(ICruiseRequest));
DynamicMock buildSpecifierMock = new DynamicMock(typeof(IBuildSpecifier));
DynamicMock requestStub = new DynamicMock(typeof(IRequest));
ICruiseRequest cruiseRequest = (ICruiseRequest) cruiseRequestMock.MockInstance;
IBuildSpecifier buildSpecifier = (IBuildSpecifier) buildSpecifierMock.MockInstance;
IRequest request = (IRequest) requestStub.MockInstance;
cruiseRequestMock.ExpectAndReturn("BuildSpecifier", buildSpecifier);
cruiseRequestMock.SetupResult("Request", request);
requestStub.SetupResult("ApplicationPath", "myAppPath");
Hashtable expectedXsltArgs = new Hashtable();
expectedXsltArgs["applicationPath"] = "myAppPath";
buildLogTransformerMock.ExpectAndReturn("Transform", "transformed", buildSpecifier, new string[] { @"xsl\myxsl.xsl" }, new HashtableConstraint(expectedXsltArgs), null);
XslReportBuildAction action = new XslReportBuildAction((IBuildLogTransformer) buildLogTransformerMock.MockInstance, null);
action.XslFileName = @"xsl\myxsl.xsl";
Assert.AreEqual("transformed", ((HtmlFragmentResponse)action.Execute(cruiseRequest)).ResponseFragment);
buildLogTransformerMock.Verify();
cruiseRequestMock.Verify();
buildSpecifierMock.Verify();
}
public void ShouldBeAbleToSaveProjectsThatALoaderCanLoad()
{
ExecutableTask builder = new ExecutableTask();
builder.Executable = "foo";
FileSourceControl sourceControl = new FileSourceControl();
sourceControl.RepositoryRoot = "bar";
// Setup
Project project1 = new Project();
project1.Name = "Project One";
project1.SourceControl = sourceControl;
Project project2 = new Project();
project2.Name = "Project Two";
project2.SourceControl = sourceControl;
ProjectList projectList = new ProjectList();
projectList.Add(project1);
projectList.Add(project2);
DynamicMock mockConfiguration = new DynamicMock(typeof(IConfiguration));
mockConfiguration.ExpectAndReturn("Projects", projectList);
FileInfo configFile = new FileInfo(TempFileUtil.CreateTempFile(TempFileUtil.CreateTempDir(this), "loadernet.config"));
// Execute
DefaultConfigurationFileSaver saver = new DefaultConfigurationFileSaver(new NetReflectorProjectSerializer());
saver.Save((IConfiguration) mockConfiguration.MockInstance, configFile);
DefaultConfigurationFileLoader loader = new DefaultConfigurationFileLoader();
IConfiguration configuration2 = loader.Load(configFile);
// Verify
Assert.IsNotNull (configuration2.Projects["Project One"]);
Assert.IsNotNull (configuration2.Projects["Project Two"]);
mockConfiguration.Verify();
}
public void ShouldOnlyAllowOneThreadToResolveEachType()
{
TypeToTypeMap sharedMap = new HashtableTypeMap(Hashtable.Synchronized(new Hashtable()));
DynamicMock expectedToBeUsed = new DynamicMock(typeof(ImplementationResolver));
expectedToBeUsed.ExpectAndReturn("ResolveImplementation", typeof(TestClass), typeof(TestInterface));
DynamicMock notExpectedToBeUsed = new DynamicMock(typeof(ImplementationResolver));
notExpectedToBeUsed.ExpectNoCall("ResolveImplementation", typeof(Type));
StallingImplementationResolver stallingResolver = new StallingImplementationResolver((ImplementationResolver) expectedToBeUsed.MockInstance);
ImplementationResolver resolvingResolver = new CachingImplementationResolver(
stallingResolver, sharedMap);
ImplementationResolver moochingResolver = new CachingImplementationResolver((ImplementationResolver) notExpectedToBeUsed.MockInstance, sharedMap);
ImplementationResolverRunner resolvingRunner = new ImplementationResolverRunner(resolvingResolver, typeof(TestInterface));
Thread resolvingThread = new Thread(
new ThreadStart(resolvingRunner.runResolution));
ImplementationResolverRunner moochingRunner = new ImplementationResolverRunner(moochingResolver, typeof(TestInterface));
Thread moochingThread = new Thread(
new ThreadStart(moochingRunner.runResolution));
resolvingThread.Start();
moochingThread.Start();
Thread.Sleep(500); // allow moochingThread to catch up to resolvingThread
stallingResolver.Resume();
Assert.IsTrue(resolvingThread.Join(200), "Resolving thread did not complete before timeout.");
Assert.IsTrue(moochingThread.Join(200), "Mooching thread did not complete before timeout.");
expectedToBeUsed.Verify();
notExpectedToBeUsed.Verify();
Assert.AreEqual(typeof(TestClass), resolvingRunner.implementationType);
Assert.AreEqual(typeof(TestClass), moochingRunner.implementationType);
}
public void ViewManagerCreateView()
{
DynamicMock useCase = new DynamicMock(typeof(IUseCase));
IUseCase useCaseMockInstance = (IUseCase)useCase.MockInstance;
IRegexEngine engine = new DotNetRegexEngine();
IRegexView view = new ReplaceView();
useCase.ExpectAndReturn("CreateNewView", view);
useCase.ExpectAndReturn("CreateNewEngine", engine);
ViewManager factory = new ViewManager();
IRegexView newView = factory.CreateView(useCaseMockInstance);
Form frm = (Form)newView;
frm.ShowDialog();
}
public void ShouldOnlyDisposeOnce()
{
string configFile = CreateTemporaryConfigurationFile();
IMock mockCruiseManager = new RemotingMock(typeof (ICruiseManager));
IMock mockCruiseServer = new DynamicMock(typeof (ICruiseServer));
mockCruiseServer.ExpectAndReturn("CruiseManager", mockCruiseManager.MockInstance);
mockCruiseServer.ExpectAndReturn("CruiseManager", mockCruiseManager.MockInstance);
mockCruiseServer.Expect("Dispose");
RemoteCruiseServer server = new RemoteCruiseServer((ICruiseServer) mockCruiseServer.MockInstance, configFile);
((IDisposable)server).Dispose();
mockCruiseServer.ExpectNoCall("Dispose");
((IDisposable)server).Dispose();
mockCruiseServer.Verify();
}
public void ShouldCallDelegateTransformerWithCorrectFileNames()
{
DynamicMock delegateMock = new DynamicMock(typeof(IMultiTransformer));
DynamicMock pathProviderStub = new DynamicMock(typeof(IPhysicalApplicationPathProvider));
PathMappingMultiTransformer transformer = new PathMappingMultiTransformer((IPhysicalApplicationPathProvider) pathProviderStub.MockInstance, (IMultiTransformer) delegateMock.MockInstance);
pathProviderStub.ExpectAndReturn("GetFullPathFor", @"c:\myAppPath\xslFile1", "xslFile1");
pathProviderStub.ExpectAndReturn("GetFullPathFor", @"c:\myAppPath\xslFile2", "xslFile2");
delegateMock.ExpectAndReturn("Transform", "output", "myInput", new string[] { @"c:\myAppPath\xslFile1", @"c:\myAppPath\xslFile2" }, null);
Assert.AreEqual("output", transformer.Transform("myInput", new string[] { "xslFile1", "xslFile2"}, null));
pathProviderStub.Verify();
delegateMock.Verify();
}
public void TestSimpleSmtpNegotiation()
{
SmtpServer smtpserver=new SmtpServer("localhost");
EmailMessage emailMessage=GetTestHtmlAndTextMessage();
IMock mockSmtpProxy = new DynamicMock(typeof(ISmtpProxy));
mockSmtpProxy.ExpectAndReturn("Open", new SmtpResponse(220, "welcome to the mock object server"), null);
mockSmtpProxy.ExpectAndReturn("Helo", new SmtpResponse(250, "helo"), Dns.GetHostName());
mockSmtpProxy.ExpectAndReturn("MailFrom", new SmtpResponse(250, "mail from"), emailMessage.FromAddress);
foreach (EmailAddress rcpttoaddr in emailMessage.ToAddresses)
{
mockSmtpProxy.ExpectAndReturn("RcptTo", new SmtpResponse(250, "receipt to"), rcpttoaddr);
}
mockSmtpProxy.ExpectAndReturn("Data", new SmtpResponse(354, "data open"), null);
mockSmtpProxy.ExpectAndReturn("WriteData", new SmtpResponse(250, "data"), emailMessage.ToDataString());
mockSmtpProxy.ExpectAndReturn("Quit", new SmtpResponse(221, "quit"), null);
mockSmtpProxy.Expect("Close", null);
ISmtpProxy smtpProxy= (ISmtpProxy) mockSmtpProxy.MockInstance;
smtpserver.OverrideSmtpProxy(smtpProxy);
emailMessage.Send(smtpserver);
}
public void MethodsAndPropertiesDoSimpleDelagationOntoInjectedMonitor()
{
DynamicMock mockServerMonitor = new DynamicMock(typeof (ISingleServerMonitor));
SynchronizedServerMonitor monitor = new SynchronizedServerMonitor(
(ISingleServerMonitor) mockServerMonitor.MockInstance, null);
mockServerMonitor.ExpectAndReturn("ServerUrl", @"tcp://blah/");
Assert.AreEqual(@"tcp://blah/", monitor.ServerUrl);
mockServerMonitor.ExpectAndReturn("IsConnected", true);
Assert.AreEqual(true, monitor.IsConnected);
mockServerMonitor.Expect("Poll");
monitor.Poll();
mockServerMonitor.Verify();
}
public void ShouldDecorateUrlsToCreateAbsoluteURLs()
{
/// Setup
DynamicMock decoratedBuilderMock = new DynamicMock(typeof(IUrlBuilder));
string baseUrl = "https://myserver:8080/myvdir";
AbsolutePathUrlBuilderDecorator decorator = new AbsolutePathUrlBuilderDecorator((IUrlBuilder) decoratedBuilderMock.MockInstance, baseUrl);
string actionName = "myAction";
decoratedBuilderMock.ExpectAndReturn("BuildUrl", "myRelativeUrl", actionName);
decoratedBuilderMock.ExpectAndReturn("BuildUrl", "myRelativeUrl2", actionName, "query");
decoratedBuilderMock.ExpectAndReturn("BuildUrl", "myPath/myRelativeUrl3", actionName, "query", "myPath/");
/// Execute & Verify
Assert.AreEqual(baseUrl + "/myRelativeUrl", decorator.BuildUrl(actionName));
Assert.AreEqual(baseUrl + "/myRelativeUrl2", decorator.BuildUrl(actionName, "query"));
Assert.AreEqual(baseUrl + "/myPath/myRelativeUrl3", decorator.BuildUrl(actionName, "query", "myPath/"));
decoratedBuilderMock.Verify();
}
public void ShouldUseObjectGiverToInstantiateActions()
{
DynamicMock objectSourceMock = new DynamicMock(typeof(ObjectSource));
Type typeToInstantiate = typeof(XslReportBuildAction);
ICruiseAction instantiated = new XslReportBuildAction(null, null);
objectSourceMock.ExpectAndReturn("GetByType", instantiated, typeToInstantiate);
ActionInstantiatorWithObjectSource instantiator = new ActionInstantiatorWithObjectSource((ObjectSource) objectSourceMock.MockInstance);
Assert.AreEqual(instantiated, instantiator.InstantiateAction(typeToInstantiate));
objectSourceMock.Verify();
}
public void TestSimpleSmtpNegotiationWithAuth()
{
SmtpServer smtpserver=new SmtpServer("localhost");
smtpserver.SmtpAuthToken=new SmtpAuthToken("test", "test");
Base64Encoder encoder=Base64Encoder.GetInstance();
String base64Username=encoder.EncodeString(smtpserver.SmtpAuthToken.UserName, System.Text.Encoding.ASCII );
String base64Password=encoder.EncodeString(smtpserver.SmtpAuthToken.Password, System.Text.Encoding.ASCII );
EmailMessage emailMessage=GetTestHtmlAndTextMessage();
IMock mockSmtpProxy = new DynamicMock(typeof(ISmtpProxy));
mockSmtpProxy.ExpectAndReturn("Open", new SmtpResponse(220, "welcome to the mock object server"), null);
EhloSmtpResponse ehloResponse=new EhloSmtpResponse();
ehloResponse.AddAvailableAuthType("login");
ehloResponse.Message="OK";
ehloResponse.ResponseCode=250;
mockSmtpProxy.ExpectAndReturn("Ehlo",ehloResponse , Dns.GetHostName());
mockSmtpProxy.ExpectAndReturn("Auth", new SmtpResponse(334, encoder.EncodeString("Username:"******"login");
mockSmtpProxy.ExpectAndReturn("SendString", new SmtpResponse(334, encoder.EncodeString("Password:"******"SendString", new SmtpResponse(235, "Hooray, Authenticated"), base64Password);
mockSmtpProxy.ExpectAndReturn("MailFrom", new SmtpResponse(250, "mail from"), emailMessage.FromAddress);
foreach (EmailAddress rcpttoaddr in emailMessage.ToAddresses)
{
mockSmtpProxy.ExpectAndReturn("RcptTo", new SmtpResponse(250, "receipt to"), rcpttoaddr);
}
mockSmtpProxy.ExpectAndReturn("Data", new SmtpResponse(354, "data open"), null);
mockSmtpProxy.ExpectAndReturn("WriteData", new SmtpResponse(250, "data"), emailMessage.ToDataString());
mockSmtpProxy.ExpectAndReturn("Quit", new SmtpResponse(221, "quit"), null);
mockSmtpProxy.Expect("Close", null);
ISmtpProxy smtpProxy= (ISmtpProxy) mockSmtpProxy.MockInstance;
smtpserver.OverrideSmtpProxy(smtpProxy);
try
{
emailMessage.Send(smtpserver);
}
catch (SmtpException ex)
{
log.Debug("Exception was "+ex.Message);
log.Debug(ex.StackTrace);
throw ex;
}
}
public void ForceBuildCruiseServerProject()
{
ConsoleRunnerArguments consoleArgs = new ConsoleRunnerArguments();
consoleArgs.Project = "test";
Mock mockCruiseServer = new DynamicMock(typeof(ICruiseServer));
var projectConstraint = new ProjectRequestConstraint
{
ProjectName = "test"
};
mockCruiseServer.ExpectAndReturn("ForceBuild", new Response { Result = ResponseResult.Success }, projectConstraint);
mockCruiseServer.ExpectAndReturn("Stop", new Response { Result = ResponseResult.Success }, projectConstraint);
mockCruiseServer.Expect("WaitForExit", projectConstraint);
Mock mockCruiseServerFactory = new DynamicMock(typeof(ICruiseServerFactory));
mockCruiseServerFactory.ExpectAndReturn("Create", mockCruiseServer.MockInstance, consoleArgs.UseRemoting, consoleArgs.ConfigFile);
new ConsoleRunner(consoleArgs, (ICruiseServerFactory)mockCruiseServerFactory.MockInstance).Run();
mockCruiseServer.Verify();
}
[Test] public void NamedDynamicMockImplementsAnInterface()
{
IMock mock = new DynamicMock(typeof(IBlah), "XBlah");
mock.ExpectAndReturn("DoStuff", "world", "hello");
IBlah blah = (IBlah)mock.MockInstance;
Assertion.AssertEquals("world", blah.DoStuff("hello"));
mock.Verify();
}
public void Setup()
{
serverSpecifier = new DefaultServerSpecifier(serverName);
projectSpecifier = new DefaultProjectSpecifier(serverSpecifier, projectName);
buildSpecifier = new DefaultBuildSpecifier(projectSpecifier, buildName);
linkFactoryMock = new DynamicMock(typeof (ILinkFactory));
configurationMock = new DynamicMock(typeof (IPluginConfiguration));
Plugins = new DefaultPluginLinkCalculator((ILinkFactory) linkFactoryMock.MockInstance, (IPluginConfiguration) configurationMock.MockInstance);
pluginMock1 = new DynamicMock(typeof (IPlugin));
pluginMock2 = new DynamicMock(typeof (IPlugin));
action1 = new ImmutableNamedAction("Action Name 1", null);
action2 = new ImmutableNamedAction("Action Name 2", null);
action3 = new ImmutableNamedAction("Action Name 3", null);
pluginMock1.ExpectAndReturn("LinkDescription", "Description 1");
pluginMock1.ExpectAndReturn("NamedActions", new INamedAction[] {action1});
pluginMock2.ExpectAndReturn("LinkDescription", "Description 2");
pluginMock2.ExpectAndReturn("NamedActions", new INamedAction[] {action2});
link1 = (IAbsoluteLink) new DynamicMock(typeof (IAbsoluteLink)).MockInstance;
link2 = (IAbsoluteLink) new DynamicMock(typeof (IAbsoluteLink)).MockInstance;
}
[Test] public void CanSetAndGetPropertiesOnAMockedInterface()
{
DynamicMock mock = new DynamicMock(typeof(IWithProperty));
IWithProperty withProperty = (IWithProperty)mock.MockInstance;
mock.ExpectAndReturn("Name", "fred");
mock.Expect("Name", "joe");
AssertEquals("Should be property Name", "fred", withProperty.Name);
withProperty.Name = "joe";
mock.Verify();
}
public void ShouldDelegateExtensionToSubBuilder()
{
// Setup
DynamicMock decoratedBuilderMock = new DynamicMock(typeof(IUrlBuilder));
decoratedBuilderMock.ExpectAndReturn("Extension", "foo");
// Execute
AbsolutePathUrlBuilderDecorator decorator = new AbsolutePathUrlBuilderDecorator((IUrlBuilder) decoratedBuilderMock.MockInstance, null);
decorator.Extension = "foo";
// Verify
decoratedBuilderMock.Verify();
}
public void ShouldGetSourceIfAutoGetSourceTrue()
{
DynamicMock executor = new DynamicMock(typeof(ProcessExecutor));
AccuRev accurev = new AccuRev((ProcessExecutor) executor.MockInstance);
accurev.AutoGetSource = true;
ProcessInfo expectedProcessRequest = new ProcessInfo("accurev.exe", "update");
expectedProcessRequest.TimeOut = Timeout.DefaultTimeout.Millis;
executor.ExpectAndReturn("Execute", new ProcessResult("foo", null, 0, false), expectedProcessRequest);
accurev.GetSource(new IntegrationResult());
executor.Verify();
}
public void CanProvideASetOfProjectStatusMonitors()
{
CCTrayMultiConfiguration provider = CreateTestConfiguration(ConfigXml);
DynamicMock mockCruiseServerManager = new DynamicMock(typeof(ICruiseServerManager));
mockCruiseServerManager.Strict = true;
mockCruiseServerManager.ExpectAndReturn("Configuration", new BuildServer("tcp://blah1"));
mockCruiseServerManager.ExpectAndReturn("Configuration", new BuildServer("tcp://blah2"));
ICruiseServerManager cruiseServerManagerInstance = (ICruiseServerManager) mockCruiseServerManager.MockInstance;
mockServerConfigFactory.ExpectAndReturn("Create", cruiseServerManagerInstance, provider.GetUniqueBuildServerList()[0]);
mockServerConfigFactory.ExpectAndReturn("Create", cruiseServerManagerInstance, provider.GetUniqueBuildServerList()[1]);
ISingleServerMonitor[] serverMonitorList = provider.GetServerMonitors();
mockProjectConfigFactory.ExpectAndReturn("Create", null, provider.Projects[0], null);
mockProjectConfigFactory.ExpectAndReturn("Create", null, provider.Projects[1], null);
IProjectMonitor[] monitorList = provider.GetProjectStatusMonitors(serverMonitorList);
Assert.AreEqual(2, monitorList.Length);
mockProjectConfigFactory.Verify();
mockServerConfigFactory.Verify();
mockCruiseServerManager.Verify();
}
[Test] public void CanMockMethodWithConstraint()
{
IMock mock = new DynamicMock(typeof(TwoMethods));
mock.Expect("Foo", new StartsWith("Hello"));
mock.ExpectAndReturn("Bar", 5, new NotNull());
TwoMethods instance = (TwoMethods)mock.MockInstance;
instance.Foo("Hello World");
Assertion.AssertEquals("Should get a result", 5, instance.Bar("not null"));
mock.Verify();
}
[Test] public void CanExpectMultipleInputsAndReturnAValue()
{
IMock mock = new DynamicMock(typeof(IValueType));
ArrayList ret = new ArrayList();
DateTime date = DateTime.Now;
mock.ExpectAndReturn("Query", ret, "hello", date);
IValueType blah = (IValueType)mock.MockInstance;
Assertion.AssertEquals(ret, blah.Query("hello", date));
mock.Verify();
}
[Test] public void CanSetStubsAndExpectationsOnMethodsInTheSameClass()
{
DynamicMock mock = new DynamicMock(typeof(SameClass));
mock.Ignore("A");
SameClass sc = (SameClass)mock.MockInstance;
mock.ExpectAndReturn("c", true);
mock.SetupResult("b", "hello");
AssertEquals("Should have overriden B()", "hello", sc.A());
mock.Verify();
}
public void ShouldInstantiateArrayOfStrings()
{
CollectionComponentParameter ccp = new CollectionComponentParameter();
Mock componentAdapterMock = new DynamicMock(typeof (IComponentAdapter));
componentAdapterMock.ExpectAndReturn("ComponentKey", "x", null);
componentAdapterMock.ExpectAndReturn("ComponentKey", "x", null);
Mock containerMock = new DynamicMock(typeof (IPicoContainer));
containerMock.ExpectAndReturn("ComponentAdapters", new Hashtable(), null);
IComponentAdapter[] adapters = new IComponentAdapter[]
{
new InstanceComponentAdapter("y", "Hello"),
new InstanceComponentAdapter("z", "World")
};
containerMock.ExpectAndReturn("GetComponentAdaptersOfType", adapters, new IsEqual(typeof (string)));
containerMock.ExpectAndReturn("GetComponentInstance", "World", new IsEqual("z"));
containerMock.ExpectAndReturn("GetComponentInstance", "Hello", new IsEqual("y"));
containerMock.ExpectAndReturn("Parent", null, null);
ArrayList expected = new ArrayList(new string[] {"Hello", "World"});
expected.Sort();
object[] array = (object[]) ccp.ResolveInstance((IPicoContainer) containerMock.MockInstance,
(IComponentAdapter) componentAdapterMock.MockInstance,
typeof (string[]));
ArrayList actual = new ArrayList(array);
actual.Sort();
Assert.AreEqual(expected.ToArray(), actual.ToArray());
// Verify mocks
componentAdapterMock.Verify();
containerMock.Verify();
}
public void ShouldGenerateAFileInTheArtifactDirectory()
{
IMock mockIntegrationResult = new DynamicMock(typeof (IIntegrationResult));
mockIntegrationResult.ExpectAndReturn("ArtifactDirectory", artifactDirectory);
IIntegrationResult mockIntegrationResultInstance = (IIntegrationResult) mockIntegrationResult.MockInstance;
IMock mockProcessor = new DynamicMock(typeof(BuildStatisticsProcessor));
IntegrationStatistics statistics = new IntegrationStatistics();
mockProcessor.ExpectAndReturn("ProcessBuildResults", statistics, mockIntegrationResultInstance);
publisher.Processor = (BuildStatisticsProcessor) mockProcessor.MockInstance;
publisher.Run(mockIntegrationResultInstance);
filePath = Path.Combine(artifactDirectory, publisher.FileName);
bool fileExists = File.Exists(filePath);
Assert.IsTrue(fileExists);
if (fileExists) File.Delete(filePath);
}
public void ShouldHandleBaseURLsWithTrailingSlashes()
{
/// Setup
DynamicMock decoratedBuilderMock = new DynamicMock(typeof(IUrlBuilder));
string baseUrl = "https://myserver:8080/myvdir/";
AbsolutePathUrlBuilderDecorator decorator = new AbsolutePathUrlBuilderDecorator((IUrlBuilder) decoratedBuilderMock.MockInstance, baseUrl);
string actionName = "myAction";
decoratedBuilderMock.ExpectAndReturn("BuildUrl", "myRelativeUrl", actionName);
/// Execute & Verify
Assert.AreEqual(baseUrl + "myRelativeUrl", decorator.BuildUrl(actionName));
decoratedBuilderMock.Verify();
}
public void KillContainer()
{
Mock mockPicoContainer = new DynamicMock(typeof(IMutablePicoContainer));
IMutablePicoContainer picoContainer = mockPicoContainer.MockInstance as IMutablePicoContainer;
mockPicoContainer.Expect("Stop");
mockPicoContainer.Expect("Dispose");
mockPicoContainer.ExpectAndReturn("Parent", new DefaultPicoContainer(picoContainer));
mockPicoContainer.Strict = true;
LifeCycleContainerBuilder lifeCycleContainerBuilder = new StubLifeCycleContainerBuilder();
SimpleReference reference = new SimpleReference();
reference.Set(mockPicoContainer.MockInstance);
lifeCycleContainerBuilder.KillContainer(reference);
mockPicoContainer.Verify();
}
public void ShouldHandleIncrementingLabelAfterInitialBuildFailsWithException()
{
IMock mockSourceControl = new DynamicMock(typeof (ISourceControl));
mockSourceControl.ExpectAndThrow("GetModifications", new Exception("doh!"), new IsAnything(), new IsAnything());
mockSourceControl.ExpectAndReturn("GetModifications", new Modification[] {new Modification()}, new IsAnything(), new IsAnything());
Project project = new Project();
project.Name = "test";
project.SourceControl = (ISourceControl) mockSourceControl.MockInstance;
project.StateManager = new StateManagerStub();
try { project.Integrate(new IntegrationRequest(BuildCondition.ForceBuild, "test", null));}
catch (Exception) { }
project.Integrate(new IntegrationRequest(BuildCondition.ForceBuild, "test", null));
Assert.AreEqual(IntegrationStatus.Success, project.CurrentResult.Status);
Assert.AreEqual("1", project.CurrentResult.Label);
}
public void MethodsAndPropertiesDoSimpleDelagationOntoInjectedMonitor()
{
DynamicMock mockProjectMonitor = new DynamicMock(typeof (IProjectMonitor));
SynchronizedProjectMonitor monitor = new SynchronizedProjectMonitor(
(IProjectMonitor) mockProjectMonitor.MockInstance, null);
mockProjectMonitor.ExpectAndReturn("ProjectState", null);
Assert.IsNull(monitor.ProjectState);
Dictionary<string, string> parameters = new Dictionary<string, string>();
mockProjectMonitor.Expect("ForceBuild", parameters, (string)null);
monitor.ForceBuild(parameters, null);
mockProjectMonitor.Expect("Poll");
monitor.Poll();
mockProjectMonitor.Verify();
}
public void CurrentlyAddedProjectsAreIgnoredWhenServerIsSelected()
{
CCTrayProject[] allProjects = {
new CCTrayProject("tcp://localhost:123/blah", "proj1"),
new CCTrayProject("tcp://localhost:123/blah", "proj2"),
new CCTrayProject("tcp://localhost:123/blah", "proj3"),
};
CCTrayProject[] selectedProjects = {
new CCTrayProject("tcp://localhost:123/blah", "proj1"),
new CCTrayProject("tcp://localhost:123/blah", "proj2"),
};
DynamicMock mockCruiseManagerFactory = new DynamicMock(typeof (ICruiseProjectManagerFactory));
mockCruiseManagerFactory.ExpectAndReturn("GetProjectList", allProjects, allProjects[0].BuildServer, false);
AddProjects addProjects = new AddProjects(
(ICruiseProjectManagerFactory)mockCruiseManagerFactory.MockInstance,
null,
selectedProjects);
}
public void ReuseGeneratedAssembly()
{
DynamicMock mock = new DynamicMock(typeof(SameClass));
mock.Ignore("A");
mock.Ignore("c");
SameClass sc = (SameClass)mock.MockInstance;
mock.SetupResult("b", "hello");
Assertion.AssertEquals("hello", sc.A());
mock = new DynamicMock(typeof(SameClass));
mock.Ignore("A");
sc = (SameClass)mock.MockInstance;
mock.ExpectAndReturn("c", true);
mock.SetupResult("b", "hello");
AssertEquals("Should have overriden B()", "hello", sc.A());
mock.Verify();
}