public void ShouldReadAllConfigurations()
    {
        var system = new SystemUnderTest();

        system.WorkerServerStarter.Start(new ConfigurationOptions
        {
            UpdateConfigurations = new []
            {
                new UpdateStorageConfiguration
                {
                    ConnectionString = new SqlConnectionStringBuilder {
                        DataSource = "DataSource"
                    }.ToString(),
                    Name       = DefaultConfigurationName.Name(),
                    SchemaName = "defaultSchemaName"
                }
            }
        });
        system.ConfigurationApi().CreateServerConfiguration(new CreateSqlServerWorkerServer
        {
            Server                = "newServer",
            Database              = "database",
            User                  = "******",
            Password              = "******",
            SchemaCreatorUser     = "******",
            SchemaCreatorPassword = "******",
            SchemaName            = "newSchemaName"
        });

        var configurations = system.ConfigurationStorage.ReadConfigurations();

        Assert.AreEqual(2, configurations.Count());
    }
Beispiel #2
0
        public void ShouldNotActivateWhenUpdating()
        {
            var system = new SystemUnderTest();

            system.ConfigurationStorage.Has(new StoredConfiguration {
                ConnectionString = new NpgsqlConnectionStringBuilder {
                    ApplicationName = "ApplicationName.AutoUpdate"
                }.ToString(), Active = false
            });
            system.ConfigurationStorage.Has(new StoredConfiguration {
                ConnectionString = new NpgsqlConnectionStringBuilder {
                    Host = "DataSource"
                }.ToString(), Active = true
            });

            system.WorkerServerStarter.Start(new ConfigurationOptions
            {
                UpdateConfigurations = new []
                {
                    new UpdateStorageConfiguration
                    {
                        ConnectionString = new NpgsqlConnectionStringBuilder {
                            Host = "AutoUpdate"
                        }.ToString(),
                        Name = DefaultConfigurationName.Name()
                    }
                }
            });

            Assert.False(system.ConfigurationStorage.Data.First().Active);
            Assert.True(system.ConfigurationStorage.Data.Last().Active);
        }
Beispiel #3
0
    public void ShouldNotInsertMultiple()
    {
        Parallel.ForEach(Enumerable.Range(1, 10), _ =>
        {
            var system = new SystemUnderInfraTest();
            system.UseOptions(new ConfigurationOptions
            {
                ConnectionString     = ConnectionString,
                UpdateConfigurations = new[]
                {
                    new UpdateStorageConfiguration
                    {
                        ConnectionString = ConnectionString,
                        Name             = DefaultConfigurationName.Name()
                    }
                }
            });
            system.StartWorkerServers();
        });

        var system = new SystemUnderInfraTest();

        system.UseOptions(new ConfigurationOptions {
            ConnectionString = ConnectionString
        });
        var storage = system.ConfigurationStorage;

        storage.ReadConfigurations()
        .Should().Have.Count.EqualTo(1);
    }
Beispiel #4
0
        public void ShouldUpdate()
        {
            var system = new SystemUnderTest();
            var existing = new NpgsqlConnectionStringBuilder {
                Host = "existingDataSource", ApplicationName = "existingApplicationName.AutoUpdate"
            }.ToString();

            system.ConfigurationStorage.Has(new StoredConfiguration {
                ConnectionString = existing
            });

            system.WorkerServerStarter.Start(new ConfigurationOptions
            {
                UpdateConfigurations = new []
                {
                    new UpdateStorageConfiguration
                    {
                        ConnectionString = new NpgsqlConnectionStringBuilder {
                            Host = "newDataSource", ApplicationName = "newApplicationName"
                        }.ToString(),
                        Name = DefaultConfigurationName.Name()
                    }
                }
            });

            var updatedConnectionString = new NpgsqlConnectionStringBuilder(system.ConfigurationStorage.Data.Single().ConnectionString);

            Assert.AreEqual("newDataSource", updatedConnectionString.Host);
            Assert.AreEqual("newApplicationName.AutoUpdate", updatedConnectionString.ApplicationName);
        }
Beispiel #5
0
        public void ShouldAddAutoUpdatedConfigurationIfNoMarkedExists()
        {
            var system = new SystemUnderTest();

            system.ConfigurationStorage.Has(new StoredConfiguration {
                ConnectionString = new NpgsqlConnectionStringBuilder {
                    Host = "existing"
                }.ToString()
            });

            system.WorkerServerStarter.Start(new ConfigurationOptions
            {
                UpdateConfigurations = new []
                {
                    new UpdateStorageConfiguration
                    {
                        ConnectionString = new NpgsqlConnectionStringBuilder {
                            Host = "autoupdated"
                        }.ToString(),
                        Name = DefaultConfigurationName.Name()
                    }
                }
            });

            var actual = system.ConfigurationStorage.Data.OrderBy(x => x.Id).Last();

            Assert.AreEqual("autoupdated", new NpgsqlConnectionStringBuilder(actual.ConnectionString).Host);
        }
