ISecurityContext ISecurityContextFactory.CreateSecurityContext() { using (SecurityFreeSection.Activate()) { return(SecurityContext.Create(GetPublicDomainObjectType(), GetOwner(), GetOwningGroup(), GetOwningTenant(), GetStates(), GetAbstractRoles())); } }
public void SetUp() { _context = SecurityContext.Create(typeof(SecurableObject), "owner", "group", "tenant", new Dictionary <string, Enum>(), new Enum[0]); _invalidationToken = InvalidationToken.Create(); _strategy = ObjectSecurityStrategy.Create(new SerializableSecurityContextFactory(_context), _invalidationToken); }
public void Equals_WithStatefulAndStateless() { SecurityContext left = SecurityContext.CreateStateless(typeof(File)); SecurityContext right = SecurityContext.Create(typeof(File), null, null, null, new Dictionary <string, Enum>(), new Enum[0]); Assert.That(left.Equals(right), Is.False); Assert.That(right.Equals(left), Is.False); }
private SecurityContext CreateContextForSpecialOrder(OrderState orderState, PaymentState paymentState) { var states = new Dictionary <string, Enum>(); states.Add("State", orderState); states.Add("Payment", paymentState); return(SecurityContext.Create(typeof(SpecialOrder), "owner", "ownerGroup", "ownerTenant", states, new Enum[0])); }
public void Equals_WithDifferentClasses() { SecurityContext left = SecurityContext.Create(typeof(File), "owner", "ownerGroup", "ownerTenant", CreateTwoStates(), CreateTwoAbstractRoles()); SecurityContext right = SecurityContext.Create( typeof(PaperFile), "owner", "ownerGroup", "ownerTenant", CreateTwoStates(), CreateTwoAbstractRoles()); Assert.That(left.Equals(right), Is.False); Assert.That(right.Equals(left), Is.False); }
private SecurityContext CreateContextForCustomer() { return(SecurityContext.Create( typeof(Customer), "owner", "ownerGroup", "ownerTenant", new Dictionary <string, Enum>(), new Enum[0])); }
public void Equals_WithDifferentAbstractRoles() { SecurityContext left = SecurityContext.Create(typeof(File), "owner", "ownerGroup", "ownerTenant", CreateTwoStates(), CreateTwoAbstractRoles()); Enum[] rightAbstractRoles = new Enum[] { TestAbstractRoles.QualityEngineer, TestAbstractRoles.Manager }; SecurityContext right = SecurityContext.Create(typeof(File), "owner", "ownerGroup", "ownerTenant", CreateTwoStates(), rightAbstractRoles); Assert.That(left.Equals(right), Is.False); Assert.That(right.Equals(left), Is.False); }
private async ValueTask <IStateMachineController> StartStateMachineWrapper(SessionId sessionId, StateMachineOrigin origin, DataModelValue parameters) { var finalizer = new DeferredFinalizer(); var securityContext = SecurityContext.Create(SecurityContextType.NewTrustedStateMachine, finalizer); await using (finalizer.ConfigureAwait(false)) { return(await StartStateMachine(sessionId, origin, parameters, securityContext, finalizer).ConfigureAwait(false)); } }
public void Equals_WithDifferentStatePropertyLength() { SecurityContext left = SecurityContext.Create(typeof(File), "owner", "ownerGroup", "ownerTenant", CreateTwoStates(), CreateTwoAbstractRoles()); Dictionary <string, Enum> rightStates = new Dictionary <string, Enum>(); rightStates.Add("Confidentiality", TestSecurityState.Public); SecurityContext right = SecurityContext.Create(typeof(File), "owner", "ownerGroup", "ownerTenant", rightStates, CreateTwoAbstractRoles()); Assert.That(left.Equals(right), Is.False); Assert.That(right.Equals(left), Is.False); }
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); }
ISecurityContext ISecurityContextFactory.CreateSecurityContext() { if (_securityContext == null) { _securityContext = SecurityContext.Create( ((ISecurableObject)this).GetSecurableType(), null, null, null, new Dictionary <string, EnumWrapper>(), new EnumWrapper[0]); } return(_securityContext); }
public void Find_WithUnknownStatePropertyInContext_ReturnsNull() { StubClassDefinition <Customer>(); var states = new Dictionary <string, Enum>(); states.Add("Unknown", Delivery.Post); var context = SecurityContext.Create(typeof(Customer), "owner", "ownerGroup", "ownerTenant", states, new Enum[0]); var aclFinder = CreateAccessControlListFinder(); var foundAcl = aclFinder.Find(context); Assert.That(foundAcl, Is.Null); }
public void Serialization() { Dictionary <string, Enum> myStates = new Dictionary <string, Enum>(); myStates.Add("State", TestSecurityState.Public); myStates.Add("Confidentiality", TestSecurityState.Public); Enum[] myRoles = new Enum[] { TestAbstractRoles.Developer, TestAbstractRoles.QualityEngineer }; SecurityContext context = SecurityContext.Create(typeof(SecurableObject), "myOwner", "myGroup", "myTenant", myStates, myRoles); SecurityContext deserializedContext = Serializer.SerializeAndDeserialize(context); Assert.That(deserializedContext, Is.Not.SameAs(context)); Assert.That(deserializedContext, Is.EqualTo(context)); }
ISecurityContext ISecurityContextFactory.CreateSecurityContext() { if (_securityContext == null) { _securityContext = SecurityContext.Create( GetPublicDomainObjectType(), null, null, ClassForRelationTestMandatory.Name.Substring(0, ClassForRelationTestMandatory.Name.Length - 1), new Dictionary <string, EnumWrapper>(), new EnumWrapper[0]); } return(_securityContext); }
protected void EvaluateSecurity_Click(object sender, EventArgs e) { ISecurityProvider provider = SafeServiceLocator.Current.GetInstance <ISecurityProvider>(); SecurityContext context = SecurityContext.Create( typeof(File), "1A", "{00000004-1000-0000-0000-000000000007}", string.Empty, new Dictionary <string, Enum>(), new Enum[] { DomainAbstractRoles.Creator }); ISecurityPrincipal user = new SecurityPrincipal("1A", null, null, null); AccessType[] accessTypes = provider.GetAccess(context, user); }
private void SetupResultSecurityProviderGetAccessForPosition(Delegation delegation, ISecurityPrincipal principal, params Enum[] returnedAccessTypeEnums) { Type classType = typeof(Position); string owner = string.Empty; string owningGroup = string.Empty; string owningTenant = string.Empty; Dictionary <string, Enum> states = new Dictionary <string, Enum>(); states.Add("Delegation", delegation); List <Enum> abstractRoles = new List <Enum>(); SecurityContext securityContext = SecurityContext.Create(classType, owner, owningGroup, owningTenant, states, abstractRoles); AccessType[] returnedAccessTypes = Array.ConvertAll(returnedAccessTypeEnums, AccessType.Get); SetupResult.For(_mockSecurityProvider.GetAccess(securityContext, principal)).Return(returnedAccessTypes); }
public void TestGetHashCode() { Dictionary <string, Enum> leftStates = new Dictionary <string, Enum>(); leftStates.Add("State", TestSecurityState.Public); leftStates.Add("Confidentiality", TestSecurityState.Public); Enum[] leftAbstractRoles = new Enum[] { TestAbstractRoles.Developer, TestAbstractRoles.QualityEngineer }; SecurityContext left = SecurityContext.Create(typeof(File), "owner", "ownerGroup", "ownerTenant", leftStates, leftAbstractRoles); Dictionary <string, Enum> rightStates = new Dictionary <string, Enum>(); rightStates.Add("Confidentiality", TestSecurityState.Public); rightStates.Add("State", TestSecurityState.Public); Enum[] rightAbstractRoles = new Enum[] { TestAbstractRoles.QualityEngineer, TestAbstractRoles.Developer }; SecurityContext right = SecurityContext.Create(typeof(File), "owner", "ownerGroup", "ownerTenant", rightStates, rightAbstractRoles); Assert.That(right.GetHashCode(), Is.EqualTo(left.GetHashCode())); }
public void Find_WithInvalidStateValueInContext_ThrowsAccessControlException() { var acl = CreateStatefulAcl(OrderState_Delivered, PaymentState_None); StubClassDefinition <Order> (acl); var states = new Dictionary <string, Enum>(); states.Add("State", Delivery.Post); states.Add("Payment", PaymentState.None); var context = SecurityContext.Create(typeof(Order), "owner", "ownerGroup", "ownerTenant", states, new Enum[0]); var aclFinder = CreateAccessControlListFinder(); Assert.That( () => aclFinder.Find(context), Throws.TypeOf <AccessControlException>() .And.Message.EqualTo( "The state 'Post|Remotion.SecurityManager.UnitTests.TestDomain.Delivery, Remotion.SecurityManager.UnitTests' is not defined " + "for the property 'State' of the securable class 'Remotion.SecurityManager.UnitTests.TestDomain.Order, Remotion.SecurityManager.UnitTests' " + "or its base classes.")); }
public void CreateSecurityContextFromEnumWrappers() { var abstractRoles = new[] { EnumWrapper.Get(TestAbstractRoles.QualityEngineer), EnumWrapper.Get(SimpleEnum.Second), EnumWrapper.Get("Role") }; var states = new Dictionary <string, EnumWrapper>(); states.Add("property1", EnumWrapper.Get(TestSecurityState.Confidential)); states.Add("property2", EnumWrapper.Get(SimpleEnum.First)); states.Add("property3", EnumWrapper.Get("State")); SecurityContext context = SecurityContext.Create(typeof(ISecurableObject), "owner", "group", "tenant", states, abstractRoles); Assert.That(context.Owner, Is.EqualTo("owner")); Assert.That(context.OwnerGroup, Is.EqualTo("group")); Assert.That(context.OwnerTenant, Is.EqualTo("tenant")); Assert.That(context.AbstractRoles, Is.Not.SameAs(abstractRoles)); Assert.That(context.AbstractRoles, Is.EquivalentTo(abstractRoles)); Assert.That(context.GetNumberOfStates(), Is.EqualTo(3)); Assert.That(context.GetState("property1"), Is.EqualTo(states["property1"])); Assert.That(context.GetState("property2"), Is.EqualTo(states["property2"])); Assert.That(context.GetState("property3"), Is.EqualTo(states["property3"])); }
public ISecurityContext CreateSecurityContext() { return(SecurityContext.Create(GetPublicDomainObjectType(), GetOwnerName(), GetOwnerGroupName(), GetOwnerTenantName(), GetStates(), GetAbstractRoles())); }
private SecurityContext CreateContextWithNotExistingOwningUser() { return(SecurityContext.Create( typeof(Order), "notExistingUser", "UID: testOwningGroup", "UID: testTenant", new Dictionary <string, Enum>(), new Enum[0])); }
private SecurityContext CreateContextWithoutOwningGroup() { return(SecurityContext.Create(typeof(Order), "group0/user1", null, "UID: testTenant", new Dictionary <string, Enum>(), new Enum[0])); }
private SecurityContext CreateContext(params Enum[] abstractRoles) { return(SecurityContext.Create( typeof(Order), "group0/user1", "UID: testOwningGroup", "UID: testTenant", new Dictionary <string, Enum>(), abstractRoles)); }
public async Task DtdReaderTest() { var uri = new Uri("res://Xtate.Core.Test/Xtate.Core.Test/Scxml/XInclude/DtdSingleIncludeSource.scxml"); var securityContext = SecurityContext.Create(SecurityContextType.NewStateMachine, new DeferredFinalizer()); var factoryContext = new FactoryContext(ImmutableArray.Create(ResxResourceLoaderFactory.Instance), securityContext, logger: default, loggerContext: default);
private SecurityContext CreateTestSecurityContext(Type type, IDictionary <string, Enum> states, ICollection <Enum> abstractRoles) { return(SecurityContext.Create(type, "owner", "group", "tenant", states, abstractRoles)); }