OptionsBuilderTest.cs

// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Xunit;

namespace Microsoft.Extensions.Options.Tests
{
    public class OptionsBuilderTest
    {
        [Fact]
        public void CanSupportDefaultName()
        {
            var services = new ServiceCollection();
            var dic = new Dictionary<string, string>
            {
                { "Message", "!" },
            };
            var config = new ConfigurationBuilder().AddInMemoryCollection(dic).Build();

            var builder = services.AddOptions<FakeOptions>();
            builder
                .Configure(options => options.Message += "Igetstomped")
                .Bind(config)
                .PostConfigure(options => options.Message += "]")
                .Configure(options => options.Message += "[")
                .Configure(options => options.Message += "Default");

            var sp = services.BuildServiceProvider();
            var factory = sp.GetRequiredService<IOptionsFactory<FakeOptions>>();
            Assert.Equal("![Default]", factory.Create(Options.DefaultName).Message);
        }

        [Fact]
        public void CanSupportNamedOptions()
        {
            var services = new ServiceCollection();
            var dic = new Dictionary<string, string>
            {
                { "Message", "!" },
            };
            var config = new ConfigurationBuilder().AddInMemoryCollection(dic).Build();

            var builder1 = services.AddOptions<FakeOptions>("1");
            var builder2 = services.AddOptions<FakeOptions>("2");
            builder1
                .Bind(config)
                .PostConfigure(options => options.Message += "]")
                .Configure(options => options.Message += "[")
                .Configure(options => options.Message += "one");
            builder2
                .Bind(config)
                .PostConfigure(options => options.Message += ">")
                .Configure(options => options.Message += "<")
                .Configure(options => options.Message += "two");

            var sp = services.BuildServiceProvider();
            var factory = sp.GetRequiredService<IOptionsFactory<FakeOptions>>();
            Assert.Equal("![one]", factory.Create("1").Message);
            Assert.Equal("!<two>", factory.Create("2").Message);
        }

        [Fact]
        public void CanMixConfigureCallsOutsideBuilderInOrder()
        {
            var services = new ServiceCollection();
            var builder = services.AddOptions<FakeOptions>("1");

            services.ConfigureAll<FakeOptions>(o => o.Message += "A");
            builder.PostConfigure(o => o.Message += "D");
            services.PostConfigure<FakeOptions>("1", o => o.Message += "E");
            builder.Configure(o => o.Message += "B");
            services.Configure<FakeOptions>("1", o => o.Message += "C");

            var sp = services.BuildServiceProvider();
            var factory = sp.GetRequiredService<IOptionsFactory<FakeOptions>>();
            Assert.Equal("ABCDE", factory.Create("1").Message);
        }


        public class SomeService
        {
            public SomeService(string stuff) => Stuff = stuff;

            public string Stuff { get; set; }
        }

        public class Counter
        {
            public int Count { get; set; }

            public void Increment() => Count++;
        }

        public class SomeCounterConsumer
        {
            public SomeCounterConsumer(Counter c)
            {
                Current = c.Count;
                c.Increment();
            }

            public int Current { get; }
        }

        [Fact]
        public void ConfigureOptionsWithSingletonDepWillUpdate()
        {
            var someService = new SomeService("Something");
            var services = new ServiceCollection().AddOptions().AddSingleton(someService);
            services.AddOptions<FakeOptions>().Configure<SomeService>((o, s) => o.Message = s.Stuff);
            services.AddOptions<FakeOptions>("named").Configure<SomeService>((o, s) => o.Message = "named " + s.Stuff);

            var sp = services.BuildServiceProvider();
            var factory = sp.GetRequiredService<IOptionsFactory<FakeOptions>>();

            Assert.Equal("named Something", factory.Create("named").Message);
            Assert.Equal("Something", factory.Create(Options.DefaultName).Message);

            someService.Stuff = "Else";

            Assert.Equal("named Else", factory.Create("named").Message);
            Assert.Equal("Else", factory.Create(Options.DefaultName).Message);
        }

