public void ForeignKeyCopiedFromAutoPrimaryKey_InCorrectOrder_Test() { // Arrange var primaryTable = new PrimaryTable(); var primaryRecordReference = new RecordReference<PrimaryTable>(Helpers.GetTypeGeneratorMock(primaryTable).Object, this.attributeDecorator); primaryRecordReference.Populate(); var foreignTable = new ForeignTable(); var foreignRecordReference = new RecordReference<ForeignTable>(Helpers.GetTypeGeneratorMock(foreignTable).Object, this.attributeDecorator); foreignRecordReference.Populate(); foreignRecordReference.AddPrimaryRecordReference(primaryRecordReference); var expected = new object[] {"Key", 1, "Guid", Guid.NewGuid(), "Key", 2}; this.writePrimitivesMock.Setup(m => m.Execute()).Returns(expected); // Act // Note the foreign key record is being passed in before the primary key record. // This is to test that the primary key record that wrote first gets the first return // data element and the foreign key record gets the subsequent one. this.persistence.Persist(new RecordReference[] { foreignRecordReference, primaryRecordReference }); // Assert Assert.AreEqual(expected[1], primaryTable.Key); Assert.AreEqual(expected[5], foreignTable.Key); }
private void CopyPrimaryToForeignKeys(RecordReference recordReference) { var primaryKeys = recordReference.PrimaryKeyReferences.SelectMany( pkRef => this.attributeDecorator.GetPropertyAttributes<PrimaryKeyAttribute>(pkRef.RecordType) .Select(pkpa => new {@Object = pkRef.RecordObject, PkProperty = pkpa.PropertyInfo})); IEnumerable<PropertyAttribute<ForeignKeyAttribute>> foreignKeyPropertyAttributes = this.attributeDecorator.GetPropertyAttributes<ForeignKeyAttribute>(recordReference.RecordType); foreignKeyPropertyAttributes.ToList().ForEach(fkpa => { var primaryKey = primaryKeys.FirstOrDefault( pk => pk.PkProperty.DeclaringType == this.attributeDecorator.GetTableType(fkpa.Attribute, recordReference.RecordType) && Helper.GetColumnName(pk.PkProperty, this.attributeDecorator) == fkpa.Attribute.PrimaryKeyName); if (primaryKey == null) { return; } MemoryPersistence.Logger.Debug($"PropertyInfo to get from: {primaryKey.PkProperty}"); object primaryKeyPropertyValue = primaryKey.PkProperty.GetValue(primaryKey.Object); MemoryPersistence.Logger.Debug($"primaryKeyPropertyValue: {primaryKeyPropertyValue}"); MemoryPersistence.Logger.Debug($"PropertyInfo to set: {fkpa.PropertyInfo}"); fkpa.PropertyInfo.SetValue(recordReference.RecordObject, primaryKeyPropertyValue); }); }
public void CopyForeignKeyColumns_Test() { // Arrange var target = new ManualKeyForeignTable(); var recordReference = new RecordReference<ManualKeyForeignTable>(Helpers.GetTypeGeneratorMock(target).Object, this.attributeDecorator); recordReference.Populate(); this.insertRecordService = new InsertRecordService(recordReference, this.attributeDecorator, InsertRecordServiceTest.IsKeyReferenceCheckEnforced); var columns = new[] { new Column { Name = "ForeignKey1", Value = "ABCD" }, new Column { Name = "Two", Value = new Variable(null) }, new Column { Name = "ForeignKey2", Value = 3 }, }; // Act this.insertRecordService.CopyPrimaryToForeignKeyColumns(columns); // Assert Assert.AreEqual(columns[0].Value, target.ForeignKey1); Assert.AreEqual(columns[2].Value, target.ForeignKey2); }
public void Persists_KeyMapping_Test() { // Arrange var primaryTable = new ManualKeyPrimaryTable { Key1 = "ABCD", Key2 = 5 }; var primaryReference = new RecordReference<ManualKeyPrimaryTable>(Helpers.GetTypeGeneratorMock(primaryTable).Object, this.attributeDecorator); var foreignTable = new ManualKeyForeignTable(); var foreignReference = new RecordReference<ManualKeyForeignTable>(Helpers.GetTypeGeneratorMock(foreignTable).Object, this.attributeDecorator); foreignReference.AddPrimaryRecordReference(primaryReference); var deferredValueGeneratorMock = new Mock<IDeferredValueGenerator<LargeInteger>>(); var persistence = new MemoryPersistence(deferredValueGeneratorMock.Object, this.attributeDecorator); // Act primaryReference.Populate(); foreignReference.Populate(); persistence.Persist(new RecordReference[] { primaryReference, foreignReference}); // Assert Assert.AreEqual(primaryTable.Key1, foreignTable.ForeignKey1); Assert.AreEqual(primaryTable.Key2, foreignTable.ForeignKey2); }
public InsertRecordService(RecordReference recordReference, IAttributeDecorator attributeDecorator, bool enforceKeyReferenceCheck) { InsertRecordService.Logger.Debug("Entering constructor"); this.recordReference = recordReference; this.attributeDecorator = attributeDecorator; this.enforceKeyReferenceCheck = enforceKeyReferenceCheck; InsertRecordService.Logger.Debug("Exiting constructor"); }
public InsertRecord(InsertRecordService service, RecordReference recordReference, IEnumerable<AbstractRepositoryOperation> peers, IAttributeDecorator attributeDecorator) { InsertRecord.Logger.Debug("Entering constructor"); this.Peers = peers; this.RecordReference = recordReference; this.service = service; this.attributeDecorator = attributeDecorator; InsertRecord.Logger.Debug("Exiting constructor"); }
public void DeferredValueGenerator_Test() { // Arrange var typeGeneratorMock = new Mock<ITypeGenerator>(); typeGeneratorMock.Setup( m => m.GetObject<PrimaryTable>(It.IsAny<ConcurrentDictionary<PropertyInfo, Action<PrimaryTable>>>())) .Returns(new PrimaryTable()); typeGeneratorMock.Setup( m => m.GetObject<ForeignTable>(It.IsAny<ConcurrentDictionary<PropertyInfo, Action<ForeignTable>>>())) .Returns(new ForeignTable()); var recordObject1 = new RecordReference<PrimaryTable>(typeGeneratorMock.Object, this.attributeDecorator); var recordObject2 = new RecordReference<ForeignTable>(typeGeneratorMock.Object, this.attributeDecorator); var dataSource = new Mock<IPropertyDataGenerator<LargeInteger>>(); var generator = new StandardDeferredValueGenerator<LargeInteger>(dataSource.Object); // Act recordObject1.Populate(); recordObject2.Populate(); generator.AddDelegate(recordObject1.RecordType.GetProperty("Text"), ul => "A"); generator.AddDelegate(recordObject1.RecordType.GetProperty("Integer"), ul => 1); generator.AddDelegate(recordObject2.RecordType.GetProperty("Text"), ul => "B"); generator.AddDelegate(recordObject2.RecordType.GetProperty("Integer"), ul => 2); generator.Execute(new RecordReference[] {recordObject2, recordObject1}); // Assert Assert.AreEqual("A", recordObject1.RecordObject.Text); Assert.AreEqual(1, recordObject1.RecordObject.Integer); Assert.AreEqual("B", recordObject2.RecordObject.Text); Assert.AreEqual(2, recordObject2.RecordObject.Integer); }
public void Initialize() { XmlConfigurator.Configure(); this.foreignKeyTable = new ForeignTable(); this.attributeDecorator = new StandardAttributeDecorator(attributeDecorator => null, null); this.typeGeneratorMock = Helpers.GetTypeGeneratorMock(this.foreignKeyTable); this.recordReference = new RecordReference<ForeignTable>(this.typeGeneratorMock.Object, this.attributeDecorator); this.recordReference.Populate(); this.insertRecordService = new InsertRecordService(this.recordReference, this.attributeDecorator, InsertRecordServiceTest.IsKeyReferenceCheckEnforced); this.writerMock = new Mock<IWritePrimitives>(); this.peers = Enumerable.Empty<AbstractRepositoryOperation>(); this.mainTableColumns = Helpers.GetColumns(this.foreignKeyTable, this.attributeDecorator); }
public void GetRegularColumns_WriteGuid_Test() { // Arrange var table = new ClassWithGuidKeys(); Mock<ITypeGenerator> typeGeneratorMock = Helpers.GetTypeGeneratorMock(table); var recordReference = new RecordReference<ClassWithGuidKeys>(typeGeneratorMock.Object, this.attributeDecorator); recordReference.Populate(); var insertRecordService = new InsertRecordService(recordReference, this.attributeDecorator, InsertRecordServiceTest.IsKeyReferenceCheckEnforced); Variable v1, v2, v3; this.writerMock.Setup(m => m.WriteGuid("Key1")).Returns(v1 = new Variable("x")); this.writerMock.Setup(m => m.WriteGuid("Key3")).Returns(v2 = new Variable("y")); this.writerMock.Setup(m => m.WriteGuid("Key4")).Returns(v3 = new Variable("z")); // Act List<Column> regularColumns = insertRecordService.GetRegularColumns(this.writerMock.Object).ToList(); // Assert this.writerMock.Verify(m => m.WriteGuid(It.IsAny<string>()), Times.Exactly(3)); Column key1 = regularColumns.First(c => c.Name == "Key1"); Column key3 = regularColumns.First(c => c.Name == "Key3"); Column key4 = regularColumns.First(c => c.Name == "Key4"); Assert.AreEqual(v1, key1.Value); Assert.AreEqual(v2, key3.Value); Assert.AreEqual(v3, key4.Value); }
public void GetRegularColumns_NonAutoPrimaryKey_Test() { // Arrange var table = new ManualKeyPrimaryTable {Key1 = "ABCD", Key2 = 7}; var typeGeneratorMock = Helpers.GetTypeGeneratorMock(table); var recordReference = new RecordReference<ManualKeyPrimaryTable>(typeGeneratorMock.Object, this.attributeDecorator); recordReference.Populate(); var insertRecordService = new InsertRecordService(recordReference, this.attributeDecorator, InsertRecordServiceTest.IsKeyReferenceCheckEnforced); // Act List<Column> regularColumns = insertRecordService.GetRegularColumns(null).ToList(); // Assert Assert.AreEqual(2, regularColumns.Count); Column stringKey = regularColumns.First(c => c.Name == "Key1"); Column intKey = regularColumns.First(c => c.Name == "Key2"); Assert.AreEqual(table.Key1, stringKey.Value); Assert.AreEqual(table.Key2, intKey.Value); }
public void GetRegularColumns_ExplicitlySetGuid_Test() { // Arrange var table = new ClassWithGuidKeys {Key1 = Guid.NewGuid(), Key3 = Guid.NewGuid(), Key4 = null}; Mock<ITypeGenerator> typeGeneratorMock = Helpers.GetTypeGeneratorMock(table); var recordReference = new RecordReference<ClassWithGuidKeys>(typeGeneratorMock.Object, this.attributeDecorator); recordReference.Set(r => r.Key1, Guid.Empty).Set(r => r.Key3, Guid.Empty).Set(r => r.Key4, Guid.Empty); recordReference.Populate(); var insertRecordService = new InsertRecordService(recordReference, this.attributeDecorator, InsertRecordServiceTest.IsKeyReferenceCheckEnforced); // Act List<Column> regularColumns = insertRecordService.GetRegularColumns(null).ToList(); // Assert Column key1 = regularColumns.First(c => c.Name == "Key1"); Column key3 = regularColumns.First(c => c.Name == "Key3"); Column key4 = regularColumns.First(c => c.Name == "Key4"); Assert.AreEqual(table.Key1, key1.Value); Assert.AreEqual(table.Key3, key3.Value); Assert.AreEqual(null, key4.Value); }
public void GetPrimaryKeyOperations_Test() { // Arrange Mock<ITypeGenerator> subjectTypeGeneratorMock = Helpers.GetTypeGeneratorMock(new SubjectClass()); Mock<ITypeGenerator> primaryTableTypeGeneratorMock = Helpers.GetTypeGeneratorMock(new PrimaryTable()); var peerRecordreferences = new RecordReference[] { new RecordReference<SubjectClass>(subjectTypeGeneratorMock.Object, this.attributeDecorator), new RecordReference<PrimaryTable>(primaryTableTypeGeneratorMock.Object, this.attributeDecorator), new RecordReference<SubjectClass>(subjectTypeGeneratorMock.Object, this.attributeDecorator), new RecordReference<PrimaryTable>(primaryTableTypeGeneratorMock.Object, this.attributeDecorator), }; InsertRecord[] peerOperations = peerRecordreferences.Select(r => new InsertRecord(this.insertRecordService, r, this.peers, this.attributeDecorator)).ToArray(); // Act this.recordReference.AddPrimaryRecordReference(peerRecordreferences[1], peerRecordreferences[3]); InsertRecord[] primaryKeyOperations = this.insertRecordService.GetPrimaryKeyOperations(peerOperations).ToArray(); // Assert Assert.AreEqual(2, primaryKeyOperations.Length); Assert.AreEqual(peerOperations[1], primaryKeyOperations[0]); Assert.AreEqual(peerOperations[3], primaryKeyOperations[1]); }
public void GetForeignKeyColumns_PropertyIsExplicitlySet_Test() { // Arrange const int explicitValue = 7; this.foreignKeyTable.ForeignKey = explicitValue; // Simulate getting expicitly set value from type generator var primaryKeySymbols = new List<ColumnSymbol> { new ColumnSymbol {ColumnName = "Key", TableType = typeof (PrimaryTable), Value = 5} }; var recordReference = new RecordReference<PrimaryTable>(Helpers.GetTypeGeneratorMock(new PrimaryTable()).Object, this.attributeDecorator); var primaryKeyInsertRecordMock = new Mock<InsertRecord>(this.insertRecordService, recordReference, this.peers, this.attributeDecorator); primaryKeyInsertRecordMock.Setup(m => m.GetPrimaryKeySymbols()).Returns(primaryKeySymbols); // Just record the fact that "ForeignKey" is explicitly set. Actual value comes from explicit value above. this.recordReference.Set(r => r.ForeignKey, default(int)); // Act List<ExtendedColumnSymbol> fkColumns = this.insertRecordService.GetForeignKeyColumns(new[] { primaryKeyInsertRecordMock.Object }).ToList(); // Assert Assert.AreEqual(1, fkColumns.Count); Assert.AreEqual("ForeignKey", fkColumns[0].ColumnName); Assert.AreEqual(explicitValue, fkColumns[0].Value); }
public void Insert_Test() { // Arrange var primaryTable = new PrimaryTable { Integer = 5, Text = "Text"}; var primaryRecordReference = new RecordReference<PrimaryTable>(Helpers.GetTypeGeneratorMock(primaryTable).Object, this.attributeDecorator); primaryRecordReference.Populate(); string tableName = typeof(PrimaryTable).Name; List<Column> primaryTableColumns = null; this.writePrimitivesMock.Setup(m => m.Insert(null, It.IsAny<string>(), tableName, It.IsAny<IEnumerable<Column>>())) .Callback<string, string, string, IEnumerable<Column>>((cat, s, t, col) => primaryTableColumns = col.ToList()); this.writePrimitivesMock.Setup(m => m.Execute()).Returns(new object[] {"Key", 0, "Guid", Guid.NewGuid()}); // Act var recordReferenceArray = new RecordReference[] {primaryRecordReference}; this.persistence.Persist(recordReferenceArray); // Assert this.writePrimitivesMock.Verify(m => m.Insert(null, It.IsAny<string>(), tableName, It.IsAny<IEnumerable<Column>>()), Times.Once()); this.deferredValueGeneratorMock.Verify( m => m.Execute(It.Is<IEnumerable<RecordReference>>(e => e.First() == recordReferenceArray[0])), Times.Once); Assert.IsNotNull(primaryTableColumns); Assert.AreEqual(4, primaryTableColumns.Count); Assert.AreEqual("Text", primaryTableColumns[0].Name); Assert.AreEqual(primaryTable.Text, primaryTableColumns[0].Value); Assert.AreEqual("Integer", primaryTableColumns[1].Name); Assert.AreEqual(primaryTable.Integer, primaryTableColumns[1].Value); }
public void InsertsInProperOrder_Test() { // Arrange var primaryTable = new PrimaryTable { Integer = 1}; var primaryRecordReference = new RecordReference<PrimaryTable>(Helpers.GetTypeGeneratorMock(primaryTable).Object, this.attributeDecorator); primaryRecordReference.Populate(); var foreignTable = new ForeignTable {Integer = 1}; var foreignRecordReference = new RecordReference<ForeignTable>(Helpers.GetTypeGeneratorMock(foreignTable).Object, this.attributeDecorator); foreignRecordReference.Populate(); foreignRecordReference.AddPrimaryRecordReference(primaryRecordReference); var columns = new List<List<Column>>(); this.writePrimitivesMock.Setup(m => m.Insert(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<IEnumerable<Column>>())) .Callback<string, string, string, IEnumerable<Column>>((cat, s, t, col) => columns.Add(col.ToList())); this.writePrimitivesMock.Setup(m => m.SelectIdentity(It.IsAny<string>())).Returns(new Variable(null)); this.writePrimitivesMock.Setup(m => m.Execute()).Returns(new object[] {"Key", 0, "Guid", Guid.NewGuid(), "Key", 0}); // Act // Note the foreign key record is being passed in before the primary key record // to test that the primary key record writes first regardless which insert operation's // Write method is called. this.persistence.Persist(new RecordReference[] { foreignRecordReference, primaryRecordReference}); // Assert Assert.AreEqual(primaryTable.Integer, columns[0].First(c => c.Name == "Integer").Value); Assert.AreEqual(foreignTable.Integer, columns[1].First(c => c.Name == "Integer").Value); }
public virtual void AddPrimaryRecordReference(RecordReference primaryRecordReference) { RecordReference.Logger.Debug( $"Entering AddPrimaryRecordReference(RecordReference). record object: {primaryRecordReference.RecordObject}"); if (!this.ValidateRelationship(primaryRecordReference)) { throw new NoReferentialIntegrityException(primaryRecordReference.RecordType, this.RecordType); } ((List<RecordReference>)this.PrimaryKeyReferences).Add(primaryRecordReference); RecordReference.Logger.Debug("Exiting AddPrimaryRecordReference(RecordReference)"); }
protected virtual bool ValidateRelationship(RecordReference primaryRecordReference) { RecordReference.Logger.Debug("Entering ValidateRelationship"); IEnumerable<PropertyAttribute<ForeignKeyAttribute>> foreignKeyPropertyAttributes = this.AttributeDecorator.GetPropertyAttributes<ForeignKeyAttribute>(this.RecordType).ToList(); bool result = this.AttributeDecorator.GetPropertyAttributes<PrimaryKeyAttribute>(primaryRecordReference.RecordType) .All( pkPa => foreignKeyPropertyAttributes.Any( fkPa => pkPa.PropertyInfo.DeclaringType == this.AttributeDecorator.GetTableType(fkPa.Attribute, this.RecordType) && Helper.GetColumnName(pkPa.PropertyInfo, this.AttributeDecorator) .Equals(fkPa.Attribute.PrimaryKeyName, StringComparison.Ordinal) && pkPa.PropertyInfo.PropertyType == fkPa.PropertyInfo.PropertyType ) ); RecordReference.Logger.Debug("Exiting ValidateRelationship"); return result; }
public void ForeignKeysCopiedFromManualPrimaryKeys_Test() { // Arrange var primaryTable = new ManualKeyPrimaryTable {Key1 = "A", Key2 = 7}; var foreignTable = new ManualKeyForeignTable(); var primaryRecordReference = new RecordReference<ManualKeyPrimaryTable>(Helpers.GetTypeGeneratorMock(primaryTable).Object, this.attributeDecorator); primaryRecordReference.Populate(); var foreignRecordReference = new RecordReference<ManualKeyForeignTable>(Helpers.GetTypeGeneratorMock(foreignTable).Object, this.attributeDecorator); foreignRecordReference.Populate(); foreignRecordReference.AddPrimaryRecordReference(primaryRecordReference); const string catalogueName = "catABC"; const string schema = "schemaABC"; const string tableName = "ABCD"; var columns = new List<List<Column>>(); this.writePrimitivesMock.Setup(m => m.Insert(catalogueName, schema, tableName, It.IsAny<IEnumerable<Column>>())) .Callback<string, string, string, IEnumerable<Column>>((cat, s, t, col) => columns.Add(col.ToList())); // Act this.persistence.Persist(new RecordReference[] { foreignRecordReference, primaryRecordReference }); // Assert Assert.AreEqual(primaryTable.Key1, foreignTable.ForeignKey1); Assert.AreEqual(primaryTable.Key2, foreignTable.ForeignKey2); }
public void CopyForeignKeyColumns_UnknownColumnThrows_Test() { // Arrange var target = new ManualKeyForeignTable(); var recordReference = new RecordReference<ManualKeyForeignTable>(Helpers.GetTypeGeneratorMock(target).Object, this.attributeDecorator); recordReference.Populate(); this.insertRecordService = new InsertRecordService(recordReference, this.attributeDecorator, InsertRecordServiceTest.IsKeyReferenceCheckEnforced); var columns = new[] { new Column { Name = "ForeignKey1", Value = "ABCD" }, new Column { Name = "Two", Value = new object() }, }; // Act // Assert Helpers.ExceptionTest( () => this.insertRecordService.CopyPrimaryToForeignKeyColumns(columns), typeof(InvalidOperationException), "Sequence contains no matching element"); }
public void Persist_Test() { // Arrange var deferredValueGeneratorMock = new Mock<IDeferredValueGenerator<LargeInteger>>(); var persistence = new MemoryPersistence(deferredValueGeneratorMock.Object, this.attributeDecorator); var primaryTable = new PrimaryTable { Integer = 5, Text = "Text" }; var primaryRecordReference = new RecordReference<PrimaryTable>( Helpers.GetTypeGeneratorMock(primaryTable).Object, this.attributeDecorator); var recordReferenceArray = new RecordReference[] { primaryRecordReference }; // Act persistence.Persist(recordReferenceArray); // Assert deferredValueGeneratorMock.Verify( m => m.Execute(It.Is<IEnumerable<RecordReference>>(e => e.First() == recordReferenceArray[0])), Times.Once); }