public void Scope_NestedForDifferentTransactionsInTheHierarchy()
{
var middleTransaction = _rootTransaction.CreateSubTransaction();
var subTransaction = middleTransaction.CreateSubTransaction();
Assert.That(_rootTransaction.ActiveTransaction, Is.SameAs(_rootTransaction));
Assert.That(_order1LoadedInRootTransaction.DefaultTransactionContext.ClientTransaction, Is.SameAs(_rootTransaction));
using (middleTransaction.EnterNonDiscardingScope())
{
Assert.That(_rootTransaction.ActiveTransaction, Is.SameAs(middleTransaction));
Assert.That(_order1LoadedInRootTransaction.DefaultTransactionContext.ClientTransaction, Is.SameAs(middleTransaction));
using (subTransaction.EnterNonDiscardingScope())
{
Assert.That(_rootTransaction.ActiveTransaction, Is.SameAs(subTransaction));
Assert.That(_order1LoadedInRootTransaction.DefaultTransactionContext.ClientTransaction, Is.SameAs(subTransaction));
using (_rootTransaction.EnterNonDiscardingScope())
{
Assert.That(_rootTransaction.ActiveTransaction, Is.SameAs(_rootTransaction));
Assert.That(_order1LoadedInRootTransaction.DefaultTransactionContext.ClientTransaction, Is.SameAs(_rootTransaction));
}
Assert.That(_rootTransaction.ActiveTransaction, Is.SameAs(subTransaction));
Assert.That(_order1LoadedInRootTransaction.DefaultTransactionContext.ClientTransaction, Is.SameAs(subTransaction));
}
Assert.That(_rootTransaction.ActiveTransaction, Is.SameAs(middleTransaction));
Assert.That(_order1LoadedInRootTransaction.DefaultTransactionContext.ClientTransaction, Is.SameAs(middleTransaction));
}
Assert.That(_rootTransaction.ActiveTransaction, Is.SameAs(_rootTransaction));
Assert.That(_order1LoadedInRootTransaction.DefaultTransactionContext.ClientTransaction, Is.SameAs(_rootTransaction));
}
public void GetObject_NoClientTransactionGiven_UsesCurrentTransaction()
{
using (_clientTransaction.EnterNonDiscardingScope())
{
var result = _orderID1.GetObject <Order>();
CheckDomainObject(result, _clientTransaction);
}
}
/// <summary>
/// Loads a new instance of a domain object for transportation.
/// </summary>
/// <param name="type">The domain object type to instantiate.</param>
/// <param name="constructorParameters">A <see cref="ParamList"/> encapsulating the parameters to be passed to the constructor. Instantiate this
/// by using one of the <see cref="ParamList.Create{A1,A2}"/> methods.</param>
/// <returns>A new instance of <paramref name="type"/> prepared for transport.</returns>
public DomainObject LoadNew(Type type, ParamList constructorParameters)
{
using (_transportTransaction.EnterNonDiscardingScope())
{
DomainObject domainObject = LifetimeService.NewObject(ClientTransaction.Current, type, constructorParameters);
Load(domainObject.ID);
return(domainObject);
}
}
public AbstractRoleDefinition CreateClerkAbstractRole(int index)
{
using (_transaction.EnterNonDiscardingScope())
{
AbstractRoleDefinition role = AbstractRoleDefinition.NewObject(
new Guid("00000003-0001-0000-0000-000000000000"),
"Clerk|Remotion.Security.UnitTests.TestDomain.DomainAbstractRoles, Remotion.Security.UnitTests.TestDomain",
0);
role.Index = index;
return(role);
}
}
private IDisposable EnterScopeOnDemand(ClientTransaction clientTransaction)
{
if (clientTransaction.ActiveTransaction != clientTransaction)
{
return(clientTransaction.EnterNonDiscardingScope());
}
if (ClientTransaction.Current != clientTransaction)
{
return(clientTransaction.EnterNonDiscardingScope());
}
return(null);
}
public void ExecuteInScope_Action_ReusesScopeIfPossible()
{
using (var scope = _transaction.EnterNonDiscardingScope())
{
Assert.That(ClientTransactionScope.ActiveScope, Is.SameAs(scope));
ClientTransactionScope scopeInDelegate = null;
Action action = () => scopeInDelegate = ClientTransactionScope.ActiveScope;
_transaction.ExecuteInScope(action);
Assert.That(scopeInDelegate, Is.SameAs(scope));
Assert.That(ClientTransactionScope.ActiveScope, Is.SameAs(scope));
}
}
public User CreateUser(string userName, string firstName, string lastName, string title, Group owningGroup, Tenant tenant)
{
using (_transaction.EnterNonDiscardingScope())
{
User user = _factory.CreateUser();
user.UserName = userName;
user.FirstName = firstName;
user.LastName = lastName;
user.Title = title;
user.Tenant = tenant;
user.OwningGroup = owningGroup;
return(user);
}
}
public static BindableSecurableObject NewObject(ClientTransaction clientTransaction, IObjectSecurityStrategy securityStrategy)
{
using (clientTransaction.EnterNonDiscardingScope())
{
return(NewObject <BindableSecurableObject> (ParamList.Create(securityStrategy)));
}
}
public static NonSecurableObject NewObject(ClientTransaction clientTransaction)
{
using (clientTransaction.EnterNonDiscardingScope())
{
return(NewObject <NonSecurableObject>());
}
}
public SecurableClassDefinition CreateAndCommitSecurableClassDefinitionWithAccessControlLists(int accessControlLists, ClientTransaction transaction)
{
CreateEmptyDomain();
using (transaction.EnterNonDiscardingScope())
{
SecurableClassDefinition classDefinition = CreateOrderSecurableClassDefinition();
StatelessAccessControlList statelessAccessControlList = StatelessAccessControlList.NewObject();
classDefinition.StatelessAccessControlList = statelessAccessControlList;
var stateProperty = StatePropertyDefinition.NewObject(Guid.NewGuid(), "Property");
classDefinition.AddStateProperty(stateProperty);
for (int i = 1; i < accessControlLists; i++)
{
StatefulAccessControlList statefulAccessControlList = StatefulAccessControlList.NewObject();
classDefinition.StatefulAccessControlLists.Add(statefulAccessControlList);
statefulAccessControlList.CreateAccessControlEntry();
CreateStateCombination(statefulAccessControlList, stateProperty, StateDefinition.NewObject(string.Format("Value {0}", i), i));
}
ClientTransactionScope.CurrentTransaction.Commit();
return(classDefinition);
}
}
public static FileItem NewObject(ClientTransaction clientTransaction)
{
using (clientTransaction.EnterNonDiscardingScope())
{
return(DomainObject.NewObject <FileItem> ());
}
}
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();
}
public void NestedScopes()
{
ClientTransaction clientTransaction1 = ClientTransaction.CreateRootTransaction();
ClientTransaction clientTransaction2 = ClientTransaction.CreateRootTransaction();
ClientTransactionScope originalScope = ClientTransactionScope.ActiveScope;
ClientTransaction original = ClientTransactionScope.CurrentTransaction;
Assert.That(original, Is.Not.SameAs(clientTransaction1));
Assert.That(original, Is.Not.SameAs(clientTransaction2));
Assert.That(original, Is.Not.Null);
using (ClientTransactionScope scope1 = clientTransaction1.EnterNonDiscardingScope())
{
Assert.That(ClientTransactionScope.CurrentTransaction, Is.SameAs(clientTransaction1));
Assert.That(ClientTransactionScope.ActiveScope, Is.SameAs(scope1));
using (ClientTransactionScope scope2 = clientTransaction2.EnterNonDiscardingScope())
{
Assert.That(ClientTransactionScope.ActiveScope, Is.SameAs(scope2));
Assert.That(ClientTransactionScope.CurrentTransaction, Is.SameAs(clientTransaction2));
}
Assert.That(ClientTransactionScope.ActiveScope, Is.SameAs(scope1));
Assert.That(ClientTransactionScope.CurrentTransaction, Is.SameAs(clientTransaction1));
}
Assert.That(ClientTransactionScope.ActiveScope, Is.SameAs(originalScope));
Assert.That(ClientTransactionScope.CurrentTransaction, Is.SameAs(original));
}
public void CommitAndRollbackOnScope()
{
ClientTransaction transaction = ClientTransaction.CreateRootTransaction();
var eventCounter = new TransactionEventCounter(transaction);
using (ClientTransactionScope scope = transaction.EnterNonDiscardingScope())
{
Assert.That(eventCounter.Commits, Is.EqualTo(0));
Assert.That(eventCounter.Rollbacks, Is.EqualTo(0));
scope.Commit();
Assert.That(eventCounter.Commits, Is.EqualTo(1));
Assert.That(eventCounter.Rollbacks, Is.EqualTo(0));
scope.Rollback();
Assert.That(eventCounter.Commits, Is.EqualTo(1));
Assert.That(eventCounter.Rollbacks, Is.EqualTo(1));
transaction.Commit();
Assert.That(eventCounter.Commits, Is.EqualTo(2));
Assert.That(eventCounter.Rollbacks, Is.EqualTo(1));
transaction.Rollback();
Assert.That(eventCounter.Commits, Is.EqualTo(2));
Assert.That(eventCounter.Rollbacks, Is.EqualTo(2));
}
}
public DomainObject CreateObjectReference(IObjectInitializationContext objectInitializationContext, ClientTransaction clientTransaction)
{
ArgumentUtility.CheckNotNull("objectInitializationContext", objectInitializationContext);
ArgumentUtility.CheckNotNull("clientTransaction", clientTransaction);
var objectID = objectInitializationContext.ObjectID;
CheckDomainTypeAndClassDefinition(objectID.ClassDefinition.ClassType);
objectID.ClassDefinition.ValidateCurrentMixinConfiguration();
var concreteType = Pipeline.ReflectionService.GetAssembledType(objectID.ClassDefinition.ClassType);
var instance = (DomainObject)FormatterServices.GetSafeUninitializedObject(concreteType);
Pipeline.ReflectionService.PrepareExternalUninitializedObject(instance, InitializationSemantics.Construction);
// These calls are normally performed by DomainObject's ctor
instance.Initialize(objectID, objectInitializationContext.RootTransaction);
objectInitializationContext.RegisterObject(instance);
using (clientTransaction.EnterNonDiscardingScope())
{
instance.RaiseReferenceInitializatingEvent();
}
return(instance);
}
public void Import(XmlDocument metadataXmlDocument)
{
using (_transaction.EnterNonDiscardingScope())
{
SecurityMetadataSchema metadataSchema = new SecurityMetadataSchema();
if (!metadataXmlDocument.Schemas.Contains(metadataSchema.SchemaUri))
{
metadataXmlDocument.Schemas.Add(metadataSchema.LoadSchemaSet());
}
metadataXmlDocument.Validate(null);
XmlNamespaceManager namespaceManager = new XmlNamespaceManager(metadataXmlDocument.NameTable);
namespaceManager.AddNamespace("md", metadataSchema.SchemaUri);
AddItem(_classes, metadataXmlDocument, "/md:securityMetadata/md:classes/md:class", namespaceManager, CreateSecurableClassDefinition);
AddItem(
_stateProperties,
metadataXmlDocument,
"/md:securityMetadata/md:stateProperties/md:stateProperty",
namespaceManager,
CreateStatePropertyDefinition);
AddItem(
_abstractRoles,
metadataXmlDocument,
"/md:securityMetadata/md:abstractRoles/md:abstractRole",
namespaceManager,
CreateAbstractRoleDefinition);
AddItem(_accessTypes, metadataXmlDocument, "/md:securityMetadata/md:accessTypes/md:accessType", namespaceManager, CreateAccessTypeDefinition);
LinkDerivedClasses();
LinkStatePropertiesToClasses();
LinkAccessTypesToClasses();
}
}
public StateCombination CreateStateCombination(SecurableClassDefinition classDefinition, ClientTransaction transaction, params StateDefinition[] states)
{
using (transaction.EnterNonDiscardingScope())
{
StatefulAccessControlList acl = CreateStatefulAcl(classDefinition, transaction, states);
return(acl.StateCombinations[0]);
}
}
public void DiscardRendersSubTransactionUnusable()
{
_subTransaction.Discard();
using (_subTransaction.EnterNonDiscardingScope())
{
Order.NewObject();
}
}
public void Import_EmptyCultureFile()
{
string cultureXml =
@"
<localizedNames xmlns=""http://www.re-motion.org/Security/Metadata/Localization/1.0"" culture=""de"" />
";
_importer.Import(GetXmlDocument(cultureXml));
using (_transaction.EnterNonDiscardingScope())
{
Assert.AreEqual(0, _importer.LocalizedNames.Count, "LocalizedNames count");
Assert.IsNotNull(_importer.Cultures, "Cultures");
Assert.That(_importer.Cultures.Count, Is.EqualTo(1));
Assert.That(_importer.Cultures[0].CultureName, Is.EqualTo("de"));
}
}
public StatelessAccessControlList CreateStatelessAcl(SecurableClassDefinition classDefinition, ClientTransaction transaction)
{
using (transaction.EnterNonDiscardingScope())
{
var acl = StatelessAccessControlList.NewObject();
classDefinition.StatelessAccessControlList = acl;
return(acl);
}
}
public void GetAccess_WithAccessControlExcptionFromAccessControlListFinder()
{
AccessControlException expectedException = new AccessControlException();
using (_clientTransaction.EnterNonDiscardingScope())
{
Expect.Call(_mockAclFinder.Find(_context)).Throw(expectedException);
}
_mocks.ReplayAll();
AccessType[] accessTypes = _service.GetAccess(_context, _principalStub);
_mocks.VerifyAll();
Assert.That(accessTypes.Length, Is.EqualTo(0));
LoggingEvent[] events = _memoryAppender.GetEvents();
Assert.That(events.Length, Is.EqualTo(1));
Assert.That(events[0].ExceptionObject, Is.SameAs(expectedException));
Assert.That(events[0].Level, Is.EqualTo(Level.Error));
}
private SecurableClassDefinition CreateSecurableClassDefinition(ClientTransaction transaction, Guid metadataItemID, string name)
{
using (transaction.EnterNonDiscardingScope())
{
SecurableClassDefinition classDefinition = SecurableClassDefinition.NewObject();
classDefinition.MetadataItemID = metadataItemID;
classDefinition.Name = name;
return(classDefinition);
}
}
public void ScopeSetsAndResetsCurrentTransaction()
{
ClientTransaction clientTransaction = ClientTransaction.CreateRootTransaction();
Assert.That(ClientTransactionScope.CurrentTransaction, Is.Not.SameAs(clientTransaction));
using (clientTransaction.EnterNonDiscardingScope())
{
Assert.That(ClientTransactionScope.CurrentTransaction, Is.SameAs(clientTransaction));
}
Assert.That(ClientTransactionScope.CurrentTransaction, Is.Not.SameAs(clientTransaction));
}
public Tenant CreateTenant(ClientTransaction transaction, string name, string uniqueIdentifier)
{
using (transaction.EnterNonDiscardingScope())
{
Tenant tenant = _factory.CreateTenant();
tenant.UniqueIdentifier = uniqueIdentifier;
tenant.Name = name;
return(tenant);
}
}
public SecurableClassDefinition CreateAndCommitSecurableClassDefinitionWithAccessTypes(int accessTypes, ClientTransaction transaction)
{
CreateEmptyDomain();
using (transaction.EnterNonDiscardingScope())
{
SecurableClassDefinition classDefinition = CreateSecurableClassDefinitionWithAccessTypes(accessTypes);
ClientTransactionScope.CurrentTransaction.Commit();
return(classDefinition);
}
}
private ClientTransactionScope EnterScopeOnDemand()
{
//if (_clientTransaction.ActiveTransaction != _clientTransaction)
// return _clientTransaction.EnterNonDiscardingScope();
if (ClientTransaction.Current != _clientTransaction)
{
return(_clientTransaction.EnterNonDiscardingScope());
}
return(null);
}
public SecurableClassDefinition[] CreateAndCommitSecurableClassDefinitions(int classDefinitionCount, ClientTransaction transaction)
{
CreateEmptyDomain();
using (transaction.EnterNonDiscardingScope())
{
SecurableClassDefinition[] classDefinitions = CreateSecurableClassDefinitions(classDefinitionCount, 0);
ClientTransactionScope.CurrentTransaction.Commit();
return(classDefinitions);
}
}
public void EnterNonDiscardingScope()
{
ClientTransactionScope outerScope = ClientTransactionScope.ActiveScope;
ClientTransaction newTransaction = ClientTransaction.CreateRootTransaction();
using (newTransaction.EnterNonDiscardingScope())
{
Assert.That(ClientTransactionScope.ActiveScope, Is.Not.SameAs(outerScope));
Assert.That(ClientTransactionScope.CurrentTransaction, Is.SameAs(newTransaction));
Assert.That(ClientTransactionScope.ActiveScope.AutoRollbackBehavior, Is.EqualTo(AutoRollbackBehavior.None));
}
}
public void CreateAndCommitAdministratorAbstractRole(ClientTransaction transaction)
{
CreateEmptyDomain();
using (transaction.EnterNonDiscardingScope())
{
Guid metadataItemID = new Guid("00000004-0001-0000-0000-000000000000");
string abstractRoleName = "Administrator|Remotion.Security.UnitTests.TestDomain.SpecialAbstractRoles, Remotion.Security.UnitTests.TestDomain";
AbstractRoleDefinition administratorAbstractRole = AbstractRoleDefinition.NewObject(metadataItemID, abstractRoleName, 0);
ClientTransactionScope.CurrentTransaction.Commit();
}
}
public Group CreateGroup(ClientTransaction transaction, string name, string uniqueIdentifier, Group parent, Tenant tenant)
{
using (transaction.EnterNonDiscardingScope())
{
Group group = _factory.CreateGroup();
group.Name = name;
group.Parent = parent;
group.Tenant = tenant;
group.UniqueIdentifier = uniqueIdentifier;
return(group);
}
}
