Exemplo n.º 1
0
            public void ShouldNotSuccessfullyUninstallWithDefaultUninstallMethod()
            {
                // by default, Uninstall _should_ wait for the stop / uninstall
                // but _not_ kill (in case of loss of data)
                // Arrange
                var serviceExe  = StubbornServiceExe;
                var serviceName = $"stubborn-service{Guid.NewGuid()}";
                var util        = Create(
                    serviceName,
                    serviceName,
                    serviceExe
                    );

                using var _ = new AutoResetter(Noop, () => util.Uninstall(
                                                   ControlOptions.Force | ControlOptions.Wait
                                                   ));
                util.InstallAndStart();
                // Act
                Expect(() => util.Uninstall())
                .To.Throw <ServiceOperationException>()
                .With.Message.Containing("Unable to perform Stop");
                // Assert
                Expect(util.IsInstalled)
                .To.Be.True();
                Process process = null;

                Expect(() => process = Process.GetProcessById(util.ServicePID))
                .Not.To.Throw();
                Expect(process.HasExited)
                .To.Be.False();
            }
        public void ShouldSetPortHintFromEnvironmentWhenAvailable()
        {
            // Arrange
            using var resetter = new AutoResetter <int?>(
                      StoreCurrentPortHint,
                      RestorePortHint);
            var expected = GetRandomInt(15000, 20000);

            Environment.SetEnvironmentVariable(
                TempDbMySqlServerSettings.EnvironmentVariables.PORT_HINT,
                expected.ToString()
                );
            Expect(
                Environment.GetEnvironmentVariable(
                    TempDbMySqlServerSettings.EnvironmentVariables.PORT_HINT
                    )
                ).To.Equal(expected.ToString());
            // Act
            var sut = new TempDbMySqlServerSettings()
            {
                Options =
                {
                    DefaultSchema = GetRandomAlphaString(8, 8)
                },
                InnodbFlushLogAtTrxCommit = 2,
                SlowQueryLog = 0
            };

            // Assert
            Expect(sut.Options.PortHint)
            .To.Equal(expected);
        }
Exemplo n.º 3
0
            public void ShouldKillTheCorrectService()
            {
                // Arrange
                var service1Name = $"service-1-{Guid.NewGuid()}";
                var service2Name = $"service-2-{Guid.NewGuid()}";
                var args1        = GetRandomArray <string>(2);
                var args2        = GetRandomArray <string>(2);
                var cli1         = $"\"{SpacedServiceExe}\" {string.Join(" ", args1)}";
                var cli2         = $"\"{SpacedServiceExe}\" {string.Join(" ", args2)}";
                var util1        = Create(service1Name, service1Name, cli1);
                var util2        = Create(service2Name, service2Name, cli2);

                util1.InstallAndStart();
                util2.InstallAndStart();

                using var _ = new AutoResetter(Noop, () =>
                {
                    TryDo(() => util1.Uninstall());
                    TryDo(() => util2.Uninstall());
                });

                var processes = Process.GetProcesses()
                                .Where(p => HasMainModule(p, SpacedServiceExe))
                                .ToArray();
                var p1 = processes.FirstOrDefault(
                    p =>
                {
                    var testArgs = p.QueryCommandline()
                                   .SplitCommandline()
                                   .Skip(1)
                                   .ToArray();
                    return(testArgs.Matches(args1));
                }
                    );
                var p2 = processes.FirstOrDefault(
                    p => p.QueryCommandline()
                    .SplitCommandline()
                    .Skip(1)
                    .Matches(args2)
                    );

                Expect(p1)
                .Not.To.Be.Null(() => $"Can't find process for {cli1}");
                Expect(p2)
                .Not.To.Be.Null(() => $"Can't find process for {cli2}");

                // Act
                util1.KillService();

                // Assert
                Expect(p1.HasExited)
                .To.Be.True();
                Expect(p2.HasExited)
                .To.Be.False();
            }
