public void Setup()
{
this.mocks = new MockRepository();
mockery = new Mockery();
targetMock = mockery.NewDynamicMock(typeof(IIntegrationRunnerTarget));
resultManagerMock = mockery.NewDynamicMock(typeof(IIntegrationResultManager));
quietPeriodMock = mockery.NewDynamicMock(typeof(IQuietPeriod));
runner = new IntegrationRunner((IIntegrationResultManager)resultManagerMock.MockInstance,
(IIntegrationRunnerTarget)targetMock.MockInstance,
(IQuietPeriod)quietPeriodMock.MockInstance);
request = ModificationExistRequest();
endTime = new DateTime(2005, 2, 1);
modifications = new Modification[] { new Modification() };
resultMock = mockery.NewDynamicMock(typeof(IIntegrationResult));
resultMock.SetupResult("WorkingDirectory", TempFileUtil.GetTempPath("workingDir"));
resultMock.SetupResult("ArtifactDirectory", TempFileUtil.GetTempPath("artifactDir"));
resultMock.SetupResult("BuildProgressInformation", new ThoughtWorks.CruiseControl.Core.Util.BuildProgressInformation("", string.Empty));
resultMock.SetupResult("IntegrationProperties", new Dictionary <string, string>());
result = (IIntegrationResult)resultMock.MockInstance;
lastResultMock = mockery.NewDynamicMock(typeof(IIntegrationResult));
lastResult = (IIntegrationResult)lastResultMock.MockInstance;
}
/// <summary>
/// Fires this instance.
/// </summary>
/// <returns></returns>
/// <remarks></remarks>
public IntegrationRequest Fire()
{
IntegrationRequest request = null;
foreach (ITrigger trigger in triggers)
{
IntegrationRequest triggerRequest = trigger.Fire();
//todo : shouldn't we loop over all triggers before we return null?
// suppose you have operator AND and Operator Or
// if the AND operator does not have a trigger request, we return null
// but the OR part could have a valid request
// nasty stuff concerning JIRA issue 1835
if (Operator == Operator.And && triggerRequest == null)
{
return(null);
}
if (triggerRequest != null)
{
if (request == null || triggerRequest.BuildCondition == BuildCondition.ForceBuild)
{
request = triggerRequest;
}
}
}
return(request);
}
public void CancelPendingRequestRemovesPendingItems()
{
IProject project = (IProject)projectMock.Object;
IntegrationRequest request1 = new IntegrationRequest(BuildCondition.IfModificationExists, "intervalTrigger", null);
projectMock.Setup(_project => _project.NotifyPendingState()).Verifiable();
integrationQueue.Enqueue(new IntegrationQueueItem(project, request1, integrator));
IntegrationRequest request2 = new IntegrationRequest(BuildCondition.IfModificationExists, "intervalTrigger", null);
integrationQueue.Enqueue(new IntegrationQueueItem(project, request2, integrator));
int queuedItemCount = integrationQueue.GetQueuedIntegrations().Length;
Assert.AreEqual(2, queuedItemCount);
integrationTriggerMock.Setup(_trigger => _trigger.IntegrationCompleted()).Verifiable();
integrator.CancelPendingRequest();
queuedItemCount = integrationQueue.GetQueuedIntegrations().Length;
Assert.AreEqual(1, queuedItemCount);
VerifyAll();
projectMock.Verify(_project => _project.NotifyPendingState(), Times.Once);
}
/// <summary>
/// Starts a new <see cref="TaskExecutionContext"/>.
/// </summary>
/// <param name="project">The project.</param>
/// <param name="request">The request.</param>
/// <returns>
/// The new <see cref="TaskExecutionContext"/>.
/// </returns>
public TaskExecutionContext StartNew(Project project, IntegrationRequest request)
{
logger.Debug("Starting execution context for project '{0}", project.Name);
var buildName = this.Clock.Now.ToString("yyyyMMddHHmmss");
var logFile = TaskExecutionContext.GenerateArtifactFileName(project, buildName, "build.log");
this.FileSystem.EnsureFolderExists(Path.GetDirectoryName(logFile));
var writer = this.FileSystem.CreateXmlWriter(logFile);
writer.WriteStartElement("project");
writer.WriteAttributeString("name", project.Name);
writer.WriteElementString("start", this.Clock.Now.ToString("s"));
var parameters = new TaskExecutionParameters
{
XmlWriter = writer,
FileSystem = this.FileSystem,
Clock = this.Clock,
IntegrationRequest = request,
Project = project,
BuildName = buildName
};
var context = new TaskExecutionContext(parameters);
return(context);
}
public void SetUp()
{
integrationQueues = new IntegrationQueueSet();
integrationQueues.Add(TestQueueName, new DefaultQueueConfiguration(TestQueueName));
integrationQueues.Add(TestQueueName2, new DefaultQueueConfiguration(TestQueueName2));
integrationQueue1 = integrationQueues[TestQueueName];
integrationQueue2 = integrationQueues[TestQueueName2];
integrationRequest = new IntegrationRequest(BuildCondition.ForceBuild, "Test", null);
project1Mock = new LatchMock(typeof(IProject));
project1Mock.Strict = true;
project1Mock.SetupResult("Name", "ProjectOne");
project1Mock.SetupResult("QueueName", TestQueueName);
project1Mock.SetupResult("QueuePriority", 0);
project2Mock = new LatchMock(typeof(IProject));
project2Mock.Strict = true;
project2Mock.SetupResult("Name", "ProjectTwo");
project2Mock.SetupResult("QueueName", TestQueueName2);
project2Mock.SetupResult("QueuePriority", 0);
queueNotifier1Mock = new LatchMock(typeof(IIntegrationQueueNotifier));
queueNotifier1Mock.Strict = true;
queueNotifier2Mock = new LatchMock(typeof(IIntegrationQueueNotifier));
queueNotifier2Mock.Strict = true;
integrationQueueItem1 = new IntegrationQueueItem((IProject)project1Mock.MockInstance,
integrationRequest, (IIntegrationQueueNotifier)queueNotifier1Mock.MockInstance);
integrationQueueItem2 = new IntegrationQueueItem((IProject)project2Mock.MockInstance,
integrationRequest, (IIntegrationQueueNotifier)queueNotifier2Mock.MockInstance);
}
public void Setup()
{
this.mocks = new MockRepository(MockBehavior.Default);
mockery = new Mockery();
targetMock = mockery.NewDynamicMock <IIntegrationRunnerTarget>();
resultManagerMock = mockery.NewDynamicMock <IIntegrationResultManager>();
quietPeriodMock = mockery.NewDynamicMock <IQuietPeriod>();
runner = new IntegrationRunner((IIntegrationResultManager)resultManagerMock.Object,
(IIntegrationRunnerTarget)targetMock.Object,
(IQuietPeriod)quietPeriodMock.Object);
request = ModificationExistRequest();
endTime = new DateTime(2005, 2, 1);
modifications = new Modification[] { new Modification() };
resultMock = mockery.NewDynamicMock <IIntegrationResult>();
resultMock.SetupGet(_result => _result.WorkingDirectory).Returns(TempFileUtil.GetTempPath("workingDir"));
resultMock.SetupGet(_result => _result.ArtifactDirectory).Returns(TempFileUtil.GetTempPath("artifactDir"));
resultMock.SetupGet(_result => _result.BuildProgressInformation).Returns(new ThoughtWorks.CruiseControl.Core.Util.BuildProgressInformation("", string.Empty));
resultMock.SetupGet(_result => _result.IntegrationProperties).Returns(new Dictionary <string, string>());
result = (IIntegrationResult)resultMock.Object;
lastResultMock = mockery.NewDynamicMock <IIntegrationResult>();
lastResult = (IIntegrationResult)lastResultMock.Object;
}
public void CompletingAllPendingQueueBuildsGoesToPendingState()
{
IProject project = (IProject)projectMock.MockInstance;
IntegrationRequest request1 = new IntegrationRequest(BuildCondition.IfModificationExists, "intervalTrigger", null);
projectMock.Expect("NotifyPendingState");
IntegrationRequest request2 = new IntegrationRequest(BuildCondition.IfModificationExists, "intervalTrigger", null);
// As first build completes we go to pending as still another build on queue
integrationTriggerMock.Expect("IntegrationCompleted");
projectMock.Expect("NotifyPendingState");
// As second build completes, we can go to sleeping state
integrationTriggerMock.Expect("IntegrationCompleted");
projectMock.Expect("NotifySleepingState");
integrationQueue.Enqueue(new IntegrationQueueItem(project, request1, integrator));
integrationQueue.Enqueue(new IntegrationQueueItem(project, request2, integrator));
// Simulate first build completed by dequeuing it to invoke notifcation.
integrationQueue.Dequeue();
// Simulate second build completed by dequeuing it to invoke notifcation.
integrationQueue.Dequeue();
VerifyAll();
}
public void RunForDirectoryWildCard()
{
IntegrationRequest request = new IntegrationRequest(BuildCondition.ForceBuild, "Somewhere", null);
IntegrationSummary summary = new IntegrationSummary(IntegrationStatus.Success, "A Label", "Another Label", new DateTime(2009, 1, 1));
IntegrationResult result = new IntegrationResult("Test project", "Working directory", "Artifact directory", request, summary);
Modification modification1 = GenerateModification("first file", "Add");
Modification modification2 = GenerateModification("second file", "Modify");
result.Modifications = new Modification[] { modification1, modification2 };
result.Status = IntegrationStatus.Success;
result.ArtifactDirectory = Path.GetTempPath();
string packageLocation = Path.Combine(Path.GetTempPath(), "Test Package-1");
string packageName = packageLocation + ".zip";
if (File.Exists(packageName))
{
File.Delete(packageName);
}
PackagePublisher publisher = new PackagePublisher();
publisher.PackageName = packageLocation;
publisher.PackageList = new IPackageItem[] {
new PackageFile(Path.Combine(Path.GetTempPath(), "**\\datafile.txt"))
};
publisher.Run(result);
Assert.IsTrue(File.Exists(packageName), "Package not generated");
Assert.IsTrue(
File.Exists(Path.Combine(Path.GetTempPath(), Path.Combine("A Label", "Test project-packages.xml"))),
"Project package list not generated");
}
public void CancelPendingRequestRemovesPendingItems()
{
IProject project = (IProject)projectMock.MockInstance;
IntegrationRequest request1 = new IntegrationRequest(BuildCondition.IfModificationExists, "intervalTrigger", null);
projectMock.Expect("NotifyPendingState");
integrationQueue.Enqueue(new IntegrationQueueItem(project, request1, integrator));
IntegrationRequest request2 = new IntegrationRequest(BuildCondition.IfModificationExists, "intervalTrigger", null);
projectMock.ExpectNoCall("NotifyPendingState");
integrationQueue.Enqueue(new IntegrationQueueItem(project, request2, integrator));
int queuedItemCount = integrationQueue.GetQueuedIntegrations().Length;
Assert.AreEqual(2, queuedItemCount);
integrationTriggerMock.Expect("IntegrationCompleted");
integrator.CancelPendingRequest();
queuedItemCount = integrationQueue.GetQueuedIntegrations().Length;
Assert.AreEqual(1, queuedItemCount);
VerifyAll();
}
public void IntegrateHandlesErrorDuringTaskCleanUp()
{
var initialised = false;
var ran = false;
var dummy = new TaskStub
{
OnInitialiseAction = () => initialised = true,
OnRunAction = c =>
{
ran = true;
return(null);
},
OnCleanUpAction = () =>
{
throw new Exception("Oops");
}
};
var executionFactoryMock = new Mock <ITaskExecutionFactory>(MockBehavior.Strict);
InitialiseExecutionContext(executionFactoryMock);
var project = new Project("test", dummy)
{
TaskExecutionFactory = executionFactoryMock.Object
};
var request = new IntegrationRequest("Dummy");
project.Integrate(request);
Assert.IsTrue(initialised);
Assert.IsTrue(ran);
}
public void FirePassesOnParameters()
{
var parameters = new[]
{
new NameValuePair("test", "testValue")
};
var request = new IntegrationRequest(BuildCondition.IfModificationExists, "test", null);
var innerTriggerMock = this.mocks.StrictMock <ITrigger>();
Expect.Call(innerTriggerMock.Fire()).Return(request);
var trigger = new ParameterTrigger
{
InnerTrigger = innerTriggerMock,
Parameters = parameters
};
mocks.ReplayAll();
var actual = trigger.Fire();
mocks.VerifyAll();
Assert.AreSame(request, actual);
Assert.AreEqual(1, request.BuildValues.Count);
Assert.AreEqual(parameters[0].Value,
request.BuildValues[parameters[0].Name]);
}
public void SetUp()
{
integrationQueues = new IntegrationQueueSet();
integrationQueues.Add(TestQueueName, new DefaultQueueConfiguration(TestQueueName));
integrationQueues.Add(TestQueueName2, new DefaultQueueConfiguration(TestQueueName2));
integrationQueue1 = integrationQueues[TestQueueName];
integrationQueue2 = integrationQueues[TestQueueName2];
integrationRequest = new IntegrationRequest(BuildCondition.ForceBuild, "Test", null);
project1Mock = new Mock <IProject>(MockBehavior.Strict);
project1Mock.SetupGet(project => project.Name).Returns("ProjectOne");
project1Mock.SetupGet(project => project.QueueName).Returns(TestQueueName);
project1Mock.SetupGet(project => project.QueuePriority).Returns(0);
project2Mock = new Mock <IProject>(MockBehavior.Strict);
project2Mock.SetupGet(project => project.Name).Returns("ProjectTwo");
project2Mock.SetupGet(project => project.QueueName).Returns(TestQueueName2);
project2Mock.SetupGet(project => project.QueuePriority).Returns(0);
queueNotifier1Mock = new Mock <IIntegrationQueueNotifier>(MockBehavior.Strict);
queueNotifier2Mock = new Mock <IIntegrationQueueNotifier>(MockBehavior.Strict);
integrationQueueItem1 = new IntegrationQueueItem((IProject)project1Mock.Object,
integrationRequest, (IIntegrationQueueNotifier)queueNotifier1Mock.Object);
integrationQueueItem2 = new IntegrationQueueItem((IProject)project2Mock.Object,
integrationRequest, (IIntegrationQueueNotifier)queueNotifier2Mock.Object);
}
/// <summary>
/// Fires this instance.
/// </summary>
/// <returns></returns>
/// <remarks></remarks>
public IntegrationRequest Fire()
{
IntegrationRequest request = InnerTrigger.Fire();
if (request == null)
{
return(null);
}
InnerTrigger.IntegrationCompleted(); // reset inner trigger (timer)
try
{
currentStatus = GetCurrentProjectStatus();
if (lastStatus == null)
{
lastStatus = currentStatus;
if (TriggerFirstTime && currentStatus.BuildStatus == TriggerStatus)
{
return(request);
}
return(null);
}
if (currentStatus.LastBuildDate > lastStatus.LastBuildDate && currentStatus.BuildStatus == TriggerStatus)
{
return(request);
}
}
catch (SocketException)
{
Log.Warning("Skipping Fire() because ServerUri " + ServerUri + " was not found.");
}
return(null);
}
private void WriteRequest(IntegrationRequest request)
{
if (request == null)
{
return;
}
writer.WriteStartElement(Elements.Request);
writer.WriteAttributeString("source", request.Source);
writer.WriteAttributeString("buildCondition", request.BuildCondition.ToString());
writer.WriteString(request.ToString());
writer.WriteEndElement();
// Output the parameters
if ((request.BuildValues != null) && (request.BuildValues.Count > 0))
{
writer.WriteStartElement(Elements.Parameters);
foreach (string key in request.BuildValues.Keys)
{
writer.WriteStartElement(Elements.Parameter);
writer.WriteAttributeString("name", key);
writer.WriteAttributeString("value", request.BuildValues[key]);
writer.WriteEndElement();
}
writer.WriteEndElement();
}
}
public void SuccessfulIntegrationUpdatesSuccessCounter()
{
var counters = this.InitialiseCounters();
Mock.Get(counters).Setup(_counters => _counters.IncrementCounter(
IntegrationPerformanceCountersExtension.CategoryName,
IntegrationPerformanceCountersExtension.NumberCompletedCounter)).Verifiable();
Mock.Get(counters).Setup(_counters => _counters.IncrementCounter(
IntegrationPerformanceCountersExtension.CategoryName,
IntegrationPerformanceCountersExtension.NumberTotalCounter)).Verifiable();
Mock.Get(counters).Setup(_counters => _counters.IncrementCounter(
IntegrationPerformanceCountersExtension.CategoryName,
IntegrationPerformanceCountersExtension.AverageTimeCounter,
It.IsAny <long>())).Verifiable();
var extension = new IntegrationPerformanceCountersExtension
{
PerformanceCounters = counters
};
var serverMock = this.mocks.Create <ICruiseServer>(MockBehavior.Strict).Object;
var config = new ExtensionConfiguration();
Mock.Get(serverMock).SetupAdd(_serverMock => _serverMock.IntegrationCompleted += It.IsAny <EventHandler <IntegrationCompletedEventArgs> >()).Verifiable();
Mock.Get(serverMock).SetupAdd(_serverMock => _serverMock.IntegrationStarted += It.IsAny <EventHandler <IntegrationStartedEventArgs> >()).Verifiable();
var request = new IntegrationRequest(BuildCondition.ForceBuild, "Testing", null);
extension.Initialise(serverMock, config);
Mock.Get(serverMock).Raise(_serverMock => _serverMock.IntegrationStarted += null, new IntegrationStartedEventArgs(request, "TestProject"));
Mock.Get(serverMock).Raise(_serverMock => _serverMock.IntegrationCompleted += null, new IntegrationCompletedEventArgs(request, "TestProject", IntegrationStatus.Success));
mocks.VerifyAll();
}
public void GenerateFullManifest()
{
ManifestGenerator generator = new ManifestGenerator();
IntegrationRequest request = new IntegrationRequest(BuildCondition.ForceBuild, "Somewhere", null);
IntegrationSummary summary = new IntegrationSummary(IntegrationStatus.Success, "A Label", "Another Label", new DateTime(2009, 1, 1));
IntegrationResult result = new IntegrationResult("Test project", "Working directory", "Artifact directory", request, summary);
Modification modification1 = GenerateModification("first file", "Add");
Modification modification2 = GenerateModification("second file", "Modify");
result.Modifications = new Modification[] { modification1, modification2 };
List <string> files = new List <string>();
files.Add("first file");
XmlDocument manifest = generator.Generate(result, files.ToArray());
Assert.IsNotNull(manifest);
string actualManifest = manifest.OuterXml;
string expectedManifest = "<manifest>" +
"<header project=\"Test project\" label=\"A Label\" build=\"ForceBuild\" status=\"Unknown\">" +
"<modification user=\"johnDoe\" changeNumber=\"1\" time=\"2009-01-01T00:00:00\">" +
"<comment>A comment</comment>" +
"<file name=\"first file\" type=\"Add\" />" +
"<file name=\"second file\" type=\"Modify\" />" +
"</modification>" +
"</header>" +
"<file name=\"first file\" />" +
"</manifest>";
Assert.AreEqual(expectedManifest, actualManifest);
}
public void StartNewStartsANewContext()
{
var path = Path.Combine(
Environment.CurrentDirectory,
"Test",
"20100101120101");
var writerMock = new Mock<XmlWriter>(MockBehavior.Strict);
writerMock.Setup(w => w.WriteStartElement(null, "project", null)).Verifiable();
writerMock.MockWriteAttributeString("name", "Test");
writerMock.MockWriteElementString("start", "2010-01-01T12:01:01");
var clockMock = new Mock<IClock>(MockBehavior.Strict);
clockMock.Setup(c => c.Now).Returns(new DateTime(2010, 1, 1, 12, 1, 1));
var fileSystemMock = new Mock<IFileSystem>(MockBehavior.Strict);
fileSystemMock.Setup(fs => fs.EnsureFolderExists(path));
fileSystemMock.Setup(fs => fs.CreateXmlWriter(Path.Combine(path, "build.log"))).Returns(writerMock.Object);
var factory = new TaskExecutionFactory
{
Clock = clockMock.Object,
FileSystem = fileSystemMock.Object
};
var project = new Project("Test");
var request = new IntegrationRequest("Testing");
var actual = factory.StartNew(project, request);
Assert.IsNotNull(actual);
Assert.AreSame(project, actual.Project);
Assert.AreSame(request, actual.Request);
writerMock.Verify();
}
public void RequestFiresEvents()
{
string projectName = "Project 1";
string enforcer = "JohnDoe";
IntegrationRequest request = new IntegrationRequest(BuildCondition.ForceBuild, enforcer, null);
bool forceBuildReceived = false;
server.ForceBuildReceived += delegate(object o, CancelProjectEventArgs <string> e)
{
forceBuildReceived = true;
Assert.AreEqual(projectName, e.ProjectName);
};
bool forceBuildProcessed = false;
server.ForceBuildProcessed += delegate(object o, ProjectEventArgs <string> e)
{
forceBuildProcessed = true;
Assert.AreEqual(projectName, e.ProjectName);
};
server.CruiseManager.Request(projectName, request);
Assert.IsTrue(forceBuildReceived, "ForceBuildReceived not fired");
Assert.IsTrue(forceBuildProcessed, "ForceBuildProcessed not fired");
}
public void StartNewStartsANewContext()
{
var path = Path.Combine(
Environment.CurrentDirectory,
"Test",
"20100101120101");
var writerMock = new Mock <XmlWriter>(MockBehavior.Strict);
writerMock.Setup(w => w.WriteStartElement(null, "project", null)).Verifiable();
writerMock.MockWriteAttributeString("name", "Test");
writerMock.MockWriteElementString("start", "2010-01-01T12:01:01");
var clockMock = new Mock <IClock>(MockBehavior.Strict);
clockMock.Setup(c => c.Now).Returns(new DateTime(2010, 1, 1, 12, 1, 1));
var fileSystemMock = new Mock <IFileSystem>(MockBehavior.Strict);
fileSystemMock.Setup(fs => fs.EnsureFolderExists(path));
fileSystemMock.Setup(fs => fs.CreateXmlWriter(Path.Combine(path, "build.log"))).Returns(writerMock.Object);
var factory = new TaskExecutionFactory
{
Clock = clockMock.Object,
FileSystem = fileSystemMock.Object
};
var project = new Project("Test");
var request = new IntegrationRequest("Testing");
var actual = factory.StartNew(project, request);
Assert.IsNotNull(actual);
Assert.AreSame(project, actual.Project);
Assert.AreSame(request, actual.Request);
writerMock.Verify();
}
public void ImportRelativeBasedManifest()
{
string sourceFile = Path.Combine(Path.GetTempPath(), "ImportManifest.xml");
string expectedManifest = "<manifest>" +
"From a file" +
"</manifest>";
if (File.Exists(sourceFile))
{
File.Delete(sourceFile);
}
File.WriteAllText(sourceFile, expectedManifest);
ManifestImporter generator = new ManifestImporter();
generator.FileName = "ImportManifest.xml";
IntegrationRequest request = new IntegrationRequest(BuildCondition.ForceBuild, "Somewhere", null);
IntegrationSummary summary = new IntegrationSummary(IntegrationStatus.Success, "A Label", "Another Label", new DateTime(2009, 1, 1));
IntegrationResult result = new IntegrationResult("Test project", "Working directory", "Artifact directory", request, summary);
List <string> files = new List <string>();
result.WorkingDirectory = Path.GetTempPath();
XmlDocument manifest = generator.Generate(result, files.ToArray());
Assert.IsNotNull(manifest);
string actualManifest = manifest.OuterXml;
Assert.AreEqual(expectedManifest, actualManifest);
}
public IntegrationRequest Fire()
{
IntegrationRequest request = null;
if (this.lastChanged.HasValue)
{
if (this.InnerTrigger.Fire() != null)
{
var changeTime = File.GetLastWriteTime(this.MonitorFile);
if (changeTime > this.lastChanged.Value)
{
request = new IntegrationRequest(
this.BuildCondition,
this.GetType().Name,
null);
this.lastChanged = changeTime;
}
}
}
else
{
this.lastChanged = File.GetLastWriteTime(this.MonitorFile);
}
return(request);
}
public void GetNextRequestIsNullWithNothingOnQueue()
{
IntegrationRequest ir = integrationQueueUseFirst.GetNextRequest((IProject)project1Mock.MockInstance);
Assert.IsNull(ir);
VerifyAll();
}
public void VerifyCreateQueryProcessInfoWithAttributes()
{
string fromtime = "01/02/2003 00:00:00";
string totime = "23/02/2006 23:14:05";
IntegrationRequest request = new IntegrationRequest(BuildCondition.ForceBuild, "source", null);
IntegrationSummary lastSummary = new IntegrationSummary(IntegrationStatus.Success, "label", "lastlabel", DateTime.Now);
IntegrationResult from = new IntegrationResult("test", @"c:\workspace", @"c:\artifacts", request, lastSummary);
from.StartTime = DateTime.ParseExact(fromtime, PlasticSCM.DATEFORMAT, System.Globalization.CultureInfo.InvariantCulture);
IntegrationResult to = new IntegrationResult("test", @"c:\workspace", @"c:\artifacts", request, lastSummary);
to.StartTime = DateTime.ParseExact(totime, PlasticSCM.DATEFORMAT, System.Globalization.CultureInfo.InvariantCulture);
PlasticSCM plasticscm = new PlasticSCM();
NetReflector.Read(PLASTICSCM_XML, plasticscm);
string query = string.Format(
@"c:\plastic\client\cm.exe find revision where branch = 'br:/main' and revno != 'CO' "
+ "and date between '{0}' and '{1}' on repository 'mainrep' ", fromtime, totime);
string dateformat = string.Format(System.Globalization.CultureInfo.CurrentCulture, "--dateformat=\"{0}\" ", PlasticSCM.DATEFORMAT);
string format = string.Format(System.Globalization.CultureInfo.CurrentCulture, "--format=\"{0}\"", PlasticSCM.FORMAT);
ProcessInfo info = plasticscm.CreateQueryProcessInfo(from, to);
Assert.AreEqual(query + dateformat + format, info.FileName + " " + info.Arguments);
}
public void ProjectsInQueueShouldNotIntegrateIfQueueIsLocked()
{
// ensure we have the correct setup for testing
string[] queues = integrationQueues.GetQueueNames();
integrationQueues[queues[0]].Configuration.LockQueueNames = string.Format(System.Globalization.CultureInfo.CurrentCulture, "{0},{1}", queues[1], queues[2]);
integrationQueues[queues[1]].Configuration.LockQueueNames = queues[0];
integrationQueues[queues[2]].Configuration.LockQueueNames = queues[0];
// now lock one of the queues and add projects to it
IDisposable lock1;
Assert.IsTrue(integrationQueues[queues[0]].TryLock(out lock1));
project1Mock.SetupResult("QueueName", queues[1]);
project1Mock.SetupResult("QueuePriority", 1);
queueNotifier1Mock.Expect("NotifyEnteringIntegrationQueue");
integrationQueueReplace.Enqueue(integrationQueueItem1);
Assert.IsNull(integrationQueueReplace.GetNextRequest((IProject)project1Mock.MockInstance), "Expected no next request, as queue is locked");
lock1.Dispose();
IntegrationRequest next = integrationQueueReplace.GetNextRequest((IProject)project1Mock.MockInstance);
Assert.IsNotNull(next, "Expected next request as queue lock has been released");
}
public void IntegrateHandlesErrorDuringSourceControlCleanUp()
{
var initialised = false;
var dummy = new SourceControlBlockStub
{
OnInitialise = () => initialised = true,
OnCleanUp = () =>
{
throw new Exception("Oops");
}
};
var executionFactoryMock = new Mock <ITaskExecutionFactory>(MockBehavior.Strict);
InitialiseExecutionContext(executionFactoryMock);
var project = new Project("test")
{
TaskExecutionFactory = executionFactoryMock.Object
};
project.SourceControl.Add(dummy);
var request = new IntegrationRequest("Dummy");
project.Integrate(request);
Assert.IsTrue(initialised);
}
public IntegrationRequest Fire()
{
if (!started)
{
started = true;
if (string.IsNullOrEmpty(this.EndPoint))
{
this.EndPoint = DefaultEndPoint;
}
if (this.Branches == null || this.Branches.Length == 0)
{
this.Branches = new string[] { "master" }
}
;
Log("Starting OWIN on " + this.EndPoint);
webApp = OwinStartup.Start(this);
Log("Started OWIN on " + this.EndPoint);
}
if (this.PushData != null)
{
IntegrationRequest req = new IntegrationRequest(this.BuildCondition, this.GetType().Name, this.PushData.PushedBy);
req.BuildValues["Branch"] = this.PushData.Branch;
this.PushData = null;
return(req);
}
return(null);
}
public void IntegrateInitialisesRunsAndCleansUp()
{
var initialised = false;
var ran = false;
var cleanedUp = false;
var dummy = new TaskStub
{
OnInitialiseAction = () => initialised = true,
OnRunAction = c => { ran = true; return(null); },
OnCleanUpAction = () => cleanedUp = true
};
var executionFactoryMock = new Mock <ITaskExecutionFactory>(MockBehavior.Strict);
InitialiseExecutionContext(executionFactoryMock);
var project = new Project("test", dummy)
{
TaskExecutionFactory = executionFactoryMock.Object
};
var request = new IntegrationRequest("Dummy");
project.Integrate(request);
Assert.IsTrue(initialised);
Assert.IsTrue(ran);
Assert.IsTrue(cleanedUp);
}
public void ShouldOnlyBuildBetween7AMAnd7PMOnWeekdays()
{
FilterTrigger outerTrigger = new FilterTrigger((DateTimeProvider)mockDateTime.Object);
outerTrigger.StartTime = "19:00";
outerTrigger.EndTime = "7:00";
outerTrigger.InnerTrigger = trigger;
trigger.StartTime = "0:00";
trigger.EndTime = "23:59:59";
trigger.WeekDays = new DayOfWeek[] { DayOfWeek.Saturday, DayOfWeek.Sunday };
IntegrationRequest request = ModificationExistRequest();
mockTrigger.Setup(_trigger => _trigger.Fire()).Returns(request);
mockDateTime.SetupGet(provider => provider.Now).Returns(new DateTime(2006, 8, 10, 11, 30, 0, 0)); // Thurs midday
Assert.AreEqual(request, outerTrigger.Fire(), "outerTrigger.Fire()");
mockDateTime.SetupGet(provider => provider.Now).Returns(new DateTime(2006, 8, 10, 19, 30, 0, 0)); // Thurs evening
Assert.IsNull(outerTrigger.Fire(), "outerTrigger.Fire()");
mockDateTime.SetupGet(provider => provider.Now).Returns(new DateTime(2006, 8, 12, 11, 30, 0, 0)); // Sat midday
Assert.IsNull(outerTrigger.Fire(), "outerTrigger.Fire()");
mockDateTime.SetupGet(provider => provider.Now).Returns(new DateTime(2006, 8, 12, 19, 30, 0, 0)); // Sat evening
Assert.IsNull(outerTrigger.Fire(), "outerTrigger.Fire()");
}
/// <summary>
/// Fires the IntegrationCompleted event.
/// </summary>
/// <param name="request">The integration request.</param>
/// <param name="projectName">The name of the project.</param>
/// <param name="status">The outcome of the integration.</param>
protected virtual void FireIntegrationCompleted(IntegrationRequest request, string projectName, IntegrationStatus status)
{
if (IntegrationCompleted != null)
{
IntegrationCompletedEventArgs args = new IntegrationCompletedEventArgs(request, projectName, status);
IntegrationCompleted(this, args);
}
}
/// <summary>
/// Creates the initial integration result.
/// </summary>
/// <param name="project">The project.</param>
/// <param name="workingDirectory">The working directory.</param>
/// <param name="artifactDirectory">The artifact directory.</param>
/// <returns></returns>
/// <remarks></remarks>
public static IntegrationResult CreateInitialIntegrationResult(string project, string workingDirectory, string artifactDirectory)
{
IntegrationRequest initialRequest = new IntegrationRequest(BuildCondition.ForceBuild, "Initial Build", null);
IntegrationResult result = new IntegrationResult(project, workingDirectory, artifactDirectory, initialRequest, IntegrationSummary.Initial);
result.StartTime = DateTime.Now.AddDays(-1);
result.EndTime = DateTime.Now;
return(result);
}
private void PollTriggers()
{
IntegrationRequest triggeredRequest = trigger.Fire();
if (triggeredRequest != null)
{
AddToQueue(triggeredRequest);
}
}
public void ConstructorSetsProperties()
{
var request = new IntegrationRequest("Test");
var project = new Project();
var context = new TaskExecutionContext(new TaskExecutionParameters
{
IntegrationRequest = request,
Project = project
});
Assert.AreSame(request, context.Request);
Assert.AreSame(project, context.Project);
Assert.IsNotNull(context.ModificationSets);
}
/// <summary>
/// Starts a new <see cref="TaskExecutionContext"/>.
/// </summary>
/// <param name="project">The project.</param>
/// <param name="request">The request.</param>
/// <returns>
/// The new <see cref="TaskExecutionContext"/>.
/// </returns>
public TaskExecutionContext StartNew(Project project, IntegrationRequest request)
{
logger.Debug("Starting execution context for project '{0}", project.Name);
var buildName = this.Clock.Now.ToString("yyyyMMddHHmmss");
var logFile = TaskExecutionContext.GenerateArtifactFileName(project, buildName, "build.log");
this.FileSystem.EnsureFolderExists(Path.GetDirectoryName(logFile));
var writer = this.FileSystem.CreateXmlWriter(logFile);
writer.WriteStartElement("project");
writer.WriteAttributeString("name", project.Name);
writer.WriteElementString("start", this.Clock.Now.ToString("s"));
var parameters = new TaskExecutionParameters
{
XmlWriter = writer,
FileSystem = this.FileSystem,
Clock = this.Clock,
IntegrationRequest = request,
Project = project,
BuildName = buildName
};
var context = new TaskExecutionContext(parameters);
return context;
}
public void IntegrateHandlesErrorDuringTaskCleanUp()
{
var initialised = false;
var ran = false;
var dummy = new TaskStub
{
OnInitialiseAction = () => initialised = true,
OnRunAction = c =>
{
ran = true;
return null;
},
OnCleanUpAction = () =>
{
throw new Exception("Oops");
}
};
var executionFactoryMock = new Mock<ITaskExecutionFactory>(MockBehavior.Strict);
InitialiseExecutionContext(executionFactoryMock);
var project = new Project("test", dummy)
{
TaskExecutionFactory = executionFactoryMock.Object
};
var request = new IntegrationRequest("Dummy");
project.Integrate(request);
Assert.IsTrue(initialised);
Assert.IsTrue(ran);
}
public void IntegrateInitialisesAndCleansUpSourceControl()
{
var initialised = false;
var cleanedUp = false;
var dummy = new SourceControlBlockStub
{
OnInitialise = () => initialised = true,
OnCleanUp = () => cleanedUp = true
};
var executionFactoryMock = new Mock<ITaskExecutionFactory>(MockBehavior.Strict);
InitialiseExecutionContext(executionFactoryMock);
var project = new Project("test")
{
TaskExecutionFactory = executionFactoryMock.Object
};
project.SourceControl.Add(dummy);
var request = new IntegrationRequest("Dummy");
project.Integrate(request);
Assert.IsTrue(initialised);
Assert.IsTrue(cleanedUp);
}
/// <summary>
/// Initialise a new instance of <see cref="IntegrationStartedEventArgs"/>.
/// </summary>
/// <param name="projectName"></param>
/// <param name="request">The request to process.</param>
public IntegrationStartedEventArgs(IntegrationRequest request, string projectName)
: base(projectName)
{
this.request = request;
}
public void IntegrateHandlesErrorDuringSourceControlCleanUp()
{
var initialised = false;
var dummy = new SourceControlBlockStub
{
OnInitialise = () => initialised = true,
OnCleanUp = () =>
{
throw new Exception("Oops");
}
};
var executionFactoryMock = new Mock<ITaskExecutionFactory>(MockBehavior.Strict);
InitialiseExecutionContext(executionFactoryMock);
var project = new Project("test")
{
TaskExecutionFactory = executionFactoryMock.Object
};
project.SourceControl.Add(dummy);
var request = new IntegrationRequest("Dummy");
project.Integrate(request);
Assert.IsTrue(initialised);
}
public void IntegrateResetsTriggers()
{
var reset = false;
var dummy = new TriggerStub
{
OnResetAction = () => reset = true
};
var executionFactoryMock = new Mock<ITaskExecutionFactory>(MockBehavior.Strict);
InitialiseExecutionContext(executionFactoryMock);
var project = new ProjectStub("test")
{
TaskExecutionFactory = executionFactoryMock.Object
};
project.Triggers.Add(dummy);
var request = new IntegrationRequest("Dummy");
project.Integrate(request);
Assert.IsTrue(reset);
}
public void IntegrateHandlesErrorDuringTriggerReset()
{
var dummy = new TriggerStub
{
OnResetAction = () =>
{
throw new Exception("Oops");
}
};
var executionFactoryMock = new Mock<ITaskExecutionFactory>(MockBehavior.Strict);
InitialiseExecutionContext(executionFactoryMock);
var project = new Project("test")
{
TaskExecutionFactory = executionFactoryMock.Object
};
project.Triggers.Add(dummy);
var request = new IntegrationRequest("Dummy");
project.Integrate(request);
}
public void IntegrateSkipsTasksWhoseConditionsFail()
{
var conditionMock = new Mock<TaskCondition>(MockBehavior.Strict);
conditionMock.Setup(c => c.Evaluate(It.IsAny<TaskExecutionContext>()))
.Returns(false);
var initialised = false;
var ran = false;
var cleanedUp = false;
var dummy = new TaskStub
{
OnInitialiseAction = () => initialised = true,
OnRunAction = c =>
{
ran = true;
return null;
},
OnCleanUpAction = () => cleanedUp = true
};
dummy.Conditions.Add(conditionMock.Object);
var executionFactoryMock = new Mock<ITaskExecutionFactory>(MockBehavior.Strict);
var contextMock = InitialiseExecutionContext(executionFactoryMock);
contextMock.Setup(ec => ec.AddEntryToBuildLog("Task 'TaskStub' has been skipped"));
var project = new Project("test", dummy)
{
TaskExecutionFactory = executionFactoryMock.Object
};
var request = new IntegrationRequest("Dummy");
project.Integrate(request);
Assert.IsTrue(initialised);
Assert.IsFalse(ran);
Assert.IsTrue(cleanedUp);
}
/// <summary>
/// Initialise a new instance of <see cref="IntegrationCompletedEventArgs"/>.
/// </summary>
/// <param name="request">The request to process.</param>
/// <param name="projectName"></param>
/// <param name="status"></param>
public IntegrationCompletedEventArgs(IntegrationRequest request, string projectName, IntegrationStatus status)
: base(projectName)
{
this.request = request;
this.status = status;
}
public void IntegrateHandlesErrorDuringInitialisation()
{
var ran = false;
var cleanedUp = false;
var dummy = new TaskStub
{
OnInitialiseAction = () =>
{
throw new Exception("Oops!");
},
OnRunAction = c =>
{
ran = true;
return null;
},
OnCleanUpAction = () => cleanedUp = true
};
var project = new Project("test", dummy);
var request = new IntegrationRequest("Dummy");
project.Integrate(request);
Assert.IsFalse(ran);
Assert.IsTrue(cleanedUp);
}
public override IntegrationStatus Integrate(IntegrationRequest request)
{
return this.OnIntegrate == null ?
base.Integrate(request) :
this.OnIntegrate(request);
}
public void IntegrateInitialisesRunsAndCleansUp()
{
var initialised = false;
var ran = false;
var cleanedUp = false;
var dummy = new TaskStub
{
OnInitialiseAction = () => initialised = true,
OnRunAction = c => { ran = true; return null; },
OnCleanUpAction = () => cleanedUp = true
};
var executionFactoryMock = new Mock<ITaskExecutionFactory>(MockBehavior.Strict);
InitialiseExecutionContext(executionFactoryMock);
var project = new Project("test", dummy)
{
TaskExecutionFactory = executionFactoryMock.Object
};
var request = new IntegrationRequest("Dummy");
project.Integrate(request);
Assert.IsTrue(initialised);
Assert.IsTrue(ran);
Assert.IsTrue(cleanedUp);
}