Beispiel #6
0
    private void enqueuedJobOnWorker(string storageConnstring)
    {
        var system = new SystemUnderInfraTest();

        system.UseOptions(new ConfigurationOptions
        {
            ConnectionString     = ConnectionString,
            UpdateConfigurations = new[]
            {
                new UpdateStorageConfiguration
                {
                    ConnectionString = storageConnstring,
                    Name             = DefaultConfigurationName.Name()
                }
            }
        });
        system.UseRealHangfire();
        FakeJobService.Reset();

        var publisher = system.QueryPublishers().Single();

        publisher.BackgroundJobClient.Enqueue(() => FakeJobService.RunTheJob());
        WorkerEmulation.SingleIteration(publisher.JobStorage);

        FakeJobService.WasRun.Should().Be.True();
    }
    private void runJobs(string storageConnectionString)
    {
        var system = new SystemUnderInfraTest();

        system.UseOptions(new ConfigurationOptions
        {
            ConnectionString     = ConnectionString,
            UpdateConfigurations = new[]
            {
                new UpdateStorageConfiguration
                {
                    ConnectionString = storageConnectionString,
                    Name             = DefaultConfigurationName.Name()
                }
            }
        })
        .UseServerOptions(new BackgroundJobServerOptions
        {
            Queues = _queues
        });
        system.UseRealHangfire();
        FakeJobService.Reset();

        var publisher = system.QueryPublishers().Single();

        publisher.BackgroundJobClient.Enqueue(() => FakeJobService.DefaultQueueJob());
        publisher.BackgroundJobClient.Enqueue(() => FakeJobService.AQueueJob());
        WorkerEmulation.SingleIteration(publisher.JobStorage, _queues);
        WorkerEmulation.SingleIteration(publisher.JobStorage, _queues);
    }
Beispiel #8
0
        public void ShouldAutoUpdateWithDefaultConfigurationName2()
        {
            var system = new SystemUnderTest();

            system.ConfigurationStorage.Has(new StoredConfiguration {
                ConnectionString = new NpgsqlConnectionStringBuilder {
                    ApplicationName = "ApplicationName.AutoUpdate"
                }.ToString(), Active = false
            });

            system.WorkerServerStarter.Start(new ConfigurationOptions
            {
                UpdateConfigurations = new []
                {
                    new UpdateStorageConfiguration
                    {
                        ConnectionString = new NpgsqlConnectionStringBuilder {
                            Host = "DataSource"
                        }.ToString(),
                        Name = DefaultConfigurationName.Name()
                    }
                }
            });

            Assert.AreEqual("Hangfire", system.ConfigurationStorage.Data.Single().Name);
        }
Beispiel #9
0
        public void ShouldSaveSchemaNameOnLegacyConfiguration()
        {
            var system = new SystemUnderTest();

            system.ConfigurationStorage.Has(new StoredConfiguration {
                GoalWorkerCount = 4
            });

            system.WorkerServerStarter.Start(new ConfigurationOptions
            {
                UpdateConfigurations = new []
                {
                    new UpdateStorageConfiguration
                    {
                        ConnectionString = new NpgsqlConnectionStringBuilder {
                            Host = "AutoUpdate"
                        }.ToString(),
                        Name       = DefaultConfigurationName.Name(),
                        SchemaName = "schemaName"
                    }
                }
            });

            Assert.AreEqual("schemaName", system.ConfigurationStorage.Data.Single().SchemaName);
        }
Beispiel #10
0
        private bool runConfigurationUpdates(IEnumerable <UpdateStorageConfiguration> received)
        {
            var stored = _storage.ReadConfigurations();

            received.ForEach(update =>
            {
                var configuration = stored.FirstOrDefault(c => c.Name == update.Name) ??
                                    new StoredConfiguration
                {
                    Name   = update.Name,
                    Active = true
                };

                if (update.Name == DefaultConfigurationName.Name())
                {
                    configuration.ConnectionString = markConnectionString(update.ConnectionString);
                }
                else
                {
                    configuration.ConnectionString = update.ConnectionString;
                }

                configuration.SchemaName = update.SchemaName;
                _storage.WriteConfiguration(configuration);
            });

            return(true);
        }