Exemplo n.º 4
0
        public void Dispose_ShouldCallDisposalActionExactlyOnce()
        {
            //---------------Set up test pack-------------------
            var disposeCalls = 0;
            var sut          = new AutoResetter(() => { }, () => disposeCalls++);

            //---------------Assert Precondition----------------
            Expect(disposeCalls).To.Equal(0);

            //---------------Execute Test ----------------------
            sut.Dispose();

            //---------------Test Result -----------------------
            Expect(disposeCalls).To.Equal(1);
        }
Exemplo n.º 5
0
        public void Dispose_ShouldNotRecallDisposeActionWhenCalledAgain()
        {
            //---------------Set up test pack-------------------
            var disposeCalls = 0;
            var sut          = new AutoResetter(() => { }, () => disposeCalls++);

            //---------------Assert Precondition----------------
            Expect(disposeCalls).To.Equal(0);

            //---------------Execute Test ----------------------
            sut.Dispose();
            sut.Dispose();

            //---------------Test Result -----------------------
            Expect(disposeCalls).To.Equal(1);
        }
Exemplo n.º 6
0
        public void Dispose_ShouldOnlyCallActionOfT_Once()
        {
            //---------------Set up test pack-------------------
            var disposeCalls = 0;
            var sut          = new AutoResetter <int>(() => 0, v => disposeCalls++);

            //---------------Assert Precondition----------------

            //---------------Execute Test ----------------------
            sut.Dispose();
            Expect(disposeCalls).To.Equal(1);
            sut.Dispose();

            //---------------Test Result -----------------------
            Expect(disposeCalls).To.Equal(1);
        }
Exemplo n.º 7
0
            public void ShouldRetryOnError()
            {
                // Arrange
                using var arena = new TestArena();
                var options     = Substitute.For <IOptions>();

                options.Retries.Returns(3);

                using var resetter = new AutoResetter <int>(() =>
                {
                    var original           = StreamSource.MaxBuffer;
                    StreamSource.MaxBuffer = 1;
                    return(original);
                },
                                                            original => StreamSource.MaxBuffer = original);
                var haveErrored      = false;
                var errorPassThrough = new GenericPassThrough(
                    (data, size) =>
                {
                    if (!haveErrored)
                    {
                        haveErrored = true;
                        throw new DirectoryNotFoundException("foo");
                    }
                },
                    () =>
                {
                }
                    );
                // keep the size small since we're forcing a flush at every byte
                var sourceFile = arena.CreateSourceFile(data: GetRandomBytes(10, 20));
                var expected   = arena.TargetPathFor(sourceFile);
                var sut        = Create(
                    intermediatePipes: new IPassThrough[] { errorPassThrough },
                    options: options);

                // Act
                sut.Synchronize(arena.SourceFileSystem, arena.TargetFileSystem);
                // Assert
                Expect(expected)
                .To.Exist();
                Expect(File.ReadAllBytes(expected))
                .To.Equal(sourceFile.Data);
            }
Exemplo n.º 8
0
        public void InstallingServiceWithSpacedPath()
        {
            // Arrange
            Expect(SpacedServiceExe)
            .Not.To.Be.Null();
            var sut = Create(
                SpacedServiceName,
                SpacedServiceDisplayName,
                $"\"{SpacedServiceExe}\" --arg --another-arg"
                );

            sut.ServiceStateExtraWaitSeconds = 30;
            // Act
            var completed = false;

            using var _ = new AutoResetter(Noop, () =>
            {
                if (completed)
                {
                    return;
                }

                EnsureServiceNotRunning(
                    SpacedServiceName,
                    SpacedServiceExe
                    );
            });
            Expect(sut.Install)
            .Not.To.Throw();
            // Assert
            Expect(sut.Start)
            .Not.To.Throw();
            Expect(sut.State)
            .To.Equal(ServiceState.Running);
            sut.Stop();
            Expect(sut.State)
            .To.Equal(ServiceState.Stopped);
            sut.Uninstall();
            // signal the safety-net that it doesn't have to do anything
            completed = true;
        }
