public async Task VerifyCancelCertificateOperation()
{
// Log details why this fails often for live tests on net461.
using AzureEventSourceListener listener = AzureEventSourceListener.CreateConsoleLogger(EventLevel.Verbose);
string certName = Recording.GenerateId();
CertificatePolicy certificatePolicy = DefaultPolicy;
CertificateOperation operation = await Client.StartCreateCertificateAsync(certName, certificatePolicy);
RegisterForCleanup(certName);
try
{
await operation.CancelAsync();
}
catch (RequestFailedException e) when(e.Status == 403)
{
Assert.Inconclusive("The create operation completed before it could be canceled.");
}
OperationCanceledException ex = Assert.ThrowsAsync <OperationCanceledException>(() => WaitForCompletion(operation));
Assert.AreEqual("The operation was canceled so no value is available.", ex.Message);
Assert.IsTrue(operation.HasCompleted);
Assert.IsFalse(operation.HasValue);
Assert.AreEqual(200, operation.GetRawResponse().Status);
}
public async Task VerifyUnexpectedDeleteCertificateOperation()
{
string certName = Recording.GenerateId();
CertificatePolicy certificatePolicy = DefaultPolicy;
certificatePolicy.IssuerName = WellKnownIssuerNames.Unknown;
CertificateOperation operation = await Client.StartCreateCertificateAsync(certName, certificatePolicy);
RegisterForCleanup(certName);
try
{
// Calling through the CertificateClient directly won't affect the CertificateOperation, so subsequent status updates should throw.
await Client.DeleteCertificateOperationAsync(certName);
}
catch (RequestFailedException e) when(e.Status == 403)
{
Assert.Inconclusive("The create operation completed before it could be canceled.");
}
InvalidOperationException ex = Assert.ThrowsAsync <InvalidOperationException>(
async() => await operation.WaitForCompletionAsync(DefaultCertificateOperationPollingInterval, default));
Assert.AreEqual("The operation was deleted so no value is available.", ex.Message);
Assert.IsTrue(operation.HasCompleted);
Assert.IsFalse(operation.HasValue);
Assert.AreEqual(404, operation.GetRawResponse().Status);
}
public async Task VerifyUnexpectedCancelCertificateOperation()
{
string certName = Recording.GenerateId();
CertificatePolicy certificatePolicy = DefaultPolicy;
CertificateOperation operation = await Client.StartCreateCertificateAsync(certName, certificatePolicy);
RegisterForCleanup(certName);
try
{
// Calling through the CertificateClient directly won't affect the CertificateOperation, so subsequent status updates should throw.
await Client.CancelCertificateOperationAsync(certName);
}
catch (RequestFailedException e) when(e.Status == 403)
{
Assert.Inconclusive("The create operation completed before it could be canceled.");
}
OperationCanceledException ex = Assert.ThrowsAsync <OperationCanceledException>(
async() => await WaitForCompletion(operation),
$"Expected exception {nameof(OperationCanceledException)} not thrown. Operation status: {operation?.Properties?.Status}, error: {operation?.Properties?.Error?.Message}");
Assert.AreEqual("The operation was canceled so no value is available.", ex.Message);
Assert.IsTrue(operation.HasCompleted);
Assert.IsFalse(operation.HasValue);
Assert.AreEqual(200, operation.GetRawResponse().Status);
}
public async Task VerifyCertificateOperationError()
{
string issuerName = Recording.GenerateId();
string certName = Recording.GenerateId();
CertificateIssuer certIssuer = new CertificateIssuer(issuerName, "DigiCert")
{
AccountId = "test",
Password = "******",
OrganizationId = "test",
};
await Client.CreateIssuerAsync(certIssuer);
CertificateOperation operation = null;
try
{
CertificatePolicy certificatePolicy = DefaultPolicy;
certificatePolicy.IssuerName = issuerName;
operation = await Client.StartCreateCertificateAsync(certName, certificatePolicy);
operation = InstrumentOperation(operation);
RegisterForCleanup(certName);
using CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromMinutes(2));
TimeSpan pollingInterval = Mode == RecordedTestMode.Playback ? TimeSpan.Zero : KeyVaultTestEnvironment.DefaultPollingInterval;
while (!operation.HasCompleted)
{
await Task.Delay(pollingInterval, cts.Token);
await operation.UpdateStatusAsync(cts.Token);
}
InvalidOperationException ex = Assert.Throws <InvalidOperationException>(() => { KeyVaultCertificateWithPolicy cert = operation.Value; });
StringAssert.StartsWith("The certificate operation failed: ", ex.Message);
Assert.IsTrue(operation.HasCompleted);
Assert.IsFalse(operation.HasValue);
Assert.AreEqual(200, operation.GetRawResponse().Status);
Assert.AreEqual("failed", operation.Properties.Status);
}
catch (TaskCanceledException) when(operation != null)
{
Assert.Inconclusive("Timed out while waiting for operation {0}", operation.Id);
}
finally
{
await Client.DeleteIssuerAsync(issuerName);
}
}
public async Task VerifyUnexpectedCancelCertificateOperation()
{
string certName = Recording.GenerateId();
CertificatePolicy certificatePolicy = DefaultPolicy;
CertificateOperation operation = await Client.StartCreateCertificateAsync(certName, certificatePolicy);
RegisterForCleanup(certName);
OperationCanceledException ex = null;
try
{
// Calling through the CertificateClient directly won't affect the CertificateOperation, so subsequent status updates should throw.
await Client.CancelCertificateOperationAsync(certName);
await operation.WaitForCompletionAsync(DefaultCertificateOperationPollingInterval, default);
}
catch (OperationCanceledException e)
{
ex = e;
}
catch (RequestFailedException e) when(e.Status == 403)
{
Assert.Inconclusive("The create operation completed before it could be canceled.");
}
catch (RequestFailedException e) when(e.Status == 409)
{
Assert.Inconclusive("There was a service timing issue when attempting to cancel the operation.");
}
if (operation.HasCompleted && !operation.Properties.CancellationRequested)
{
Assert.Inconclusive("The create operation completed before it could be canceled.");
}
Assert.AreEqual("The operation was canceled so no value is available.", ex?.Message);
Assert.IsTrue(operation.HasCompleted);
Assert.IsFalse(operation.HasValue);
Assert.AreEqual(200, operation.GetRawResponse().Status);
}
public async Task VerifyCancelCertificateOperation()
{
string certName = Recording.GenerateId();
CertificatePolicy certificatePolicy = DefaultPolicy;
CertificateOperation operation = await Client.StartCreateCertificateAsync(certName, certificatePolicy);
RegisterForCleanup(certName);
// Give the service time to process the start request.
await DelayAsync(TimeSpan.FromSeconds(2));
OperationCanceledException ex = null;
try
{
await operation.CancelAsync();
await operation.WaitForCompletionAsync(DefaultCertificateOperationPollingInterval, default);
}
catch (OperationCanceledException e)
{
ex = e;
}
catch (RequestFailedException e) when(e.Status == 403)
{
Assert.Inconclusive("The create operation completed before it could be canceled.");
}
if (operation.HasCompleted && !operation.Properties.CancellationRequested)
{
Assert.Inconclusive("The create operation completed before it could be canceled.");
}
Assert.AreEqual("The operation was canceled so no value is available.", ex?.Message);
Assert.IsTrue(operation.HasCompleted);
Assert.IsFalse(operation.HasValue);
Assert.AreEqual(200, operation.GetRawResponse().Status);
}
public async Task VerifyDeleteCertificateOperation()
{
string certName = Recording.GenerateId();
CertificatePolicy certificatePolicy = DefaultPolicy;
certificatePolicy.IssuerName = WellKnownIssuerNames.Unknown;
CertificateOperation operation = await Client.StartCreateCertificateAsync(certName, certificatePolicy);
RegisterForCleanup(certName);
await operation.DeleteAsync();
InvalidOperationException ex = Assert.ThrowsAsync <InvalidOperationException>(() => WaitForCompletion(operation));
Assert.AreEqual("The operation was deleted so no value is available.", ex.Message);
Assert.IsTrue(operation.HasCompleted);
Assert.IsFalse(operation.HasValue);
Assert.AreEqual(404, operation.GetRawResponse().Status);
}