public void ShouldAddSingleMemberPassedAsParameter()
{
// Setup
var sut = RandomObjectFactory.GenerateRandomObject <TGroup>();
AddableRepository.Add(sut);
var newMember = RandomObjectFactory.GenerateRandomObject <TMember>();
AddableRepository.Add(newMember);
// Test
var script = $"Add-{noun} -GroupName {sut.Name} -MemberName {newMember.Name};";
psTestRunner.ExecuteCommand(script);
// Validate
var updatedGroup = searchableRepository.GetSingle <TGroupDeserializer>(sut.Name, ConfigTypes.Candidate).Single();
Assert.IsTrue(updatedGroup.Members.Contains(newMember.Name));
Assert.AreNotEqual(sut.Members.Count, updatedGroup.Members.Count);
Assert.IsTrue((updatedGroup.Members.Count - sut.Members.Count) == 1);
// Cleanup
DeletableRepository.Delete(sut.SchemaName, sut.Name);
foreach (var member in updatedGroup.Members)
{
DeletableRepository.Delete(newMember.SchemaName, member);
}
}
public async Task Handle_SshPortPresentOnInstance_InstanceWithNoPortsReturned()
{
//Arrange
var fakeMediator = Substitute.For <IMediator>();
fakeMediator
.Send(
Arg.Is <GetLightsailInstanceByNameQuery>(arg =>
arg.Name == "some-instance-name"),
default)
.Returns(RandomObjectFactory
.Create <Instance>(instance =>
instance.Networking.Ports = new List <InstancePortInfo>()
{
new InstancePortInfo()
{
FromPort = 22,
ToPort = 22,
Protocol = NetworkProtocol.Tcp
}
}));
var handler = new GetConnectionDetailsQueryHandler(fakeMediator);
//Act
var response = await handler.Handle(new GetConnectionDetailsQuery("some-instance-name"), default);
//Assert
Assert.IsNotNull(response);
Assert.AreEqual(0, response.Ports.Count());
}
protected BaseConfigTest()
{
this.ConfigCommandFactory =
new ConfigCommandFactory(
new ApiUriFactory(
Connection.Host),
new ConfigPostKeyValuePairFactory(
Connection.AccessToken,
Connection.Vsys));
this.ConfigMembershipCommandFactory =
new ConfigMembershipCommandFactory(
new ApiUriFactory(
Connection.Host),
new ConfigMembershipPostKeyValuePairFactory(
Connection.AccessToken,
Connection.Vsys));
CommitCommandFactory = new CommitApiCommandFactory(
new ApiUriFactory(Connection.Host),
new CommitApiPostKeyValuePairFactory(Connection.AccessToken));
AddableRepository = new AddableRepository(ConfigCommandFactory);
DeletableRepository = new DeletableRepository(ConfigCommandFactory);
RandomObjectFactory = new RandomObjectFactory(new AddableRepository(ConfigCommandFactory));
}
public void CommitTest()
{
// Setup
var newObj = RandomObjectFactory.GenerateRandomObject <AddressObject>();
AddableRepository.Add(newObj);
var makeChangeScript =
$"$obj = {newObj.ToPsScript()};Add-PANOSObject -ConnectionProperties $ConnectionProperties -FirewallObject $obj";
PsRunner.ExecutePanosPowerShellScript(makeChangeScript);
// Test
const string CommitScript = "Save-PANOSChanges -ConnectionProperties $ConnectionProperties";
var results = PsRunner.ExecutePanosPowerShellScript(CommitScript);
// Validate
Assert.IsNotNull(results[0]);
var apiEnqueuedResponse = results[0].BaseObject as ApiEnqueuedResponse;
Assert.IsNotNull(apiEnqueuedResponse);
var job = apiEnqueuedResponse.Job;
Assert.IsNotNull(job);
Assert.IsTrue(job.Id > 0);
// Cleanup
this.DeletableRepository.Delete(newObj.SchemaName, newObj.Name);
}
public void ShouldSetMultipleFromObjectPassedAsParameter()
{
// Setup
var sut = RandomObjectFactory.GenerateRandomObjects <T>();
// Test
var script = string.Format(
"$obj1 = {0};$obj2={1};{2}-{3} -{4} $obj1,$obj2",
sut[0].ToPsScript(),
sut[1].ToPsScript(),
verb,
noun,
noun);
psTestRunner.ExecuteCommand(script);
// Validate
foreach (var obj in sut)
{
var confirmationObject = searchableRepository.GetSingle <TDeserializer>(obj.Name, ConfigTypes.Candidate);
Assert.IsTrue(confirmationObject.Any());
Assert.AreEqual(obj, confirmationObject.Single());
}
// Cleanup
foreach (var obj in sut)
{
DeletableRepository.Delete(obj.SchemaName, obj.Name);
}
}
public void ShouldNOtDeleteNonExistingObject()
{
// Precondition
var sut = RandomObjectFactory.GenerateRandomObject <T>();
// Test
Assert.That(
() =>
DeletableRepository.Delete(sut.SchemaName, sut.Name),
Throws.TypeOf <ObjectNotFound>());
}
public void ShouldNotRenameNonExistingTest()
{
// Precondition
var obj = RandomObjectFactory.GenerateRandomObject <T>();
// Test
Assert.That(
() =>
renamableRepository.Rename(obj.SchemaName, obj.Name, "foo"),
Throws.TypeOf <AttemptToRenameNonExistingObject>());
}
// "is not a valid reference"
public void ShouldThrowExceptionWhenAddingNonExistingMember()
{
// Setup
var sut = RandomObjectFactory.GenerateRandomObject <TGroup>();
AddableRepository.Add(sut);
var newMember = RandomObjectFactory.GenerateRandomName();
// Test
var script = $"Add-{noun} -GroupName {sut.Name} -MemberName {newMember};";
Assert.That(() => psTestRunner.ExecuteCommand(script), Throws.Exception);
}
public void ShouldDeleteObject()
{
// Precondition
var sut = RandomObjectFactory.GenerateRandomObject <T>();
AddableRepository.Add(sut);
Assert.IsTrue(searchableRepository.GetSingle <TDeserializer>(sut.Name, ConfigTypes.Candidate).Any());
// Test
DeletableRepository.Delete(sut.SchemaName, sut.Name);
// Postcondition
Assert.IsFalse(searchableRepository.GetSingle <TDeserializer>(sut.Name, ConfigTypes.Candidate).Any());
}
public void ShouldDeleteSingleByNamePassedAsParameter()
{
// Setup
var sut = RandomObjectFactory.GenerateRandomObject <T>();
AddableRepository.Add(sut);
Assert.IsTrue(searchableRepository.GetSingle <TDeserializer>(sut.Name, ConfigTypes.Candidate).Any());
// Test
var script = $"$name = '{sut.Name}';Remove-{this.noun} -Name $name;";
psTestRunner.ExecuteCommand(script);
// Validate
Assert.IsFalse(searchableRepository.GetSingle <TDeserializer>(sut.Name, ConfigTypes.Candidate).Any());
}
public void ShouldDeleteAndPassThruObjectTest()
{
// Setup
var sut = RandomObjectFactory.GenerateRandomObject <T>();
AddableRepository.Add(sut);
Assert.IsTrue(searchableRepository.GetSingle <TDeserializer>(sut.Name, ConfigTypes.Candidate).Any());
// Test
var script = $"$obj = {sut.ToPsScript()};Remove-{noun} -{noun} $obj -PassThru;";
var passThruObject = psTestRunner.ExecuteCommandWithPasThru(script);
// Validate
Assert.IsFalse(searchableRepository.GetSingle <TDeserializer>(sut.Name, ConfigTypes.Candidate).Any());
Assert.IsNotNull(passThruObject);
Assert.AreEqual(passThruObject, sut);
}
public async Task Handle_NonSslPortsPresentOnInstance_InstanceWithPortsReturned()
{
//Arrange
var fakeMediator = Substitute.For <IMediator>();
fakeMediator
.Send(
Arg.Is <GetLightsailInstanceByNameQuery>(arg =>
arg.Name == "some-instance-name"),
default)
.Returns(RandomObjectFactory
.Create <Instance>(instance =>
instance.Networking.Ports = new List <InstancePortInfo>()
{
new InstancePortInfo()
{
FromPort = 23,
ToPort = 24,
Protocol = NetworkProtocol.Tcp
},
new InstancePortInfo()
{
FromPort = 25,
ToPort = 26,
Protocol = NetworkProtocol.Udp
}
}));
var handler = new GetConnectionDetailsQueryHandler(fakeMediator);
//Act
var response = await handler.Handle(new GetConnectionDetailsQuery("some-instance-name"), default);
//Assert
Assert.IsNotNull(response);
var allPorts = response.Ports.ToArray();
Assert.AreEqual(4, allPorts.Length);
Assert.IsTrue(allPorts.Any(x => x.Port == 23 && x.Protocol == SocketProtocol.Tcp));
Assert.IsTrue(allPorts.Any(x => x.Port == 24 && x.Protocol == SocketProtocol.Tcp));
Assert.IsTrue(allPorts.Any(x => x.Port == 25 && x.Protocol == SocketProtocol.Udp));
Assert.IsTrue(allPorts.Any(x => x.Port == 26 && x.Protocol == SocketProtocol.Udp));
}
public void CommitWhileAnotherCommitIsInProgressTest()
{
// Setup
var newObj = RandomObjectFactory.GenerateRandomObject <AddressObject>();
AddableRepository.Add(newObj);
var makeChangeScript =
$"$obj = {newObj.ToPsScript()};Add-PANOSObject -ConnectionProperties $ConnectionProperties -FirewallObject $obj";
PsRunner.ExecutePanosPowerShellScript(makeChangeScript);
// Test
const string CommitScript = "Save-PANOSChanges -ConnectionProperties $ConnectionProperties";
PsRunner.ExecutePanosPowerShellScript(CommitScript);
Assert.That(() => PsRunner.ExecutePanosPowerShellScript(CommitScript), Throws.TypeOf <CmdletInvocationException>());
}
public void Setup()
{
this.sut = new List <T>
{
RandomObjectFactory.GenerateRandomObject <T>(),
RandomObjectFactory.GenerateRandomObject <T>()
};
foreach (var objectUnderTest in this.sut)
{
AddableRepository.Add(objectUnderTest);
}
if (configType == ConfigTypes.Running)
{
CommitCandidateConfig();
}
}
public void ShouldRenameObject()
{
// Setup
var sut = RandomObjectFactory.GenerateRandomObject <T>();
AddableRepository.Add(sut);
// Test
var newName = RandomObjectFactory.GenerateRandomName();
renamableRepository.Rename(sut.SchemaName, sut.Name, newName);
// Postcondition
Assert.IsTrue(searchableRepository.GetSingle <TDeserializer>(newName, ConfigTypes.Candidate).Any());
Assert.IsFalse(searchableRepository.GetSingle <TDeserializer>(sut.Name, ConfigTypes.Candidate).Any());
// Clean-up
DeletableRepository.Delete(sut.SchemaName, newName);
}
public void ShouldAddSingleFromObjectPassedAsParameter()
{
// Setup
var sut = RandomObjectFactory.GenerateRandomObject <T>();
// Test
var script = string.Format(
"$obj = {0};{1}-{2} -{3} $obj", sut.ToPsScript(), verb, noun, noun);
psTestRunner.ExecuteCommand(script);
// Validate
var confirmationObject = searchableRepository.GetSingle <TDeserializer>(sut.Name, ConfigTypes.Candidate);
Assert.IsTrue(confirmationObject.Any());
Assert.AreEqual(sut, confirmationObject.Single());
// Cleanup
DeletableRepository.Delete(sut.SchemaName, sut.Name);
}
public async Task Handle_DomainsPresent_InstanceWithDomainHostNameReturned()
{
//Arrange
var fakeMediator = Substitute.For <IMediator>();
fakeMediator
.Send(
Arg.Is <GetLightsailInstanceByNameQuery>(arg =>
arg.Name == "some-instance-name"),
default)
.Returns(RandomObjectFactory
.Create <Instance>(instance =>
instance.PublicIpAddress = "127.0.0.1"));
fakeMediator
.Send(
Arg.Any <GetAllLightsailDomainsQuery>(),
default)
.Returns(new[] {
RandomObjectFactory.Create <global::Amazon.Lightsail.Model.Domain>(domain =>
domain.DomainEntries = new List <DomainEntry>()
{
new DomainEntry()
{
Target = "127.0.0.1",
Name = "some-hostname"
}
})
});
var handler = new GetConnectionDetailsQueryHandler(fakeMediator);
//Act
var response = await handler.Handle(new GetConnectionDetailsQuery("some-instance-name"), default);
//Assert
Assert.IsNotNull(response);
Assert.AreEqual("some-hostname", response.HostName);
}
public void ShouldPassThruCreatedObject()
{
// Setup
var sut = RandomObjectFactory.GenerateRandomObject <T>();
// Test
var script = string.Format(
"$obj = {0};{1}-{2} -{3} $obj -PassThru", sut.ToPsScript(), verb, noun, noun);
var passedThruObj = psTestRunner.ExecuteCommandWithPasThru(script);
// Validate
Assert.IsNotNull(passedThruObj);
Assert.AreEqual(passedThruObj, sut);
var confirmationObject = searchableRepository.GetSingle <TDeserializer>(sut.Name, ConfigTypes.Candidate);
Assert.IsTrue(confirmationObject.Any());
Assert.AreEqual(sut, confirmationObject.Single());
// Cleanup
DeletableRepository.Delete(sut.SchemaName, sut.Name);
}
public void ShouldDeleteMultipleByNamePassedAsParameter()
{
// Setup
var sut = RandomObjectFactory.GenerateRandomObjects <T>();
foreach (var obj in sut)
{
AddableRepository.Add(obj);
Assert.IsTrue(searchableRepository.GetSingle <TDeserializer>(obj.Name, ConfigTypes.Candidate).Any());
}
// Test
var script = $"$name1 = '{sut[0].Name}'; $name2 = '{sut[1].Name}'; Remove-{noun} -Name $name1, $name2;";
psTestRunner.ExecuteCommand(script);
// Validate
foreach (var obj in sut)
{
Assert.IsFalse(searchableRepository.GetSingle <TDeserializer>(obj.Name, ConfigTypes.Candidate).Any());
}
}
public void ShouldDeleteMultipleByObjectPassedViaPipeline()
{
// Setup
var sut = RandomObjectFactory.GenerateRandomObjects <T>();
foreach (var obj in sut)
{
AddableRepository.Add(obj);
Assert.IsTrue(searchableRepository.GetSingle <TDeserializer>(obj.Name, ConfigTypes.Candidate).Any());
}
// Test
var script =
$"$obj1 = {sut[0].ToPsScript()}; $obj2 = {sut[1].ToPsScript()}; $obj1, $obj2 | Remove-{this.noun};";
psTestRunner.ExecuteCommand(script);
// Validate
foreach (var obj in sut)
{
Assert.IsFalse(searchableRepository.GetSingle <TDeserializer>(obj.Name, ConfigTypes.Candidate).Any());
}
}
public async Task Get_OneInstanceFound_InstanceReturned()
{
//Arrange
var fakeMediator = Substitute.For <IMediator>();
fakeMediator
.Send(
Arg.Is <EnsureUserForIdentityCommand>(
args => args.IdentityName == "some-identity-name"),
default)
.Returns(new User());
fakeMediator
.Send(Arg.Any <GetProvisionedClustersWithInstancesForUserQuery>(), default)
.Returns(new[]
{
RandomObjectFactory.Create <UserClusterResponse>()
});
var mapper = AutoMapperFactory.CreateValidMapper();
var controller = new ClustersController(
fakeMediator,
mapper);
controller.FakeAuthentication("some-identity-name");
//Act
var result = await controller.Get();
//Assert
var clusters = result.ToArray();
Assert.AreEqual(1, clusters.Length);
Assert.AreEqual(1, clusters.Single().Instances.Count());
}
public void ShouldNotGetAnythingWhenNonExistingNameSupplied()
{
var objectUnderTest = RandomObjectFactory.GenerateRandomObject <T>();
Assert.AreEqual(searchableRepository.GetSingle <TGetSingleDeserializer>(objectUnderTest.Name, configType).Count(), 0);
}
