public void ShouldGetSingleResourceByClaimSetIdAndResourceId()
{
var testApplication = new Application
{
ApplicationName = "TestApplicationName"
};
Save(testApplication);
var testClaimSets = SetupApplicationWithClaimSets(testApplication).ToList();
var testResourceClaims = SetupParentResourceClaims(testClaimSets, testApplication);
Transaction <SqlServerSecurityContext>(securityContext =>
{
var query = new GetResourcesByClaimSetIdQuery(securityContext, GetMapper());
foreach (var testClaimSet in testClaimSets)
{
var testResourceClaim =
testResourceClaims.Single(x => x.ClaimSet.ClaimSetId == testClaimSet.ClaimSetId && x.ResourceClaim.ResourceName == "TestResourceClaim3.00").ResourceClaim;
var result = query.SingleResource(testClaimSet.ClaimSetId, testResourceClaim.ResourceClaimId);
result.Name.ShouldBe(testResourceClaim.ResourceName);
result.Id.ShouldBe(testResourceClaim.ResourceClaimId);
result.Create.ShouldBe(true);
result.Read.ShouldBe(false);
result.Update.ShouldBe(false);
result.Delete.ShouldBe(false);
}
});
}
public void ShouldGetDefaultAuthorizationStrategiesForParentResourcesByClaimSetId()
{
var testApplication = new Application
{
ApplicationName = "TestApplicationName"
};
Save(testApplication);
var testClaimSet = new ClaimSet
{
ClaimSetName = "TestClaimSet",
Application = testApplication
};
Save(testClaimSet);
var appAuthorizationStrategies = SetupApplicationAuthorizationStrategies(testApplication).ToList();
var testResourceClaims = SetupParentResourceClaims(new List <ClaimSet> {
testClaimSet
}, testApplication);
var testAuthStrategies = SetupResourcesWithDefaultAuthorizationStrategies(appAuthorizationStrategies, testResourceClaims.ToList());
Transaction <SqlServerSecurityContext>(securityContext =>
{
var query = new GetResourcesByClaimSetIdQuery(securityContext, GetMapper());
var results = query.AllResources(testClaimSet.ClaimSetId).ToArray();
results.Select(x => x.DefaultAuthStrategiesForCRUD[0].AuthStrategyName).ShouldBe(testAuthStrategies.Select(x => x.AuthorizationStrategy.AuthorizationStrategyName), true);
});
}
public void ShouldGetParentResourcesByClaimSetId()
{
var testApplication = new Application
{
ApplicationName = "TestApplicationName"
};
Save(testApplication);
var testClaimSets = SetupApplicationWithClaimSets(testApplication).ToList();
var testResourceClaims = SetupParentResourceClaims(testClaimSets, testApplication);
Transaction <SqlServerSecurityContext>(securityContext =>
{
var query = new GetResourcesByClaimSetIdQuery(securityContext, GetMapper());
foreach (var testClaimSet in testClaimSets)
{
var results = query.AllResources(testClaimSet.ClaimSetId).ToArray();
var testResourceClaimsForId =
testResourceClaims.Where(x => x.ClaimSet.ClaimSetId == testClaimSet.ClaimSetId).Select(x => x.ResourceClaim).ToArray();
results.Length.ShouldBe(testResourceClaimsForId.Length);
results.Select(x => x.Name).ShouldBe(testResourceClaimsForId.Select(x => x.ResourceName), true);
results.Select(x => x.Id).ShouldBe(testResourceClaimsForId.Select(x => x.ResourceClaimId), true);
results.All(x => x.Create).ShouldBe(true);
}
});
}
public void ShouldNotAddDuplicateResourcesToClaimSetDuringEdit()
{
var testApplication = new Application
{
ApplicationName = $"Test Application {DateTime.Now:O}"
};
Save(testApplication);
var testClaimSet = new ClaimSet {
ClaimSetName = "TestClaimSet", Application = testApplication
};
Save(testClaimSet);
SetupParentResourceClaimsWithChildren(testClaimSet, testApplication);
var existingResources = new GetResourcesByClaimSetIdQuery(TestContext, GetMapper()).AllResources(testClaimSet.ClaimSetId)
.ToList();
var duplicateResource = existingResources.Single(x => x.Name == "TestParentResourceClaim1");
var editResourceOnClaimSetModel = new EditClaimSetResourceModel
{
ClaimSetId = testClaimSet.ClaimSetId,
ResourceClaim = duplicateResource,
ExistingResourceClaims = existingResources
};
var validator = new EditClaimSetResourceModelValidator();
var validationResults = validator.Validate(editResourceOnClaimSetModel);
validationResults.IsValid.ShouldBe(false);
validationResults.Errors.Single().ErrorMessage.ShouldBe("Only unique resource claims can be added. The following is a duplicate resource:\nTestParentResourceClaim1");
}
public void ShouldResetAuthorizationStrategiesForParentResourcesOnClaimSet()
{
var testApplication = new Application
{
ApplicationName = "TestApplicationName"
};
Save(testApplication);
var testClaimSet = new ClaimSet
{
ClaimSetName = "TestClaimSet",
Application = testApplication
};
Save(testClaimSet);
var appAuthorizationStrategies = SetupApplicationAuthorizationStrategies(testApplication).ToList();
var testResourceClaims = SetupParentResourceClaimsWithChildren(testClaimSet, testApplication);
var testResourceToEdit = testResourceClaims.Select(x => x.ResourceClaim).Single(x => x.ResourceName == "TestParentResourceClaim1");
var resultResourceClaimBeforeOverride = new GetResourcesByClaimSetIdQuery(TestContext, GetMapper()).AllResources(testClaimSet.ClaimSetId).Single(x => x.Id == testResourceToEdit.ResourceClaimId);
resultResourceClaimBeforeOverride.AuthStrategyOverridesForCRUD[0].ShouldBeNull();
resultResourceClaimBeforeOverride.AuthStrategyOverridesForCRUD[1].ShouldBeNull();
resultResourceClaimBeforeOverride.AuthStrategyOverridesForCRUD[2].ShouldBeNull();
resultResourceClaimBeforeOverride.AuthStrategyOverridesForCRUD[3].ShouldBeNull();
SetupOverridesForResourceCreateAction(testResourceToEdit.ResourceClaimId, testClaimSet.ClaimSetId,
appAuthorizationStrategies.Single(x => x.AuthorizationStrategyName == "TestAuthStrategy4")
.AuthorizationStrategyId);
var resultResourceClaimAfterOverride = new GetResourcesByClaimSetIdQuery(TestContext, GetMapper()).AllResources(testClaimSet.ClaimSetId).Single(x => x.Id == testResourceToEdit.ResourceClaimId);
resultResourceClaimAfterOverride.AuthStrategyOverridesForCRUD[0].ShouldNotBeNull();
resultResourceClaimAfterOverride.AuthStrategyOverridesForCRUD[0].AuthStrategyName.ShouldBe("TestAuthStrategy4");
resultResourceClaimAfterOverride.AuthStrategyOverridesForCRUD[1].ShouldBeNull();
resultResourceClaimAfterOverride.AuthStrategyOverridesForCRUD[2].ShouldBeNull();
resultResourceClaimAfterOverride.AuthStrategyOverridesForCRUD[3].ShouldBeNull();
var resetModel = new ResetToDefaultAuthStrategyModel
{
ResourceClaimId = testResourceToEdit.ResourceClaimId,
ClaimSetId = testClaimSet.ClaimSetId
};
var command = new ResetToDefaultAuthStrategyCommand(TestContext);
command.Execute(resetModel);
var resultResourceClaimAfterReset = new GetResourcesByClaimSetIdQuery(TestContext, GetMapper()).AllResources(testClaimSet.ClaimSetId).Single(x => x.Id == testResourceToEdit.ResourceClaimId);
resultResourceClaimAfterReset.AuthStrategyOverridesForCRUD[0].ShouldBeNull();
resultResourceClaimAfterReset.AuthStrategyOverridesForCRUD[1].ShouldBeNull();
resultResourceClaimAfterReset.AuthStrategyOverridesForCRUD[2].ShouldBeNull();
resultResourceClaimAfterReset.AuthStrategyOverridesForCRUD[3].ShouldBeNull();
}
public void ShouldEditParentResourcesOnClaimSet()
{
var testApplication = new Application
{
ApplicationName = $"Test Application {DateTime.Now:O}"
};
Save(testApplication);
var testClaimSet = new ClaimSet {
ClaimSetName = "TestClaimSet", Application = testApplication
};
Save(testClaimSet);
var testResources = SetupParentResourceClaimsWithChildren(testClaimSet, testApplication);
var testResource1ToEdit = testResources.Select(x => x.ResourceClaim).Single(x => x.ResourceName == "TestParentResourceClaim1");
var testResource2ToNotEdit = testResources.Select(x => x.ResourceClaim).Single(x => x.ResourceName == "TestParentResourceClaim2");
var editedResource = new ResourceClaim
{
Id = testResource1ToEdit.ResourceClaimId,
Name = testResource1ToEdit.ResourceName,
Create = false,
Read = false,
Update = true,
Delete = true
};
var editResourceOnClaimSetModel = new Mock <IEditResourceOnClaimSetModel>();
editResourceOnClaimSetModel.Setup(x => x.ClaimSetId).Returns(testClaimSet.ClaimSetId);
editResourceOnClaimSetModel.Setup(x => x.ResourceClaim).Returns(editedResource);
var command = new EditResourceOnClaimSetCommand(TestContext);
command.Execute(editResourceOnClaimSetModel.Object);
var resourceClaimsForClaimSet = new GetResourcesByClaimSetIdQuery(TestContext, GetMapper()).AllResources(testClaimSet.ClaimSetId).ToList();
var parentResources = testResources.Where(x =>
x.ClaimSet.ClaimSetId == testClaimSet.ClaimSetId && x.ResourceClaim.ParentResourceClaim == null).Select(x => x.ResourceClaim).ToList();
resourceClaimsForClaimSet.Count().ShouldBe(parentResources.Count);
var resultResourceClaim1 = resourceClaimsForClaimSet.Single(x => x.Id == editedResource.Id);
resultResourceClaim1.Create.ShouldBe(editedResource.Create);
resultResourceClaim1.Read.ShouldBe(editedResource.Read);
resultResourceClaim1.Update.ShouldBe(editedResource.Update);
resultResourceClaim1.Delete.ShouldBe(editedResource.Delete);
var resultResourceClaim2 = resourceClaimsForClaimSet.Single(x => x.Id == testResource2ToNotEdit.ResourceClaimId);
resultResourceClaim2.Create.ShouldBe(true);
resultResourceClaim2.Read.ShouldBe(false);
resultResourceClaim2.Update.ShouldBe(false);
resultResourceClaim2.Delete.ShouldBe(false);
}
public void ShouldCopyClaimSet()
{
var testApplication = new Application
{
ApplicationName = $"Test Application {DateTime.Now:O}"
};
Save(testApplication);
var testClaimSet = new ClaimSet {
ClaimSetName = "TestClaimSet", Application = testApplication
};
Save(testClaimSet);
var testResourceClaims = SetupParentResourceClaimsWithChildren(testClaimSet, testApplication);
var newClaimSet = new Mock <ICopyClaimSetModel>();
newClaimSet.Setup(x => x.Name).Returns("TestClaimSet_Copy");
newClaimSet.Setup(x => x.OriginalId).Returns(testClaimSet.ClaimSetId);
var command = new CopyClaimSetCommand(TestContext);
var copyClaimSetId = command.Execute(newClaimSet.Object);
var copiedClaimSet = TestContext.ClaimSets.Single(x => x.ClaimSetId == copyClaimSetId);
copiedClaimSet.ClaimSetName.ShouldBe(newClaimSet.Object.Name);
Transaction <SqlServerSecurityContext>(securityContext =>
{
var query = new GetResourcesByClaimSetIdQuery(securityContext, GetMapper());
var results = query.AllResources(copiedClaimSet.ClaimSetId).ToArray();
var testParentResourceClaimsForId =
testResourceClaims.Where(x => x.ClaimSet.ClaimSetId == testClaimSet.ClaimSetId && x.ResourceClaim.ParentResourceClaim == null).Select(x => x.ResourceClaim).ToArray();
results.Length.ShouldBe(testParentResourceClaimsForId.Length);
results.Select(x => x.Name).ShouldBe(testParentResourceClaimsForId.Select(x => x.ResourceName), true);
results.Select(x => x.Id).ShouldBe(testParentResourceClaimsForId.Select(x => x.ResourceClaimId), true);
results.All(x => x.Create).ShouldBe(true);
foreach (var testParentResourceClaim in testParentResourceClaimsForId)
{
var testChildren = securityContext.ResourceClaims.Where(x =>
x.ParentResourceClaimId == testParentResourceClaim.ResourceClaimId).ToList();
var parentResult = results.First(x => x.Id == testParentResourceClaim.ResourceClaimId);
parentResult.Children.Select(x => x.Name).ShouldBe(testChildren.Select(x => x.ResourceName), true);
parentResult.Children.Select(x => x.Id).ShouldBe(testChildren.Select(x => x.ResourceClaimId), true);
parentResult.Children.All(x => x.Create).ShouldBe(true);
}
});
Transaction <SqlServerUsersContext>(usersContext =>
{
usersContext.Applications.Count(x => x.ClaimSetName == copiedClaimSet.ClaimSetName).ShouldBe(0);
});
}
public void ShouldOverrideAuthorizationStrategiesForParentResourcesOnClaimSet()
{
var testApplication = new Application
{
ApplicationName = "TestApplicationName"
};
Save(testApplication);
var testClaimSet = new ClaimSet
{
ClaimSetName = "TestClaimSet",
Application = testApplication
};
Save(testClaimSet);
var appAuthorizationStrategies = SetupApplicationAuthorizationStrategies(testApplication).ToList();
var testResourceClaims = SetupParentResourceClaimsWithChildren(testClaimSet, testApplication);
SetupResourcesWithDefaultAuthorizationStrategies(appAuthorizationStrategies, testResourceClaims.ToList());
var testResource1ToEdit = testResourceClaims.Select(x => x.ResourceClaim).Single(x => x.ResourceName == "TestParentResourceClaim1");
var testResource2ToNotEdit = testResourceClaims.Select(x => x.ResourceClaim).Single(x => x.ResourceName == "TestParentResourceClaim2");
var overrideModel = new OverrideDefaultAuthorizationStrategyModel
{
ResourceClaimId = testResource1ToEdit.ResourceClaimId,
ClaimSetId = testClaimSet.ClaimSetId,
AuthorizationStrategyForCreate = appAuthorizationStrategies.Single(x => x.AuthorizationStrategyName == "TestAuthStrategy4").AuthorizationStrategyId,
AuthorizationStrategyForRead = 0,
AuthorizationStrategyForUpdate = 0,
AuthorizationStrategyForDelete = 0
};
var command = new OverrideDefaultAuthorizationStrategyCommand(TestContext);
command.Execute(overrideModel);
var resourceClaimsForClaimSet = new GetResourcesByClaimSetIdQuery(TestContext, GetMapper()).AllResources(testClaimSet.ClaimSetId).ToList();
var resultResourceClaim1 = resourceClaimsForClaimSet.Single(x => x.Id == overrideModel.ResourceClaimId);
resultResourceClaim1.AuthStrategyOverridesForCRUD[0].AuthStrategyName.ShouldBe("TestAuthStrategy4");
resultResourceClaim1.AuthStrategyOverridesForCRUD[1].ShouldBeNull();
resultResourceClaim1.AuthStrategyOverridesForCRUD[2].ShouldBeNull();
resultResourceClaim1.AuthStrategyOverridesForCRUD[3].ShouldBeNull();
var resultResourceClaim2 = resourceClaimsForClaimSet.Single(x => x.Id == testResource2ToNotEdit.ResourceClaimId);
resultResourceClaim2.AuthStrategyOverridesForCRUD[0].ShouldBeNull();
resultResourceClaim2.AuthStrategyOverridesForCRUD[1].ShouldBeNull();
resultResourceClaim2.AuthStrategyOverridesForCRUD[2].ShouldBeNull();
resultResourceClaim2.AuthStrategyOverridesForCRUD[3].ShouldBeNull();
}
public void ShouldAddChildResourcesToClaimSet()
{
var testApplication = new Application
{
ApplicationName = $"Test Application {DateTime.Now:O}"
};
Save(testApplication);
var testClaimSet = new ClaimSet {
ClaimSetName = "TestClaimSet", Application = testApplication
};
Save(testClaimSet);
var testResources = SetupResourceClaims(testApplication);
var testParentResource1 = testResources.Single(x => x.ResourceName == "TestParentResourceClaim1");
var testChildResource1ToAdd = TestContext.ResourceClaims.Single(x => x.ResourceName == "TestChildResourceClaim1" && x.ParentResourceClaimId == testParentResource1.ResourceClaimId);
var resourceToAdd = new ResourceClaim()
{
Id = testChildResource1ToAdd.ResourceClaimId,
Name = testChildResource1ToAdd.ResourceName,
Create = true,
Read = false,
Update = true,
Delete = false
};
var existingResources = new GetResourcesByClaimSetIdQuery(TestContext, GetMapper()).AllResources(testClaimSet.ClaimSetId)
.ToList();
var editResourceOnClaimSetModel = new EditClaimSetResourceModel
{
ClaimSetId = testClaimSet.ClaimSetId,
ResourceClaim = resourceToAdd,
ExistingResourceClaims = existingResources
};
var command = new EditResourceOnClaimSetCommand(TestContext);
command.Execute(editResourceOnClaimSetModel);
var resourceClaimsForClaimSet = new GetResourcesByClaimSetIdQuery(TestContext, GetMapper()).AllResources(testClaimSet.ClaimSetId).ToList();
var resultChildResourceClaim1 =
resourceClaimsForClaimSet.Single(x => x.Name == testChildResource1ToAdd.ResourceName);
resultChildResourceClaim1.Create.ShouldBe(resourceToAdd.Create);
resultChildResourceClaim1.Read.ShouldBe(resourceToAdd.Read);
resultChildResourceClaim1.Update.ShouldBe(resourceToAdd.Update);
resultChildResourceClaim1.Delete.ShouldBe(resourceToAdd.Delete);
}
public void ShouldGetDefaultAuthorizationStrategiesForParentResourcesWithChildrenByClaimSetId()
{
var testApplication = new Application
{
ApplicationName = "TestApplicationName"
};
Save(testApplication);
var testClaimSet = new ClaimSet
{
ClaimSetName = "TestClaimSet",
Application = testApplication
};
Save(testClaimSet);
var appAuthorizationStrategies = SetupApplicationAuthorizationStrategies(testApplication).ToList();
var testResourceClaims = SetupParentResourceClaimsWithChildren(new List <ClaimSet> {
testClaimSet
}, testApplication);
var testAuthStrategies = SetupResourcesWithDefaultAuthorizationStrategies(appAuthorizationStrategies, testResourceClaims.ToList());
Transaction <SqlServerSecurityContext>(securityContext =>
{
var query = new GetResourcesByClaimSetIdQuery(securityContext, GetMapper());
var results = query.AllResources(testClaimSet.ClaimSetId).ToArray();
var testParentResourceClaimsForId =
testResourceClaims
.Where(x => x.ClaimSet.ClaimSetId == testClaimSet.ClaimSetId &&
x.ResourceClaim.ParentResourceClaim == null).Select(x => x.ResourceClaim).ToArray();
var testAuthStrategiesForParents =
testAuthStrategies.Where(x => x.ResourceClaim.ParentResourceClaim == null);
results.Select(x => x.DefaultAuthStrategiesForCRUD[0].AuthStrategyName).ShouldBe(testAuthStrategiesForParents.Select(x => x.AuthorizationStrategy.AuthorizationStrategyName), true);
foreach (var testParentResourceClaim in testParentResourceClaimsForId)
{
var parentResult = results.First(x => x.Id == testParentResourceClaim.ResourceClaimId);
var testAuthStrategiesForChildren =
testAuthStrategies.Where(x =>
x.ResourceClaim.ParentResourceClaimId == testParentResourceClaim.ResourceClaimId);
parentResult.Children.Select(x => x.DefaultAuthStrategiesForCRUD[0].AuthStrategyName).ShouldBe(testAuthStrategiesForChildren.Select(x => x.AuthorizationStrategy.AuthorizationStrategyName), true);
}
});
}
public void ShouldDeleteChildResourceOnClaimSet()
{
var testApplication = new Application
{
ApplicationName = $"Test Application {DateTime.Now:O}"
};
Save(testApplication);
var testClaimSet = new ClaimSet {
ClaimSetName = "TestClaimSet", Application = testApplication
};
Save(testClaimSet);
var testResources = SetupParentResourceClaimsWithChildren(testClaimSet, testApplication);
var parentResourcesOnClaimSetOriginalCount =
testResources.Count(x => x.ResourceClaim.ParentResourceClaim == null);
var testParentResource = testResources.Select(x => x.ResourceClaim).Single(x => x.ResourceName == "TestParentResourceClaim1");
var childResourcesForParentOriginalCount = testResources.Count(x => x.ResourceClaim.ParentResourceClaimId == testParentResource.ResourceClaimId);
var testChildResourceToDelete = testResources.Select(x => x.ResourceClaim).Single(x => x.ResourceName == "TestChildResourceClaim1" && x.ParentResourceClaimId == testParentResource.ResourceClaimId);
var deleteResourceOnClaimSetModel = new DeleteClaimSetResourceModel
{
ClaimSetId = testClaimSet.ClaimSetId,
ResourceClaimId = testChildResourceToDelete.ResourceClaimId,
ClaimSetName = testClaimSet.ClaimSetName,
ResourceName = testChildResourceToDelete.ResourceName
};
var command = new DeleteResourceOnClaimSetCommand(TestContext);
command.Execute(deleteResourceOnClaimSetModel);
var resourceClaimsForClaimSet = new GetResourcesByClaimSetIdQuery(TestContext, GetMapper()).AllResources(testClaimSet.ClaimSetId).ToList();
resourceClaimsForClaimSet.Count().ShouldBe(parentResourcesOnClaimSetOriginalCount);
var resultChildResources =
TestContext.ClaimSetResourceClaims.Where(x => x.ClaimSet.ClaimSetId == testClaimSet.ClaimSetId && x.ResourceClaim.ParentResourceClaimId == testParentResource.ResourceClaimId);
resultChildResources.Count().ShouldBe(childResourcesForParentOriginalCount - 1);
var resultResourceClaim = resultChildResources.SingleOrDefault(x => x.ResourceClaim.ResourceClaimId == testChildResourceToDelete.ResourceClaimId);
resultResourceClaim.ShouldBeNull();
}
public void ShouldGetDefaultAuthorizationStrategiesForSingleResourcesByClaimSetIdAndResourceId()
{
var testApplication = new Application
{
ApplicationName = "TestApplicationName"
};
Save(testApplication);
var testClaimSet = new ClaimSet
{
ClaimSetName = "TestClaimSet",
Application = testApplication
};
Save(testClaimSet);
var appAuthorizationStrategies = SetupApplicationAuthorizationStrategies(testApplication).ToList();
var testResourceClaims = SetupParentResourceClaims(new List <ClaimSet> {
testClaimSet
}, testApplication);
var testAuthStrategies = SetupResourcesWithDefaultAuthorizationStrategies(appAuthorizationStrategies, testResourceClaims.ToList());
Transaction <SqlServerSecurityContext>(securityContext =>
{
var query = new GetResourcesByClaimSetIdQuery(securityContext, GetMapper());
var testResourceClaim =
testResourceClaims.Single(x => x.ClaimSet.ClaimSetId == testClaimSet.ClaimSetId && x.ResourceClaim.ResourceName == "TestResourceClaim3.00").ResourceClaim;
var testAuthStrategy = testAuthStrategies.Single(x =>
x.ResourceClaim.ResourceClaimId == testResourceClaim.ResourceClaimId && x.Action.ActionName == ActionName.Create.Value).AuthorizationStrategy;
var result = query.SingleResource(testClaimSet.ClaimSetId, testResourceClaim.ResourceClaimId);
result.Name.ShouldBe(testResourceClaim.ResourceName);
result.Id.ShouldBe(testResourceClaim.ResourceClaimId);
result.Create.ShouldBe(true);
result.Read.ShouldBe(false);
result.Update.ShouldBe(false);
result.Delete.ShouldBe(false);
result.DefaultAuthStrategiesForCRUD[0].AuthStrategyName.ShouldBe(testAuthStrategy.DisplayName);
});
}
public void ShouldImportClaimSet()
{
var testApplication = new Application
{
ApplicationName = $"Test Application {DateTime.Now:O}"
};
Save(testApplication);
SetupResourceClaims(testApplication);
var testJSON = @"{
""title"": ""testfile"",
""template"": {
""claimSets"": [
{
""name"": ""Test Claimset"",
""resourceClaims"": [
{
""Name"": ""TestParentResourceClaim1"",
""Read"": true,
""Create"": false,
""Update"": false,
""Delete"": false,
""Children"": []
},
{
""Name"": ""TestParentResourceClaim2"",
""Read"": true,
""Create"": false,
""Update"": false,
""Delete"": false,
""Children"": []
},
{
""Name"": ""TestParentResourceClaim3"",
""Read"": true,
""Create"": true,
""Update"": true,
""Delete"": true,
""Children"": []
}
]
}
]
}
}";
var importModel = GetImportModel(testJSON);
var getResourceByClaimSetIdQuery = new GetResourcesByClaimSetIdQuery(TestContext, GetMapper());
var addClaimSetCommand = new AddClaimSetCommand(TestContext);
var getResourceClaimsQuery = new GetResourceClaimsQuery(TestContext);
var editResourceOnClaimSetCommand = new EditResourceOnClaimSetCommand(TestContext);
var command = new ClaimSetFileImportCommand(addClaimSetCommand, editResourceOnClaimSetCommand, getResourceClaimsQuery);
command.Execute(importModel);
var testClaimSet = TestContext.ClaimSets.SingleOrDefault(x => x.ClaimSetName == "Test Claimset");
testClaimSet.ShouldNotBeNull();
var resourcesForClaimSet = getResourceByClaimSetIdQuery.AllResources(testClaimSet.ClaimSetId).ToList();
resourcesForClaimSet.Count.ShouldBeGreaterThan(0);
var testResources = resourcesForClaimSet.Where(x => x.ParentId == 0).ToArray();
testResources.Count().ShouldBe(3);
var testResource1 = testResources[0];
MatchActions(testResource1, "TestParentResourceClaim1", new bool[] { false, true, false, false });
var testResource2 = testResources[1];
MatchActions(testResource2, "TestParentResourceClaim2", new bool[] { false, true, false, false });
var testResource3 = testResources[2];
MatchActions(testResource3, "TestParentResourceClaim3", new bool[] { true, true, true, true });
}
public void ShouldExportClaimSet()
{
var testApplication = new Application
{
ApplicationName = $"Test Application {DateTime.Now:O}"
};
Save(testApplication);
var testClaimSet1 = new ClaimSet {
ClaimSetName = "TestClaimSet1", Application = testApplication
};
Save(testClaimSet1);
var testClaimSet2 = new ClaimSet {
ClaimSetName = "TestClaimSet2", Application = testApplication
};
Save(testClaimSet2);
SetupParentResourceClaimsWithChildren(testClaimSet1, testApplication);
SetupParentResourceClaimsWithChildren(testClaimSet2, testApplication);
var getClaimSetById = new GetClaimSetByIdQuery(TestContext);
var exportModel = new ClaimSetFileExportModel
{
Title = "TestDownload",
ClaimSets = new List <Management.ClaimSetEditor.ClaimSet>
{
getClaimSetById.Execute(testClaimSet1.ClaimSetId),
getClaimSetById.Execute(testClaimSet2.ClaimSetId)
},
SelectedForExport = new List <int>
{
testClaimSet1.ClaimSetId, testClaimSet2.ClaimSetId
}
};
var getResourceByClaimSetIdQuery = new GetResourcesByClaimSetIdQuery(TestContext, GetMapper());
var command = new ClaimSetFileExportCommand(TestContext, getResourceByClaimSetIdQuery);
var sharingModel = command.Execute(exportModel);
var resourcesForClaimSet1 = getResourceByClaimSetIdQuery.AllResources(testClaimSet1.ClaimSetId).ToList();
var resourcesForClaimSet2 = getResourceByClaimSetIdQuery.AllResources(testClaimSet2.ClaimSetId).ToList();
sharingModel.Title.ShouldContain("TestDownload");
var sharedClaimSets = sharingModel.Template.ClaimSets;
sharedClaimSets.Length.ShouldBe(2);
var sharedClaimSet1 = sharedClaimSets[0];
var sharedClaimSet2 = sharedClaimSets[1];
sharedClaimSet1.Name.ShouldBe(testClaimSet1.ClaimSetName);
MatchResources(sharedClaimSet1.ResourceClaims, resourcesForClaimSet1);
sharedClaimSet2.Name.ShouldBe(testClaimSet2.ClaimSetName);
MatchResources(sharedClaimSet2.ResourceClaims, resourcesForClaimSet2);
}
public void ShouldDeleteClaimSet()
{
var testApplication = new Application
{
ApplicationName = $"Test Application {DateTime.Now:O}"
};
Save(testApplication);
var testClaimSetToDelete = new ClaimSet
{
ClaimSetName = "TestClaimSet_Delete", Application = testApplication
};
Save(testClaimSetToDelete);
SetupParentResourceClaimsWithChildren(testClaimSetToDelete, testApplication);
var testClaimSetToPreserve = new ClaimSet
{
ClaimSetName = "TestClaimSet_Preserve", Application = testApplication
};
Save(testClaimSetToPreserve);
var resourceClaimsForPreservedClaimSet = SetupParentResourceClaimsWithChildren(testClaimSetToPreserve, testApplication);
var deleteModel = new Mock <IDeleteClaimSetModel>();
deleteModel.Setup(x => x.Name).Returns(testClaimSetToDelete.ClaimSetName);
deleteModel.Setup(x => x.Id).Returns(testClaimSetToDelete.ClaimSetId);
var command = new DeleteClaimSetCommand(TestContext);
command.Execute(deleteModel.Object);
TestContext.ClaimSets.SingleOrDefault(x => x.ClaimSetId == testClaimSetToDelete.ClaimSetId).ShouldBeNull();
TestContext.ClaimSetResourceClaims.Count(x => x.ClaimSet.ClaimSetId == testClaimSetToDelete.ClaimSetId)
.ShouldBe(0);
var preservedClaimSet = TestContext.ClaimSets.Single(x => x.ClaimSetId == testClaimSetToPreserve.ClaimSetId);
preservedClaimSet.ClaimSetName.ShouldBe(testClaimSetToPreserve.ClaimSetName);
Transaction <SqlServerSecurityContext>(securityContext =>
{
var query = new GetResourcesByClaimSetIdQuery(securityContext, GetMapper());
var results = query.AllResources(testClaimSetToPreserve.ClaimSetId).ToArray();
var testParentResourceClaimsForId =
resourceClaimsForPreservedClaimSet.Where(x => x.ClaimSet.ClaimSetId == testClaimSetToPreserve.ClaimSetId && x.ResourceClaim.ParentResourceClaim == null).Select(x => x.ResourceClaim).ToArray();
results.Length.ShouldBe(testParentResourceClaimsForId.Length);
results.Select(x => x.Name).ShouldBe(testParentResourceClaimsForId.Select(x => x.ResourceName), true);
results.Select(x => x.Id).ShouldBe(testParentResourceClaimsForId.Select(x => x.ResourceClaimId), true);
results.All(x => x.Create).ShouldBe(true);
foreach (var testParentResourceClaim in testParentResourceClaimsForId)
{
var testChildren = securityContext.ResourceClaims.Where(x =>
x.ParentResourceClaimId == testParentResourceClaim.ResourceClaimId).ToList();
var parentResult = results.First(x => x.Id == testParentResourceClaim.ResourceClaimId);
parentResult.Children.Select(x => x.Name).ShouldBe(testChildren.Select(x => x.ResourceName), true);
parentResult.Children.Select(x => x.Id).ShouldBe(testChildren.Select(x => x.ResourceClaimId), true);
parentResult.Children.All(x => x.Create).ShouldBe(true);
}
});
}
