public async Task Read_By_Where_Condition(Type dataContextType)
{
// Arrange
IDataContext dataContext = DataContextTestHelper.GetDataContext(dataContextType);
await dataContext.Create(new City()
{
CityCode = "PUP", CityName = "Portsmouth", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "SOU", CityName = "Southampton", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "BOU", CityName = "Bournemouth", Area = "Dorset"
});
// Act
IEnumerable <City> cities = await dataContext.ReadList <City>(new { Area = "Hampshire" });
// Assert
// NOTE: there is only one team in Hampshire
Assert.AreEqual(2, cities.Count());
}
public async Task Insert_With_Composite_Key_Two_Assigned_And_One_Sequential(Type dataContextType)
{
// Arrange
IDataContext dataContext = DataContextTestHelper.GetDataContext(dataContextType);
// Act
AssignedPairAndSequential oneOneOne = await dataContext.Create(new AssignedPairAndSequential()
{
FirstAssignedId = 1, SecondAssignedId = 1, Heading = "One"
});
AssignedPairAndSequential oneOneTwo = await dataContext.Create(new AssignedPairAndSequential()
{
FirstAssignedId = 1, SecondAssignedId = 1, Heading = "Two"
});
AssignedPairAndSequential oneTwoOne = await dataContext.Create(new AssignedPairAndSequential()
{
FirstAssignedId = 1, SecondAssignedId = 2, Heading = "One"
});
// Assert
Assert.AreEqual(1, oneOneOne.SequentialId);
Assert.AreEqual(2, oneOneTwo.SequentialId);
Assert.AreEqual(1, oneTwoOne.SequentialId);
}
public async Task Update_With_Datestamp(Type dataContextType)
{
// Arrange
IDataContext dataContext = DataContextTestHelper.GetDataContext(dataContextType);
// insert row
DateStamp row = await dataContext.Create(new DateStamp()
{
Name = "Key", Value = "Value"
});
// sleep so that insert date and update date will be different when update called
Thread.Sleep(TimeSpan.FromMilliseconds(1000));
// Act
DateTime updateDate = DateTime.Now;
DateStamp updatedRow = await dataContext.Update <DateStamp>(new { row.Name, Value = "New Value" });
// Assert
Assert.AreEqual(row.Name, updatedRow.Name);
Assert.AreEqual("New Value", updatedRow.Value);
Assert.AreEqual(0, (row.InsertDate - updatedRow.InsertDate).Seconds);
Assert.AreNotEqual(row.InsertDate, updatedRow.UpdateDate);
Assert.That(updatedRow.UpdateDate, Is.EqualTo(updateDate).Within(TimeSpan.FromSeconds(1)));
}
public async Task Delete_List_No_Conditions(Type dataContextType)
{
// Arrange
IDataContext dataContext = DataContextTestHelper.GetDataContext(dataContextType);
await dataContext.Create <City>(new City()
{
CityCode = "BAS", CityName = "Basingstoke", Area = "Hampshire"
});
await dataContext.Create <City>(new City()
{
CityCode = "PUP", CityName = "Portsmouth", Area = "Hampshire"
});
await dataContext.Create <City>(new City()
{
CityCode = "BOU", CityName = "Bournemouth", Area = "Dorset"
});
await dataContext.Create <City>(new City()
{
CityCode = "HAV", CityName = "Havant", Area = "Hampshire"
});
// Act / Assert
Assert.ThrowsAsync <ArgumentException>(async() => { await dataContext.DeleteList <City>(null); });
Assert.ThrowsAsync <ArgumentException>(async() => { await dataContext.DeleteList <City>(new object()); });
}
public async Task Delete_List_Of_Entities(Type dataContextType)
{
// Arrange
IDataContext dataContext = DataContextTestHelper.GetDataContext(dataContextType);
await dataContext.Create <City>(new City()
{
CityCode = "BAS", CityName = "Basingstoke", Area = "Hampshire"
});
await dataContext.Create <City>(new City()
{
CityCode = "PUP", CityName = "Portsmouth", Area = "Hampshire"
});
await dataContext.Create <City>(new City()
{
CityCode = "BOU", CityName = "Bournemouth", Area = "Dorset"
});
await dataContext.Create <City>(new City()
{
CityCode = "HAV", CityName = "Havant", Area = "Hampshire"
});
// Act
await dataContext.DeleteList <City>(new { Area = "Hampshire" });
// Assert
Assert.AreEqual(0, (await dataContext.ReadList <City>(new { Area = "Hampshire" })).Count());
Assert.AreEqual(1, (await dataContext.ReadAll <City>()).Count());
}
public async Task Read_Paged_With_Where_Dictionary(Type dataContextType)
{
// Arrange
IDataContext dataContext = DataContextTestHelper.GetDataContext(dataContextType);
await dataContext.Create(new City()
{
CityCode = "PUP", CityName = "Portsmouth", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "SOU", CityName = "Southampton", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "BAS", CityName = "Basingstoke", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "WIN", CityName = "Winchester", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "PTR", CityName = "Petersfield", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "CHI", CityName = "Chichester", Area = "West Sussex"
});
await dataContext.Create(new City()
{
CityCode = "BOG", CityName = "Bognor Regis", Area = "West Sussex"
});
await dataContext.Create(new City()
{
CityCode = "BOU", CityName = "Bournemouth", Area = "Dorset"
});
// Act
PagedList <City> pagedList = await dataContext.ReadList <City>(
new Dictionary <string, object>() { { "Area", "Hampshire" } },
null,
4,
1);
// Assert
Assert.AreEqual(4, pagedList.Rows.Count());
Assert.AreEqual(false, pagedList.HasPrevious);
Assert.AreEqual(true, pagedList.HasNext);
Assert.AreEqual(2, pagedList.TotalPages);
Assert.AreEqual(5, pagedList.TotalRows);
}
public async Task Read_Paged_Last_Page(Type dataContextType)
{
// Arrange
IDataContext dataContext = DataContextTestHelper.GetDataContext(dataContextType);
await dataContext.Create(new City()
{
CityCode = "PUP", CityName = "Portsmouth", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "SOU", CityName = "Southampton", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "BAS", CityName = "Basingstoke", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "WIN", CityName = "Winchester", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "PTR", CityName = "Petersfield", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "CHI", CityName = "Chichester", Area = "West Sussex"
});
await dataContext.Create(new City()
{
CityCode = "BOG", CityName = "Bognor Regis", Area = "West Sussex"
});
await dataContext.Create(new City()
{
CityCode = "BOU", CityName = "Bournemouth", Area = "Dorset"
});
// Arrange - read the first page to see how many pages there are
int lastPage = (await dataContext.ReadList <City>(null, null, 3, 1)).TotalPages;
// Act - read the last page
PagedList <City> pagedList = await dataContext.ReadList <City>(null, null, 3, lastPage);
// Assert
Assert.AreEqual(pagedList.TotalRows - ((lastPage - 1) * 3), pagedList.Rows.Count());
Assert.AreEqual(true, pagedList.HasPrevious);
Assert.AreEqual(false, pagedList.HasNext);
Assert.AreEqual(lastPage, pagedList.TotalPages);
}
public async Task Read_Paged_With_Where_Dictionary_And_OrderBy_Dictionary(Type dataContextType)
{
// Arrange
IDataContext dataContext = DataContextTestHelper.GetDataContext(dataContextType);
await dataContext.Create(new City()
{
CityCode = "PUP", CityName = "Portsmouth", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "SOU", CityName = "Southampton", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "BAS", CityName = "Basingstoke", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "WIN", CityName = "Winchester", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "PTR", CityName = "Petersfield", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "CHI", CityName = "Chichester", Area = "West Sussex"
});
await dataContext.Create(new City()
{
CityCode = "BOG", CityName = "Bognor Regis", Area = "West Sussex"
});
await dataContext.Create(new City()
{
CityCode = "BOU", CityName = "Bournemouth", Area = "Dorset"
});
// Act
PagedList <City> pagedList = await dataContext.ReadList <City>(
new Dictionary <string, object>() { { "Area", "Hampshire" } },
new Dictionary <string, SortOrder>() { { "CityName", SortOrder.Descending } },
5,
1);
// Assert
string[] expectedOrder = { "Winchester", "Southampton", "Portsmouth", "Petersfield", "Basingstoke" };
Assert.IsTrue(pagedList.Rows.Select(x => x.CityName).SequenceEqual(expectedOrder));
}
public async Task Read_Paged_Neither_First_Or_Last_Page(Type dataContextType)
{
// Arrange
IDataContext dataContext = DataContextTestHelper.GetDataContext(dataContextType);
await dataContext.Create(new City()
{
CityCode = "PUP", CityName = "Portsmouth", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "SOU", CityName = "Southampton", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "BAS", CityName = "Basingstoke", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "WIN", CityName = "Winchester", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "PTR", CityName = "Petersfield", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "CHI", CityName = "Chichester", Area = "West Sussex"
});
await dataContext.Create(new City()
{
CityCode = "BOG", CityName = "Bognor Regis", Area = "West Sussex"
});
await dataContext.Create(new City()
{
CityCode = "BOU", CityName = "Bournemouth", Area = "Dorset"
});
// Act
PagedList <City> pagedList = await dataContext.ReadList <City>(null, null, 2, 2);
// Assert
Assert.AreEqual(2, pagedList.Rows.Count());
Assert.AreEqual(true, pagedList.HasPrevious);
Assert.AreEqual(true, pagedList.HasNext);
Assert.AreEqual(4, pagedList.TotalPages);
Assert.AreEqual(8, pagedList.TotalRows);
}
public async Task Insert_With_Soft_Delete(Type dataContextType)
{
// Arrange
IDataContext dataContext = DataContextTestHelper.GetDataContext(dataContextType);
// Act
SoftDelete softDelete = await dataContext.Create <SoftDelete>(new SoftDelete()).ConfigureAwait(false);
// Assert
Assert.Greater(softDelete.SoftDeleteId, 0);
Assert.AreEqual(1, softDelete.RecordStatus);
}
public async Task Update_Soft_Delete_Column(Type dataContextType)
{
// Arrange
IDataContext dataContext = DataContextTestHelper.GetDataContext(dataContextType);
SoftDelete softDelete = await dataContext.Create <SoftDelete>(new SoftDelete());
// Act / Assert
Assert.ThrowsAsync <ArgumentException>(async() =>
{
await dataContext.Update <SoftDelete>(new { softDelete.SoftDeleteId, RecordStatus = 999 });
});
}
public async Task Read_Paged_With_Invalid_OrderBy_Dictionary(Type dataContextType)
{
// Arrange
IDataContext dataContext = DataContextTestHelper.GetDataContext(dataContextType);
await dataContext.Create(new City()
{
CityCode = "PUP", CityName = "Portsmouth", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "SOU", CityName = "Southampton", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "BAS", CityName = "Basingstoke", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "WIN", CityName = "Winchester", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "PTR", CityName = "Petersfield", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "CHI", CityName = "Chichester", Area = "West Sussex"
});
await dataContext.Create(new City()
{
CityCode = "BOG", CityName = "Bognor Regis", Area = "West Sussex"
});
await dataContext.Create(new City()
{
CityCode = "BOU", CityName = "Bournemouth", Area = "Dorset"
});
// Act / Assert
Assert.ThrowsAsync <ArgumentException>(async() =>
{
await dataContext.ReadList <City>(null, new Dictionary <string, SortOrder> {
{ "County", SortOrder.Descending }
}, 1, 1);
});
}
public async Task Delete_Entity_Single_Typed_Argument(Type dataContextType)
{
// Arrange
IDataContext dataContext = DataContextTestHelper.GetDataContext(dataContextType);
City city = await dataContext.Create <City>(new City()
{
CityCode = "BAS", CityName = "Basingstoke", Area = "Hampshire"
});
// Act
await dataContext.Delete <City>(city.CityId);
// Assert
Assert.IsNull(await dataContext.Read <City>(new { city.CityId }));
}
public async Task Insert_With_Assigned_Key(Type dataContextType)
{
// Arrange
IDataContext dataContext = DataContextTestHelper.GetDataContext(dataContextType);
// Act
CityManual city = await dataContext.Create(new CityManual()
{
CityCode = "BRI", CityName = "Brighton"
});
// Assert
Assert.AreEqual("BRI", city.CityCode);
Assert.AreEqual("Brighton", city.CityName);
}
public async Task Insert_With_Identity(Type dataContextType)
{
// Arrange
IDataContext dataContext = DataContextTestHelper.GetDataContext(dataContextType);
// Act
City city = await dataContext.Create(new City()
{
CityCode = "BRI", CityName = "Brighton", Area = "Sussex"
});
// Assert
Assert.Greater(city.CityId, 0);
Assert.AreEqual("BRI", city.CityCode);
Assert.AreEqual("Brighton", city.CityName);
Assert.AreEqual("Sussex", city.Area);
}
public async Task Insert_With_Datestamp(Type dataContextType)
{
// Arrange
IDataContext dataContext = DataContextTestHelper.GetDataContext(dataContextType);
// Act
DateTime now = DateTime.Now;
DateStamp row = await dataContext.Create(new DateStamp()
{
Name = "Key", Value = "Value"
});
// Assert
Assert.AreEqual("Key", row.Name);
Assert.AreEqual("Value", row.Value);
Assert.AreEqual(row.InsertDate, row.UpdateDate);
Assert.That(row.InsertDate, Is.EqualTo(now).Within(TimeSpan.FromSeconds(1)));
}
public async Task Update_Editable_Property(Type dataContextType)
{
// Arrange
IDataContext dataContext = DataContextTestHelper.GetDataContext(dataContextType);
City city = await dataContext.Create <City>(new City()
{
CityCode = "BAS", CityName = "Basingstoke", Area = "Hampshire"
});
// Act
City basVegas = await dataContext.Update <City>(new { city.CityId, CityName = "Bas Vegas!" });
// Assert
Assert.AreEqual(city.CityId, basVegas.CityId);
Assert.AreEqual(city.CityCode, basVegas.CityCode);
Assert.AreEqual(city.Area, basVegas.Area);
Assert.AreEqual("Bas Vegas!", basVegas.CityName);
}
public async Task Read_All_With_Assigned(Type dataContextType)
{
// Arrange
IDataContext dataContext = DataContextTestHelper.GetDataContext(dataContextType);
await dataContext.Create(new CityManual()
{
CityCode = "PUP", CityName = "Portsmouth"
});
await dataContext.Create(new CityManual()
{
CityCode = "NYC", CityName = "New York City"
});
// Act
IEnumerable <CityManual> cities = dataContext.ReadAll <CityManual>().GetAwaiter().GetResult();
// Assert
Assert.AreEqual(2, cities.Count());
}
public async Task Read_By_Id_With_Assigned_Single_Typed_Argument(Type dataContextType)
{
// Arrange
IDataContext dataContext = DataContextTestHelper.GetDataContext(dataContextType);
await dataContext.Create(new CityManual()
{
CityCode = "PUP", CityName = "Portsmouth"
});
await dataContext.Create(new CityManual()
{
CityCode = "NYC", CityName = "New York City"
});
// Act
CityManual city = await dataContext.Read <CityManual>("NYC");
// Assert
Assert.AreEqual("NYC", city.CityCode);
Assert.AreEqual("New York City", city.CityName);
}
public async Task Read_All_With_Identity(Type dataContextType)
{
// Arrange
IDataContext dataContext = DataContextTestHelper.GetDataContext(dataContextType);
await dataContext.Create(new City()
{
CityCode = "PUP", CityName = "Portsmouth", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "BOU", CityName = "Bournemouth", Area = "Dorset"
});
// Act
IEnumerable <City> cities = await dataContext.ReadAll <City>();
// Assert
Assert.AreEqual(2, cities.Count());
Assert.Greater(cities.ElementAt(0).CityId, 0);
Assert.Greater(cities.ElementAt(1).CityId, cities.ElementAt(0).CityId);
}
public async Task Read_By_Id_With_Identity_Property_Bag(Type dataContextType)
{
// Arrange
IDataContext dataContext = DataContextTestHelper.GetDataContext(dataContextType);
City pup = await dataContext.Create(new City()
{
CityCode = "PUP", CityName = "Portsmouth", Area = "Hampshire"
});
await dataContext.Create(new City()
{
CityCode = "NYC", CityName = "New York City", Area = "New York"
});
// Act
City city = await dataContext.Read <City>(new { pup.CityId });
// Assert
Assert.AreEqual(pup.CityId, city.CityId);
Assert.AreEqual("PUP", city.CityCode);
Assert.AreEqual("Portsmouth", city.CityName);
}
public async Task Update_Read_Only_Column(Type dataContextType)
{
// Arrange
IDataContext dataContext = DataContextTestHelper.GetDataContext(dataContextType);
ReadOnly readOnly = await dataContext.Create <ReadOnly>(new ReadOnly()
{
Editable = "Hello",
ReadOnlyProperty = "World"
});
// Act
readOnly = await dataContext.Update <ReadOnly>(new
{
readOnly.SequentialId,
Editable = "Goodbye",
ReadOnlyProperty = "Yesterday"
});
// Assert
Assert.AreEqual("Goodbye", readOnly.Editable);
Assert.AreEqual("World", readOnly.ReadOnlyProperty);
}
public void TearDown()
{
Type type = (Type)TestContext.CurrentContext.Test.Arguments[0];
DataContextTestHelper.DeleteDataContext(type);
}
