public void ProcessInputs_DefaultValues_ThrowsParameterException()
        {
            Options            input = new Options();
            ParameterException e     = Assert.ThrowsException <ParameterException>(() =>
                                                                                   OptionsEvaluator.ProcessInputs(input, _processHelperMock.Object));

            Assert.AreEqual("Please specify either processId or processName on the command line", e.Message);
            VerifyAllMocks();
        }
        public void ProcessInputs_DefaultValues_ThrowsParameterException()
        {
            Options            input = new Options();
            ParameterException e     = Assert.ThrowsException <ParameterException>(() =>
                                                                                   OptionsEvaluator.ProcessInputs(input, _processHelperMock.Object));

            Assert.AreEqual(DisplayStrings.ErrorNoTarget, e.Message);
            VerifyAllMocks();
        }
        public void ProcessInputs_ProcessIdIsSpecified_FindsProcessById()
        {
            _processHelperMock.Setup(x => x.ProcessNameFromId(TestProcessId)).Returns(TestProcessName);
            Options input = new Options
            {
                ProcessId = TestProcessId,
            };

            ValidateOptions(OptionsEvaluator.ProcessInputs(input, _processHelperMock.Object),
                            processId: TestProcessId);
            VerifyAllMocks();
        }
        public void ProcessInputs_SpecifiesOverlyLongDelay_ThrowsParameterException()
        {
            const int delayInSeconds = 61;
            Options   input          = new Options {
                DelayInSeconds = delayInSeconds
            };
            ParameterException e = Assert.ThrowsException <ParameterException>(() => OptionsEvaluator.ProcessInputs(
                                                                                   input, _processHelperMock.Object));

            Assert.AreEqual(
                string.Format(CultureInfo.CurrentCulture, DisplayStrings.ErrorInvalidDelayFormat, delayInSeconds),
                e.Message);
        }
