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);
}
}
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 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 void ShouldNOtDeleteNonExistingObject()
{
// Precondition
var sut = RandomObjectFactory.GenerateRandomObject <T>();
// Test
Assert.That(
() =>
DeletableRepository.Delete(sut.SchemaName, sut.Name),
Throws.TypeOf <ObjectNotFound>());
}
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 CleanUp()
{
foreach (var obj in sut)
{
DeletableRepository.Delete(obj.SchemaName, obj.Name);
// If this is a group object, delete its members
// TODO: Deal with nested Groups
if (obj is AddressGroupObject)
{
foreach (var member in (obj as AddressGroupObject).Members)
{
DeletableRepository.Delete(Schema.AddressSchemaName, member);
}
}
}
}
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 override void OnActionExecuting(ActionExecutingContext filterContext)
{
base.OnActionExecuting(filterContext);
var user = filterContext.HttpContext.User;
if (user.Identity.IsAuthenticated == true)
{
var users = new DeletableRepository <ApplicationUser>(new ApplicationDbContext());
var usr = users.FirstOrDefault(u => u.Email == user.Identity.Name.ToLower());
if (usr != null)
{
var viewBag = filterContext.Controller.ViewBag;
viewBag.User = usr;
}
}
}
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 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 BlogsService(BlogDbContext context)
{
this.repository = new DeletableRepository <Blog>(context);
}
public PostsService(BlogDbContext context)
{
this.repository = new DeletableRepository <Post>(context);
}
public CommentService(BlogDbContext context)
{
this.repository = new DeletableRepository<Comment>(context);
}