        [Fact]
        public void ConfigureOptionsWithTransientDep()
        {
            var services = new ServiceCollection()
                .AddSingleton<Counter>()
                .AddTransient<SomeCounterConsumer>();
            services.AddOptions<FakeOptions>().Configure(o => o.Message = "none");
            services.AddOptions<FakeOptions>("1dep").Configure<SomeCounterConsumer>((o, s) => o.Message = s.Current + "");
            services.AddOptions<FakeOptions>("2dep").Configure<SomeCounterConsumer, SomeCounterConsumer>((o, s, s2) => o.Message = s.Current + " " + s2.Current);
            services.AddOptions<FakeOptions>("3dep").Configure<SomeCounterConsumer, SomeCounterConsumer, SomeCounterConsumer>((o, s, s2, s3) => o.Message = s.Current + " " + s2.Current + " " + s3.Current);
            services.AddOptions<FakeOptions>("4dep").Configure<SomeCounterConsumer, SomeCounterConsumer, SomeCounterConsumer, SomeCounterConsumer>((o, s, s2, s3, s4) => o.Message = s.Current + " " + s2.Current + " " + s3.Current + " " + s4.Current);
            services.AddOptions<FakeOptions>("5dep").Configure<SomeCounterConsumer, SomeCounterConsumer, SomeCounterConsumer, SomeCounterConsumer, SomeCounterConsumer>((o, s, s2, s3, s4, s5) => o.Message = s.Current + " " + s2.Current + " " + s3.Current + " " + s4.Current + " " + s5.Current);

            var sp = services.BuildServiceProvider();
            var factory = sp.GetRequiredService<IOptionsFactory<FakeOptions>>();

            Assert.Equal("none", factory.Create(Options.DefaultName).Message);
            Assert.Equal("0", factory.Create("1dep").Message);
            Assert.Equal("1 2", factory.Create("2dep").Message);
            Assert.Equal("3 4 5", factory.Create("3dep").Message);
            Assert.Equal("6 7 8 9", factory.Create("4dep").Message);
            Assert.Equal("10 11 12 13 14", factory.Create("5dep").Message);

            // Factory caches configures
            Assert.Equal("0", factory.Create("1dep").Message);

            // New factory will reexecute
            Assert.Equal("15", sp.GetRequiredService<IOptionsFactory<FakeOptions>>().Create("1dep").Message);
        }

        [Fact]
        public void PostConfigureOptionsWithTransientDep()
        {
            var services = new ServiceCollection()
                .AddSingleton<Counter>()
                .AddTransient<SomeCounterConsumer>();
            services.ConfigureAll<FakeOptions>(o => o.Message = "Override");
            services.AddOptions<FakeOptions>().PostConfigure(o => o.Message = "none");
            services.AddOptions<FakeOptions>("1dep").PostConfigure<SomeCounterConsumer>((o, s) => o.Message = s.Current + "");
            services.AddOptions<FakeOptions>("2dep").PostConfigure<SomeCounterConsumer, SomeCounterConsumer>((o, s, s2) => o.Message = s.Current + " " + s2.Current);
            services.AddOptions<FakeOptions>("3dep").PostConfigure<SomeCounterConsumer, SomeCounterConsumer, SomeCounterConsumer>((o, s, s2, s3) => o.Message = s.Current + " " + s2.Current + " " + s3.Current);
            services.AddOptions<FakeOptions>("4dep").PostConfigure<SomeCounterConsumer, SomeCounterConsumer, SomeCounterConsumer, SomeCounterConsumer>((o, s, s2, s3, s4) => o.Message = s.Current + " " + s2.Current + " " + s3.Current + " " + s4.Current);
            services.AddOptions<FakeOptions>("5dep").PostConfigure<SomeCounterConsumer, SomeCounterConsumer, SomeCounterConsumer, SomeCounterConsumer, SomeCounterConsumer>((o, s, s2, s3, s4, s5) => o.Message = s.Current + " " + s2.Current + " " + s3.Current + " " + s4.Current + " " + s5.Current);

            var sp = services.BuildServiceProvider();
            var factory = sp.GetRequiredService<IOptionsFactory<FakeOptions>>();

            Assert.Equal("none", factory.Create(Options.DefaultName).Message);
            Assert.Equal("0", factory.Create("1dep").Message);
            Assert.Equal("1 2", factory.Create("2dep").Message);
            Assert.Equal("3 4 5", factory.Create("3dep").Message);
            Assert.Equal("6 7 8 9", factory.Create("4dep").Message);
            Assert.Equal("10 11 12 13 14", factory.Create("5dep").Message);

            // Factory caches configures
            Assert.Equal("0", factory.Create("1dep").Message);

            // New factory will reexecute
            Assert.Equal("15", sp.GetRequiredService<IOptionsFactory<FakeOptions>>().Create("1dep").Message);
        }