Beispiel #11
0
        public void ShouldUpdateLegacyConfiguration()
        {
            var system = new SystemUnderTest();

            system.ConfigurationStorage.Has(new StoredConfiguration {
                GoalWorkerCount = 55
            });

            system.WorkerServerStarter.Start(new ConfigurationOptions
            {
                UpdateConfigurations = new []
                {
                    new UpdateStorageConfiguration
                    {
                        ConnectionString = new NpgsqlConnectionStringBuilder {
                            Host = "dataSource", ApplicationName = "applicationName"
                        }.ToString(),
                        Name = DefaultConfigurationName.Name()
                    }
                }
            });

            var expected = new NpgsqlConnectionStringBuilder {
                Host = "dataSource", ApplicationName = "applicationName.AutoUpdate"
            }.ToString();

            Assert.AreEqual(55, system.ConfigurationStorage.Data.Single().GoalWorkerCount);
            Assert.AreEqual(expected, system.ConfigurationStorage.Data.Single().ConnectionString);
        }
Beispiel #12
0
        private bool fixExistingConfigurations()
        {
            var stored = _storage.ReadConfigurations();

            var ordered = stored.OrderBy(x => x.Id).ToArray();

            var legacyConfiguration = ordered.FirstOrDefault(isLegacy);

            if (legacyConfiguration != null)
            {
                legacyConfiguration.Name ??= DefaultConfigurationName.Name();
                legacyConfiguration.Active ??= true;
                _storage.WriteConfiguration(legacyConfiguration);
                return(true);
            }

            var markedConfiguration = ordered.FirstOrDefault(isMarked);

            if (markedConfiguration != null)
            {
                markedConfiguration.Name = DefaultConfigurationName.Name();
                _storage.WriteConfiguration(markedConfiguration);
                return(true);
            }

            return(false);
        }
Beispiel #13
0
        public void ShouldAutoUpdate()
        {
            var system = new SystemUnderTest();

            system.ConfigurationStorage.Has(new StoredConfiguration());

            system.PublisherQueries
            .QueryPublishers(
                new ConfigurationOptions
            {
                UpdateConfigurations = new []
                {
                    new UpdateStorageConfiguration
                    {
                        ConnectionString = new SqlConnectionStringBuilder {
                            DataSource = "Hangfire"
                        }.ToString(),
                        Name = DefaultConfigurationName.Name()
                    }
                }
            });

            system.ConfigurationStorage.Data.Single().ConnectionString
            .Should().Contain("Hangfire");
        }
Beispiel #14
0
        public void ShouldNotUpdateExistingConfigurationThatIsNotMarked()
        {
            var system = new SystemUnderTest();
            var existing = new NpgsqlConnectionStringBuilder {
                Host = "existing"
            }.ToString();

            system.ConfigurationStorage.Has(new StoredConfiguration {
                ConnectionString = existing
            });

            system.WorkerServerStarter.Start(new ConfigurationOptions
            {
                UpdateConfigurations = new []
                {
                    new UpdateStorageConfiguration
                    {
                        ConnectionString = new NpgsqlConnectionStringBuilder {
                            Host = "autoupdated"
                        }.ToString(),
                        Name = DefaultConfigurationName.Name()
                    }
                }
            });

            var actual = system.ConfigurationStorage.Data.OrderBy(x => x.Id).First();

            Assert.AreEqual(existing, actual.ConnectionString);
        }
        public void ShouldBeActiveOnUpdateIfActiveBefore()
        {
            var system = new SystemUnderTest();

            system.ConfigurationStorage.Has(new StoredConfiguration
            {
                ConnectionString = new SqlConnectionStringBuilder {
                    ApplicationName = "ApplicationName.AutoUpdate"
                }.ToString(),
                Active = true
            });

            system.WorkerServerStarter.Start(new ConfigurationOptions
            {
                UpdateConfigurations = new []
                {
                    new UpdateStorageConfiguration
                    {
                        ConnectionString = new SqlConnectionStringBuilder {
                            DataSource = "DataSource"
                        }.ToString(),
                        Name = DefaultConfigurationName.Name()
                    }
                }
            });

            Assert.True(system.ConfigurationStorage.Data.Single().Active);
        }
Beispiel #16
0
        public void ShouldUpdateAutoUpdateMarkedWithDefaultName()
        {
            var system = new SystemUnderTest();

            system.ConfigurationStorage.Has(new StoredConfiguration {
                ConnectionString = "Application Name=name.AutoUpdate"
            });

            var result = system.WorkerServerQueries.QueryAllWorkerServers();

            Assert.AreEqual(DefaultConfigurationName.Name(), result.Single().Name);
        }