Exemplo n.º 9
0
        public void ShouldRespectNoSnakeCaseOnRequest()
        {
            // Arrange
            GlobalSetup.PerformDefaultConfiguration();
            using var _    = new AutoResetter(DisableSnakeCase, EnableSnakeCase);
            using var conn = GlobalSetup.ConnectToTempDb();
            CreateCaseTestingTableOn(conn);
            var titleCaseValue = GetRandomString(4);
            var snakeCaseValue = GetAnother(titleCaseValue, () => GetRandomString(4));
            var id             = CommandExecutor.Execute(
                new CreateCaseTestingEntity(
                    titleCaseValue,
                    snakeCaseValue
                    )
                );
            var query = new FindCaseTestingEntity(id);

            // Act
            var whenSnakeCaseDisabled = QueryExecutor.Execute(query);

            EnableSnakeCase();
            var whenSnakeCaseEnabled = QueryExecutor.Execute(query);

            // Assert
            Expect(whenSnakeCaseDisabled)
            .Not.To.Be.Null("entity not found at all");
            Expect(whenSnakeCaseDisabled.TitleCased)
            .To.Equal(titleCaseValue, "TitleCased should always be mapped");
            Expect(whenSnakeCaseDisabled.SnakeCased)
            .To.Be.Null("snake_case is disabled -- should not map the property");

            Expect(whenSnakeCaseEnabled)
            .Not.To.Be.Null("entity not found at all");
            Expect(whenSnakeCaseEnabled.TitleCased)
            .To.Equal(titleCaseValue, "TitleCased should always be mapped");
            Expect(whenSnakeCaseEnabled.SnakeCased)
            .To.Equal(snakeCaseValue, "snake_case is enabled -- should be mapped");
        }
Exemplo n.º 10
0
            public void ShouldPassWhenNegatingAFailingComposition()
            {
                // Arrange
                using var _ = new AutoResetter(
                          () => Assertions.RegisterAssertionsFactory(
                              s => new AssertionException(s)
                              ),
                          Assertions.UseDefaultAssertionsFactory
                          );
                var person = new Person()
                {
                    Gender = Genders.Unknown,
                    Name   = "Blergschootz"
                };

                // Act
                Assert.That(() =>
                {
                    Expect(person)
                    .Not.To.Be.A.Benny();
                }, Throws.Nothing);
                // Assert
            }
Exemplo n.º 11
0
        public void ServiceWithArgs()
        {
            // Arrange
            var myPath = new Uri(GetType().Assembly.Location).LocalPath;
            var myDir = Path.GetDirectoryName(myPath);
            var serviceExe = Path.Combine(myDir, "ServiceWithArgs.exe");
            var logFile = Path.Combine(myDir, "service.log");
            var arg1 = GetRandomString(3);
            var arg2 = GetRandomString(3);
            var args = new[] { logFile, arg1, arg2 }.Select(p => p.QuoteIfSpaced());
            var serviceName = "test-service-foo-bar";
            var displayName = "Test Service - Foo,Bar";
            var commandline = string.Join(
                " ",
                new[] { serviceExe }
                .Concat(args)
                );
            var util = new WindowsServiceUtil(
                serviceName,
                displayName,
                commandline
                );

            if (util.IsInstalled)
            {
                util.Uninstall();
            }

            if (File.Exists(logFile))
            {
                File.Delete(logFile);
            }

            // Act
            using var resetter = new AutoResetter(
                      () => util.Install(),
                      () => util.Uninstall(true));
            util.Install();
            // Assert
            Expect(util.IsInstalled)
            .To.Be.True();
            util.Start();
            Expect(util.State)
            .To.Equal(ServiceState.Running);

            Expect(logFile)
            .To.Exist();
            var logData = TryReadAllLinesFrom(logFile);

            Expect(logData)
            .Not.To.Be.Empty();
            Expect(logData[0])
            .To.Contain(arg1)
            .Then(arg2);

            util.Stop();

            Expect(util.State)
            .To.Equal(ServiceState.Stopped);

            var anotherUtil = Create(serviceName);

            Expect(anotherUtil.Commandline)
            .To.Equal(commandline);
            Expect(anotherUtil.ServiceExe)
            .To.Equal(serviceExe);
            Expect(anotherUtil.DisplayName)
            .To.Equal(displayName);
        }