Beispiel #1
0
        public void Test_BuildFromOptionalSources_ConfigAJson_Ok()
        {
            // Arrange
            var expected = new ConfigA("Config1", 2, true);

            var source = new ConfigurationSource <ConfigA>(
                Environment.Default,
                FileType.Json,
                false
                );

            // Act
            var actual = new ConfigA();

            this.Builder
            .Register(
                source,
                source.With(Environment.Production).With(true)
                )
            .Build()
            .GetSection(nameof(ConfigA))
            .Bind(actual);

            // Assert
            expected.AssertWith(actual);
        }
        public void Test_ConfigureWithDI_HotReload_Ok()
        {
            // Arrange
            PrepareHotReloadFile();

            var expected       = new ConfigA("Config1", 4, true);
            var configurations = this.Builder
                                 .Auto <ConfigA>(FileType.Json)
                                 .Build();

            var provider = new ServiceCollection()
                           .AddOptions()
                           .AutoConfigure <ConfigA>(configurations)
                           .BuildServiceProvider();

            // Act
            var old    = provider.GetService <IOptions <ConfigA> >().Value;
            var file   = ModifyHotReloadFile(expected);
            var actual = provider
                         .GetRequiredService <IOptionsSnapshot <ConfigA> >()
                         .Value;

            // Assert
            Console.WriteLine(JsonConvert.SerializeObject(
                                  old, Formatting.Indented
                                  ));

            expected.AssertWith(actual);

            file.Delete();
        }
Beispiel #3
0
        public void ConstructorAppliesConfigurationsInOrderDefinedbyAttribute()
        {
            var configA  = new ConfigA();
            var configB  = new ConfigB();
            var settings = new CassetteSettings(new IConfiguration <CassetteSettings>[] { configB, configA });

            // Each config appends a letter to Version so we can test the order that they were called.
            settings.Version.ShouldEqual("AB");
        }
Beispiel #4
0
        public void ConstructorAppliesConfigurations()
        {
            var configA = new ConfigA();
            var configB = new ConfigB();

            var settings = new CassetteSettings(new IConfiguration <CassetteSettings>[] { configA, configB });

            configA.AssertWasCalled(settings);
            configB.AssertWasCalled(settings);
        }
        public void Test_ConfigA_AutoBound()
        {
            // Arrange
            var expected = new ConfigA("Config1", 3, true);

            // Act
            var actual = this.Builder
                         .Auto <ConfigA>(FileType.Json)
                         .Build()
                         .Bind <ConfigA>();

            // Assert
            expected.AssertWith(actual);
        }
        public static FileInfo ModifyHotReloadFile(ConfigA config)
        {
            var file = PrepareHotReloadFile();

            File.WriteAllText(
                file.FullName,
                JsonConvert.SerializeObject(
                    new
            {
                configA = config
            }, Formatting.Indented
                    )
                );

            System.Threading.Thread.Sleep(1000);
            return(file);
        }
Beispiel #7
0
        public void Test_AutoBuild_ConfigAJson_Ok()
        {
            // Arrange
            var expected = new ConfigA("Config1", 3, true);

            // Act
            var actual = new ConfigA();

            this.Builder
            .Auto <ConfigA>(FileType.Json)
            .Build()
            .GetSection(nameof(ConfigA))
            .Bind(actual);

            // Assert
            expected.AssertWith(actual);
        }
        public void Test_AutoBind_MultiConfig_Ok()
        {
            // Arrange
            var expectedA = new ConfigA("Config1", 3, true);
            var expectedB = new ConfigA("Config1", 2, true);

            // Act
            var builder = this.Builder
                          .Auto <ConfigA>(FileType.Json)
                          .Auto <ConfigB>(FileType.Json)
                          .Build();
            var actualA = builder.Bind <ConfigA>();
            var actualB = builder.Bind <ConfigB>();

            // Assert
            expectedA.AssertWith(actualA);
            expectedB.AssertWith(actualB.ConfigA);
        }
Beispiel #9
0
        public void ConfigurationSectionTest()
        {
            UnityContainer unityContainer = (UnityContainer)ServiceLocator.Current.GetInstance <IUnityContainer>();
            IAppConfig     appConfig      = Substitute.For <IAppConfig>();

            appConfig.GetString(null).ReturnsForAnyArgs(ci =>
            {
                switch (ci.Arg <string>().ToLower())
                {
                case "configa:maxvalue":
                    return("10");

                case "configb:maxvalue":
                    return("20");
                }

                return(null);
            });
            unityContainer.RegisterInstance(appConfig);

            ApplicationContext applicationContext = new ApplicationContext()
            {
                Container = unityContainer
            };

            ConfigurationService configurationService = new ConfigurationService(new IConfigurationSection[2] {
                new ConfigA(applicationContext), new ConfigB(applicationContext)
            });

            ConfigA configA = (ConfigA)configurationService["configA"];
            ConfigB configB = (ConfigB)configurationService["configB"];

            configA.Initialize();
            configB.Initialize();

            ushort maxValueA = configA.MaxValue;
            ushort maxValueB = configB.MaxValue;

            Assert.Equal(10, maxValueA);
            Assert.Equal(20, maxValueB);
        }
        public void Test_ConfigureWithDI_Ok()
        {
            // Arrange
            var expected       = new ConfigA("Config1", 3, true);
            var configurations = this.Builder
                                 .Auto <ConfigA>(FileType.Json)
                                 .Build();

            var provider = new ServiceCollection()
                           .AddOptions()
                           .AutoConfigure <ConfigA>(configurations)
                           .BuildServiceProvider();

            // Act
            var actual = provider
                         .GetRequiredService <IOptions <ConfigA> >()
                         .Value;

            // Assert
            expected.AssertWith(actual);
        }