Пример #5
0
        public void ProcessInputs_SpecifiesScanOptions_SetsMultiscan()
        {
            _processHelperMock.Setup(x => x.ProcessIdFromName(TestProcessName)).Returns(TestProcessId);
            Options input = new Options
            {
                ProcessName = TestProcessName,
                AreMultipleScanRootsEnabled = true
            };

            ValidateOptions(OptionsEvaluator.ProcessInputs(input, _processHelperMock.Object),
                            processId: TestProcessId, areMultipleScanRootsEnabled: true);
            VerifyAllMocks();
        }
        public void ProcessInputs_ProcessNameIsSpecifiedWithNoExtension_FindsProcessByName()
        {
            const string fullProcessName    = @"c:\foo\bar\myprocess";
            const string reducedProcessName = "myprocess";

            _processHelperMock.Setup(x => x.ProcessIdFromName(reducedProcessName)).Returns(TestProcessId);
            Options input = new Options
            {
                ProcessName = fullProcessName,
            };

            ValidateOptions(OptionsEvaluator.ProcessInputs(input, _processHelperMock.Object),
                            processId: TestProcessId, processName: reducedProcessName);
            VerifyAllMocks();
        }
        public void ProcessInputs_SpecifiesValidDelay_SetsDelayInSeconds()
        {
            const int expectedDelay = 60;

            _processHelperMock.Setup(x => x.ProcessIdFromName(TestProcessName)).Returns(TestProcessId);
            Options input = new Options
            {
                ProcessName    = TestProcessName,
                DelayInSeconds = expectedDelay,
            };

            ValidateOptions(OptionsEvaluator.ProcessInputs(input, _processHelperMock.Object),
                            processId: TestProcessId, delayInSeconds: expectedDelay);
            VerifyAllMocks();
        }
        public void ProcessInputs_SpecifiesVerbose_SetsQuietVerbosity()
        {
            const string verbosity = "VERBOSE";

            _processHelperMock.Setup(x => x.ProcessIdFromName(TestProcessName)).Returns(TestProcessId);
            Options input = new Options
            {
                ProcessName = TestProcessName,
                Verbosity   = verbosity,
            };

            ValidateOptions(OptionsEvaluator.ProcessInputs(input, _processHelperMock.Object),
                            processId: TestProcessId, verbosityLevel: VerbosityLevel.Verbose);
            VerifyAllMocks();
        }
        public void ProcessInputs_SpecifiesDefault_SetsDefaultVerbosity()
        {
            const string verbosity = "dEfAuLt";

            _processHelperMock.Setup(x => x.ProcessIdFromName(TestProcessName)).Returns(TestProcessId);
            Options input = new Options
            {
                ProcessName = TestProcessName,
                Verbosity   = verbosity,
            };

            ValidateOptions(OptionsEvaluator.ProcessInputs(input, _processHelperMock.Object),
                            processId: TestProcessId);
            VerifyAllMocks();
        }
        public void ProcessInputs_SpecifiesScanId_RetainsOutputDirectory()
        {
            const string testScanId = "SuperScan";

            _processHelperMock.Setup(x => x.ProcessIdFromName(TestProcessName)).Returns(TestProcessId);
            Options input = new Options
            {
                ProcessName = TestProcessName,
                ScanId      = testScanId,
            };

            ValidateOptions(OptionsEvaluator.ProcessInputs(input, _processHelperMock.Object),
                            processId: TestProcessId, scanId: testScanId);
            VerifyAllMocks();
        }
        public void ProcessInputs_SpecifiesOutputDirectory_RetainsOutputDirectory()
        {
            const string testOutputDirectory = @"C:\Test\Output\Directory";

            _processHelperMock.Setup(x => x.ProcessIdFromName(TestProcessName)).Returns(TestProcessId);
            Options input = new Options
            {
                ProcessName     = TestProcessName,
                OutputDirectory = testOutputDirectory,
            };

            ValidateOptions(OptionsEvaluator.ProcessInputs(input, _processHelperMock.Object),
                            processId: TestProcessId, outputDirectory: testOutputDirectory);
            VerifyAllMocks();
        }
        public void ProcessInputs_SpecifiesInvalidVerbosity_ThrowsParameterException()
        {
            const string verbosity = "Not_A_Valid_Value";

            _processHelperMock.Setup(x => x.ProcessIdFromName(TestProcessName)).Returns(TestProcessId);
            Options input = new Options
            {
                ProcessName = TestProcessName,
                Verbosity   = verbosity,
            };
            ParameterException e = Assert.ThrowsException <ParameterException>(() =>
                                                                               OptionsEvaluator.ProcessInputs(input, _processHelperMock.Object));

            Assert.AreEqual("Invalid verbosity level: Not_A_Valid_Value", e.Message);
            VerifyAllMocks();
        }
        public void ProcessInputs_SpecifiesInvalidVerbosity_ThrowsParameterException()
        {
            const string verbosity = "Not_A_Valid_Value";

            _processHelperMock.Setup(x => x.ProcessIdFromName(TestProcessName)).Returns(TestProcessId);
            Options input = new Options
            {
                ProcessName = TestProcessName,
                Verbosity   = verbosity,
            };
            ParameterException e = Assert.ThrowsException <ParameterException>(() =>
                                                                               OptionsEvaluator.ProcessInputs(input, _processHelperMock.Object));

            Assert.AreEqual(
                string.Format(CultureInfo.CurrentCulture, DisplayStrings.ErrorInvalidVerbosityFormat, verbosity),
                e.Message);
            VerifyAllMocks();
        }
        public void ProcessInputs_ProcessHelperIsNull_ThrowsArgumentNullException()
        {
            ArgumentNullException e = Assert.ThrowsException <ArgumentNullException>(() => OptionsEvaluator.ProcessInputs(
                                                                                         new Options(), null));

            Assert.AreEqual("processHelper", e.ParamName);
            VerifyAllMocks();
        }
        public void ProcessInputs_RawInputsIsNull_ThrowsArgumentNullException()
        {
            ArgumentNullException e = Assert.ThrowsException <ArgumentNullException>(() => OptionsEvaluator.ProcessInputs(
                                                                                         null, _processHelperMock.Object));

            Assert.AreEqual("rawInputs", e.ParamName);
            VerifyAllMocks();
        }