public void ShouldMapAssociationForChild() { // db config var conn = new MockDb() .NewReader("Field4") .NewRow("TestOne"); using (conn) using (var db = new DbManager(conn)) { // fluent config new FluentMap<AssociationThis2Dbo>() .MapField(_ => _.FieldThis1, "ThisId") .MapField(_ => _.FieldThis3) .Association(_ => _.FieldThis1).ToOne(_ => _.FieldOther3) .MapTo(db); var table = db.GetTable<AssociationThis2ChildDbo>(); // when var dbo = (from t in table select t.FieldThis3.FieldOther4).First(); // then Assert.AreEqual("TestOne", dbo, "Fail result for many"); conn.Commands[0] .Assert().AreField("ThisId", "Fail this key"); conn.Commands[0] .Assert().AreField("FieldOther3", "Fail other key"); conn.Commands[0] .Assert().AreField("FieldOther4", "Fail other result"); Assert.AreEqual(3, conn.Commands[0].Fields.Count, "More fields"); } }
public void ShouldMapTableNameForChild() { // db config var conn = new MockDb() .NewReader("Field1") .NewRow(1); using (conn) using (var db = new DbManager(conn)) { // fluent config new FluentMap<TableNameDbo>() .TableName("TableNameDboT1") .MapTo(db); // when db.GetTable<TableNameChildDbo>().ToArray(); // then conn.Commands[0] .Assert().AreTable("TableNameDboT1", "Fail mapping"); } }
public void ShouldMapValueForTypeForChild() { // db config var conn = new MockDb() .NewReader("Field1", "Field2", "Field3") .NewRow("one", "two", true); using (conn) using (var db = new DbManager(conn)) { #warning bug for property any different types #warning bug for maping TO db // fluent config new FluentMap<MapValueTypeDbo>() .MapValue(1, "one", "1") .MapValue(2, "two") .MapValue(3, true) .MapTo(db); var table = db.GetTable<MapValueTypeChildDbo>(); // when var dbo = (from t in table select t).First(); // then Assert.AreEqual(1, dbo.Field1, "Not map from value1"); Assert.AreEqual(2, dbo.Field2, "Not map from value2"); Assert.AreEqual(3, dbo.Field3, "Not map from value3"); } }
public void ShouldMapValueForEnumForChild() { // db config var conn = new MockDb() .NewReader("Field1", "Field2", "Field3", "Field4") .NewRow("ok", "super", "yes", 10); using (conn) using (var db = new DbManager(conn)) { #warning bug for maping TO db // fluent config new FluentMap<MapValueEnumDbo>() .MapValue(MapValueEnum.Value1, "ok", "yes") .MapValue(MapValueEnum.Value2, "super") .MapTo(db); var table = db.GetTable<MapValueEnumChildDbo>(); // when var dbo = (from t in table select t).First(); // then Assert.AreEqual(MapValueEnum.Value1, dbo.Field1, "Not map from value1"); Assert.AreEqual(MapValueEnum.Value2, dbo.Field2, "Not map from value2"); Assert.AreEqual(MapValueEnum.Value1, dbo.Field3, "Not map from value3"); } }
public void ShouldMapValueForMemberForChild() { // db config var conn = new MockDb() .NewReader("Field1", "Field2") .NewRow(true, false); using (conn) using (var db = new DbManager(conn)) { #warning bug for maping TO db // fluent config new FluentMap<MapValueMemberDbo>() .MapField(_ => _.Field1) .MapValue("result true", true) .MapValue("result false", false) .MapField(_ => _.Field2) .MapValue("value true", true) .MapValue("value false", false) .MapTo(db); var table = db.GetTable<MapValueMemberChildDbo>(); // when var dbo = (from t in table select t).First(); // then Assert.AreEqual("result true", dbo.Field1, "Not map from value1"); Assert.AreEqual("value false", dbo.Field2, "Not map from value2"); } }
public void ShouldMapTrimmableForChild() { // db config var conn = new MockDb() .NewReader("Field1") .NewRow("test "); using (conn) using (var db = new DbManager(conn)) { // fluent config new FluentMap<TrimmableDbo>() .Trimmable(_ => _.Field1) .MapTo(db); var table = db.GetTable<TrimmableChildDbo>(); // when var dbo = (from t in table select t).First(); // then Assert.AreEqual("test", dbo.Field1, "Not trimmable"); } }
public MockCommand(MockDb db) { _db = db; Parameters = new DataParameterCollection(); }
public void ShouldMapField() { // db config var conn = new MockDb() .NewNonQuery(); using (conn) using (var db = new DbManager(conn)) { // fluent config new FluentMap<MapFieldDbo>() .MapField(_ => _.Field1, "f1") .MapTo(db); // when db.GetTable<MapFieldDbo>().Insert(() => new MapFieldDbo { Field1 = 1 }); // then conn.Commands[0] .Assert().AreField("f1", "Fail mapping"); } }
public void ShouldMapNonUpdatableForChild() { // db config var conn = new MockDb() .NewNonQuery(); using (conn) using (var db = new DbManager(conn)) { // fluent config new FluentMap<NonUpdatableDbo>() .NonUpdatable(_ => _.Field1) .MapTo(db); // when new SqlQuery<NonUpdatableChildDbo>(db).Insert(new NonUpdatableChildDbo { Field1 = 10, Field2 = 1 }); // then Assert.AreEqual(1, conn.Commands[0].Parameters.Count, "Fail params"); } }
public void ShouldMapPrimaryKeyForChild() { // db config var conn = new MockDb() .NewReader("Field1", "Field2") .NewRow(1, 2); using (conn) using (var db = new DbManager(conn)) { // fluent config new FluentMap<PrimaryKeyDbo>() .PrimaryKey(_ => _.Field2) .MapTo(db); // when AssertExceptionEx.AreNotException<Exception>(() => new SqlQuery<PrimaryKeyChildDbo>(db).SelectByKey(1) , "Fail query"); // then Assert.AreEqual(1, conn.Commands[0].Parameters.Count, "Fail params"); conn.Commands[0] .Assert().AreField("Field2", 2, "Not where part"); } }
public AssertDb(MockDb db) { _db = db; }
public void ShouldFailMapValueForTypeForPropertyAnyDifferentTypes() { // db config var conn = new MockDb() .NewReader("Field1", "Field2") .NewRow("one", 2); using (conn) using (var db = new DbManager(conn)) { // fluent config new FluentMap<MapValueTypeDbo2>() .MapValue(1, "one") // Field1 - int .MapValue("two", 2) // Filed2 - string .MapTo(db); var table = db.GetTable<MapValueTypeDbo2>(); // when / then AssertExceptionEx.AreNotException<Exception>(() => { var dbo = (from t in table select t).First(); } , "Bug for property any different types"); } }
public void ShouldFailMapValueForInsert() { // db config var conn = new MockDb() .NewNonQuery() .NewNonQuery(); using (conn) using (var db = new DbManager(conn)) { // fluent config new FluentMap<MapValueMemberDbo>() .MapField(_ => _.Field1) .MapValue("result true", true) .MapValue("result false", false) .MapField(_ => _.Field2) .MapValue("value true", true) .MapValue("value false", false) .MapTo(db); var table = db.GetTable<MapValueMemberDbo>(); // when table.Insert(() => new MapValueMemberDbo { Field1 = "result true", Field2 = "value false" }); // linq db.Insert(new MapValueMemberDbo { Field1 = "result true", Field2 = "value false" }); // other? // then var i1 = conn.Commands[0].CommandText.IndexOf("result true", StringComparison.Ordinal); Assert.IsTrue(-1 == i1, "Not map to value1 for linq"); var i2 = conn.Commands[0].CommandText.IndexOf("value false", StringComparison.Ordinal); Assert.IsTrue(-1 == i2, "Not map to value2 for linq"); Assert.AreEqual(true, conn.Commands[1].Parameters[0].Value, "Not map to value1"); Assert.AreEqual(false, conn.Commands[1].Parameters[1].Value, "Not map to value2"); } }
public void ShouldMapInheritanceMapping() { // db config var conn = new MockDb() .NewReader("Field1", "Field2") .NewRow(1, 1) .NewRow(2, 2); using (conn) using (var db = new DbManager(conn)) { // fluent config new FluentMap<InheritanceMappingDbo>() .InheritanceMapping<InheritanceMappingDbo1>(1) .InheritanceMapping<InheritanceMappingDbo2>(2) .InheritanceField(_ => _.Field2) .MapTo(db); var table = db.GetTable<InheritanceMappingDbo>(); // when var dbos = (from t in table select t).ToArray(); // then Assert.IsInstanceOfType(dbos[0], typeof(InheritanceMappingDbo1), "Invalid type1"); Assert.IsInstanceOfType(dbos[1], typeof(InheritanceMappingDbo2), "Invalid type2"); } }
public void ShouldMapInheritanceMappingSelectChild() { // db config var conn = new MockDb() .NewReader("Field1", "Field2") .NewRow(1, 1); using (conn) using (var db = new DbManager(conn)) { // fluent config new FluentMap<InheritanceMappingChDbo>() .TableName("tt") .InheritanceMapping<InheritanceMappingChDbo1>(11111) .InheritanceMapping<InheritanceMappingChDbo2>(22222) .InheritanceField(_ => _.Field2) .MapTo(db); var table = db.GetTable<InheritanceMappingChDbo1>(); // when var dbos = (from t in table select t).ToArray(); // then Assert.IsInstanceOfType(dbos[0], typeof(InheritanceMappingChDbo1), "Invalid type"); Assert.IsTrue(conn.Commands[0].CommandText.ToLower().Contains("where"), "Not condition"); Assert.IsTrue(conn.Commands[0].CommandText.ToLower().Contains("11111"), "Fail condition value"); conn.Commands[0] .Assert().AreField("Field2", 2, "Not in where part"); } }
public void ShouldMapIgnoreInsert() { // db config var conn = new MockDb() .NewNonQuery(); using (conn) using (var db = new DbManager(conn)) { // fluent config new FluentMap<MapIgnoreInsertDbo>() .MapIgnore(_ => _.Field2) .MapTo(db); // when / then new SqlQuery<MapIgnoreInsertDbo>(db).Insert(new MapIgnoreInsertDbo { Field1 = 20, Field2 = 2 }); AssertExceptionEx.AreException<LinqException>( () => db.GetTable<MapIgnoreInsertDbo>().Insert(() => new MapIgnoreInsertDbo { Field1 = 10, Field2 = 1 }) , "Fail for linq"); // then conn.Commands[0] .Assert().AreNotField("Field2", "Field exists"); Assert.AreEqual(1, conn.Commands[0].Parameters.Count, "Fail params"); } }
public void ShouldMapRelationForChild() { // given List<Parent2Child> parents = new List<Parent2Child>(); MapResultSet[] sets = new MapResultSet[2]; sets[0] = new MapResultSet(typeof(Parent2Child), parents); sets[1] = new MapResultSet(typeof(Child2)); // db config var conn = new MockDb() .NewReader("ParentID") .NewRow(1) .NewRow(2) .NextResult("ChildID", "ParentID") .NewRow(4, 1) .NewRow(5, 2) .NewRow(6, 2) .NewRow(7, 1); using (conn) using (var db = new DbManager(conn)) { // fluent config new FluentMap<Parent2>() .MapField(_ => _.ID, "ParentID").PrimaryKey() .MapField(_ => _.Children).Relation() .MapTo(db); new FluentMap<Child2>() .MapField(_ => _.Parent.ID, "ParentID") .MapField(_ => _.ID, "ChildID").PrimaryKey() .MapField(_ => _.Parent).Relation() .MapTo(db); // when db.SetCommand("select *").ExecuteResultSet(sets); } // then Assert.IsTrue(parents.Any()); foreach (Parent2Child parent in parents) { Assert.IsNotNull(parent); Assert.IsTrue(parent.Children.Any()); foreach (Child2 child in parent.Children) { Assert.AreEqual(parent, child.Parent); } } }
public void ShouldMapIgnoreForChild() { // db config var conn = new MockDb() .NewReader("Field1") .NewRow(10, 1); using (conn) using (var db = new DbManager(conn)) { // fluent config new FluentMap<MapIgnoreSelectDbo>() .MapIgnore(_ => _.Field2) .MapTo(db); var table = db.GetTable<MapIgnoreChildDbo>(); // when (from t in table where t.Field1 == 10 select t).First(); // then conn.Commands[0] .Assert().AreNotField("Field2", "Field exists"); } }