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 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;
});
}
}
private bool GetAllTemplates()
{
TemplateImageListResult response = null;
response = CallClient(() => Client.TemplateImages.List(), Client.TemplateImages);
if (response != null)
{
List <TemplateImage> customerImages = new List <TemplateImage>();
List <TemplateImage> platformImages = new List <TemplateImage>();
List <TemplateImage> unknownImages = new List <TemplateImage>();
foreach (TemplateImage image in response.RemoteAppTemplateImageList)
{
if (UseWildcard && !Wildcard.IsMatch(image.Name))
{
continue;
}
switch (image.Type)
{
case TemplateImageType.CustomerImage:
{
customerImages.Add(image);
break;
}
case TemplateImageType.PlatformImage:
{
platformImages.Add(image);
break;
}
default:
{
unknownImages.Add(image);
break;
}
}
}
WriteImage(unknownImages);
WriteImage(customerImages);
WriteImage(platformImages);
}
return(found);
}
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);
}
public static int SetUpDefaultRemoteAppTemplates(Mock <IRemoteAppManagementClient> clientMock, string imageName, string id)
{
TemplateImageListResult response = new TemplateImageListResult()
{
RequestId = "122-13342",
StatusCode = System.Net.HttpStatusCode.Accepted,
};
response.RemoteAppTemplateImageList = new List <TemplateImage>()
{
new TemplateImage()
{
Name = imageName,
Status = TemplateImageStatus.Ready,
Id = id,
NumberOfLinkedCollections = 2,
Type = TemplateImageType.PlatformImage,
RegionList = new List <string>()
{
"West US"
}
},
new TemplateImage()
{
Name = "a",
Status = TemplateImageStatus.Ready,
Id = "2222",
NumberOfLinkedCollections = 2,
Type = TemplateImageType.PlatformImage,
RegionList = new List <string>()
{
"West US"
}
},
new TemplateImage()
{
Name = "ztestImage",
Status = TemplateImageStatus.Ready,
Id = "4444",
NumberOfLinkedCollections = 2,
Type = TemplateImageType.CustomerImage,
RegionList = new List <string>()
{
"West US"
}
},
new TemplateImage()
{
Name = "atestImage",
Status = TemplateImageStatus.Ready,
Id = "3333",
NumberOfLinkedCollections = 1,
Type = TemplateImageType.CustomerImage,
RegionList = new List <string>()
{
"West US"
}
}
};
mockTemplates = new List <TemplateImage>();
foreach (TemplateImage image in response.RemoteAppTemplateImageList)
{
TemplateImage mockImage = new TemplateImage()
{
Name = image.Name,
Status = image.Status,
Id = image.Id,
NumberOfLinkedCollections = image.NumberOfLinkedCollections,
Type = image.Type,
RegionList = image.RegionList
};
mockTemplates.Add(mockImage);
}
ISetup <IRemoteAppManagementClient, Task <TemplateImageListResult> > Setup = clientMock.Setup(c => c.TemplateImages.ListAsync(It.IsAny <CancellationToken>()));
Setup.Returns(Task.Factory.StartNew(() => response));
return(mockTemplates.Count);
}
protected TemplateImage FilterTemplateImage(string TemplateImageName, Operation op)
{
TemplateImageListResult response = null;
TemplateImage matchingTemplate = null;
string errorMessage = null;
ErrorCategory category = ErrorCategory.NotSpecified;
response = CallClient_ThrowOnError(() => Client.TemplateImages.List());
foreach (TemplateImage template in response.RemoteAppTemplateImageList)
{
if (String.Equals(template.Name, TemplateImageName, StringComparison.OrdinalIgnoreCase))
{
matchingTemplate = template;
break;
}
}
switch (op)
{
case Operation.Remove:
case Operation.Update:
{
if (matchingTemplate == null)
{
errorMessage = String.Format("Template {0} does not exist.", TemplateImageName);
category = ErrorCategory.ObjectNotFound;
}
break;
}
case Operation.Create:
{
if (matchingTemplate != null)
{
errorMessage = String.Format("There is an existing template named {0}.", TemplateImageName);
category = ErrorCategory.ResourceExists;
}
break;
}
case Operation.Resume:
{
if (matchingTemplate == null)
{
errorMessage = String.Format("Template {0} does not exist.", TemplateImageName);
category = ErrorCategory.ObjectNotFound;
}
else if (matchingTemplate.Status != TemplateImageStatus.UploadPending &&
matchingTemplate.Status != TemplateImageStatus.UploadInProgress)
{
errorMessage = String.Format(
"Unable to resume uploading this template {0}." +
"It is in the wrong state {1}, it should be either UploadPending or UploadInProgress",
matchingTemplate.Name,
matchingTemplate.Status.ToString());
category = ErrorCategory.InvalidOperation;
}
else if (DateTime.UtcNow >= matchingTemplate.SasExpiry)
{
errorMessage = String.Format(
"Unable to resume uploading this template {0}. The time limit has expired at {1}",
matchingTemplate.Name,
matchingTemplate.SasExpiry.ToString());
category = ErrorCategory.InvalidOperation;
}
break;
}
}
if (errorMessage != null)
{
throw new RemoteAppServiceException(errorMessage, category);
}
return(matchingTemplate);
}
public void CanCreateTemplateImagesSuccessfully()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
string imageName = "my_unit_test_created_templateimage";
string returnedImageName = null;
HttpRecorderMode mode = HttpMockServer.GetCurrentMode();
RemoteAppManagementClient client = GetRemoteAppManagementClient();
TemplateImageResult setResponse;
AzureOperationResponse deleteResponse;
TemplateImageListResult listResponse = null;
IList <TemplateImage> imageList;
TemplateImage myImage = null;
bool foundTestImage = false;
string newName = "renamed_my_test_image";
TemplateImageDetails renameDetails = null;
TemplateImageDetails newImageDetails = new TemplateImageDetails()
{
Name = imageName,
Region = "West US"
};
Assert.DoesNotThrow(() =>
{
setResponse = client.TemplateImages.Set(newImageDetails);
});
// now check the list
Assert.DoesNotThrow(() =>
{
listResponse = client.TemplateImages.List();
imageList = listResponse.RemoteAppTemplateImageList;
foreach (TemplateImage image in imageList)
{
if ((image.Name == imageName))
{
foreach (string region in image.RegionList)
{
if (region == newImageDetails.Region)
{
foundTestImage = true;
// cleanup
returnedImageName = image.Name;
myImage = image;
break;
}
}
}
}
});
Assert.True(foundTestImage);
Assert.False(string.IsNullOrEmpty(returnedImageName));
Assert.NotNull(myImage);
// rename the image
renameDetails = new TemplateImageDetails()
{
Id = myImage.Id,
Name = newName,
Region = "West US"
};
setResponse = null;
Assert.DoesNotThrow(() =>
{
setResponse = client.TemplateImages.Set(renameDetails);
});
Assert.NotNull(setResponse);
Assert.NotNull(setResponse.TemplateImage);
Assert.Equal(System.Net.HttpStatusCode.OK, setResponse.StatusCode);
// verify that we have an image with the new name
TemplateImageResult imageResponse = null;
Assert.DoesNotThrow(() =>
{
imageResponse = client.TemplateImages.Get(newName);
});
Assert.NotNull(imageResponse);
Assert.NotNull(imageResponse.TemplateImage);
Assert.Equal(newName, imageResponse.TemplateImage.Name);
Assert.True(imageResponse.TemplateImage.RegionList.Contains("West US"), "Unexpected region of the renamed image: " + String.Join(", ", imageResponse.TemplateImage.RegionList));
Assert.DoesNotThrow(() =>
{
deleteResponse = client.TemplateImages.Delete(newName);
});
}
}
