Beispiel #1
0
        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");
        }
Beispiel #2
0
        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);
            }
        }
Beispiel #3
0
        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);
                }
            }
        }
Beispiel #4
0
        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"));
        }
Beispiel #6
0
        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));
        }
Beispiel #7
0
        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 + "'."));
        }
Beispiel #8
0
        public void TimeoutCausesErrorIfValueIsNotInteger()
        {
            ConsoleOptions options = ConsoleMocks.Options("tests.dll", "-timeout:abc");

            Assert.That(options.Validate(), Is.False);
            Assert.That(options.DefaultTimeout, Is.EqualTo(-1));
        }
Beispiel #9
0
        public void CreateReporter()
        {
            _report = new StringBuilder();
            var writer = new ExtendedTextWrapper(new StringWriter(_report));

            _reporter = new ResultReporter(_result, writer, ConsoleMocks.Options());
        }
Beispiel #10
0
        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));
        }
Beispiel #11
0
        public void TimeoutParsesIntValueCorrectly()
        {
            ConsoleOptions options = ConsoleMocks.Options("tests.dll", "-timeout:5000");

            Assert.That(options.Validate(), Is.True);
            Assert.That(options.DefaultTimeout, Is.EqualTo(5000));
        }
Beispiel #12
0
        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");
        }
Beispiel #13
0
        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");
        }
Beispiel #14
0
        public void DeprecatedLabelsOptionsAreReplacedCorrectly(string oldOption, string newOption)
        {
            var options = ConsoleMocks.Options("--labels=" + oldOption);

            options.Validate();
            Assert.That(options.DisplayTestLabels, Is.EqualTo(newOption));
        }
Beispiel #15
0
        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" }));
        }
Beispiel #17
0
        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));
        }
Beispiel #18
0
        public void ExploreOptionWithoutPath()
        {
            ConsoleOptions options = ConsoleMocks.Options("tests.dll", "-explore");

            Assert.That(options.Validate(), Is.True);
            Assert.That(options.Explore, Is.True);
        }
Beispiel #19
0
        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);
        }
Beispiel #20
0
        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));
        }
Beispiel #21
0
        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));
        }
Beispiel #23
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));
        }
Beispiel #27
0
        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"));
        }
Beispiel #28
0
        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" }
            }));
        }
Beispiel #29
0
        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" }
            }));
        }
Beispiel #30
0
        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" }
            }));
        }