public void InvokeWithParameterSetPlainWithValidTenantSucceeds()
{
var uri = new Uri("httpS://abiquo.example.com/api/");
var user = "******";
var password = "******";
var tenantId = 42;
var parameters = string.Format(@"-Uri {0} -User '{1}' -Password '{2}' -TenantId {3}", uri, user, password, tenantId);
Mock.Arrange(() => Client.Login(Arg.IsAny <string>(), Arg.IsAny <IAuthenticationInformation>()))
.IgnoreInstance()
.Returns(true)
.MustBeCalled();
Mock.Arrange(() => Client.SwitchEnterprise(tenantId))
.IgnoreInstance()
.DoNothing()
.MustBeCalled();
var results = PsCmdletAssert.Invoke(sut, parameters);
Assert.IsNotNull(results);
Assert.AreEqual(1, results.Count);
Assert.IsInstanceOfType(results[0].BaseObject, typeof(BaseAbiquoClient));
var result = (BaseAbiquoClient)results[0].BaseObject;
Assert.IsNotNull(result);
Assert.AreEqual(User.Id, result.CurrentUserInformation.Id);
Mock.Assert(Client);
}
public void InvokeWithInvalidNameParameterThrowsParameterBindingValidationException()
{
var invalidName = "invalid-name";
var parameters = string.Format("-Name '{0}'", invalidName);
PsCmdletAssert.Invoke(sut, parameters);
}
public void InvokeParameterSetNameSucceedsAndReturnsCollection()
{
Mock.Arrange(() => CurrentClient.IsLoggedIn)
.Returns(true);
Mock.Arrange(() => CurrentClient.GetAllVirtualMachines())
.Returns(VirtualMachines)
.MustBeCalled();
// this Id does not exist
var parameters = @"-Name MachineWithDuplicateName";
var results = PsCmdletAssert.Invoke(sut, parameters);
Assert.IsNotNull(results);
Assert.AreEqual(2, results.Count);
var result0 = results[0].BaseObject as VirtualMachine;
Assert.IsNotNull(result0, results[0].BaseObject.GetType().FullName);
Assert.AreEqual("MachineWithDuplicateName".ToLower(), result0.Name.ToLower());
var result1 = results[1].BaseObject as VirtualMachine;
Assert.IsNotNull(result1, results[1].BaseObject.GetType().FullName);
Assert.AreEqual("MachineWithDuplicateName".ToLower(), result1.Name.ToLower());
Assert.AreNotEqual(result0.Id, result1.Id);
Mock.Assert(() => CurrentClient.GetAllVirtualMachines());
}
public void InvokeParameterSetIdWriterErrorRecord()
{
Mock.Arrange(() => CurrentClient.IsLoggedIn)
.Returns(true);
Mock.Arrange(() => CurrentClient.GetVirtualDataCenter(Arg.IsAny <int>()))
.Throws(new Exception("baseException"))
.MustBeCalled();
// this Id does not exist
var parameters = @"-Id 9999";
Action <IList <ErrorRecord> > errorHandler = er =>
{
Assert.IsNotNull(er);
Assert.AreEqual(2, er.Count);
var er0 = er[0];
Assert.IsTrue(er0.Exception.Message.Contains("baseException"));
var er1 = er[1];
Assert.IsTrue(er1.Exception.Message.Contains("9999"));
};
var results = PsCmdletAssert.Invoke(sut, parameters, errorHandler);
Assert.IsNotNull(results);
Assert.AreEqual(0, results.Count);
Mock.Assert(() => CurrentClient.GetVirtualDataCenter(Arg.IsAny <int>()));
}
public void InvokeParameterSetIdSucceeds()
{
Mock.Arrange(() => CurrentClient.IsLoggedIn)
.Returns(true);
Mock.Arrange(() => CurrentClient.GetVirtualDataCenter(Arg.IsAny <int>()))
.Returns(VirtualDataCenters.Collection.First(e => e.Id == 42))
.MustBeCalled();
// this Id does not exist
var parameters = @"-Id 42";
var results = PsCmdletAssert.Invoke(sut, parameters);
Assert.IsNotNull(results);
Assert.AreEqual(1, results.Count);
var result = results[0].BaseObject as VirtualDataCenter;
Assert.IsNotNull(result, results[0].BaseObject.GetType().FullName);
Assert.AreEqual(42, result.Id);
Assert.AreEqual("Edgar", result.Name);
Mock.Assert(() => CurrentClient.GetVirtualDataCenter(Arg.IsAny <int>()));
}
public void InvokeParameterSetNameSucceeds()
{
Mock.Arrange(() => CurrentClient.IsLoggedIn)
.Returns(true);
Mock.Arrange(() => CurrentClient.GetAllVirtualMachines())
.Returns(VirtualMachines)
.MustBeCalled();
// this Id does not exist
var parameters = @"-Name Edgar";
var results = PsCmdletAssert.Invoke(sut, parameters);
Assert.IsNotNull(results);
Assert.AreEqual(1, results.Count);
var result = results[0].BaseObject as VirtualMachine;
Assert.IsNotNull(result, results[0].BaseObject.GetType().FullName);
Assert.AreEqual(42, result.Id);
Assert.AreEqual("Edgar", result.Name);
Mock.Assert(() => CurrentClient.GetAllVirtualMachines());
}
public void InvokeNewAclWithValidParametersCallsApiAndCreatesAcl()
{
// Arrange
var coreContext = Mock.Create <Api::Net.Appclusive.Api.Core.Core>();
var response = Mock.Create <DataServiceResponse>();
var changeOperationResponse = Mock.Create <ChangeOperationResponse>();
Mock.Arrange(() => coreContext.AddToAcls(Arg.IsAny <Acl>()))
.DoNothing()
.OccursOnce();
Mock.Arrange(() => coreContext.SaveChanges())
.Returns(response)
.OccursOnce();
Mock.Arrange(() => response.FirstOrDefault())
.Returns(changeOperationResponse)
.OccursOnce();
Mock.Arrange(() => changeOperationResponse.StatusCode)
.Returns(201)
.OccursOnce();
var svc = new Dictionary <string, DataServiceContextBase>
{
{
nameof(Api::Net.Appclusive.Api.Core.Core),
coreContext
}
};
var parameters = new Dictionary <string, object>()
{
{ nameof(NewAcl.Name), ACL_NAME },
{ nameof(NewAcl.ParentId), PARENT_ID },
{ nameof(svc), svc }
};
// Act
var results = PsCmdletAssert.Invoke(sut, parameters);
// Assert
Assert.IsNotNull(results);
Assert.AreEqual(1, results.Count);
var acl = results[0].BaseObject as Acl;
Assert.IsNotNull(acl);
Assert.AreEqual(ACL_NAME, acl.Name);
Assert.AreEqual(PARENT_ID, acl.ParentId);
Assert.IsFalse(acl.NoInheritance);
Mock.Assert(coreContext);
Mock.Assert(response);
Mock.Assert(changeOperationResponse);
}
public void TestCase1()
{
var sut = typeof(ArbitraryCmdlet);
var parameters = "-TestCase 1 -StringParameter2 'tralala';";
var result = PsCmdletAssert.Invoke(sut, parameters);
Assert.IsNotNull(result);
Assert.AreEqual(0, result.Count);
}
public void InvokeParameterSetListWithInvalidVdcVappCombination()
{
Mock.Arrange(() => CurrentClient.IsLoggedIn)
.Returns(true);
// this Id does not exist
var parameters = @"-VirtualApplianceId 42";
var results = PsCmdletAssert.Invoke(sut, parameters, ex => ex);
}
public void InvokeWithInvalidStringThrowsIncompleteParseException()
{
// Arrange
// missing string terminator
var parameters = string.Format(@"-ApiBaseUri {0} -User '{1} -Password '{2}'", _apiBaseUri, _username, _password);
// Act
PsCmdletAssert.Invoke(sut, parameters);
// Assert
}
public void InvokeWithEmptyPathResolvesDefaultConfigurationFileNameThrowsContractException()
{
Mock.SetupStatic(typeof(File));
Mock.Arrange(() => File.Exists(Arg.IsAny <string>()))
.OnAllThreads()
.Returns(false);
var parameters = @";";
PsCmdletAssert.Invoke(sut, parameters, ex => ex);
}
public void InvokeWithExistingDirectoryAsPathThrowsContractException()
{
Mock.SetupStatic(typeof(Directory));
Mock.Arrange(() => Directory.Exists(Arg.IsAny <string>()))
.OnAllThreads()
.Returns(true);
var parameters = @"-Path existing-directory";
PsCmdletAssert.Invoke(sut, parameters, ex => ex);
}
public void InvokeWithInvalidStringThrowsIncompleteParseException()
{
// Arrange
// missing string terminator
var parameters = string.Format(@"-Name '{0}", ACL_NAME);
// Act
PsCmdletAssert.Invoke(sut, parameters);
// Assert
}
public void InvokeGetTenantWithNameParameterCallsApiWithFilterAndReturnsResult()
{
// Arrange
var tenant = CreateSampleTenant();
var tenant2 = CreateSampleTenant();
var tenantName = tenant.Name;
var tenants = new List <Tenant>
{
tenant,
tenant2
};
var coreContext = Mock.Create <Api::Net.Appclusive.Api.Core.Core>();
var dataServiceQuery = Mock.Create <DataServiceQuery <Tenant> >();
Mock.Arrange(() => coreContext.Tenants)
.Returns(dataServiceQuery)
.OccursOnce();
var query = string.Format(Odata.BY_NAME_QUERY_TEMPLATE, tenantName);
Mock.Arrange(() => dataServiceQuery.Filter(query).Execute())
.Returns(tenants)
.OccursOnce();
var svc = new Dictionary <string, DataServiceContextBase>
{
{
nameof(Api::Net.Appclusive.Api.Core.Core),
coreContext
}
};
var parameters = new Dictionary <string, object>()
{
{ nameof(GetTenant.Name), tenantName },
{ nameof(svc), svc }
};
// Act
var results = PsCmdletAssert.Invoke(sut, parameters);
// Assert
Assert.IsNotNull(results);
Assert.AreEqual(2, results.Count);
var result0 = results[0].BaseObject as Tenant;
var result1 = results[1].BaseObject as Tenant;
Assert.IsNotNull(result0);
Assert.IsNotNull(result1);
Mock.Assert(coreContext);
Mock.Assert(dataServiceQuery);
}
public void InvokeWithEmptyPathAndDisplayOnlyTrueSucceeds()
{
var parameters = @"-DisplayOnly:$true; Get-Variable net_Appclusive_PS_Client -ValueOnly -ErrorAction:SilentlyContinue;";
var results = PsCmdletAssert.Invoke(sut, parameters);
Assert.IsNotNull(results);
Assert.AreEqual(1, results.Count);
var result = results[0].BaseObject;
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(ModuleContext));
}
public void InvokeWithEmptyPathSucceeds()
{
var parameters = @";";
var results = PsCmdletAssert.Invoke(sut, parameters);
Assert.IsNotNull(results);
Assert.AreEqual(1, results.Count);
var result = results[0].BaseObject;
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(ModuleContext));
}
public void InvokeNotLoggedInThrowsContractException()
{
Mock.Arrange(() => CurrentClient.IsLoggedIn)
.Returns(false);
var parameters = @"-ListAvailable";
var results = PsCmdletAssert.Invoke(sut, parameters, ex => ex);
Assert.IsNotNull(results);
Assert.AreEqual(0, results.Count);
}
public void InvokeWithInvalidStringThrowsIncompleteParseException()
{
var user = "******";
var password = "******";
// missing string terminator
var parameters = string.Format(@"-Uri httpS://abiquo.example.com/api/ -User '{0} -Password '{1}'", user, password);
var results = PsCmdletAssert.Invoke(sut, parameters);
Assert.IsNotNull(results);
Assert.AreEqual(1, results.Count);
var result = results[0].BaseObject.ToString();
Assert.AreEqual("tralala", result);
}
public void InvokeGetTenantListAvailableCallsApiAndReturnsResult()
{
// Arrange
var tenant = CreateSampleTenant();
var tenant2 = CreateSampleTenant();
var tenants = new List <Tenant>
{
tenant,
tenant2
};
var coreContext = Mock.Create <Api::Net.Appclusive.Api.Core.Core>();
var dataServiceQuery = Mock.Create <DataServiceQuery <Tenant> >();
Mock.Arrange(() => coreContext.Tenants)
.Returns(dataServiceQuery)
.OccursOnce();
Mock.Arrange(() => dataServiceQuery.Execute())
.Returns(tenants)
.OccursOnce();
var svc = new Dictionary <string, DataServiceContextBase>
{
{
nameof(Api::Net.Appclusive.Api.Core.Core),
coreContext
}
};
var parameters = new Dictionary <string, object>()
{
{ nameof(svc), svc }
};
// Act
var results = PsCmdletAssert.Invoke(sut, parameters);
// Assert
Assert.IsNotNull(results);
Assert.AreEqual(2, results.Count);
var result0 = results[0].BaseObject as Tenant;
var result1 = results[1].BaseObject as Tenant;
Assert.IsNotNull(result0);
Assert.IsNotNull(result1);
Mock.Assert(coreContext);
Mock.Assert(dataServiceQuery);
}
public void InvokeWithInvalidTokenThrowsContractException()
{
var uri = new Uri("httpS://abiquo.example.com/api/");
var token = "invalid-token";
var parameters = string.Format(@"-Uri {0} -OAuth2Token '{1}'", uri, token);
Mock.Arrange(() => Client.Login(Arg.IsAny <string>(), Arg.IsAny <IAuthenticationInformation>()))
.IgnoreInstance()
.Returns(false);
var results = PsCmdletAssert.Invoke(sut, parameters, ex => ex);
Assert.IsNotNull(results);
Assert.AreEqual(0, results.Count);
}
public void InvokeWithParameterSetPlainWithValidTenantIdSucceeds()
{
// Arrange
var parameters = string.Format(@"-ApiBaseUri {0} -User '{1}' -Password '{2}' -TenantId {3}", _apiBaseUri, _username, _password, Identity.Tenant.SYSTEM_TID);
// Act
var results = PsCmdletAssert.Invoke(sut, parameters);
// Assert
Assert.IsNotNull(results);
Assert.AreEqual(1, results.Count);
var svc = results[0].BaseObject as Dictionary <string, DataServiceContextBase>;
Assert.IsNotNull(svc);
Assert.AreEqual(2, svc.Count);
}
public void InvokeWithParameterSetCredSucceeds()
{
// Arrange
var parameters = string.Format(@"-ApiBaseUri {0} -Credential $([pscredential]::new('{1}', (ConvertTo-SecureString -AsPlainText -String {2} -Force)))", _apiBaseUri, _username, _password);
// Act
var results = PsCmdletAssert.Invoke(sut, parameters);
// Assert
Assert.IsNotNull(results);
Assert.AreEqual(1, results.Count);
var svc = results[0].BaseObject as Dictionary <string, DataServiceContextBase>;
Assert.IsNotNull(svc);
Assert.AreEqual(2, svc.Count);
}
public void InvokeGetTenantWithIdParameterCallsApiWithFilterAndReturnsResult()
{
// Arrange
var tenant = CreateSampleTenant();
var tenantId = tenant.Id;
var coreContext = Mock.Create <Api::Net.Appclusive.Api.Core.Core>();
var dataServiceQuery = Mock.Create <DataServiceQuery <Tenant> >();
Mock.Arrange(() => coreContext.Tenants)
.Returns(dataServiceQuery)
.OccursOnce();
Mock.Arrange(() => dataServiceQuery.Id(tenantId))
.Returns(tenant)
.OccursOnce();
var svc = new Dictionary <string, DataServiceContextBase>
{
{
nameof(Api::Net.Appclusive.Api.Core.Core),
coreContext
}
};
var parameters = new Dictionary <string, object>()
{
{ nameof(GetTenant.Id), tenantId },
{ nameof(svc), svc }
};
// Act
var results = PsCmdletAssert.Invoke(sut, parameters);
// Assert
Assert.IsNotNull(results);
Assert.AreEqual(1, results.Count);
var result0 = results[0].BaseObject as Tenant;
Assert.IsNotNull(result0);
Assert.AreEqual(tenantId, result0.Id);
Mock.Assert(coreContext);
Mock.Assert(dataServiceQuery);
}
public void InvokeParameterSetListAvailableSucceeds()
{
Mock.Arrange(() => CurrentClient.IsLoggedIn)
.Returns(true);
Mock.Arrange(() => CurrentClient.GetAllVirtualMachines())
.Returns(VirtualMachines)
.MustBeCalled();
var parameters = @"-ListAvailable";
var results = PsCmdletAssert.Invoke(sut, parameters);
Assert.IsNotNull(results);
Assert.AreEqual(3, results.Count);
Mock.Assert(() => CurrentClient.GetAllVirtualMachines());
}
public void InvokeParameterSetIdWriterErrorRecord()
{
Mock.Arrange(() => CurrentClient.IsLoggedIn)
.Returns(true);
Mock.Arrange(() => CurrentClient.GetAllVirtualMachines())
.Returns(VirtualMachines)
.MustBeCalled();
// this Id does not exist
var parameters = @"-Id 9999";
var results = PsCmdletAssert.Invoke(sut, parameters, er => { Assert.IsTrue(er.Single().Exception.Message.Contains("9999")); });
Assert.IsNotNull(results);
Assert.AreEqual(0, results.Count);
Mock.Assert(() => CurrentClient.GetAllVirtualMachines());
}
public void InvokeWithEmptyPathAndDisplayOnlyFalseSucceeds()
{
var parameters = @"-DisplayOnly:$false; Get-Variable net_Appclusive_PS_Client -ValueOnly;";
var results = PsCmdletAssert.Invoke(sut, parameters);
Assert.IsNotNull(results);
Assert.AreEqual(2, results.Count);
var moduleContext = results[0].BaseObject;
Assert.IsNotNull(moduleContext);
Assert.IsInstanceOfType(moduleContext, typeof(ModuleContext));
var variable = results[1].BaseObject;
Assert.IsNotNull(variable);
Assert.IsInstanceOfType(variable, typeof(ModuleContext));
Assert.AreEqual(variable, moduleContext);
}
public void InvokeWithParameterSetOAuth2Succeeds()
{
var uri = new Uri("httpS://abiquo.example.com/api/");
var token = "arbitrary-token";
var parameters = string.Format(@"-Uri {0} -OAuth2Token '{1}'", uri, token);
Mock.Arrange(() => Client.Login(Arg.IsAny <string>(), Arg.IsAny <IAuthenticationInformation>()))
.IgnoreInstance()
.Returns(true);
var results = PsCmdletAssert.Invoke(sut, parameters);
Assert.IsNotNull(results);
Assert.AreEqual(1, results.Count);
Assert.IsInstanceOfType(results[0].BaseObject, typeof(BaseAbiquoClient));
var result = (BaseAbiquoClient)results[0].BaseObject;
Assert.IsNotNull(result);
Assert.AreEqual(User.Id, result.CurrentUserInformation.Id);
}
public void InvokeWithParameterSetCredSucceeds()
{
var uri = new Uri("httpS://abiquo.example.com/api/");
var user = "******";
var password = "******";
var parameters = string.Format(@"-Uri {0} -Credential $([pscredential]::new('{1}', (ConvertTo-SecureString -AsPlainText -String {2} -Force)))", uri, user, password);
Mock.Arrange(() => Client.Login(Arg.IsAny <string>(), Arg.IsAny <IAuthenticationInformation>()))
.IgnoreInstance()
.Returns(true);
var results = PsCmdletAssert.Invoke(sut, parameters);
Assert.IsNotNull(results);
Assert.AreEqual(1, results.Count);
Assert.IsInstanceOfType(results[0].BaseObject, typeof(BaseAbiquoClient));
var result = (BaseAbiquoClient)results[0].BaseObject;
Assert.IsNotNull(result);
Assert.AreEqual(User.Id, result.CurrentUserInformation.Id);
}
public void InvokeWithParameterSetConfigSucceeds()
{
// Arrange
var fileInfo = ModuleConfiguration.ResolveConfigurationFileInfo(null);
var moduleContextSection = ModuleConfiguration.GetModuleContextConfigurationSection(fileInfo);
ModuleConfiguration.SetModuleContext(moduleContextSection);
var parameters = "-UseModuleContext";
// Act
var results = PsCmdletAssert.Invoke(sut, parameters);
// Assert
Assert.IsNotNull(results);
Assert.AreEqual(1, results.Count);
var svc = results[0].BaseObject as Dictionary <string, DataServiceContextBase>;
Assert.IsNotNull(svc);
Assert.AreEqual(2, svc.Count);
ModuleConfiguration.SetModuleContext(new ModuleContextConfigurationSection());
}
public void ParameterSetIdHasExpectedOutputType()
{
PsCmdletAssert.HasOutputType(sut, typeof(VirtualMachine), GetMachine.ParameterSets.ID);
}
