public void SetUp()
{
executor = Stub<IExecutor>();
runData = new RunData();
ender = Stub<IThreadEnder>();
target = new ExecutorThreadImpl(executor, runData);
}
public void Collect()
{
RunData a = new RunData();
RunData b = new RunData();
RunData c = new RunData();
IList<RunData> items = new List<RunData> { a, b, c };
ResultFile fileA = new ResultFile();
ResultFile fileB = new ResultFile();
ResultFile fileC = new ResultFile();
Stream streamA = Stub<Stream>();
Stream streamB = Stub<Stream>();
Stream streamC = Stub<Stream>();
using (Ordered())
{
fileHelper.Expect(m => m.OpenTrxFile(a)).Return(streamA);
trxParser.Expect(m => m.Parse(streamA)).Return(fileA);
fileHelper.Expect(m => m.OpenTrxFile(b)).Return(streamB);
trxParser.Expect(m => m.Parse(streamB)).Return(fileB);
fileHelper.Expect(m => m.OpenTrxFile(c)).Return(streamC);
trxParser.Expect(m => m.Parse(streamC)).Return(fileC);
}
IList<ResultFile> actual = VerifyTarget(() => target.Collect(items));
Assert.AreEqual(fileA, actual[0]);
Assert.AreEqual(fileB, actual[1]);
Assert.AreEqual(fileC, actual[2]);
}
public void LaunchExecutor_CanTestIsFalse()
{
RunData input = new RunData();
threadFactory.Expect((m) => m.CanLaunch(threads, input)).Return(false);
bool actual = VerifyTarget(() => target.LaunchExecutor(input));
Assert.IsFalse(actual);
}
public void LaunchExecutor_CanTestIsTrue()
{
RunData input = new RunData();
threadFactory.Expect((m) => m.CanLaunch(threads, input)).Return(true);
threadFactory.Expect((m) => m.Create(executor, input, target)).Return(thread);
thread.Expect((m) => m.Launch(target));
bool actual = VerifyTarget(() => target.LaunchExecutor(input));
Assert.IsTrue(actual);
}
public void Run(RunData data)
{
FileHelper.CreateSettingsFile(data);
FileHelper.CreateExecutionFolder(data);
var info = ProcessStartInfoFactory.CreateProcessStartInfo(data);
FileHelper.CreateInputFile(data, info);
var processReader = ProcessOutputReaderFactory.CreateReader(data);
ProcessFactory.StartProcessAndWait(info, processReader);
FileHelper.CreateOutputFile(data);
}
public void CreateSettingsFile(RunData data)
{
string settingFileName = string.Concat(data.Root, "\\", data.RunId, ".settings");
string settingsFileContent = string.Concat(
"<?xml version=\"1.0\" encoding=\"UTF-8\"?><RunSettings><RunConfiguration><ResultsDirectory>",
data.RunId,
"</ResultsDirectory></RunConfiguration></RunSettings>");
WindowsFileHelper.WriteFile(settingFileName, settingsFileContent);
}
public void CanLaunch_2ThreadsWithOtherGroups_RunDataIsExclusive()
{
IExecutorThread threadA = Stub<IExecutorThread>();
IExecutorThread threadB = Stub<IExecutorThread>();
threadA.Expect((m) => m.GetRunData()).Return(new RunData() { Groups = new HashSet<string>() { "Group2" } });
IList<IExecutorThread> threads = new List<IExecutorThread>() { threadA, threadB };
RunData data = new RunData() { Groups = new HashSet<string>() { "Group1" }, Exclusive = true };
bool actual = VerifyTarget(() => target.CanLaunch(threads, data));
Assert.IsFalse(actual);
}
public void CanLaunch_2ThreadsWithoutGroups()
{
IExecutorThread threadA = Stub<IExecutorThread>();
IExecutorThread threadB = Stub<IExecutorThread>();
threadA.Expect((m) => m.GetRunData()).Return(new RunData() { Groups = new HashSet<string>() });
threadB.Expect((m) => m.GetRunData()).Return(new RunData() { Groups = new HashSet<string>() });
IList<IExecutorThread> threads = new List<IExecutorThread>() { threadA, threadB };
RunData data = new RunData() { Groups = new HashSet<string>() { "Group1" } };
bool actual = VerifyTarget(() => target.CanLaunch(threads, data));
Assert.IsTrue(actual);
}
public void CleanRootFolder(RunData data)
{
try
{
WindowsFileHelper.DeleteFolder(string.Concat(data.Root, "\\", data.RunId));
WindowsFileHelper.DeleteFile(string.Concat(data.Root, "\\", data.RunId, ".settings"));
}
catch (IOException)
{
}
}
public void Clean()
{
RunData a = new RunData();
RunData b = new RunData();
IList<RunData> items = new List<RunData> { a, b };
using (Ordered())
{
fileHelper.Expect(m => m.CleanRootFolder(a));
fileHelper.Expect(m => m.CleanRootFolder(b));
}
VerifyTarget(() => target.Clean(items));
}
public void GetEnumerator()
{
RunData a = new RunData();
RunData b = new RunData();
RunData c = new RunData();
RunData d = new RunData();
IList<RunData> list1 = new List<RunData>() { a, b };
IList<RunData> list2 = new List<RunData>() { c, d };
target.Add(list1);
target.Add(list2);
IRunDataEnumerator enumerator = target.GetEnumerator();
Assert.IsNotNull(enumerator);
Assert.AreEqual(a, enumerator.PeekNext());
}
public void Add()
{
RunData a = new RunData();
RunData b = new RunData();
RunData c = new RunData();
RunData d = new RunData();
IList<RunData> list1 = new List<RunData>() { a, b };
IList<RunData> list2 = new List<RunData>() { c, d };
target.Add(list1);
target.Add(list2);
IList<RunData> full = target.GetFull();
Assert.AreEqual(a, full[0]);
Assert.AreEqual(b, full[1]);
Assert.AreEqual(c, full[2]);
Assert.AreEqual(d, full[3]);
}
public ProcessStartInfo CreateProcessStartInfo(RunData data)
{
string testNames = ConcatFixtures(data.Fixtures);
string settings = string.Concat(data.Root, "\\", data.RunId, ".settings");
return new ProcessStartInfo()
{
FileName = data.Executable,
Arguments =
"\"" + data.AssemblyName + "\"" +
" \"/settings:" + settings + "\"" +
" /logger:trx" +
" /Tests:" + testNames,
RedirectStandardOutput = true,
CreateNoWindow = true,
UseShellExecute = false
};
}
public void SetUp()
{
target = new ProcessStartInfoFactoryImpl();
input = new RunData()
{
Executable = "Executable.exe",
AssemblyName = "AssemblyName.dll",
Fixtures = new List<TestFixture>()
{
new TestFixture() { Name = "Fixture1" },
new TestFixture() { Name = "Fixture2" },
new TestFixture() { Name = "Fixture3" }
},
Root = "ROOT",
RunId = Guid.NewGuid()
};
}
public void Run()
{
RunData data = new RunData();
ProcessStartInfo info = new ProcessStartInfo();
IProcessOutputReader reader = Stub<IProcessOutputReader>();
using (Ordered())
{
fileHelper.Expect(m => m.CreateSettingsFile(data));
fileHelper.Expect(m => m.CreateExecutionFolder(data));
processStartInfoFactory.Expect(m => m.CreateProcessStartInfo(data)).Return(info);
fileHelper.Expect(m => m.CreateInputFile(data, info));
processOutputReaderFactory.Expect(m => m.CreateReader(data)).Return(reader);
processFactory.Expect(m => m.StartProcessAndWait(info, reader));
fileHelper.Expect(m => m.CreateOutputFile(data));
}
VerifyTarget(() => target.Run(data));
}
public void SetUp()
{
runData = new RunData();
runData.Output = new StringBuilder();
target = new ProcessOutputReaderImpl(runData);
}
public void SetUp()
{
runDataA = new RunData();
runDataB = new RunData();
runDataC = new RunData();
target = new RunDataEnumeratorImpl(new List<RunData>() { runDataA, runDataB, runDataC });
}
public IProcessOutputReader CreateReader(RunData data)
{
return new ProcessOutputReaderImpl(data);
}
public Stream OpenTrxFile(RunData data)
{
string trxPath = WindowsFileHelper.GetFile(string.Concat(data.Root, "\\", data.RunId), "*.trx");
return WindowsFileHelper.OpenFile(trxPath);
}
public void DeleteSettingsFile(RunData data)
{
WindowsFileHelper.DeleteFile(
string.Concat(data.Root, "\\", data.RunId, ".settings"));
}
public void Execute_HasItems_NoBreak_HasFreeThreads_NoBreak_HasItems_Peek_NoLaunch_NoFreeThreads_NoItems()
{
RunData data = new RunData();
using (Ordered())
{
runDataListBuilder.Expect((m) => m.GetEnumerator()).Return(enumerator);
enumerator.Expect((m) => m.HasItems()).Return(true);
enumerator.Expect((m) => m.HasItems()).Return(true);
breaker.Expect((m) => m.IsBreakReceived()).Return(false);
executorLauncher.Expect((m) => m.WaitForAnyThreadToComplete());
executorLauncher.Expect((m) => m.HasFreeThreads()).Return(true);
breaker.Expect((m) => m.IsBreakReceived()).Return(false);
enumerator.Expect((m) => m.HasItems()).Return(true);
enumerator.Expect((m) => m.PeekNext()).Return(data);
executorLauncher.Expect((m) => m.LaunchExecutor(data)).Return(false);
executorLauncher.Expect((m) => m.HasFreeThreads()).Return(false);
enumerator.Expect((m) => m.HasItems()).Return(false);
executorLauncher.Expect((m) => m.WaitForAll());
}
VerifyTarget(() => target.Execute());
}
public void CreateOutputFile(RunData data)
{
WindowsFileHelper.WriteFile(
string.Concat(data.Root, "\\", data.RunId, "\\output.txt"),
data.Output.ToString());
}
public void CreateInputFile(RunData data, ProcessStartInfo processStartInfo)
{
WindowsFileHelper.WriteFile(
string.Concat(data.Root, "\\", data.RunId, "\\cmd.txt"),
string.Concat(processStartInfo.FileName, " ", processStartInfo.Arguments));
}
public void CreateExecutionFolder(RunData data)
{
WindowsFileHelper.CreateFolder(
string.Concat(data.Root, "\\", data.RunId));
}
public void CreateReader()
{
RunData input = new RunData();
IProcessOutputReader reader = target.CreateReader(input);
Assert.IsNotNull(reader);
}
public void Create()
{
IExecutor executor = Stub<IExecutor>();
IThreadStarter starter = Stub<IThreadStarter>();
RunData data = new RunData();
starter.Expect((m) => m.OnStarted(Arg<IExecutorThread>.Is.NotNull));
IExecutorThread thread = VerifyTarget(() => target.Create(executor, data, starter));
Assert.AreEqual(data, thread.GetRunData());
Assert.AreEqual(executor, thread.GetExecutor());
Assert.IsNull(thread.GetTask());
}
public void CanLaunch_NoGroups()
{
IList<IExecutorThread> threads = new List<IExecutorThread>() { Stub<IExecutorThread>() };
RunData data = new RunData() { Groups = new HashSet<string>() };
bool actual = target.CanLaunch(threads, data);
Assert.IsTrue(actual);
}
public void SetUp()
{
fileHelper = Stub<IWindowsFileHelper>();
target = new VSTestFileHelperImpl();
target.WindowsFileHelper = fileHelper;
input = new RunData()
{
Root = "ROOT",
RunId = Guid.NewGuid(),
Output = new StringBuilder("THE CONTENT OF THE FILE")
};
}
