public ConnectionStringInitializerTests()
 {
     Environment.SetEnvironmentVariable("VCAP_SERVICES", VcapServices);
     _webConfigWriter = Substitute.For <IWebConfigWriter>();
     _config          = new ConfigurationBuilder()
                        .AddEnvironmentVariables()
                        .AddCloudFoundry()
                        .Build();
 }
        private static void CopyBoundSqlConnection(
            IWebConfigWriter webConfig,
            SqlServerServiceInfo sqlServiceInfo,
            SqlServerProviderConnectorOptions sqlConnectorOptions)
        {
            SqlServerProviderConnectorFactory sqlConnectorFactory = new SqlServerProviderConnectorFactory(
                sqlServiceInfo, sqlConnectorOptions, typeof(SqlConnection));

            webConfig.SetConnectionString(sqlServiceInfo.Id, sqlConnectorFactory.CreateConnectionString());
        }
        public void CopyBoundSqlInstancesToWebConfig(IWebConfigWriter webConfig)
        {
            if (webConfig == null)
            {
                throw new ArgumentNullException(nameof(webConfig), "The web config writer is required");
            }

            SqlServerProviderConnectorOptions sqlConnectorOptions = new SqlServerProviderConnectorOptions(_config);

            foreach (SqlServerServiceInfo sqlServiceInfo in _config.GetServiceInfos <SqlServerServiceInfo>())
            {
                CopyBoundSqlConnection(webConfig, sqlServiceInfo, sqlConnectorOptions);
            }
        }
示例#4
0
        public void CopyConfigToAppSettings(IWebConfigWriter webConfigWriter)
        {
            if (webConfigWriter == null)
            {
                throw new ArgumentNullException(nameof(webConfigWriter), "The web config writer is required");
            }

            foreach (KeyValuePair <string, string> pair in _webConfigReader.GetAppSettings())
            {
                var updatedValue = _config.GetValue <string>(pair.Key);
                if (updatedValue != null)
                {
                    webConfigWriter.SetAppSetting(pair.Key, updatedValue);
                }
            }
        }
        public void CopyExternalTokens(IWebConfigWriter webConfigWriter)
        {
            if (webConfigWriter == null)
            {
                throw new ArgumentNullException(nameof(webConfigWriter), "WebConfig writer is required");
            }

            webConfigWriter.InitializeWebConfigForTokenReplacements();

            foreach (var configEntry in _config.AsEnumerable())
            {
                webConfigWriter.ReplaceToken(configEntry.Key, configEntry.Value);
            }

            webConfigWriter.FinalizeWebConfigTokenReplacements();
        }
        public void CopyExternalConnectionStrings(IWebConfigWriter webConfigWriter)
        {
            if (webConfigWriter == null)
            {
                throw new ArgumentNullException(nameof(webConfigWriter), "WebConfig writer is required");
            }

            foreach (var connectionString in _webConfigReader.GetConnectionStrings())
            {
                var value = _config[$"connectionStrings:{connectionString.Key}"];

                if (!string.IsNullOrEmpty(value))
                {
                    webConfigWriter.SetConnectionString(connectionString.Key, value);
                }
            }
        }
        public void SetCustomErrorsMode(IWebConfigWriter webConfigWriter)
        {
            if (webConfigWriter == null)
            {
                throw new ArgumentNullException(nameof(webConfigWriter), "The web config writer is required");
            }

            var customErrorModeString = _config.GetValue <string>(CustomErrorsModeEnvVarName);

            if (!string.IsNullOrWhiteSpace(customErrorModeString))
            {
                CustomErrorsMode customErrorsMode;
                if (Enum.TryParse(customErrorModeString, true, out customErrorsMode))
                {
                    webConfigWriter.SetCustomErrorsMode(customErrorsMode);
                }
            }
        }
示例#8
0
        public AppSettingsInitializerTests()
        {
            _webConfigWriter = Substitute.For <IWebConfigWriter>();
            _webConfigReader = Substitute.For <IWebConfigReader>();

            var existingAppSettings = new List <KeyValuePair <string, string> >
            {
                new KeyValuePair <string, string>("app_setting_1", "old_value1"),
                new KeyValuePair <string, string>("app_setting_2", "old_value2")
            };

            _webConfigReader.GetAppSettings().Returns(existingAppSettings.AsReadOnly());

            _config = new ConfigurationBuilder().AddInMemoryCollection(new Dictionary <string, string>
            {
                { "app_setting_2", "new_value_2" },
                { "app_setting_3", "new_value_3" }
            }).Build();
        }
        public void ApplyXmlTransformation(string buildPath, IEnvironmentWrapper environmentWrapper, IWebConfigWriter webConfigWriter)
        {
            if (webConfigWriter == null)
            {
                throw new ArgumentNullException(nameof(webConfigWriter), "WebConfig writer is required");
            }

            var transformationKey = environmentWrapper.GetEnvironmentVariable(Constants.XML_TRANSFORM_KEY_NM) ?? "Release";

            var transformFilePath = Path.Combine(buildPath, $"web.{transformationKey}.config");

            if (File.Exists(transformFilePath))
            {
                webConfigWriter.ExecuteXmlTransformation(transformFilePath);
            }
        }