public void Mock_MockTable_FromType_Test()
{
// Act
var table = MockTable.FromType <SimpleModel>();
// Assert
Assert.IsNotNull(table);
Assert.AreEqual(7, table.Columns.Length);
Assert.AreEqual(nameof(SimpleModel.Id), table.Columns[0].Name);
Assert.AreEqual(nameof(SimpleModel.Name), table.Columns[1].Name);
Assert.AreEqual(nameof(SimpleModel.Description), table.Columns[2].Name);
Assert.AreEqual(nameof(SimpleModel.Value), table.Columns[3].Name);
Assert.AreEqual(nameof(SimpleModel.Checksum), table.Columns[4].Name);
Assert.AreEqual(nameof(SimpleModel.TimestampCreated), table.Columns[5].Name);
Assert.AreEqual(nameof(SimpleModel.TimestampModified), table.Columns[6].Name);
Assert.AreEqual(typeof(Guid), table.Columns[0].Type);
Assert.AreEqual(typeof(string), table.Columns[1].Type);
Assert.AreEqual(typeof(string), table.Columns[2].Type);
Assert.AreEqual(typeof(int), table.Columns[3].Type);
Assert.AreEqual(typeof(long?), table.Columns[4].Type);
Assert.AreEqual(typeof(DateTime), table.Columns[5].Type);
Assert.AreEqual(typeof(DateTime?), table.Columns[6].Type);
}
public void Mock_MockTable_FromType_with_BindingFlags_override_Test()
{
// Arrange
var bindingFlags = MockTable.DefaultFromTypeBindingFlags | BindingFlags.Static;
// Act
var table = MockTable.FromType <SimpleModel>(propertyBindingFlags: bindingFlags);
// Assert
Assert.IsNotNull(table);
Assert.AreEqual(8, table.Columns.Length);
Assert.AreEqual(nameof(SimpleModel.Id), table.Columns[0].Name);
Assert.AreEqual(nameof(SimpleModel.Name), table.Columns[1].Name);
Assert.AreEqual(nameof(SimpleModel.Description), table.Columns[2].Name);
Assert.AreEqual(nameof(SimpleModel.Value), table.Columns[3].Name);
Assert.AreEqual(nameof(SimpleModel.Checksum), table.Columns[4].Name);
Assert.AreEqual(nameof(SimpleModel.TimestampCreated), table.Columns[5].Name);
Assert.AreEqual(nameof(SimpleModel.TimestampModified), table.Columns[6].Name);
Assert.AreEqual(typeof(Guid), table.Columns[0].Type);
Assert.AreEqual(typeof(string), table.Columns[1].Type);
Assert.AreEqual(typeof(string), table.Columns[2].Type);
Assert.AreEqual(typeof(int), table.Columns[3].Type);
Assert.AreEqual(typeof(long?), table.Columns[4].Type);
Assert.AreEqual(typeof(DateTime), table.Columns[5].Type);
Assert.AreEqual(typeof(DateTime?), table.Columns[6].Type);
}
public void Exists_Success()
{
MockTable <TestEntity> database = new MockTable <TestEntity>();
database.Add(new TestEntity(1234));
Assert.IsTrue(database.Exists(1234));
}
public void Add_Existing_Fails()
{
MockTable <TestEntity> database = new MockTable <TestEntity>();
database.Add(new TestEntity(1234));
database.Add(new TestEntity(1234)); // throws exception
}
public void Mock_ExecuteDataset_WithFunction_Test()
{
var conn = new MockDbConnection();
MockTable table1 = MockTable.WithColumns("Col1", "Col2")
.AddRow(11, 12);
MockTable table2 = MockTable.WithColumns("Col3", "Col4")
.AddRow("MyString", 3.4);
conn.Mocks
.When(null)
.ReturnsDataset(cmd => new[] { table1, table2 });
using (var cmd = new DatabaseCommand(conn))
{
cmd.CommandText.AppendLine("SELECT ...");
var result = cmd.ExecuteDataSet(new { Col1 = 0, Col2 = 0 },
new { Col3 = "", Col4 = 0.0 });
Assert.AreEqual(1, result.Item1.Count()); // 1 row
Assert.AreEqual(11, result.Item1.First().Col1);
Assert.AreEqual(12, result.Item1.First().Col2);
Assert.AreEqual(1, result.Item2.Count()); // 1 row
Assert.AreEqual("MyString", result.Item2.First().Col3);
Assert.AreEqual(3.4, result.Item2.First().Col4);
}
}
public void Mock_MockTable_FromCsv_Test()
{
var conn = new MockDbConnection();
string csv = @" Id Name Birthdate
1 Scott 1980-02-03
2 Bill 1972-01-12
3 Anders 1965-03-14 ";
var table = MockTable.FromCsv(csv);
Assert.AreEqual("Id", table.Columns[0].Name);
Assert.AreEqual("Name", table.Columns[1].Name);
Assert.AreEqual(3, table.Rows.RowsCount());
Assert.AreEqual("Scott", table.Rows[0, 1]);
Assert.IsInstanceOfType(table.Rows[0, 1], typeof(string));
Assert.AreEqual(3, table.Rows[2, 0]);
Assert.IsInstanceOfType(table.Rows[2, 0], typeof(int));
Assert.AreEqual(new DateTime(1972, 1, 12), table.Rows[1, 2]);
Assert.IsInstanceOfType(table.Rows[1, 2], typeof(DateTime));
}
public void Mock_ReturnsSimple_MockRow_Test()
{
var conn = new MockDbConnection();
MockTable table = MockTable.WithColumns("Col1", "Col2")
.AddRow(11, 12)
.AddRow(13, 14);
conn.Mocks
.WhenAny()
.ReturnsRow(table);
DbCommand cmd = conn.CreateCommand();
DbDataReader result = cmd.ExecuteReader();
result.Read();
Assert.AreEqual(11, result.GetInt32(0));
Assert.AreEqual(12, result.GetInt32(1));
result.Read();
Assert.AreEqual(13, result.GetInt32(0));
Assert.AreEqual(14, result.GetInt32(1));
}
public void Mock_ReturnsMultiple_MockTable_Test()
{
var conn = new MockDbConnection();
MockTable table1 = MockTable.WithColumns("Col1", "Col2")
.AddRow(11, 12);
MockTable table2 = MockTable.WithColumns("Col3", "Col4")
.AddRow("aa", 3.4);
conn.Mocks
.WhenAny()
.ReturnsDataset(table1, table2);
DbCommand cmd = conn.CreateCommand();
DbDataReader result = cmd.ExecuteReader();
Assert.IsTrue(result.Read());
Assert.AreEqual(11, result.GetInt32(0));
Assert.AreEqual(12, result.GetInt32(1));
Assert.IsTrue(result.NextResult());
Assert.IsTrue(result.Read());
Assert.AreEqual("aa", result.GetString(0));
Assert.AreEqual(3.4, result.GetDouble(1));
}
public void Mock_ReturnsSimple_MockTableWithNull_Test()
{
var conn = new MockDbConnection();
MockTable table = MockTable.WithColumns("Col1", "Col2")
.AddRow(null, 12)
.AddRow(13, 14);
conn.Mocks
.WhenAny()
.ReturnsTable(table);
DbCommand cmd = conn.CreateCommand();
DbDataReader result = cmd.ExecuteReader();
result.Read();
Assert.AreEqual(null, result.GetValue(0));
Assert.IsTrue(result.GetFieldType(0) == typeof(object));
result.Read();
Assert.AreEqual(13, result.GetValue(0));
Assert.IsTrue(result.GetFieldType(0) == typeof(object));
}
public void Exists_Failure()
{
MockTable <TestEntity> database = new MockTable <TestEntity>();
database.Add(new TestEntity(1234));
Assert.IsFalse(database.Exists(5678));
}
public void Find_Nonexistent_ReturnsNull()
{
MockTable <TestEntity> database = new MockTable <TestEntity>();
database.Add(new TestEntity(1234));
Assert.IsNull(database.Get(5678));
}
public void Select_TestEntity_To_Int()
{
TestEntities = new MockTable <TestEntity>();
TestEntities.Add(new TestEntity(42), new TestEntity(43), new TestEntity(44),
new TestEntity(99), new TestEntity(0));
IEnumerable <int> returns = TestEntities.Select(item => item.EntityId);
}
public void Index_SelectTestEntity_ReturnTestEntityMockTable()
{
MockDatabase database = new MockDatabase();
database.Add(new TestEntity(42));
MockTable <IEntity> testEntities =
database[typeof(TestEntity)];
}
public void MockTable_InvalidGuid_Test()
{
string content = "Col1 \n" +
"(guid) \n" +
"b5acc392-XXXX-XXXX-XXXX-3d7344db6e91 ";
var table = MockTable.FromFixed(content);
}
public void MockTable_InvalidDate_Test()
{
string content = "Col1 \n" +
"(date) \n" +
"2020-01-32 ";
var table = MockTable.FromFixed(content);
}
public void Mock_MockTable_FromType_with_BindingFlags_override_and_RowData_Test()
{
// Arrange
var bindingFlags = MockTable.DefaultFromTypeBindingFlags | BindingFlags.Static;
var rowData = Enumerable.Range(1, 5)
.Select(x =>
{
var instance = SimpleModel.RandomInstance();
if (x % 2 == 0)
{
instance.CalculateChecksum();
}
if (x % 3 == 0)
{
instance.SetUpdated();
}
return(instance);
})
.ToArray();
// Act
var table = MockTable.FromType <SimpleModel>(rowData, bindingFlags);
// Assert
Assert.IsNotNull(table);
Assert.AreEqual(8, table.Columns.Length);
Assert.AreEqual(nameof(SimpleModel.Id), table.Columns[0].Name);
Assert.AreEqual(nameof(SimpleModel.Name), table.Columns[1].Name);
Assert.AreEqual(nameof(SimpleModel.Description), table.Columns[2].Name);
Assert.AreEqual(nameof(SimpleModel.Value), table.Columns[3].Name);
Assert.AreEqual(nameof(SimpleModel.Checksum), table.Columns[4].Name);
Assert.AreEqual(nameof(SimpleModel.TimestampCreated), table.Columns[5].Name);
Assert.AreEqual(nameof(SimpleModel.TimestampModified), table.Columns[6].Name);
Assert.AreEqual(nameof(SimpleModel.RandomValue), table.Columns[7].Name);
Assert.AreEqual(typeof(Guid), table.Columns[0].Type);
Assert.AreEqual(typeof(string), table.Columns[1].Type);
Assert.AreEqual(typeof(string), table.Columns[2].Type);
Assert.AreEqual(typeof(int), table.Columns[3].Type);
Assert.AreEqual(typeof(long?), table.Columns[4].Type);
Assert.AreEqual(typeof(DateTime), table.Columns[5].Type);
Assert.AreEqual(typeof(DateTime?), table.Columns[6].Type);
Assert.AreEqual(typeof(long), table.Columns[7].Type);
for (var i = 0; i < rowData.Length; ++i)
{
Assert.AreEqual(rowData[i].Id, table.Rows[i, 0]);
Assert.AreEqual(rowData[i].Name, table.Rows[i, 1]);
Assert.AreEqual(rowData[i].Description, table.Rows[i, 2]);
Assert.AreEqual(rowData[i].Value, table.Rows[i, 3]);
Assert.AreEqual(rowData[i].Checksum, table.Rows[i, 4]);
Assert.AreEqual(rowData[i].TimestampCreated, table.Rows[i, 5]);
Assert.AreEqual(rowData[i].TimestampModified, table.Rows[i, 6]);
}
}
public void Find_Entity_Success()
{
MockTable<TestEntity> database = new MockTable<TestEntity>();
database.Add(new TestEntity(1234));
Assert.AreEqual<string>("1234", database.Get(1234).ToString());
database.Add(new TestEntity(5678));
Assert.AreEqual<string>("5678", database.Get(5678).ToString());
Assert.AreEqual<string>("1234", database.Get(1234).ToString()); // Still
}
public void Foreach_IterateOverItemsInTable()
{
MockTable <TestEntity> table = new MockTable <TestEntity>();
int counter = 0;
foreach (TestEntity entity in table)
{
counter++;
}
Assert.AreEqual <int>(0, counter);
}
private MockTable CreateMockTable()
{
return(MockTable.WithColumns(nameof(Tests.Student.Id),
nameof(Tests.Student.FirstName),
nameof(Tests.Student.LastName),
nameof(Tests.Student.Grade),
nameof(Tests.Student.Timestamp),
nameof(Tests.Student.CreationDate),
nameof(Tests.Student.ModificationDate),
nameof(Tests.Student.DeletionDate)));
}
public void Add_Success()
{
MockTable<TestEntity> database = new MockTable<TestEntity>();
Assert.AreEqual<int>(0, database.Size);
database.Add(new TestEntity(1234));
Assert.AreEqual<int>(1, database.Size);
database.Add(new TestEntity(5678));
Assert.AreEqual<int>(2, database.Size);
}
public void Find_Entity_Success()
{
MockTable <TestEntity> database = new MockTable <TestEntity>();
database.Add(new TestEntity(1234));
Assert.AreEqual <string>("1234", database.Get(1234).ToString());
database.Add(new TestEntity(5678));
Assert.AreEqual <string>("5678", database.Get(5678).ToString());
Assert.AreEqual <string>("1234", database.Get(1234).ToString()); // Still
}
public void MockTable_FixedColumns_String_Test()
{
string content = "Col1 Col2 \n" +
"string int \n" +
"abc def 99 ";
var table = MockTable.FromFixed(content);
Assert.AreEqual("abc def", table.Rows[0, 0]);
Assert.AreEqual(99, table.Rows[0, 1]);
}
public void MockTable_Decimal_Test()
{
string content = "Col1 \n" +
"(decimal) \n" +
"123.45 ";
var table = MockTable.FromFixed(content);
Assert.AreEqual(typeof(decimal), table.Columns[0].Type);
Assert.AreEqual((decimal)123.45, table.Rows[0, 0]);
}
public void MockTable_StringGuillemets_Test()
{
string content = "Col1 \n" +
"(string) \n" +
"\"ABC DEF\" ";
var table = MockTable.FromFixed(content);
Assert.AreEqual(typeof(String), table.Columns[0].Type);
Assert.AreEqual("ABC DEF", table.Rows[0, 0]);
}
public void MockTable_FixedColumns_MissingColumn_Test()
{
string content = "Col1 \n" +
"int string";
var table = MockTable.FromFixed(content);
Assert.AreEqual(1, table.Columns.Length);
Assert.AreEqual("Col1", table.Columns[0].Name);
Assert.AreEqual(null, table.Columns[0].Type);
}
public void MockTable_TimeSpan_Test()
{
string content = "Col1 \n" +
"(timespan) \n" +
"01:02:03.123 ";
var table = MockTable.FromFixed(content);
Assert.AreEqual(typeof(TimeSpan), table.Columns[0].Type);
Assert.AreEqual(new TimeSpan(0, 1, 2, 3, 123), table.Rows[0, 0]);
}
public void MockTable_DateTime_Test()
{
string content = "Col1 \n" +
"(date) \n" +
"2020-01-15 ";
var table = MockTable.FromFixed(content);
Assert.AreEqual(typeof(DateTime), table.Columns[0].Type);
Assert.AreEqual(new DateTime(2020, 01, 15), table.Rows[0, 0]);
}
public void MockTable_Guid_Test()
{
string content = "Col1 \n" +
"(guid) \n" +
"b5acc392-3b9d-4059-9851-3d7344db6e91 ";
var table = MockTable.FromFixed(content);
Assert.AreEqual(typeof(Guid), table.Columns[0].Type);
Assert.AreEqual(new Guid("b5acc392-3b9d-4059-9851-3d7344db6e91"), table.Rows[0, 0]);
}
public void MockTable_Boolean_Test()
{
string content = "Col1 \n" +
"(bool) \n" +
"true ";
var table = MockTable.FromFixed(content);
Assert.AreEqual(typeof(Boolean), table.Columns[0].Type);
Assert.AreEqual(true, table.Rows[0, 0]);
}
public void MockTable_Int32_Test()
{
string content = "Col1 \n" +
"(int) \n" +
"123 ";
var table = MockTable.FromFixed(content);
Assert.AreEqual(typeof(int), table.Columns[0].Type);
Assert.AreEqual(123, table.Rows[0, 0]);
}
public void MockTable_FixedColumns_StringGuillemets_Test()
{
string content = "Col1 Col2 \n" +
"string int \n" +
"\" abc def \" ";
var table = MockTable.FromFixed(content);
Assert.AreEqual(" abc def ", table.Rows[0, 0]);
Assert.AreEqual(null, table.Rows[0, 1]);
}
public void UnitTest5()
{
var conn = new MockDbConnection();
conn.Mocks
.WhenTag("COUNT_EMPLOYEES")
.ReturnsTable(cmd => MockTable.SingleCell("Count", cmd.Parameters.Count()));
int count = GetNumberOfEmployees(conn);
Assert.AreEqual(0, count);
}
public void ImplicitLocalVariables()
{
var table1 =
new MockTable<Person>();
MockTable<Person> table2 =
new MockTable<Person>();
var table3 = GetPeople();
string test = "forty-two";
Assert.AreEqual<Type>(
typeof(string), test.GetType());
}
public void InitializeMockTable()
{
MockTable<TestEntity> table =
new MockTable<TestEntity>()
{
new TestEntity(42),
new TestEntity(140)
};
Assert.AreEqual<int>(2,
table.Count());
}
public void TestInitialize()
{
TestEntities = new MockTable<TestEntity>();
TestEntities.Add(new TestEntity(42), new TestEntity(43), new TestEntity(44),
new TestEntity(99), new TestEntity(0));
}
public void Select_TestEntity_To_Int()
{
TestEntities = new MockTable<TestEntity>();
TestEntities.Add(new TestEntity(42), new TestEntity(43), new TestEntity(44),
new TestEntity(99), new TestEntity(0) );
IEnumerable<int> returns = TestEntities.Select(item => item.EntityId);
}
public void Add_Existing_Fails()
{
MockTable<TestEntity> database = new MockTable<TestEntity>();
database.Add(new TestEntity(1234));
database.Add(new TestEntity(1234)); // throws exception
}
public void Find_Nonexistent_ReturnsNull()
{
MockTable<TestEntity> database = new MockTable<TestEntity>();
database.Add(new TestEntity(1234));
Assert.IsNull(database.Get(5678));
}
public void Exists_Success()
{
MockTable<TestEntity> database = new MockTable<TestEntity>();
database.Add(new TestEntity(1234));
Assert.IsTrue(database.Exists(1234));
}
public void Exists_Failure()
{
MockTable<TestEntity> database = new MockTable<TestEntity>();
database.Add(new TestEntity(1234));
Assert.IsFalse(database.Exists(5678));
}
public void Foreach_IterateOverItemsInTable()
{
MockTable<TestEntity> table = new MockTable<TestEntity>();
int counter = 0;
foreach (TestEntity entity in table)
{
counter++;
}
Assert.AreEqual<int>(0, counter);
}