Beispiel #17
0
        public void ShouldUpdateLegacyWithDefaultName()
        {
            var system = new SystemUnderTest();

            system.ConfigurationStorage.Has(new StoredConfiguration {
                GoalWorkerCount = 3
            });

            var result = system.WorkerServerQueries.QueryAllWorkerServers();

            Assert.AreEqual(DefaultConfigurationName.Name(), result.Single().Name);
        }
    public void ShouldUpgradeFrom2To3()
    {
        DatabaseTestSetup.SetupSqlServer(ConnectionStrings.SqlServer, schemaVersion: 2);
        Assert.AreEqual(2, version());
        using (var c = new SqlConnection(ConnectionStrings.SqlServer))
        {
            c.Execute(@"INSERT INTO HangfireConfiguration.Configuration (ConnectionString) VALUES (@ConnectionString)", new values());
            c.Execute(@"INSERT INTO HangfireConfiguration.Configuration (ConnectionString) VALUES (@ConnectionString)", new values());
        }

        install(3);

        Assert.AreEqual(DefaultConfigurationName.Name(), read().First().Name);
        Assert.AreEqual(3, version());
    }
        public void ShouldGetDefaultForFirstServer()
        {
            var system = new SystemUnderTest();

            system.WorkerServerStarter.Start(
                new ConfigurationOptions
            {
                UpdateConfigurations = new []
                {
                    new UpdateStorageConfiguration
                    {
                        Name = DefaultConfigurationName.Name()
                    }
                }
            });

            Assert.AreEqual(10, system.Hangfire.StartedServers.Single().options.WorkerCount);
        }
    public void ShouldStartServerWithWorkers()
    {
        var system = new SystemUnderInfraTest();

        system.UseOptions(new ConfigurationOptions
        {
            ConnectionString     = ConnectionString,
            UpdateConfigurations = new[]
            {
                new UpdateStorageConfiguration
                {
                    ConnectionString = ConnectionString,
                    Name             = DefaultConfigurationName.Name()
                }
            }
        });
        system.StartWorkerServers();
    }
        public void ShouldUseDefaultGoalWorkerCount()
        {
            var system = new SystemUnderTest();

            system.WorkerServerStarter.Start(new ConfigurationOptionsForTest
            {
                UpdateConfigurations = new[]
                {
                    new UpdateStorageConfiguration
                    {
                        // ConnectionString = new SqlConnectionStringBuilder{ DataSource = "Hangfire" }.ToString(),
                        Name = DefaultConfigurationName.Name()
                    }
                },
                DefaultGoalWorkerCount = 12
            });

            Assert.AreEqual(12, system.Hangfire.StartedServers.Single().options.WorkerCount);
        }
        public void ShouldUseDefaultGoalWorkerCountWithMinimumKnownServers()
        {
            var system = new SystemUnderTest();

            system.WorkerServerStarter.Start(new ConfigurationOptionsForTest
            {
                UpdateConfigurations = new []
                {
                    new UpdateStorageConfiguration
                    {
                        Name = DefaultConfigurationName.Name()
                    }
                },
                DefaultGoalWorkerCount = 12,
                MinimumServerCount     = 2
            });

            Assert.AreEqual(6, system.Hangfire.StartedServers.Single().options.WorkerCount);
        }
        public void ShouldConfigureAndStartWithAutoUpdatedConnectionString()
        {
            var system = new SystemUnderTest();

            system.UseOptions(new ConfigurationOptions
            {
                UpdateConfigurations = new[]
                {
                    new UpdateStorageConfiguration
                    {
                        ConnectionString = "Host=Hangfire",
                        Name             = DefaultConfigurationName.Name()
                    }
                }
            });
            system.PublisherStarter.Start();

            Assert.NotNull(system.Hangfire.LastCreatedStorage);
        }
Beispiel #24
0
        public void ShouldUpdateLegacyOverAutoUpdateMarkedWithDefaultName()
        {
            var system = new SystemUnderTest();

            system.ConfigurationStorage.Has(new StoredConfiguration
            {
                Id = 1,
                ConnectionString = "Application Name=name.AutoUpdate"
            });
            system.ConfigurationStorage.Has(new StoredConfiguration
            {
                Id = 2,
                GoalWorkerCount = 3
            });

            var result = system.WorkerServerQueries.QueryAllWorkerServers();

            Assert.AreEqual(DefaultConfigurationName.Name(), result.Single(x => x.ConfigurationId == 2).Name);
            Assert.Null(result.Single(x => x.ConfigurationId == 1).Name);
        }
