public void CanGetAD()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
RemoteAppManagementClient remoteAppManagementClient = GetRemoteAppManagementClient();
ActiveDirectoryConfigResult result = null;
//CollectionListResult collectionList = remoteAppManagementClient.Collections.List();
//Assert.NotNull(collectionList);
//Assert.Equal(HttpStatusCode.OK, collectionList.StatusCode);
//Assert.NotNull(collectionList.Collections);
//Assert.NotEmpty(collectionList.Collections);
result = remoteAppManagementClient.Collections.GetAd("testd112");
Assert.NotNull(result);
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
AssertNotNullOrEmpty(result.RequestId);
Assert.NotNull(result.ActiveDirectoryConfig);
AssertNotNullOrEmpty(result.ActiveDirectoryConfig.DomainName);
AssertNotNullOrEmpty(result.ActiveDirectoryConfig.UserName);
//verify that the simple or cloud only collection does not have an AD info and throws a WebFault
Assert.Throws(typeof(CloudException), () =>
{
result = remoteAppManagementClient.Collections.GetAd("simple");
});
}
}
private GetPublishedApplicationResult WaitForAppStatus(RemoteAppManagementClient client, string collectionId, string appAlias, AppPublishingStatus status)
{
// Wait for application status to change to "Published"
GetPublishedApplicationResult publishedAppResult = null;
int retryCount = 0;
do
{
// Need not wait in Mock environment
if (HttpMockServer.Mode != HttpRecorderMode.Playback)
{
TestUtilities.Wait(AppPublihingStatusCheckIntervalSeconds * 1000);
}
publishedAppResult = client.Publishing.Get(collectionId, appAlias);
Assert.NotNull(publishedAppResult);
Assert.NotNull(publishedAppResult.Result);
Assert.True(publishedAppResult.StatusCode == HttpStatusCode.OK);
retryCount++;
} while (retryCount < AppPublihingStatusCheckMaxRetries &&
publishedAppResult.Result.Status != status);
Assert.True(retryCount < AppPublihingStatusCheckMaxRetries);
return(publishedAppResult);
}
public void CanGetStartMenuApplication()
{
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
RemoteAppManagementClient client = GetRemoteAppManagementClient();
CollectionListResult serviceList = null;
Assert.DoesNotThrow(() =>
{
serviceList = client.Collections.List();
});
Assert.NotNull(serviceList);
Assert.NotEmpty(serviceList.Collections);
foreach (Collection collection in serviceList.Collections)
{
GetStartMenuApplicationListResult appListResult = client.Publishing.StartMenuApplicationList(collection.Name);
foreach (StartMenuApplication startMenuApp in appListResult.ResultList)
{
GetStartMenuApplicationResult appResult = client.Publishing.StartMenuApplication(collection.Name, startMenuApp.StartMenuAppId);
Assert.NotNull(appResult);
Assert.NotNull(appResult.Result);
Assert.True(appResult.StatusCode == HttpStatusCode.OK);
return;
}
}
}
}
public void CanCreateAD()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
HttpRecorderMode mode = HttpMockServer.GetCurrentMode();
RemoteAppManagementClient remoteAppManagementClient = GetRemoteAppManagementClient();
HttpStatusCode[] statusSuccess = { HttpStatusCode.OK, HttpStatusCode.Accepted };
ActiveDirectoryConfigParameter payload = new ActiveDirectoryConfigParameter()
{
DomainName = "MyDomain",
UserName = "******",
Password = "******"
};
OperationResultWithTrackingId result = null;
Assert.DoesNotThrow(() =>
{
result = remoteAppManagementClient.Collections.SetAd("testd112", payload);
});
Assert.NotNull(result);
Assert.True(result.StatusCode == HttpStatusCode.OK || result.StatusCode == HttpStatusCode.Accepted);
if (result.StatusCode == HttpStatusCode.Accepted)
{
Assert.NotNull(result.TrackingId);
}
}
}
public void CanGetSessionsList()
{
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
RemoteAppManagementClient client = GetRemoteAppManagementClient();
CollectionSessionListResult sessionsResponse = client.Collections.ListSessions("testd112");
RemoteAppSession session = null;
Assert.NotNull(sessionsResponse);
Assert.NotNull(sessionsResponse.Sessions);
Assert.True(sessionsResponse.StatusCode == HttpStatusCode.OK);
Assert.Empty(sessionsResponse.Sessions);
// verify the serialization of the response with one item
sessionsResponse = client.Collections.ListSessions("simple");
Assert.NotNull(sessionsResponse);
Assert.NotNull(sessionsResponse.Sessions);
Assert.True(sessionsResponse.StatusCode == HttpStatusCode.OK);
Assert.NotEmpty(sessionsResponse.Sessions);
Assert.True(sessionsResponse.Sessions.Count == 1, "There must be only 1 session here.");
session = sessionsResponse.Sessions[0];
// these data are validated from the recorded json file
Assert.NotNull(session);
Assert.True(session.State == SessionState.Connected);
}
}
public void CanGetTemplateImageByName()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
RemoteAppManagementClient client = GetRemoteAppManagementClient();
TemplateImageListResult templatImagesList = client.TemplateImages.List();
Assert.NotNull(templatImagesList);
Assert.NotEmpty(templatImagesList.RemoteAppTemplateImageList);
Assert.True(templatImagesList.StatusCode == System.Net.HttpStatusCode.OK);
foreach (TemplateImage image in templatImagesList.RemoteAppTemplateImageList)
{
TemplateImageResult imageByNameResponse = client.TemplateImages.Get(image.Name);
Assert.NotNull(imageByNameResponse);
Assert.NotNull(imageByNameResponse.TemplateImage);
Assert.True(imageByNameResponse.TemplateImage.Id == image.Id);
Assert.True(imageByNameResponse.TemplateImage.Name == image.Name);
}
}
}
public void CanNotSendCommandToASessionOnNonExistingCollection()
{
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
RemoteAppManagementClient client = GetRemoteAppManagementClient();
SessionCommandParameter parameter = new SessionCommandParameter
{
UserUpn = "*****@*****.**"
};
// testing the web fault
OperationResultWithTrackingId response = null;
Assert.Throws <CloudException>(() => response = client.Collections.LogoffSession("mycoll", parameter));
Assert.Throws <CloudException>(() => response = client.Collections.DisconnectSession("mycoll", parameter));
SessionSendMessageCommandParameter messageParameter = new SessionSendMessageCommandParameter()
{
Message = "Hey there!",
UserUpn = "*****@*****.**"
};
Assert.Throws <CloudException>(() => response = client.Collections.SendMessageToSession("mycoll", messageParameter));
}
}
private static void AssertLongrunningOperation(RemoteAppManagementClient client, RemoteAppOperationStatus status, String operationTrackingId)
{
int retries = 10;
RemoteAppOperationStatusResult operationResult = null;
//check for the operation status to success
while (retries > 0)
{
operationResult = null;
Assert.DoesNotThrow(() =>
{
operationResult = client.OperationResults.Get(operationTrackingId);
});
Assert.Equal(operationResult.StatusCode, HttpStatusCode.OK);
if (operationResult.RemoteAppOperationResult.Status == RemoteAppOperationStatus.Success ||
operationResult.RemoteAppOperationResult.Status == RemoteAppOperationStatus.Failed)
{
break;
}
else
{
TestUtilities.Wait(1000);
--retries;
}
}
Assert.True(retries > 0, "Failed getting the operation status to success or fail after 10 retries.");
Assert.NotNull(operationResult);
Assert.Equal(status, operationResult.RemoteAppOperationResult.Status);
}
public void CanSetAccount()
{
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
RemoteAppManagementClient client = GetRemoteAppManagementClient();
GetAccountResult accountResult = client.Account.Get();
Assert.NotNull(accountResult);
Assert.NotNull(accountResult.Details);
string oldName = accountResult.Details.EndUserFeedName;
string newName = "TestWorkspaceName";
AccountDetailsParameter param = new AccountDetailsParameter();
param.AccountInfo = new AccountUpdateDetails();//accountResult.Details;
param.AccountInfo.EndUserFeedName = newName;
OperationResultWithTrackingId result = client.Account.Set(param);
Assert.NotNull(result);
accountResult = client.Account.Get();
Assert.Equal(newName, accountResult.Details.EndUserFeedName);
param.AccountInfo.EndUserFeedName = oldName;
result = client.Account.Set(param);
Assert.NotNull(result);
}
}
private RemoteAppManagementClient GetRemoteAppManagementClient()
{
RemoteAppManagementClient client =
TestBase.GetServiceClient <RemoteAppManagementClient>(new RDFETestEnvironmentFactory());
client.RdfeNamespace = "rdst15";
return(client);
}
public void CanCreateVnet()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
HttpRecorderMode mode = HttpMockServer.GetCurrentMode();
RemoteAppManagementClient remoteAppManagementClient = GetRemoteAppManagementClient();
string vnetName = "hkutvnet1";
VNetParameter payload = new VNetParameter()
{
Region = "West US",
VnetAddressSpaces = new List <string>
{
"172.16.0.0/16"
},
LocalAddressSpaces = new List <string>
{
"11.0.0.0/16"
},
DnsServers = new List <string>()
{
"10.0.0.1"
},
VpnAddress = "13.0.0.1",
GatewayType = GatewayType.StaticRouting
};
Assert.DoesNotThrow(() =>
{
OperationResultWithTrackingId result = remoteAppManagementClient.VNet.CreateOrUpdate(vnetName, payload);
Assert.NotNull(result);
Assert.True(result.StatusCode == HttpStatusCode.OK || result.StatusCode == HttpStatusCode.Accepted, "StatusCode = " + result.StatusCode + "is not one of the expected");
if (result.StatusCode == HttpStatusCode.Accepted)
{
Assert.NotNull(result.TrackingId);
}
// verify the creation
VNetResult vnet = remoteAppManagementClient.VNet.Get(vnetName, false);
Assert.NotNull(vnet);
Assert.Equal(HttpStatusCode.OK, vnet.StatusCode);
Assert.NotNull(vnet.VNet);
Assert.Equal(vnetName, vnet.VNet.Name);
Assert.Equal(payload.VpnAddress, vnet.VNet.VpnAddress);
Assert.Equal(payload.GatewayType, vnet.VNet.GatewayType);
Assert.Equal(payload.Region, vnet.VNet.Region);
});
}
}
public void CanGetBillingPlans()
{
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
RemoteAppManagementClient client = GetRemoteAppManagementClient();
ListBillingPlansResult billingPlansResult = client.Account.ListBillingPlans();
Assert.NotNull(billingPlansResult);
Assert.NotEmpty(billingPlansResult.PlanList);
}
}
public void CanGetEnabledFeatures()
{
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
RemoteAppManagementClient client = GetRemoteAppManagementClient();
EnabledFeaturesResult enabledFeaturesResult = client.Account.GetEnabledFeatures();
Assert.NotNull(enabledFeaturesResult);
Assert.NotEmpty(enabledFeaturesResult.EnabledFeatures);
}
}
public void CanGetUploadScript()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
HttpRecorderMode mode = HttpMockServer.GetCurrentMode();
RemoteAppManagementClient remoteAppManagementClient = GetRemoteAppManagementClient();
UploadScriptResult scriptResult = remoteAppManagementClient.TemplateImages.GetUploadScript();
Assert.NotNull(scriptResult);
Assert.NotNull(scriptResult.Script);
}
}
public void CanEnsureStorageInRegion()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
HttpRecorderMode mode = HttpMockServer.GetCurrentMode();
RemoteAppManagementClient remoteAppManagementClient = GetRemoteAppManagementClient();
// Assume region to be "West US" for test purposes
OperationResultWithTrackingId ensureResult = remoteAppManagementClient.TemplateImages.EnsureStorageInRegion("West US");
Assert.NotNull(ensureResult);
}
}
private string GetCollectionName()
{
RemoteAppManagementClient remoteAppManagementClient = GetRemoteAppManagementClient();
CollectionListResult result = remoteAppManagementClient.Collections.List();
Assert.NotNull(result);
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
IList <Collection> colList = result.Collections;
Random r = new Random(42);
int index = r.Next(0, colList.Count - 1);
return(colList[index].Name);
}
private Collection CreateNewServiceWithPopulateOnlyTrue(RemoteAppManagementClient client)
{
string name = "hsut2861";
string activeDirectoryName = "ghutad";
string billingPlanName = "Standard";
string templateName = "bluerefresh.2014.08.21.vhd"; //GetReadyTemplateImageName(client);
ActiveDirectoryConfig adDetails = new ActiveDirectoryConfig()
{
DomainName = activeDirectoryName,
UserName = "******",
Password = "******"
};
CollectionCreationDetails collectionDetails = new CollectionCreationDetails()
{
Name = name,
AdInfo = adDetails,
PlanName = billingPlanName,
TemplateImageName = templateName,
Description = "OneSDK test created.",
Mode = CollectionMode.Apps,
ReadyForPublishing = true,
VNetName = "SomeVnet"
};
OperationResultWithTrackingId result = null;
Assert.DoesNotThrow(() =>
{
result = client.Collections.Create(true, collectionDetails);
});
Assert.NotNull(result);
// if OK is returned then the tracking id is the name of the newly created collection
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
Assert.NotNull(result.TrackingId);
// now check if the object is actually created at the backend
CollectionResult queriedService = client.Collections.Get(collectionDetails.Name);
Assert.Equal(HttpStatusCode.OK, queriedService.StatusCode);
Assert.Equal(queriedService.Collection.Name, name);
Assert.Equal(queriedService.Collection.PlanName, collectionDetails.PlanName);
Assert.Equal(queriedService.Collection.TemplateImageName, collectionDetails.TemplateImageName);
Assert.Equal(queriedService.Collection.Status, "Creating");
return(queriedService.Collection);
}
public void CanRestartVm()
{
using (UndoContext undoContext = UndoContext.Current)
{
undoContext.Start();
RemoteAppManagementClient client = GetRemoteAppManagementClient();
CollectionListResult collectionList = null;
Assert.DoesNotThrow(() =>
{
collectionList = client.Collections.List();
});
Assert.NotNull(collectionList);
Assert.NotEmpty(collectionList.Collections);
foreach (Collection collection in collectionList.Collections)
{
CollectionVmsListResult vmsList = null;
Assert.DoesNotThrow(() =>
{
vmsList = client.Collections.ListVms(collection.Name);
});
Assert.NotNull(vmsList);
Assert.NotEmpty(vmsList.Vms);
Assert.DoesNotThrow(() =>
{
RestartVmCommandParameter restartParam = new RestartVmCommandParameter();
restartParam.VirtualMachineName = vmsList.Vms[0].VirtualMachineName;
restartParam.LogoffMessage = "You will be logged off after 2 minutes";
restartParam.LogoffWaitTimeInSeconds = 120;
OperationResultWithTrackingId restartResult = client.Collections.RestartVm(collection.Name, restartParam);
Assert.True(restartResult.StatusCode == HttpStatusCode.OK);
Assert.NotNull(restartResult.TrackingId);
});
break;
}
}
}
public void CanResetVpnSharedKey()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
HttpRecorderMode mode = HttpMockServer.GetCurrentMode();
RemoteAppManagementClient remoteAppManagementClient = GetRemoteAppManagementClient();
Assert.DoesNotThrow(() =>
{
string vNet = "hkutvnet1";
// lets remember the vpn shared key before the reset request
VNetResult vnetBefore = remoteAppManagementClient.VNet.Get(vNet, true);
Assert.Equal(HttpStatusCode.OK, vnetBefore.StatusCode);
Assert.NotNull(vnetBefore.VNet);
Assert.Equal(vNet, vnetBefore.VNet.Name);
Assert.NotNull(vnetBefore.VNet.SharedKey);
// now reset the key
OperationResultWithTrackingId result = remoteAppManagementClient.VNet.ResetVpnSharedKey(vNet);
Assert.NotNull(result);
Assert.InRange(result.StatusCode, HttpStatusCode.OK, HttpStatusCode.Accepted);
if (result.StatusCode == HttpStatusCode.Accepted)
{
Assert.NotNull(result.TrackingId);
TrackingId = result.TrackingId;
}
VNetOperationStatusResult vnetOperationResult = remoteAppManagementClient.VNet.GetResetVpnSharedKeyOperationStatus(TrackingId);
Assert.NotNull(vnetOperationResult);
Assert.Equal(HttpStatusCode.OK, vnetOperationResult.StatusCode);
// lets check if the key is actually reset
VNetResult vnetAfter = remoteAppManagementClient.VNet.Get(vNet, true);
Assert.Equal(HttpStatusCode.OK, vnetAfter.StatusCode);
Assert.NotNull(vnetAfter.VNet);
Assert.Equal(vNet, vnetAfter.VNet.Name);
Assert.NotNull(vnetAfter.VNet.SharedKey);
// make sure that the key before and after does not match
Assert.NotEqual(vnetBefore.VNet.SharedKey, vnetAfter.VNet.SharedKey);
});
}
}
public void CanListTemplateImagesSuccessfully()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
HttpRecorderMode mode = HttpMockServer.GetCurrentMode();
RemoteAppManagementClient remoteAppManagementClient = GetRemoteAppManagementClient();
Assert.DoesNotThrow(() =>
{
TemplateImageListResult response = remoteAppManagementClient.TemplateImages.List();
IList <TemplateImage> templateImageList = response.RemoteAppTemplateImageList;
});
}
}
public void CanExportUserDisk()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
HttpRecorderMode mode = HttpMockServer.GetCurrentMode();
RemoteAppManagementClient remoteAppManagementClient = GetRemoteAppManagementClient();
string collectionName = "collectionname";
string accountKey = "accountkey";
string accountName = "accountname";
string containerName = "containername";
OperationResultWithTrackingId result = remoteAppManagementClient.UserDisks.Migrate(collectionName, accountName, accountKey, containerName, true);
Assert.NotNull(result);
}
}
public void CanGetAccount()
{
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
RemoteAppManagementClient client = GetRemoteAppManagementClient();
GetAccountResult accountResult = client.Account.Get();
Assert.NotNull(accountResult);
Assert.NotNull(accountResult.Details);
Assert.False(string.IsNullOrWhiteSpace(accountResult.Details.ClientUrl), "The client URL is empty.");
Assert.False(string.IsNullOrWhiteSpace(accountResult.Details.EndUserFeedName), "The Workspace name is empty.");
}
}
public void CanSendMessageToASessionInACollection()
{
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
RemoteAppManagementClient client = GetRemoteAppManagementClient();
SessionSendMessageCommandParameter parameter = new SessionSendMessageCommandParameter
{
UserUpn = "*****@*****.**",
Message = "Hello there!"
};
// testing the web fault
OperationResultWithTrackingId response = null;
response = client.Collections.SendMessageToSession("simple", parameter);
Assert.NotNull(response);
Assert.NotNull(response.TrackingId);
Assert.Equal(HttpStatusCode.Accepted, response.StatusCode);
AssertLongrunningOperation(client, RemoteAppOperationStatus.Success, response.TrackingId);
CollectionSessionListResult sessionList = client.Collections.ListSessions("simple");
Assert.NotNull(sessionList);
Assert.NotNull(sessionList.Sessions);
Assert.True(sessionList.StatusCode == HttpStatusCode.OK);
Assert.NotEmpty(sessionList.Sessions);
RemoteAppSession session = null;
foreach (var s in sessionList.Sessions)
{
if (s.UserUpn == parameter.UserUpn)
{
session = s;
break;
}
}
Assert.NotNull(session);
Assert.True(session.State == SessionState.Connected);
}
}
public void CanDeleteVnet()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
HttpRecorderMode mode = HttpMockServer.GetCurrentMode();
RemoteAppManagementClient remoteAppManagementClient = GetRemoteAppManagementClient();
VNet vnet = null;
// verify the creation
VNetListResult vnetList = null;
Assert.DoesNotThrow(() =>
{
vnetList = remoteAppManagementClient.VNet.List();
});
Assert.NotNull(vnetList);
Assert.Equal(HttpStatusCode.OK, vnetList.StatusCode);
Assert.NotNull(vnetList.VNetList);
Assert.NotEmpty(vnetList.VNetList);
foreach (VNet v in vnetList.VNetList)
{
if (Regex.IsMatch(v.Name, @"^hkutvnet"))
{
// found a match
if (v.State == VNetState.Connecting || v.State == VNetState.Ready)
{
vnet = v;
break;
}
}
}
Assert.NotNull(vnet);
OperationResultWithTrackingId deleteResult = remoteAppManagementClient.VNet.Delete(vnet.Name);
Assert.NotNull(deleteResult);
Assert.True(deleteResult.StatusCode == HttpStatusCode.OK || deleteResult.StatusCode == HttpStatusCode.Accepted, "StatusCode = " + deleteResult.StatusCode + "is not one of the expected");
if (deleteResult.StatusCode == HttpStatusCode.Accepted)
{
Assert.NotNull(deleteResult.TrackingId);
}
}
}
public void CanGetRemoteAppServiceList()
{
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
RemoteAppManagementClient client = GetRemoteAppManagementClient();
Assert.DoesNotThrow(() =>
{
var serviceList = client.Collections.List();
Assert.Equal(serviceList.StatusCode, HttpStatusCode.OK);
Assert.NotEmpty(serviceList.Collections);
});
}
}
private IEnumerable<Collection> GetAllActiveCollections(RemoteAppManagementClient client)
{
CollectionListResult result = client.Collections.List();
Assert.NotNull(result);
Assert.True(result.StatusCode == System.Net.HttpStatusCode.OK, "Failed retrieving the list of collections.");
IEnumerable<Collection> activeCollections = result.Collections.Where(
(service, index) =>
{
return string.Equals(service.Status, "Active", StringComparison.OrdinalIgnoreCase);
});
Assert.True(activeCollections.Count() > 0, "No active collection exist for the test.");
return activeCollections;
}
private IEnumerable <Collection> GetAllActiveCollections(RemoteAppManagementClient client)
{
CollectionListResult result = client.Collections.List();
Assert.NotNull(result);
Assert.True(result.StatusCode == System.Net.HttpStatusCode.OK, "Failed retrieving the list of collections.");
IEnumerable <Collection> activeCollections = result.Collections.Where(
(service, index) =>
{
return(string.Equals(service.Status, "Active", StringComparison.OrdinalIgnoreCase));
});
Assert.True(activeCollections.Count() > 0, "No active collection exist for the test.");
return(activeCollections);
}
public void CanLogOffASessionFromACollection()
{
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
RemoteAppManagementClient client = GetRemoteAppManagementClient();
SessionCommandParameter parameter = new SessionCommandParameter
{
UserUpn = "*****@*****.**"
};
// testing the web fault
OperationResultWithTrackingId response = null;
response = client.Collections.LogoffSession("simple", parameter);
Assert.NotNull(response);
Assert.NotNull(response.TrackingId);
Assert.Equal(HttpStatusCode.Accepted, response.StatusCode);
AssertLongrunningOperation(client, RemoteAppOperationStatus.Success, response.TrackingId);
TestUtilities.Wait(20000); //wait a little bit
CollectionSessionListResult sessionList = client.Collections.ListSessions("simple");
Assert.NotNull(sessionList);
Assert.NotNull(sessionList.Sessions);
Assert.True(sessionList.StatusCode == HttpStatusCode.OK);
RemoteAppSession session = null;
foreach (var s in sessionList.Sessions)
{
if (s.UserUpn == parameter.UserUpn)
{
session = s;
break;
}
}
Assert.Null(session);
}
}
public void CanGetVnetList()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
HttpRecorderMode mode = HttpMockServer.GetCurrentMode();
RemoteAppManagementClient remoteAppManagementClient = GetRemoteAppManagementClient();
Assert.DoesNotThrow(() =>
{
VNetListResult result = remoteAppManagementClient.VNet.List();
Assert.NotNull(result);
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
AssertNotNullOrEmpty(result.RequestId);
ValidateVnets(result.VNetList);
});
}
}
public void CanGetVpnConfigScript()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
HttpRecorderMode mode = HttpMockServer.GetCurrentMode();
RemoteAppManagementClient remoteAppManagementClient = GetRemoteAppManagementClient();
Assert.DoesNotThrow(() =>
{
string vNet = TestVnet;
VNetConfigScriptResult result = remoteAppManagementClient.VNet.GetVpnDeviceConfigScript(vNet, "Cisco Systems, Inc.", "ASA 5500 Series Adaptive Security Appliances", "ASA Software 8.3");
Assert.NotNull(result);
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
AssertNotNullOrEmpty(result.ConfigScript);
});
}
}
private string GetVNetName()
{
if (UseTestVnet)
{
return(TestVnet);
}
else
{
RemoteAppManagementClient remoteAppManagementClient = GetRemoteAppManagementClient();
VNetListResult vnets = remoteAppManagementClient.VNet.List();
Assert.NotNull(vnets);
Assert.Equal(HttpStatusCode.OK, vnets.StatusCode);
IList <VNet> vnetsList = vnets.VNetList;
Random r = new Random(42);
int index = r.Next(0, vnetsList.Count - 1);
return(vnetsList[index].Name);
}
}
private Collection CreateNewServiceWithPopulateOnlyTrue(RemoteAppManagementClient client)
{
string name = "hsut2861";
string activeDirectoryName = "ghutad";
string billingPlanName = "Standard";
string templateName = "bluerefresh.2014.08.21.vhd"; //GetReadyTemplateImageName(client);
ActiveDirectoryConfig adDetails = new ActiveDirectoryConfig()
{
DomainName = activeDirectoryName,
UserName = "******",
Password = "******"
};
CollectionCreationDetails collectionDetails = new CollectionCreationDetails()
{
Name = name,
AdInfo = adDetails,
PlanName = billingPlanName,
TemplateImageName = templateName,
Description = "OneSDK test created.",
Mode = CollectionMode.Apps,
ReadyForPublishing = true,
VNetName = "SomeVnet"
};
OperationResultWithTrackingId result = null;
Assert.DoesNotThrow(() =>
{
result = client.Collections.Create(true, collectionDetails);
});
Assert.NotNull(result);
// if OK is returned then the tracking id is the name of the newly created collection
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
Assert.NotNull(result.TrackingId);
// now check if the object is actually created at the backend
CollectionResult queriedService = client.Collections.Get(collectionDetails.Name);
Assert.Equal(HttpStatusCode.OK, queriedService.StatusCode);
Assert.Equal(queriedService.Collection.Name, name);
Assert.Equal(queriedService.Collection.PlanName, collectionDetails.PlanName);
Assert.Equal(queriedService.Collection.TemplateImageName, collectionDetails.TemplateImageName);
Assert.Equal(queriedService.Collection.Status, "Creating");
return queriedService.Collection;
}
private static void AssertLongrunningOperation(RemoteAppManagementClient client, RemoteAppOperationStatus status, String operationTrackingId)
{
int retries = 10;
RemoteAppOperationStatusResult operationResult = null;
//check for the operation status to success
while (retries > 0)
{
operationResult = null;
Assert.DoesNotThrow(() =>
{
operationResult = client.OperationResults.Get(operationTrackingId);
});
Assert.Equal(operationResult.StatusCode, HttpStatusCode.OK);
if (operationResult.RemoteAppOperationResult.Status == RemoteAppOperationStatus.Success ||
operationResult.RemoteAppOperationResult.Status == RemoteAppOperationStatus.Failed)
{
break;
}
else
{
TestUtilities.Wait(1000);
--retries;
}
}
Assert.True(retries > 0, "Failed getting the operation status to success or fail after 10 retries.");
Assert.NotNull(operationResult);
Assert.Equal(status, operationResult.RemoteAppOperationResult.Status);
}
private GetPublishedApplicationResult WaitForAppStatus(RemoteAppManagementClient client, string collectionId, string appAlias, AppPublishingStatus status)
{
// Wait for application status to change to "Published"
GetPublishedApplicationResult publishedAppResult = null;
int retryCount = 0;
do
{
// Need not wait in Mock environment
if (HttpMockServer.Mode != HttpRecorderMode.Playback)
{
TestUtilities.Wait(AppPublihingStatusCheckIntervalSeconds * 1000);
}
publishedAppResult = client.Publishing.Get(collectionId, appAlias);
Assert.NotNull(publishedAppResult);
Assert.NotNull(publishedAppResult.Result);
Assert.True(publishedAppResult.StatusCode == HttpStatusCode.OK);
retryCount++;
} while (retryCount < AppPublihingStatusCheckMaxRetries &&
publishedAppResult.Result.Status != status);
Assert.True(retryCount < AppPublihingStatusCheckMaxRetries);
return publishedAppResult;
}
private string GetReadyTemplateImageName(RemoteAppManagementClient client)
{
string activeImageName = string.Empty;
TemplateImageListResult allImageList = client.TemplateImages.List();
Assert.NotNull(allImageList);
Assert.Equal(HttpStatusCode.OK, allImageList.StatusCode);
Assert.NotNull(allImageList.RemoteAppTemplateImageList);
Assert.NotEmpty(allImageList.RemoteAppTemplateImageList);
foreach (TemplateImage image in allImageList.RemoteAppTemplateImageList)
{
if (image.Status == TemplateImageStatus.Ready)
{
activeImageName = image.Name;
break;
}
}
Assert.False(string.IsNullOrEmpty(activeImageName), "Ready template image name is empty.");
return activeImageName;
}
private void ValidateAD(RemoteAppManagementClient client, ActiveDirectoryConfig adConfig)
{
AssertNotNullOrEmpty(adConfig.DomainName);
AssertNotNullOrEmpty(adConfig.UserName);
}
