public void ExecuteLoadsContentsFileIfItExists()
{
var workingDir = System.IO.Path.Combine("workingDir", "NDependResults");
var result = GenerateResultMock();
var executor = GenerateExecutorMock(System.IO.Path.Combine("workingDir", "NDepend.Console"), workingDir + " /OutDir " + workingDir, "workingDir", 600000);
var fileSystem = mocks.Create <IFileSystem>(MockBehavior.Strict).Object;
MockSequence sequence = new MockSequence();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.DirectoryExists(workingDir)).Returns(true).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.GetFilesInDirectory(workingDir)).Returns(new string[0]).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.FileExists(System.IO.Path.Combine("workingDir", "NDependResults", "ReportResources.xml"))).Returns(true).Verifiable();
using (var reader = new StringReader("<ReportResources><File>file1.txt</File><File>file2.xml</File></ReportResources>"))
{
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.Load(System.IO.Path.Combine("workingDir", "NDependResults", "ReportResources.xml"))).Returns(reader).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.DirectoryExists(System.IO.Path.Combine("artefactDir", "1", "NDepend"))).Returns(false).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.CreateDirectory(System.IO.Path.Combine("artefactDir", "1", "NDepend"))).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.FileExists(System.IO.Path.Combine("workingDir", "NDependResults", "file1.txt"))).Returns(true).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.Copy(System.IO.Path.Combine("workingDir", "NDependResults", "file1.txt"), System.IO.Path.Combine("artefactDir", "1", "NDepend", "file1.txt"))).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.FileExists(System.IO.Path.Combine("workingDir", "NDependResults", "file2.xml"))).Returns(true).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.Copy(System.IO.Path.Combine("workingDir", "NDependResults", "file2.xml"), System.IO.Path.Combine("artefactDir", "1", "NDepend", "file2.xml"))).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.GenerateTaskResultFromFile(System.IO.Path.Combine("workingDir", "NDependResults", "file2.xml"))).Returns(mocks.Create <ITaskResult>().Object).Verifiable();
var logger = mocks.Create <ILogger>().Object;
var task = new NDependTask(executor, fileSystem, logger);
Mock.Get(result).SetupProperty(_result => _result.Status);
result.Status = IntegrationStatus.Unknown;
task.Run(result);
mocks.Verify();
}
}
public void CanOverrideBaseDirectory()
{
var workingDir = System.IO.Path.Combine("somewhere-else", "NDependResults");
var result = GenerateResultMock();
var executor = GenerateExecutorMock(System.IO.Path.Combine("somewhere-else", "NDepend.Console"), workingDir + " /OutDir " + workingDir, "somewhere-else", 600000);
var fileSystem = mocks.Create <IFileSystem>(MockBehavior.Strict).Object;
MockSequence sequence = new MockSequence();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.DirectoryExists(workingDir)).Returns(true).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.GetFilesInDirectory(workingDir)).Returns(new string[0]).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.FileExists(System.IO.Path.Combine("somewhere-else", "NDependResults", "ReportResources.xml"))).Returns(false).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.DirectoryExists(workingDir)).Returns(true).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.GetFilesInDirectory(workingDir)).Returns(new string[] {
System.IO.Path.Combine("somewhere-else", "NDependResults", "file1.txt"),
System.IO.Path.Combine("somewhere-else", "NDependResults", "file2.xml")
}).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.DirectoryExists(System.IO.Path.Combine("artefactDir", "1", "NDepend"))).Returns(true).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.FileExists(System.IO.Path.Combine("somewhere-else", "NDependResults", "file1.txt"))).Returns(true).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.Copy(System.IO.Path.Combine("somewhere-else", "NDependResults", "file1.txt"), System.IO.Path.Combine("artefactDir", "1", "NDepend", "file1.txt"))).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.FileExists(System.IO.Path.Combine("somewhere-else", "NDependResults", "file2.xml"))).Returns(true).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.Copy(System.IO.Path.Combine("somewhere-else", "NDependResults", "file2.xml"), System.IO.Path.Combine("artefactDir", "1", "NDepend", "file2.xml"))).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.GenerateTaskResultFromFile(System.IO.Path.Combine("somewhere-else", "NDependResults", "file2.xml"))).Returns(mocks.Create <ITaskResult>().Object).Verifiable();
var logger = mocks.Create <ILogger>().Object;
var task = new NDependTask(executor, fileSystem, logger);
task.BaseDirectory = "somewhere-else";
Mock.Get(result).SetupProperty(_result => _result.Status);
result.Status = IntegrationStatus.Unknown;
task.Run(result);
mocks.Verify();
}
public void DefaultConstructorSetsFileSystemAndLogger()
{
var task = new NDependTask();
Assert.IsInstanceOf <SystemIoFileSystem>(task.FileSystem);
Assert.IsInstanceOf <DefaultLogger>(task.Logger);
}
public void ExecuteLoadsContentsFileIfItExists()
{
var workingDir = "workingDir\\NDependResults";
var result = GenerateResultMock();
var executor = GenerateExecutorMock("workingDir\\NDepend.Console", "workingDir\\NDependResults /OutDir workingDir\\NDependResults", "workingDir", 600000);
var fileSystem = mocks.StrictMock <IFileSystem>();
Expect.Call(fileSystem.DirectoryExists(workingDir)).Return(true);
Expect.Call(fileSystem.GetFilesInDirectory(workingDir)).Return(new string[0]);
Expect.Call(fileSystem.FileExists("workingDir\\NDependResults\\ReportResources.xml")).Return(true);
using (var reader = new StringReader("<ReportResources><File>file1.txt</File><File>file2.xml</File></ReportResources>"))
{
Expect.Call(fileSystem.Load("workingDir\\NDependResults\\ReportResources.xml")).Return(reader);
Expect.Call(fileSystem.DirectoryExists("artefactDir\\1\\NDepend")).Return(false);
Expect.Call(() => fileSystem.CreateDirectory("artefactDir\\1\\NDepend"));
Expect.Call(fileSystem.FileExists("workingDir\\NDependResults\\file1.txt")).Return(true);
Expect.Call(() => fileSystem.Copy("workingDir\\NDependResults\\file1.txt", "artefactDir\\1\\NDepend\\file1.txt"));
Expect.Call(fileSystem.FileExists("workingDir\\NDependResults\\file2.xml")).Return(true);
Expect.Call(() => fileSystem.Copy("workingDir\\NDependResults\\file2.xml", "artefactDir\\1\\NDepend\\file2.xml"));
Expect.Call(fileSystem.GenerateTaskResultFromFile("workingDir\\NDependResults\\file2.xml")).Return(mocks.DynamicMock <ITaskResult>());
var logger = mocks.DynamicMock <ILogger>();
var task = new NDependTask(executor, fileSystem, logger);
Expect.Call(result.Status).PropertyBehavior();
mocks.ReplayAll();
result.Status = IntegrationStatus.Unknown;
task.Run(result);
mocks.VerifyAll();
}
}
public void CanOverrideBaseDirectory()
{
var workingDir = "somewhere-else\\NDependResults";
var result = GenerateResultMock();
var executor = GenerateExecutorMock("somewhere-else\\NDepend.Console", "somewhere-else\\NDependResults /OutDir somewhere-else\\NDependResults", "somewhere-else", 600000);
var fileSystem = mocks.StrictMock <IFileSystem>();
Expect.Call(fileSystem.DirectoryExists(workingDir)).Return(true).Repeat.Times(2);
Expect.Call(fileSystem.GetFilesInDirectory(workingDir)).Return(new string[0]);
Expect.Call(fileSystem.FileExists("somewhere-else\\NDependResults\\ReportResources.xml")).Return(false);
Expect.Call(fileSystem.GetFilesInDirectory(workingDir)).Return(new string[] {
"somewhere-else\\NDependResults\\file1.txt",
"somewhere-else\\NDependResults\\file2.xml"
});
Expect.Call(fileSystem.DirectoryExists("artefactDir\\1\\NDepend")).Return(true);
Expect.Call(fileSystem.FileExists("somewhere-else\\NDependResults\\file1.txt")).Return(true);
Expect.Call(() => fileSystem.Copy("somewhere-else\\NDependResults\\file1.txt", "artefactDir\\1\\NDepend\\file1.txt"));
Expect.Call(fileSystem.FileExists("somewhere-else\\NDependResults\\file2.xml")).Return(true);
Expect.Call(() => fileSystem.Copy("somewhere-else\\NDependResults\\file2.xml", "artefactDir\\1\\NDepend\\file2.xml"));
Expect.Call(fileSystem.GenerateTaskResultFromFile("somewhere-else\\NDependResults\\file2.xml")).Return(mocks.DynamicMock <ITaskResult>());
var logger = mocks.DynamicMock <ILogger>();
var task = new NDependTask(executor, fileSystem, logger);
task.BaseDirectory = "somewhere-else";
Expect.Call(result.Status).PropertyBehavior();
mocks.ReplayAll();
result.Status = IntegrationStatus.Unknown;
task.Run(result);
mocks.VerifyAll();
}
public void RunningOnExistingDirectoryChecksFilesAndCopiesWhenNewer()
{
var workingDir = "workingDir\\NDependResults";
var result = GenerateResultMock();
var executor = GenerateExecutorMock("workingDir\\NDepend.Console", "workingDir\\NDependResults /OutDir workingDir\\NDependResults", "workingDir", 600000);
var fileSystem = mocks.StrictMock <IFileSystem>();
Expect.Call(fileSystem.DirectoryExists(workingDir)).Return(true).Repeat.Times(2);
Expect.Call(fileSystem.GetFilesInDirectory(workingDir)).Return(new string[] {
"workingDir\\NDependResults\\file1.txt",
"workingDir\\NDependResults\\file2.xml"
});
Expect.Call(fileSystem.FileExists("workingDir\\NDependResults\\ReportResources.xml")).Return(false);
Expect.Call(fileSystem.GetFilesInDirectory(workingDir)).Return(new string[] {
"workingDir\\NDependResults\\file1.txt",
"workingDir\\NDependResults\\file2.xml"
});
Expect.Call(fileSystem.DirectoryExists("artefactDir\\1\\NDepend")).Return(true);
Expect.Call(fileSystem.FileExists("workingDir\\NDependResults\\file1.txt")).Return(true);
Expect.Call(() => fileSystem.Copy("workingDir\\NDependResults\\file1.txt", "artefactDir\\1\\NDepend\\file1.txt"));
var baseTime = DateTime.Now;
Expect.Call(fileSystem.GetLastWriteTime("workingDir\\NDependResults\\file1.txt")).Return(baseTime);
Expect.Call(fileSystem.GetLastWriteTime("workingDir\\NDependResults\\file2.xml")).Return(baseTime).Repeat.Times(2);
Expect.Call(fileSystem.GetLastWriteTime("workingDir\\NDependResults\\file1.txt")).Return(baseTime.AddMinutes(1));
var logger = mocks.DynamicMock <ILogger>();
var task = new NDependTask(executor, fileSystem, logger);
Expect.Call(result.Status).PropertyBehavior();
mocks.ReplayAll();
result.Status = IntegrationStatus.Unknown;
task.Run(result);
mocks.VerifyAll();
}
public void CanUsePathsWithSpaces()
{
var workingDir = "working Dir\\NDependResults";
var result = GenerateResultMock("working Dir", "artefact Dir");
var executor = GenerateExecutorMock("working Dir\\ndepend-app.exe", "\"working Dir\\NDependResults\" /OutDir \"working Dir\\NDependResults\"", "working Dir", 600000);
var fileSystem = mocks.StrictMock <IFileSystem>();
Expect.Call(fileSystem.DirectoryExists(workingDir)).Return(true).Repeat.Times(2);
Expect.Call(fileSystem.GetFilesInDirectory(workingDir)).Return(new string[0]);
Expect.Call(fileSystem.FileExists("working Dir\\NDependResults\\ReportResources.xml")).Return(false);
Expect.Call(fileSystem.GetFilesInDirectory(workingDir)).Return(new string[] {
"working Dir\\NDependResults\\file1.txt",
"working Dir\\NDependResults\\file2.xml"
});
Expect.Call(fileSystem.DirectoryExists("artefact Dir\\1\\NDepend")).Return(true);
Expect.Call(fileSystem.FileExists("working Dir\\NDependResults\\file1.txt")).Return(true);
Expect.Call(() => fileSystem.Copy("working Dir\\NDependResults\\file1.txt", "artefact Dir\\1\\NDepend\\file1.txt"));
Expect.Call(fileSystem.FileExists("working Dir\\NDependResults\\file2.xml")).Return(true);
Expect.Call(() => fileSystem.Copy("working Dir\\NDependResults\\file2.xml", "artefact Dir\\1\\NDepend\\file2.xml"));
Expect.Call(fileSystem.GenerateTaskResultFromFile("working Dir\\NDependResults\\file2.xml")).Return(mocks.DynamicMock <ITaskResult>());
var logger = mocks.DynamicMock <ILogger>();
var task = new NDependTask(executor, fileSystem, logger);
task.Executable = "ndepend-app.exe";
Expect.Call(result.Status).PropertyBehavior();
mocks.ReplayAll();
result.Status = IntegrationStatus.Unknown;
task.Run(result);
mocks.VerifyAll();
}
public void ExecuteWillCreateANewDirectory()
{
var workingDir = "workingDir\\NDependResults";
var result = GenerateResultMock();
var executor = GenerateExecutorMock("workingDir\\NDepend.Console", "workingDir\\NDependResults /OutDir workingDir\\NDependResults", "workingDir", 600000);
var fileSystem = mocks.Create <IFileSystem>(MockBehavior.Strict).Object;
MockSequence sequence = new MockSequence();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.DirectoryExists(workingDir)).Returns(true).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.GetFilesInDirectory(workingDir)).Returns(new string[0]).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.FileExists("workingDir\\NDependResults\\ReportResources.xml")).Returns(false).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.DirectoryExists(workingDir)).Returns(true).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.GetFilesInDirectory(workingDir)).Returns(new string[] {
"workingDir\\NDependResults\\file1.txt",
"workingDir\\NDependResults\\file2.xml"
}).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.DirectoryExists("artefactDir\\1\\NDepend")).Returns(false).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.CreateDirectory("artefactDir\\1\\NDepend")).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.FileExists("workingDir\\NDependResults\\file1.txt")).Returns(true).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.Copy("workingDir\\NDependResults\\file1.txt", "artefactDir\\1\\NDepend\\file1.txt")).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.FileExists("workingDir\\NDependResults\\file2.xml")).Returns(true).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.Copy("workingDir\\NDependResults\\file2.xml", "artefactDir\\1\\NDepend\\file2.xml")).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.GenerateTaskResultFromFile("workingDir\\NDependResults\\file2.xml")).Returns(mocks.Create <ITaskResult>().Object).Verifiable();
var logger = mocks.Create <ILogger>().Object;
var task = new NDependTask(executor, fileSystem, logger);
Mock.Get(result).SetupProperty(_result => _result.Status);
result.Status = IntegrationStatus.Unknown;
task.Run(result);
mocks.Verify();
}
public void ExecuteLoadsContentsFileIfItExistsAndImportsDirectory()
{
var workingDir = "workingDir\\NDependResults";
var result = GenerateResultMock();
var executor = GenerateExecutorMock("workingDir\\NDepend.Console", "workingDir\\NDependResults /OutDir workingDir\\NDependResults", "workingDir", 600000);
var fileSystem = mocks.Create <IFileSystem>(MockBehavior.Strict).Object;
MockSequence sequence = new MockSequence();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.DirectoryExists(workingDir)).Returns(true).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.GetFilesInDirectory(workingDir)).Returns(new string[0]).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.FileExists("workingDir\\NDependResults\\ReportResources.xml")).Returns(true).Verifiable();
using (var reader = new StringReader("<ReportResources><Directory>images</Directory></ReportResources>"))
{
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.Load("workingDir\\NDependResults\\ReportResources.xml")).Returns(reader).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.GetFilesInDirectory("workingDir\\NDependResults\\images", true)).Returns(new[] { "workingDir\\NDependResults\\images\\test.png" }).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.DirectoryExists("artefactDir\\1\\NDepend\\images")).Returns(false).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.CreateDirectory("artefactDir\\1\\NDepend\\images")).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.FileExists("workingDir\\NDependResults\\images\\test.png")).Returns(true).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.Copy("workingDir\\NDependResults\\images\\test.png", "artefactDir\\1\\NDepend\\images\\test.png")).Verifiable();
var logger = mocks.Create <ILogger>().Object;
var task = new NDependTask(executor, fileSystem, logger);
Mock.Get(result).SetupProperty(_result => _result.Status);
result.Status = IntegrationStatus.Unknown;
task.Run(result);
mocks.Verify();
}
}
public void AllApplicationArgsAreSet()
{
var workingDir = System.IO.Path.Combine("workingDir", "out-dir");
var result = GenerateResultMock();
var executor = GenerateExecutorMock(System.IO.Path.Combine("workingDir", "NDepend.Console"),
System.IO.Path.Combine("workingDir", "test.project") + " /Silent /EmitVisualNDependBinXml /InDirs " + System.IO.Path.Combine("workingDir", "dir1") + " " + System.IO.Path.Combine("workingDir", "dir2") +
" /OutDir " + workingDir + " /XslForReport " + System.IO.Path.Combine("workingDir", "report.xslt"),
"workingDir", 600000);
var fileSystem = mocks.Create <IFileSystem>(MockBehavior.Strict).Object;
MockSequence sequence = new MockSequence();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.DirectoryExists(workingDir)).Returns(true).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.GetFilesInDirectory(workingDir)).Returns(new string[0]).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.FileExists(System.IO.Path.Combine("workingDir", "out-dir", "ReportResources.xml"))).Returns(false).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.DirectoryExists(workingDir)).Returns(true).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.GetFilesInDirectory(workingDir)).Returns(new string[] {
System.IO.Path.Combine("workingDir", "out-dir", "file1.txt"),
System.IO.Path.Combine("workingDir", "out-dir", "file2.xml")
}).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.DirectoryExists(System.IO.Path.Combine("artefactDir", "1", "NDepend"))).Returns(true).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.FileExists(System.IO.Path.Combine("workingDir", "out-dir", "file1.txt"))).Returns(true).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.Copy(System.IO.Path.Combine("workingDir", "out-dir", "file1.txt"), System.IO.Path.Combine("artefactDir", "1", "NDepend", "file1.txt"))).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.FileExists(System.IO.Path.Combine("workingDir", "out-dir", "file2.xml"))).Returns(true).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.Copy(System.IO.Path.Combine("workingDir", "out-dir", "file2.xml"), System.IO.Path.Combine("artefactDir", "1", "NDepend", "file2.xml"))).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.GenerateTaskResultFromFile(System.IO.Path.Combine("workingDir", "out-dir", "file2.xml"))).Returns(mocks.Create <ITaskResult>().Object).Verifiable();
var logger = mocks.Create <ILogger>().Object;
var task = new NDependTask(executor, fileSystem, logger);
task.ProjectFile = "test.project";
task.Silent = true;
task.EmitXml = true;
task.InputDirs = new string[]
{
"dir1",
"dir2"
};
task.OutputDir = "out-dir";
task.ReportXslt = "report.xslt";
Mock.Get(result).SetupProperty(_result => _result.Status);
result.Status = IntegrationStatus.Unknown;
task.Run(result);
mocks.Verify();
}
public void AllApplicationArgsAreSet()
{
var workingDir = "workingDir\\out-dir";
var result = GenerateResultMock();
var executor = GenerateExecutorMock("workingDir\\NDepend.Console",
"workingDir\\test.project /Silent /EmitVisualNDependBinXml /InDirs workingDir\\dir1 workingDir\\dir2 /OutDir workingDir\\out-dir /XslForReport workingDir\\report.xslt",
"workingDir", 600000);
var fileSystem = mocks.StrictMock <IFileSystem>();
Expect.Call(fileSystem.DirectoryExists(workingDir)).Return(true).Repeat.Times(2);
Expect.Call(fileSystem.GetFilesInDirectory(workingDir)).Return(new string[0]);
Expect.Call(fileSystem.FileExists("workingDir\\out-dir\\ReportResources.xml")).Return(false);
Expect.Call(fileSystem.GetFilesInDirectory(workingDir)).Return(new string[] {
"workingDir\\out-dir\\file1.txt",
"workingDir\\out-dir\\file2.xml"
});
Expect.Call(fileSystem.DirectoryExists("artefactDir\\1\\NDepend")).Return(true);
Expect.Call(fileSystem.FileExists("workingDir\\out-dir\\file1.txt")).Return(true);
Expect.Call(() => fileSystem.Copy("workingDir\\out-dir\\file1.txt", "artefactDir\\1\\NDepend\\file1.txt"));
Expect.Call(fileSystem.FileExists("workingDir\\out-dir\\file2.xml")).Return(true);
Expect.Call(() => fileSystem.Copy("workingDir\\out-dir\\file2.xml", "artefactDir\\1\\NDepend\\file2.xml"));
Expect.Call(fileSystem.GenerateTaskResultFromFile("workingDir\\out-dir\\file2.xml")).Return(mocks.DynamicMock <ITaskResult>());
var logger = mocks.DynamicMock <ILogger>();
var task = new NDependTask(executor, fileSystem, logger);
task.ProjectFile = "test.project";
task.Silent = true;
task.EmitXml = true;
task.InputDirs = new string[]
{
"dir1",
"dir2"
};
task.OutputDir = "out-dir";
task.ReportXslt = "report.xslt";
Expect.Call(result.Status).PropertyBehavior();
mocks.ReplayAll();
result.Status = IntegrationStatus.Unknown;
task.Run(result);
mocks.VerifyAll();
}
public void ExecuteFailsIfContentFileIsInvalid()
{
var workingDir = System.IO.Path.Combine("workingDir", "NDependResults");
var result = GenerateResultMock();
var executor = GenerateExecutorMock(System.IO.Path.Combine("workingDir", "NDepend.Console"), workingDir + " /OutDir " + workingDir, "workingDir", 600000);
var fileSystem = mocks.Create <IFileSystem>(MockBehavior.Strict).Object;
MockSequence sequence = new MockSequence();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.DirectoryExists(workingDir)).Returns(true).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.GetFilesInDirectory(workingDir)).Returns(new string[0]).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.FileExists(System.IO.Path.Combine("workingDir", "NDependResults", "ReportResources.xml"))).Returns(true).Verifiable();
using (var reader = new StringReader("garbage"))
{
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.Load(System.IO.Path.Combine("workingDir", "NDependResults", "ReportResources.xml"))).Returns(reader).Verifiable();
var logger = mocks.Create <ILogger>().Object;
var task = new NDependTask(executor, fileSystem, logger);
Mock.Get(result).SetupProperty(_result => _result.Status);
result.Status = IntegrationStatus.Unknown;
Assert.Throws <CruiseControlException>(() => task.Run(result));
mocks.Verify();
}
}
public void ExecuteFailsIfContentFileIsInvalid()
{
var workingDir = "workingDir\\NDependResults";
var result = GenerateResultMock();
var executor = GenerateExecutorMock("workingDir\\NDepend.Console", "workingDir\\NDependResults /OutDir workingDir\\NDependResults", "workingDir", 600000);
var fileSystem = mocks.StrictMock <IFileSystem>();
Expect.Call(fileSystem.DirectoryExists(workingDir)).Return(true);
Expect.Call(fileSystem.GetFilesInDirectory(workingDir)).Return(new string[0]);
Expect.Call(fileSystem.FileExists("workingDir\\NDependResults\\ReportResources.xml")).Return(true);
using (var reader = new StringReader("garbage"))
{
Expect.Call(fileSystem.Load("workingDir\\NDependResults\\ReportResources.xml")).Return(reader);
var logger = mocks.DynamicMock <ILogger>();
var task = new NDependTask(executor, fileSystem, logger);
Expect.Call(result.Status).PropertyBehavior();
mocks.ReplayAll();
result.Status = IntegrationStatus.Unknown;
Assert.Throws <CruiseControlException>(() => task.Run(result));
mocks.VerifyAll();
}
}
public void RunningOnExistingDirectoryChecksFilesAndCopiesWhenNewer()
{
var workingDir = System.IO.Path.Combine("workingDir", "NDependResults");
var result = GenerateResultMock();
var executor = GenerateExecutorMock(System.IO.Path.Combine("workingDir", "NDepend.Console"), workingDir + " /OutDir " + workingDir, "workingDir", 600000);
var fileSystem = mocks.Create <IFileSystem>(MockBehavior.Strict).Object;
MockSequence sequence = new MockSequence();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.DirectoryExists(workingDir)).Returns(true).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.GetFilesInDirectory(workingDir)).Returns(new string[] {
System.IO.Path.Combine("workingDir", "NDependResults", "file1.txt"),
System.IO.Path.Combine("workingDir", "NDependResults", "file2.xml")
}).Verifiable();
var baseTime = DateTime.Now;
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.GetLastWriteTime(System.IO.Path.Combine("workingDir", "NDependResults", "file1.txt"))).Returns(baseTime).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.GetLastWriteTime(System.IO.Path.Combine("workingDir", "NDependResults", "file2.xml"))).Returns(baseTime).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.FileExists(System.IO.Path.Combine("workingDir", "NDependResults", "ReportResources.xml"))).Returns(false).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.DirectoryExists(workingDir)).Returns(true).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.GetFilesInDirectory(workingDir)).Returns(new string[] {
System.IO.Path.Combine("workingDir", "NDependResults", "file1.txt"),
System.IO.Path.Combine("workingDir", "NDependResults", "file2.xml")
}).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.GetLastWriteTime(System.IO.Path.Combine("workingDir", "NDependResults", "file1.txt"))).Returns(baseTime.AddMinutes(1)).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.GetLastWriteTime(System.IO.Path.Combine("workingDir", "NDependResults", "file2.xml"))).Returns(baseTime).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.DirectoryExists(System.IO.Path.Combine("artefactDir", "1", "NDepend"))).Returns(true).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.FileExists(System.IO.Path.Combine("workingDir", "NDependResults", "file1.txt"))).Returns(true).Verifiable();
Mock.Get(fileSystem).InSequence(sequence).Setup(_fileSystem => _fileSystem.Copy(System.IO.Path.Combine("workingDir", "NDependResults", "file1.txt"), System.IO.Path.Combine("artefactDir", "1", "NDepend", "file1.txt"))).Verifiable();
var logger = mocks.Create <ILogger>().Object;
var task = new NDependTask(executor, fileSystem, logger);
Mock.Get(result).SetupProperty(_result => _result.Status);
result.Status = IntegrationStatus.Unknown;
task.Run(result);
mocks.Verify();
}
