Ejemplo n.º 1
0
 internal TransactionRecordState(NeoStores neoStores, IntegrityValidator integrityValidator, RecordChangeSet recordChangeSet, long lastCommittedTxWhenTransactionStarted, ResourceLocker locks, RelationshipCreator relationshipCreator, RelationshipDeleter relationshipDeleter, PropertyCreator propertyCreator, PropertyDeleter propertyDeleter)
 {
     this._neoStores              = neoStores;
     this._nodeStore              = neoStores.NodeStore;
     this._relationshipStore      = neoStores.RelationshipStore;
     this._propertyStore          = neoStores.PropertyStore;
     this._relationshipGroupStore = neoStores.RelationshipGroupStore;
     this._metaDataStore          = neoStores.MetaDataStore;
     this._schemaStore            = neoStores.SchemaStore;
     this._integrityValidator     = integrityValidator;
     this._recordChangeSet        = recordChangeSet;
     this._lastCommittedTxWhenTransactionStarted = lastCommittedTxWhenTransactionStarted;
     this._locks = locks;
     this._relationshipCreator = relationshipCreator;
     this._relationshipDeleter = relationshipDeleter;
     this._propertyCreator     = propertyCreator;
     this._propertyDeleter     = propertyDeleter;
 }
Ejemplo n.º 2
0
        private TransactionRecordState InjectAllPossibleCommands()
        {
            RecordChangeSet recordChangeSet = mock(typeof(RecordChangeSet));

            RecordChanges <LabelTokenRecord, Void>            labelTokenChanges            = mock(typeof(RecordChanges));
            RecordChanges <RelationshipTypeTokenRecord, Void> relationshipTypeTokenChanges = mock(typeof(RecordChanges));
            RecordChanges <PropertyKeyTokenRecord, Void>      propertyKeyTokenChanges      = mock(typeof(RecordChanges));
            RecordChanges <NodeRecord, Void>                nodeRecordChanges         = mock(typeof(RecordChanges));
            RecordChanges <RelationshipRecord, Void>        relationshipRecordChanges = mock(typeof(RecordChanges));
            RecordChanges <PropertyRecord, PrimitiveRecord> propertyRecordChanges     = mock(typeof(RecordChanges));
            RecordChanges <RelationshipGroupRecord, int>    relationshipGroupChanges  = mock(typeof(RecordChanges));
            RecordChanges <SchemaRecord, SchemaRule>        schemaRuleChanges         = mock(typeof(RecordChanges));

            when(recordChangeSet.LabelTokenChanges).thenReturn(labelTokenChanges);
            when(recordChangeSet.RelationshipTypeTokenChanges).thenReturn(relationshipTypeTokenChanges);
            when(recordChangeSet.PropertyKeyTokenChanges).thenReturn(propertyKeyTokenChanges);
            when(recordChangeSet.NodeRecords).thenReturn(nodeRecordChanges);
            when(recordChangeSet.RelRecords).thenReturn(relationshipRecordChanges);
            when(recordChangeSet.PropertyRecords).thenReturn(propertyRecordChanges);
            when(recordChangeSet.RelGroupRecords).thenReturn(relationshipGroupChanges);
            when(recordChangeSet.SchemaRuleChanges).thenReturn(schemaRuleChanges);

            IList <RecordAccess_RecordProxy <NodeRecord, Void> > nodeChanges = new LinkedList <RecordAccess_RecordProxy <NodeRecord, Void> >();

            RecordChanges.RecordChange <NodeRecord, Void> deletedNode = mock(typeof(RecordChanges.RecordChange));
            when(deletedNode.Before).thenReturn(InUseNode());
            when(deletedNode.ForReadingLinkage()).thenReturn(MissingNode());
            nodeChanges.Add(deletedNode);

            RecordChanges.RecordChange <NodeRecord, Void> createdNode = mock(typeof(RecordChanges.RecordChange));
            when(createdNode.Before).thenReturn(MissingNode());
            when(createdNode.ForReadingLinkage()).thenReturn(createdNode());
            nodeChanges.Add(createdNode);

            RecordChanges.RecordChange <NodeRecord, Void> updatedNode = mock(typeof(RecordChanges.RecordChange));
            when(updatedNode.Before).thenReturn(InUseNode());
            when(updatedNode.ForReadingLinkage()).thenReturn(InUseNode());
            nodeChanges.Add(updatedNode);

            when(nodeRecordChanges.Changes()).thenReturn(nodeChanges);
            when(nodeRecordChanges.ChangeSize()).thenReturn(3);
            when(recordChangeSet.ChangeSize()).thenReturn(3);

            when(labelTokenChanges.Changes()).thenReturn(Collections.emptyList());
            when(relationshipTypeTokenChanges.Changes()).thenReturn(Collections.emptyList());
            when(propertyKeyTokenChanges.Changes()).thenReturn(Collections.emptyList());
            when(relationshipRecordChanges.Changes()).thenReturn(Collections.emptyList());
            when(propertyRecordChanges.Changes()).thenReturn(Collections.emptyList());
            when(relationshipGroupChanges.Changes()).thenReturn(Collections.emptyList());
            when(schemaRuleChanges.Changes()).thenReturn(Collections.emptyList());

            NeoStores neoStores = mock(typeof(NeoStores));
            NodeStore store     = mock(typeof(NodeStore));

            when(neoStores.NodeStore).thenReturn(store);
            RelationshipGroupStore relationshipGroupStore = mock(typeof(RelationshipGroupStore));

            when(neoStores.RelationshipGroupStore).thenReturn(relationshipGroupStore);
            RelationshipStore relationshipStore = mock(typeof(RelationshipStore));

            when(neoStores.RelationshipStore).thenReturn(relationshipStore);

            return(new TransactionRecordState(neoStores, mock(typeof(IntegrityValidator)), recordChangeSet, 0, null, null, null, null, null));
        }