public void CreateFactoryFromConfig_can_pass_non_option_parameters_through(IConfigurationReader configReader,
                                                                                   IReadsEnvironmentVariables env,
                                                                                   [NoAutoProperties] WebDriverFactoryConfigurationSection config,
                                                                                   IDictionary <string, object> caps,
                                                                                   IGetsBrowserFlags flagsProvider,
                                                                                   string scenarioName)
        {
            // Arrange
            var envVars = new Dictionary <string, string>();

            Mock.Get(configReader)
            .Setup(x => x.ReadSection <WebDriverFactoryConfigurationSection>())
            .Returns(config);
            Mock.Get(env)
            .Setup(x => x.GetEnvironmentVariables())
            .Returns(envVars);

            config.WebDriverFactoryAssemblyQualifiedType = typeof(DummyBrowserFactory).AssemblyQualifiedName;

            var sut = new WebDriverFactorySource(configurationReader: configReader,
                                                 environmentReader: env);

            // Act
            var factory = sut.CreateFactoryFromConfig();
            var result  = GetProxiedFactory(factory);

            factory.CreateWebDriver(caps, flagsProvider, scenarioName);

            // Assert
            Assert.That(result.CapturedName, Is.EqualTo(scenarioName));
            Assert.That(result.CapturedCapabilities, Is.SameAs(caps));
            Assert.That(result.CapturedFlagsProvider, Is.SameAs(flagsProvider));
        }
        public void GetProviderOptions_adds_environment_values_when_it_is_supported(IIndicatesEnvironmentSupport proxied,
                                                                                    [HasValues] Dictionary <string, string> proxiedResult,
                                                                                    IReadsEnvironmentVariables environment)
        {
            // Arrange
            var sut = new EnvironmentVariableFactoryDescriptionProxy(proxied, environment);

            Mock.Get(proxied).Setup(x => x.GetOptionKeyValuePairs()).Returns(proxiedResult);
            Mock.Get(proxied).SetupGet(x => x.EnvironmentVariableSupportEnabled).Returns(true);
            Mock.Get(proxied).Setup(x => x.GetEnvironmentVariablePrefix()).Returns("E_");
            Mock.Get(environment)
            .Setup(x => x.GetEnvironmentVariables())
            .Returns(new Dictionary <string, string> {
                { "E_EnvironmentVar", "EnvironmentValue" }
            });
            var expected = new Dictionary <string, string>(proxiedResult);

            expected.Add("EnvironmentVar", "EnvironmentValue");

            // Act
            var result = sut.GetOptionKeyValuePairs();

            // Assert
            Assert.That(result, Is.EquivalentTo(expected));
        }
