/// <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();
        }
コード例 #2
0
        IDescribesWebDriverFactory GetDescriptionWithEnvironmentSupportIfApplicable(IDescribesWebDriverFactory description)
        {
            if (description == null)
            {
                return(null);
            }

            if (description is IIndicatesEnvironmentSupport)
            {
                var envSupport = (IIndicatesEnvironmentSupport)description;
                if (envSupport.EnvironmentVariableSupportEnabled)
                {
                    return(new EnvironmentVariableFactoryDescriptionProxy(description, environmentReader));
                }
            }

            return(description);
        }
コード例 #3
0
        /// <summary>
        /// Gets a web driver factory matching the given description.
        /// </summary>
        /// <returns>The web driver factory.</returns>
        /// <param name="description">An object which describes a web driver factory.</param>
        public virtual ICreatesWebDriver CreateFactory(IDescribesWebDriverFactory description)
        {
            if (description == null)
            {
                return(null);
            }

            var factory = factoryCreator.GetFactory(description.GetFactoryAssemblyQualifiedTypeName());

            if (factory == null)
            {
                return(null);
            }

            var options = optionsCreator.GetFactoryOptions(factory, description.GetOptionKeyValuePairs());

            return(GetFactory(factory, options));
        }
コード例 #4
0
        public void GetWebDriverProviderFactory_returns_proxy_when_factory_supports_options(ICreatesWebDriverFactory factoryCreator,
                                                                                            ICreatesFactoryOptions optionsCreator,
                                                                                            IDescribesWebDriverFactory config,
                                                                                            ICreatesWebDriverFromOptions factory,
                                                                                            object options,
                                                                                            string typeName,
                                                                                            Dictionary <string, string> optionsDictionary)
        {
            // Arrange
            var sut = new WebDriverFactorySource(factoryCreator, optionsCreator);

            Mock.Get(config)
            .Setup(x => x.GetFactoryAssemblyQualifiedTypeName())
            .Returns(typeName);
            Mock.Get(config)
            .Setup(x => x.GetOptionKeyValuePairs())
            .Returns(optionsDictionary);
            Mock.Get(factoryCreator)
            .Setup(x => x.GetFactory(It.IsAny <string>()))
            .Returns(factory);
            Mock.Get(optionsCreator)
            .Setup(x => x.GetFactoryOptions(factory, It.IsAny <IDictionary <string, string> >()))
            .Returns(options);

            // Act
            var result = sut.CreateFactory(config);

            // Assert
            Assert.That(result, Is.InstanceOf <OptionsCachingDriverFactoryProxy>());
            var proxy = (OptionsCachingDriverFactoryProxy)result;

            Assert.That(proxy.ProxiedFactory, Is.SameAs(factory));
        }
コード例 #5
0
        public void GetWebDriverProviderFactory_returns_factory_creator_result_when_factory_does_not_support_options(ICreatesWebDriverFactory factoryCreator,
                                                                                                                     ICreatesFactoryOptions optionsCreator,
                                                                                                                     IDescribesWebDriverFactory config,
                                                                                                                     ICreatesWebDriver factory,
                                                                                                                     string typeName,
                                                                                                                     Dictionary <string, string> optionsDictionary)
        {
            // Arrange
            var sut = new WebDriverFactorySource(factoryCreator, optionsCreator);

            Mock.Get(config)
            .Setup(x => x.GetFactoryAssemblyQualifiedTypeName())
            .Returns(typeName);
            Mock.Get(config)
            .Setup(x => x.GetOptionKeyValuePairs())
            .Returns(optionsDictionary);
            Mock.Get(factoryCreator)
            .Setup(x => x.GetFactory(It.IsAny <string>()))
            .Returns(factory);

            // Act
            var result = sut.CreateFactory(config);

            // Assert
            Assert.That(result, Is.SameAs(factory));
        }
コード例 #6
0
        public void GetWebDriverProviderFactory_passes_assembly_name_to_factory_creator(ICreatesWebDriverFactory factoryCreator,
                                                                                        ICreatesFactoryOptions optionsCreator,
                                                                                        IDescribesWebDriverFactory config,
                                                                                        string typeName,
                                                                                        Dictionary <string, string> optionsDictionary)
        {
            // Arrange
            var sut = new WebDriverFactorySource(factoryCreator, optionsCreator);

            Mock.Get(config)
            .Setup(x => x.GetFactoryAssemblyQualifiedTypeName())
            .Returns(typeName);
            Mock.Get(config)
            .Setup(x => x.GetOptionKeyValuePairs())
            .Returns(optionsDictionary);

            // Act
            var result = sut.CreateFactory(config);

            // Assert
            Mock.Get(factoryCreator).Verify(x => x.GetFactory(typeName), Times.Once);
        }
 /// <summary>
 /// Initializes a new instance of the
 /// <see cref="EnvironmentVariableFactoryDescriptionProxy"/> class.
 /// </summary>
 /// <param name="proxied">The web driver factory description to proxy.</param>
 public EnvironmentVariableFactoryDescriptionProxy(IDescribesWebDriverFactory proxied)
     : this(proxied, null)
 {
 }
        public void GetProviderOptions_returns_same_result_as_proxied_when_environment_cannot_be_supported(IDescribesWebDriverFactory proxied,
                                                                                                           [HasValues] Dictionary <string, string> proxiedResult)
        {
            // Arrange
            var sut = new EnvironmentVariableFactoryDescriptionProxy(proxied);

            Mock.Get(proxied).Setup(x => x.GetOptionKeyValuePairs()).Returns(proxiedResult);

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

            // Assert
            Assert.That(result, Is.EquivalentTo(proxiedResult));
        }
        public void GetFactoryAssemblyQualifiedTypeName_returns_result_from_proxied_type(IDescribesWebDriverFactory proxied,
                                                                                         string baseResult)
        {
            // Arrange
            var sut = new EnvironmentVariableFactoryDescriptionProxy(proxied);

            Mock.Get(proxied).Setup(x => x.GetFactoryAssemblyQualifiedTypeName()).Returns(baseResult);

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

            // Assert
            Assert.That(result, Is.EqualTo(baseResult));
        }