        [Fact]
        public void CanConfigureWithServiceProvider()
        {
            var someService = new SomeService("Something");
            var services = new ServiceCollection().AddSingleton(someService);
            services.AddOptions<FakeOptions>().Configure<IServiceProvider>((o, s) => o.Message = s.GetRequiredService<SomeService>().Stuff);

            var sp = services.BuildServiceProvider();
            var factory = sp.GetRequiredService<IOptionsFactory<FakeOptions>>();
            Assert.Equal("Something", factory.Create(Options.DefaultName).Message);
        }

        [Theory]
        [InlineData("PrivateSetter")]
        [InlineData("ProtectedSetter")]
        [InlineData("InternalSetter")]
        public void CanBindToNonPublicProperties(string property)
        {
            var dic = new Dictionary<string, string>
            {
                {property, "stuff"},
            };
            var services = new ServiceCollection();
            services.AddOptions<ComplexOptions>().Bind(new ConfigurationBuilder().AddInMemoryCollection(dic).Build(), o => o.BindNonPublicProperties = true);
            var sp = services.BuildServiceProvider();
            var options = sp.GetRequiredService<IOptions<ComplexOptions>>().Value;
            Assert.Equal("stuff", options.GetType().GetProperty(property).GetValue(options));
        }

        [Theory]
        [InlineData("PrivateSetter")]
        [InlineData("ProtectedSetter")]
        [InlineData("InternalSetter")]
        public void CanNamedBindToNonPublicProperties(string property)
        {
            var dic = new Dictionary<string, string>
            {
                {property, "stuff"},
            };
            var services = new ServiceCollection();
            services.AddOptions<ComplexOptions>("named").Bind(new ConfigurationBuilder().AddInMemoryCollection(dic).Build(), o => o.BindNonPublicProperties = true);
            var sp = services.BuildServiceProvider();
            var options = sp.GetRequiredService<IOptionsMonitor<ComplexOptions>>().Get("named");
            Assert.Equal("stuff", options.GetType().GetProperty(property).GetValue(options));
        }

        [Fact]
        public void CanValidateOptionsWithCustomError()
        {
            var services = new ServiceCollection();
            services.AddOptions<ComplexOptions>()
                .Configure(o => o.Boolean = false)
                .Validate(Options.DefaultName, o => o.Boolean, "Boolean must be true.");
            var sp = services.BuildServiceProvider();
            var error = Assert.Throws<OptionsValidationException>(() => sp.GetRequiredService<IOptions<ComplexOptions>>().Value);
            Assert.Equal("Boolean must be true.", error.Failures.First());
        }

        [Fact]
        public void CanValidateOptionsWithDefaultError()
        {
            var services = new ServiceCollection();
            services.AddOptions<ComplexOptions>()
                .Configure(o => o.Boolean = false)
                .Validate(o => o.Boolean);
            var sp = services.BuildServiceProvider();
            var error = Assert.Throws<OptionsValidationException>(() => sp.GetRequiredService<IOptions<ComplexOptions>>().Value);
            Assert.Equal("A validation error has occured.", error.Failures.First());
        }

        [Fact]
        public void CanValidateOptionsWithMultipleDefaultErrors()
        {
            var services = new ServiceCollection();
            services.AddOptions<ComplexOptions>()
                .Configure(o =>
                {
                    o.Boolean = false;
                    o.Integer = 11;
                })
                .Validate(o => o.Boolean)
                .Validate(o => o.Integer > 12);

            var sp = services.BuildServiceProvider();
            var error = Assert.Throws<OptionsValidationException>(() => sp.GetRequiredService<IOptions<ComplexOptions>>().Value);
            var errors = error.Failures.ToArray();
            Assert.Equal(2, errors.Length);
            Assert.Equal("A validation error has occured.", errors[0]);
            Assert.Equal("A validation error has occured.", errors[1]);
        }

        [Fact]
        public void CanValidateOptionsWithMixedOverloads()
        {
            var services = new ServiceCollection();
            services.AddOptions<ComplexOptions>()
                .Configure(o =>
                {
                    o.Boolean = false;
                    o.Integer = 11;
                    o.Virtual = "wut";
                })
                .Validate(o => o.Boolean)
                .Validate(Options.DefaultName, o => o.Virtual == null, "Virtual")
                .Validate(o => o.Integer > 12, "Integer");

            var sp = services.BuildServiceProvider();
            var error = Assert.Throws<OptionsValidationException>(() => sp.GetRequiredService<IOptions<ComplexOptions>>().Value);
            var errors = error.Failures.ToArray();
            Assert.Equal(3, errors.Length);
            Assert.Equal("A validation error has occured.", errors[0]);
            Assert.Equal("Virtual", errors[1]);
            Assert.Equal("Integer", errors[2]);
        }

