public void CanRecognizeInProcessOption()
{
ConsoleOptions options = ConsoleMocks.Options("--inprocess");
Assert.That(options.Validate(), Is.True, "Should be valid: --inprocess");
Assert.That(options.ProcessModel, Is.EqualTo("InProcess"), "Didn't recognize --inprocess");
}
public void CanRecognizeBooleanOptions(string propertyName, string pattern)
{
string[] prototypes = pattern.Split('|');
PropertyInfo property = GetPropertyInfo(propertyName);
Assert.That(property.PropertyType, Is.EqualTo(typeof(bool)), "Property '{0}' is wrong type", propertyName);
foreach (string option in prototypes)
{
ConsoleOptions options;
if (option.Length == 1)
{
options = ConsoleMocks.Options("-" + option);
Assert.That((bool)property.GetValue(options, null), Is.EqualTo(true), "Didn't recognize -" + option);
options = ConsoleMocks.Options("-" + option + "+");
Assert.That((bool)property.GetValue(options, null), Is.EqualTo(true), "Didn't recognize -" + option + "+");
options = ConsoleMocks.Options("-" + option + "-");
Assert.That((bool)property.GetValue(options, null), Is.EqualTo(false), "Didn't recognize -" + option + "-");
}
else
{
options = ConsoleMocks.Options("--" + option);
Assert.That((bool)property.GetValue(options, null), Is.EqualTo(true), "Didn't recognize --" + option);
}
options = ConsoleMocks.Options("/" + option);
Assert.That((bool)property.GetValue(options, null), Is.EqualTo(true), "Didn't recognize /" + option);
}
}
public void CanRecognizeStringOptions(string propertyName, string pattern, string[] goodValues, string[] badValues)
{
string[] prototypes = pattern.Split('|');
PropertyInfo property = GetPropertyInfo(propertyName);
Assert.That(property.PropertyType, Is.EqualTo(typeof(string)));
foreach (string option in prototypes)
{
foreach (string value in goodValues)
{
string optionPlusValue = string.Format("--{0}:{1}", option, value);
ConsoleOptions options = ConsoleMocks.Options(optionPlusValue);
Assert.That(options.Validate(), Is.True, "Should be valid: " + optionPlusValue);
Assert.That((string)property.GetValue(options, null), Is.EqualTo(value), "Didn't recognize " + optionPlusValue);
}
foreach (string value in badValues)
{
string optionPlusValue = string.Format("--{0}:{1}", option, value);
ConsoleOptions options = ConsoleMocks.Options(optionPlusValue);
Assert.That(options.Validate(), Is.False, "Should not be valid: " + optionPlusValue);
}
}
}
public void NoInputFiles()
{
ConsoleOptions options = ConsoleMocks.Options();
Assert.That(options.Validate(), Is.True);
Assert.That(options.InputFiles.Count, Is.EqualTo(0));
}
public void InvalidOptionsShowError(string arg, bool isValidOnNetCore)
{
var options = ConsoleMocks.Options("mock-assembly.dll", arg);
var errorsExpected = isValidOnNetCore ? 0 : 1;
Assert.That(options.ErrorMessages, Has.Exactly(errorsExpected).Contains("not available on this platform"));
}
public void MissingFileTest(string filename, string message)
{
var fullname = Path.Combine(TestContext.CurrentContext.TestDirectory, filename);
var services = new ServiceContext();
services.Add(new InProcessTestRunnerFactory());
services.Add(new ExtensionService());
services.Add(new DriverService());
#if NET35
services.Add(new RuntimeFrameworkService());
#endif
var package = new TestPackage(fullname);
package.AddSetting("ProcessModel", "InProcess");
package.AddSetting("DomainUsage", "None");
var runner = new MasterTestRunner(services, package);
var result = runner.Run(this, TestFilter.Empty);
var sb = new StringBuilder();
var writer = new ExtendedTextWrapper(new StringWriter(sb));
var reporter = new ResultReporter(result, writer, ConsoleMocks.Options());
reporter.WriteErrorsFailuresAndWarningsReport();
var report = sb.ToString();
Assert.That(report, Contains.Substring($"1) Invalid : {fullname}"));
Assert.That(report, Contains.Substring(message));
}
public void MissingValuesAreReported(string option)
{
ConsoleOptions options = ConsoleMocks.Options(option + "=");
Assert.That(options.Validate(), Is.False, "Missing value should not be valid");
Assert.That(options.ErrorMessages[0], Is.EqualTo("Missing required value for option '" + option + "'."));
}
public void TimeoutCausesErrorIfValueIsNotInteger()
{
ConsoleOptions options = ConsoleMocks.Options("tests.dll", "-timeout:abc");
Assert.That(options.Validate(), Is.False);
Assert.That(options.DefaultTimeout, Is.EqualTo(-1));
}
public void CreateReporter()
{
_report = new StringBuilder();
var writer = new ExtendedTextWrapper(new StringWriter(_report));
_reporter = new ResultReporter(_result, writer, ConsoleMocks.Options());
}
public void ShouldSetTeamCityFlagAccordingToArgsAndDefaults(bool hasTeamcityInCmd, bool?defaultTeamcity, bool expectedTeamCity)
{
// Given
List <string> args = new List <string> {
"tests.dll"
};
if (hasTeamcityInCmd)
{
args.Add("--teamcity");
}
ConsoleOptions options;
if (defaultTeamcity.HasValue)
{
options = new ConsoleOptions(new DefaultOptionsProviderStub(defaultTeamcity.Value), new VirtualFileSystem(), args.ToArray());
}
else
{
options = ConsoleMocks.Options(args.ToArray());
}
// When
var actualTeamCity = options.TeamCity;
// Then
Assert.That(expectedTeamCity, Is.EqualTo(actualTeamCity));
}
public void TimeoutParsesIntValueCorrectly()
{
ConsoleOptions options = ConsoleMocks.Options("tests.dll", "-timeout:5000");
Assert.That(options.Validate(), Is.True);
Assert.That(options.DefaultTimeout, Is.EqualTo(5000));
}
public void AssemblyAloneIsValid()
{
ConsoleOptions options = ConsoleMocks.Options("nunit.tests.dll");
Assert.That(options.Validate(), Is.True);
Assert.That(options.ErrorMessages.Count, Is.EqualTo(0), "command line should be valid");
}
public void ResultOptionWithoutFileNameIsInvalid()
{
ConsoleOptions options = ConsoleMocks.Options("tests.dll", "-result:");
Assert.That(options.Validate(), Is.False, "Should not be valid");
Assert.That(options.ErrorMessages.Count, Is.EqualTo(1), "An error was expected");
}
public void DeprecatedLabelsOptionsAreReplacedCorrectly(string oldOption, string newOption)
{
var options = ConsoleMocks.Options("--labels=" + oldOption);
options.Validate();
Assert.That(options.DisplayTestLabels, Is.EqualTo(newOption));
}
public void TimeoutIsMinusOneIfNoOptionIsProvided()
{
ConsoleOptions options = ConsoleMocks.Options("tests.dll");
Assert.That(options.Validate(), Is.True);
Assert.That(options.DefaultTimeout, Is.EqualTo(-1));
}
public void WhenNoOptionsAreSpecified_PackageContainsOnlyTwoSettings()
{
var options = ConsoleMocks.Options("test.dll");
var package = ConsoleRunner.MakeTestPackage(options);
Assert.That(package.Settings.Keys, Is.EquivalentTo(new string[] { "WorkDirectory", "DisposeRunners" }));
}
public void DeprecatedParameterWithoutEqualSignIsInvalid()
{
var options = ConsoleMocks.Options("--params=X5");
Assert.That(options.WarningMessages, Has.One.Contains("deprecated").IgnoreCase);
Assert.That(options.ErrorMessages.Count, Is.EqualTo(1));
}
public void ExploreOptionWithoutPath()
{
ConsoleOptions options = ConsoleMocks.Options("tests.dll", "-explore");
Assert.That(options.Validate(), Is.True);
Assert.That(options.Explore, Is.True);
}
public void InvalidResultSpecRecordsError()
{
var options = ConsoleMocks.Options("test.dll", "-result:userspecifed.xml;format=nunit2;format=nunit3");
Assert.That(options.ResultOutputSpecifications, Has.Exactly(1).Items
.And.Exactly(1).Property(nameof(OutputSpecification.OutputPath)).EqualTo("TestResult.xml"));
Assert.That(options.ErrorMessages, Has.Exactly(1).Contains("conflicting format options").IgnoreCase);
}
public void FileNameWithoutResultOptionLooksLikeParameter()
{
ConsoleOptions options = ConsoleMocks.Options("tests.dll", "results.xml");
Assert.That(options.Validate(), Is.True);
Assert.That(options.ErrorMessages.Count, Is.EqualTo(0));
Assert.That(options.InputFiles.Count, Is.EqualTo(2));
}
public void InvalidOption()
{
ConsoleOptions options = ConsoleMocks.Options("-assembly:nunit.tests.dll");
Assert.That(options.Validate(), Is.False);
Assert.That(options.ErrorMessages.Count, Is.EqualTo(1));
Assert.That(options.ErrorMessages[0], Is.EqualTo("Invalid argument: -assembly:nunit.tests.dll"));
}
public void WhenDebugging_NumberOfTestWorkersDefaultsToZero()
{
var options = ConsoleMocks.Options("test.dll", "--debug");
var package = ConsoleRunner.MakeTestPackage(options);
Assert.That(package.Settings["DebugTests"], Is.EqualTo(true));
Assert.That(package.Settings["NumberOfTestWorkers"], Is.EqualTo(0));
}
public void AssemblyName()
{
ConsoleOptions options = ConsoleMocks.Options("nunit.tests.dll");
Assert.That(options.Validate(), Is.True);
Assert.That(options.InputFiles.Count, Is.EqualTo(1));
Assert.That(options.InputFiles[0], Is.EqualTo("nunit.tests.dll"));
}
public void SingleAssembly()
{
var options = ConsoleMocks.Options("test.dll");
var package = ConsoleRunner.MakeTestPackage(options);
Assert.That(package.SubPackages.Count, Is.EqualTo(1));
Assert.That(package.SubPackages[0].FullName, Is.EqualTo(Path.GetFullPath("test.dll")));
}
public void WhenOptionIsSpecified_PackageIncludesSetting(string option, string key, object val)
{
var options = ConsoleMocks.Options("test.dll", option);
var package = ConsoleRunner.MakeTestPackage(options);
Assert.That(package.Settings.ContainsKey(key), "Setting not included for {0}", option);
Assert.That(package.Settings[key], Is.EqualTo(val), "NumberOfTestWorkers not set correctly for {0}", option);
}
public void WhenDebugging_NumberOfTestWorkersMayBeOverridden()
{
var options = ConsoleMocks.Options("test.dll", "--debug", "--workers=3");
var package = ConsoleRunner.MakeTestPackage(options);
Assert.That(package.Settings["DebugTests"], Is.EqualTo(true));
Assert.That(package.Settings["NumberOfTestWorkers"], Is.EqualTo(3));
}
public void InvalidCommandLineParms()
{
ConsoleOptions options = ConsoleMocks.Options("-garbage:TestFixture", "-assembly:Tests.dll");
Assert.That(options.Validate(), Is.False);
Assert.That(options.ErrorMessages.Count, Is.EqualTo(2));
Assert.That(options.ErrorMessages[0], Is.EqualTo("Invalid argument: -garbage:TestFixture"));
Assert.That(options.ErrorMessages[1], Is.EqualTo("Invalid argument: -assembly:Tests.dll"));
}
public void TwoTestParametersInSeparateOptions()
{
var options = ConsoleMocks.Options("--testparam:X=5", "--testparam:Y=7");
Assert.That(options.ErrorMessages, Is.Empty);
Assert.That(options.TestParameters, Is.EqualTo(new Dictionary <string, string> {
{ "X", "5" }, { "Y", "7" }
}));
}
public void SemicolonsDoNotSplitTestParameters()
{
var options = ConsoleMocks.Options("--testparam:X=5;Y=7");
Assert.That(options.ErrorMessages, Is.Empty);
Assert.That(options.TestParameters, Is.EqualTo(new Dictionary <string, string> {
{ "X", "5;Y=7" }
}));
}
public void SingleTestParameter()
{
var options = ConsoleMocks.Options("--testparam=X=5");
Assert.That(options.ErrorMessages, Is.Empty);
Assert.That(options.TestParameters, Is.EqualTo(new Dictionary <string, string> {
{ "X", "5" }
}));
}
