public void CanCreateFromCustomImageWithManagedDisk()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var userName = "******";
var password = "******";
var publicIPDnsLabel = SdkContext.RandomResourceName("pip", 10);
var customImageName = SdkContext.RandomResourceName("img", 10);
var vmssName = SdkContext.RandomResourceName("vmss", 10);
var resourceManager = TestHelper.CreateRollupClient();
var computeManager = TestHelper.CreateComputeManager();
var networkManager = TestHelper.CreateNetworkManager();
var rgName = TestUtilities.GenerateName("rgfluentchash-");
try
{
var resourceGroup = resourceManager.ResourceGroups
.Define(rgName)
.WithRegion(Location)
.Create();
var vm = computeManager.VirtualMachines.Define(SdkContext.RandomResourceName("vm", 10))
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(publicIPDnsLabel)
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername(userName)
.WithRootPassword(password)
.WithUnmanagedDisks()
.DefineUnmanagedDataDisk("disk-1")
.WithNewVhd(100)
.WithLun(1)
.Attach()
.DefineUnmanagedDataDisk("disk-2")
.WithNewVhd(50)
.WithLun(2)
.Attach()
.WithSize(VirtualMachineSizeTypes.StandardD3V2)
.Create();
Assert.NotNull(vm);
TestHelper.DeprovisionAgentInLinuxVM(vm.GetPrimaryPublicIPAddress().Fqdn, 22, userName, password);
vm.Deallocate();
vm.Generalize();
var virtualMachineCustomImage = computeManager.VirtualMachineCustomImages
.Define(customImageName)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.FromVirtualMachine(vm)
.Create();
Assert.NotNull(virtualMachineCustomImage);
var network = networkManager
.Networks
.Define(SdkContext.RandomResourceName("vmssvnet", 15))
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithAddressSpace("10.0.0.0/28")
.WithSubnet("subnet1", "10.0.0.0/28")
.Create();
var publicLoadBalancer = ScaleSet.CreateHttpLoadBalancers(resourceManager, resourceGroup, "1", Location);
var vmScaleSet = computeManager.VirtualMachineScaleSets
.Define(vmssName)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithSku(VirtualMachineScaleSetSkuTypes.StandardD5v2)
.WithExistingPrimaryNetworkSubnet(network, "subnet1")
.WithExistingPrimaryInternetFacingLoadBalancer(publicLoadBalancer)
.WithoutPrimaryInternalLoadBalancer()
.WithLinuxCustomImage(virtualMachineCustomImage.Id)
.WithRootUsername(userName)
.WithRootPassword(password)
.Create();
var virtualMachineScaleSetVMs = vmScaleSet.VirtualMachines;
var virtualMachines = virtualMachineScaleSetVMs.List();
Assert.Equal(virtualMachines.Count(), vmScaleSet.Capacity);
foreach (var vm1 in virtualMachines)
{
Assert.True(vm1.IsOSBasedOnCustomImage);
Assert.False(vm1.IsOSBasedOnPlatformImage);
Assert.False(vm1.IsOSBasedOnStoredImage);
Assert.True(vm1.IsManagedDiskEnabled);
Assert.NotNull(vm1.UnmanagedDataDisks);
Assert.Empty(vm1.UnmanagedDataDisks);
Assert.NotNull(vm1.DataDisks);
Assert.Equal(2, vm1.DataDisks.Count); // Disks from data disk image from custom image
Assert.True(vm1.DataDisks.ContainsKey(1));
var disk = vm1.DataDisks[1];
Assert.Equal(100, disk.Size);
Assert.True(vm1.DataDisks.ContainsKey(2));
disk = vm1.DataDisks[2];
Assert.Equal(50, disk.Size);
}
vmScaleSet.Deallocate();
// Updating and adding disk as part of VMSS Update seems consistency failing, CRP is aware of
// this, hence until it is fixed comment-out the test
//
// {
// "startTime": "2017-01-25T06:10:55.2243509+00:00",
// "endTime": "2017-01-25T06:11:07.8649525+00:00",
// "status": "Failed",
// "error": {
// "code": "InternalExecutionError",
// "message": "An internal execution error occurred."
// },
// "name": "6786df83-ed3f-4d7a-bf58-d295b96fef46"
// }
//
// vmScaleSet.Update()
// .WithDataDiskUpdated(1, 200) // update not supported
// .WithNewDataDisk(100)
// .Apply();
//
// vmScaleSet.Start();
//
// virtualMachineScaleSetVMs = vmScaleSet.VirtualMachines;
// virtualMachines = virtualMachineScaleSetVMs.List();
// foreach (VirtualMachineScaleSetVM vm1 in virtualMachines) {
// Assert.True(vm1.IsOSBasedOnCustomImage());
// Assert.False(vm1.IsOSBasedOnPlatformImage());
// Assert.False(vm1.IsOSBasedOnStoredImage());
// Assert.True(vm1.IsManagedDiskEnabled());
// Assert.NotNull(vm1.UnmanagedDataDisks());
// Assert.Equal(vm1.UnmanagedDataDisks().Size(), 0);
// Assert.NotNull(vm1.DataDisks());
// Assert.Equal(vm1.DataDisks().Size(), 3);
// Assert.True(vm1.DataDisks().ContainsKey(1));
// VirtualMachineDataDisk disk = vm1.DataDisks().Get(1);
// Assert.Equal(disk.Size(), 200);
// Assert.True(vm1.DataDisks().ContainsKey(2));
// disk = vm1.DataDisks().Get(2);
// Assert.Equal(disk.Size(), 50);
// Assert.True(vm1.DataDisks().ContainsKey(0));
// disk = vm1.DataDisks().Get(0);
// Assert.Equal(disk.Size(), 100);
// }
}
finally
{
try
{
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public void CanOperateOnAuthorizationRules()
{
using (var context = FluentMockContext.Start(this.GetType().FullName))
{
var rgName = TestUtilities.GenerateName("fluentnetsbmrg");
try
{
var resourceManager = TestHelper.CreateResourceManager();
var serviceBusManager = TestHelper.CreateServiceBusManager();
Region region = Region.USEast;
var rgCreatable = resourceManager.ResourceGroups
.Define(rgName)
.WithRegion(region);
var namespaceDNSLabel = TestUtilities.GenerateName("netsbns");
var queueName = TestUtilities.GenerateName("queue1-");
var topicName = TestUtilities.GenerateName("topic1-");
var nsRuleName = TestUtilities.GenerateName("nsrule1-");
// Create NS with Queue, Topic and authorization rule
//
var nspace = serviceBusManager.Namespaces
.Define(namespaceDNSLabel)
.WithRegion(region)
.WithNewResourceGroup(rgCreatable)
.WithSku(NamespaceSku.Standard)
.WithNewQueue(queueName, 1024)
.WithNewTopic(topicName, 1024)
.WithNewManageRule(nsRuleName)
.Create();
// Lookup ns authorization rule
//
var rulesInNamespace = nspace.AuthorizationRules.List();
Assert.NotNull(rulesInNamespace);
Assert.Equal(2, rulesInNamespace.Count()); // Default + one explicit
INamespaceAuthorizationRule foundNsRule = rulesInNamespace.FirstOrDefault(r => r.Name.Equals(nsRuleName, StringComparison.OrdinalIgnoreCase));
Assert.NotNull(foundNsRule);
var nsRuleKeys = foundNsRule.GetKeys();
Assert.NotNull(nsRuleKeys);
Assert.NotNull(nsRuleKeys.Inner);
var primaryKey = nsRuleKeys.PrimaryKey;
Assert.NotNull(primaryKey);
Assert.NotNull(nsRuleKeys.SecondaryKey);
Assert.NotNull(nsRuleKeys.PrimaryConnectionString);
Assert.NotNull(nsRuleKeys.SecondaryConnectionString);
nsRuleKeys = foundNsRule.RegenerateKey(Policykey.PrimaryKey);
if (HttpMockServer.Mode != HttpRecorderMode.Playback)
{
Assert.NotEqual(nsRuleKeys.PrimaryKey, primaryKey);
}
// Lookup queue & operate on auth rules
//
var queuesInNamespace = nspace.Queues.List();
Assert.NotNull(queuesInNamespace);
Assert.Single(queuesInNamespace);
var queue = queuesInNamespace.ElementAt(0);
Assert.NotNull(queue);
Assert.NotNull(queue.Inner);
var qRule = queue.AuthorizationRules
.Define("rule1")
.WithListeningEnabled()
.Create();
Assert.NotNull(qRule);
Assert.Contains(AccessRights.Listen, qRule.Rights);
qRule = qRule.Update()
.WithManagementEnabled()
.Apply();
Assert.Contains(AccessRights.Manage, qRule.Rights);
var rulesInQueue = queue.AuthorizationRules.List();
Assert.True(rulesInQueue.Count() > 0);
var foundQRule = false;
foreach (var r in rulesInQueue)
{
if (r.Name.Equals(qRule.Name, StringComparison.OrdinalIgnoreCase))
{
foundQRule = true;
break;
}
}
Assert.True(foundQRule);
queue.AuthorizationRules.DeleteByName(qRule.Name);
// Lookup topic & operate on auth rules
//
var topicsInNamespace = nspace.Topics.List();
Assert.NotNull(topicsInNamespace);
Assert.Single(topicsInNamespace);
var topic = topicsInNamespace.ElementAt(0);
Assert.NotNull(topic);
Assert.NotNull(topic.Inner);
var tRule = topic.AuthorizationRules
.Define("rule2")
.WithSendingEnabled()
.Create();
Assert.NotNull(tRule);
Assert.Contains(AccessRights.Send, tRule.Rights);
tRule = tRule.Update()
.WithManagementEnabled()
.Apply();
Assert.Contains(AccessRights.Manage, tRule.Rights);
var rulesInTopic = topic.AuthorizationRules.List();
Assert.True(rulesInTopic.Count() > 0);
var foundTRule = false;
foreach (var r in rulesInTopic)
{
if (r.Name.Equals(tRule.Name, StringComparison.OrdinalIgnoreCase))
{
foundTRule = true;
break;
}
}
Assert.True(foundTRule);
topic.AuthorizationRules.DeleteByName(tRule.Name);
}
finally
{
try
{
TestHelper.CreateResourceManager().ResourceGroups.DeleteByName(rgName);
}
catch
{
}
}
}
}
public void CanCreateNamespaceThenCRUDOnQueue()
{
using (var context = FluentMockContext.Start(this.GetType().FullName))
{
var rgName = TestUtilities.GenerateName("sluentnetsbmrg");
try
{
var resourceManager = TestHelper.CreateResourceManager();
var serviceBusManager = TestHelper.CreateServiceBusManager();
Region region = Region.USEast;
var rgCreatable = resourceManager.ResourceGroups
.Define(rgName)
.WithRegion(region);
var namespaceDNSLabel = TestUtilities.GenerateName("netsbns");
var nspace = serviceBusManager.Namespaces
.Define(namespaceDNSLabel)
.WithRegion(region)
.WithNewResourceGroup(rgCreatable)
.WithSku(NamespaceSku.Standard)
.Create();
Assert.NotNull(nspace);
Assert.NotNull(nspace.Inner);
String queueName = TestUtilities.GenerateName("queue14444444444444444444444444444444444444444444555555555555");
var queue = nspace.Queues
.Define(queueName)
.Create();
Assert.NotNull(queue);
Assert.NotNull(queue.Inner);
Assert.NotNull(queue.Name);
Assert.Equal(queue.Name, queueName, ignoreCase: true);
// Default lock duration is 1 minute, assert TimeSpan("00:01:00") parsing
//
Assert.Equal("00:01:00", queue.Inner.LockDuration);
Assert.Equal(60, queue.LockDurationInSeconds);
var dupDetectionDuration = queue.DuplicateMessageDetectionHistoryDuration;
Assert.Equal(10, dupDetectionDuration.TotalMinutes);
// Default message TTL is TimeSpan.Max, assert parsing
//
Assert.Equal("10675199.02:48:05.4775807", queue.Inner.DefaultMessageTimeToLive);
var msgTtlDuration = queue.DefaultMessageTtlDuration;
// Assert the default ttl TimeSpan("10675199.02:48:05.4775807") parsing
//
Assert.Equal(10675199, msgTtlDuration.Days);
Assert.Equal(2, msgTtlDuration.Hours);
Assert.Equal(48, msgTtlDuration.Minutes);
// Assert the default max size In MB
//
Assert.Equal(1024, queue.MaxSizeInMB);
var queuesInNamespace = nspace.Queues.List();
Assert.NotNull(queuesInNamespace);
Assert.True(queuesInNamespace.Count() > 0);
IQueue foundQueue = queuesInNamespace.FirstOrDefault(q => q.Name.Equals(queueName, StringComparison.OrdinalIgnoreCase));
Assert.NotNull(foundQueue);
// Dead lettering disabled by default
//
Assert.False(foundQueue.IsDeadLetteringEnabledForExpiredMessages);
foundQueue = foundQueue.Update()
.WithMessageLockDurationInSeconds(120)
.WithDefaultMessageTTL(new TimeSpan(0, 20, 0))
.WithExpiredMessageMovedToDeadLetterQueue()
.WithMessageMovedToDeadLetterQueueOnMaxDeliveryCount(25)
.Apply();
Assert.Equal(120, foundQueue.LockDurationInSeconds);
Assert.True(foundQueue.IsDeadLetteringEnabledForExpiredMessages);
Assert.Equal(25, foundQueue.MaxDeliveryCountBeforeDeadLetteringMessage);
queuesInNamespace = nspace.Queues.List();
Assert.NotNull(queuesInNamespace);
Assert.True(queuesInNamespace.Count() > 0);
foundQueue = queuesInNamespace.FirstOrDefault(q => q.Name.Equals(queueName, StringComparison.OrdinalIgnoreCase));
Assert.NotNull(foundQueue);
Assert.Equal(120, foundQueue.LockDurationInSeconds);
Assert.True(foundQueue.IsDeadLetteringEnabledForExpiredMessages);
Assert.Equal(25, foundQueue.MaxDeliveryCountBeforeDeadLetteringMessage);
nspace.Queues.DeleteByName(foundQueue.Name);
}
finally
{
try
{
TestHelper.CreateResourceManager().ResourceGroups.DeleteByName(rgName);
}
catch
{
}
}
}
}
public void CanCreateImageFromNativeVhd()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var vhdBasedImageName = SdkContext.RandomResourceName("img", 20);
var resourceManager = TestHelper.CreateRollupClient();
var computeManager = TestHelper.CreateComputeManager();
var rgName = TestUtilities.GenerateName("rgfluentchash-");
try
{
var linuxVM = PrepareGeneralizedVMWith2EmptyDataDisks(rgName,
SdkContext.RandomResourceName("muldvm", 15),
Location,
computeManager);
//
var creatableDisk = computeManager.VirtualMachineCustomImages.Define(vhdBasedImageName)
.WithRegion(Location)
.WithNewResourceGroup(rgName)
.WithLinuxFromVhd(linuxVM.OSUnmanagedDiskVhdUri, OperatingSystemStateTypes.Generalized)
.WithOSDiskCaching(linuxVM.OSDiskCachingType);
foreach (var disk in linuxVM.UnmanagedDataDisks.Values)
{
creatableDisk.DefineDataDiskImage()
.WithLun(disk.Lun)
.FromVhd(disk.VhdUri)
.WithDiskCaching(disk.CachingType)
.WithDiskSizeInGB(disk.Size + 10) // Resize each data disk image by +10GB
.Attach();
}
var customImage = creatableDisk.Create();
Assert.NotNull(customImage.Id);
Assert.Equal(customImage.Name, vhdBasedImageName);
Assert.False(customImage.IsCreatedFromVirtualMachine);
Assert.Null(customImage.SourceVirtualMachineId);
Assert.NotNull(customImage.OSDiskImage);
Assert.NotNull(customImage.OSDiskImage.BlobUri);
Assert.Equal(CachingTypes.ReadWrite, customImage.OSDiskImage.Caching);
Assert.Equal(OperatingSystemStateTypes.Generalized, customImage.OSDiskImage.OsState);
Assert.Equal(OperatingSystemTypes.Linux, customImage.OSDiskImage.OsType);
Assert.NotNull(customImage.DataDiskImages);
Assert.Equal(customImage.DataDiskImages.Count, linuxVM.UnmanagedDataDisks.Count);
Assert.Equal(customImage.HyperVGeneration, HyperVGenerationTypes.V1);
foreach (ImageDataDisk diskImage in customImage.DataDiskImages.Values)
{
IVirtualMachineUnmanagedDataDisk matchedDisk = null;
foreach (var vmDisk in linuxVM.UnmanagedDataDisks.Values)
{
if (vmDisk.Lun == diskImage.Lun)
{
matchedDisk = vmDisk;
break;
}
}
Assert.NotNull(matchedDisk);
Assert.Equal(matchedDisk.CachingType, diskImage.Caching);
Assert.Equal(matchedDisk.VhdUri, diskImage.BlobUri);
Assert.Equal((long)matchedDisk.Size + 10, (long)diskImage.DiskSizeGB);
}
var image = computeManager
.VirtualMachineCustomImages
.GetByResourceGroup(rgName, vhdBasedImageName);
Assert.NotNull(image);
var images = computeManager
.VirtualMachineCustomImages
.ListByResourceGroup(rgName);
Assert.True(images.Count() > 0);
// Create virtual machine from custom image
//
var virtualMachine = computeManager.VirtualMachines
.Define(SdkContext.RandomResourceName("cusvm", 15))
.WithRegion(Location)
.WithNewResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithLinuxCustomImage(image.Id)
.WithRootUsername("javauser")
.WithRootPassword(TestUtilities.GenerateName("Pa5$"))
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
var dataDisks = virtualMachine.DataDisks;
Assert.NotNull(dataDisks);
Assert.Equal(dataDisks.Count, image.DataDiskImages.Count);
//Create a hyperv Gen2 image
var creatableDiskGen2 = computeManager
.VirtualMachineCustomImages
.Define(vhdBasedImageName + "Gen2")
.WithRegion(Location)
.WithNewResourceGroup(rgName)
.WithHyperVGeneration(HyperVGenerationTypes.V2)
.WithLinuxFromVhd(linuxVM.OSUnmanagedDiskVhdUri, OperatingSystemStateTypes.Generalized)
.WithOSDiskCaching(linuxVM.OSDiskCachingType);
foreach (var disk in linuxVM.UnmanagedDataDisks.Values)
{
creatableDisk.DefineDataDiskImage()
.WithLun(disk.Lun)
.FromVhd(disk.VhdUri)
.WithDiskCaching(disk.CachingType)
.WithDiskSizeInGB(disk.Size + 10) // Resize each data disk image by +10GB
.Attach();
}
IVirtualMachineCustomImage customImageGen2 = creatableDiskGen2.Create();
Assert.NotNull(customImageGen2.Id);
Assert.Equal(customImageGen2.Name, vhdBasedImageName + "Gen2");
Assert.False(customImageGen2.IsCreatedFromVirtualMachine);
Assert.Null(customImageGen2.SourceVirtualMachineId);
Assert.NotNull(customImageGen2.OSDiskImage);
Assert.NotNull(customImageGen2.OSDiskImage);
Assert.Equal(CachingTypes.ReadWrite, customImageGen2.OSDiskImage.Caching);
Assert.Equal(OperatingSystemStateTypes.Generalized, customImageGen2.OSDiskImage.OsState);
Assert.Equal(OperatingSystemTypes.Linux, customImageGen2.OSDiskImage.OsType);
Assert.NotNull(customImageGen2.DataDiskImages);
Assert.Equal(0, customImageGen2.DataDiskImages.Count);
Assert.Equal(customImageGen2.HyperVGeneration, HyperVGenerationTypes.V2);
}
finally
{
try
{
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public void CanCRUDOnSimpleNamespace()
{
using (var context = FluentMockContext.Start(this.GetType().FullName))
{
var rgName = TestUtilities.GenerateName("fluentnetsbmrg");
try
{
var resourceManager = TestHelper.CreateResourceManager();
var serviceBusManager = TestHelper.CreateServiceBusManager();
Region region = Region.USEast;
var rgCreatable = resourceManager.ResourceGroups
.Define(rgName)
.WithRegion(region);
var namespaceDNSLabel = TestUtilities.GenerateName("netsbns");
var nspace = serviceBusManager.Namespaces
.Define(namespaceDNSLabel)
.WithRegion(region)
.WithNewResourceGroup(rgCreatable)
.WithSku(NamespaceSku.Basic)
.Create();
var namespaces = serviceBusManager.Namespaces.ListByResourceGroup(rgName);
Assert.NotNull(namespaces);
Assert.True(namespaces.Count() > 0);
var found = namespaces.Any(n => n.Name.Equals(nspace.Name, StringComparison.OrdinalIgnoreCase));
Assert.True(found);
Assert.NotNull(nspace.DnsLabel);
Assert.Equal(nspace.DnsLabel, namespaceDNSLabel, ignoreCase: true);
Assert.NotNull(nspace.Fqdn);
Assert.Contains(namespaceDNSLabel, nspace.Fqdn);
Assert.NotNull(nspace.Sku);
Assert.True(nspace.Sku.Name.Equals(NamespaceSku.Basic.Name));
Assert.NotNull(nspace.Region);
Assert.True(nspace.Region.Equals(region));
Assert.NotNull(nspace.ResourceGroupName);
Assert.Equal(nspace.ResourceGroupName, rgName, ignoreCase: true);
Assert.NotNull(nspace.Queues);
Assert.Empty(nspace.Queues.List());
Assert.NotNull(nspace.Topics);
Assert.Empty(nspace.Topics.List());
Assert.NotNull(nspace.AuthorizationRules);
var defaultNsRules = nspace.AuthorizationRules.List();
Assert.Single(defaultNsRules);
var defaultNsRule = defaultNsRules.ElementAt(0);
Assert.Equal("RootManageSharedAccessKey", defaultNsRule.Name, ignoreCase: true);
Assert.NotNull(defaultNsRule.Rights);
Assert.NotNull(defaultNsRule.NamespaceName);
Assert.Equal(defaultNsRule.NamespaceName, namespaceDNSLabel, ignoreCase: true);
Assert.NotNull(defaultNsRule.ResourceGroupName);
Assert.Equal(defaultNsRule.ResourceGroupName, rgName, ignoreCase: true);
nspace.Update()
.WithSku(NamespaceSku.Standard)
.Apply();
Assert.True(nspace.Sku.Name.Equals(NamespaceSku.Standard.Name));
// TODO: There is a bug in LRO implementation of ServiceBusNamespace DELETE operation (Last poll returns 404, reported this to RP]
//
// serviceBusManager.Namespaces.DeleteByGroup(rgName, nspace.Name);
}
finally
{
try
{
TestHelper.CreateResourceManager().ResourceGroups.DeleteByName(rgName);
}
catch
{
}
}
}
}
public void CanAssignRoles()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var rgName = TestUtilities.GenerateName("rgmsi");
var identityName = TestUtilities.GenerateName("msitest");
var anotherRgName = TestUtilities.GenerateName("rg");
try
{
var azure = TestHelper.CreateRollupClient();
var anotherResourceGroup = azure.ResourceGroups
.Define(anotherRgName)
.WithRegion(region)
.Create();
var creatableRG = azure.ResourceGroups
.Define(rgName)
.WithRegion(region);
var identity = azure.Identities
.Define(identityName)
.WithRegion(region)
.WithNewResourceGroup(creatableRG)
.WithAccessToCurrentResourceGroup(BuiltInRole.Reader)
.WithAccessTo(anotherResourceGroup, BuiltInRole.Contributor)
.Create();
Assert.NotNull(identity);
Assert.NotNull(identity.Inner);
// Ensure roles are assigned
//
var resourceGroup = azure.ResourceGroups.GetByName(identity.ResourceGroupName);
var roleAssignments = azure.Identities.Manager.GraphRbacManager.RoleAssignments.ListByScope(resourceGroup.Id);
bool found = false;
foreach (var roleAssignment in roleAssignments)
{
if (roleAssignment.PrincipalId != null && roleAssignment.PrincipalId.Equals(identity.PrincipalId, StringComparison.OrdinalIgnoreCase))
{
found = true;
break;
}
}
Assert.True(found, "Expected role assignment not found for the resource group that identity belongs to");
roleAssignments = azure.Identities.Manager.GraphRbacManager.RoleAssignments.ListByScope(anotherResourceGroup.Id);
found = false;
foreach (var roleAssignment in roleAssignments)
{
if (roleAssignment.PrincipalId != null && roleAssignment.PrincipalId.Equals(identity.PrincipalId, StringComparison.OrdinalIgnoreCase))
{
found = true;
break;
}
}
Assert.True(found, "Expected role assignment not found for the resource group resource");
identity = identity
.Update()
.WithTag("a", "bb")
.Apply();
Assert.NotNull(identity.Tags);
Assert.True(identity.Tags.ContainsKey("a"));
}
finally
{
try
{
var resourceManager = TestHelper.CreateResourceManager();
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public void CanAssignCurrentResourceGroupAccessRole()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var rgName = TestUtilities.GenerateName("rgmsi");
var identityName = TestUtilities.GenerateName("msitest");
try
{
var azure = TestHelper.CreateRollupClient();
var creatableRG = azure.ResourceGroups
.Define(rgName)
.WithRegion(region);
var identity = azure.Identities
.Define(identityName)
.WithRegion(region)
.WithNewResourceGroup(creatableRG)
.WithAccessToCurrentResourceGroup(BuiltInRole.Reader)
.Create();
// Ensure role assigned
//
var resourceGroup = azure.ResourceGroups.GetByName(identity.ResourceGroupName);
var roleAssignments = azure.Identities.Manager.GraphRbacManager
.RoleAssignments
.ListByScope(resourceGroup.Id);
var found = false;
foreach (var roleAssignment in roleAssignments)
{
if (roleAssignment.PrincipalId != null && roleAssignment.PrincipalId.Equals(identity.PrincipalId, StringComparison.OrdinalIgnoreCase))
{
found = true;
break;
}
}
Assert.True(found, "Expected role assignment not found for the resource group that identity belongs to");
identity.Update()
.WithoutAccessTo(resourceGroup.Id, BuiltInRole.Reader)
.Apply();
SdkContext.DelayProvider.Delay(30 * 1000);
// Ensure role assignment removed
//
roleAssignments = azure.Identities.Manager.GraphRbacManager
.RoleAssignments
.ListByScope(resourceGroup.Id);
bool notFound = true;
foreach (var roleAssignment in roleAssignments)
{
if (roleAssignment.PrincipalId != null && roleAssignment.PrincipalId.Equals(identity.PrincipalId, StringComparison.OrdinalIgnoreCase))
{
notFound = false;
break;
}
}
Assert.True(notFound, "Role assignment to access resource group is not removed");
azure.Identities.DeleteById(identity.Id);
}
finally
{
try
{
var resourceManager = TestHelper.CreateResourceManager();
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public void CanCheckAvailabilityAndCreate()
{
using (var context = FluentMockContext.Start(this.GetType().FullName))
{
var rgName = TestUtilities.GenerateName("rgstg");
var stgName = TestUtilities.GenerateName("stgbnx");
try
{
var storageManager = TestHelper.CreateStorageManager();
var availabilityResult = storageManager
.StorageAccounts
.CheckNameAvailability(stgName);
Assert.NotNull(availabilityResult);
Assert.True(availabilityResult.IsAvailable);
var storageAccount = storageManager.StorageAccounts.Define(stgName)
.WithRegion(Region.USEast2)
.WithNewResourceGroup(rgName)
.WithTag("aa", "aa")
.WithTag("bb", "bb")
.Create();
Assert.NotNull(storageAccount);
Assert.NotNull(storageAccount.Inner);
// Check the defaults
//
Assert.Equal(SkuName.StandardGRS, storageAccount.Sku.Name);
Assert.Equal(Kind.Storage, storageAccount.Kind);
//
Assert.NotNull(storageAccount.Tags);
Assert.Equal(2, storageAccount.Tags.Count());
Assert.NotNull(storageAccount);
Assert.NotNull(storageAccount.Inner);
availabilityResult = storageManager
.StorageAccounts
.CheckNameAvailability(stgName);
Assert.NotNull(availabilityResult);
Assert.False(availabilityResult.IsAvailable);
Assert.NotNull(availabilityResult.Reason);
// Get
storageAccount = storageManager.StorageAccounts.GetByResourceGroup(rgName, stgName);
Assert.NotNull(storageAccount);
Assert.NotNull(storageAccount.Inner);
}
finally
{
try
{
TestHelper.CreateResourceManager().ResourceGroups.BeginDeleteByName(rgName);
}
catch { }
}
}
}
public void CreateUpdate()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
string groupName = SdkContext.RandomResourceName("rg", 10);
string clusterName = SdkContext.RandomResourceName("cluster", 15);
string saName = SdkContext.RandomResourceName("sa", 15);
string shareName = "myfileshare";
string shareMountPath = "azurefileshare";
string blobFileSystemPath = "myblobsystem";
string containerName = "mycontainer";
string userName = "******";
string storageAccountKey = "dummy_key";
string fileShareUri = "dummy_uri";
var manager = TestHelper.CreateBatchAIManager();
IBatchAICluster cluster = manager.BatchAIClusters.Define(clusterName)
.WithRegion(REGION)
.WithNewResourceGroup(groupName)
.WithVMSize(VirtualMachineSizeTypes.StandardD1V2.Value)
.WithUserName(userName)
.WithPassword("MyPassword")
.WithAutoScale(1, 1)
.WithLowPriority()
.DefineSetupTask()
.WithCommandLine("echo Hello World!")
.WithStdOutErrPath("./outputpath")
.Attach()
.DefineAzureFileShare()
.WithStorageAccountName(saName)
.WithAzureFileUrl(fileShareUri)
.WithRelativeMountPath(shareMountPath)
.WithAccountKey(storageAccountKey)
.Attach()
.DefineAzureBlobFileSystem()
.WithStorageAccountName(saName)
.WithContainerName(containerName)
.WithRelativeMountPath(blobFileSystemPath)
.WithAccountKey(storageAccountKey)
.Attach()
.WithTag("tag1", "value1")
.Create();
Assert.Equal(AllocationState.Steady, cluster.AllocationState);
Assert.Equal(userName, cluster.AdminUserName);
Assert.Equal(VmPriority.Lowpriority, cluster.VMPriority);
Assert.Equal(1, cluster.NodeSetup.MountVolumes.AzureFileShares.Count);
Assert.Equal(shareMountPath, cluster.NodeSetup.MountVolumes.AzureFileShares.ElementAt(0).RelativeMountPath);
Assert.Equal(1, cluster.NodeSetup.MountVolumes.AzureBlobFileSystems.Count);
Assert.Equal(blobFileSystemPath, cluster.NodeSetup.MountVolumes.AzureBlobFileSystems.ElementAt(0).RelativeMountPath);
cluster.Update()
.WithAutoScale(1, 2, 2)
.WithTag("tag1", "value2")
.Apply();
Assert.Equal(2, cluster.ScaleSettings.AutoScale.MaximumNodeCount);
string tag1;
Assert.True(cluster.Tags.TryGetValue("tag1", out tag1));
Assert.Equal("value2", tag1);
manager.ResourceManager.ResourceGroups.DeleteByName(groupName);
}
}
public void CanUpdateEMSIAndLMSI()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var region = Region.USSouthCentral;
var vmssName = "javavm";
var groupName = TestUtilities.GenerateName("rgmsi");
String identityName1 = TestUtilities.GenerateName("msi-id");
String identityName2 = TestUtilities.GenerateName("msi-id");
IAzure azure = null;
try
{
azure = TestHelper.CreateRollupClient();
// Prepare a definition for yet-to-be-created resource group
//
var resourceGroup = azure.ResourceGroups
.Define(groupName)
.WithRegion(region)
.Create();
// Create a virtual network for VMSS
//
var vmssNetwork = azure
.Networks
.Define("vmssvnet")
.WithRegion(region)
.WithExistingResourceGroup(resourceGroup)
.WithAddressSpace("10.0.0.0/28")
.WithSubnet("subnet1", "10.0.0.0/28")
.Create();
// Create a Load balancer for VMSS
//
var vmssInternalLoadBalancer = CreateInternalLoadBalancer(azure,
resourceGroup,
vmssNetwork,
"1",
region);
var virtualMachineScaleSet = azure.VirtualMachineScaleSets
.Define(vmssName)
.WithRegion(region)
.WithExistingResourceGroup(resourceGroup)
.WithSku(VirtualMachineScaleSetSkuTypes.StandardA0)
.WithExistingPrimaryNetworkSubnet(vmssNetwork, "subnet1")
.WithoutPrimaryInternetFacingLoadBalancer()
.WithExistingPrimaryInternalLoadBalancer(vmssInternalLoadBalancer)
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername("jvuser")
.WithRootPassword(TestUtilities.GenerateName("Pa5$"))
.Create();
// Prepare a definition for yet-to-be-created "User Assigned (External) MSI" with contributor access to the resource group
// it resides
//
var creatableIdentity = azure.Identities
.Define(identityName1)
.WithRegion(region)
.WithExistingResourceGroup(virtualMachineScaleSet.ResourceGroupName)
.WithAccessToCurrentResourceGroup(BuiltInRole.Contributor);
// Update virtual machine so that it depends on the EMSI
//
virtualMachineScaleSet = virtualMachineScaleSet.Update()
.WithNewUserAssignedManagedServiceIdentity(creatableIdentity)
.Apply();
// Ensure the "User Assigned (External) MSI" id can be retrieved from the virtual machine
//
ISet <string> emsiIds = virtualMachineScaleSet.UserAssignedManagedServiceIdentityIds;
Assert.NotNull(emsiIds);
Assert.Equal(1, emsiIds.Count);
var identity = azure.Identities.GetById(emsiIds.First());
Assert.NotNull(identity);
Assert.Equal(identity.Name, identityName1, ignoreCase: true);
var createdIdentity = azure.Identities
.Define(identityName2)
.WithRegion(region)
.WithExistingResourceGroup(virtualMachineScaleSet.ResourceGroupName)
.WithAccessToCurrentResourceGroup(BuiltInRole.Contributor)
.Create();
// Update the virtual machine by removing the an EMSI and adding existing EMSI
//
virtualMachineScaleSet = virtualMachineScaleSet.Update()
.WithoutUserAssignedManagedServiceIdentity(identity.Id)
.WithExistingUserAssignedManagedServiceIdentity(createdIdentity)
.Apply();
// Ensure the "User Assigned (External) MSI" id can be retrieved from the virtual machine
//
emsiIds = virtualMachineScaleSet.UserAssignedManagedServiceIdentityIds;
Assert.NotNull(emsiIds);
Assert.Single(emsiIds);
identity = azure.Identities.GetById(emsiIds.First());
Assert.NotNull(identity);
Assert.Equal(identity.Name, identityName2, ignoreCase: true);
// Update the virtual machine by enabling "LMSI"
virtualMachineScaleSet
.Update()
.WithSystemAssignedManagedServiceIdentity()
.Apply();
Assert.NotNull(virtualMachineScaleSet);
Assert.NotNull(virtualMachineScaleSet.Inner);
Assert.True(virtualMachineScaleSet.IsManagedServiceIdentityEnabled);
Assert.NotNull(virtualMachineScaleSet.SystemAssignedManagedServiceIdentityPrincipalId);
Assert.NotNull(virtualMachineScaleSet.SystemAssignedManagedServiceIdentityTenantId);
}
finally
{
try
{
if (azure != null)
{
azure.ResourceGroups.BeginDeleteByName(groupName);
}
}
catch { }
}
}
}
public void CanCRUDSecret()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
IGraphRbacManager graphManager = TestHelper.CreateGraphRbacManager();
string vaultName1 = TestUtilities.GenerateName("vault1");
string secretName = TestUtilities.GenerateName("secret1");
string rgName = TestUtilities.GenerateName("rgNEMV");
IKeyVaultManager manager = TestHelper.CreateKeyVaultManager();
var spnCredentialsClientId = HttpMockServer.Variables[ConnectionStringKeys.ServicePrincipalKey];
try
{
IVault vault = manager.Vaults
.Define(vaultName1)
.WithRegion(Region.USWest)
.WithNewResourceGroup(rgName)
.DefineAccessPolicy()
.ForServicePrincipal(spnCredentialsClientId)
.AllowKeyAllPermissions()
.AllowSecretAllPermissions()
.Attach()
.Create();
Assert.NotNull(vault);
SdkContext.DelayProvider.Delay(10000);
var secret = vault.Secrets.Define(secretName)
.WithValue("Some secret value")
.Create();
Assert.NotNull(secret);
Assert.NotNull(secret.Id);
Assert.Equal("Some secret value", secret.Value);
secret = secret.Update()
.WithValue("Some updated value")
.Apply();
Assert.Equal("Some updated value", secret.Value);
var versions = secret.ListVersions();
int count = 2;
foreach (var version in versions)
{
if ("Some secret value" == version.Value)
{
count--;
}
if ("Some updated value" == version.Value)
{
count--;
}
}
Assert.Equal(0, count);
}
finally
{
try
{
TestHelper.CreateResourceManager().ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public void CanCreateWithEMSI()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var region = Region.USSouthCentral;
var vmssName = "javavm";
var groupName = TestUtilities.GenerateName("rgmsi");
String identityName1 = TestUtilities.GenerateName("msi-id");
String identityName2 = TestUtilities.GenerateName("msi-id");
String networkName = TestUtilities.GenerateName("nw");
IAzure azure = null;
try
{
azure = TestHelper.CreateRollupClient();
// Prepare a definition for yet-to-be-created resource group
//
var resourceGroup = azure.ResourceGroups
.Define(groupName)
.WithRegion(region)
.Create();
// Create a virtual network residing in the above RG
//
var network = azure.Networks
.Define(networkName)
.WithRegion(region)
.WithExistingResourceGroup(resourceGroup)
.Create();
// Create an "User Assigned (External) MSI" residing in the above RG and assign reader access to the virtual network
//
var createdIdentity = azure.Identities
.Define(identityName1)
.WithRegion(region)
.WithExistingResourceGroup(resourceGroup)
.WithAccessTo(network, BuiltInRole.Reader)
.Create();
// Prepare a definition for yet-to-be-created "User Assigned (External) MSI" with contributor access to the resource group
// it resides
//
var creatableIdentity = azure.Identities
.Define(identityName2)
.WithRegion(region)
.WithExistingResourceGroup(resourceGroup)
.WithAccessToCurrentResourceGroup(BuiltInRole.Contributor);
// Create a virtual network for VMSS
//
var vmssNetwork = azure
.Networks
.Define("vmssvnet")
.WithRegion(region)
.WithExistingResourceGroup(resourceGroup)
.WithAddressSpace("10.0.0.0/28")
.WithSubnet("subnet1", "10.0.0.0/28")
.Create();
// Create a Load balancer for VMSS
//
var vmssInternalLoadBalancer = CreateInternalLoadBalancer(azure,
resourceGroup,
vmssNetwork,
"1",
region);
var virtualMachineScaleSet = azure.VirtualMachineScaleSets
.Define(vmssName)
.WithRegion(region)
.WithExistingResourceGroup(resourceGroup)
.WithSku(VirtualMachineScaleSetSkuTypes.StandardA0)
.WithExistingPrimaryNetworkSubnet(vmssNetwork, "subnet1")
.WithoutPrimaryInternetFacingLoadBalancer()
.WithExistingPrimaryInternalLoadBalancer(vmssInternalLoadBalancer)
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername("jvuser")
.WithRootPassword(TestUtilities.GenerateName("Pa5$"))
.WithExistingUserAssignedManagedServiceIdentity(createdIdentity)
.WithNewUserAssignedManagedServiceIdentity(creatableIdentity)
.Create();
Assert.NotNull(virtualMachineScaleSet);
Assert.NotNull(virtualMachineScaleSet.Inner);
Assert.True(virtualMachineScaleSet.IsManagedServiceIdentityEnabled);
Assert.Null(virtualMachineScaleSet.SystemAssignedManagedServiceIdentityPrincipalId); // No Local MSI enabled
Assert.Null(virtualMachineScaleSet.SystemAssignedManagedServiceIdentityTenantId); // No Local MSI enabled
// Ensure the "User Assigned (External) MSI" id can be retrieved from the VMSS
//
var emsiIds = virtualMachineScaleSet.UserAssignedManagedServiceIdentityIds;
Assert.NotNull(emsiIds);
Assert.Equal(2, emsiIds.Count);
// Ensure the "User Assigned (External) MSI"s matches with the those provided as part of VMSS create
//
IIdentity implicitlyCreatedIdentity = null;
foreach (var emsiId in emsiIds)
{
var identity = azure.Identities.GetById(emsiId);
Assert.NotNull(identity);
Assert.True(identity.Name.Equals(identityName1, StringComparison.OrdinalIgnoreCase) ||
identity.Name.Equals(identityName2, StringComparison.OrdinalIgnoreCase));
Assert.NotNull(identity.PrincipalId);
if (identity.Name.Equals(identityName2, StringComparison.OrdinalIgnoreCase))
{
implicitlyCreatedIdentity = identity;
}
}
Assert.NotNull(implicitlyCreatedIdentity);
// Ensure expected role assignment exists for explicitly created EMSI
//
var roleAssignmentsForNetwork = azure
.AccessManagement
.RoleAssignments
.ListByScope(network.Id);
bool found = roleAssignmentsForNetwork.Any(r => r.PrincipalId != null && r.PrincipalId.Equals(createdIdentity.PrincipalId, StringComparison.OrdinalIgnoreCase));
Assert.True(found, $"Expected role assignment not found for the virtual network for identity {createdIdentity.Name}");
var assignment = LookupRoleAssignmentUsingScopeAndRole(network.Id, BuiltInRole.Reader, createdIdentity.PrincipalId, azure);
Assert.False(assignment == null, "Expected role assignment with ROLE not found for the virtual network for identity");
// Ensure expected role assignment exists for explicitly created EMSI
//
var roleAssignmentsForResourceGroup = azure
.AccessManagement
.RoleAssignments
.ListByScope(resourceGroup.Id);
found = roleAssignmentsForResourceGroup.Any(r => r.PrincipalId != null && r.PrincipalId.Equals(implicitlyCreatedIdentity.PrincipalId, StringComparison.OrdinalIgnoreCase));
Assert.True(found, $"Expected role assignment not found for the resource group for identity{implicitlyCreatedIdentity.Name}");
assignment = LookupRoleAssignmentUsingScopeAndRole(resourceGroup.Id, BuiltInRole.Contributor, implicitlyCreatedIdentity.PrincipalId, azure);
Assert.False(assignment == null, "Expected role assignment with ROLE not found for the resource group for identity");
emsiIds = virtualMachineScaleSet.UserAssignedManagedServiceIdentityIds;
// Remove both (all) identities
virtualMachineScaleSet.Update()
.WithoutUserAssignedManagedServiceIdentity(emsiIds.ElementAt(0))
.WithoutUserAssignedManagedServiceIdentity(emsiIds.ElementAt(1))
.Apply();
//
Assert.Equal(0, virtualMachineScaleSet.UserAssignedManagedServiceIdentityIds.Count);
if (virtualMachineScaleSet.ManagedServiceIdentityType != null)
{
Assert.True(virtualMachineScaleSet.ManagedServiceIdentityType.Equals(ResourceIdentityType.None));
}
// fetch vm again and validate
virtualMachineScaleSet.Refresh();
//
Assert.Equal(0, virtualMachineScaleSet.UserAssignedManagedServiceIdentityIds.Count);
if (virtualMachineScaleSet.ManagedServiceIdentityType != null)
{
Assert.True(virtualMachineScaleSet.ManagedServiceIdentityType.Equals(ResourceIdentityType.None));
}
//
//
var identity1 = azure.Identities.GetById(emsiIds.ElementAt(0));
var identity2 = azure.Identities.GetById(emsiIds.ElementAt(1));
//
// Update VM by enabling System-MSI and add two identities
virtualMachineScaleSet.Update()
.WithSystemAssignedManagedServiceIdentity()
.WithExistingUserAssignedManagedServiceIdentity(identity1)
.WithExistingUserAssignedManagedServiceIdentity(identity2)
.Apply();
Assert.NotNull(virtualMachineScaleSet.UserAssignedManagedServiceIdentityIds);
Assert.Equal(2, virtualMachineScaleSet.UserAssignedManagedServiceIdentityIds.Count);
Assert.NotNull(virtualMachineScaleSet.ManagedServiceIdentityType);
Assert.True(virtualMachineScaleSet.ManagedServiceIdentityType.Equals(ResourceIdentityType.SystemAssignedUserAssigned));
//
Assert.NotNull(virtualMachineScaleSet.SystemAssignedManagedServiceIdentityPrincipalId);
Assert.NotNull(virtualMachineScaleSet.SystemAssignedManagedServiceIdentityTenantId);
//
virtualMachineScaleSet.Refresh();
Assert.NotNull(virtualMachineScaleSet.UserAssignedManagedServiceIdentityIds);
Assert.Equal(2, virtualMachineScaleSet.UserAssignedManagedServiceIdentityIds.Count);
Assert.NotNull(virtualMachineScaleSet.ManagedServiceIdentityType);
Assert.True(virtualMachineScaleSet.ManagedServiceIdentityType.Equals(ResourceIdentityType.SystemAssignedUserAssigned));
//
Assert.NotNull(virtualMachineScaleSet.SystemAssignedManagedServiceIdentityPrincipalId);
Assert.NotNull(virtualMachineScaleSet.SystemAssignedManagedServiceIdentityTenantId);
//
// Remove identities one by one (first one)
virtualMachineScaleSet.Update()
.WithoutUserAssignedManagedServiceIdentity(emsiIds.ElementAt(0))
.Apply();
//
Assert.NotNull(virtualMachineScaleSet.UserAssignedManagedServiceIdentityIds);
Assert.Equal(1, virtualMachineScaleSet.UserAssignedManagedServiceIdentityIds.Count);
Assert.NotNull(virtualMachineScaleSet.ManagedServiceIdentityType);
Assert.True(virtualMachineScaleSet.ManagedServiceIdentityType.Equals(ResourceIdentityType.SystemAssignedUserAssigned));
Assert.NotNull(virtualMachineScaleSet.SystemAssignedManagedServiceIdentityPrincipalId);
Assert.NotNull(virtualMachineScaleSet.SystemAssignedManagedServiceIdentityTenantId);
// Remove identities one by one (second one)
virtualMachineScaleSet
.Update()
.WithoutUserAssignedManagedServiceIdentity(emsiIds.ElementAt(1))
.Apply();
//
Assert.Equal(0, virtualMachineScaleSet.UserAssignedManagedServiceIdentityIds.Count);
Assert.NotNull(virtualMachineScaleSet.ManagedServiceIdentityType);
Assert.True(virtualMachineScaleSet.ManagedServiceIdentityType.Equals(ResourceIdentityType.SystemAssigned));
//
virtualMachineScaleSet
.Update()
.WithoutSystemAssignedManagedServiceIdentity()
.Apply();
Assert.Equal(0, virtualMachineScaleSet.UserAssignedManagedServiceIdentityIds.Count);
if (virtualMachineScaleSet.ManagedServiceIdentityType != null)
{
Assert.True(virtualMachineScaleSet.ManagedServiceIdentityType.Equals(ResourceIdentityType.None));
}
Assert.Null(virtualMachineScaleSet.SystemAssignedManagedServiceIdentityPrincipalId);
Assert.Null(virtualMachineScaleSet.SystemAssignedManagedServiceIdentityTenantId);
}
finally
{
try
{
if (azure != null)
{
azure.ResourceGroups.BeginDeleteByName(groupName);
}
}
catch { }
}
}
}
public void CanCreateWithLMSIAndEMSI()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var region = Region.USSouthCentral;
var vmssName = "javavm";
var groupName = TestUtilities.GenerateName("rgmsi");
String identityName1 = TestUtilities.GenerateName("msi-id");
String networkName = TestUtilities.GenerateName("nw");
IAzure azure = null;
try
{
azure = TestHelper.CreateRollupClient();
// Prepare a definition for yet-to-be-created resource group
//
var resourceGroup = azure.ResourceGroups
.Define(groupName)
.WithRegion(region)
.Create();
// Create a virtual network residing in the above RG
//
var network = azure.Networks
.Define(networkName)
.WithRegion(region)
.WithExistingResourceGroup(resourceGroup)
.Create();
// Prepare a definition for yet-to-be-created "User Assigned (External) MSI" with contributor access to the resource group
// it resides
//
var creatableIdentity = azure.Identities
.Define(identityName1)
.WithRegion(region)
.WithExistingResourceGroup(resourceGroup)
.WithAccessToCurrentResourceGroup(BuiltInRole.Contributor);
// Create a virtual network for VMSS
//
var vmssNetwork = azure
.Networks
.Define("vmssvnet")
.WithRegion(region)
.WithExistingResourceGroup(resourceGroup)
.WithAddressSpace("10.0.0.0/28")
.WithSubnet("subnet1", "10.0.0.0/28")
.Create();
// Create a Load balancer for VMSS
//
var vmssInternalLoadBalancer = CreateInternalLoadBalancer(azure,
resourceGroup,
vmssNetwork,
"1",
region);
var virtualMachineScaleSet = azure.VirtualMachineScaleSets
.Define(vmssName)
.WithRegion(region)
.WithExistingResourceGroup(resourceGroup)
.WithSku(VirtualMachineScaleSetSkuTypes.StandardA0)
.WithExistingPrimaryNetworkSubnet(vmssNetwork, "subnet1")
.WithoutPrimaryInternetFacingLoadBalancer()
.WithExistingPrimaryInternalLoadBalancer(vmssInternalLoadBalancer)
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername("jvuser")
.WithRootPassword(TestUtilities.GenerateName("Pa5$"))
.WithSystemAssignedManagedServiceIdentity()
.WithSystemAssignedIdentityBasedAccessTo(network.Id, BuiltInRole.Contributor)
.WithNewUserAssignedManagedServiceIdentity(creatableIdentity)
.Create();
Assert.NotNull(virtualMachineScaleSet);
Assert.NotNull(virtualMachineScaleSet.Inner);
Assert.True(virtualMachineScaleSet.IsManagedServiceIdentityEnabled);
Assert.NotNull(virtualMachineScaleSet.SystemAssignedManagedServiceIdentityPrincipalId);
Assert.NotNull(virtualMachineScaleSet.SystemAssignedManagedServiceIdentityTenantId);
// Ensure the "User Assigned (External) MSI" id can be retrieved from the virtual machine
//
ISet <string> emsiIds = virtualMachineScaleSet.UserAssignedManagedServiceIdentityIds;
Assert.NotNull(emsiIds);
Assert.Equal(1, emsiIds.Count);
var identity = azure.Identities.GetById(emsiIds.First());
Assert.NotNull(identity);
Assert.Equal(identity.Name, identityName1, ignoreCase: true);
// Ensure expected role assignment exists for LMSI
//
var roleAssignmentsForNetwork = azure
.AccessManagement
.RoleAssignments
.ListByScope(network.Id);
bool found = roleAssignmentsForNetwork.Any(r => r.PrincipalId != null && r.PrincipalId.Equals(virtualMachineScaleSet.SystemAssignedManagedServiceIdentityPrincipalId, StringComparison.OrdinalIgnoreCase));
Assert.True(found, $"Expected role assignment not found for the virtual network for local identity {virtualMachineScaleSet.SystemAssignedManagedServiceIdentityPrincipalId}");
var assignment = LookupRoleAssignmentUsingScopeAndRole(network.Id, BuiltInRole.Contributor, virtualMachineScaleSet.SystemAssignedManagedServiceIdentityPrincipalId, azure);
Assert.False(assignment == null, $"Expected role assignment with ROLE {BuiltInRole.Contributor} not found for the virtual network for identity");
var roleAssignmentsForResourceGroup = azure
.AccessManagement
.RoleAssignments
.ListByScope(resourceGroup.Id);
found = roleAssignmentsForResourceGroup.Any(r => r.PrincipalId != null && r.PrincipalId.Equals(identity.PrincipalId, StringComparison.OrdinalIgnoreCase));
Assert.True(found, $"Expected role assignment not found for the resource group for identity {identity.Name}");
assignment = LookupRoleAssignmentUsingScopeAndRole(resourceGroup.Id, BuiltInRole.Contributor, identity.PrincipalId, azure);
Assert.False(assignment == null, $"Expected role assignment with ROLE {BuiltInRole.Contributor} not found for the resource group for system assigned identity");
}
finally
{
try
{
if (azure != null)
{
azure.ResourceGroups.BeginDeleteByName(groupName);
}
}
catch { }
}
}
}
public void CanCreateUpdateFromPIRWithManagedDisk()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var vmssName = SdkContext.RandomResourceName("vmss", 10);
var resourceManager = TestHelper.CreateRollupClient();
var computeManager = TestHelper.CreateComputeManager();
var networkManager = TestHelper.CreateNetworkManager();
var rgName = TestUtilities.GenerateName("rgfluentchash-");
try
{
var resourceGroup = resourceManager.ResourceGroups
.Define(rgName)
.WithRegion(Location)
.Create();
var network = networkManager
.Networks
.Define(SdkContext.RandomResourceName("vmssvnet", 15))
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithAddressSpace("10.0.0.0/28")
.WithSubnet("subnet1", "10.0.0.0/28")
.Create();
var publicLoadBalancer = ScaleSet.CreateHttpLoadBalancers(resourceManager, resourceGroup, "1", Location);
var vmScaleSet = computeManager.VirtualMachineScaleSets
.Define(vmssName)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithSku(VirtualMachineScaleSetSkuTypes.StandardD5v2)
.WithExistingPrimaryNetworkSubnet(network, "subnet1")
.WithExistingPrimaryInternetFacingLoadBalancer(publicLoadBalancer)
.WithoutPrimaryInternalLoadBalancer()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername("jvuser")
.WithRootPassword("123OData!@#123")
.WithNewDataDisk(100)
.WithNewDataDisk(100, 1, CachingTypes.ReadWrite)
.WithNewDataDisk(100, 2, CachingTypes.ReadOnly)
.Create();
var virtualMachineScaleSetVMs = vmScaleSet.VirtualMachines;
var virtualMachines = virtualMachineScaleSetVMs.List();
Assert.Equal(virtualMachines.Count(), vmScaleSet.Capacity);
foreach (var vm in virtualMachines)
{
Assert.True(vm.IsOSBasedOnPlatformImage);
Assert.False(vm.IsOSBasedOnCustomImage);
Assert.False(vm.IsOSBasedOnStoredImage);
Assert.True(vm.IsManagedDiskEnabled);
Assert.NotNull(vm.UnmanagedDataDisks);
Assert.Empty(vm.UnmanagedDataDisks);
Assert.NotNull(vm.DataDisks);
Assert.Equal(3, vm.DataDisks.Count);
}
vmScaleSet.Update()
.WithoutDataDisk(0)
.WithNewDataDisk(50)
.Apply();
virtualMachineScaleSetVMs = vmScaleSet.VirtualMachines;
virtualMachines = virtualMachineScaleSetVMs.List();
Assert.Equal(virtualMachines.Count(), vmScaleSet.Capacity);
foreach (var vm in virtualMachines)
{
Assert.NotNull(vm.DataDisks);
Assert.Equal(3, vm.DataDisks.Count);
}
}
finally
{
try
{
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public void CanCRUDGroup()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
IGraphRbacManager manager = TestHelper.CreateGraphRbacManager();
var userName = SdkContext.RandomResourceName("user", 16);
var spName = SdkContext.RandomResourceName("sp", 16);
var group1Name = SdkContext.RandomResourceName("group", 16);
var group2Name = SdkContext.RandomResourceName("group", 16);
IActiveDirectoryUser user = null;
IServicePrincipal servicePrincipal = null;
IActiveDirectoryGroup group1 = null;
IActiveDirectoryGroup group2 = null;
try
{
user = manager.Users.Define(userName)
.WithEmailAlias(userName)
.WithPassword("StrongPass!123")
.Create();
servicePrincipal = manager.ServicePrincipals.Define(spName)
.WithNewApplication("https://" + spName)
.Create();
group1 = manager.Groups.Define(group1Name)
.WithEmailAlias(group1Name)
.Create();
SdkContext.DelayProvider.Delay(15000);
group2 = manager.Groups.Define(group2Name)
.WithEmailAlias(group2Name)
.WithMember(user.Id)
.WithMember(servicePrincipal.Id)
.WithMember(group1.Id)
.Create();
Assert.NotNull(group2);
Assert.NotNull(group2.Id);
var members = group2.ListMembers();
Assert.Equal(3, members.Count());
var enumerator = members.GetEnumerator();
Assert.True(enumerator.MoveNext());
Assert.NotNull(enumerator.Current.Id);
Assert.True(enumerator.MoveNext());
Assert.NotNull(enumerator.Current.Id);
Assert.True(enumerator.MoveNext());
Assert.NotNull(enumerator.Current.Id);
Assert.False(enumerator.MoveNext());
}
finally
{
if (servicePrincipal != null)
{
manager.ServicePrincipals.DeleteById(servicePrincipal.Id);
}
// cannot delete users or groups from service principal
// if (user != null) {
// manager.Users.DeleteById(user.Id);
// }
// if (group != null) {
// manager.Groups.DeleteById(group.Id);
// }
}
}
}
public void CanCreateUpdateGetDeleteGalleryImageVersion()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
Region region = Region.USWestCentral;
string rgName = TestUtilities.GenerateName("vmexttest");
string galleryName = TestUtilities.GenerateName("jsim");
string galleryImageName = "SampleImages";
var azure = TestHelper.CreateRollupClient();
try
{
IGallery gallery = azure.Galleries.Define(galleryName)
.WithRegion(region)
.WithNewResourceGroup(rgName)
.WithDescription("java's image gallery")
.Create();
//
// Create an image in the gallery (a container to hold custom linux image)
//
IGalleryImage galleryImage = azure.GalleryImages.Define(galleryImageName)
.WithExistingGallery(gallery)
.WithLocation(region)
.WithIdentifier("JavaSDKTeam", "JDK", "Jdk-9")
.WithGeneralizedLinux()
.Create();
//
// Create a custom image to base the version on
//
IVirtualMachineCustomImage customImage = PrepareCustomImage(rgName, region, azure);
// String customImageId = "/subscriptions/0b1f6471-1bf0-4dda-aec3-cb9272f09590/resourceGroups/javacsmrg91482/providers/Microsoft.Compute/images/img96429090dee3";
//
// Create a image version based on the custom image
//
string versionName = "0.0.4";
IGalleryImageVersion imageVersion = azure.GalleryImageVersions.Define(versionName)
.WithExistingImage(rgName, gallery.Name, galleryImage.Name)
.WithLocation(region.ToString())
.WithSourceCustomImage(customImage)
// Options - Start
.WithRegionAvailability(Region.USEast2, 1)
// Options - End
.Create();
Assert.NotNull(imageVersion);
Assert.NotNull(imageVersion.Inner);
Assert.NotNull(imageVersion.PublishingProfile.TargetRegions);
Assert.Equal(2, imageVersion.PublishingProfile.TargetRegions.Count);
Assert.False(imageVersion.IsExcludedFromLatest);
imageVersion = azure.GalleryImageVersions.GetByGalleryImage(rgName, gallery.Name, galleryImage.Name, imageVersion.Name);
Assert.NotNull(imageVersion);
Assert.Null(imageVersion.ReplicationStatus);
imageVersion = azure.GalleryImageVersions.GetByGalleryImageWithReplicationStatus(rgName, gallery.Name, galleryImage.Name, imageVersion.Name);
Assert.NotNull(imageVersion);
Assert.NotNull(imageVersion.ReplicationStatus);
Assert.NotNull(imageVersion.ReplicationStatus.AggregatedState);
//
// Update image version
//
imageVersion.Update()
.WithoutRegionAvailability(Region.USEast2)
.Apply();
Assert.NotNull(imageVersion.PublishingProfile.TargetRegions);
Assert.Equal(1, imageVersion.PublishingProfile.TargetRegions.Count);
Assert.False(imageVersion.IsExcludedFromLatest);
//
// List image versions
//
IEnumerable <IGalleryImageVersion> versions = galleryImage.ListVersions();
Assert.NotNull(versions);
Assert.True(versions.Count() > 0);
//
// Delete the image version
//
azure.GalleryImageVersions.DeleteByGalleryImage(rgName, galleryName, galleryImageName, versionName);
}
finally
{
try
{
azure.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public void CanCRUDCdn()
{
using (var context = FluentMockContext.Start(this.GetType().FullName))
{
var cdnStandardProfileName = TestUtilities.GenerateName("cdnStandardProfile");
var cdnPremiumProfileName = TestUtilities.GenerateName("cdnPremiumProfile22");
var cdnPremiumEndpointName = TestUtilities.GenerateName("premiumVerizonEndpointFluentTest22");
var rgName = TestUtilities.GenerateName("rgRCCDN");
try
{
var cdnManager = TestHelper.CreateCdnManager();
var standardProfile = cdnManager.Profiles.Define(cdnStandardProfileName)
.WithRegion(Region.USCentral)
.WithNewResourceGroup(rgName)
.WithStandardAkamaiSku()
.WithNewEndpoint("supername.cloudapp.net")
.DefineNewEndpoint("akamiEndpointWithoutMuchProperties")
.WithOrigin("originSuperName", "storageforazdevextest.blob.core.windows.net")
.Attach()
.DefineNewEndpoint(cdnEndpointName, endpointOriginHostname)
.WithContentTypeToCompress("powershell/pain")
.WithGeoFilter("/path/videos", GeoFilterActions.Block, CountryISOCode.Argentina)
.WithGeoFilter("/path/images", GeoFilterActions.Block, CountryISOCode.Belgium)
.WithContentTypeToCompress("text/plain")
.WithCompressionEnabled(true)
.WithQueryStringCachingBehavior(QueryStringCachingBehavior.BypassCaching)
.WithHttpsAllowed(true)
.WithHttpsPort(444)
.WithHttpAllowed(true)
.WithHttpPort(85)
.WithCustomDomain("sdk-1-f3757d2a3e10.azureedge-test.net")
.WithCustomDomain("sdk-2-f3757d2a3e10.azureedge-test.net")
.Attach()
.Create();
Assert.NotNull(standardProfile);
Assert.Equal(cdnStandardProfileName, standardProfile.Name);
Assert.False(standardProfile.IsPremiumVerizon);
Assert.Equal(3, standardProfile.Endpoints.Count);
Assert.True(standardProfile.Endpoints.ContainsKey(cdnEndpointName));
Assert.Equal(endpointOriginHostname, standardProfile.Endpoints[cdnEndpointName].OriginHostName);
Assert.Equal(2, standardProfile.Endpoints[cdnEndpointName].CustomDomains.Count);
Assert.Equal(2, standardProfile.Endpoints[cdnEndpointName].GeoFilters.Count);
Assert.True(standardProfile.Endpoints[cdnEndpointName].IsCompressionEnabled);
Assert.True(standardProfile.Endpoints[cdnEndpointName].IsHttpAllowed);
Assert.True(standardProfile.Endpoints[cdnEndpointName].IsHttpsAllowed);
Assert.Equal(444, standardProfile.Endpoints[cdnEndpointName].HttpsPort);
Assert.Equal(85, standardProfile.Endpoints[cdnEndpointName].HttpPort);
var premiumProfile = cdnManager.Profiles.Define(cdnPremiumProfileName)
.WithRegion(Region.USCentral)
.WithNewResourceGroup(rgName)
.WithPremiumVerizonSku()
.WithNewPremiumEndpoint("someweirdname.blob.core.windows.net")
.DefineNewPremiumEndpoint("supermuperep1")
.WithPremiumOrigin("originPremium", "xplattestvmss1sto0575014.blob.core.windows.net")
.Attach()
.DefineNewPremiumEndpoint(cdnPremiumEndpointName)
.WithPremiumOrigin("supername.cloudapp.net")
.WithHttpAllowed(true)
.WithHttpsAllowed(true)
.WithHttpsPort(12)
.WithHttpPort(123)
.Attach()
.Create();
Assert.NotNull(premiumProfile);
Assert.Equal(Region.USCentral, premiumProfile.Region);
Assert.True(premiumProfile.IsPremiumVerizon);
Assert.Equal(3, premiumProfile.Endpoints.Count);
Assert.True(premiumProfile.Endpoints.ContainsKey(cdnPremiumEndpointName));
Assert.True(premiumProfile.Endpoints[cdnPremiumEndpointName].IsHttpAllowed);
Assert.True(premiumProfile.Endpoints[cdnPremiumEndpointName].IsHttpsAllowed);
Assert.Equal(12, premiumProfile.Endpoints[cdnPremiumEndpointName].HttpsPort);
Assert.Equal(123, premiumProfile.Endpoints[cdnPremiumEndpointName].HttpPort);
var profileRead = standardProfile.Refresh();
Assert.NotNull(profileRead);
Assert.Equal(standardProfile.Region, profileRead.Region);
Assert.Equal(standardProfile.Name, profileRead.Name);
Assert.Equal(standardProfile.Endpoints.Count, profileRead.Endpoints.Count);
profileRead = cdnManager.Profiles.GetById(standardProfile.Id);
Assert.Equal(3, profileRead.Endpoints.Count);
Assert.Equal(2, profileRead.Endpoints[cdnEndpointName].CustomDomains.Count);
Assert.Equal(standardProfile.Name, profileRead.Name);
if (!standardProfile.IsPremiumVerizon)
{
standardProfile.Update()
.WithTag("provider", "Akamai")
.WithNewEndpoint("www.somewebsite.com")
.DefineNewEndpoint("somenewnamefortheendpoint")
.WithOrigin("www.someotherwebsite.com")
.WithGeoFilter("/path/music", GeoFilterActions.Block, CountryISOCode.Estonia)
.Attach()
.UpdateEndpoint(cdnEndpointName)
.WithoutGeoFilters()
.WithHttpAllowed(true)
.WithHttpPort(1111)
.WithoutCustomDomain("sdk-2-f3757d2a3e10.azureedge-test.net")
.Parent()
.Apply();
}
Assert.Equal(standardProfile.Region, profileRead.Region);
Assert.Equal(standardProfile.Name, profileRead.Name);
Assert.NotEqual(standardProfile.Endpoints.Count, profileRead.Endpoints.Count);
Assert.Equal(5, standardProfile.Endpoints.Count);
Assert.Equal(1111, standardProfile.Endpoints[cdnEndpointName].HttpPort);
Assert.Equal(1, standardProfile.Endpoints[cdnEndpointName].CustomDomains.Count);
Assert.Equal("sdk-1-f3757d2a3e10.azureedge-test.net", standardProfile.Endpoints[cdnEndpointName].CustomDomains.ElementAt(0));
Assert.Equal(0, standardProfile.Endpoints[cdnEndpointName].GeoFilters.Count);
premiumProfile.Update()
.WithTag("provider", "Verizon")
.WithNewPremiumEndpoint("xplattestvmss1sto0575014.blob.core.windows.net")
.DefineNewPremiumEndpoint("supermuperep3")
.WithPremiumOrigin("xplattestvmss1sto0575014.blob.core.windows.net")
.Attach()
.UpdatePremiumEndpoint(cdnPremiumEndpointName)
.WithHttpsAllowed(true)
.WithHttpsPort(1111)
.Parent()
.WithoutEndpoint("supermuperep1")
.Apply();
Assert.True(premiumProfile.IsPremiumVerizon);
Assert.Equal(4, premiumProfile.Endpoints.Count);
Assert.False(premiumProfile.Endpoints.ContainsKey("supermuperep1"));
Assert.True(premiumProfile.IsPremiumVerizon);
string ssoUri = premiumProfile.GenerateSsoUri();
Assert.NotNull(ssoUri);
var standardEp = standardProfile.Endpoints[cdnEndpointName];
var validationResult = standardEp.ValidateCustomDomain("sdk-2-f3757d2a3e10.azureedge-test.net");
Assert.NotNull(validationResult);
Assert.True(validationResult.CustomDomainValidated);
standardProfile.StopEndpoint(standardEp.Name);
standardEp.Start();
}
finally
{
try
{
TestHelper.CreateResourceManager().ResourceGroups.DeleteByName(rgName);
}
catch
{ }
}
}
}
public void CanCreateUpdateGetDeleteGalleryImage()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
Region region = Region.USWestCentral;
string rgName = TestUtilities.GenerateName("vmexttest");
string galleryName = TestUtilities.GenerateName("jsim");
string galleryImageName = "JavaImages";
var azure = TestHelper.CreateRollupClient();
try
{
// Create a gallery
//
IGallery javaGallery = azure.Galleries.Define(galleryName)
.WithRegion(region)
.WithNewResourceGroup(rgName)
.WithDescription("java's image gallery")
.Create();
//
// Create an image in the gallery
//
IGalleryImage galleryImage = azure.GalleryImages.Define(galleryImageName)
.WithExistingGallery(javaGallery)
.WithLocation(region)
.WithIdentifier("JavaSDKTeam", "JDK", "Jdk-9")
.WithGeneralizedWindows()
// Optionals - Start
.WithUnsupportedDiskType(DiskSkuTypes.StandardLRS)
.WithUnsupportedDiskType(DiskSkuTypes.PremiumLRS)
.WithRecommendedMaximumCPUsCountForVirtualMachine(25)
.WithRecommendedMaximumMemoryForVirtualMachine(3200)
// Options - End
.Create();
Assert.NotNull(galleryImage);
Assert.NotNull(galleryImage.Inner);
Assert.Equal(galleryImage.Location, region.ToString(), ignoreCase: true);
Assert.True(galleryImage.OSType.Equals(OperatingSystemTypes.Windows));
Assert.True(galleryImage.OSState.Equals(OperatingSystemStateTypes.Generalized));
Assert.Equal(2, galleryImage.UnsupportedDiskTypes.Count);
Assert.NotNull(galleryImage.Identifier);
Assert.Equal("JavaSDKTeam", galleryImage.Identifier.Publisher);
Assert.Equal("JDK", galleryImage.Identifier.Offer);
Assert.Equal("Jdk-9", galleryImage.Identifier.Sku);
Assert.NotNull(galleryImage.RecommendedVirtualMachineConfiguration);
Assert.NotNull(galleryImage.RecommendedVirtualMachineConfiguration.VCPUs);
Assert.NotNull(galleryImage.RecommendedVirtualMachineConfiguration.VCPUs.Max);
Assert.Equal(25, galleryImage.RecommendedVirtualMachineConfiguration.VCPUs.Max);
Assert.NotNull(galleryImage.RecommendedVirtualMachineConfiguration.Memory);
Assert.NotNull(galleryImage.RecommendedVirtualMachineConfiguration.Memory.Max);
Assert.Equal(3200, galleryImage.RecommendedVirtualMachineConfiguration.Memory.Max);
//
// Update an image in the gallery
//
galleryImage.Update()
.WithoutUnsupportedDiskType(DiskSkuTypes.PremiumLRS)
.WithRecommendedMinimumCPUsCountForVirtualMachine(15)
.WithRecommendedMemoryForVirtualMachine(2200, 3200)
.Apply();
Assert.Equal(1, galleryImage.UnsupportedDiskTypes.Count);
Assert.NotNull(galleryImage.RecommendedVirtualMachineConfiguration);
Assert.NotNull(galleryImage.RecommendedVirtualMachineConfiguration.VCPUs);
Assert.NotNull(galleryImage.RecommendedVirtualMachineConfiguration.VCPUs.Max);
Assert.Equal(25, galleryImage.RecommendedVirtualMachineConfiguration.VCPUs.Max);
Assert.NotNull(galleryImage.RecommendedVirtualMachineConfiguration.VCPUs.Min);
Assert.Equal(15, galleryImage.RecommendedVirtualMachineConfiguration.VCPUs.Min);
Assert.NotNull(galleryImage.RecommendedVirtualMachineConfiguration.Memory);
Assert.NotNull(galleryImage.RecommendedVirtualMachineConfiguration.Memory.Max);
Assert.Equal(3200, galleryImage.RecommendedVirtualMachineConfiguration.Memory.Max);
Assert.NotNull(galleryImage.RecommendedVirtualMachineConfiguration.Memory.Min);
Assert.Equal(2200, galleryImage.RecommendedVirtualMachineConfiguration.Memory.Min);
//
// List images in the gallery
//
IEnumerable <IGalleryImage> images = azure.GalleryImages.ListByGallery(rgName, galleryName);
Assert.Single(images);
//
// Get image from gallery
//
galleryImage = azure.GalleryImages.GetByGallery(rgName, galleryName, galleryImageName);
Assert.NotNull(galleryImage);
Assert.NotNull(galleryImage.Inner);
//
// Delete an image from gallery
//
azure.GalleryImages.DeleteByGallery(rgName, galleryName, galleryImageName);
}
finally
{
try
{
azure.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public void CanCreateGetListDelete()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var rgName = TestUtilities.GenerateName("rgmsi");
var identityName = TestUtilities.GenerateName("msitest");
try
{
var azure = TestHelper.CreateRollupClient();
var creatableRG = azure.ResourceGroups
.Define(rgName)
.WithRegion(region);
var identity = azure.Identities
.Define(identityName)
.WithRegion(region)
.WithNewResourceGroup(creatableRG)
.Create();
Assert.NotNull(identity);
Assert.NotNull(identity.Inner);
Assert.True(identityName.Equals(identity.Name, StringComparison.OrdinalIgnoreCase), $"{identityName} == {identity.Name}");
Assert.True(identity.ResourceGroupName.Equals(rgName, StringComparison.OrdinalIgnoreCase), $"{rgName} == {identity.ResourceGroupName}");
Assert.NotNull(identity.ClientId);
Assert.NotNull(identity.PrincipalId);
Assert.NotNull(identity.TenantId);
Assert.NotNull(identity.ClientSecretUrl);
identity = azure.Identities.GetById(identity.Id);
Assert.NotNull(identity);
Assert.NotNull(identity.Inner);
var identities = azure.Identities.ListByResourceGroup(rgName);
Assert.NotNull(identities);
var found = false;
foreach (var id in identities)
{
Assert.NotNull(id);
Assert.NotNull(id.Inner);
if (id.Name.Equals(identityName, StringComparison.OrdinalIgnoreCase))
{
found = true;
}
Assert.NotNull(identity.ClientId);
Assert.NotNull(identity.PrincipalId);
Assert.NotNull(identity.TenantId);
Assert.NotNull(identity.ClientSecretUrl);
}
Assert.True(found);
azure.Identities
.DeleteById(identity.Id);
}
finally
{
try
{
var resourceManager = TestHelper.CreateResourceManager();
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public void CanSetMSIOnNewVMWithMultipleRoleAssignments()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var groupName = TestUtilities.GenerateName("rgmsi");
var storageAccountName = TestUtilities.GenerateName("ja");
var region = Region.USEast2;
var vmName = "javavm";
IAzure azure = null;
try
{
azure = TestHelper.CreateRollupClient();
IStorageAccount storageAccount = azure.StorageAccounts
.Define(storageAccountName)
.WithRegion(region)
.WithNewResourceGroup(groupName)
.Create();
var resourceGroup = azure.ResourceGroups.GetByName(storageAccount.ResourceGroupName);
IVirtualMachine virtualMachine = azure.VirtualMachines
.Define(vmName)
.WithRegion(region)
.WithExistingResourceGroup(groupName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername("Foo12")
.WithRootPassword("abc!@#F0orL")
.WithSize(VirtualMachineSizeTypes.StandardDS2V2)
.WithOSDiskCaching(CachingTypes.ReadWrite)
.WithSystemAssignedManagedServiceIdentity()
.WithSystemAssignedIdentityBasedAccessTo(resourceGroup.Id, BuiltInRole.Contributor)
.WithSystemAssignedIdentityBasedAccessTo(storageAccount.Id, BuiltInRole.Contributor)
.Create();
var authenticatedClient = TestHelper.CreateAuthenticatedClient();
// TODO: Renable the below code snippet: https://github.com/Azure/azure-libraries-for-net/issues/739
//
// Comment out since the below code need external tennat.
//
////
//IServicePrincipal servicePrincipal = authenticatedClient
// .ServicePrincipals
// .GetById(virtualMachineScaleSet.SystemAssignedManagedServiceIdentityPrincipalId);
//Assert.NotNull(servicePrincipal);
//Assert.NotNull(servicePrincipal.Inner);
// Ensure role assigned for resource group
//
var rgRoleAssignments = authenticatedClient.RoleAssignments.ListByScope(resourceGroup.Id);
Assert.NotNull(rgRoleAssignments);
bool found = false;
foreach (var roleAssignment in rgRoleAssignments)
{
if (roleAssignment.PrincipalId != null && roleAssignment.PrincipalId.Equals(virtualMachine.SystemAssignedManagedServiceIdentityPrincipalId, StringComparison.OrdinalIgnoreCase))
{
found = true;
break;
}
}
Assert.True(found, "Resource group should have a role assignment with virtual machine MSI principal");
// Ensure role assigned for storage account
//
var stgRoleAssignments = authenticatedClient.RoleAssignments.ListByScope(storageAccount.Id);
Assert.NotNull(stgRoleAssignments);
found = false;
foreach (var roleAssignment in stgRoleAssignments)
{
if (roleAssignment.PrincipalId != null && roleAssignment.PrincipalId.Equals(virtualMachine.SystemAssignedManagedServiceIdentityPrincipalId, StringComparison.OrdinalIgnoreCase))
{
found = true;
break;
}
}
Assert.True(found, "Storage account should have a role assignment with virtual machine MSI principal");
}
finally
{
try
{
if (azure != null)
{
azure.ResourceGroups.BeginDeleteByName(groupName);
}
}
catch { }
}
}
}
public void ContainerServiceCRUDTest()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var csName = TestUtilities.GenerateName("cr");
var saName = TestUtilities.GenerateName("crsa");
var dnsPrefix = TestUtilities.GenerateName("dns");
var rgName = TestUtilities.GenerateName("crRg");
IContainerService containerService = null;
var computeManager = TestHelper.CreateComputeManager();
var resourceManager = TestHelper.CreateResourceManager();
try
{
containerService = computeManager.ContainerServices.Define(csName)
.WithRegion(Region.USWest)
.WithNewResourceGroup(rgName)
.WithDcosOrchestration()
.WithDiagnostics()
.WithLinux()
.WithRootUsername("testusername")
.WithSshKey(SshKey)
.WithMasterNodeCount(ContainerServiceMasterProfileCount.MIN)
.WithMasterLeafDomainLabel("mp1" + dnsPrefix)
.DefineAgentPool("agentPool0" + csName)
.WithVMCount(1)
.WithVMSize(ContainerServiceVMSizeTypes.StandardA1)
.WithLeafDomainLabel("ap0" + dnsPrefix)
.Attach()
.WithTag("tag1", "value1")
.Create();
Assert.NotNull(containerService.Id);
Assert.Equal(containerService.Region, Region.USWest);
Assert.Equal(containerService.MasterNodeCount, (int)ContainerServiceMasterProfileCount.MIN);
Assert.Equal("testusername", containerService.LinuxRootUsername);
Assert.Equal(1, containerService.AgentPoolCount);
Assert.Equal(containerService.AgentPoolName, "agentPool0" + csName);
Assert.Equal(containerService.AgentPoolLeafDomainLabel, "ap0" + dnsPrefix);
Assert.Equal(containerService.AgentPoolVMSize, ContainerServiceVMSizeTypes.StandardA1);
Assert.Equal(ContainerServiceOrchestratorTypes.DCOS, containerService.OrchestratorType);
Assert.True(containerService.IsDiagnosticsEnabled);
Assert.True(containerService.Tags.ContainsKey("tag1"));
containerService = containerService.Update()
.WithAgentVMCount(5)
.WithTag("tag2", "value2")
.WithTag("tag3", "value3")
.WithoutTag("tag1")
.Apply();
Assert.True(containerService.AgentPoolCount == 5);
Assert.True(containerService.Tags.ContainsKey("tag2"));
Assert.True(!containerService.Tags.ContainsKey("tag1"));
}
finally
{
try
{
resourceManager.ResourceGroups.BeginDeleteByName(rgName);
}
catch { }
}
}
}
public void CanSetMSIOnExistingVMWithRoleAssignments()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var groupName = TestUtilities.GenerateName("rgmsi");
var storageAccountName = TestUtilities.GenerateName("ja");
var region = Region.USEast2;
var vmName = "javavm";
IAzure azure = null;
try
{
azure = TestHelper.CreateRollupClient();
IVirtualMachine virtualMachine = azure.VirtualMachines
.Define(vmName)
.WithRegion(region)
.WithNewResourceGroup(groupName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername("Foo12")
.WithRootPassword("abc!@#F0orL")
.WithSize(VirtualMachineSizeTypes.StandardDS2V2)
.WithOSDiskCaching(CachingTypes.ReadWrite)
.WithSystemAssignedManagedServiceIdentity()
.Create();
Assert.NotNull(virtualMachine);
Assert.NotNull(virtualMachine.Inner);
Assert.True(virtualMachine.IsManagedServiceIdentityEnabled);
Assert.NotNull(virtualMachine.SystemAssignedManagedServiceIdentityPrincipalId);
Assert.NotNull(virtualMachine.SystemAssignedManagedServiceIdentityTenantId);
var authenticatedClient = TestHelper.CreateAuthenticatedClient();
// Ensure NO role assigned for resource group
//
var resourceGroup = azure.ResourceGroups.GetByName(virtualMachine.ResourceGroupName);
var rgRoleAssignments1 = authenticatedClient.RoleAssignments.ListByScope(resourceGroup.Id);
Assert.NotNull(rgRoleAssignments1);
bool found = false;
foreach (var roleAssignment in rgRoleAssignments1)
{
if (roleAssignment.PrincipalId != null && roleAssignment.PrincipalId.Equals(virtualMachine.SystemAssignedManagedServiceIdentityPrincipalId, StringComparison.OrdinalIgnoreCase))
{
found = true;
break;
}
}
Assert.False(found, "Resource group should not have a role assignment with virtual machine MSI principal");
virtualMachine.Update()
.WithSystemAssignedManagedServiceIdentity()
.WithSystemAssignedIdentityBasedAccessToCurrentResourceGroup(BuiltInRole.Contributor)
.Apply();
// Ensure role assigned for resource group
//
var roleAssignments2 = authenticatedClient.RoleAssignments.ListByScope(resourceGroup.Id);
Assert.NotNull(roleAssignments2);
foreach (var roleAssignment in roleAssignments2)
{
if (roleAssignment.PrincipalId != null && roleAssignment.PrincipalId.Equals(virtualMachine.SystemAssignedManagedServiceIdentityPrincipalId, StringComparison.OrdinalIgnoreCase))
{
found = true;
break;
}
}
Assert.True(found, "Resource group should have a role assignment with virtual machine MSI principal");
// Try adding the same role again, implementation should handle 'RoleAlreadyExists' error code and resume
//
virtualMachine.Update()
.WithSystemAssignedManagedServiceIdentity()
.WithSystemAssignedIdentityBasedAccessToCurrentResourceGroup(BuiltInRole.Contributor)
.Apply();
}
finally
{
try
{
if (azure != null)
{
azure.ResourceGroups.BeginDeleteByName(groupName);
}
}
catch { }
}
}
}
public void CanCreateImageFromManagedDisk()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var vmName = SdkContext.RandomResourceName("vm7-", 20);
var storageAccountName = SdkContext.RandomResourceName("stg", 17);
var uname = "juser";
var password = TestUtilities.GenerateName("Pa5$");
var resourceManager = TestHelper.CreateRollupClient();
var computeManager = TestHelper.CreateComputeManager();
var storageManager = TestHelper.CreateStorageManager();
var rgName = TestUtilities.GenerateName("rgfluentchash-");
try
{
var nativeVM = computeManager.VirtualMachines
.Define(vmName)
.WithRegion(Location)
.WithNewResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithLatestLinuxImage("Canonical", "UbuntuServer", "14.04.2-LTS")
.WithRootUsername(uname)
.WithRootPassword(password)
.WithUnmanagedDisks() /* UN-MANAGED OS and DATA DISKS */
.DefineUnmanagedDataDisk("disk1")
.WithNewVhd(100)
.WithCaching(CachingTypes.ReadWrite)
.Attach()
.WithNewUnmanagedDataDisk(100)
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.WithNewStorageAccount(storageAccountName)
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
Assert.False(nativeVM.IsManagedDiskEnabled);
var osVhdUri = nativeVM.OSUnmanagedDiskVhdUri;
Assert.NotNull(osVhdUri);
var dataDisks = nativeVM.UnmanagedDataDisks;
Assert.Equal(2, dataDisks.Count);
computeManager.VirtualMachines.DeleteById(nativeVM.Id);
var osDiskName = SdkContext.RandomResourceName("dsk", 15);
// Create managed disk with Os from vm's Os disk
//
var managedOsDisk = computeManager.Disks.Define(osDiskName)
.WithRegion(Location)
.WithNewResourceGroup(rgName)
.WithLinuxFromVhd(osVhdUri)
.WithStorageAccountName(storageAccountName)
.Create();
// Create managed disk with Data from vm's lun0 data disk
//
var storageAccount = storageManager.StorageAccounts.GetByResourceGroup(rgName, storageAccountName);
var dataDiskName1 = SdkContext.RandomResourceName("dsk", 15);
var vmNativeDataDisk1 = dataDisks[0];
var managedDataDisk1 = computeManager.Disks.Define(dataDiskName1)
.WithRegion(Location)
.WithNewResourceGroup(rgName)
.WithData()
.FromVhd(vmNativeDataDisk1.VhdUri)
.WithStorageAccount(storageAccount)
.Create();
// Create managed disk with Data from vm's lun1 data disk
//
var dataDiskName2 = SdkContext.RandomResourceName("dsk", 15);
var vmNativeDataDisk2 = dataDisks[1];
var managedDataDisk2 = computeManager.Disks.Define(dataDiskName2)
.WithRegion(Location)
.WithNewResourceGroup(rgName)
.WithData()
.FromVhd(vmNativeDataDisk2.VhdUri)
.WithStorageAccountId(storageAccount.Id)
.Create();
// Create an image from the above managed disks
// Note that this is not a direct user scenario, but including this as per CRP team request
//
var imageName = SdkContext.RandomResourceName("img", 15);
var customImage = computeManager.VirtualMachineCustomImages.Define(imageName)
.WithRegion(Location)
.WithNewResourceGroup(rgName)
.WithLinuxFromDisk(managedOsDisk, OperatingSystemStateTypes.Generalized)
.DefineDataDiskImage()
.WithLun(vmNativeDataDisk1.Lun)
.FromManagedDisk(managedDataDisk1)
.WithDiskCaching(vmNativeDataDisk1.CachingType)
.WithDiskSizeInGB(vmNativeDataDisk1.Size + 10)
.Attach()
.DefineDataDiskImage()
.WithLun(vmNativeDataDisk2.Lun)
.FromManagedDisk(managedDataDisk2)
.WithDiskSizeInGB(vmNativeDataDisk2.Size + 10)
.Attach()
.Create();
Assert.NotNull(customImage);
Assert.Equal(customImage.Name, imageName, ignoreCase: true);
Assert.NotNull(customImage.OSDiskImage);
Assert.Equal(OperatingSystemStateTypes.Generalized, customImage.OSDiskImage.OsState);
Assert.Equal(OperatingSystemTypes.Linux, customImage.OSDiskImage.OsType);
Assert.NotNull(customImage.DataDiskImages);
Assert.Equal(2, customImage.DataDiskImages.Count);
Assert.Equal(customImage.HyperVGeneration, HyperVGenerationTypes.V1);
Assert.Null(customImage.SourceVirtualMachineId);
Assert.True(customImage.DataDiskImages.ContainsKey(vmNativeDataDisk1.Lun));
Assert.Equal(customImage.DataDiskImages[vmNativeDataDisk1.Lun].Caching, vmNativeDataDisk1.CachingType);
Assert.True(customImage.DataDiskImages.ContainsKey(vmNativeDataDisk2.Lun));
Assert.Equal(CachingTypes.None, customImage.DataDiskImages[vmNativeDataDisk2.Lun].Caching);
foreach (var vmDisk in dataDisks.Values)
{
Assert.True(customImage.DataDiskImages.ContainsKey(vmDisk.Lun));
var diskImage = customImage.DataDiskImages[vmDisk.Lun];
Assert.Equal((long)diskImage.DiskSizeGB, vmDisk.Size + 10);
Assert.Null(diskImage.BlobUri);
Assert.NotNull(diskImage.ManagedDisk);
Assert.True(diskImage.ManagedDisk.Id.Equals(managedDataDisk1.Id, StringComparison.OrdinalIgnoreCase) ||
diskImage.ManagedDisk.Id.Equals(managedDataDisk2.Id, StringComparison.OrdinalIgnoreCase));
}
computeManager.Disks.DeleteById(managedOsDisk.Id);
computeManager.Disks.DeleteById(managedDataDisk1.Id);
computeManager.Disks.DeleteById(managedDataDisk2.Id);
computeManager.VirtualMachineCustomImages.DeleteById(customImage.Id);
}
finally
{
try
{
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public void CanTroubleshootConnection()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
string newName = SdkContext.RandomResourceName("nw", 6);
var groupName = SdkContext.RandomResourceName("rg", 6);
String gatewayName = SdkContext.RandomResourceName("vngw", 8);
String connectionName = SdkContext.RandomResourceName("vngwc", 8);
try
{
// Create network watcher
var manager = TestHelper.CreateNetworkManager();
// make sure Network Watcher is disabled in current subscription and region as only one can exist
EnsureNetworkWatcherNotExists(manager.NetworkWatchers);
var nw = manager.NetworkWatchers.Define(newName)
.WithRegion(REGION)
.WithNewResourceGroup(groupName)
.Create();
IVirtualNetworkGateway vngw1 = manager.VirtualNetworkGateways.Define(gatewayName)
.WithRegion(REGION)
.WithExistingResourceGroup(groupName)
.WithNewNetwork("10.11.0.0/16", "10.11.255.0/27")
.WithRouteBasedVpn()
.WithSku(VirtualNetworkGatewaySkuName.VpnGw1)
.Create();
IVirtualNetworkGateway vngw2 = manager.VirtualNetworkGateways.Define(gatewayName + "2")
.WithRegion(REGION)
.WithExistingResourceGroup(groupName)
.WithNewNetwork("10.41.0.0/16", "10.41.255.0/27")
.WithRouteBasedVpn()
.WithSku(VirtualNetworkGatewaySkuName.VpnGw1)
.Create();
IVirtualNetworkGatewayConnection connection1 = vngw1.Connections
.Define(connectionName)
.WithVNetToVNet()
.WithSecondVirtualNetworkGateway(vngw2)
.WithSharedKey("MySecretKey")
.Create();
// Create storage account to store troubleshooting information
IStorageAccount storageAccount = EnsureStorageAccount(groupName);
// Troubleshoot connection
ITroubleshooting troubleshooting = nw.Troubleshoot()
.WithTargetResourceId(connection1.Id)
.WithStorageAccount(storageAccount.Id)
.WithStoragePath(storageAccount.EndPoints.Primary.Blob + "results")
.Execute();
Assert.Equal("UnHealthy", troubleshooting.Code);
// Create corresponding connection on second gateway to make it work
vngw2.Connections
.Define(connectionName + "2")
.WithVNetToVNet()
.WithSecondVirtualNetworkGateway(vngw1)
.WithSharedKey("MySecretKey")
.Create();
TestHelper.Delay(250000);
troubleshooting = nw.Troubleshoot()
.WithTargetResourceId(connection1.Id)
.WithStorageAccount(storageAccount.Id)
.WithStoragePath(storageAccount.EndPoints.Primary.Blob + "results")
.Execute();
Assert.Equal("Healthy", troubleshooting.Code);
manager.ResourceManager.ResourceGroups.DeleteByName(nw.ResourceGroupName);
}
finally
{
try
{
TestHelper.CreateResourceManager().ResourceGroups.DeleteByName(groupName);
}
catch { }
}
}
}
public void CanCreateNamespaceThenCRUDOnTopic()
{
using (var context = FluentMockContext.Start(this.GetType().FullName))
{
var rgName = TestUtilities.GenerateName("fluentnetsbmrg");
try
{
var resourceManager = TestHelper.CreateResourceManager();
var serviceBusManager = TestHelper.CreateServiceBusManager();
Region region = Region.USEast;
var rgCreatable = resourceManager.ResourceGroups
.Define(rgName)
.WithRegion(region);
var namespaceDNSLabel = TestUtilities.GenerateName("netsbns");
var queueName = TestUtilities.GenerateName("queue1-");
// Create NS with Queue
//
var nspace = serviceBusManager.Namespaces
.Define(namespaceDNSLabel)
.WithRegion(region)
.WithNewResourceGroup(rgCreatable)
.WithSku(NamespaceSku.Standard)
.Create();
Assert.NotNull(nspace);
Assert.NotNull(nspace.Inner);
var topicName = TestUtilities.GenerateName("topic14444444444444444444444444444444444444444444555555555555");
var topic = nspace.Topics
.Define(topicName)
.Create();
Assert.NotNull(topic);
Assert.NotNull(topic.Inner);
Assert.NotNull(topic.Name);
Assert.Equal(topic.Name, topicName, ignoreCase: true);
var dupDetectionDuration = topic.DuplicateMessageDetectionHistoryDuration;
Assert.Equal(10, dupDetectionDuration.TotalMinutes);
// Default message TTL is TimeSpan.Max, assert parsing
//
Assert.Equal("10675199.02:48:05.4775807", topic.Inner.DefaultMessageTimeToLive);
var msgTtlDuration = topic.DefaultMessageTtlDuration;
// Assert the default ttl TimeSpan("10675199.02:48:05.4775807") parsing
//
Assert.Equal(10675199, msgTtlDuration.Days);
Assert.Equal(2, msgTtlDuration.Hours);
Assert.Equal(48, msgTtlDuration.Minutes);
// Assert the default max size In MB
//
Assert.Equal(1024, topic.MaxSizeInMB);
var topicsInNamespace = nspace.Topics.List();
Assert.NotNull(topicsInNamespace);
Assert.True(topicsInNamespace.Count() > 0);
ITopic foundTopic = topicsInNamespace.FirstOrDefault(t => t.Name.Equals(topic.Name, StringComparison.OrdinalIgnoreCase));
Assert.NotNull(foundTopic);
foundTopic = foundTopic.Update()
.WithDefaultMessageTTL(new TimeSpan(0, 20, 0))
.WithDuplicateMessageDetectionHistoryDuration(new TimeSpan(0, 15, 0))
.WithDeleteOnIdleDurationInMinutes(25)
.Apply();
var ttlDuration = foundTopic.DefaultMessageTtlDuration;
Assert.Equal(20, ttlDuration.Minutes);
var duplicateDetectDuration = foundTopic.DuplicateMessageDetectionHistoryDuration;
Assert.Equal(15, duplicateDetectDuration.Minutes);
Assert.Equal(25, foundTopic.DeleteOnIdleDurationInMinutes);
// Delete
nspace.Topics.DeleteByName(foundTopic.Name);
}
finally
{
try
{
TestHelper.CreateResourceManager().ResourceGroups.DeleteByName(rgName);
}
catch
{
}
}
}
}
public void CanWatchNetwork()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
string newName = SdkContext.RandomResourceName("nw", 6);
var groupName = SdkContext.RandomResourceName("rg", 6);
var resourcesGroupName = SdkContext.RandomResourceName("rg", 8);
// Create network watcher
var manager = TestHelper.CreateNetworkManager();
var computeManager = TestHelper.CreateComputeManager();
try
{
// make sure Network Watcher is disabled in current subscription and region as only one can exist
EnsureNetworkWatcherNotExists(manager.NetworkWatchers);
var nw = manager.NetworkWatchers.Define(newName)
.WithRegion(REGION)
.WithNewResourceGroup(groupName)
.Create();
// pre-create VMs to show topology on
ICreatedResources <IVirtualMachine> virtualMachines = EnsureNetwork(manager, computeManager, resourcesGroupName);
var vm0 = virtualMachines.ElementAt(0);
ITopology topology = nw.Topology()
.WithTargetResourceGroup(vm0.ResourceGroupName)
.Execute();
Assert.Equal(11, topology.Resources.Count);
Assert.True(topology.Resources.ContainsKey(vm0.PrimaryNetworkInterfaceId));
Assert.Equal(4, topology.Resources[vm0.PrimaryNetworkInterfaceId].Associations.Count);
ISecurityGroupView sgViewResult = nw.GetSecurityGroupView(virtualMachines.ElementAt(0).Id);
Assert.Equal(1, sgViewResult.NetworkInterfaces.Count);
Assert.Equal(virtualMachines.ElementAt(0).PrimaryNetworkInterfaceId,
sgViewResult.NetworkInterfaces.Keys.First());
IFlowLogSettings flowLogSettings =
nw.GetFlowLogSettings(vm0.GetPrimaryNetworkInterface().NetworkSecurityGroupId);
IStorageAccount storageAccount = EnsureStorageAccount(resourcesGroupName);
flowLogSettings.Update()
.WithLogging()
.WithStorageAccount(storageAccount.Id)
.WithRetentionPolicyDays(5)
.WithRetentionPolicyEnabled()
.Apply();
Assert.True(flowLogSettings.Enabled);
Assert.Equal(5, flowLogSettings.RetentionDays);
Assert.Equal(storageAccount.Id, flowLogSettings.StorageId);
INextHop nextHop = nw.NextHop().WithTargetResourceId(vm0.Id)
.WithSourceIPAddress("10.0.0.4")
.WithDestinationIPAddress("8.8.8.8")
.Execute();
Assert.Equal("System Route", nextHop.RouteTableId);
Assert.Equal(NextHopType.Internet, nextHop.NextHopType);
Assert.Null(nextHop.NextHopIpAddress);
IVerificationIPFlow verificationIPFlow = nw.VerifyIPFlow()
.WithTargetResourceId(vm0.Id)
.WithDirection(Direction.Outbound)
.WithProtocol(IpFlowProtocol.TCP)
.WithLocalIPAddress("10.0.0.4")
.WithRemoteIPAddress("8.8.8.8")
.WithLocalPort("443")
.WithRemotePort("443")
.Execute();
Assert.Equal(Access.Allow, verificationIPFlow.Access);
Assert.Equal("defaultSecurityRules/AllowInternetOutBound", verificationIPFlow.RuleName);
// test packet capture
IEnumerable <IPacketCapture> packetCaptures = nw.PacketCaptures.List();
Assert.Empty(packetCaptures);
IPacketCapture packetCapture = nw.PacketCaptures
.Define("NewPacketCapture")
.WithTarget(vm0.Id)
.WithStorageAccountId(storageAccount.Id)
.WithTimeLimitInSeconds(1500)
.DefinePacketCaptureFilter()
.WithProtocol(PcProtocol.TCP)
.WithLocalIPAddresses(new List <string>()
{
"127.0.0.1", "127.0.0.5"
})
.Attach()
.Create();
packetCaptures = nw.PacketCaptures.List();
Assert.Single(packetCaptures);
Assert.Equal("NewPacketCapture", packetCapture.Name);
Assert.Equal(1500, packetCapture.TimeLimitInSeconds);
Assert.Equal(PcProtocol.TCP, packetCapture.Filters[0].Protocol);
Assert.Equal("127.0.0.1;127.0.0.5", packetCapture.Filters[0].LocalIPAddress);
// Assert.assertEquals("Running", packetCapture.getStatus().packetCaptureStatus().toString());
packetCapture.Stop();
Assert.Equal("Stopped", packetCapture.GetStatus().PacketCaptureStatus.Value);
nw.PacketCaptures.DeleteByName(packetCapture.Name);
IConnectivityCheck connectivityCheck = nw.CheckConnectivity()
.ToDestinationResourceId(vm0.Id)
.ToDestinationPort(80)
.FromSourceVirtualMachine(virtualMachines.ElementAt(0).Id)
.Execute();
Assert.Equal("Reachable", connectivityCheck.ConnectionStatus.ToString());
computeManager.VirtualMachines.DeleteById(virtualMachines.ElementAt(1).Id);
topology.Execute();
Assert.Equal(10, topology.Resources.Count);
manager.ResourceManager.ResourceGroups.DeleteByName(nw.ResourceGroupName);
manager.ResourceManager.ResourceGroups.DeleteByName(resourcesGroupName);
}
finally
{
try
{
TestHelper.CreateResourceManager().ResourceGroups.DeleteByName(resourcesGroupName);
TestHelper.CreateResourceManager().ResourceGroups.DeleteByName(groupName);
}
catch { }
}
}
}
public void CanPerformCRUDOnSubscriptions()
{
using (var context = FluentMockContext.Start(this.GetType().FullName))
{
var rgName = TestUtilities.GenerateName("fluentnetsbmrg");
try
{
var resourceManager = TestHelper.CreateResourceManager();
var serviceBusManager = TestHelper.CreateServiceBusManager();
Region region = Region.USEast;
var rgCreatable = resourceManager.ResourceGroups
.Define(rgName)
.WithRegion(region);
String namespaceDNSLabel = TestUtilities.GenerateName("netsbns");
String topicName = TestUtilities.GenerateName("topic1-");
String subscriptionName = TestUtilities.GenerateName("sub1-");
// Create NS with Topic
//
var nspace = serviceBusManager.Namespaces
.Define(namespaceDNSLabel)
.WithRegion(region)
.WithNewResourceGroup(rgCreatable)
.WithSku(NamespaceSku.Standard)
.WithNewTopic(topicName, 1024)
.Create();
Assert.NotNull(nspace);
Assert.NotNull(nspace.Inner);
// Create Topic subscriptions and list it
//
var topic = nspace.Topics.GetByName(topicName);
var subscription = topic.Subscriptions
.Define(subscriptionName)
.WithSession()
.WithDefaultMessageTTL(new TimeSpan(0, 20, 0))
.Create();
Assert.NotNull(subscription);
Assert.NotNull(subscription.Inner);
Assert.Equal(20, subscription.DefaultMessageTtlDuration.Minutes);
subscription = topic.Subscriptions.GetByName(subscriptionName);
Assert.NotNull(subscription);
Assert.NotNull(subscription.Inner);
var subscriptionsInTopic = topic.Subscriptions.List();
Assert.True(subscriptionsInTopic.Count() > 0);
var foundSubscription = subscriptionsInTopic.Any(s => s.Name.Equals(subscription.Name, StringComparison.OrdinalIgnoreCase));
Assert.True(foundSubscription);
topic.Subscriptions.DeleteByName(subscriptionName);
subscriptionsInTopic = topic.Subscriptions.List();
Assert.True(subscriptionsInTopic.Count() == 0);
Assert.True(subscription.IsSessionEnabled);
subscription.Update().WithoutSession().Apply();
subscription.Refresh();
Assert.False(subscription.IsSessionEnabled);
}
finally
{
try
{
TestHelper.CreateResourceManager().ResourceGroups.DeleteByName(rgName);
}
catch
{
}
}
}
}
public void CanCRUDFunctionApp()
{
using (var context = FluentMockContext.Start(this.GetType().FullName))
{
string GroupName1 = TestUtilities.GenerateName("javacsmrg");
string GroupName2 = TestUtilities.GenerateName("javacsmrg");
string WebAppName1 = TestUtilities.GenerateName("java-webapp-");
string WebAppName2 = TestUtilities.GenerateName("java-webapp-");
string WebAppName3 = TestUtilities.GenerateName("java-webapp-");
string StorageName1 = TestUtilities.GenerateName("javast");
if (StorageName1.Length >= 23)
{
StorageName1 = StorageName1.Substring(0, 20);
}
StorageName1 = StorageName1.Replace("-", string.Empty);
var appServiceManager = TestHelper.CreateAppServiceManager();
// Create with consumption plan
var functionApp1 = appServiceManager.FunctionApps.Define(WebAppName1)
.WithRegion(Region.USWest)
.WithNewResourceGroup(GroupName1)
.Create();
Assert.NotNull(functionApp1);
Assert.Equal(Region.USWest, functionApp1.Region);
var plan1 = appServiceManager.AppServicePlans.GetById(functionApp1.AppServicePlanId);
Assert.NotNull(plan1);
Assert.Equal(Region.USWest, plan1.Region);
Assert.Equal(new PricingTier("Dynamic", "Y1"), plan1.PricingTier);
// Create in a new group with existing consumption plan
var functionApp2 = appServiceManager.FunctionApps.Define(WebAppName2)
.WithExistingAppServicePlan(plan1)
.WithNewResourceGroup(GroupName2)
.WithExistingStorageAccount(functionApp1.StorageAccount)
.Create();
Assert.NotNull(functionApp2);
Assert.Equal(Region.USWest, functionApp2.Region);
// Create with app service plan
var functionApp3 = appServiceManager.FunctionApps.Define(WebAppName3)
.WithRegion(Region.USWest)
.WithExistingResourceGroup(GroupName2)
.WithNewAppServicePlan(PricingTier.BasicB1)
.WithExistingStorageAccount(functionApp1.StorageAccount)
.Create();
Assert.NotNull(functionApp3);
Assert.Equal(Region.USWest, functionApp3.Region);
// Get
var functionApp = appServiceManager.FunctionApps.GetByResourceGroup(GroupName1, functionApp1.Name);
Assert.Equal(functionApp1.Id, functionApp.Id);
functionApp = appServiceManager.FunctionApps.GetById(functionApp2.Id);
Assert.Equal(functionApp2.Name, functionApp.Name);
// List
var functionApps = appServiceManager.FunctionApps.ListByResourceGroup(GroupName1);
Assert.Single(functionApps);
functionApps = appServiceManager.FunctionApps.ListByResourceGroup(GroupName2);
Assert.Equal(2, functionApps.Count());
// Update
functionApp2.Update()
.WithNewStorageAccount(StorageName1, Microsoft.Azure.Management.Storage.Fluent.Models.SkuName.StandardGRS)
.Apply();
Assert.Equal(StorageName1, functionApp2.StorageAccount.Name);
// Scale
functionApp3.Update()
.WithNewAppServicePlan(PricingTier.StandardS2)
.Apply();
var plan2 = appServiceManager.AppServicePlans.GetById(functionApp3.AppServicePlanId);
Assert.NotNull(plan2);
Assert.NotEqual(plan1.Id, plan2.Id);
Assert.Equal(Region.USWest, plan2.Region);
Assert.Equal(PricingTier.StandardS2, plan2.PricingTier);
}
}
public void CanCRUDSwapSlots()
{
using (var context = FluentMockContext.Start(this.GetType().FullName))
{
string GroupName = TestUtilities.GenerateName("javacsmrg");
string WebAppName = TestUtilities.GenerateName("java-webapp-");
string SlotName1 = TestUtilities.GenerateName("java-slot-");
string SlotName2 = TestUtilities.GenerateName("java-slot-");
string SlotName3 = TestUtilities.GenerateName("java-slot-");
string AppServicePlanName = TestUtilities.GenerateName("java-asp-");
var appServiceManager = TestHelper.CreateAppServiceManager();
// Create function app
var functionApp = appServiceManager.FunctionApps.Define(WebAppName)
.WithRegion(Region.USWest)
.WithNewResourceGroup(GroupName)
.WithNewAppServicePlan(PricingTier.StandardS2)
.WithAppSetting("appkey", "appvalue")
.WithStickyAppSetting("stickykey", "stickyvalue")
.WithConnectionString("connectionName", "connectionValue", ConnectionStringType.Custom)
.WithStickyConnectionString("stickyName", "stickyValue", ConnectionStringType.Custom)
.WithJavaVersion(JavaVersion.V7_51)
.WithWebContainer(WebContainer.Tomcat7_0_50)
.Create();
Assert.NotNull(functionApp);
Assert.Equal(Region.USWest, functionApp.Region);
// Create a deployment slot with empty config
var slot1 = functionApp.DeploymentSlots.Define(SlotName1)
.WithBrandNewConfiguration()
.WithPythonVersion(PythonVersion.V27)
.Create();
Assert.NotNull(slot1);
Assert.NotEqual(JavaVersion.V7_51, slot1.JavaVersion);
Assert.Equal(PythonVersion.V27, slot1.PythonVersion);
var appSettingMap = slot1.GetAppSettings();
Assert.False(appSettingMap.ContainsKey("appkey"));
Assert.False(appSettingMap.ContainsKey("stickykey"));
var connectionStringMap = slot1.GetConnectionStrings();
Assert.False(connectionStringMap.ContainsKey("connectionName"));
Assert.False(connectionStringMap.ContainsKey("stickyName"));
// Create a deployment slot with web app's config
var slot2 = functionApp.DeploymentSlots.Define(SlotName2)
.WithConfigurationFromParent()
.Create();
Assert.NotNull(slot2);
Assert.Equal(JavaVersion.V7_51, slot2.JavaVersion);
appSettingMap = slot2.GetAppSettings();
Assert.Equal("appvalue", appSettingMap["appkey"].Value);
Assert.False(appSettingMap["appkey"].Sticky);
Assert.Equal("stickyvalue", appSettingMap["stickykey"].Value);
Assert.True(appSettingMap["stickykey"].Sticky);
connectionStringMap = slot2.GetConnectionStrings();
Assert.Equal("connectionValue", connectionStringMap["connectionName"].Value);
Assert.False(connectionStringMap["connectionName"].Sticky);
Assert.Equal("stickyValue", connectionStringMap["stickyName"].Value);
Assert.True(connectionStringMap["stickyName"].Sticky);
// Update deployment slot
slot2.Update()
.WithoutJava()
.WithPythonVersion(PythonVersion.V34)
.WithAppSetting("slot2key", "slot2value")
.WithStickyAppSetting("sticky2key", "sticky2value")
.Apply();
Assert.NotNull(slot2);
Assert.Equal(JavaVersion.Off, slot2.JavaVersion);
Assert.Equal(PythonVersion.V34, slot2.PythonVersion);
appSettingMap = slot2.GetAppSettings();
Assert.Equal("slot2value", appSettingMap["slot2key"].Value);
// Create 3rd deployment slot with configuration from slot 2
var slot3 = functionApp.DeploymentSlots.Define(SlotName3)
.WithConfigurationFromDeploymentSlot(slot2)
.Create();
Assert.NotNull(slot3);
Assert.Equal(JavaVersion.Off, slot3.JavaVersion);
Assert.Equal(PythonVersion.V34, slot3.PythonVersion);
appSettingMap = slot3.GetAppSettings();
Assert.Equal("slot2value", appSettingMap["slot2key"].Value);
// Get
var deploymentSlot = functionApp.DeploymentSlots.GetByName(SlotName3);
Assert.Equal(slot3.Id, deploymentSlot.Id);
// List
var deploymentSlots = functionApp.DeploymentSlots.List();
Assert.Equal(3, deploymentSlots.Count());
// Swap
slot3.Swap(slot1.Name);
slot1 = functionApp.DeploymentSlots.GetByName(SlotName1);
Assert.Equal(JavaVersion.Off, slot1.JavaVersion);
Assert.Equal(PythonVersion.V34, slot1.PythonVersion);
Assert.Equal(PythonVersion.V27, slot3.PythonVersion);
var appSettings1 = slot1.GetAppSettings();
var appSettings3 = slot3.GetAppSettings();
Assert.Equal("appvalue", appSettings1["appkey"].Value);
Assert.Equal("slot2value", appSettings1["slot2key"].Value);
Assert.Equal("sticky2value", appSettings3["sticky2key"].Value);
Assert.Equal("stickyvalue", appSettings3["stickykey"].Value);
}
}
public void CreateUpdate()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
string testId = SdkContext.RandomResourceName("", 9);
string resourceGroupName = "rg" + testId;
string nsgName = "nsg" + testId;
string nicName = "nic" + testId;
Region region = Region.USSouthCentral;
try
{
var manager = TestHelper.CreateNetworkManager();
var nsg = manager.NetworkSecurityGroups.Define(nsgName)
.WithRegion(region)
.WithNewResourceGroup(resourceGroupName)
.DefineRule("rule1")
.AllowOutbound()
.FromAnyAddress()
.FromPort(80)
.ToAnyAddress()
.ToPort(80)
.WithProtocol(SecurityRuleProtocol.Tcp)
.Attach()
.DefineRule("rule2")
.AllowInbound()
.FromAnyAddress()
.FromAnyPort()
.ToAnyAddress()
.ToPortRange(22, 25)
.WithAnyProtocol()
.WithPriority(200)
.WithDescription("foo!!")
.Attach()
.Create();
var nic = manager.NetworkInterfaces.Define(nicName)
.WithRegion(nsg.Region)
.WithExistingResourceGroup(nsg.ResourceGroupName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithExistingNetworkSecurityGroup(nsg)
.Create();
nsg.Refresh();
// Verify
Assert.True(nsg.Region.Equals(region));
Assert.True(nsg.SecurityRules.Count == 2);
// Confirm NIC association
Assert.Equal(1, nsg.NetworkInterfaceIds.Count);
Assert.True(nsg.NetworkInterfaceIds.Contains(nic.Id.ToLower()));
var resource = manager.NetworkSecurityGroups.GetByResourceGroup(resourceGroupName, nsgName);
resource = resource.Update()
.WithoutRule("rule1")
.WithTag("tag1", "value1")
.WithTag("tag2", "value2")
.DefineRule("rule3")
.AllowInbound()
.FromAnyAddress()
.FromAnyPort()
.ToAnyAddress()
.ToAnyPort()
.WithProtocol(SecurityRuleProtocol.Udp)
.Attach()
.WithoutRule("rule1")
.UpdateRule("rule2")
.DenyInbound()
.FromAddresses("100.0.0.0/29", "100.1.0.0/29")
.FromPortRanges("88-90")
.WithPriority(300)
.WithDescription("bar!!!")
.Parent()
.Apply();
Assert.True(resource.Tags.ContainsKey("tag1"));
INetworkSecurityRule rule2;
Assert.True(resource.SecurityRules.TryGetValue("rule2", out rule2));
Assert.Equal(0, rule2.SourceApplicationSecurityGroupIds.Count);
Assert.Null(rule2.SourceAddressPrefix);
Assert.Equal(2, rule2.SourceAddressPrefixes.Count);
Assert.True(rule2.SourceAddressPrefixes.Contains("100.1.0.0/29"));
Assert.Equal(1, rule2.SourcePortRanges.Count);
Assert.Equal("88-90", rule2.SourcePortRanges.ElementAt(0));
manager.NetworkSecurityGroups.DeleteById(resource.Id);
manager.ResourceManager.ResourceGroups.DeleteByName(resource.ResourceGroupName);
}
finally
{
try
{
TestHelper.CreateResourceManager().ResourceGroups.DeleteByName(resourceGroupName);
}
catch { }
}
}
}