        private class MultiOptionValidator : IValidateOptions<ComplexOptions>, IValidateOptions<FakeOptions>
        {
            private readonly string _allowed;
            public MultiOptionValidator(string allowed) => _allowed = allowed;

            public ValidateOptionsResult Validate(string name, ComplexOptions options)
            {
                if (options.Virtual == _allowed)
                {
                    return ValidateOptionsResult.Success;
                }
                return ValidateOptionsResult.Fail("Virtual != " + _allowed);
            }

            public ValidateOptionsResult Validate(string name, FakeOptions options)
            {
                if (options.Message == _allowed)
                {
                    return ValidateOptionsResult.Success;
                }
                return ValidateOptionsResult.Fail("Message != " + _allowed);
            }
        }

        [Fact]
        public void CanValidateMultipleOptionsWithOneValidator()
        {
            var services = new ServiceCollection();
            services.AddOptions<ComplexOptions>()
                .Configure(o => o.Virtual = "wut");
            services.AddOptions<FakeOptions>("fake")
                .Configure(o => o.Message = "real");

            var validator = new MultiOptionValidator("real");
            services.AddSingleton<IValidateOptions<ComplexOptions>>(validator);
            services.AddSingleton<IValidateOptions<FakeOptions>>(validator);

            var sp = services.BuildServiceProvider();
            var error = Assert.Throws<OptionsValidationException>(() => sp.GetRequiredService<IOptions<ComplexOptions>>().Value);
            Assert.Single(error.Failures);
            Assert.Equal("Virtual != real", error.Failures.First());

            error = Assert.Throws<OptionsValidationException>(() => sp.GetRequiredService<IOptions<FakeOptions>>().Value);
            Assert.Single(error.Failures);
            Assert.Equal("Message != real", error.Failures.First());

            var fake = sp.GetRequiredService<IOptionsMonitor<FakeOptions>>().Get("fake");
            Assert.Equal("real", fake.Message);
        }

        private class DependencyValidator : IValidateOptions<ComplexOptions>
        {
            private readonly string _allowed;
            public DependencyValidator(IOptions<FakeOptions> _fake)
            {
                _allowed = _fake.Value.Message;
            }

            public ValidateOptionsResult Validate(string name, ComplexOptions options)
            {
                if (options.Virtual == _allowed)
                {
                    return ValidateOptionsResult.Success;
                }
                return ValidateOptionsResult.Fail("Virtual != " + _allowed);
            }
        }

        [Fact]
        public void CanValidateOptionsThatDependOnOptions()
        {
            var services = new ServiceCollection();
            services.AddOptions<ComplexOptions>()
                .Configure(o => o.Virtual = "default");
            services.AddOptions<ComplexOptions>("yes")
                .Configure(o => o.Virtual = "target");
            services.AddOptions<ComplexOptions>("no")
                .Configure(o => o.Virtual = "no");
            services.AddOptions<FakeOptions>()
                .Configure(o => o.Message = "target");
            services.AddSingleton<IValidateOptions<ComplexOptions>, DependencyValidator>();

            var sp = services.BuildServiceProvider();

            var error = Assert.Throws<OptionsValidationException>(() => sp.GetRequiredService<IOptions<ComplexOptions>>().Value);
            Assert.Single(error.Failures);
            Assert.Equal("Virtual != target", error.Failures.First());

            error = Assert.Throws<OptionsValidationException>(() => sp.GetRequiredService<IOptionsMonitor<ComplexOptions>>().Get(Options.DefaultName));
            Assert.Single(error.Failures);
            Assert.Equal("Virtual != target", error.Failures.First());

            error = Assert.Throws<OptionsValidationException>(() => sp.GetRequiredService<IOptionsMonitor<ComplexOptions>>().Get("no"));
            Assert.Single(error.Failures);
            Assert.Equal("Virtual != target", error.Failures.First());

            var op = sp.GetRequiredService<IOptionsMonitor<ComplexOptions>>().Get("yes");
            Assert.Equal("target", op.Virtual);
        }

    }
}