Example #3
0
 /// <summary>
 /// Initializes a new instance of the <see cref="WebDriverFactorySource"/> class.
 /// </summary>
 /// <param name="factoryCreator">A factory service which creates web driver factories (a factory-factory if you will).</param>
 /// <param name="optionsCreator">A factory service which instantiates instances of factory options.</param>
 /// <param name="configurationReader">A service which reads the application configuration.</param>
 /// <param name="environmentReader">A service which reads the process' environment variables.</param>
 public WebDriverFactorySource(ICreatesWebDriverFactory factoryCreator      = null,
                               ICreatesFactoryOptions optionsCreator        = null,
                               IConfigurationReader configurationReader     = null,
                               IReadsEnvironmentVariables environmentReader = null)
 {
     this.factoryCreator      = GetFactoryCreator(factoryCreator);
     this.optionsCreator      = optionsCreator ?? new FactoryOptionsFactory();
     this.configurationReader = configurationReader ?? new ConfigurationReader();
     this.environmentReader   = environmentReader ?? new EnvironmentReader();
 }
        /// <summary>
        /// Initializes a new instance of the
        /// <see cref="EnvironmentVariableFactoryDescriptionProxy"/> class.
        /// </summary>
        /// <param name="proxied">The web driver factory description to proxy.</param>
        /// <param name="environmentReader">Environment reader.</param>
        public EnvironmentVariableFactoryDescriptionProxy(IDescribesWebDriverFactory proxied,
                                                          IReadsEnvironmentVariables environmentReader)
        {
            if (proxied == null)
            {
                throw new ArgumentNullException(nameof(proxied));
            }

            this.proxiedReader     = proxied;
            this.environmentReader = environmentReader ?? new EnvironmentReader();
        }
        public void CreateFactoryFromConfig_can_derive_and_cache_options_correctly(IConfigurationReader configReader,
                                                                                   IReadsEnvironmentVariables env,
                                                                                   [NoAutoProperties] WebDriverFactoryConfigurationSection config,
                                                                                   IDictionary <string, object> caps,
                                                                                   IGetsBrowserFlags flagsProvider,
                                                                                   string scenarioName)
        {
            // Arrange
            var envVars = new Dictionary <string, string>();

            Mock.Get(configReader)
            .Setup(x => x.ReadSection <WebDriverFactoryConfigurationSection>())
            .Returns(config);
            Mock.Get(env)
            .Setup(x => x.GetEnvironmentVariables())
            .Returns(envVars);

            envVars.Add("Env_AnotherDummyNumber", "20");
            envVars.Add("Env_DummyString", "Ohai");
            envVars.Add("Invalid_DummyNumber", "8");

            config.WebDriverFactoryAssemblyQualifiedType = typeof(DummyBrowserFactory).AssemblyQualifiedName;
            config.EnvironmentVariableSupportEnabled     = true;
            config.EnvironmentVariablePrefix             = "Env_";
            config.FactoryOptions.Add(new FactoryOption {
                Name = "DummyString", Value = "Should be overridden"
            });
            config.FactoryOptions.Add(new FactoryOption {
                Name = "DummyNumber", Value = "5"
            });

            var sut = new WebDriverFactorySource(configurationReader: configReader,
                                                 environmentReader: env);

            // Act
            var factory = sut.CreateFactoryFromConfig();
            var result  = GetProxiedFactory(factory);

            factory.CreateWebDriver(caps, flagsProvider, scenarioName);

            // Assert
            Assert.That(result.CapturedOptions.DummyString, Is.EqualTo("Ohai"));
            Assert.That(result.CapturedOptions.DummyNumber, Is.EqualTo(5));
            Assert.That(result.CapturedOptions.AnotherDummyNumber, Is.EqualTo(20));
        }
        public void CreateFactoryFromConfig_can_create_an_instance_of_a_dummy_factory(IConfigurationReader configReader,
                                                                                      IReadsEnvironmentVariables env,
                                                                                      [NoAutoProperties] WebDriverFactoryConfigurationSection config)
        {
            // Arrange
            var envVars = new Dictionary <string, string>();

            Mock.Get(configReader)
            .Setup(x => x.ReadSection <WebDriverFactoryConfigurationSection>())
            .Returns(config);
            Mock.Get(env)
            .Setup(x => x.GetEnvironmentVariables())
            .Returns(envVars);
            config.WebDriverFactoryAssemblyQualifiedType = typeof(DummyBrowserFactory).AssemblyQualifiedName;
            config.EnvironmentVariableSupportEnabled     = true;
            config.EnvironmentVariablePrefix             = "Env_";

            var sut = new WebDriverFactorySource(configurationReader: configReader,
                                                 environmentReader: env);

            // Act
            var factory = sut.CreateFactoryFromConfig();
            var result  = GetProxiedFactory(factory);

            // Assert
            Assert.That(result, Is.InstanceOf <DummyBrowserFactory>());
        }
        public void GetProviderOptions_gives_environment_values_precedence_over_base_results(IIndicatesEnvironmentSupport proxied,
                                                                                             [HasValues(0)] Dictionary <string, string> proxiedResult,
                                                                                             IReadsEnvironmentVariables environment)
        {
            // Arrange
            var sut = new EnvironmentVariableFactoryDescriptionProxy(proxied, environment);

            proxiedResult.Add("VariableName", "ValueFromBase");
            Mock.Get(proxied).Setup(x => x.GetOptionKeyValuePairs()).Returns(proxiedResult);
            Mock.Get(proxied).SetupGet(x => x.EnvironmentVariableSupportEnabled).Returns(true);
            Mock.Get(proxied).Setup(x => x.GetEnvironmentVariablePrefix()).Returns("E_");
            Mock.Get(environment)
            .Setup(x => x.GetEnvironmentVariables())
            .Returns(new Dictionary <string, string> {
                { "E_VariableName", "ValueFromEnvironment" }
            });
            var expected = new Dictionary <string, string> {
                { "VariableName", "ValueFromEnvironment" }
            };

            // Act
            var result = sut.GetOptionKeyValuePairs();

            // Assert
            Assert.That(result, Is.EquivalentTo(expected));
        }