private IBusinessObject CreateDerivedSecurableClassWithProperties(ISecurityContextFactory securityContextFactoryStub)
{
return((IBusinessObject)ObjectFactory.Create(
false,
typeof(DerivedSecurableClassWithProperties),
ParamList.Create(ObjectSecurityStrategy.Create(securityContextFactoryStub, InvalidationToken.Create()))));
}
private IBusinessObject CreateDerivedBindableSecurableObject(ISecurityContextFactory securityContextFactoryStub)
{
return((IBusinessObject)
DerivedBindableSecurableObject.NewObject(
_clientTransaction,
ObjectSecurityStrategy.Create(securityContextFactoryStub, InvalidationToken.Create())));
}
public override void SetUp()
{
base.SetUp();
_securityProviderStub = MockRepository.GenerateStub <ISecurityProvider>();
_principalProviderStub = MockRepository.GenerateStub <IPrincipalProvider>();
_securityPrincipalStub = MockRepository.GenerateStub <ISecurityPrincipal>();
_functionalSecurityStrategyStub = MockRepository.GenerateStub <IFunctionalSecurityStrategy>();
_principalProviderStub.Stub(stub => stub.GetPrincipal()).Return(_securityPrincipalStub);
_securityContextStub = MockRepository.GenerateStub <ISecurityContext> ();
_securityContextFactoryStub = MockRepository.GenerateStub <ISecurityContextFactory> ();
_securityContextFactoryStub.Stub(mock => mock.CreateSecurityContext()).Return(_securityContextStub);
_clientTransaction = ClientTransaction.CreateRootTransaction();
_clientTransaction.Extensions.Add(new SecurityClientTransactionExtension());
var serviceLocator = DefaultServiceLocator.Create();
serviceLocator.RegisterSingle(() => _securityProviderStub);
serviceLocator.RegisterSingle(() => _principalProviderStub);
serviceLocator.RegisterSingle(() => _functionalSecurityStrategyStub);
_serviceLocatorScope = new ServiceLocatorScope(serviceLocator);
_clientTransaction.EnterNonDiscardingScope();
}
private SecurableObject CreateSecurableObject(ISecurityContextFactory securityContextFactory, ClientTransaction clientTransaction = null, Action <SecurableObject> action = null)
{
return(SecurableObject.NewObject(
clientTransaction ?? _clientTransaction,
ObjectSecurityStrategy.Create(securityContextFactory, InvalidationToken.Create()),
action));
}
private ObjectSecurityStrategy(ISecurityContextFactory securityContextFactory, ICache <ISecurityPrincipal, AccessType[]> cache)
{
ArgumentUtility.DebugCheckNotNull("securityContextFactory", securityContextFactory);
ArgumentUtility.DebugCheckNotNull("cache", cache);
_securityContextFactory = securityContextFactory;
_cache = cache;
}
/// <summary>
/// Instantiates <see cref="ObjectSecurityStrategy"/> with a custom <paramref name="cache"/> implementation.
/// </summary>
public static IObjectSecurityStrategy CreateWithCustomCache(
[NotNull] ISecurityContextFactory securityContextFactory,
[NotNull] ICache <ISecurityPrincipal, AccessType[]> cache)
{
ArgumentUtility.CheckNotNull("securityContextFactory", securityContextFactory);
ArgumentUtility.CheckNotNull("cache", cache);
return(new ObjectSecurityStrategy(securityContextFactory, cache));
}
/// <summary>
/// Instantiates <see cref="ObjectSecurityStrategy"/> with a cache based on the <paramref name="invalidationToken"/>.
/// </summary>
public static IObjectSecurityStrategy Create(
[NotNull] ISecurityContextFactory securityContextFactory,
[NotNull] InvalidationToken invalidationToken)
{
ArgumentUtility.CheckNotNull("securityContextFactory", securityContextFactory);
ArgumentUtility.CheckNotNull("invalidationToken", invalidationToken);
return(new ObjectSecurityStrategy(securityContextFactory, CacheFactory.Create <ISecurityPrincipal, AccessType[]> (invalidationToken)));
}
public WithPermissionsImpl(ISecurityContextFactory securityContextFactory, string[] permissions)
{
_securityContextFactory = securityContextFactory.ThrowIfNull(nameof(securityContextFactory));
_permissions = permissions.ThrowIfNull(nameof(permissions));
if (!_permissions.Any())
{
throw new ArgumentException(nameof(permissions));
}
}
public CachedSecurityRepository(ISecurityContextFactory securityContextFactory, int cacheTimeoutInMinutes)
: base(securityContextFactory)
{
if (cacheTimeoutInMinutes <= 0)
{
throw new ArgumentException("Cache Timeout in minutes must be a positive number.", nameof(cacheTimeoutInMinutes));
}
_cacheTimeoutInMinutes = cacheTimeoutInMinutes;
// Current implementation of the base expects to initialize the data immediately, so reflect that with a cache update
_lastCacheUpdate = SystemClock.Now();
}
public void SetUp()
{
_securityProviderMock = MockRepository.GenerateStrictMock <ISecurityProvider>();
_securityContextFactoryStub = MockRepository.GenerateStub <ISecurityContextFactory>();
_principalStub = MockRepository.GenerateStub <ISecurityPrincipal>();
_principalStub.Stub(_ => _.User).Return("user");
_context = SecurityContext.Create(typeof(SecurableObject), "owner", "group", "tenant", new Dictionary <string, Enum>(), new Enum[0]);
_securityContextFactoryStub.Stub(_ => _.CreateSecurityContext()).Return(_context);
_invalidationToken = InvalidationToken.Create();
_strategy = ObjectSecurityStrategy.Create(_securityContextFactoryStub, _invalidationToken);
}
public SecurityRepository(ISecurityContextFactory securityContextFactory)
{
_securityContextFactory = Preconditions.ThrowIfNull(securityContextFactory, nameof(securityContextFactory));
Initialize(
GetApplication,
GetActions,
GetClaimSets,
GetResourceClaims,
GetAuthorizationStrategies,
GetClaimSetResourceClaimActions,
GetResourceClaimActionAuthorizations);
}
public void GetSecurityRepository_ForInstanceSecurityRepositoryCacheObject_Does_Not_Finds_Cache_Object_And_Calls_SecurityContextFactory()
{
ISecurityContextFactory securityContextFactory = A.Fake <ISecurityContextFactory>();
A.CallTo(() => securityContextFactory.CreateContext()).Returns(SecurityContextMock.GetMockedSecurityContext()).Once();
var cache = MockInstanceSecurityRepositoryCallsAndInitializeCache(securityContextFactory);
var repositoryCacheObject = cache.GetSecurityRepository("Instance2");
int ApplicationId = 1;
Assert.AreEqual(repositoryCacheObject.Application.ApplicationId, ApplicationId);
}
public void GetSecurityRepository_ForInstanceSecurityRepositoryCacheObject_Finds_Cache_Object_And_Does_Not_Need_To_Call_SecurityContextFactory()
{
// Fake securityContextFactory
ISecurityContextFactory securityContextFactory = A.Fake <ISecurityContextFactory>();
var cache = MockInstanceSecurityRepositoryCallsAndInitializeCache(securityContextFactory);
var repositoryCacheObject = cache.GetSecurityRepository(TestInstanceId);
int ApplicationId = 20;
Assert.AreEqual(repositoryCacheObject.Application.ApplicationId, ApplicationId);
// Asserting that the call to securityContextFactory.CreateContext() was not used due to cache object being present
A.CallTo(() => securityContextFactory.CreateContext()).MustNotHaveHappened();
}
private IInstanceSecurityRepositoryCache MockInstanceSecurityRepositoryCallsAndInitializeCache(ISecurityContextFactory securityContextFactory)
{
InstanceSecurityRepositoryCacheObject values = new InstanceSecurityRepositoryCacheObject
(
new Application {
ApplicationId = 20, ApplicationName = "Ed-Fi ODS API"
},
null,
null,
null,
null,
null,
null
);
var memoryCacheOption = A.Fake <IOptions <MemoryCacheOptions> >();
MemoryCache memoryCache = new MemoryCache(memoryCacheOption);
CacheProvider = new MemoryCacheProvider(memoryCache);
CacheProvider.SetCachedObject(TestInstanceId, values);
CacheProvider.SetCachedObject(GetLastSynchedKey(TestInstanceId), SystemClock.Now());
CacheProvider.SetCachedObject(GetCurrentCacheInitializedKey(TestInstanceId), true);
InstanceSecurityRepositoryCache = new InstanceSecurityRepositoryCache(securityContextFactory, CacheProvider);
return(InstanceSecurityRepositoryCache);
}
protected ScopeOfResponsibilityServiceOfT(ISecurityContextFactory contextFactory, IIdentityService identityService, ILogger log)
{
_contextFactory = contextFactory;
_identityService = identityService;
_log = log;
}
protected void ArrangeBase()
{
_securityContextFactory = A.Fake <ISecurityContextFactory>();
A.CallTo(() => _securityContextFactory.CreateContext()).Returns(SecurityContextMock.GetMockedSecurityContext());
}
public DefaultCallContextProvider(ISecurityContextFactory securityContextFactory)
{
_securityContextFactory = securityContextFactory.ThrowIfNull(nameof(securityContextFactory));
}
public InstanceSecurityRepositoryCache(ISecurityContextFactory securityContextFactory, ICacheProvider cacheProvider)
{
_securityContextFactory = Preconditions.ThrowIfNull(securityContextFactory, nameof(securityContextFactory));
_cacheProvider = Preconditions.ThrowIfNull(cacheProvider, nameof(cacheProvider));
}
public SecurityRepository(ISecurityContextFactory securityContextFactory)
{
_securityContextFactory = Preconditions.ThrowIfNull(securityContextFactory, nameof(securityContextFactory));
LoadSecurityConfigurationFromDatabase();
}
private ObjectSecurityStrategy(ISecurityContextFactory securityContextFactory)
{
throw new NotImplementedException(
"Use new ObjectSecurityStrategy (securityContextFactory, NullAccessTypeFilter.Null, new CacheInvalidationToken()) instead. (Version 1.15.20.0)");
}