Beispiel #25
0
        public void ShouldActivateOnFirstUpdate()
        {
            var system = new SystemUnderTest();

            system.WorkerServerStarter.Start(new ConfigurationOptions
            {
                UpdateConfigurations = new []
                {
                    new UpdateStorageConfiguration
                    {
                        ConnectionString = new NpgsqlConnectionStringBuilder {
                            Host = "DataSource"
                        }.ToString(),
                        Name = DefaultConfigurationName.Name()
                    }
                }
            });

            Assert.True(system.ConfigurationStorage.Data.Single().Active);
        }
Beispiel #26
0
        public void ShouldAutoUpdate()
        {
            var system = new SystemUnderTest();

            system.ConfigurationStorage.Has(new StoredConfiguration());

            system.UseOptions(new ConfigurationOptions
            {
                UpdateConfigurations = new []
                {
                    new UpdateStorageConfiguration
                    {
                        ConnectionString = @"Data Source=.;Initial Catalog=Hangfire;",
                        Name             = DefaultConfigurationName.Name()
                    }
                }
            });
            system.WorkerServerQueries.QueryAllWorkerServers();

            system.ConfigurationStorage.Data.Single().ConnectionString
            .Should().Contain("Hangfire");
        }
        public void ShouldConfigureAutoUpdatedServer()
        {
            var system = new SystemUnderTest();

            system.WorkerServerStarter.Start(new ConfigurationOptions
            {
                UpdateConfigurations = new []
                {
                    new UpdateStorageConfiguration
                    {
                        ConnectionString = new SqlConnectionStringBuilder {
                            DataSource = "DataSource"
                        }.ToString(),
                        Name = DefaultConfigurationName.Name()
                    }
                }
            });

            var dataSource = new SqlConnectionStringBuilder(system.ConfigurationStorage.Data.Single().ConnectionString).DataSource;

            Assert.AreEqual("DataSource", dataSource);
        }
Beispiel #28
0
        public void ShouldConfigureAutoUpdatedServer()
        {
            var system = new SystemUnderTest();

            system.WorkerServerStarter.Start(new ConfigurationOptions
            {
                UpdateConfigurations = new []
                {
                    new UpdateStorageConfiguration
                    {
                        ConnectionString = new NpgsqlConnectionStringBuilder {
                            Host = "host"
                        }.ToString(),
                        Name = DefaultConfigurationName.Name()
                    }
                }
            });

            var host = new NpgsqlConnectionStringBuilder(system.ConfigurationStorage.Data.Single().ConnectionString).Host;

            Assert.AreEqual("host", host);
        }
Beispiel #29
0
        public void ShouldMarkAutoUpdatedConnectionStringWhenNoApplicationName()
        {
            var system = new SystemUnderTest();

            system.WorkerServerStarter.Start(new ConfigurationOptions
            {
                UpdateConfigurations = new []
                {
                    new UpdateStorageConfiguration
                    {
                        ConnectionString = new NpgsqlConnectionStringBuilder {
                            Host = "host"
                        }.ToString(),
                        Name = DefaultConfigurationName.Name()
                    }
                }
            });

            var applicationName = new NpgsqlConnectionStringBuilder(system.ConfigurationStorage.Data.Single().ConnectionString).ApplicationName;

            Assert.AreEqual("Hangfire.AutoUpdate", applicationName);
        }
Beispiel #30
0
        public void ShouldAutoUpdateTwiceIfAllConfigurationsWhereRemoved()
        {
            var system = new SystemUnderTest();

            system.WorkerServerStarter.Start(new ConfigurationOptions
            {
                UpdateConfigurations = new []
                {
                    new UpdateStorageConfiguration
                    {
                        ConnectionString = new NpgsqlConnectionStringBuilder {
                            Host = "FirstUpdate"
                        }.ToString(),
                        Name = DefaultConfigurationName.Name()
                    }
                }
            });
            system.ConfigurationStorage.Clear();

            system.PublisherQueries.QueryPublishers(new ConfigurationOptions
            {
                UpdateConfigurations = new []
                {
                    new UpdateStorageConfiguration
                    {
                        ConnectionString = new NpgsqlConnectionStringBuilder {
                            Host = "SecondUpdate"
                        }.ToString(),
                        Name = DefaultConfigurationName.Name()
                    }
                }
            });

            var host = new NpgsqlConnectionStringBuilder(system.ConfigurationStorage.Data.Single().ConnectionString).Host;

            Assert.AreEqual("SecondUpdate", host);
        }