public void FixtureInit()
{
ilMergeAvailable = File.Exists(
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles),
@"Microsoft\ILMerge\ILMerge.exe"));
MockBuild buildEngine = new MockBuild();
testDirectory = TaskUtility.makeTestDirectory(buildEngine);
ILMerge task = new ILMerge();
task.BuildEngine = buildEngine;
if (TaskUtility.CalledInBuildDirectory)
{
assemblyA = Path.Combine(testDirectory, @"A.dll");
assemblyB = Path.Combine(testDirectory, @"B.dll");
excludeFile = Path.Combine(testDirectory, @"ExcludeTypes.txt");
keyFile = Path.Combine(testDirectory, @"keypair.snk");
}
else
{
string config = TaskUtility.BuildConfiguration;
string assDir = Path.GetFullPath(TaskUtility.AssemblyDirectory);
assemblyA = Path.GetFullPath(Path.Combine(assDir, @"..\..\ILMerge\A\bin\" + config + @"\A.dll"));
assemblyB = Path.GetFullPath(Path.Combine(assDir, @"..\..\ILMerge\B\bin\" + config + @"\B.dll"));
excludeFile = Path.Combine(assDir, @"ILMerge\ExcludeTypes.txt");
keyFile = Path.Combine(assDir, @"ILMerge\keypair.snk");
}
inputAssemblies = TaskUtility.StringArrayToItemArray(assemblyA, assemblyB);
}
public void FixtureInit()
{
MockBuild buildEngine = new MockBuild();
this.testDirectory = TaskUtility.makeTestDirectory(buildEngine);
if (TaskUtility.CalledInBuildDirectory)
{
this.assemblyA = Path.Combine(this.testDirectory, @"A.dll");
this.assemblyB = Path.Combine(this.testDirectory, @"B.dll");
this.excludeFile = Path.Combine(this.testDirectory, @"ExcludeTypes.txt");
this.keyFile = Path.Combine(this.testDirectory, @"keypair.snk");
}
else
{
string config = TaskUtility.BuildConfiguration;
string assDir = Path.GetFullPath(TaskUtility.AssemblyDirectory);
this.assemblyA = Path.GetFullPath(Path.Combine(assDir, @"..\..\ILMerge\A\bin\" + config + @"\A.dll"));
this.assemblyB = Path.GetFullPath(Path.Combine(assDir, @"..\..\ILMerge\B\bin\" + config + @"\B.dll"));
this.excludeFile = Path.Combine(assDir, @"ILMerge\ExcludeTypes.txt");
this.keyFile = Path.Combine(assDir, @"ILMerge\keypair.snk");
}
this.inputAssemblies = TaskUtility.StringArrayToItemArray(this.assemblyA, this.assemblyB);
}
public void ZipRelativeExecute()
{
var task = new Zip();
task.BuildEngine = new MockBuild();
string testDir = TaskUtility.TestDirectory;
string prjRootPath = TaskUtility.GetProjectRootDirectory(true);
string workingDir = Path.Combine(prjRootPath, @"Source\MSBuild.Community.Tasks.Tests");
List <string> files = Directory.GetFiles(workingDir, "*.*", SearchOption.TopDirectoryOnly).ToList();
files.Add(Path.Combine(workingDir, "..\\..\\readme.md"));
TaskItem[] items = TaskUtility.StringArrayToItemArray(files.ToArray());
task.Files = items;
task.WorkingDirectory = workingDir;
task.ZipFileName = Path.Combine(testDir, ZIP_WITH_RELATIVE_FILE_NAME);
if (File.Exists(task.ZipFileName))
{
File.Delete(task.ZipFileName);
}
Assert.IsTrue(task.Execute(), "Execute Failed");
Assert.IsTrue(ZipFile.Read(task.ZipFileName).ContainsEntry("readme.md"), "The zip doesnt contains the readme.md file");
Assert.IsTrue(File.Exists(task.ZipFileName), "Zip file not found");
}
public void NUnitExecute()
{
#region Find NUnit installation
string nunitPath = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles);
nunitPath = Path.Combine(nunitPath, NUnit.DEFAULT_NUNIT_DIRECTORY);
RegistryKey buildKey = Registry.ClassesRoot.OpenSubKey(@"NUnitTestProject\shell\open\command");
if (buildKey == null)
{
Assert.Ignore(@"Can't find NUnit installation");
}
nunitPath = buildKey.GetValue(null, nunitPath).ToString();
Regex nunitRegex = new Regex("(.+)nunit-gui\\.exe", RegexOptions.IgnoreCase);
Match pathMatch = nunitRegex.Match(nunitPath);
nunitPath = pathMatch.Groups[1].Value.Replace("\"", "");
#endregion Find NUnit installation
MockBuild buildEngine = new MockBuild();
string testDirectory = TaskUtility.makeTestDirectory(buildEngine);
NUnit task = new NUnit();
task.BuildEngine = buildEngine;
task.Assemblies = TaskUtility.StringArrayToItemArray(
Path.Combine(nunitPath, "nunit.framework.tests.dll"));
task.WorkingDirectory = testDirectory;
task.OutputXmlFile = Path.Combine(testDirectory, @"nunit.framework.tests-results.xml");
Assert.IsTrue(task.Execute(), "Execute Failed");
}
public void ZipNoRoot()
{
var task = new Zip();
task.BuildEngine = new MockBuild();
string testDir = TaskUtility.TestDirectory;
string prjRootPath = TaskUtility.GetProjectRootDirectory(true);
string workingDir = Path.Combine(prjRootPath, @"Source\MSBuild.Community.Tasks.Tests");
string[] files = Directory.GetFiles(workingDir, "*.*", SearchOption.AllDirectories);
TaskItem[] items = TaskUtility.StringArrayToItemArray(files);
task.Files = items;
task.ZipFileName = Path.Combine(testDir, ZIP_FILE_NAME);
if (File.Exists(task.ZipFileName))
{
File.Delete(task.ZipFileName);
}
Assert.IsTrue(task.Execute(), "Execute Failed");
Assert.IsTrue(File.Exists(task.ZipFileName), "Zip file not found");
}
public void DuplicateTypeAllowed()
{
task.OutputFile = new TaskItem(Path.Combine(this.testDirectory, @"merged1.dll"));
task.AllowDuplicateTypes = TaskUtility.StringArrayToItemArray(@"ClassAB", "ClassBA");
task.XmlDocumentation = true;
Assert.IsTrue(task.Execute(), @"Task failed");
this.AssertResults(task, PublicCount, VersionA);
}
public void ChecksumTestUnsupportedAlg()
{
Checksum task = new Checksum();
task.BuildEngine = new MockBuild();
task.Files = TaskUtility.StringArrayToItemArray(inputFiles);
task.Algorithm = "foo";
Assert.IsFalse(task.Execute(), "Execute Failed");
}
public void ChecksumTestSHA1()
{
Checksum task = new Checksum();
task.BuildEngine = new MockBuild();
task.Files = TaskUtility.StringArrayToItemArray(inputFiles);
task.Algorithm = "SHA1";
Assert.IsTrue(task.Execute(), "Execute Failed");
}
public void PrimaryTypesAndExclusions()
{
task.OutputFile = new TaskItem(Path.Combine(this.testDirectory, @"merged3.dll"));
task.AllowDuplicateTypes = TaskUtility.StringArrayToItemArray(@"ClassAB");
task.DebugInfo = false;
task.XmlDocumentation = false;
task.ExcludeFile = new TaskItem(this.excludeFile);
Assert.IsTrue(task.Execute(), @"Task failed");
this.AssertResults(task, PublicACount + 1, VersionA);
}
public void SignedMergedAssembly()
{
task.OutputFile = new TaskItem(Path.Combine(this.testDirectory, @"merged4.dll"));
task.AllowDuplicateTypes = TaskUtility.StringArrayToItemArray(@"ClassAB");
task.DebugInfo = false;
task.XmlDocumentation = false;
task.KeyFile = new TaskItem(this.keyFile);
Assert.IsTrue(task.Execute(), @"Task failed");
this.AssertResults(task, PublicCount, VersionA);
}
public void RegexMatchExecute()
{
RegexMatch task = new RegexMatch();
task.BuildEngine = new MockBuild();
task.Input = TaskUtility.StringArrayToItemArray("foo.my.foo.foo.test.o", "foo.my.faa.foo.test.a", "foo.my.fbb.foo.test.b", "foo.my.fcc.foo.test.c", "foo.my.fdd.foo.test.d");
task.Expression = new TaskItem("[a-c]$");
Assert.IsTrue(task.Execute(), "Execute Failed");
Assert.AreEqual(3, task.Output.Length, "Match should have matched three items");
}
public void XsltOneInput()
{
Xslt task = new Xslt();
task.BuildEngine = new MockBuild();
string testDir;
string assemblyDir = TaskUtility.AssemblyDirectory;
TaskUtility.logEnvironmentInfo(task.Log);
if (TaskUtility.CalledInBuildDirectory)
{
task.Log.LogMessage("Called in build directory");
// get the files from where msbuild put them
testDir = TaskUtility.TestDirectory;
}
else
{
task.Log.LogMessage("Not called in build directory");
// get the files from where Visual Studio put them
testDir = Path.Combine(TaskUtility.AssemblyDirectory, @"Xslt");
}
task.Inputs = TaskUtility.StringArrayToItemArray(Path.Combine(testDir, @"XsltTestInput.xml"));
task.Inputs[0].SetMetadata(@"configuration", "test");
task.Xsl = new TaskItem(Path.Combine(assemblyDir, @"NUnitReport.xsl"));
task.Xsl.SetMetadata(@"project", "XsltTest");
task.RootTag = "mergedroot";
task.Output = Path.Combine(testDir, @"XsltTestOutput.html");
Assert.IsNotNull(task.Inputs, @"No inputs");
Assert.IsNull(task.RootAttributes, @"Wrong default root attributes");
Assert.IsNotNull(task.Xsl, @"No xsl");
Assert.IsNotNull(task.Output, @"No output");
// executing with one input files
Assert.IsTrue(task.Execute(), @"Task with one input files failed");
Assert.IsTrue(File.Exists(task.Output), @"Missing output file");
string taskOutput = File.ReadAllText(task.Output);
Assert.IsTrue(taskOutput.Contains(
@"<h1>Project ""XsltTest"" - Configuration ""test"" - NUnit Test Report</h1>"),
@"Input or Xsl metadata not correctly added.");
}
public void ExecuteAttrib()
{
string attribFile = Path.Combine(TaskUtility.TestDirectory, @"attrib.txt");
File.WriteAllText(attribFile, "This is a test file");
Attrib task = new Attrib();
task.BuildEngine = new MockBuild();
task.Files = TaskUtility.StringArrayToItemArray(attribFile);
task.ReadOnly = true;
task.Hidden = true;
task.System = true;
task.Execute();
bool isReadOnly = ((File.GetAttributes(attribFile) & FileAttributes.ReadOnly) == FileAttributes.ReadOnly);
bool isHidden = ((File.GetAttributes(attribFile) & FileAttributes.Hidden) == FileAttributes.Hidden);
bool isSystem = ((File.GetAttributes(attribFile) & FileAttributes.System) == FileAttributes.System);
Assert.IsTrue(isReadOnly, "Attribute should be readonly");
Assert.IsTrue(isHidden, "Attribute should be hidden");
Assert.IsTrue(isSystem, "Attribute should be system");
task = new Attrib();
task.BuildEngine = new MockBuild();
task.Files = TaskUtility.StringArrayToItemArray(attribFile);
task.Hidden = false;
task.System = false;
task.Execute();
isReadOnly = ((File.GetAttributes(attribFile) & FileAttributes.ReadOnly) == FileAttributes.ReadOnly);
isHidden = ((File.GetAttributes(attribFile) & FileAttributes.Hidden) == FileAttributes.Hidden);
isSystem = ((File.GetAttributes(attribFile) & FileAttributes.System) == FileAttributes.System);
Assert.IsTrue(isReadOnly, "Attribute should be readonly");
Assert.IsFalse(isHidden, "Attribute should not be hidden");
Assert.IsFalse(isSystem, "Attribute should not be system");
task = new Attrib();
task.BuildEngine = new MockBuild();
task.Files = TaskUtility.StringArrayToItemArray(attribFile);
task.Normal = true;
task.Execute();
isReadOnly = ((File.GetAttributes(attribFile) & FileAttributes.ReadOnly) == FileAttributes.ReadOnly);
Assert.IsFalse(isReadOnly, "Attribute should not be readonly");
}
public void RegexReplaceRemoveFirstFoo()
{
RegexReplace task = new RegexReplace();
task.BuildEngine = new MockBuild();
task.Input = TaskUtility.StringArrayToItemArray("foo.my.foo.foo.test.o", "foo.my.faa.foo.test.a", "foo.my.fbb.foo.test.b", "foo.my.fcc.foo.test.c", "foo.my.fdd.foo.test.d");
task.Expression = new TaskItem("foo\\.");
task.Count = new TaskItem("1");
Assert.IsTrue(task.Execute(), "Execute Failed");
foreach (ITaskItem item in task.Output)
{
Assert.IsTrue(!item.ItemSpec.StartsWith("foo."), string.Format("Item still starts with foo: {0}", item.ItemSpec));
}
}
public void DuplicateTypeAllowed()
{
if (!ilMergeAvailable)
{
Assert.Ignore(@"ILMerge.exe not available");
}
ILMerge task = new ILMerge();
task.BuildEngine = new MockBuild();
task.InputAssemblies = inputAssemblies;
task.OutputFile = new TaskItem(Path.Combine(testDirectory, @"merged1.dll"));
task.AllowDuplicateTypes = TaskUtility.StringArrayToItemArray(@"ClassAB");
task.XmlDocumentation = true;
Assert.IsTrue(task.Execute(), @"Task failed");
AssertResults(task, PUBLIC_COUNT, VERSION_A);
}
public void RegexReplaceLastDotForBang()
{
RegexReplace task = new RegexReplace();
task.BuildEngine = new MockBuild();
task.Input = TaskUtility.StringArrayToItemArray("foo.my.foo.foo.test.o", "foo.my.faa.foo.test.a", "foo.my.fbb.foo.test.b", "foo.my.fcc.foo.test.c", "foo.my.fdd.foo.test.d");
task.Expression = new TaskItem("\\.");
task.Replacement = new TaskItem("!");
task.Count = new TaskItem("1");
task.Options = TaskUtility.StringArrayToItemArray("RightToLeft");
Assert.IsTrue(task.Execute(), "Execute Failed");
foreach (ITaskItem item in task.Output)
{
Assert.AreEqual("!", item.ItemSpec.Substring(19, 1), string.Format("Item not replaced properly: {0}", item.ItemSpec));
}
}
public void RegexReplaceFooForOop()
{
RegexReplace task = new RegexReplace();
task.BuildEngine = new MockBuild();
string[] expectedResult = new string[] { "foo.my.oop.oop.test.o", "foo.my.faa.oop.test.a", "foo.my.fbb.oop.test.b", "foo.my.fcc.oop.test.c", "foo.my.fdd.oop.test.d" };
task.Input = TaskUtility.StringArrayToItemArray("foo.my.foo.foo.test.o", "foo.my.faa.foo.test.a", "foo.my.fbb.foo.test.b", "foo.my.fcc.foo.test.c", "foo.my.fdd.foo.test.d");
task.Expression = new TaskItem("foo\\.");
task.StartAt = new TaskItem("6");
task.Replacement = new TaskItem("oop.");
Assert.IsTrue(task.Execute(), "Execute Failed");
for (int ndx = 0; ndx < task.Output.Length; ndx++)
{
Assert.AreEqual(expectedResult[ndx], task.Output[ndx].ItemSpec, "Results did not match expectations");
}
}
public void TestFilesUpdate()
{
FileUpdate task = new FileUpdate();
task.BuildEngine = new MockBuild();
TaskItem[] items = TaskUtility.StringArrayToItemArray(files);
task.Files = items;
task.Regex = @"(\d+)\.(\d+)\.(\d+)\.(\d+)";
task.ReplacementText = "$1.$2.$3.123";
Assert.IsTrue(task.Execute(), "Execute Failed!");
task = new FileUpdate();
task.BuildEngine = new MockBuild();
task.Files = items;
task.Regex = @"@\w*?@";
task.ReplacementText = DateTime.Now.ToString();
Assert.IsTrue(task.Execute(), "Execute Failed!");
}
public void NUnitExecuteWhenToolPathIsDefined(int majorVersion, int minorVersion, int number)
{
string nUnitDirName = string.Format("NUnit {0}.{1}.{2}", majorVersion, minorVersion, number);
string nunitPath = Path.Combine(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), nUnitDirName), "bin");
if (!Directory.Exists(nunitPath))
{
Assert.Inconclusive("{0} - not found", nunitPath);
}
MockBuild buildEngine = new MockBuild();
string testDirectory = TaskUtility.makeTestDirectory(buildEngine);
NUnit task = new NUnit();
task.ToolPath = nunitPath;
task.BuildEngine = buildEngine;
task.Assemblies = TaskUtility.StringArrayToItemArray(Path.Combine(nunitPath, "nunit.framework.tests.dll"));
task.WorkingDirectory = testDirectory;
Assert.IsTrue(task.Execute(), "Execute Failed");
}
public void SignedMergedAssembly()
{
if (!this.isILMergeAvailable)
{
Assert.Ignore(@"ILMerge.exe not available");
}
ILMerge task = new ILMerge();
task.BuildEngine = new MockBuild();
task.InputAssemblies = this.inputAssemblies;
task.OutputFile = new TaskItem(Path.Combine(this.testDirectory, @"merged4.dll"));
task.AllowDuplicateTypes = TaskUtility.StringArrayToItemArray(@"ClassAB");
task.DebugInfo = false;
task.XmlDocumentation = false;
task.KeyFile = new TaskItem(this.keyFile);
Assert.IsTrue(task.Execute(), @"Task failed");
this.AssertResults(task, PublicCount, VersionA);
}
public void MoveExecute()
{
string attribFile = Path.Combine(TaskUtility.TestDirectory, @"moveme.txt");
File.WriteAllText(attribFile, "This is a test file");
Move task = new Move();
task.BuildEngine = new MockBuild();
task.SourceFiles = TaskUtility.StringArrayToItemArray(attribFile);
task.DestinationFolder = new TaskItem(Path.Combine(TaskUtility.TestDirectory, ".."));
task.Execute();
File.WriteAllText(attribFile, "This is a test file");
task = new Move();
task.BuildEngine = new MockBuild();
task.SourceFiles = TaskUtility.StringArrayToItemArray(attribFile);
task.DestinationFiles = TaskUtility.StringArrayToItemArray("newme.txt");
task.Execute();
}
public void TestItemsNotUpdated()
{
FileUpdate task = new FileUpdate();
task.BuildEngine = new MockBuild();
TaskItem[] items = TaskUtility.StringArrayToItemArray(files);
task.Files = items;
task.Regex = @"(\d+)\.(\d+)\.(\d+)\.(\d+)";
task.ReplacementText = "$1.$2.$3.123";
Assert.IsTrue(task.Execute(), "Execute Failed!");
task = new FileUpdate();
task.BuildEngine = new MockBuild();
task.Files = items;
task.Regex = @"TestExitStatusAndNotUpdatedItems";
task.ReplacementText = DateTime.Now.ToString();
Assert.IsTrue(task.Execute(), "Execute Failed!");
Assert.IsTrue(task.ItemsNotUpdated.Length == 3);
Assert.IsFalse(task.AllItemsUpdated);
}
public void ZipExecuteWithEmptyFolders()
{
var task = new Zip();
task.BuildEngine = new MockBuild();
string testDir = TaskUtility.TestDirectory;
string prjRootPath = TaskUtility.GetProjectRootDirectory(true);
string workingDir = Path.Combine(prjRootPath, @"Source\MSBuild.Community.Tasks.Tests");
string[] files = Directory.GetFiles(workingDir, "*.*", SearchOption.TopDirectoryOnly);
string[] directories = Directory.GetDirectories(workingDir, "*.*", SearchOption.TopDirectoryOnly);
string[] filesFromXmlDirectory = new string[0]; //Directory.GetFiles(workingDir + "\\" + "Xml", "*.*", SearchOption.TopDirectoryOnly);
var filesAndDirectories = new string[files.Length + directories.Length + filesFromXmlDirectory.Length];
files.CopyTo(filesAndDirectories, 0);
directories.CopyTo(filesAndDirectories, files.Length + filesFromXmlDirectory.Length);
filesFromXmlDirectory.CopyTo(filesAndDirectories, files.Length);
TaskItem[] items = TaskUtility.StringArrayToItemArray(filesAndDirectories);
task.Files = items;
task.WorkingDirectory = workingDir;
task.ZipFileName = Path.Combine(testDir, ZIP_WITH_FOLDERS_FILE_NAME);
if (File.Exists(task.ZipFileName))
{
File.Delete(task.ZipFileName);
}
Assert.IsTrue(task.Execute(), "Execute Failed");
Assert.IsTrue(File.Exists(task.ZipFileName), "Zip file not found");
}
public void VersionedMergedAssembly()
{
if (!ilMergeAvailable)
{
Assert.Ignore(@"ILMerge.exe not available");
}
ILMerge task = new ILMerge();
task.BuildEngine = new MockBuild();
task.InputAssemblies = inputAssemblies;
task.OutputFile = new TaskItem(Path.Combine(testDirectory, @"merged5.dll"));
task.AllowDuplicateTypes = TaskUtility.StringArrayToItemArray(@"ClassAB");
task.DebugInfo = false;
task.XmlDocumentation = false;
task.KeyFile = new TaskItem(keyFile);
string version = @"5.6.7.8";
task.Version = version;
Assert.IsTrue(task.Execute(), @"Task failed");
AssertResults(task, PUBLIC_COUNT, version);
}
public void UploadMultipleFilesInFolderStructure()
{
// set up test environment
string testFile1 = Path.Combine(TaskUtility.TestDirectory, "file1.txt");
string testDir2 = Path.Combine(TaskUtility.TestDirectory, "testfolder");
string testFile2 = Path.Combine(testDir2, "file2.txt");
Directory.CreateDirectory(testDir2);
File.WriteAllText(testFile1, "file number one");
File.WriteAllText(testFile2, "file number two");
MemoryStream file1Stream = new MemoryStream();
MemoryStream file2Stream = new MemoryStream();
// record expected operations
var mockery = new MockRepository();
var ftpService = mockery.CreateMock <IFtpWebRequest>();
var ftpCreator = mockery.CreateMock <IFtpWebRequestCreator>();
FtpUpload task = new FtpUpload(ftpCreator);
using (mockery.Record()) {
// this call responds to the FtpUpload's request to list folders; return no folders.
ftpCreator.Create(new Uri("ftp://server.com/folder/"), "NLST");
LastCall.Return(ftpService);
ftpService.GetResponseStream();
LastCall.Return(new MemoryStream(new byte[0]));
// this call should make the testfolder
ftpCreator.Create(new Uri("ftp://server.com/folder/testfolder"), "MKD");
LastCall.Return(ftpService);
ftpService.GetAndCloseResponse();
// now upload file1
ftpCreator.Create(new Uri("ftp://server.com/folder/file1.txt"), "STOR");
LastCall.Return(ftpService);
ftpService.SetContentLength(15);
ftpService.GetRequestStream();
LastCall.Return(file1Stream);
ftpService.GetStatusDescriptionAndCloseResponse();
LastCall.Return("okay");
// now upload file2
ftpCreator.Create(new Uri("ftp://server.com/folder/testfolder/file2.txt"), "STOR");
LastCall.Return(ftpService);
ftpService.SetContentLength(15);
ftpService.GetRequestStream();
LastCall.Return(file2Stream);
ftpService.GetStatusDescriptionAndCloseResponse();
LastCall.Return("okay");
}
task.BuildEngine = _mockBuild;
task.RemoteUri = "ftp://server.com/folder/";
task.LocalFiles = TaskUtility.StringArrayToItemArray(testFile1, testFile2);
task.RemoteFiles = TaskUtility.StringArrayToItemArray("file1.txt", "testfolder\\file2.txt");
bool result = task.Execute();
Assert.AreEqual("file number one", GetString(file1Stream));
Assert.AreEqual("file number two", GetString(file2Stream));
mockery.VerifyAll();
}
