public void Should_get_200_OK_or_204_No_Content_when_item_exists()
{
using (var testHelper = new TestHelper(authToken, storageUrl))
{
try
{
testHelper.PutItemInContainer(Constants.HeadStorageItemName);
testHelper.AddMetadataToItem(Constants.HeadStorageItemName);
var getStorageItemInformation = new GetStorageItemInformation(storageUrl, Constants.CONTAINER_NAME, Constants.HeadStorageItemName);
var getStorageItemInformationResponse = new GenerateRequestByType().Submit(
getStorageItemInformation, authToken);
Assert.That(getStorageItemInformationResponse.Status == HttpStatusCode.OK
|| getStorageItemInformationResponse.Status == HttpStatusCode.NoContent, Is.True);
var metadata = getStorageItemInformationResponse.Metadata;
Assert.That(metadata["Test"], Is.EqualTo("test"));
Assert.That(metadata["Test2"], Is.EqualTo("test2"));
}
finally
{
testHelper.DeleteItemFromContainer(Constants.HeadStorageItemName);
}
}
}
public void SetUpDataBinding()
{
//temporary lines, this lines should be another place
TestHelper th = new TestHelper();
control1.CreateRootNode(th.GetTestDescriptor);
control1.CreateTreeNodes(th.GetTestBinding);
}
public void Should_fail_when_an_invalid_paramter_is_passed()
{
using (TestHelper testHelper = new TestHelper(authToken, storageUrl))
{
for (int i = 0; i < 12; ++i)
testHelper.PutItemInContainer(Constants.StorageItemName, i.ToString());
try
{
Dictionary<GetItemListParameters, string> parameters =
new Dictionary<GetItemListParameters, string> {{(GetItemListParameters) int.MaxValue, "2"}};
new GetContainerItemList(storageUrl, Constants.CONTAINER_NAME, parameters);
}
catch (NotImplementedException ne)
{
Assert.That(ne, Is.TypeOf(typeof (NotImplementedException)));
}
finally
{
for (int i = 0; i < 12; ++i)
testHelper.DeleteItemFromContainer(i.ToString());
}
}
}
public void SetUpDataBinding()
{
//temporary lines, this lines should be another place
TestHelper th = new TestHelper();
control1.CreateRootNode(th.GetTestDescriptor);
control1.CreateTreeNodes(th.GetTestBinding);
control1.ControllerView.AfterSelect += FillInfoListBox;
}
public void SetupTestingAssists()
{
_testHelper = new TestHelper();
var parameterNames = MethodInfoExtensions.GetMethodInfo<IProxyFactory>(x => x.CreateVersioning<object>(null, null, null))
.GetParameters()
.Select(param => param.Name);
parameterNames.Should().Contain(new[] { ExistingControllerArgumentName, ExistingObjectArgumentName });
}
public void CreateDummyfiles()
{
_testHelper = new TestHelper(DefaultTestfileFolderPath);
if (Directory.Exists(DummyImportFolderPath)) Directory.Delete(DummyImportFolderPath, true);
if (Directory.Exists(DummyExportFolderPath)) Directory.Delete(DummyExportFolderPath, true);
Directory.CreateDirectory(DummyImportFolderPath);
File.WriteAllText(DummyImportFolderPath + "/a", "bli");
File.WriteAllText(DummyImportFolderPath + "/b", "bla");
File.WriteAllText(DummyImportFolderPath + "/c", "blub");
}
public void Should_return_created_when_etag_is_not_supplied_because_it_is_optional()
{
using (TestHelper testHelper = new TestHelper(authToken, storageUrl))
{
var putStorageItem = new PutStorageItem(storageUrl, authToken, Constants.CONTAINER_NAME, Constants.StorageItemName, Constants.StorageItemName);
putStorageItem.Headers.Remove("ETag");
var response = new ResponseFactory<CloudFilesResponse>().Create(new CloudFilesRequest(putStorageItem));
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.Created));
testHelper.DeleteItemFromContainer();
}
}
public void Should_return_created_when_a_stream_is_passed_instead_of_a_file_name()
{
using (var testHelper = new TestHelper(authToken, storageUrl))
{
var fs = new FileStream(Constants.StorageItemName, FileMode.Open, FileAccess.Read);
var putStorageItem = new PutStorageItem(storageUrl, Constants.CONTAINER_NAME, Constants.StorageItemName, fs, null);
var response = new GenerateRequestByType().Submit(putStorageItem, authToken);
fs.Close();
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.Created));
testHelper.DeleteItemFromContainer();
}
}
public void should_return_204_no_content_when_the_item_exists()
{
using (TestHelper testHelper = new TestHelper(authToken, storageUrl))
{
testHelper.PutItemInContainer();
var deleteStorageItem = new DeleteStorageItem(storageUrl, authToken, Constants.CONTAINER_NAME, Constants.StorageItemName);
var response = new ResponseFactory<CloudFilesResponse>().Create(new CloudFilesRequest(deleteStorageItem));
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.NoContent));
Assert.That(response.Headers["Content-Type"].Contains("text/plain"), Is.True);
}
}
public void should_return_204_no_content_when_the_item_exists()
{
using (TestHelper testHelper = new TestHelper(authToken, storageUrl))
{
testHelper.PutItemInContainer();
var deleteStorageItem = new DeleteStorageItem(storageUrl, Constants.CONTAINER_NAME, Constants.StorageItemName);
var response = new GenerateRequestByType().Submit(deleteStorageItem,authToken );
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.NoContent));
Console.WriteLine(response.Headers["Content-Type"]);
Assert.That(Regex.Match(response.Headers["Content-Type"], "text/(plain|html)").Success, Is.True);
}
}
public void Should_return_no_content_when_the_container_exists()
{
using (var testHelper = new TestHelper(authToken, storageUrl))
{
testHelper.PutItemInContainer(Constants.StorageItemName, Constants.StorageItemName);
var getContainerInformation = new GetContainerInformation(storageUrl, Constants.CONTAINER_NAME);
var informationResponse = new GenerateRequestByType().Submit(getContainerInformation, authToken);
Assert.That(informationResponse.Status, Is.EqualTo(HttpStatusCode.NoContent));
Assert.That(informationResponse.Headers[Constants.XContainerObjectCount], Is.EqualTo("1"));
Assert.That(informationResponse.Headers[Constants.XContainerBytesUsed], (Is.Not.Null));
testHelper.DeleteItemFromContainer(Constants.StorageItemName);
}
}
public void Should_return_created_as_status_when_the_file_does_not_already_exist()
{
using (TestHelper testHelper = new TestHelper(authToken, storageUrl))
{
var putStorageItem = new PutStorageItem(storageUrl, authToken, Constants.CONTAINER_NAME, Constants.StorageItemName, Constants.StorageItemName);
Assert.That(putStorageItem.ContentLength, Is.EqualTo(34));
var response = new ResponseFactory<CloudFilesResponse>().Create(new CloudFilesRequest(putStorageItem));
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.Created));
Assert.That(response.Headers[Constants.ETAG], Is.EqualTo(putStorageItem.ETag));
testHelper.DeleteItemFromContainer();
}
}
public void Should_return_created_as_status_when_the_file_does_not_already_exist()
{
using (var testHelper = new TestHelper(authToken, storageUrl))
{
var putStorageItem = new PutStorageItem(storageUrl, Constants.CONTAINER_NAME, Constants.StorageItemName, Constants.StorageItemName);
// Assert.That(putStorageItem.ContentLength, Is.EqualTo(34)); //does not belong in this test
var response = new GenerateRequestByType().Submit(putStorageItem, authToken);
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.Created));
Assert.That(response.Headers[Constants.ETAG], Is.EqualTo(response.ETag));
testHelper.DeleteItemFromContainer();
}
}
public void Should_get_serialized_json_format()
{
var testHelper = new TestHelper(authToken, storageUrl);
testHelper.PutItemInContainer(Constants.StorageItemNameJpg);
var getContainerInformation = new GetContainerInformationSerialized(storageUrl, Constants.CONTAINER_NAME, Format.JSON);
var jsonResponse = new GenerateRequestByType().Submit(getContainerInformation, authToken);
Assert.That(jsonResponse.Status, Is.EqualTo(HttpStatusCode.OK));
var jsonReturnValue = String.Join("", jsonResponse.ContentBody.ToArray());
jsonResponse.Dispose();
var expectedSubString = "[{\"name\":[ ]?\"" + Constants.StorageItemNameJpg + "\",[ ]?\"hash\":[ ]?\"b44a59383b3123a747d139bd0e71d2df\",[ ]?\"bytes\":[ ]?\\d+,[ ]?\"content_type\":[ ]?\"image.*jpeg\",[ ]?\"last_modified\":[ ]?\"" + String.Format("{0:yyyy-MM}", DateTime.Now);
Assert.That(Regex.Match(jsonReturnValue, expectedSubString).Success, Is.True);
testHelper.DeleteItemFromContainer(Constants.StorageItemNameJpg);
testHelper.Dispose();
}
public void Should_get_serialized_xml_format()
{
using (var testHelper = new TestHelper(authToken, storageUrl))
{
testHelper.PutItemInContainer(Constants.StorageItemNameJpg);
var getContainerInformation = new GetContainerInformationSerialized(storageUrl, Constants.CONTAINER_NAME, Format.XML);
var xmlResponse = new GenerateRequestByType().Submit(getContainerInformation, authToken);
Assert.That(xmlResponse.Status, Is.EqualTo(HttpStatusCode.OK));
var xmlReturnValue = String.Join("", xmlResponse.ContentBody.ToArray());
xmlResponse.Dispose();
var expectedSubString = "<container name=\"" + Constants.CONTAINER_NAME + "\"><object><name>" + Constants.StorageItemNameJpg + "<\\/name><hash>b44a59383b3123a747d139bd0e71d2df<\\/hash><bytes>\\d+<\\/bytes><content_type>image.*jpeg<\\/content_type><last_modified>" + String.Format("{0:yyyy-MM}", DateTime.Now);
Assert.That(Regex.Match(xmlReturnValue, expectedSubString).Success || string.IsNullOrEmpty(xmlReturnValue), Is.True);
testHelper.DeleteItemFromContainer(Constants.StorageItemNameJpg);
}
}
public void Should_return_created_when_content_length_is_not_supplied_because_it_is_optional()
{
using (var testHelper = new TestHelper(authToken, storageUrl))
{
var putStorageItem = new PutStorageItem(storageUrl, Constants.CONTAINER_NAME, Constants.StorageItemName, Constants.StorageItemName);
var uri = putStorageItem.CreateUri();
var request = new CloudFilesRequest(uri);
putStorageItem.Apply(request);
// request.ContentLength = 0;
request.Headers.Add("X-Auth-Token", HttpUtility.UrlEncode(authToken));
var response= request.GetResponse();
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.Created));
Assert.That(response.Headers[Constants.ETAG], Is.EqualTo(request.ETag));
testHelper.DeleteItemFromContainer();
}
}
public void Should_return_accepted_when_meta_information_is_supplied()
{
using (TestHelper testHelper = new TestHelper(authToken, storageUrl))
{
testHelper.PutItemInContainer();
Dictionary<string, string> metadata = new Dictionary<string, string>();
metadata.Add("Test", "test");
metadata.Add("Test2", "test2");
SetStorageItemMetaInformation setStorageItemMetaInformation = new SetStorageItemMetaInformation(storageUrl, authToken, Constants.CONTAINER_NAME, Constants.StorageItemName, metadata);
var metaInformationResponse = new ResponseFactory<CloudFilesResponse>().Create(new CloudFilesRequest(setStorageItemMetaInformation));
Assert.That(metaInformationResponse.Status, Is.EqualTo(HttpStatusCode.Accepted));
testHelper.DeleteItemFromContainer();
}
}
public void Should_return_ok_if_the_item_exists()
{
using (var testHelper = new TestHelper(authToken, storageUrl))
{
ICloudFilesResponse getStorageItemResponse = null;
try
{
testHelper.PutItemInContainer();
var getStorageItem = new GetStorageItem(storageUrl, Constants.CONTAINER_NAME, Constants.StorageItemName, requestHeaderFields);
getStorageItemResponse = new GenerateRequestByType().Submit(getStorageItem, authToken);
Assert.That(getStorageItemResponse.Status, Is.EqualTo(HttpStatusCode.OK));
}
finally
{
if (getStorageItemResponse != null) getStorageItemResponse.Dispose();
testHelper.DeleteItemFromContainer();
}
}
}
public void should_return_number_of_containers_and_bytes_used()
{
try
{
connection.CreateContainer(Constants.CONTAINER_NAME);
connection.PutStorageItem(Constants.CONTAINER_NAME, Constants.StorageItemName);
}
finally
{
connection.DeleteStorageItem(Constants.CONTAINER_NAME, Constants.StorageItemName);
connection.DeleteContainer(Constants.CONTAINER_NAME);
}
using (TestHelper testHelper = new TestHelper(authToken, storageUrl))
{
testHelper.PutItemInContainer(Constants.StorageItemName, Constants.StorageItemName);
GetAccountInformation getAccountInformation = new GetAccountInformation(storageUrl, authToken);
var response = new ResponseFactory<CloudFilesResponse>().Create(new CloudFilesRequest(getAccountInformation));
Assert.That(response.Headers[Constants.XAccountBytesUsed], Is.Not.Null);
Assert.That(response.Headers[Constants.XAccountContainerCount], Is.Not.Null);
testHelper.DeleteItemFromContainer(Constants.StorageItemName);
}
}
public void Should_get_204_No_Content_when_item_exists()
{
using (TestHelper testHelper = new TestHelper(authToken, storageUrl))
{
try
{
testHelper.PutItemInContainer(Constants.HeadStorageItemName);
testHelper.AddMetadataToItem(Constants.HeadStorageItemName);
var getStorageItemInformation = new GetStorageItemInformation(storageUrl, authToken, Constants.CONTAINER_NAME, Constants.HeadStorageItemName);
var getStorageItemInformationResponse = new ResponseFactory<CloudFilesResponse>().Create(new CloudFilesRequest(getStorageItemInformation));
Assert.That(getStorageItemInformationResponse.Status, Is.EqualTo(HttpStatusCode.NoContent));
var metadata = getStorageItemInformationResponse.Metadata;
Assert.That(metadata["Test"], Is.EqualTo("test"));
Assert.That(metadata["Test2"], Is.EqualTo("test2"));
}
finally
{
testHelper.DeleteItemFromContainer(Constants.HeadStorageItemName);
}
}
}
public void Should_return_item_if_the_item_exists_and_has_been_modified_since_designated_time()
{
requestHeaderFields = new Dictionary<RequestHeaderFields, string>
{{RequestHeaderFields.IfModifiedSince, pastDateTime.ToString()}};
using (var testHelper = new TestHelper(authToken, storageUrl))
{
ICloudFilesResponse getStorageItemResponse = null;
try
{
testHelper.PutItemInContainer();
var getStorageItem = new GetStorageItem(storageUrl, Constants.CONTAINER_NAME, Constants.StorageItemName, requestHeaderFields);
getStorageItemResponse = new GenerateRequestByType().Submit(getStorageItem, authToken);
Assert.That(getStorageItemResponse.Status, Is.EqualTo(HttpStatusCode.OK));
}
finally
{
if (getStorageItemResponse != null) getStorageItemResponse.Dispose();
testHelper.DeleteItemFromContainer();
}
}
}
public void Should_set_content_type_of_jpg_for_local_file_upload()
{
using (var testHelper = new TestHelper(authToken, storageUrl))
{
var putStorageItem = new PutStorageItem(storageUrl, Constants.CONTAINER_NAME, Constants.StorageItemNameJpg, Constants.StorageItemNameJpg);
// Assert.That(putStorageItem.ContentLength, Is.GreaterThan(0));
// Assert.That(putStorageItem.ContentType, Is.EqualTo("image/jpeg"));
var response = new GenerateRequestByType().Submit(putStorageItem, authToken);
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.Created));
Assert.That(response.Headers[Constants.ETAG], Is.EqualTo(response.ETag));
testHelper.DeleteItemFromContainer(Constants.StorageItemNameJpg);
}
}
public void CanUpdateVirtualMachineByAddingAndRemovingManagedDisks()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var publicIPDnsLabel = SdkContext.RandomResourceName("pip", 20);
var uname = "juser";
var password = "******";
// Create with implicit + explicit empty disks, check default and override
//
var vmName1 = "myvm1";
var explicitlyCreatedEmptyDiskName1 = SdkContext.RandomResourceName(vmName1 + "_mdisk_", 25);
var explicitlyCreatedEmptyDiskName2 = SdkContext.RandomResourceName(vmName1 + "_mdisk_", 25);
var explicitlyCreatedEmptyDiskName3 = SdkContext.RandomResourceName(vmName1 + "_mdisk_", 25);
var resourceManager = TestHelper.CreateRollupClient();
var computeManager = TestHelper.CreateComputeManager();
var rgName = TestUtilities.GenerateName("rgfluentchash-");
try
{
var resourceGroup = resourceManager.ResourceGroups
.Define(rgName)
.WithRegion(Location)
.Create();
var creatableEmptyDisk1 = computeManager.Disks
.Define(explicitlyCreatedEmptyDiskName1)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithData()
.WithSizeInGB(150);
var creatableEmptyDisk2 = computeManager.Disks
.Define(explicitlyCreatedEmptyDiskName2)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithData()
.WithSizeInGB(150);
var creatableEmptyDisk3 = computeManager.Disks
.Define(explicitlyCreatedEmptyDiskName3)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithData()
.WithSizeInGB(150);
var virtualMachine1 = computeManager.VirtualMachines
.Define(vmName1)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(publicIPDnsLabel)
.WithPopularLinuxImage(LinuxImage)
.WithRootUsername(uname)
.WithRootPassword(password)
// Start: Add bunch of empty managed disks
.WithNewDataDisk(100) // CreateOption: EMPTY
.WithNewDataDisk(100, 1, CachingTypes.ReadWrite) // CreateOption: EMPTY
.WithNewDataDisk(creatableEmptyDisk1) // CreateOption: ATTACH
.WithNewDataDisk(creatableEmptyDisk2, 2, CachingTypes.None) // CreateOption: ATTACH
.WithNewDataDisk(creatableEmptyDisk3, 3, CachingTypes.None) // CreateOption: ATTACH
// End : Add bunch of empty managed disks
.WithDataDiskDefaultCachingType(CachingTypes.ReadOnly)
.WithDataDiskDefaultStorageAccountType(StorageAccountTypes.StandardLRS)
.WithSize(VirtualMachineSizeTypes.StandardD5V2)
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
virtualMachine1.Update()
.WithoutDataDisk(1)
.WithNewDataDisk(100, 6, CachingTypes.ReadWrite) // CreateOption: EMPTY
.Apply();
var dataDisks = virtualMachine1.DataDisks;
Assert.NotNull(dataDisks);
Assert.Equal(5, dataDisks.Count); // Removed one added another
Assert.True(dataDisks.ContainsKey(6));
Assert.False(dataDisks.ContainsKey(1));
}
finally
{
try
{
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public void CanSetMSIOnNewOrExistingVMWithoutRoleAssignment()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var groupName = TestUtilities.GenerateName("rgmsi");
var region = Region.USSouthCentral;
var vmName = "javavm";
IAzure azure = null;
try
{
azure = TestHelper.CreateRollupClient();
// Create a virtual machine with just MSI enabled without role and scope.
//
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)
.WithManagedServiceIdentity()
.Create();
Assert.NotNull(virtualMachine);
Assert.NotNull(virtualMachine.Inner);
Assert.True(virtualMachine.IsManagedServiceIdentityEnabled);
Assert.NotNull(virtualMachine.ManagedServiceIdentityPrincipalId);
Assert.NotNull(virtualMachine.ManagedServiceIdentityTenantId);
// Ensure the MSI extension is set
//
var extensions = virtualMachine.ListExtensions();
IVirtualMachineExtension msiExtension = null;
foreach (var extension in extensions.Values)
{
if (extension.PublisherName.Equals("Microsoft.ManagedIdentity", StringComparison.OrdinalIgnoreCase) &&
extension.TypeName.Equals("ManagedIdentityExtensionForLinux", StringComparison.OrdinalIgnoreCase))
{
msiExtension = extension;
break;
}
}
Assert.NotNull(msiExtension);
// Check the default token port
//
var publicSettings = msiExtension.PublicSettings;
Assert.NotNull(publicSettings);
Assert.True(publicSettings.ContainsKey("port"));
Object portObj = publicSettings["port"];
Assert.NotNull(portObj);
int?port = ObjectToInteger(portObj);
Assert.True(port.HasValue);
Assert.NotNull(port);
Assert.Equal(50342, port);
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.ManagedServiceIdentityPrincipalId, StringComparison.OrdinalIgnoreCase))
{
found = true;
break;
}
}
Assert.False(found, "Resource group should not have a role assignment with virtual machine MSI principal");
virtualMachine = virtualMachine.Update()
.WithManagedServiceIdentity(50343)
.Apply();
Assert.NotNull(virtualMachine);
Assert.NotNull(virtualMachine.Inner);
Assert.True(virtualMachine.IsManagedServiceIdentityEnabled);
Assert.NotNull(virtualMachine.ManagedServiceIdentityPrincipalId);
Assert.NotNull(virtualMachine.ManagedServiceIdentityTenantId);
extensions = virtualMachine.ListExtensions();
msiExtension = null;
foreach (var extension in extensions.Values)
{
if (extension.PublisherName.Equals("Microsoft.ManagedIdentity", StringComparison.OrdinalIgnoreCase) &&
extension.TypeName.Equals("ManagedIdentityExtensionForLinux", StringComparison.OrdinalIgnoreCase))
{
msiExtension = extension;
break;
}
}
Assert.NotNull(msiExtension);
// Check the default token port
//
publicSettings = msiExtension.PublicSettings;
Assert.NotNull(publicSettings);
Assert.True(publicSettings.ContainsKey("port"));
portObj = publicSettings["port"];
Assert.NotNull(portObj);
port = ObjectToInteger(portObj);
Assert.True(port.HasValue);
Assert.NotNull(port);
Assert.Equal(50343, port);
rgRoleAssignments1 = authenticatedClient.RoleAssignments.ListByScope(resourceGroup.Id);
Assert.NotNull(rgRoleAssignments1);
found = false;
foreach (var roleAssignment in rgRoleAssignments1)
{
if (roleAssignment.PrincipalId != null && roleAssignment.PrincipalId.Equals(virtualMachine.ManagedServiceIdentityPrincipalId, StringComparison.OrdinalIgnoreCase))
{
found = true;
break;
}
}
Assert.False(found, "Resource group should not have a role assignment with virtual machine MSI principal");
}
finally
{
try
{
if (azure != null)
{
azure.ResourceGroups.BeginDeleteByName(groupName);
}
}
catch { }
}
}
}
public void MySqlProcedureTest()
{
const string providername = "MySql.Data.MySqlClient";
var connectionString = ConnectionStrings.MySql;
ProviderChecker.Check(providername, connectionString);
var dbReader = new DatabaseReader(connectionString, providername);
var schema = dbReader.ReadAll();
var procedure = schema.StoredProcedures
.Find(x => string.Equals(x.Name, "film_not_in_stock", StringComparison.OrdinalIgnoreCase));
if (procedure == null)
{
Assert.Inconclusive("No sproc film_not_in_stock in Sakila");
}
//getting the procedure resultsets is a special call
var runner = new ResultSetReader(schema);
runner.Execute();
var directory = TestHelper.CreateDirectory("MySqlSproc");
const string @namespace = "MySqlSproc.Domain";
var settings = new CodeWriterSettings
{
Namespace = @namespace,
CodeTarget = CodeTarget.Poco,
WriteStoredProcedures = true
};
//act
var codeWriter = new CodeWriter(schema, settings);
codeWriter.Execute(directory);
//assert
//This procedure produces a table of inventory ID numbers for the copies of the film not in stock,
//and returns (in the p_film_count parameter) a count that indicates the number of rows in that table.
//using (var connection = new MySqlConnection("Server=...;Database=sakila;Allow User Variables=True;"))
//{
// var sproc = new FilmNotInStock(connection);
// var result = sproc.Execute(2, 1);
// Console.WriteLine(result.PFilmCount);
// Console.WriteLine(string.Join(",", result.FilmNotInStockResult0.Select(x => x.InventoryId)));
//}
var procedures = directory.GetDirectories("Procedures").FirstOrDefault();
if (procedures == null)
{
Assert.Fail("Could not find Procedures subdirectory");
}
var files = procedures.GetFiles("*.cs");
var filmNotInStock = files.FirstOrDefault(f => f.Name == "FilmNotInStock.cs");
Assert.IsNotNull(filmNotInStock,
"Should have written FilmNotInStock class for film_not_in_stock procedure");
var cs = File.ReadAllText(filmNotInStock.FullName);
//there are 2 input parameters, an OUT parameter and a resultset.
Assert.IsTrue(cs.Contains("public virtual FilmNotInStockResult Execute(int? pFilmId, int? pStoreId)"),
"Generated input signature");
var result = files.FirstOrDefault(f => f.Name == "FilmNotInStockResult.cs");
Assert.IsNotNull(result, "Should have written FilmNotInStockResult class");
cs = File.ReadAllText(result.FullName);
Assert.IsTrue(cs.Contains("public virtual int? PFilmCount { get; set; }"),
"Generated property for OUT parameter");
Assert.IsTrue(cs.Contains("public virtual IList<FilmNotInStockResult0> FilmNotInStockResult0 { get; private set; }"),
"Generated collection property for resultset");
}
public StoreTestsFixture()
{
TestHelper.WipeStores();
}
public void AsInteger_FormattedNumericInput_ReturnsNumber(string input, int expectedResult)
{
TestHelper.AssertTemplateOutput(expectedResult.ToString(), "{{ '" + input + "' | AsInteger }}");
}
public void AsBoolean_Theory_CanConvertCommonTextRepresentationsOfFalse(string input)
{
TestHelper.AssertTemplateOutput("false", "{{ '" + input + "' | AsBoolean }}");
}
public void AsDouble_NumericText_ReturnsNumber(string input, double expectedResult)
{
TestHelper.AssertTemplateOutput(expectedResult.ToString(), "{{ '" + input + "' | AsDouble }}");
}
public void ToQuantity_GreaterThanOne_ProducesPluralDescription()
{
TestHelper.AssertTemplateOutput("3 phone numbers", "{{ 'phone number' | ToQuantity:3 }}");
}
public void ToQuantity_EqualToOne_ProducesSingularDescription()
{
TestHelper.AssertTemplateOutput("1 phone number", "{{ 'phone number' | ToQuantity:1 }}");
}
static LingTagsLayerFragmentSeederTest()
{
_factory = TestHelper.GetFactory();
_seedOptions = _factory.GetSeedOptions();
_item = _factory.GetItemSeeder().GetItem(1, "facet");
}
public void Should_still_come_back_as_pdf_even_when_sent_up_as_octet_stream()
{
using (var testHelper = new TestHelper(authToken, storageUrl))
{
var file = new FileInfo(Constants.StorageItemNamePdf);
var metadata = new Dictionary<string, string> {{"Source", "1"}, {"Note", "2"}};
const string DUMMY_FILE_NAME = "HAHAHA";
var putStorageItem = new PutStorageItem(storageUrl, Constants.CONTAINER_NAME, DUMMY_FILE_NAME, file.Open(FileMode.Open), metadata);
// Assert.That(putStorageItem.ContentLength, Is.GreaterThan(0));
// Assert.That(putStorageItem.ContentType, Is.EqualTo("application/octet-stream"));
var response = new GenerateRequestByType().Submit(putStorageItem, authToken);
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.Created));
Assert.That(response.Headers[Constants.ETAG], Is.EqualTo(response.ETag));
var getStorageItem = new GetStorageItem(storageUrl, Constants.CONTAINER_NAME, DUMMY_FILE_NAME);
var getStorageItemResponse = new GenerateRequestByType().Submit(getStorageItem, authToken);
Assert.That(getStorageItemResponse.ContentType, Is.EqualTo("application/octet-stream"));
getStorageItemResponse.Dispose();
testHelper.DeleteItemFromContainer(DUMMY_FILE_NAME);
}
}
public void AsInteger_NonNumericInput_ReturnsEmptyString()
{
TestHelper.AssertTemplateOutput(string.Empty, "{{ 'xyzzy' | AsInteger }}");
}
public void Should_return_created_as_status()
{
var metadata = new Dictionary<string, string>
{
{Constants.MetadataKey, Constants.MetadataValue}
};
using (var testHelper = new TestHelper(authToken, storageUrl))
{
var putStorageItem = new PutStorageItem(storageUrl, Constants.CONTAINER_NAME, Constants.StorageItemName, Constants.StorageItemName, metadata);
// Assert.That(putStorageItem.ContentLength, Is.GreaterThan(0));
var response = new GenerateRequestByType().Submit(putStorageItem, authToken);
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.Created));
Assert.That(response.Headers[Constants.ETAG], Is.EqualTo(response.ETag));
testHelper.DeleteItemFromContainer();
}
}
public void Times_ValidNumericOperands_ReturnsNumericResult(string input1, string input2, string expectedResult)
{
TestHelper.AssertTemplateOutput(expectedResult, "{{ " + input1 + " | Times: " + input2 + " }}");
}
public void should_return_account_information_in_xml_format_including_name_count_and_size()
{
using (TestHelper testHelper = new TestHelper(authToken, storageUrl))
{
try
{
testHelper.PutItemInContainer(Constants.StorageItemName);
var accountInformationXml = new GetAccountInformationSerialized(storageUrl, authToken, Format.XML);
var getAccountInformationXmlResponse = new ResponseFactoryWithContentBody<CloudFilesResponseWithContentBody>().Create(new CloudFilesRequest(accountInformationXml));
if (getAccountInformationXmlResponse.ContentBody.Count == 0)
Assert.Fail("No content body returned in response");
var contentBody = "";
foreach (var s in getAccountInformationXmlResponse.ContentBody)
{
contentBody += s;
}
getAccountInformationXmlResponse.Dispose();
var xmlDocument = new XmlDocument();
try
{
xmlDocument.LoadXml(contentBody);
}
catch(XmlException e)
{
Console.WriteLine(e.Message);
}
// Console.WriteLine(xmlDocument.InnerXml);
var expectedSubString = "<container><name>"+ Constants.CONTAINER_NAME +"</name><count>1</count><bytes>34</bytes></container>";
Assert.That(contentBody.IndexOf(expectedSubString) > 0, Is.True);
}
finally
{
testHelper.DeleteItemFromContainer();
}
}
}
public void should_return_account_information_in_json_format_including_name_count_and_bytes()
{
using (TestHelper testHelper = new TestHelper(authToken, storageUrl))
{
try
{
testHelper.PutItemInContainer(Constants.StorageItemName);
var getAccountInformationJson = new GetAccountInformationSerialized(storageUrl, authToken, Format.JSON);
var getAccountInformationJsonResponse = new ResponseFactoryWithContentBody<CloudFilesResponseWithContentBody>().Create(new CloudFilesRequest(getAccountInformationJson));
if(getAccountInformationJsonResponse.ContentBody.Count == 0)
Assert.Fail("No content body returned in response");
// foreach (string s in getAccountInformationJsonResponse.ContentBody)
// {
// Console.WriteLine(s);
// }
var expectedSubString = "{\"name\": \"" + Constants.CONTAINER_NAME + "\", \"count\": 1, \"bytes\": 34}";
var contentBody = getAccountInformationJsonResponse.ContentBody;
getAccountInformationJsonResponse.Dispose();
foreach (var s in contentBody)
{
if (s.IndexOf(expectedSubString) > -1) return;
}
Assert.Fail("Expected value: " + expectedSubString + " not found");
}
finally
{
testHelper.DeleteItemFromContainer();
}
}
}
/// <summary>
/// Train and evaluate a image classifier for MNIST data.
/// </summary>
/// <param name="device">CPU or GPU device to run training and evaluation</param>
/// <param name="useConvolution">option to use convolution network or to use multilayer perceptron</param>
/// <param name="forceRetrain">whether to override an existing model.
/// if true, any existing model will be overridden and the new one evaluated.
/// if false and there is an existing model, the existing model is evaluated.</param>
public static void TrainAndEvaluate(DeviceDescriptor device, bool forceRetrain)
{
var featureStreamName = "features";
var labelsStreamName = "labels";
var classifierName = "classifierOutput";
Function classifierOutput;
int[] imageDim = new int[] { 28, 28, 1 };
int imageSize = 28 * 28;
int numClasses = 10;
IList <StreamConfiguration> streamConfigurations = new StreamConfiguration[]
{ new StreamConfiguration(featureStreamName, imageSize), new StreamConfiguration(labelsStreamName, numClasses) };
string modelFile = ImageDataFolder + "\\MNISTConvolution.model";
// If a model already exists and not set to force retrain, validate the model and return.
if (File.Exists(modelFile) && !forceRetrain)
{
var minibatchSourceExistModel = MinibatchSource.TextFormatMinibatchSource(
Path.Combine(ImageDataFolder, "Test-28x28_cntk_text.txt"), streamConfigurations);
TestHelper.ValidateModelWithMinibatchSource(modelFile, minibatchSourceExistModel, imageDim,
numClasses, featureStreamName, labelsStreamName, classifierName, device);
return;
}
// build the network
var input = CNTKLib.InputVariable(imageDim, DataType.Float, featureStreamName);
var scaledInput = CNTKLib.ElementTimes(Constant.Scalar <float>(0.00390625f, device), input);
classifierOutput = CreateConvolutionalNeuralNetwork(scaledInput, numClasses, device, classifierName);
var labels = CNTKLib.InputVariable(new int[] { numClasses }, DataType.Float, labelsStreamName);
var trainingLoss = CNTKLib.CrossEntropyWithSoftmax(new Variable(classifierOutput), labels, "lossFunction");
var prediction = CNTKLib.ClassificationError(new Variable(classifierOutput), labels, "classificationError");
// prepare training data
var minibatchSource = MinibatchSource.TextFormatMinibatchSource(
Path.Combine(ImageDataFolder, "Train-28x28_cntk_text.txt"), streamConfigurations, MinibatchSource.InfinitelyRepeat);
var featureStreamInfo = minibatchSource.StreamInfo(featureStreamName);
var labelStreamInfo = minibatchSource.StreamInfo(labelsStreamName);
// set per sample learning rate
CNTK.TrainingParameterScheduleDouble learningRatePerSample = new CNTK.TrainingParameterScheduleDouble(
0.003125, 1);
IList <Learner> parameterLearners = new List <Learner>()
{
Learner.SGDLearner(classifierOutput.Parameters(), learningRatePerSample)
};
var trainer = Trainer.CreateTrainer(classifierOutput, trainingLoss, prediction, parameterLearners);
//
const uint minibatchSize = 64;
int outputFrequencyInMinibatches = 20, i = 0;
int epochs = 5;
while (epochs > 0)
{
var minibatchData = minibatchSource.GetNextMinibatch(minibatchSize, device);
var arguments = new Dictionary <Variable, MinibatchData>
{
{ input, minibatchData[featureStreamInfo] },
{ labels, minibatchData[labelStreamInfo] }
};
trainer.TrainMinibatch(arguments, device);
TestHelper.PrintTrainingProgress(trainer, i++, outputFrequencyInMinibatches);
// MinibatchSource is created with MinibatchSource.InfinitelyRepeat.
// Batching will not end. Each time minibatchSource completes an sweep (epoch),
// the last minibatch data will be marked as end of a sweep. We use this flag
// to count number of epochs.
if (TestHelper.MiniBatchDataIsSweepEnd(minibatchData.Values))
{
epochs--;
}
}
// save the trained model
classifierOutput.Save(modelFile);
// validate the model
var minibatchSourceNewModel = MinibatchSource.TextFormatMinibatchSource(
Path.Combine(ImageDataFolder, "Test-28x28_cntk_text.txt"), streamConfigurations, MinibatchSource.FullDataSweep);
TestHelper.ValidateModelWithMinibatchSource(modelFile, minibatchSourceNewModel,
imageDim, numClasses, featureStreamName, labelsStreamName, classifierName, device);
}
public void Dispose()
{
TestHelper.WipeStores();
}
public void CanSetMSIOnExistingVMWithRoleAssignments()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var groupName = TestUtilities.GenerateName("rgmsi");
var storageAccountName = TestUtilities.GenerateName("ja");
var region = Region.USSouthCentral;
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)
.WithManagedServiceIdentity()
.Create();
Assert.NotNull(virtualMachine);
Assert.NotNull(virtualMachine.Inner);
Assert.True(virtualMachine.IsManagedServiceIdentityEnabled);
Assert.NotNull(virtualMachine.ManagedServiceIdentityPrincipalId);
Assert.NotNull(virtualMachine.ManagedServiceIdentityTenantId);
// Ensure the MSI extension is set
//
var extensions = virtualMachine.ListExtensions();
bool extensionFound = false;
foreach (var extension in extensions.Values)
{
if (extension.PublisherName.Equals("Microsoft.ManagedIdentity", StringComparison.OrdinalIgnoreCase) &&
extension.TypeName.Equals("ManagedIdentityExtensionForLinux", StringComparison.OrdinalIgnoreCase))
{
extensionFound = true;
break;
}
}
Assert.True(extensionFound);
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.ManagedServiceIdentityPrincipalId, StringComparison.OrdinalIgnoreCase))
{
found = true;
break;
}
}
Assert.False(found, "Resource group should not have a role assignment with virtual machine MSI principal");
virtualMachine.Update()
.WithManagedServiceIdentity()
.WithRoleBasedAccessToCurrentResourceGroup(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.ManagedServiceIdentityPrincipalId, 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()
.WithManagedServiceIdentity()
.WithRoleBasedAccessToCurrentResourceGroup(BuiltInRole.Contributor)
.Apply();
}
finally
{
try
{
if (azure != null)
{
azure.ResourceGroups.BeginDeleteByName(groupName);
}
}
catch { }
}
}
}
public void Format_UsingValidDotNetFormatString_ProducesValidNumber()
{
TestHelper.AssertTemplateOutput("1,234,567.89", "{{ '1234567.89' | Format:'#,##0.00' }}");
}
public void CanCreateUpdateVirtualMachineWithEmptyManagedDataDisks()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var publicIPDnsLabel = SdkContext.RandomResourceName("pip", 20);
var uname = "juser";
var password = "******";
// Create with implicit + explicit empty disks, check default and override
//
var vmName1 = "myvm1";
var explicitlyCreatedEmptyDiskName1 = SdkContext.RandomResourceName(vmName1 + "_mdisk_", 25);
var explicitlyCreatedEmptyDiskName2 = SdkContext.RandomResourceName(vmName1 + "_mdisk_", 25);
var explicitlyCreatedEmptyDiskName3 = SdkContext.RandomResourceName(vmName1 + "_mdisk_", 25);
var resourceManager = TestHelper.CreateRollupClient();
var computeManager = TestHelper.CreateComputeManager();
var rgName = TestUtilities.GenerateName("rgfluentchash-");
try
{
var resourceGroup = resourceManager.ResourceGroups
.Define(rgName)
.WithRegion(Location)
.Create();
var creatableEmptyDisk1 = computeManager.Disks
.Define(explicitlyCreatedEmptyDiskName1)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithData()
.WithSizeInGB(150);
var creatableEmptyDisk2 = computeManager.Disks
.Define(explicitlyCreatedEmptyDiskName2)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithData()
.WithSizeInGB(150);
var creatableEmptyDisk3 = computeManager.Disks
.Define(explicitlyCreatedEmptyDiskName3)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithData()
.WithSizeInGB(150);
var virtualMachine = computeManager.VirtualMachines
.Define(vmName1)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(publicIPDnsLabel)
.WithPopularLinuxImage(LinuxImage)
.WithRootUsername(uname)
.WithRootPassword(password)
// Start: Add 5 empty managed disks
.WithNewDataDisk(100) // CreateOption: EMPTY
.WithNewDataDisk(100, 1, CachingTypes.ReadOnly) // CreateOption: EMPTY
.WithNewDataDisk(creatableEmptyDisk1) // CreateOption: ATTACH
.WithNewDataDisk(creatableEmptyDisk2, 2, CachingTypes.None) // CreateOption: ATTACH
.WithNewDataDisk(creatableEmptyDisk3, 3, CachingTypes.None) // CreateOption: ATTACH
// End : Add 5 empty managed disks
.WithSize(VirtualMachineSizeTypes.StandardD5V2)
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
Assert.True(virtualMachine.IsManagedDiskEnabled);
// There should not be any un-managed data disks
//
Assert.NotNull(virtualMachine.UnmanagedDataDisks);
Assert.Equal(0, virtualMachine.UnmanagedDataDisks.Count);
// Validate the managed data disks
//
var dataDisks = virtualMachine.DataDisks;
Assert.NotNull(dataDisks);
Assert.True(dataDisks.Count == 5);
Assert.True(dataDisks.ContainsKey(1));
var dataDiskLun1 = dataDisks[1];
Assert.NotNull(dataDiskLun1.Id);
Assert.Equal(CachingTypes.ReadOnly, dataDiskLun1.CachingType);
Assert.Equal(100, dataDiskLun1.Size);
Assert.True(dataDisks.ContainsKey(2));
var dataDiskLun2 = dataDisks[2];
Assert.NotNull(dataDiskLun2.Id);
Assert.Equal(CachingTypes.None, dataDiskLun2.CachingType);
Assert.Equal(150, dataDiskLun2.Size);
Assert.True(dataDisks.ContainsKey(3));
var dataDiskLun3 = dataDisks[3];
Assert.NotNull(dataDiskLun3.Id);
Assert.Equal(CachingTypes.None, dataDiskLun3.CachingType);
Assert.Equal(150, dataDiskLun3.Size);
// Validate the defaults assigned
//
foreach (var dataDisk in dataDisks.Values)
{
if (dataDisk.Lun != 1 && dataDisk.Lun != 2 && dataDisk.Lun != 3)
{
Assert.Equal(CachingTypes.ReadWrite, dataDisk.CachingType);
Assert.Equal(StorageAccountTypes.StandardLRS, dataDisk.StorageAccountType);
}
}
// Updating and adding disk as part of VM Update seems consistency failing, CRP is aware of
// this, hence until it is fixed comment-out the test
//
// {
// "startTime": "2017-01-26T05:48:59.9290573+00:00",
// "endTime": "2017-01-26T05:49:02.2884052+00:00",
// "status": "Failed",
// "error": {
// "code": "InternalExecutionError",
// "message": "An internal execution error occurred."
// },
// "name": "bc8072a7-38bb-445b-ae59-f16cf125342c"
// }
//
// virtualMachine.Deallocate();
//
// virtualMachine.Update()
// .WithDataDiskUpdated(1, 200)
// .WithDataDiskUpdated(2, 200, CachingTypes.ReadWrite)
// .WithNewDataDisk(60)
// .Apply();
//
// Assert.True(virtualMachine.IsManagedDiskEnabled());
// // There should not be any un-managed data disks
// //
// Assert.NotNull(virtualMachine.UnmanagedDataDisks());
// Assert.Equal(virtualMachine.UnmanagedDataDisks().Count, 0);
//
// // Validate the managed data disks
// //
// dataDisks = virtualMachine.DataDisks;
// Assert.NotNull(dataDisks);
// Assert.True(dataDisks.Count == 6);
// Assert.True(dataDisks.ContainsKey(1));
// dataDiskLun1 = dataDisks[1];
// Assert.NotNull(dataDiskLun1.Id);
// Assert.Equal(dataDiskLun1.CachingType(), CachingTypes.ReadOnly);
// Assert.Equal(dataDiskLun1.Count, 200); // 100 -> 200
//
// Assert.True(dataDisks.ContainsKey(2));
// dataDiskLun2 = dataDisks[2];
// Assert.NotNull(dataDiskLun2.Id);
// Assert.Equal(dataDiskLun2.CachingType(), CachingTypes.ReadWrite); // None -> ReadWrite
// Assert.Equal(dataDiskLun2.Count, 200); // 150 -> 200
//
// Assert.True(dataDisks.ContainsKey(3));
// dataDiskLun3 = dataDisks[3];
// Assert.NotNull(dataDiskLun3.Id);
// Assert.Equal(dataDiskLun3.CachingType(), CachingTypes.None);
// Assert.Equal(dataDiskLun3.Count, 150);
//
// // Ensure defaults of other disks are not affected
// foreach (VirtualMachineDataDisk dataDisk in dataDisks.Values()) {
// if (dataDisk.Lun != 1 && dataDisk.Lun != 3) {
// Assert.Equal(dataDisk.CachingType(), CachingTypes.ReadWrite);
// Assert.Equal(dataDisk.StorageAccountType(), StorageAccountTypes.STANDARD_LRS);
// }
// }
}
finally
{
try
{
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public void Format_EmptyInput_ProducesZeroLengthStringOutput()
{
TestHelper.AssertTemplateOutput("", "{{ '' | Format:'#,##0.00' }}");
}
public void CanCreateVirtualMachineByAttachingManagedOsDisk()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var uname = "juser";
var password = "******";
var vmName = "myvm6";
var resourceManager = TestHelper.CreateRollupClient();
var computeManager = TestHelper.CreateComputeManager();
var rgName = TestUtilities.GenerateName("rgfluentchash-");
try
{
// Creates a native virtual machine
//
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 */
.WithSize(VirtualMachineSizeTypes.StandardD5V2)
.WithNewStorageAccount(SdkContext.RandomResourceName("stg", 17))
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
Assert.False(nativeVM.IsManagedDiskEnabled);
var osVhdUri = nativeVM.OSUnmanagedDiskVhdUri;
Assert.NotNull(osVhdUri);
computeManager.VirtualMachines.DeleteById(nativeVM.Id);
var diskName = SdkContext.RandomResourceName("dsk-", 15);
var osDisk = computeManager.Disks.Define(diskName)
.WithRegion(Location)
.WithExistingResourceGroup(rgName)
.WithLinuxFromVhd(osVhdUri)
.Create();
// Creates a managed virtual machine
//
var managedVM = computeManager.VirtualMachines
.Define(vmName)
.WithRegion(Location)
.WithExistingResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithSpecializedOSDisk(osDisk, OperatingSystemTypes.Linux)
.WithSize(VirtualMachineSizeTypes.StandardD5V2)
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
Assert.True(managedVM.IsManagedDiskEnabled);
Assert.Equal(managedVM.OSDiskId, osDisk.Id, ignoreCase: true);
}
finally
{
try
{
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public void Format_NonnumericInput_ProducesUnchangedOutput()
{
TestHelper.AssertTemplateOutput("not_a_number", "{{ 'not_a_number' | Format:'#,##0.00' }}");
}
public void Setup()
{
_testHelper = ObjectFactory.GetInstance<TestHelper>();
_commodityRepository = _testHelper.Ioc<ICommodityRepository>();
}
public void NumberToOrdinal_IntegerInput_ProducesValidOrdinal()
{
TestHelper.AssertTemplateOutput("1st", "{{ 1 | NumberToOrdinal }}");
}
public void Should_set_content_type_of_jpg_for_stream_upload()
{
using (var testHelper = new TestHelper(authToken, storageUrl))
{
var fileStream = new FileStream(Constants.StorageItemNameJpg, FileMode.Open, FileAccess.Read);
var putStorageItem = new PutStorageItem(storageUrl, Constants.CONTAINER_NAME, Constants.StorageItemNameJpg, fileStream);
var response = new GenerateRequestByType().Submit(putStorageItem, authToken);
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.Created));
Assert.That(response.Headers[Constants.ETAG], Is.EqualTo(response.ETag));
testHelper.DeleteItemFromContainer(Constants.StorageItemNameJpg);
}
}
public void NumberToOrdinalWords_IntegerInput_ProducesValidWords()
{
TestHelper.AssertTemplateOutput("third", "{{ 3 | NumberToOrdinalWords }}");
}
public void CanCreateVirtualMachineFromCustomImageWithManagedDisks()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var publicIPDnsLabel = SdkContext.RandomResourceName("pip", 20);
var uname = "juser";
var password = "******";
// Create with implicit + explicit empty disks, check default and override
//
var vmName1 = "myvm1";
var explicitlyCreatedEmptyDiskName1 = SdkContext.RandomResourceName(vmName1 + "_mdisk_", 25);
var explicitlyCreatedEmptyDiskName2 = SdkContext.RandomResourceName(vmName1 + "_mdisk_", 25);
var explicitlyCreatedEmptyDiskName3 = SdkContext.RandomResourceName(vmName1 + "_mdisk_", 25);
var resourceManager = TestHelper.CreateRollupClient();
var computeManager = TestHelper.CreateComputeManager();
var rgName = TestUtilities.GenerateName("rgfluentchash-");
try
{
var resourceGroup = resourceManager.ResourceGroups
.Define(rgName)
.WithRegion(Location)
.Create();
var creatableEmptyDisk1 = computeManager.Disks
.Define(explicitlyCreatedEmptyDiskName1)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithData()
.WithSizeInGB(150);
var creatableEmptyDisk2 = computeManager.Disks
.Define(explicitlyCreatedEmptyDiskName2)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithData()
.WithSizeInGB(150);
var creatableEmptyDisk3 = computeManager.Disks
.Define(explicitlyCreatedEmptyDiskName3)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithData()
.WithSizeInGB(150);
var virtualMachine1 = computeManager.VirtualMachines
.Define(vmName1)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(publicIPDnsLabel)
.WithPopularLinuxImage(LinuxImage)
.WithRootUsername(uname)
.WithRootPassword(password)
// Start: Add bunch of empty managed disks
.WithNewDataDisk(100) // CreateOption: EMPTY
.WithNewDataDisk(100, 1, CachingTypes.ReadOnly) // CreateOption: EMPTY
.WithNewDataDisk(creatableEmptyDisk1) // CreateOption: ATTACH
.WithNewDataDisk(creatableEmptyDisk2, 2, CachingTypes.None) // CreateOption: ATTACH
.WithNewDataDisk(creatableEmptyDisk3, 3, CachingTypes.None) // CreateOption: ATTACH
// End : Add bunch of empty managed disks
.WithSize(VirtualMachineSizeTypes.StandardD5V2)
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
TestHelper.Delay(60 * 1000); // Wait for some time to ensure vm is publicly accessible
TestHelper.DeprovisionAgentInLinuxVM(virtualMachine1.GetPrimaryPublicIPAddress().Fqdn,
22,
uname,
password);
virtualMachine1.Deallocate();
virtualMachine1.Generalize();
var customImageName = SdkContext.RandomResourceName("img-", 10);
var customImage = computeManager.VirtualMachineCustomImages.Define(customImageName)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.FromVirtualMachine(virtualMachine1)
.Create();
Assert.NotNull(customImage);
Assert.NotNull(customImage.SourceVirtualMachineId);
Assert.Equal(customImage.SourceVirtualMachineId, virtualMachine1.Id, 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(5, customImage.DataDiskImages.Count);
foreach (ImageDataDisk imageDataDisk in customImage.DataDiskImages.Values)
{
Assert.Null(imageDataDisk.BlobUri);
Assert.NotNull(imageDataDisk.ManagedDisk.Id);
}
// Create virtual machine from the custom image
// This one relies on CRP's capability to create implicit data disks from the virtual machine
// image data disk images.
//
var vmName2 = "myvm2";
var virtualMachine2 = computeManager.VirtualMachines
.Define(vmName2)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithLinuxCustomImage(customImage.Id)
.WithRootUsername(uname)
.WithRootPassword(password)
// No explicit data disks, let CRP create it from the image's data disk images
.WithSize(VirtualMachineSizeTypes.StandardD5V2)
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
var dataDisks = virtualMachine2.DataDisks;
Assert.NotNull(dataDisks);
Assert.Equal(dataDisks.Count, customImage.DataDiskImages.Count);
foreach (var imageDataDisk in customImage.DataDiskImages.Values)
{
Assert.True(dataDisks.ContainsKey(imageDataDisk.Lun));
var dataDisk = dataDisks[imageDataDisk.Lun];
Assert.Equal(dataDisk.CachingType, imageDataDisk.Caching);
// Fails with new service.
//Assert.Equal(dataDisk.Size, (long)imageDataDisk.DiskSizeGB.Value);
}
// Create virtual machine from the custom image
// This one override the size and caching type of data disks from data disk images and
// adds one additional disk
//
var vmName3 = "myvm3";
var creatableVirtualMachine3 = computeManager.VirtualMachines
.Define(vmName3)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithLinuxCustomImage(customImage.Id)
.WithRootUsername(uname)
.WithRootPassword(password);
foreach (var dataDiskImage in customImage.DataDiskImages.Values)
{
// Explicitly override the properties of the data disks created from disk image
//
// CreateOption: FROM_IMAGE
var dataDisk = dataDisks[dataDiskImage.Lun];
creatableVirtualMachine3.WithNewDataDiskFromImage(dataDiskImage.Lun,
dataDisk.Size + 10, // increase size by 10 GB
CachingTypes.ReadOnly);
}
var virtualMachine3 = creatableVirtualMachine3
.WithNewDataDisk(200) // CreateOption: EMPTY
.WithSize(VirtualMachineSizeTypes.StandardD5V2)
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
dataDisks = virtualMachine3.DataDisks;
Assert.NotNull(dataDisks);
Assert.Equal(dataDisks.Count, customImage.DataDiskImages.Count + 1 /* count one extra empty disk */);
foreach (var imageDataDisk in customImage.DataDiskImages.Values)
{
Assert.True(dataDisks.ContainsKey(imageDataDisk.Lun));
var dataDisk = dataDisks[imageDataDisk.Lun];
Assert.Equal(CachingTypes.ReadOnly, dataDisk.CachingType);
// Fails with new service.
//Assert.Equal(dataDisk.Size, (long)imageDataDisk.DiskSizeGB + 10);
}
}
finally
{
try
{
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public void NumberToRomanNumerals_IntegerInput_ProducesValidNumerals()
{
TestHelper.AssertTemplateOutput("VII", "{{ 7 | NumberToRomanNumerals }}");
}
public void CanCreateVirtualMachineFromPIRImageWithManagedOsDisk()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var vmName1 = "myvm1";
var publicIPDnsLabel = SdkContext.RandomResourceName("pip", 20);
var uname = "juser";
var password = "******";
var resourceManager = TestHelper.CreateRollupClient();
var computeManager = TestHelper.CreateComputeManager();
var rgName = TestUtilities.GenerateName("rgfluentchash-");
try
{
var virtualMachine = computeManager.VirtualMachines
.Define(vmName1)
.WithRegion(Location)
.WithNewResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(publicIPDnsLabel)
.WithPopularLinuxImage(LinuxImage)
.WithRootUsername(uname)
.WithRootPassword(password)
.WithSize(VirtualMachineSizeTypes.StandardD5V2)
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
// Ensure default to managed disk
//
Assert.True(virtualMachine.IsManagedDiskEnabled);
// Validate caching, size and the default storage account type set for the managed disk
// backing os disk
//
Assert.NotNull(virtualMachine.OSDiskStorageAccountType);
Assert.Equal(CachingTypes.ReadWrite, virtualMachine.OSDiskCachingType);
Assert.Equal(virtualMachine.Size, VirtualMachineSizeTypes.StandardD5V2);
// Validate the implicit managed disk created by CRP to back the os disk
//
Assert.NotNull(virtualMachine.OSDiskId);
var osDisk = computeManager.Disks.GetById(virtualMachine.OSDiskId);
Assert.True(osDisk.IsAttachedToVirtualMachine);
Assert.Equal(OperatingSystemTypes.Linux, osDisk.OSType);
// Check the auto created public ip
//
var publicIPId = virtualMachine.GetPrimaryPublicIPAddressId();
Assert.NotNull(publicIPId);
// Validates the options which are valid only for native disks
//
Assert.Null(virtualMachine.OSUnmanagedDiskVhdUri);
Assert.NotNull(virtualMachine.UnmanagedDataDisks);
Assert.True(virtualMachine.UnmanagedDataDisks.Count == 0);
}
finally
{
try
{
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public void NumberToWords_IntegerInput_ProducesValidWords()
{
TestHelper.AssertTemplateOutput("one", "{{ 1 | NumberToWords }}");
}
public void Setup()
{
_testHelper = ObjectFactory.GetInstance<TestHelper>();
_promotionDiscountRepository = _testHelper.Ioc<IPromotionDiscountRepository>();
}
public static void ClassStartup(TestContext context)
{
var mockConfigModel = TestHelper.MakeConfig();
AppConfigManager.SetConfig(mockConfigModel);
}
public void Times_ValidNumericStringOperands_ReturnsNumericResult(string input1, string input2, string expectedResult)
{
// Insert the operands as string values.
TestHelper.AssertTemplateOutput(expectedResult, "{{ '" + input1 + "' | Times: '" + input2 + "' }}");
}
public static ITestIntfPrx allTests(TestHelper helper)
{
Communicator?communicator = helper.Communicator();
TestHelper.Assert(communicator != null);
var output = helper.GetWriter();
output.Write("testing stringToProxy... ");
output.Flush();
ITestIntfPrx testPrx = ITestIntfPrx.Parse($"Test:{helper.GetTestEndpoint(0)} -t 2000", communicator);
output.WriteLine("ok");
output.Write("base... ");
output.Flush();
{
try
{
testPrx.baseAsBase();
TestHelper.Assert(false);
}
catch (Base b)
{
TestHelper.Assert(b.b.Equals("Base.b"));
TestHelper.Assert(b.GetType().FullName !.Equals("ZeroC.Ice.Test.Slicing.Exceptions.Base"));
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
output.WriteLine("ok");
output.Write("base (AMI)... ");
output.Flush();
{
try
{
testPrx.baseAsBaseAsync().Wait();
TestHelper.Assert(false);
}
catch (AggregateException ae)
{
try
{
TestHelper.Assert(ae.InnerException != null);
throw ae.InnerException;
}
catch (Base b)
{
TestHelper.Assert(b.b.Equals("Base.b"));
TestHelper.Assert(b.GetType().Name.Equals("Base"));
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
}
output.WriteLine("ok");
output.Write("slicing of unknown derived... ");
output.Flush();
{
try
{
testPrx.unknownDerivedAsBase();
TestHelper.Assert(false);
}
catch (Base b)
{
TestHelper.Assert(b.b.Equals("UnknownDerived.b"));
TestHelper.Assert(b.GetType().FullName !.Equals("ZeroC.Ice.Test.Slicing.Exceptions.Base"));
}
catch (System.Exception)
{
TestHelper.Assert(false);
}
}
output.WriteLine("ok");
output.Write("slicing of unknown derived (AMI)... ");
output.Flush();
{
try
{
testPrx.unknownDerivedAsBaseAsync().Wait();
TestHelper.Assert(false);
}
catch (AggregateException ae)
{
try
{
TestHelper.Assert(ae.InnerException != null);
throw ae.InnerException;
}
catch (Base b)
{
TestHelper.Assert(b.b.Equals("UnknownDerived.b"));
TestHelper.Assert(b.GetType().Name.Equals("Base"));
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
}
output.WriteLine("ok");
output.Write("non-slicing of known derived as base... ");
output.Flush();
{
try
{
testPrx.knownDerivedAsBase();
TestHelper.Assert(false);
}
catch (KnownDerived k)
{
TestHelper.Assert(k.b.Equals("KnownDerived.b"));
TestHelper.Assert(k.kd.Equals("KnownDerived.kd"));
TestHelper.Assert(k.GetType().FullName !.Equals("ZeroC.Ice.Test.Slicing.Exceptions.KnownDerived"));
}
catch (System.Exception)
{
TestHelper.Assert(false);
}
}
output.WriteLine("ok");
output.Write("non-slicing of known derived as base (AMI)... ");
output.Flush();
{
try
{
testPrx.knownDerivedAsBaseAsync().Wait();
TestHelper.Assert(false);
}
catch (AggregateException ae)
{
try
{
TestHelper.Assert(ae.InnerException != null);
throw ae.InnerException;
}
catch (KnownDerived k)
{
TestHelper.Assert(k.b.Equals("KnownDerived.b"));
TestHelper.Assert(k.kd.Equals("KnownDerived.kd"));
TestHelper.Assert(k.GetType().Name.Equals("KnownDerived"));
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
}
output.WriteLine("ok");
output.Write("non-slicing of known derived as derived... ");
output.Flush();
{
try
{
testPrx.knownDerivedAsKnownDerived();
TestHelper.Assert(false);
}
catch (KnownDerived k)
{
TestHelper.Assert(k.b.Equals("KnownDerived.b"));
TestHelper.Assert(k.kd.Equals("KnownDerived.kd"));
TestHelper.Assert(k.GetType().FullName !.Equals("ZeroC.Ice.Test.Slicing.Exceptions.KnownDerived"));
}
catch (System.Exception)
{
TestHelper.Assert(false);
}
}
output.WriteLine("ok");
output.Write("non-slicing of known derived as derived (AMI)... ");
output.Flush();
{
try
{
testPrx.knownDerivedAsKnownDerivedAsync().Wait();
TestHelper.Assert(false);
}
catch (AggregateException ae)
{
try
{
TestHelper.Assert(ae.InnerException != null);
throw ae.InnerException;
}
catch (KnownDerived k)
{
TestHelper.Assert(k.b.Equals("KnownDerived.b"));
TestHelper.Assert(k.kd.Equals("KnownDerived.kd"));
TestHelper.Assert(k.GetType().Name.Equals("KnownDerived"));
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
}
output.WriteLine("ok");
output.Write("slicing of unknown intermediate as base... ");
output.Flush();
{
try
{
testPrx.unknownIntermediateAsBase();
TestHelper.Assert(false);
}
catch (Base b)
{
TestHelper.Assert(b.b.Equals("UnknownIntermediate.b"));
TestHelper.Assert(b.GetType().FullName !.Equals("ZeroC.Ice.Test.Slicing.Exceptions.Base"));
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
output.WriteLine("ok");
output.Write("slicing of unknown intermediate as base (AMI)... ");
output.Flush();
{
try
{
testPrx.unknownIntermediateAsBaseAsync().Wait();
TestHelper.Assert(false);
}
catch (AggregateException ae)
{
try
{
TestHelper.Assert(ae.InnerException != null);
throw ae.InnerException;
}
catch (Base b)
{
TestHelper.Assert(b.b.Equals("UnknownIntermediate.b"));
TestHelper.Assert(b.GetType().Name.Equals("Base"));
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
}
output.WriteLine("ok");
output.Write("slicing of known intermediate as base... ");
output.Flush();
{
try
{
testPrx.knownIntermediateAsBase();
TestHelper.Assert(false);
}
catch (KnownIntermediate ki)
{
TestHelper.Assert(ki.b.Equals("KnownIntermediate.b"));
TestHelper.Assert(ki.ki.Equals("KnownIntermediate.ki"));
TestHelper.Assert(ki.GetType().FullName !.Equals("ZeroC.Ice.Test.Slicing.Exceptions.KnownIntermediate"));
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
output.WriteLine("ok");
output.Write("slicing of known intermediate as base (AMI)... ");
output.Flush();
{
try
{
testPrx.knownIntermediateAsBaseAsync().Wait();
TestHelper.Assert(false);
}
catch (AggregateException ae)
{
try
{
TestHelper.Assert(ae.InnerException != null);
throw ae.InnerException;
}
catch (KnownIntermediate ki)
{
TestHelper.Assert(ki.b.Equals("KnownIntermediate.b"));
TestHelper.Assert(ki.ki.Equals("KnownIntermediate.ki"));
TestHelper.Assert(ki.GetType().Name.Equals("KnownIntermediate"));
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
}
output.WriteLine("ok");
output.Write("slicing of known most derived as base... ");
output.Flush();
{
try
{
testPrx.knownMostDerivedAsBase();
TestHelper.Assert(false);
}
catch (KnownMostDerived kmd)
{
TestHelper.Assert(kmd.b.Equals("KnownMostDerived.b"));
TestHelper.Assert(kmd.ki.Equals("KnownMostDerived.ki"));
TestHelper.Assert(kmd.kmd.Equals("KnownMostDerived.kmd"));
TestHelper.Assert(kmd.GetType().FullName !.Equals("ZeroC.Ice.Test.Slicing.Exceptions.KnownMostDerived"));
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
output.WriteLine("ok");
output.Write("slicing of known most derived as base (AMI)... ");
output.Flush();
{
try
{
testPrx.knownMostDerivedAsBaseAsync().Wait();
TestHelper.Assert(false);
}
catch (AggregateException ae)
{
try
{
TestHelper.Assert(ae.InnerException != null);
throw ae.InnerException;
}
catch (KnownMostDerived kmd)
{
TestHelper.Assert(kmd.b.Equals("KnownMostDerived.b"));
TestHelper.Assert(kmd.ki.Equals("KnownMostDerived.ki"));
TestHelper.Assert(kmd.kmd.Equals("KnownMostDerived.kmd"));
TestHelper.Assert(kmd.GetType().Name.Equals("KnownMostDerived"));
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
}
output.WriteLine("ok");
output.Write("non-slicing of known intermediate as intermediate... ");
output.Flush();
{
try
{
testPrx.knownIntermediateAsKnownIntermediate();
TestHelper.Assert(false);
}
catch (KnownIntermediate ki)
{
TestHelper.Assert(ki.b.Equals("KnownIntermediate.b"));
TestHelper.Assert(ki.ki.Equals("KnownIntermediate.ki"));
TestHelper.Assert(ki.GetType().FullName !.Equals("ZeroC.Ice.Test.Slicing.Exceptions.KnownIntermediate"));
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
output.WriteLine("ok");
output.Write("non-slicing of known intermediate as intermediate (AMI)... ");
output.Flush();
{
try
{
testPrx.knownIntermediateAsKnownIntermediateAsync().Wait();
TestHelper.Assert(false);
}
catch (AggregateException ae)
{
try
{
TestHelper.Assert(ae.InnerException != null);
throw ae.InnerException;
}
catch (KnownIntermediate ki)
{
TestHelper.Assert(ki.b.Equals("KnownIntermediate.b"));
TestHelper.Assert(ki.ki.Equals("KnownIntermediate.ki"));
TestHelper.Assert(ki.GetType().Name.Equals("KnownIntermediate"));
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
}
output.WriteLine("ok");
output.Write("non-slicing of known most derived as intermediate... ");
output.Flush();
{
try
{
testPrx.knownMostDerivedAsKnownIntermediate();
TestHelper.Assert(false);
}
catch (KnownMostDerived kmd)
{
TestHelper.Assert(kmd.b.Equals("KnownMostDerived.b"));
TestHelper.Assert(kmd.ki.Equals("KnownMostDerived.ki"));
TestHelper.Assert(kmd.kmd.Equals("KnownMostDerived.kmd"));
TestHelper.Assert(kmd.GetType().FullName !.Equals("ZeroC.Ice.Test.Slicing.Exceptions.KnownMostDerived"));
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
output.WriteLine("ok");
output.Write("non-slicing of known most derived as intermediate (AMI)... ");
output.Flush();
{
try
{
testPrx.knownMostDerivedAsKnownIntermediateAsync().Wait();
TestHelper.Assert(false);
}
catch (AggregateException ae)
{
try
{
TestHelper.Assert(ae.InnerException != null);
throw ae.InnerException;
}
catch (KnownMostDerived kmd)
{
TestHelper.Assert(kmd.b.Equals("KnownMostDerived.b"));
TestHelper.Assert(kmd.ki.Equals("KnownMostDerived.ki"));
TestHelper.Assert(kmd.kmd.Equals("KnownMostDerived.kmd"));
TestHelper.Assert(kmd.GetType().Name.Equals("KnownMostDerived"));
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
}
output.WriteLine("ok");
output.Write("non-slicing of known most derived as most derived... ");
output.Flush();
{
try
{
testPrx.knownMostDerivedAsKnownMostDerived();
TestHelper.Assert(false);
}
catch (KnownMostDerived kmd)
{
TestHelper.Assert(kmd.b.Equals("KnownMostDerived.b"));
TestHelper.Assert(kmd.ki.Equals("KnownMostDerived.ki"));
TestHelper.Assert(kmd.kmd.Equals("KnownMostDerived.kmd"));
TestHelper.Assert(kmd.GetType().FullName !.Equals("ZeroC.Ice.Test.Slicing.Exceptions.KnownMostDerived"));
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
output.WriteLine("ok");
output.Write("non-slicing of known most derived as most derived (AMI)... ");
output.Flush();
{
try
{
testPrx.knownMostDerivedAsKnownMostDerivedAsync().Wait();
TestHelper.Assert(false);
}
catch (AggregateException ae)
{
try
{
TestHelper.Assert(ae.InnerException != null);
throw ae.InnerException;
}
catch (KnownMostDerived kmd)
{
TestHelper.Assert(kmd.b.Equals("KnownMostDerived.b"));
TestHelper.Assert(kmd.ki.Equals("KnownMostDerived.ki"));
TestHelper.Assert(kmd.kmd.Equals("KnownMostDerived.kmd"));
TestHelper.Assert(kmd.GetType().Name.Equals("KnownMostDerived"));
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
}
output.WriteLine("ok");
output.Write("slicing of unknown most derived, known intermediate as base... ");
output.Flush();
{
try
{
testPrx.unknownMostDerived1AsBase();
TestHelper.Assert(false);
}
catch (KnownIntermediate ki)
{
TestHelper.Assert(ki.b.Equals("UnknownMostDerived1.b"));
TestHelper.Assert(ki.ki.Equals("UnknownMostDerived1.ki"));
TestHelper.Assert(ki.GetType().FullName !.Equals("ZeroC.Ice.Test.Slicing.Exceptions.KnownIntermediate"));
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
output.WriteLine("ok");
output.Write("slicing of unknown most derived, known intermediate as base (AMI)... ");
output.Flush();
{
try
{
testPrx.unknownMostDerived1AsBaseAsync().Wait();
TestHelper.Assert(false);
}
catch (AggregateException ae)
{
try
{
TestHelper.Assert(ae.InnerException != null);
throw ae.InnerException;
}
catch (KnownIntermediate ki)
{
TestHelper.Assert(ki.b.Equals("UnknownMostDerived1.b"));
TestHelper.Assert(ki.ki.Equals("UnknownMostDerived1.ki"));
TestHelper.Assert(ki.GetType().Name.Equals("KnownIntermediate"));
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
}
output.WriteLine("ok");
output.Write("slicing of unknown most derived, known intermediate as intermediate... ");
output.Flush();
{
try
{
testPrx.unknownMostDerived1AsKnownIntermediate();
TestHelper.Assert(false);
}
catch (KnownIntermediate ki)
{
TestHelper.Assert(ki.b.Equals("UnknownMostDerived1.b"));
TestHelper.Assert(ki.ki.Equals("UnknownMostDerived1.ki"));
TestHelper.Assert(ki.GetType().FullName !.Equals("ZeroC.Ice.Test.Slicing.Exceptions.KnownIntermediate"));
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
output.WriteLine("ok");
output.Write("slicing of unknown most derived, known intermediate as intermediate (AMI)... ");
output.Flush();
{
try
{
testPrx.unknownMostDerived1AsKnownIntermediateAsync().Wait();
TestHelper.Assert(false);
}
catch (AggregateException ae)
{
try
{
TestHelper.Assert(ae.InnerException != null);
throw ae.InnerException;
}
catch (KnownIntermediate ki)
{
TestHelper.Assert(ki.b.Equals("UnknownMostDerived1.b"));
TestHelper.Assert(ki.ki.Equals("UnknownMostDerived1.ki"));
TestHelper.Assert(ki.GetType().Name.Equals("KnownIntermediate"));
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
}
output.WriteLine("ok");
output.Write("slicing of unknown most derived, unknown intermediate thrown as base... ");
output.Flush();
{
try
{
testPrx.unknownMostDerived2AsBase();
TestHelper.Assert(false);
}
catch (Base b)
{
TestHelper.Assert(b.b.Equals("UnknownMostDerived2.b"));
TestHelper.Assert(b.GetType().FullName !.Equals("ZeroC.Ice.Test.Slicing.Exceptions.Base"));
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
output.WriteLine("ok");
output.Write("slicing of unknown most derived, unknown intermediate thrown as base (AMI)... ");
output.Flush();
{
try
{
testPrx.unknownMostDerived2AsBaseAsync().Wait();
TestHelper.Assert(false);
}
catch (AggregateException ae)
{
try
{
TestHelper.Assert(ae.InnerException != null);
throw ae.InnerException;
}
catch (Base b)
{
TestHelper.Assert(b.b.Equals("UnknownMostDerived2.b"));
TestHelper.Assert(b.GetType().Name.Equals("Base"));
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
}
output.WriteLine("ok");
output.Write("unknown most derived in compact format... ");
output.Flush();
{
try
{
testPrx.unknownMostDerived2AsBaseCompact();
TestHelper.Assert(false);
}
catch (Base)
{
// Exceptions are always marshaled in sliced format; format:compact applies only to in-parameters and
// return values.
}
catch (OperationNotExistException)
{
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
output.WriteLine("ok");
output.Write("completely unknown server-private exception... ");
output.Flush();
{
try
{
testPrx.serverPrivateException();
TestHelper.Assert(false);
}
catch (RemoteException ex)
{
SlicedData slicedData = ex.GetSlicedData() !.Value;
TestHelper.Assert(slicedData.Slices.Count == 1);
TestHelper.Assert(slicedData.Slices[0].TypeId ! == "::ZeroC::Ice::Test::Slicing::Exceptions::ServerPrivateException");
}
catch (Exception)
{
TestHelper.Assert(false);
}
}
output.WriteLine("ok");
output.Write("preserved exceptions... ");
output.Flush();
{
try
{
testPrx.unknownPreservedAsBase();
TestHelper.Assert(false);
}
catch (Base ex)
{
IReadOnlyList <SliceInfo> slices = ex.GetSlicedData() !.Value.Slices;
TestHelper.Assert(slices.Count == 2);
TestHelper.Assert(slices[1].TypeId !.Equals("::ZeroC::Ice::Test::Slicing::Exceptions::SPreserved1"));
TestHelper.Assert(slices[0].TypeId !.Equals("::ZeroC::Ice::Test::Slicing::Exceptions::SPreserved2"));
}
try
{
testPrx.unknownPreservedAsKnownPreserved();
TestHelper.Assert(false);
}
catch (KnownPreserved ex)
{
TestHelper.Assert(ex.kp.Equals("preserved"));
IReadOnlyList <SliceInfo> slices = ex.GetSlicedData() !.Value.Slices;
TestHelper.Assert(slices.Count == 2);
TestHelper.Assert(slices[1].TypeId !.Equals("::ZeroC::Ice::Test::Slicing::Exceptions::SPreserved1"));
TestHelper.Assert(slices[0].TypeId !.Equals("::ZeroC::Ice::Test::Slicing::Exceptions::SPreserved2"));
}
ObjectAdapter adapter = communicator.CreateObjectAdapter();
IRelayPrx relay = adapter.AddWithUUID(new Relay(), IRelayPrx.Factory);
adapter.Activate();
testPrx.GetConnection().Adapter = adapter;
try
{
testPrx.relayKnownPreservedAsBase(relay);
TestHelper.Assert(false);
}
catch (KnownPreservedDerived ex)
{
TestHelper.Assert(ex.b.Equals("base"));
TestHelper.Assert(ex.kp.Equals("preserved"));
TestHelper.Assert(ex.kpd.Equals("derived"));
}
catch (OperationNotExistException)
{
}
catch (System.Exception)
{
TestHelper.Assert(false);
}
try
{
testPrx.relayKnownPreservedAsKnownPreserved(relay);
TestHelper.Assert(false);
}
catch (KnownPreservedDerived ex)
{
TestHelper.Assert(ex.b.Equals("base"));
TestHelper.Assert(ex.kp.Equals("preserved"));
TestHelper.Assert(ex.kpd.Equals("derived"));
}
catch (OperationNotExistException)
{
}
catch (System.Exception)
{
TestHelper.Assert(false);
}
try
{
testPrx.relayUnknownPreservedAsBase(relay);
TestHelper.Assert(false);
}
catch (Preserved2 ex)
{
TestHelper.Assert(ex.b.Equals("base"));
TestHelper.Assert(ex.kp.Equals("preserved"));
TestHelper.Assert(ex.kpd.Equals("derived"));
TestHelper.Assert(ex.p1 !.GetType().GetIceTypeId() !.Equals(typeof(PreservedClass).GetIceTypeId()));
var pc = ex.p1 as PreservedClass;
TestHelper.Assert(pc !.bc.Equals("bc"));
TestHelper.Assert(pc !.pc.Equals("pc"));
TestHelper.Assert(ex.p2 == ex.p1);
}
catch (OperationNotExistException)
{
}
catch (Exception)
{
TestHelper.Assert(false);
}
try
{
testPrx.relayUnknownPreservedAsKnownPreserved(relay);
TestHelper.Assert(false);
}
catch (Preserved2 ex)
{
TestHelper.Assert(ex.b.Equals("base"));
TestHelper.Assert(ex.kp.Equals("preserved"));
TestHelper.Assert(ex.kpd.Equals("derived"));
TestHelper.Assert(ex.p1 !.GetType().GetIceTypeId() !.Equals(typeof(PreservedClass).GetIceTypeId()));
var pc = ex.p1 as PreservedClass;
TestHelper.Assert(pc !.bc.Equals("bc"));
TestHelper.Assert(pc !.pc.Equals("pc"));
TestHelper.Assert(ex.p2 == ex.p1);
}
catch (OperationNotExistException)
{
}
catch (Exception)
{
TestHelper.Assert(false);
}
try
{
testPrx.relayClientPrivateException(relay);
TestHelper.Assert(false);
}
catch (ClientPrivateException ex)
{
TestHelper.Assert(ex.cpe == "ClientPrivate");
}
catch (System.Exception)
{
TestHelper.Assert(false);
}
adapter.Destroy();
}
output.WriteLine("ok");
return(testPrx);
}
public void AcceptsTypesFromDifferentLoadContext()
{
string newAssemblyName = Path.GetRandomFileName();
File.Copy(Assembly.GetExecutingAssembly().Location, newAssemblyName);
var testDomain = AppDomain.CreateDomain("test", null, AppDomain.CurrentDomain.SetupInformation);
var helper = new TestHelper { AssemblyFileName = newAssemblyName };
try
{
testDomain.DoCallBack(helper.DoTestAcceptsTypesFromDifferentLoadContext);
}
finally
{
AppDomain.Unload(testDomain);
File.Delete(newAssemblyName);
}
}
public void Times_StringAndNumericOperand_ReturnsRepeatedString(string input1, string input2, string expectedResult)
{
// Insert the operands as string values.
TestHelper.AssertTemplateOutput(expectedResult, "{{ '" + input1 + "' | Times: " + input2 + " }}");
}
