/// <summary>
/// Validate the object.
/// </summary>
/// <exception cref="ValidationException">
/// Thrown if validation fails
/// </exception>
public virtual void Validate()
{
if (PrivateEndpoint != null)
{
PrivateEndpoint.Validate();
}
}
/// <summary>
/// Validate the object.
/// </summary>
/// <exception cref="ValidationException">
/// Thrown if validation fails
/// </exception>
public virtual void Validate()
{
if (ExtendedLocation != null)
{
ExtendedLocation.Validate();
}
if (PrivateEndpoint != null)
{
PrivateEndpoint.Validate();
}
if (IpConfigurations != null)
{
foreach (var element in IpConfigurations)
{
if (element != null)
{
element.Validate();
}
}
}
if (TapConfigurations != null)
{
foreach (var element1 in TapConfigurations)
{
if (element1 != null)
{
element1.Validate();
}
}
}
}
/// <summary>
/// Initializes a new instance of the NetworkInterface class.
/// </summary>
/// <param name="id">Resource ID.</param>
/// <param name="name">Resource name.</param>
/// <param name="type">Resource type.</param>
/// <param name="location">Resource location.</param>
/// <param name="tags">Resource tags.</param>
/// <param name="extendedLocation">The extended location of the network
/// interface.</param>
/// <param name="virtualMachine">The reference to a virtual
/// machine.</param>
/// <param name="networkSecurityGroup">The reference to the
/// NetworkSecurityGroup resource.</param>
/// <param name="privateEndpoint">A reference to the private endpoint
/// to which the network interface is linked.</param>
/// <param name="ipConfigurations">A list of IPConfigurations of the
/// network interface.</param>
/// <param name="tapConfigurations">A list of TapConfigurations of the
/// network interface.</param>
/// <param name="dnsSettings">The DNS settings in network
/// interface.</param>
/// <param name="macAddress">The MAC address of the network
/// interface.</param>
/// <param name="primary">Whether this is a primary network interface
/// on a virtual machine.</param>
/// <param name="vnetEncryptionSupported">Whether the virtual machine
/// this nic is attached to supports encryption.</param>
/// <param name="enableAcceleratedNetworking">If the network interface
/// is accelerated networking enabled.</param>
/// <param name="enableIPForwarding">Indicates whether IP forwarding is
/// enabled on this network interface.</param>
/// <param name="hostedWorkloads">A list of references to linked
/// BareMetal resources.</param>
/// <param name="dscpConfiguration">A reference to the dscp
/// configuration to which the network interface is linked.</param>
/// <param name="resourceGuid">The resource GUID property of the
/// network interface resource.</param>
/// <param name="provisioningState">The provisioning state of the
/// network interface resource. Possible values include: 'Succeeded',
/// 'Updating', 'Deleting', 'Failed'</param>
/// <param name="workloadType">WorkloadType of the NetworkInterface for
/// BareMetal resources</param>
/// <param name="nicType">Type of Network Interface resource. Possible
/// values include: 'Standard', 'Elastic'</param>
/// <param name="privateLinkService">Privatelinkservice of the network
/// interface resource.</param>
/// <param name="migrationPhase">Migration phase of Network Interface
/// resource. Possible values include: 'None', 'Prepare', 'Commit',
/// 'Abort', 'Committed'</param>
/// <param name="etag">A unique read-only string that changes whenever
/// the resource is updated.</param>
public NetworkInterface(string id = default(string), string name = default(string), string type = default(string), string location = default(string), IDictionary <string, string> tags = default(IDictionary <string, string>), ExtendedLocation extendedLocation = default(ExtendedLocation), SubResource virtualMachine = default(SubResource), NetworkSecurityGroup networkSecurityGroup = default(NetworkSecurityGroup), PrivateEndpoint privateEndpoint = default(PrivateEndpoint), IList <NetworkInterfaceIPConfiguration> ipConfigurations = default(IList <NetworkInterfaceIPConfiguration>), IList <NetworkInterfaceTapConfiguration> tapConfigurations = default(IList <NetworkInterfaceTapConfiguration>), NetworkInterfaceDnsSettings dnsSettings = default(NetworkInterfaceDnsSettings), string macAddress = default(string), bool?primary = default(bool?), bool?vnetEncryptionSupported = default(bool?), bool?enableAcceleratedNetworking = default(bool?), bool?enableIPForwarding = default(bool?), IList <string> hostedWorkloads = default(IList <string>), SubResource dscpConfiguration = default(SubResource), string resourceGuid = default(string), string provisioningState = default(string), string workloadType = default(string), string nicType = default(string), PrivateLinkService privateLinkService = default(PrivateLinkService), string migrationPhase = default(string), string etag = default(string))
: base(id, name, type, location, tags)
{
ExtendedLocation = extendedLocation;
VirtualMachine = virtualMachine;
NetworkSecurityGroup = networkSecurityGroup;
PrivateEndpoint = privateEndpoint;
IpConfigurations = ipConfigurations;
TapConfigurations = tapConfigurations;
DnsSettings = dnsSettings;
MacAddress = macAddress;
Primary = primary;
VnetEncryptionSupported = vnetEncryptionSupported;
EnableAcceleratedNetworking = enableAcceleratedNetworking;
EnableIPForwarding = enableIPForwarding;
HostedWorkloads = hostedWorkloads;
DscpConfiguration = dscpConfiguration;
ResourceGuid = resourceGuid;
ProvisioningState = provisioningState;
WorkloadType = workloadType;
NicType = nicType;
PrivateLinkService = privateLinkService;
MigrationPhase = migrationPhase;
Etag = etag;
CustomInit();
}
/// <summary>
/// Initializes a new instance of the PrivateEndpointConnection class.
/// </summary>
/// <param name="id">Resource ID.</param>
/// <param name="privateEndpoint">The resource of private end
/// point.</param>
/// <param name="privateLinkServiceConnectionState">A collection of
/// information about the state of the connection between service
/// consumer and provider.</param>
/// <param name="name">The name of the resource that is unique within a
/// resource group. This name can be used to access the
/// resource.</param>
public PrivateEndpointConnection(string id = default(string), PrivateEndpoint privateEndpoint = default(PrivateEndpoint), PrivateLinkServiceConnectionState privateLinkServiceConnectionState = default(PrivateLinkServiceConnectionState), string name = default(string))
: base(id)
{
PrivateEndpoint = privateEndpoint;
PrivateLinkServiceConnectionState = privateLinkServiceConnectionState;
Name = name;
CustomInit();
}
/// <summary>
/// Initializes a new instance of the PrivateEndpointConnection class.
/// </summary>
/// <param name="id">Resource ID.</param>
/// <param name="privateEndpoint">The resource of private end
/// point.</param>
/// <param name="privateLinkServiceConnectionState">A collection of
/// information about the state of the connection between service
/// consumer and provider.</param>
/// <param name="provisioningState">The provisioning state of the
/// private endpoint connection. Possible values include: 'Succeeded',
/// 'Updating', 'Deleting', 'Failed'</param>
/// <param name="name">The name of the resource that is unique within a
/// resource group. This name can be used to access the
/// resource.</param>
/// <param name="type">The resource type.</param>
/// <param name="etag">A unique read-only string that changes whenever
/// the resource is updated.</param>
public PrivateEndpointConnection(string id = default(string), PrivateEndpoint privateEndpoint = default(PrivateEndpoint), PrivateLinkServiceConnectionState privateLinkServiceConnectionState = default(PrivateLinkServiceConnectionState), string provisioningState = default(string), string name = default(string), string type = default(string), string etag = default(string))
: base(id)
{
PrivateEndpoint = privateEndpoint;
PrivateLinkServiceConnectionState = privateLinkServiceConnectionState;
ProvisioningState = provisioningState;
Name = name;
Type = type;
Etag = etag;
CustomInit();
}
/// <summary>
/// Initializes a new instance of the
/// ApplicationGatewayPrivateEndpointConnection class.
/// </summary>
/// <param name="id">Resource ID.</param>
/// <param name="privateEndpoint">The resource of private end
/// point.</param>
/// <param name="privateLinkServiceConnectionState">A collection of
/// information about the state of the connection between service
/// consumer and provider.</param>
/// <param name="provisioningState">The provisioning state of the
/// application gateway private endpoint connection resource. Possible
/// values include: 'Succeeded', 'Updating', 'Deleting',
/// 'Failed'</param>
/// <param name="linkIdentifier">The consumer link id.</param>
/// <param name="name">Name of the private endpoint connection on an
/// application gateway.</param>
/// <param name="etag">A unique read-only string that changes whenever
/// the resource is updated.</param>
/// <param name="type">Type of the resource.</param>
public ApplicationGatewayPrivateEndpointConnection(string id = default(string), PrivateEndpoint privateEndpoint = default(PrivateEndpoint), PrivateLinkServiceConnectionState privateLinkServiceConnectionState = default(PrivateLinkServiceConnectionState), string provisioningState = default(string), string linkIdentifier = default(string), string name = default(string), string etag = default(string), string type = default(string))
: base(id)
{
PrivateEndpoint = privateEndpoint;
PrivateLinkServiceConnectionState = privateLinkServiceConnectionState;
ProvisioningState = provisioningState;
LinkIdentifier = linkIdentifier;
Name = name;
Etag = etag;
Type = type;
CustomInit();
}
/// <summary>
/// Initializes a new instance of the NetworkInterface class.
/// </summary>
/// <param name="id">Resource ID.</param>
/// <param name="name">Resource name.</param>
/// <param name="type">Resource type.</param>
/// <param name="location">Resource location.</param>
/// <param name="tags">Resource tags.</param>
/// <param name="virtualMachine">The reference of a virtual
/// machine.</param>
/// <param name="networkSecurityGroup">The reference of the
/// NetworkSecurityGroup resource.</param>
/// <param name="privateEndpoint">A reference to the private endpoint
/// to which the network interface is linked.</param>
/// <param name="ipConfigurations">A list of IPConfigurations of the
/// network interface.</param>
/// <param name="tapConfigurations">A list of TapConfigurations of the
/// network interface.</param>
/// <param name="dnsSettings">The DNS settings in network
/// interface.</param>
/// <param name="macAddress">The MAC address of the network
/// interface.</param>
/// <param name="primary">Whether this is a primary network interface
/// on a virtual machine.</param>
/// <param name="enableAcceleratedNetworking">If the network interface
/// is accelerated networking enabled.</param>
/// <param name="enableIPForwarding">Indicates whether IP forwarding is
/// enabled on this network interface.</param>
/// <param name="hostedWorkloads">A list of references to linked
/// BareMetal resources.</param>
/// <param name="resourceGuid">The resource GUID property of the
/// network interface resource.</param>
/// <param name="provisioningState">The provisioning state of the
/// network interface resource. Possible values include: 'Succeeded',
/// 'Updating', 'Deleting', 'Failed'</param>
/// <param name="etag">A unique read-only string that changes whenever
/// the resource is updated.</param>
public NetworkInterface(string id = default(string), string name = default(string), string type = default(string), string location = default(string), IDictionary <string, string> tags = default(IDictionary <string, string>), SubResource virtualMachine = default(SubResource), NetworkSecurityGroup networkSecurityGroup = default(NetworkSecurityGroup), PrivateEndpoint privateEndpoint = default(PrivateEndpoint), IList <NetworkInterfaceIPConfiguration> ipConfigurations = default(IList <NetworkInterfaceIPConfiguration>), IList <NetworkInterfaceTapConfiguration> tapConfigurations = default(IList <NetworkInterfaceTapConfiguration>), NetworkInterfaceDnsSettings dnsSettings = default(NetworkInterfaceDnsSettings), string macAddress = default(string), bool?primary = default(bool?), bool?enableAcceleratedNetworking = default(bool?), bool?enableIPForwarding = default(bool?), IList <string> hostedWorkloads = default(IList <string>), string resourceGuid = default(string), string provisioningState = default(string), string etag = default(string))
: base(id, name, type, location, tags)
{
VirtualMachine = virtualMachine;
NetworkSecurityGroup = networkSecurityGroup;
PrivateEndpoint = privateEndpoint;
IpConfigurations = ipConfigurations;
TapConfigurations = tapConfigurations;
DnsSettings = dnsSettings;
MacAddress = macAddress;
Primary = primary;
EnableAcceleratedNetworking = enableAcceleratedNetworking;
EnableIPForwarding = enableIPForwarding;
HostedWorkloads = hostedWorkloads;
ResourceGuid = resourceGuid;
ProvisioningState = provisioningState;
Etag = etag;
CustomInit();
}
public void TestPrivateEndpointConnection()
{
TestInitialize();
string clusterName = TestUtilities.GenerateName("hdisdk-pe");
var createParams = CommonData.PrepareClusterCreateParamsForWasb();
createParams.Location = "South Central US";
var networkProperties = new NetworkProperties(ResourceProviderConnection.Outbound, PrivateLink.Enabled);
createParams.Properties.NetworkProperties = networkProperties;
string storageAccountResourceId = string.Format("/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Storage/storageAccounts/{2}", CommonData.SubscriptionId, CommonData.ResourceGroupName, CommonData.StorageAccountName);
createParams.Properties.StorageProfile.Storageaccounts[0].ResourceId = storageAccountResourceId;
string vnetId = "/subscriptions/964c10bb-8a6c-43bc-83d3-6b318c6c7305/resourceGroups/rg/providers/Microsoft.Network/virtualNetworks/fakevnet";
string subnetId = "/subscriptions/964c10bb-8a6c-43bc-83d3-6b318c6c7305/resourceGroups/rg/providers/Microsoft.Network/virtualNetworks/fakevnet/subnets/default";
foreach (var role in createParams.Properties.ComputeProfile.Roles)
{
role.VirtualNetworkProfile = new VirtualNetworkProfile(vnetId, subnetId);
}
var cluster = HDInsightClient.Clusters.Create(CommonData.ResourceGroupName, clusterName, createParams);
var privateLinkResourceListResult = HDInsightClient.PrivateLinkResources.ListByCluster(CommonData.ResourceGroupName, clusterName);
Assert.NotNull(privateLinkResourceListResult);
var headNodePrivateLinkResource = privateLinkResourceListResult.Value.Where(pls => pls.Name.Equals("headnode")).FirstOrDefault();
// call Network sdk to create private endpoint and choose the approve manually way.
// please notice that the
NetworkPrivateEndpoint privateEndpointParameter = new NetworkPrivateEndpoint()
{
Location = cluster.Location,
ManualPrivateLinkServiceConnections = new List <NetworkPrivateLinkServiceConnection>
{
new NetworkPrivateLinkServiceConnection()
{
Name = cluster.Name, // Private link service name is the cluster name
PrivateLinkServiceId = cluster.Id, // Private link service id is the cluster resource id
GroupIds = new List <string> {
headNodePrivateLinkResource.GroupId,
},
RequestMessage = "Want to connect to head node private link resource."
},
},
Subnet = new Subnet(id: subnetId)
};
string privateEndpointName = "headnodepe";
var createPrivateEndpointResult = HDInsightManagementHelper.CreatePrivateEndpoint(CommonData.ResourceGroupName, privateEndpointName, privateEndpointParameter);
// Get the private endpoint connection and check the status
var privateEndpointConnectionListResult = HDInsightClient.PrivateEndpointConnections.ListByCluster(CommonData.ResourceGroupName, clusterName);
Assert.NotNull(privateEndpointConnectionListResult);
foreach (var privateEndpointConnection in privateEndpointConnectionListResult)
{
Assert.Equal(PrivateLinkServiceConnectionStatus.Pending, privateEndpointConnection.PrivateLinkServiceConnectionState.Status);
//Approve
privateEndpointConnection.PrivateLinkServiceConnectionState.Status = PrivateLinkServiceConnectionStatus.Approved;
HDInsightClient.PrivateEndpointConnections.CreateOrUpdate(CommonData.ResourceGroupName, clusterName, privateEndpointConnection.Name, privateEndpointConnection);
//Delete
HDInsightClient.PrivateEndpointConnections.Delete(CommonData.ResourceGroupName, clusterName, privateEndpointConnection.Name);
}
}
public async void SetupPrivateEndpointAutoApprovalTests()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType()))
{
//prepare test base
var testBase = new ApiManagementTestBase(context);
// test is done in prod preview environment
string serviceRegion = "West US 2";
testBase.location = serviceRegion;
testBase.serviceProperties.Location = serviceRegion;
testBase.serviceProperties.Sku = new ApiManagementServiceSkuProperties(SkuType.Developer, capacity: 1);
// prepare private endpoint names and ids
var virtualNetworkName = TestUtilities.GenerateName("apimvnet");
var subnetName = TestUtilities.GenerateName("apimsubnet");
var subnetId = CreateDefaultVNetWithSubnet(virtualNetworkName, subnetName, testBase);
var privateEndpointName = TestUtilities.GenerateName("apimprivateendpoint");
var privateEndpointConnectionName = TestUtilities.GenerateName("apimprivateendpointconnection");
var apimPrivateEndpointTypeId = String.Format(apimPrivateEndpointTypeIdTemplate, testBase.subscriptionId, testBase.rgName);
var apimPrivateLinkResourceId = String.Format(apimPrivateLinkResourceIdTemplate, testBase.subscriptionId, testBase.rgName, testBase.serviceName);
var apimServiceId = String.Format(apimServiceIdTemplate, testBase.subscriptionId, testBase.rgName, testBase.serviceName);
var apimPrivateEndpointId = String.Format(privateEndpointIdTemplate, testBase.subscriptionId, testBase.rgName, privateEndpointName);
var apimPrivateEndpointConnectionId = String.Format(apimPrivateEndpointConnectionIdTemplate, testBase.subscriptionId, testBase.rgName, testBase.serviceName, privateEndpointConnectionName);
//create new service
var createdService = testBase.client.ApiManagementService.CreateOrUpdate(
resourceGroupName: testBase.rgName,
serviceName: testBase.serviceName,
parameters: testBase.serviceProperties);
// service must be non-consumption and non-vnet to enable private link
ValidateService(createdService,
testBase.serviceName,
testBase.rgName,
testBase.subscriptionId,
testBase.location,
testBase.serviceProperties.PublisherEmail,
testBase.serviceProperties.PublisherName,
testBase.serviceProperties.Sku.Name,
testBase.tags,
PlatformVersion.Stv2);
Assert.Equal(VirtualNetworkType.None, createdService.VirtualNetworkType);
// verify the response of get available private endpoint types in subscription
bool privateEndpointTypeFound = false;
var pagedAvailablePrivateEndpointTypes = await testBase.networkClient.AvailablePrivateEndpointTypes.ListByResourceGroupAsync(testBase.location, testBase.rgName);
while (pagedAvailablePrivateEndpointTypes != null && pagedAvailablePrivateEndpointTypes.Count() > 0)
{
Console.WriteLine(pagedAvailablePrivateEndpointTypes);
if (pagedAvailablePrivateEndpointTypes.Any(peType =>
peType.Name == "Microsoft.ApiManagement.service" &&
peType.Type == "Microsoft.Network/AvailablePrivateEndpointTypes" &&
peType.ResourceName == "Microsoft.ApiManagement/service" &&
peType.Id == apimPrivateEndpointTypeId))
{
privateEndpointTypeFound = true;
break;
}
if (pagedAvailablePrivateEndpointTypes.NextPageLink != null && pagedAvailablePrivateEndpointTypes.NextPageLink != String.Empty)
{
pagedAvailablePrivateEndpointTypes = await testBase.networkClient.AvailablePrivateEndpointTypes.ListByResourceGroupNextAsync(pagedAvailablePrivateEndpointTypes.NextPageLink);
}
else
{
break;
}
}
Assert.True(privateEndpointTypeFound);
// verify the response of get available private Link resources in subscription
var listAvailablePrivateLinkResourceResponse = await testBase.client.PrivateEndpointConnection.ListPrivateLinkResourcesAsync(testBase.rgName, testBase.serviceName);
Assert.Contains(listAvailablePrivateLinkResourceResponse.Value,
plResource =>
plResource.Name == privateLinkResourceName &&
plResource.Type == "Microsoft.ApiManagement/service/privateLinkResources" &&
plResource.Id == apimPrivateLinkResourceId &&
plResource.GroupId == privateLinkResourceName &&
plResource.RequiredMembers.Count == 1 &&
plResource.RequiredMembers.Contains(privateLinkResourceName) &&
plResource.RequiredZoneNames.Count == 1 &&
plResource.RequiredZoneNames.Contains("privateLink.azure-api.net"));
// prepare vnet for private endpoint creation
var plServiceConnection = new NRPPrivateLinkServiceConnection(
null,
null,
apimServiceId,
new List <string> {
privateLinkResourceName
},
privateEndpointRequestDescription,
null,
privateEndpointConnectionName);
var subnet = new Subnet(subnetId);
var privateEndpoint = new NRPPrivateEndpoint(
null,
null,
null,
testBase.location,
null,
null,
subnet,
null,
null,
new List <NRPPrivateLinkServiceConnection> {
plServiceConnection
});
// create private endpoint with auto-approval flow
var createdPrivateEndpoint = await testBase.networkClient.PrivateEndpoints.CreateOrUpdateAsync(testBase.rgName, privateEndpointName, privateEndpoint);
// verify that the private endpoint connection is created correctly
Assert.Equal(1, createdPrivateEndpoint.PrivateLinkServiceConnections.Count);
Assert.Contains(createdPrivateEndpoint.PrivateLinkServiceConnections,
connection =>
connection.PrivateLinkServiceId == plServiceConnection.PrivateLinkServiceId &&
connection.GroupIds.Count == 1 &&
connection.PrivateLinkServiceConnectionState.Status == "Approved" &&
connection.PrivateLinkServiceConnectionState.Description == privateEndpointRequestDescription &&
connection.Name == plServiceConnection.Name &&
connection.GroupIds.Contains(privateLinkResourceName));
Assert.Equal(privateEndpointName, createdPrivateEndpoint.Name);
Assert.Equal(subnetId, createdPrivateEndpoint.Subnet.Id);
Assert.Equal("Succeeded", createdPrivateEndpoint.ProvisioningState);
// verify that the private endpoint connection returned from NRP List is correct
var nrpListPrivateEndpointsResponse = await testBase.networkClient.PrivateEndpoints.ListAsync(testBase.rgName);
Assert.Contains(nrpListPrivateEndpointsResponse,
pe =>
pe.Name == privateEndpointName &&
pe.Subnet.Id == subnetId &&
pe.ProvisioningState == "Succeeded" &&
1 == pe.PrivateLinkServiceConnections.Count(
connection =>
connection.PrivateLinkServiceId == plServiceConnection.PrivateLinkServiceId &&
connection.GroupIds.Count == 1 &&
connection.PrivateLinkServiceConnectionState.Status == "Approved" &&
connection.PrivateLinkServiceConnectionState.Description == privateEndpointRequestDescription &&
connection.Name == plServiceConnection.Name &&
connection.GroupIds.Contains(privateLinkResourceName)));
// verify that the private endpoint connection returned from GET is correct
createdPrivateEndpoint = await testBase.networkClient.PrivateEndpoints.GetAsync(testBase.rgName, privateEndpointName);
Assert.Single(createdPrivateEndpoint.PrivateLinkServiceConnections);
Assert.Equal(privateEndpointName, createdPrivateEndpoint.Name);
Assert.Equal(subnetId, createdPrivateEndpoint.Subnet.Id);
Assert.Equal("Succeeded", createdPrivateEndpoint.ProvisioningState);
Assert.Contains(createdPrivateEndpoint.PrivateLinkServiceConnections,
connection =>
connection.PrivateLinkServiceId == plServiceConnection.PrivateLinkServiceId &&
connection.GroupIds.Count == 1 &&
connection.PrivateLinkServiceConnectionState.Status == "Approved" &&
connection.PrivateLinkServiceConnectionState.Description == privateEndpointRequestDescription &&
connection.Name == plServiceConnection.Name &&
connection.GroupIds.Contains(privateLinkResourceName));
// verify that the private endpoint connection returned from LIST is correct
var privateEndpointList = await testBase.networkClient.PrivateEndpoints.ListBySubscriptionAsync();
Assert.Contains(privateEndpointList,
endpoint =>
endpoint.Name == privateEndpointName &&
endpoint.Subnet.Id == subnetId &&
1 == endpoint.PrivateLinkServiceConnections.Count(
connection =>
connection.PrivateLinkServiceId == plServiceConnection.PrivateLinkServiceId &&
connection.GroupIds.Count == 1 &&
connection.PrivateLinkServiceConnectionState.Status == "Approved" &&
connection.PrivateLinkServiceConnectionState.Description == privateEndpointRequestDescription &&
connection.Name == plServiceConnection.Name &&
connection.GroupIds.Contains(privateLinkResourceName)));
// verfity that the private endpoint connection returned from GET api service container is correct
// NOTE: currently connection.Name is returning internal name, need to verify after it is fixed
var apiService = await testBase.client.ApiManagementService.GetAsync(testBase.rgName, testBase.serviceName);
Assert.Contains(apiService.PrivateEndpointConnections,
connection =>
//connection.Name == privateEndpointName &&
connection.ProvisioningState == "Succeeded" &&
connection.PrivateLinkServiceConnectionState.Status == "Approved" &&
connection.PrivateLinkServiceConnectionState.Description == privateEndpointRequestDescription &&
connection.Id == apimPrivateEndpointConnectionId &&
connection.GroupIds.Contains(privateLinkResourceName) &&
connection.PrivateEndpoint.Id == apimPrivateEndpointId);
// run only on live testing because generic HttpClient is not supported in recording
if (Environment.GetEnvironmentVariable("AZURE_TEST_MODE") == "Live")
{
// verify that the service is reachable
var httpStatusCode = await CallApiServiceEchoApi(testBase);
Assert.True(IsSuccessStatusCode((int)httpStatusCode));
}
// disable public network access for the api service and confirm the container is updated with GET
apiService.PublicNetworkAccess = "Disabled";
await testBase.client.ApiManagementService.CreateOrUpdateAsync(testBase.rgName, testBase.serviceName, apiService);
apiService = await testBase.client.ApiManagementService.GetAsync(testBase.rgName, testBase.serviceName);
Assert.Contains(apiService.PrivateEndpointConnections,
connection =>
//connection.Name == privateEndpointName &&
connection.ProvisioningState == "Succeeded" &&
connection.PrivateLinkServiceConnectionState.Status == "Approved" &&
connection.PrivateLinkServiceConnectionState.Description == privateEndpointRequestDescription &&
connection.Id == apimPrivateEndpointConnectionId &&
connection.GroupIds.Contains(privateLinkResourceName) &&
connection.PrivateEndpoint.Id == apimPrivateEndpointId);
Assert.True(apiService.PublicNetworkAccess == "Disabled");
// run only on live testing because generic HttpClient is not supported in recording
if (Environment.GetEnvironmentVariable("AZURE_TEST_MODE") == "Live")
{
// verify that the service is not reachable
var httpStatusCode = await CallApiServiceEchoApi(testBase);
Assert.False(IsSuccessStatusCode((int)httpStatusCode));
}
// reject private endpoint and verify
// NOTE:wait for the fix
var requestProperty = new PrivateEndpointConnectionRequestProperties(new PrivateLinkServiceConnectionState("Rejected", privateEndpointRejectDescription));
var request = new PrivateEndpointConnectionRequest(apimPrivateEndpointConnectionId, requestProperty);
var updatedPrivateEndpointConnection = await testBase.client.PrivateEndpointConnection.CreateOrUpdateAsync(testBase.rgName, testBase.serviceName, privateEndpointConnectionName, request);
Assert.Equal(privateEndpointConnectionName, updatedPrivateEndpointConnection.Name);
Assert.Equal("Succeeded", updatedPrivateEndpointConnection.ProvisioningState);
Assert.Equal("Rejected", updatedPrivateEndpointConnection.PrivateLinkServiceConnectionState.Status);
//Assert.Equal(privateEndpointRejectDescription, updatedPrivateEndpointConnection.PrivateLinkServiceConnectionState.Description);
Assert.Equal(apimPrivateEndpointConnectionId, updatedPrivateEndpointConnection.Id);
Assert.Equal(apimPrivateEndpointId, updatedPrivateEndpointConnection.PrivateEndpoint.Id);
Console.WriteLine(updatedPrivateEndpointConnection.Type);
// delete private endpoint and verify
testBase.networkClient.PrivateEndpoints.Delete(testBase.rgName, privateEndpointName);
Assert.Throws <Microsoft.Azure.Management.Network.Models.ErrorException>(() =>
{
testBase.networkClient.PrivateEndpoints.Get(testBase.rgName, privateEndpointName);
});
// delete created service and verify
testBase.client.ApiManagementService.Delete(testBase.rgName, testBase.serviceName);
Assert.Throws <Microsoft.Azure.Management.ApiManagement.Models.ErrorResponseException>(() =>
{
testBase.client.ApiManagementService.Get(testBase.rgName, testBase.serviceName);
});
}
}
