/*
* Sample demonstrates how to use Azure App Configuration to save information about two(2) environments
* "beta" and "production".
* To do this, we will create Configuration Settings with the same key,
* but different labels: one for "beta" and one for "production".
*/
public async Task HelloWorldExtended()
{
// Retrieve the connection string from the configuration store.
// You can get the string from your Azure portal or using Azure CLI.
var connectionString = Environment.GetEnvironmentVariable("AZ_CONFIG_CONNECTION");
// Instantiate a client that will be used to call the service.
var client = new ConfigurationClient(connectionString);
// Create the Configuration Settings to be stored in the Configuration Store.
var betaEndpoint = new ConfigurationSetting("endpoint", "https://beta.endpoint.com", "beta");
var betaInstances = new ConfigurationSetting("instances", "1", "beta");
var productionEndpoint = new ConfigurationSetting("endpoint", "https://production.endpoint.com", "production");
var productionInstances = new ConfigurationSetting("instances", "1", "production");
// There are two(2) ways to store a Configuration Setting:
// -AddAsync creates a setting only if the setting does not already exist in the store.
// -SetAsync creates a setting if it doesn't exist or overrides an existing setting
await client.AddAsync(betaEndpoint);
await client.AddAsync(betaInstances);
await client.AddAsync(productionEndpoint);
await client.AddAsync(productionInstances);
// There is a need to increase the production instances from 1 to 5.
// The UpdateSync will help us with this.
ConfigurationSetting instancesToUpdate = await client.GetAsync(productionInstances.Key, productionInstances.Label);
instancesToUpdate.Value = "5";
await client.UpdateAsync(instancesToUpdate);
// We want to gather all the information available for the "production' environment.
// By calling GetBatchSync with the proper filter for label "production", we will get
// all the Configuration Settings that satisfy that condition.
var selector = new SettingSelector(null, "production");
SettingBatch batch = await client.GetBatchAsync(selector);
Debug.WriteLine("Settings for Production environmnet");
for (int i = 0; i < batch.Count; i++)
{
var value = batch[i];
Debug.WriteLine(batch[i]);
}
// Once we don't need the Configuration Setting, we can delete them.
await client.DeleteAsync(betaEndpoint.Key, betaEndpoint.Label);
await client.DeleteAsync(betaInstances.Key, betaInstances.Label);
await client.DeleteAsync(productionEndpoint.Key, productionEndpoint.Label);
await client.DeleteAsync(productionInstances.Key, productionInstances.Label);
}
public async Task GetBatchSettingWithReadOnly()
{
ConfigurationClient service = GetClient();
string key = GenerateKeyId("key-");
ConfigurationSetting setting = await service.AddAsync(key, "my_value", "my_label");
try
{
SettingSelector selector = new SettingSelector(key)
{
Fields = SettingFields.Key | SettingFields.ReadOnly
};
List <ConfigurationSetting> batch = await service.GetSettingsAsync(selector, CancellationToken.None).ToEnumerableAsync();
CollectionAssert.IsNotEmpty(batch);
Assert.IsNotNull(batch[0].Key);
Assert.IsNotNull(batch[0].ReadOnly);
Assert.IsNull(batch[0].Label);
Assert.IsNull(batch[0].Value);
Assert.IsNull(batch[0].ContentType);
Assert.IsNull(batch[0].LastModified);
Assert.AreEqual(batch[0].ETag, default(ETag));
}
finally
{
await service.DeleteAsync(setting.Key, setting.Label);
}
}
public async Task GetBatchSettingWithFields()
{
ConfigurationClient service = GetClient();
string key = GenerateKeyId("keyFields-");
ConfigurationSetting setting = await service.AddAsync(key, "my_value", "my_label");
try
{
SettingSelector selector = new SettingSelector(key)
{
Fields = SettingFields.Key | SettingFields.Label | SettingFields.ETag
};
SettingBatch batch = await service.GetBatchAsync(selector, CancellationToken.None);
int resultsReturned = batch.Count;
Assert.AreEqual(1, resultsReturned);
Assert.IsNotNull(batch[0].Key);
Assert.IsNotNull(batch[0].Label);
Assert.IsNotNull(batch[0].ETag);
Assert.IsNull(batch[0].Value);
Assert.IsNull(batch[0].ContentType);
Assert.IsNull(batch[0].LastModified);
Assert.IsNull(batch[0].Locked);
}
finally
{
await service.DeleteAsync(setting.Key, setting.Label);
}
}
private async Task <string> SetMultipleKeys(ConfigurationClient service, int expectedEvents)
{
string key = GenerateKeyId("key-");
/*
* The configuration store contains a KV with the Key
* that represents {expectedEvents} data points.
* If not set, create the {expectedEvents} data points and the "BatchKey"
*/
const string batchKey = "BatchKey";
try
{
var responseGet = await service.GetAsync(batchKey);
key = responseGet.Value.Value;
responseGet.Dispose();
}
catch
{
for (int i = 0; i < expectedEvents; i++)
{
await service.AddAsync(new ConfigurationSetting(key, "test_value", $"{i.ToString()}"));
}
await service.SetAsync(new ConfigurationSetting(batchKey, key));
}
return(key);
}
public async Task GetBatchSettingWithAllFields()
{
ConfigurationClient service = GetClient();
string key = GenerateKeyId("keyFields-");
ConfigurationSetting setting = await service.AddAsync(key, "my_value", "my_label");
try
{
SettingSelector selector = new SettingSelector(key)
{
Fields = SettingFields.All
};
Response <ConfigurationSetting>[] batch = (await service.GetSettingsAsync(selector, CancellationToken.None).ToEnumerableAsync())
.ToArray();
Assert.AreEqual(1, batch.Length);
Assert.IsNotNull(batch[0].Value.Key);
Assert.IsNotNull(batch[0].Value.Label);
Assert.IsNotNull(batch[0].Value.Value);
Assert.IsNotNull(batch[0].Value.ContentType);
Assert.IsNotNull(batch[0].Value.ETag);
Assert.IsNotNull(batch[0].Value.LastModified);
Assert.IsNotNull(batch[0].Value.Locked);
}
finally
{
await service.DeleteAsync(setting.Key, setting.Label);
}
}
public async Task GetIfChangedSettingUnmodified()
{
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
try
{
ConfigurationSetting setting = await service.AddAsync(testSetting);
// Test
Response <ConfigurationSetting> response = await service.GetAsync(setting, onlyIfChanged : true).ConfigureAwait(false);
Assert.AreEqual(304, response.GetRawResponse().Status);
bool throws = false;
try
{
ConfigurationSetting value = response.Value;
}
catch
{
throws = true;
}
Assert.IsTrue(throws);
}
finally
{
await service.DeleteAsync(testSetting.Key, testSetting.Label);
}
}
public async Task SetSettingReadOnly()
{
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
try
{
var setting = await service.AddAsync(testSetting);
var readOnly = await service.SetReadOnlyAsync(testSetting.Key, testSetting.Label);
testSetting.Value = "new_value";
// Test
RequestFailedException exception = Assert.ThrowsAsync <RequestFailedException>(async() =>
await service.SetAsync(testSetting.Key, "new_value", testSetting.Label));
Assert.AreEqual(409, exception.Status);
}
finally
{
await service.ClearReadOnlyAsync(testSetting.Key, testSetting.Label);
await service.DeleteAsync(testSetting.Key, testSetting.Label);
}
}
public async Task AddExistingSetting()
{
ConfigurationClient service = TestEnvironment.GetClient();
try
{
await service.AddAsync(s_testSetting);
var exception = Assert.ThrowsAsync <RequestFailedException>(async() =>
{
await service.AddAsync(s_testSetting);
});
Assert.AreEqual(412, exception.Status);
}
finally
{
await service.DeleteAsync(s_testSetting.Key, s_testSetting.Label);
}
}
public async Task AddExistingSetting()
{
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
try
{
await service.AddAsync(testSetting);
RequestFailedException exception = Assert.ThrowsAsync <RequestFailedException>(async() =>
{
await service.AddAsync(testSetting);
});
Assert.AreEqual(412, exception.Status);
}
finally
{
await service.DeleteAsync(testSetting.Key, testSetting.Label);
}
}
public async Task AddExistingSetting()
{
var connectionString = Environment.GetEnvironmentVariable("AZ_CONFIG_CONNECTION");
Assert.NotNull(connectionString, "Set AZ_CONFIG_CONNECTION environment variable to the connection string");
var service = new ConfigurationClient(connectionString);
try
{
await service.AddAsync(s_testSetting);
var exception = Assert.ThrowsAsync <RequestFailedException>(async() =>
{
await service.AddAsync(s_testSetting);
});
Assert.AreEqual(412, exception.Status);
}
finally
{
await service.DeleteAsync(s_testSetting.Key, s_testSetting.Label);
}
}
public async Task AddSetting()
{
ConfigurationClient service = TestEnvironment.GetClient();
try
{
ConfigurationSetting setting = await service.AddAsync(s_testSetting);
Assert.AreEqual(s_testSetting, setting);
}
finally
{
await service.DeleteAsync(s_testSetting.Key, s_testSetting.Label);
}
}
public async Task RequestHasApiVersionQuery()
{
var response = new MockResponse(200);
response.SetContent(SerializationHelpers.Serialize(s_testSetting, SerializeSetting));
var mockTransport = new MockTransport(response);
ConfigurationClient service = CreateTestService(mockTransport);
ConfigurationSetting setting = await service.AddAsync(s_testSetting);
MockRequest request = mockTransport.SingleRequest;
StringAssert.Contains("api-version", request.UriBuilder.Uri.ToString());
}
public async Task AddSetting()
{
string connectionString = GetEnvironment();
var service = new ConfigurationClient(connectionString);
try
{
ConfigurationSetting setting = await service.AddAsync(s_testSetting);
Assert.AreEqual(s_testSetting, setting);
}
finally
{
await service.DeleteAsync(s_testSetting.Key, s_testSetting.Label);
}
}
public async Task AddSetting()
{
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
try
{
ConfigurationSetting setting = await service.AddAsync(testSetting);
Assert.AreEqual(testSetting, setting);
}
finally
{
await service.DeleteAsync(testSetting.Key, testSetting.Label);
}
}
public async Task AddSetting()
{
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
try
{
ConfigurationSetting setting = await service.AddAsync(testSetting);
Assert.True(ConfigurationSettingEqualityComparer.Instance.Equals(testSetting, setting));
}
finally
{
await service.DeleteAsync(testSetting.Key, testSetting.Label);
}
}
public async Task AddSetting()
{
var connectionString = Environment.GetEnvironmentVariable("AZ_CONFIG_CONNECTION");
Assert.NotNull(connectionString, "Set AZ_CONFIG_CONNECTION environment variable to the connection string");
var service = new ConfigurationClient(connectionString);
try
{
ConfigurationSetting setting = await service.AddAsync(s_testSetting);
Assert.AreEqual(s_testSetting, setting);
}
finally
{
await service.DeleteAsync(s_testSetting.Key, s_testSetting.Label);
}
}
public async Task ClearReadOnlyFromSetting()
{
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
try
{
var setting = await service.AddAsync(testSetting);
var readOnly = await service.ClearReadOnlyAsync(testSetting.Key, testSetting.Label);
Assert.IsFalse(readOnly.Value.ReadOnly);
}
finally
{
await service.DeleteAsync(testSetting.Key, testSetting.Label);
}
}
public async Task AddSettingNoLabel()
{
ConfigurationClient service = TestEnvironment.GetClient();
var testSettingNoLabel = s_testSetting.Clone();
testSettingNoLabel.Label = null;
try
{
ConfigurationSetting setting = await service.AddAsync(testSettingNoLabel);
Assert.AreEqual(testSettingNoLabel, setting);
}
finally
{
await service.DeleteAsync(s_testSetting.Key);
}
}
public async Task AddKeyValue()
{
ConfigurationClient service = GetClient();
string key = GenerateKeyId("key-");
try
{
string value = "my_value";
ConfigurationSetting setting = await service.AddAsync(key, value);
Assert.AreEqual(key, setting.Key);
Assert.AreEqual(value, setting.Value);
}
finally
{
await service.DeleteAsync(key);
}
}
public async Task DeleteIfUnchangedSettingUnmodified()
{
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
try
{
ConfigurationSetting setting = await service.AddAsync(testSetting);
// Test
Response response = await service.DeleteAsync(setting, onlyIfUnchanged : true);
Assert.AreEqual(200, response.Status);
}
finally
{
await service.DeleteAsync(testSetting.Key, testSetting.Label);
}
}
public async Task AddKeyValue()
{
ConfigurationClient service = TestEnvironment.GetClient();
string key = string.Concat("key-", Guid.NewGuid().ToString("N"));
try
{
string value = "my_value";
ConfigurationSetting setting = await service.AddAsync(key, value);
Assert.AreEqual(key, setting.Key);
Assert.AreEqual(value, setting.Value);
}
finally
{
await service.DeleteAsync(key);
}
}
public async Task AuthorizationHeaderFormat()
{
var expectedSyntax = $"HMAC-SHA256 Credential={s_credential}&SignedHeaders=date;host;x-ms-content-sha256&Signature=(.+)";
var response = new MockResponse(200);
response.SetContent(SerializationHelpers.Serialize(s_testSetting, SerializeSetting));
var mockTransport = new MockTransport(response);
ConfigurationClient service = CreateTestService(mockTransport);
ConfigurationSetting setting = await service.AddAsync(s_testSetting);
MockRequest request = mockTransport.SingleRequest;
AssertRequestCommon(request);
Assert.True(request.Headers.TryGetValue("Authorization", out var authHeader));
Assert.True(Regex.IsMatch(authHeader, expectedSyntax));
}
public async Task SetReadOnlyOnSetting()
{
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
try
{
var setting = await service.AddAsync(testSetting);
var locked = await service.SetReadOnlyAsync(testSetting.Key, testSetting.Label);
Assert.IsTrue(locked.Value.Locked);
}
finally
{
await service.ClearReadOnlyAsync(testSetting.Key, testSetting.Label);
await service.DeleteAsync(testSetting.Key, testSetting.Label);
}
}
public async Task RequestHasSpecificApiVersion()
{
var response = new MockResponse(200);
response.SetContent(SerializationHelpers.Serialize(s_testSetting, SerializeSetting));
var mockTransport = new MockTransport(response);
var options = new ConfigurationClientOptions(ConfigurationClientOptions.ServiceVersion.V1_0);
options.Diagnostics.ApplicationId = "test_application";
options.Transport = mockTransport;
ConfigurationClient client = CreateClient <ConfigurationClient>(s_connectionString, options);
ConfigurationSetting setting = await client.AddAsync(s_testSetting);
MockRequest request = mockTransport.SingleRequest;
StringAssert.Contains("api-version=1.0", request.UriBuilder.Uri.ToString());
}
public async Task Add()
{
var response = new MockResponse(200);
response.SetContent(SerializationHelpers.Serialize(s_testSetting, SerializeSetting));
var mockTransport = new MockTransport(response);
ConfigurationClient service = CreateTestService(mockTransport);
ConfigurationSetting setting = await service.AddAsync(s_testSetting);
MockRequest request = mockTransport.SingleRequest;
AssertRequestCommon(request);
Assert.AreEqual(RequestMethod.Put, request.Method);
Assert.AreEqual($"https://contoso.appconfig.io/kv/test_key?label=test_label&api-version={s_version}", request.UriBuilder.ToString());
Assert.True(request.Headers.TryGetValue("If-None-Match", out var ifNoneMatch));
Assert.AreEqual("*", ifNoneMatch);
AssertContent(SerializationHelpers.Serialize(s_testSetting, SerializeRequestSetting), request);
Assert.AreEqual(s_testSetting, setting);
}
public async Task AddKeyValueLabel()
{
ConfigurationClient service = TestEnvironment.GetClient();
string key = GenerateKeyId("key-");
string value = "my_value";
string label = "my_label";
try
{
ConfigurationSetting setting = await service.AddAsync(key, value, label);
Assert.AreEqual(key, setting.Key);
Assert.AreEqual(value, setting.Value);
Assert.AreEqual(label, setting.Label);
}
finally
{
await service.DeleteAsync(key, label);
}
}
public async Task AddKeyValueLabel()
{
string connectionString = GetEnvironment();
var service = new ConfigurationClient(connectionString);
string key = string.Concat("key-", Guid.NewGuid().ToString("N"));
string value = "my_value";
string label = "my_label";
try
{
ConfigurationSetting setting = await service.AddAsync(key, value, label);
Assert.AreEqual(key, setting.Key);
Assert.AreEqual(value, setting.Value);
Assert.AreEqual(label, setting.Label);
}
finally
{
await service.DeleteAsync(key, label);
}
}
public async Task AddKeyValue()
{
var connectionString = Environment.GetEnvironmentVariable("AZ_CONFIG_CONNECTION");
Assert.NotNull(connectionString, "Set AZ_CONFIG_CONNECTION environment variable to the connection string");
var service = new ConfigurationClient(connectionString);
string key = string.Concat("key-", Guid.NewGuid().ToString("N"));
try
{
string value = "my_value";
ConfigurationSetting setting = await service.AddAsync(key, value);
Assert.AreEqual(key, setting.Key);
Assert.AreEqual(value, setting.Value);
}
finally
{
await service.DeleteAsync(key);
}
}
public async Task SetIfUnchangedSettingModified()
{
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
try
{
ConfigurationSetting setting = await service.AddAsync(testSetting);
ConfigurationSetting modifiedSetting = setting.Clone();
modifiedSetting.Value = "new_value";
modifiedSetting = await service.SetAsync(modifiedSetting);
// Test
RequestFailedException exception = Assert.ThrowsAsync <RequestFailedException>(async() =>
await service.SetAsync(setting, onlyIfUnchanged: true));
Assert.AreEqual(412, exception.Status);
}
finally
{
await service.DeleteAsync(testSetting.Key, testSetting.Label);
}
}
public async Task GetIfChangedSettingModified()
{
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
try
{
ConfigurationSetting setting = await service.AddAsync(testSetting);
ConfigurationSetting modifiedSetting = setting.Clone();
modifiedSetting.Value = "new_value";
modifiedSetting = await service.SetAsync(modifiedSetting);
Response <ConfigurationSetting> response = await service.GetAsync(setting, onlyIfChanged : true).ConfigureAwait(false);
Assert.AreEqual(200, response.GetRawResponse().Status);
Assert.True(ConfigurationSettingEqualityComparer.Instance.Equals(modifiedSetting, response.Value));
}
finally
{
await service.DeleteAsync(testSetting.Key, testSetting.Label);
}
}
