protected WaitUnit[] GetWaitUnits(WaitUntil until)
{
switch (until)
{
case WaitUntil.Missing:
return new[]
{
CreateAbsenceUnit(ElementVisibility.Any)
};
case WaitUntil.Hidden:
return new[]
{
CreatePresenceUnit(ElementVisibility.Invisible)
};
case WaitUntil.MissingOrHidden:
return new[]
{
CreateAbsenceUnit(ElementVisibility.Visible)
};
case WaitUntil.Visible:
return new[]
{
CreatePresenceUnit(ElementVisibility.Visible)
};
case WaitUntil.Exists:
return new[]
{
CreatePresenceUnit(ElementVisibility.Any)
};
case WaitUntil.VisibleAndHidden:
return new[]
{
CreatePresenceUnit(ElementVisibility.Visible),
CreatePresenceUnit(ElementVisibility.Invisible)
};
case WaitUntil.VisibleAndMissing:
return new[]
{
CreatePresenceUnit(ElementVisibility.Visible),
CreateAbsenceUnit(ElementVisibility.Any)
};
case WaitUntil.MissingAndVisible:
return new[]
{
CreateAbsenceUnit(ElementVisibility.Any),
CreatePresenceUnit(ElementVisibility.Visible)
};
case WaitUntil.HiddenAndVisible:
return new[]
{
CreatePresenceUnit(ElementVisibility.Invisible),
CreatePresenceUnit(ElementVisibility.Visible)
};
default:
throw ExceptionFactory.CreateForUnsupportedEnumValue(until, nameof(until));
}
}
public virtual ArmOperation <PrivateEndpointConnectionResource> CreateOrUpdate(WaitUntil waitUntil, string privateEndpointConnectionName, PrivateEndpointConnectionData data, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(privateEndpointConnectionName, nameof(privateEndpointConnectionName));
Argument.AssertNotNull(data, nameof(data));
using var scope = _privateEndpointConnectionClientDiagnostics.CreateScope("PrivateEndpointConnectionCollection.CreateOrUpdate");
scope.Start();
try
{
var response = _privateEndpointConnectionRestClient.CreateOrUpdate(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, privateEndpointConnectionName, data, cancellationToken);
var operation = new MonitorArmOperation <PrivateEndpointConnectionResource>(new PrivateEndpointConnectionOperationSource(Client), _privateEndpointConnectionClientDiagnostics, Pipeline, _privateEndpointConnectionRestClient.CreateCreateOrUpdateRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, privateEndpointConnectionName, data).Request, response, OperationFinalStateVia.Location);
if (waitUntil == WaitUntil.Completed)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <ArmOperation <StaticSiteARMResource> > CreateOrUpdateAsync(WaitUntil waitUntil, string name, StaticSiteARMResourceData data, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(name, nameof(name));
Argument.AssertNotNull(data, nameof(data));
using var scope = _staticSiteARMResourceStaticSitesClientDiagnostics.CreateScope("StaticSiteARMResourceCollection.CreateOrUpdate");
scope.Start();
try
{
var response = await _staticSiteARMResourceStaticSitesRestClient.CreateOrUpdateStaticSiteAsync(Id.SubscriptionId, Id.ResourceGroupName, name, data, cancellationToken).ConfigureAwait(false);
var operation = new AppServiceArmOperation <StaticSiteARMResource>(new StaticSiteARMResourceOperationSource(Client), _staticSiteARMResourceStaticSitesClientDiagnostics, Pipeline, _staticSiteARMResourceStaticSitesRestClient.CreateCreateOrUpdateStaticSiteRequest(Id.SubscriptionId, Id.ResourceGroupName, name, data).Request, response, OperationFinalStateVia.Location);
if (waitUntil == WaitUntil.Completed)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <ArmOperation <DatabaseAccountGremlinDatabaseGraphThroughputSettingResource> > CreateOrUpdateAsync(WaitUntil waitUntil, ThroughputSettingsUpdateData data, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(data, nameof(data));
using var scope = _databaseAccountGremlinDatabaseGraphThroughputSettingGremlinResourcesClientDiagnostics.CreateScope("DatabaseAccountGremlinDatabaseGraphThroughputSettingResource.CreateOrUpdate");
scope.Start();
try
{
var response = await _databaseAccountGremlinDatabaseGraphThroughputSettingGremlinResourcesRestClient.UpdateGremlinGraphThroughputAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Parent.Parent.Name, Id.Parent.Parent.Name, Id.Parent.Name, data, cancellationToken).ConfigureAwait(false);
var operation = new CosmosDBArmOperation <DatabaseAccountGremlinDatabaseGraphThroughputSettingResource>(new DatabaseAccountGremlinDatabaseGraphThroughputSettingOperationSource(Client), _databaseAccountGremlinDatabaseGraphThroughputSettingGremlinResourcesClientDiagnostics, Pipeline, _databaseAccountGremlinDatabaseGraphThroughputSettingGremlinResourcesRestClient.CreateUpdateGremlinGraphThroughputRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Parent.Parent.Name, Id.Parent.Parent.Name, Id.Parent.Name, data).Request, response, OperationFinalStateVia.Location);
if (waitUntil == WaitUntil.Completed)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual ArmOperation <ScmSiteBasicPublishingCredentialsPolicyResource> CreateOrUpdate(WaitUntil waitUntil, CsmPublishingCredentialsPoliciesEntityData data, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(data, nameof(data));
using var scope = _scmSiteBasicPublishingCredentialsPolicyWebAppsClientDiagnostics.CreateScope("ScmSiteBasicPublishingCredentialsPolicyResource.CreateOrUpdate");
scope.Start();
try
{
var response = _scmSiteBasicPublishingCredentialsPolicyWebAppsRestClient.UpdateScmAllowed(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, data, cancellationToken);
var operation = new AppServiceArmOperation <ScmSiteBasicPublishingCredentialsPolicyResource>(Response.FromValue(new ScmSiteBasicPublishingCredentialsPolicyResource(Client, response), response.GetRawResponse()));
if (waitUntil == WaitUntil.Completed)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <ArmOperation> CreateZipDeploymentForStaticSiteBuildAsync(WaitUntil waitUntil, StaticSiteZipDeploymentARMResource staticSiteZipDeploymentEnvelope, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(staticSiteZipDeploymentEnvelope, nameof(staticSiteZipDeploymentEnvelope));
using var scope = _staticSiteBuildARMResourceStaticSitesClientDiagnostics.CreateScope("StaticSiteBuildARMResource.CreateZipDeploymentForStaticSiteBuild");
scope.Start();
try
{
var response = await _staticSiteBuildARMResourceStaticSitesRestClient.CreateZipDeploymentForStaticSiteBuildAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name, staticSiteZipDeploymentEnvelope, cancellationToken).ConfigureAwait(false);
var operation = new AppServiceArmOperation(_staticSiteBuildARMResourceStaticSitesClientDiagnostics, Pipeline, _staticSiteBuildARMResourceStaticSitesRestClient.CreateCreateZipDeploymentForStaticSiteBuildRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name, staticSiteZipDeploymentEnvelope).Request, response, OperationFinalStateVia.Location);
if (waitUntil == WaitUntil.Completed)
{
await operation.WaitForCompletionResponseAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <ArmOperation <DomainOwnershipIdentifierResource> > CreateOrUpdateAsync(WaitUntil waitUntil, string name, DomainOwnershipIdentifierData data, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(name, nameof(name));
Argument.AssertNotNull(data, nameof(data));
using var scope = _domainOwnershipIdentifierDomainsClientDiagnostics.CreateScope("DomainOwnershipIdentifierCollection.CreateOrUpdate");
scope.Start();
try
{
var response = await _domainOwnershipIdentifierDomainsRestClient.CreateOrUpdateOwnershipIdentifierAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, name, data, cancellationToken).ConfigureAwait(false);
var operation = new AppServiceArmOperation <DomainOwnershipIdentifierResource>(Response.FromValue(new DomainOwnershipIdentifierResource(Client, response), response.GetRawResponse()));
if (waitUntil == WaitUntil.Completed)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <ArmOperation <BlobInventoryPolicyResource> > UpdateAsync(WaitUntil waitUntil, BlobInventoryPolicyData data, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(data, nameof(data));
using var scope = _blobInventoryPolicyClientDiagnostics.CreateScope("BlobInventoryPolicyResource.Update");
scope.Start();
try
{
var response = await _blobInventoryPolicyRestClient.CreateOrUpdateAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name, data, cancellationToken).ConfigureAwait(false);
var operation = new StorageArmOperation <BlobInventoryPolicyResource>(Response.FromValue(new BlobInventoryPolicyResource(Client, response), response.GetRawResponse()));
if (waitUntil == WaitUntil.Completed)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <ArmOperation <LogSearchRuleResource> > CreateOrUpdateAsync(WaitUntil waitUntil, string ruleName, LogSearchRuleData data, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(ruleName, nameof(ruleName));
Argument.AssertNotNull(data, nameof(data));
using var scope = _logSearchRuleScheduledQueryRulesClientDiagnostics.CreateScope("LogSearchRuleCollection.CreateOrUpdate");
scope.Start();
try
{
var response = await _logSearchRuleScheduledQueryRulesRestClient.CreateOrUpdateAsync(Id.SubscriptionId, Id.ResourceGroupName, ruleName, data, cancellationToken).ConfigureAwait(false);
var operation = new MonitorArmOperation <LogSearchRuleResource>(Response.FromValue(new LogSearchRuleResource(Client, response), response.GetRawResponse()));
if (waitUntil == WaitUntil.Completed)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual ArmOperation <ManagedInstanceDatabaseVulnerabilityAssessmentRuleBaselineResource> Update(WaitUntil waitUntil, DatabaseVulnerabilityAssessmentRuleBaselineData data, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(data, nameof(data));
using var scope = _managedInstanceDatabaseVulnerabilityAssessmentRuleBaselineManagedDatabaseVulnerabilityAssessmentRuleBaselinesClientDiagnostics.CreateScope("ManagedInstanceDatabaseVulnerabilityAssessmentRuleBaselineResource.Update");
scope.Start();
try
{
var response = _managedInstanceDatabaseVulnerabilityAssessmentRuleBaselineManagedDatabaseVulnerabilityAssessmentRuleBaselinesRestClient.CreateOrUpdate(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Parent.Parent.Parent.Name, Id.Parent.Parent.Parent.Name, Id.Parent.Parent.Name, Id.Parent.Name, Id.Name.ToVulnerabilityAssessmentPolicyBaselineName(), data, cancellationToken);
var operation = new SqlArmOperation <ManagedInstanceDatabaseVulnerabilityAssessmentRuleBaselineResource>(Response.FromValue(new ManagedInstanceDatabaseVulnerabilityAssessmentRuleBaselineResource(Client, response), response.GetRawResponse()));
if (waitUntil == WaitUntil.Completed)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public void SetCommandLineArgsViaResart(TestLanguage language)
{
OpenSolutionWithName(language, "ReadCmdArgsProject");
LoadExtension();
switch (language)
{
case TestLanguage.CSharpDotNetFW:
Assert.True(SetBreakpoint("Program.cs", 14));
break;
case TestLanguage.CSharpDotNetCore:
Assert.True(SetBreakpoint("Program.cs", 10));
break;
case TestLanguage.CPP:
Assert.True(SetBreakpoint("Project1.cpp", 10));
break;
case TestLanguage.VBDotNetFW:
Assert.True(SetBreakpoint("Module1.vb", 3));
break;
case TestLanguage.NodeJS:
Assert.True(SetBreakpoint("app.ts", 9));
break;
case TestLanguage.FSharpDotNetFW:
Assert.True(SetBreakpoint("Program.fs", 6));
break;
default:
throw new ArgumentOutOfRangeException(nameof(language), language, null);
}
bool SetBreakpoint(string fileName, int line, int column = 1)
{
ProjectItem codeFile = Dte.Solution.FindProjectItem(fileName);
if (codeFile == null)
{
return(false);
}
Dte.Debugger.Breakpoints.Add("", codeFile.FileNames[0], line, column);
return(true);
}
using (var waiter = new WaitUntil())
{
Dte.Events.DebuggerEvents.OnEnterBreakMode +=
(dbgEventReason reason, ref dbgExecutionAction action) => waiter.Finish();
Dte.Debugger.Go();
}
var args = new List <(string Arg, bool Enabled)>
{
("Arg1", true),
("Arg42", false),
("Arg2", true),
};
var curList = ExtensionPackage.ToolWindowViewModel.CurrentArgumentList;
InvokeInUIThread(() =>
{
foreach (var arg in args)
{
curList.AddNewItem(arg.Arg, arg.Enabled);
}
});
Dte.Debugger.Breakpoints.Item(1).Enabled = false;
using (var waiter = new WaitUntil())
{
int dbgDesignEnters = 0;
Dte.Events.DebuggerEvents.OnEnterDesignMode += reason =>
{
dbgDesignEnters++;
if (dbgDesignEnters == 2)
{
waiter.Finish();
}
};
Dte.ExecuteCommand("Debug.Restart");
}
Assert.That(File.Exists("ReadCmdArgsProject/CmdLineArgs.txt"), Is.True);
var cmdArgsFile = File.ReadAllText("ReadCmdArgsProject/CmdLineArgs.txt");
var cmdArgsTest = string.Join(" ", args.Where(arg => arg.Enabled).Select(arg => arg.Arg));
Assert.That(cmdArgsFile, Is.EqualTo(cmdArgsTest));
}
public virtual async Task <ArmOperation <ExpressRouteGatewayResource> > UpdateAsync(WaitUntil waitUntil, TagsObject expressRouteGatewayParameters, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(expressRouteGatewayParameters, nameof(expressRouteGatewayParameters));
using var scope = _expressRouteGatewayClientDiagnostics.CreateScope("ExpressRouteGatewayResource.Update");
scope.Start();
try
{
var response = await _expressRouteGatewayRestClient.UpdateTagsAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, expressRouteGatewayParameters, cancellationToken).ConfigureAwait(false);
var operation = new NetworkArmOperation <ExpressRouteGatewayResource>(new ExpressRouteGatewayOperationSource(Client), _expressRouteGatewayClientDiagnostics, Pipeline, _expressRouteGatewayRestClient.CreateUpdateTagsRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, expressRouteGatewayParameters).Request, response, OperationFinalStateVia.AzureAsyncOperation);
if (waitUntil == WaitUntil.Completed)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <ArmOperation <DatabaseAccountMongodbDatabaseThroughputSettingResource> > MigrateMongoDBDatabaseToManualThroughputAsync(WaitUntil waitUntil, CancellationToken cancellationToken = default)
{
using var scope = _databaseAccountMongodbDatabaseThroughputSettingMongoDBResourcesClientDiagnostics.CreateScope("DatabaseAccountMongodbDatabaseThroughputSettingResource.MigrateMongoDBDatabaseToManualThroughput");
scope.Start();
try
{
var response = await _databaseAccountMongodbDatabaseThroughputSettingMongoDBResourcesRestClient.MigrateMongoDBDatabaseToManualThroughputAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Parent.Name, Id.Parent.Name, cancellationToken).ConfigureAwait(false);
var operation = new CosmosDBArmOperation <DatabaseAccountMongodbDatabaseThroughputSettingResource>(new DatabaseAccountMongodbDatabaseThroughputSettingOperationSource(Client), _databaseAccountMongodbDatabaseThroughputSettingMongoDBResourcesClientDiagnostics, Pipeline, _databaseAccountMongodbDatabaseThroughputSettingMongoDBResourcesRestClient.CreateMigrateMongoDBDatabaseToManualThroughputRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Parent.Name, Id.Parent.Name).Request, response, OperationFinalStateVia.Location);
if (waitUntil == WaitUntil.Completed)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
private void Initialize()
{
_waitForCleanup = Mode == RecordedTestMode.Live ? WaitUntil.Completed : WaitUntil.Started;
}
protected WaitForAttribute(WaitUntil until, TriggerEvents on, TriggerPriority priority = TriggerPriority.Medium)
: base(on, priority)
{
Until = until;
}
public override void OnInitialization()
{
base.OnInitialization();
_pauseWait = new WaitUntil(() => { return(!_pause); });
}
public virtual async Task <ArmOperation <ObjectReplicationPolicy> > CreateOrUpdateAsync(WaitUntil waitUntil, string objectReplicationPolicyId, ObjectReplicationPolicyData properties, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(objectReplicationPolicyId, nameof(objectReplicationPolicyId));
Argument.AssertNotNull(properties, nameof(properties));
using var scope = _objectReplicationPolicyClientDiagnostics.CreateScope("ObjectReplicationPolicyCollection.CreateOrUpdate");
scope.Start();
try
{
var response = await _objectReplicationPolicyRestClient.CreateOrUpdateAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, objectReplicationPolicyId, properties, cancellationToken).ConfigureAwait(false);
var operation = new StorageArmOperation <ObjectReplicationPolicy>(Response.FromValue(new ObjectReplicationPolicy(Client, response), response.GetRawResponse()));
if (waitUntil == WaitUntil.Completed)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <ArmOperation <AfdSecurityPolicyResource> > UpdateAsync(WaitUntil waitUntil, AfdSecurityPolicyPatch patch, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(patch, nameof(patch));
using var scope = _afdSecurityPolicyClientDiagnostics.CreateScope("AfdSecurityPolicyResource.Update");
scope.Start();
try
{
var response = await _afdSecurityPolicyRestClient.PatchAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name, patch, cancellationToken).ConfigureAwait(false);
var operation = new CdnArmOperation <AfdSecurityPolicyResource>(new AfdSecurityPolicyOperationSource(Client), _afdSecurityPolicyClientDiagnostics, Pipeline, _afdSecurityPolicyRestClient.CreatePatchRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name, patch).Request, response, OperationFinalStateVia.AzureAsyncOperation);
if (waitUntil == WaitUntil.Completed)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <ArmOperation <DedicatedHostResource> > UpdateAsync(WaitUntil waitUntil, PatchableDedicatedHostData data, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(data, nameof(data));
using var scope = _dedicatedHostClientDiagnostics.CreateScope("DedicatedHostResource.Update");
scope.Start();
try
{
var response = await _dedicatedHostRestClient.UpdateAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name, data, cancellationToken).ConfigureAwait(false);
var operation = new ComputeArmOperation <DedicatedHostResource>(new DedicatedHostOperationSource(Client), _dedicatedHostClientDiagnostics, Pipeline, _dedicatedHostRestClient.CreateUpdateRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name, data).Request, response, OperationFinalStateVia.Location);
if (waitUntil == WaitUntil.Completed)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <ArmOperation <SiteSiteextensionResource> > UpdateAsync(WaitUntil waitUntil, CancellationToken cancellationToken = default)
{
using var scope = _siteSiteextensionWebAppsClientDiagnostics.CreateScope("SiteSiteextensionResource.Update");
scope.Start();
try
{
var response = await _siteSiteextensionWebAppsRestClient.InstallSiteExtensionAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name, cancellationToken).ConfigureAwait(false);
var operation = new AppServiceArmOperation <SiteSiteextensionResource>(new SiteSiteextensionOperationSource(Client), _siteSiteextensionWebAppsClientDiagnostics, Pipeline, _siteSiteextensionWebAppsRestClient.CreateInstallSiteExtensionRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name).Request, response, OperationFinalStateVia.Location);
if (waitUntil == WaitUntil.Completed)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual ArmOperation <ApplicationGatewayPrivateEndpointConnectionResource> Update(WaitUntil waitUntil, ApplicationGatewayPrivateEndpointConnectionData data, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(data, nameof(data));
using var scope = _applicationGatewayPrivateEndpointConnectionClientDiagnostics.CreateScope("ApplicationGatewayPrivateEndpointConnectionResource.Update");
scope.Start();
try
{
var response = _applicationGatewayPrivateEndpointConnectionRestClient.Update(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name, data, cancellationToken);
var operation = new NetworkArmOperation <ApplicationGatewayPrivateEndpointConnectionResource>(new ApplicationGatewayPrivateEndpointConnectionOperationSource(Client), _applicationGatewayPrivateEndpointConnectionClientDiagnostics, Pipeline, _applicationGatewayPrivateEndpointConnectionRestClient.CreateUpdateRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name, data).Request, response, OperationFinalStateVia.AzureAsyncOperation);
if (waitUntil == WaitUntil.Completed)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <ArmOperation <PrivateEndpointConnectionResource> > CreateOrUpdateAsync(WaitUntil waitUntil, string peConnectionName, PrivateEndpointConnectionData data, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(peConnectionName, nameof(peConnectionName));
Argument.AssertNotNull(data, nameof(data));
using var scope = _privateEndpointConnectionPrivateLinkServicesClientDiagnostics.CreateScope("PrivateEndpointConnectionCollection.CreateOrUpdate");
scope.Start();
try
{
var response = await _privateEndpointConnectionPrivateLinkServicesRestClient.UpdatePrivateEndpointConnectionAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, peConnectionName, data, cancellationToken).ConfigureAwait(false);
var operation = new NetworkArmOperation <PrivateEndpointConnectionResource>(Response.FromValue(new PrivateEndpointConnectionResource(Client, response), response.GetRawResponse()));
if (waitUntil == WaitUntil.Completed)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <ArmOperation <ContainerAppCertificateResource> > CreateOrUpdateAsync(WaitUntil waitUntil, string certificateName, ContainerAppCertificateData data = null, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(certificateName, nameof(certificateName));
using var scope = _containerAppCertificateCertificatesClientDiagnostics.CreateScope("ContainerAppCertificateCollection.CreateOrUpdate");
scope.Start();
try
{
var response = await _containerAppCertificateCertificatesRestClient.CreateOrUpdateAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, certificateName, data, cancellationToken).ConfigureAwait(false);
var operation = new ContainersArmOperation <ContainerAppCertificateResource>(Response.FromValue(new ContainerAppCertificateResource(Client, response), response.GetRawResponse()));
if (waitUntil == WaitUntil.Completed)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <ArmOperation <PrivateLinkServiceResource> > UpdateAsync(WaitUntil waitUntil, PrivateLinkServiceData data, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(data, nameof(data));
using var scope = _privateLinkServiceClientDiagnostics.CreateScope("PrivateLinkServiceResource.Update");
scope.Start();
try
{
var response = await _privateLinkServiceRestClient.CreateOrUpdateAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, data, cancellationToken).ConfigureAwait(false);
var operation = new NetworkArmOperation <PrivateLinkServiceResource>(new PrivateLinkServiceOperationSource(Client), _privateLinkServiceClientDiagnostics, Pipeline, _privateLinkServiceRestClient.CreateCreateOrUpdateRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, data).Request, response, OperationFinalStateVia.AzureAsyncOperation);
if (waitUntil == WaitUntil.Completed)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <ArmOperation <VirtualNetworkRule> > CreateOrUpdateAsync(WaitUntil waitUntil, string virtualNetworkRuleName, VirtualNetworkRuleData parameters, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(virtualNetworkRuleName, nameof(virtualNetworkRuleName));
Argument.AssertNotNull(parameters, nameof(parameters));
using var scope = _virtualNetworkRuleClientDiagnostics.CreateScope("VirtualNetworkRuleCollection.CreateOrUpdate");
scope.Start();
try
{
var response = await _virtualNetworkRuleRestClient.CreateOrUpdateAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, virtualNetworkRuleName, parameters, cancellationToken).ConfigureAwait(false);
var operation = new SqlArmOperation <VirtualNetworkRule>(new VirtualNetworkRuleOperationSource(Client), _virtualNetworkRuleClientDiagnostics, Pipeline, _virtualNetworkRuleRestClient.CreateCreateOrUpdateRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, virtualNetworkRuleName, parameters).Request, response, OperationFinalStateVia.Location);
if (waitUntil == WaitUntil.Completed)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual ArmOperation <DatabaseAccountGremlinDatabaseGraphThroughputSettingResource> MigrateGremlinGraphToManualThroughput(WaitUntil waitUntil, CancellationToken cancellationToken = default)
{
using var scope = _databaseAccountGremlinDatabaseGraphThroughputSettingGremlinResourcesClientDiagnostics.CreateScope("DatabaseAccountGremlinDatabaseGraphThroughputSettingResource.MigrateGremlinGraphToManualThroughput");
scope.Start();
try
{
var response = _databaseAccountGremlinDatabaseGraphThroughputSettingGremlinResourcesRestClient.MigrateGremlinGraphToManualThroughput(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Parent.Parent.Name, Id.Parent.Parent.Name, Id.Parent.Name, cancellationToken);
var operation = new CosmosDBArmOperation <DatabaseAccountGremlinDatabaseGraphThroughputSettingResource>(new DatabaseAccountGremlinDatabaseGraphThroughputSettingOperationSource(Client), _databaseAccountGremlinDatabaseGraphThroughputSettingGremlinResourcesClientDiagnostics, Pipeline, _databaseAccountGremlinDatabaseGraphThroughputSettingGremlinResourcesRestClient.CreateMigrateGremlinGraphToManualThroughputRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Parent.Parent.Name, Id.Parent.Parent.Name, Id.Parent.Name).Request, response, OperationFinalStateVia.Location);
if (waitUntil == WaitUntil.Completed)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <ArmOperation <SubscriptionPolicySetDefinitionResource> > CreateOrUpdateAsync(WaitUntil waitUntil, string policySetDefinitionName, PolicySetDefinitionData data, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(policySetDefinitionName, nameof(policySetDefinitionName));
Argument.AssertNotNull(data, nameof(data));
using var scope = _subscriptionPolicySetDefinitionPolicySetDefinitionsClientDiagnostics.CreateScope("SubscriptionPolicySetDefinitionCollection.CreateOrUpdate");
scope.Start();
try
{
var response = await _subscriptionPolicySetDefinitionPolicySetDefinitionsRestClient.CreateOrUpdateAsync(Id.SubscriptionId, policySetDefinitionName, data, cancellationToken).ConfigureAwait(false);
var operation = new ResourcesArmOperation <SubscriptionPolicySetDefinitionResource>(Response.FromValue(new SubscriptionPolicySetDefinitionResource(Client, response), response.GetRawResponse()));
if (waitUntil == WaitUntil.Completed)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <ArmOperation <JobCredential> > CreateOrUpdateAsync(WaitUntil waitUntil, string credentialName, JobCredentialData parameters, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(credentialName, nameof(credentialName));
Argument.AssertNotNull(parameters, nameof(parameters));
using var scope = _jobCredentialClientDiagnostics.CreateScope("JobCredentialCollection.CreateOrUpdate");
scope.Start();
try
{
var response = await _jobCredentialRestClient.CreateOrUpdateAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name, credentialName, parameters, cancellationToken).ConfigureAwait(false);
var operation = new SqlArmOperation <JobCredential>(Response.FromValue(new JobCredential(Client, response), response.GetRawResponse()));
if (waitUntil == WaitUntil.Completed)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <ArmOperation <VpnProfileResponse> > GenerateVpnProfileAsync(WaitUntil waitUntil, P2SVpnProfileParameters parameters, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(parameters, nameof(parameters));
using var scope = _p2SVpnGatewayP2sVpnGatewaysClientDiagnostics.CreateScope("P2SVpnGateway.GenerateVpnProfile");
scope.Start();
try
{
var response = await _p2SVpnGatewayP2sVpnGatewaysRestClient.GenerateVpnProfileAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, parameters, cancellationToken).ConfigureAwait(false);
var operation = new NetworkArmOperation <VpnProfileResponse>(new VpnProfileResponseOperationSource(), _p2SVpnGatewayP2sVpnGatewaysClientDiagnostics, Pipeline, _p2SVpnGatewayP2sVpnGatewaysRestClient.CreateGenerateVpnProfileRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, parameters).Request, response, OperationFinalStateVia.Location);
if (waitUntil == WaitUntil.Completed)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <ArmOperation <P2SVpnGateway> > GetP2SVpnConnectionHealthAsync(WaitUntil waitUntil, CancellationToken cancellationToken = default)
{
using var scope = _p2SVpnGatewayP2sVpnGatewaysClientDiagnostics.CreateScope("P2SVpnGateway.GetP2SVpnConnectionHealth");
scope.Start();
try
{
var response = await _p2SVpnGatewayP2sVpnGatewaysRestClient.GetP2SVpnConnectionHealthAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, cancellationToken).ConfigureAwait(false);
var operation = new NetworkArmOperation <P2SVpnGateway>(new P2SVpnGatewayOperationSource(Client), _p2SVpnGatewayP2sVpnGatewaysClientDiagnostics, Pipeline, _p2SVpnGatewayP2sVpnGatewaysRestClient.CreateGetP2SVpnConnectionHealthRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Name).Request, response, OperationFinalStateVia.Location);
if (waitUntil == WaitUntil.Completed)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual ArmOperation <P2SVpnConnectionHealth> GetP2SVpnConnectionHealthDetailed(WaitUntil waitUntil, P2SVpnConnectionHealthRequest request, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(request, nameof(request));
using var scope = _p2SVpnGatewayP2sVpnGatewaysClientDiagnostics.CreateScope("P2SVpnGateway.GetP2SVpnConnectionHealthDetailed");
scope.Start();
try
{
var response = _p2SVpnGatewayP2sVpnGatewaysRestClient.GetP2SVpnConnectionHealthDetailed(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, request, cancellationToken);
var operation = new NetworkArmOperation <P2SVpnConnectionHealth>(new P2SVpnConnectionHealthOperationSource(), _p2SVpnGatewayP2sVpnGatewaysClientDiagnostics, Pipeline, _p2SVpnGatewayP2sVpnGatewaysRestClient.CreateGetP2SVpnConnectionHealthDetailedRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, request).Request, response, OperationFinalStateVia.Location);
if (waitUntil == WaitUntil.Completed)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
protected DriverUser(IWebDriver driver)
{
Driver = driver;
WaitUntil = new WaitUntil(Driver);
ScreenshotsContainer = new ScreenshotsContainer(Driver);
}
public virtual ArmOperation <ExtendedServerBlobAuditingPolicyResource> Update(WaitUntil waitUntil, ExtendedServerBlobAuditingPolicyData data, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(data, nameof(data));
using var scope = _extendedServerBlobAuditingPolicyClientDiagnostics.CreateScope("ExtendedServerBlobAuditingPolicyResource.Update");
scope.Start();
try
{
var response = _extendedServerBlobAuditingPolicyRestClient.CreateOrUpdate(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name, data, cancellationToken);
var operation = new SqlArmOperation <ExtendedServerBlobAuditingPolicyResource>(new ExtendedServerBlobAuditingPolicyOperationSource(Client), _extendedServerBlobAuditingPolicyClientDiagnostics, Pipeline, _extendedServerBlobAuditingPolicyRestClient.CreateCreateOrUpdateRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name, data).Request, response, OperationFinalStateVia.Location);
if (waitUntil == WaitUntil.Completed)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
