示例#1
0
        public async Task Read_By_Where_Condition()
        {
            using (IDbConnection connection = LocalDbTestHelper.OpenTestConnection(TestContext.CurrentContext.Test.FullName))
            {
                // Arrange
                await connection.Create(new City()
                {
                    CityCode = "PUP", CityName = "Portsmouth", Area = "Hampshire"
                });

                await connection.Create(new City()
                {
                    CityCode = "SOU", CityName = "Southampton", Area = "Hampshire"
                });

                await connection.Create(new City()
                {
                    CityCode = "BOU", CityName = "Bournemouth", Area = "Dorset"
                });

                IEnumerable <City> cities = await connection.ReadList <City>(new { Area = "Hampshire" });

                Assert.AreEqual(2, cities.Count());
            }
        }
        public async Task Insert_With_Composite_Key_Two_Assigned_And_One_Sequential()
        {
            using (IDbConnection connection = LocalDbTestHelper.OpenTestConnection(TestContext.CurrentContext.Test.FullName))
            {
                // Act
                AssignedPairAndSequential oneOneOne = await connection.Create(new AssignedPairAndSequential()
                {
                    FirstAssignedId = 1, SecondAssignedId = 1, Heading = "One"
                });

                AssignedPairAndSequential oneOneTwo = await connection.Create(new AssignedPairAndSequential()
                {
                    FirstAssignedId = 1, SecondAssignedId = 1, Heading = "Two"
                });

                AssignedPairAndSequential oneTwoOne = await connection.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);
            }
        }
示例#3
0
        public async Task Read_Paged_With_Where_Dictionary()
        {
            using (IDbConnection connection = LocalDbTestHelper.OpenTestConnection(TestContext.CurrentContext.Test.FullName))
            {
                // Arrange
                await connection.Create(new City()
                {
                    CityCode = "PUP", CityName = "Portsmouth", Area = "Hampshire"
                });

                await connection.Create(new City()
                {
                    CityCode = "SOU", CityName = "Southampton", Area = "Hampshire"
                });

                await connection.Create(new City()
                {
                    CityCode = "BAS", CityName = "Basingstoke", Area = "Hampshire"
                });

                await connection.Create(new City()
                {
                    CityCode = "WIN", CityName = "Winchester", Area = "Hampshire"
                });

                await connection.Create(new City()
                {
                    CityCode = "PTR", CityName = "Petersfield", Area = "Hampshire"
                });

                await connection.Create(new City()
                {
                    CityCode = "CHI", CityName = "Chichester", Area = "West Sussex"
                });

                await connection.Create(new City()
                {
                    CityCode = "BOG", CityName = "Bognor Regis", Area = "West Sussex"
                });

                await connection.Create(new City()
                {
                    CityCode = "BOU", CityName = "Bournemouth", Area = "Dorset"
                });

                // Act
                PagedList <City> pagedList = await connection.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 static IDataContext GetDataContext(Type dataContextType)
        {
            // check whether we are dealing with a type that implement IDataContext
            if (typeof(IDataContext).IsAssignableFrom(dataContextType) == false)
            {
                throw new ArgumentException($"Type {dataContextType.Name} does not implement IDataContext.");
            }

            // return the data context for the given type
            if (typeof(InMemoryDataContext).IsAssignableFrom(dataContextType))
            {
                return(new InMemoryDataContext());
            }
            else if (typeof(SqlServerDataContext).IsAssignableFrom(dataContextType))
            {
                // create the test database
                LocalDbTestHelper.CreateTestDatabase(TestContext.CurrentContext.Test.FullName);

                // return data context
                return(new SqlServerDataContext(LocalDbTestHelper.GetTestConnectionString(TestContext.CurrentContext.Test.FullName)));
            }
            else
            {
                throw new ArgumentException($"Type {dataContextType} is not supported, add support in {nameof(DataContextTestHelper)}.cs");
            }
        }
        public async Task Delete_List_Of_Entities()
        {
            using (IDbConnection connection = LocalDbTestHelper.OpenTestConnection(TestContext.CurrentContext.Test.FullName))
            {
                // Arrange
                await connection.Create <City>(new City()
                {
                    CityCode = "BAS", CityName = "Basingstoke", Area = "Hampshire"
                });

                await connection.Create <City>(new City()
                {
                    CityCode = "PUP", CityName = "Portsmouth", Area = "Hampshire"
                });

                await connection.Create <City>(new City()
                {
                    CityCode = "BOU", CityName = "Bournemouth", Area = "Dorset"
                });

                await connection.Create <City>(new City()
                {
                    CityCode = "HAV", CityName = "Havant", Area = "Hampshire"
                });

                // Act
                await connection.DeleteList <City>(new { Area = "Hampshire" });

                // Assert
                Assert.AreEqual(0, (await connection.ReadList <City>(new { Area = "Hampshire" })).Count());
                Assert.AreEqual(1, (await connection.ReadAll <City>()).Count());
            }
        }
        public async Task Delete_List_No_Conditions()
        {
            using (IDbConnection connection = LocalDbTestHelper.OpenTestConnection(TestContext.CurrentContext.Test.FullName))
            {
                // Arrange
                await connection.Create <City>(new City()
                {
                    CityCode = "BAS", CityName = "Basingstoke", Area = "Hampshire"
                });

                await connection.Create <City>(new City()
                {
                    CityCode = "PUP", CityName = "Portsmouth", Area = "Hampshire"
                });

                await connection.Create <City>(new City()
                {
                    CityCode = "BOU", CityName = "Bournemouth", Area = "Dorset"
                });

                await connection.Create <City>(new City()
                {
                    CityCode = "HAV", CityName = "Havant", Area = "Hampshire"
                });

                // Act / Assert
                Assert.ThrowsAsync <ArgumentException>(async() => { await connection.DeleteList <City>(null); });
                Assert.ThrowsAsync <ArgumentException>(async() => { await connection.DeleteList <City>(new object()); });
            }
        }
        public async Task Update_With_Datestamp()
        {
            using (IDbConnection connection = LocalDbTestHelper.OpenTestConnection(TestContext.CurrentContext.Test.FullName))
            {
                // Arrange
                DateStamp row = await connection.Create(new DateStamp()
                {
                    Name = "Key", Value = "Value"
                })
                                .ConfigureAwait(false);

                // sleep so that insert date and update date will be different when update called
                Thread.Sleep(TimeSpan.FromMilliseconds(100));

                // Act
                DateTime  updateDate = DateTime.Now;
                DateStamp updatedRow = await connection.Update <DateStamp>(new { row.Name, Value = "New Value" })
                                       .ConfigureAwait(false);

                // 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 Update_Editable_Properties()
        {
            using (IDbConnection connection = LocalDbTestHelper.OpenTestConnection(TestContext.CurrentContext.Test.FullName))
            {
                // Arrange
                City city = await connection.Create <City>(new City()
                {
                    CityCode = "BAS", CityName = "Basingstoke", Area = "Hampshire"
                });

                // Act
                City basVegas = await connection.Update <City>(new
                {
                    city.CityId,
                    CityCode = "BV",
                    CityName = "Bas Vegas!",
                    Area     = "The Strip"
                });

                Assert.AreEqual(city.CityId, basVegas.CityId);
                Assert.AreEqual("BV", basVegas.CityCode);
                Assert.AreEqual("The Strip", basVegas.Area);
                Assert.AreEqual("Bas Vegas!", basVegas.CityName);
            }
        }
示例#9
0
        public async Task Read_Paged_Last_Page()
        {
            using (IDbConnection connection = LocalDbTestHelper.OpenTestConnection(TestContext.CurrentContext.Test.FullName))
            {
                // Arrange - seed some data
                await connection.Create(new City()
                {
                    CityCode = "PUP", CityName = "Portsmouth", Area = "Hampshire"
                });

                await connection.Create(new City()
                {
                    CityCode = "SOU", CityName = "Southampton", Area = "Hampshire"
                });

                await connection.Create(new City()
                {
                    CityCode = "BAS", CityName = "Basingstoke", Area = "Hampshire"
                });

                await connection.Create(new City()
                {
                    CityCode = "WIN", CityName = "Winchester", Area = "Hampshire"
                });

                await connection.Create(new City()
                {
                    CityCode = "PTR", CityName = "Petersfield", Area = "Hampshire"
                });

                await connection.Create(new City()
                {
                    CityCode = "CHI", CityName = "Chichester", Area = "West Sussex"
                });

                await connection.Create(new City()
                {
                    CityCode = "BOG", CityName = "Bognor Regis", Area = "West Sussex"
                });

                await connection.Create(new City()
                {
                    CityCode = "BOU", CityName = "Bournemouth", Area = "Dorset"
                });

                // Arrange - read the first page to see how many pages there are
                int lastPage = (await connection.ReadList <City>(null, null, 3, 1)).TotalPages;

                // Act - read the last page
                PagedList <City> pagedList = await connection.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);
            }
        }
示例#10
0
        public async Task Read_Paged_With_Where_Dictionary_And_OrderBy_Dictionary()
        {
            using (IDbConnection connection = LocalDbTestHelper.OpenTestConnection(TestContext.CurrentContext.Test.FullName))
            {
                // Arrange
                await connection.Create(new City()
                {
                    CityCode = "PUP", CityName = "Portsmouth", Area = "Hampshire"
                });

                await connection.Create(new City()
                {
                    CityCode = "SOU", CityName = "Southampton", Area = "Hampshire"
                });

                await connection.Create(new City()
                {
                    CityCode = "BAS", CityName = "Basingstoke", Area = "Hampshire"
                });

                await connection.Create(new City()
                {
                    CityCode = "WIN", CityName = "Winchester", Area = "Hampshire"
                });

                await connection.Create(new City()
                {
                    CityCode = "PTR", CityName = "Petersfield", Area = "Hampshire"
                });

                await connection.Create(new City()
                {
                    CityCode = "CHI", CityName = "Chichester", Area = "West Sussex"
                });

                await connection.Create(new City()
                {
                    CityCode = "BOG", CityName = "Bognor Regis", Area = "West Sussex"
                });

                await connection.Create(new City()
                {
                    CityCode = "BOU", CityName = "Bournemouth", Area = "Dorset"
                });

                // Act
                PagedList <City> pagedList = await connection.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 static void DeleteDataContext(Type dataContextType)
 {
     // check whether we are dealing with a type that we need to dispose of
     if (typeof(SqlServerDataContext).IsAssignableFrom(dataContextType))
     {
         // create the test database
         LocalDbTestHelper.DeleteTestDatabase(TestContext.CurrentContext.Test.FullName);
     }
 }
示例#12
0
        public async Task Read_Paged_With_Invalid_OrderBy_Dictionary()
        {
            using (IDbConnection connection = LocalDbTestHelper.OpenTestConnection(TestContext.CurrentContext.Test.FullName))
            {
                // Arrange
                await connection.Create(new City()
                {
                    CityCode = "PUP", CityName = "Portsmouth", Area = "Hampshire"
                });

                await connection.Create(new City()
                {
                    CityCode = "SOU", CityName = "Southampton", Area = "Hampshire"
                });

                await connection.Create(new City()
                {
                    CityCode = "BAS", CityName = "Basingstoke", Area = "Hampshire"
                });

                await connection.Create(new City()
                {
                    CityCode = "WIN", CityName = "Winchester", Area = "Hampshire"
                });

                await connection.Create(new City()
                {
                    CityCode = "PTR", CityName = "Petersfield", Area = "Hampshire"
                });

                await connection.Create(new City()
                {
                    CityCode = "CHI", CityName = "Chichester", Area = "West Sussex"
                });

                await connection.Create(new City()
                {
                    CityCode = "BOG", CityName = "Bognor Regis", Area = "West Sussex"
                });

                await connection.Create(new City()
                {
                    CityCode = "BOU", CityName = "Bournemouth", Area = "Dorset"
                });

                // Act / Assert
                Assert.ThrowsAsync <ArgumentException>(async() =>
                {
                    await connection.ReadList <City>(null, new Dictionary <string, SortOrder> {
                        { "County", SortOrder.Descending }
                    }, 1, 1);
                });
            }
        }
        public async Task Insert_For_Soft_Delete()
        {
            using (IDbConnection connection = LocalDbTestHelper.OpenTestConnection(TestContext.CurrentContext.Test.FullName))
            {
                // Act
                SoftDelete softDelete = await connection.Create <SoftDelete>(new SoftDelete()).ConfigureAwait(false);

                // Assert
                Assert.Greater(softDelete.SoftDeleteId, 0);
                Assert.AreEqual(1, softDelete.RecordStatus);
            }
        }
        public async Task Update_Soft_Delete_Column()
        {
            using (IDbConnection connection = LocalDbTestHelper.OpenTestConnection(TestContext.CurrentContext.Test.FullName))
            {
                // Arrange
                SoftDelete softDelete = await connection.Create <SoftDelete>(new SoftDelete()).ConfigureAwait(false);

                // Act / Assert
                Assert.ThrowsAsync <ArgumentException>(async() =>
                {
                    await connection.Update <SoftDelete>(new { softDelete.SoftDeleteId, RecordsStatus = 999 });
                });
            }
        }
        public async Task Insert_With_Assigned_Key()
        {
            using (IDbConnection connection = LocalDbTestHelper.OpenTestConnection(TestContext.CurrentContext.Test.FullName))
            {
                // Act
                CityManual city = await connection.Create <CityManual>(new CityManual()
                {
                    CityCode = "BRI",
                    CityName = "Brighton"
                }).ConfigureAwait(false);

                // Assert
                Assert.AreEqual("BRI", city.CityCode);
                Assert.AreEqual("Brighton", city.CityName);
            }
        }
        public async Task Delete_Entity_Single_Typed_Argument()
        {
            using (IDbConnection connection = LocalDbTestHelper.OpenTestConnection(TestContext.CurrentContext.Test.FullName))
            {
                // Arrange
                City city = await connection.Create <City>(new City()
                {
                    CityCode = "BAS", CityName = "Basingstoke", Area = "Hampshire"
                });

                // Act
                await connection.Delete <City>(city.CityId);

                // Assert
                Assert.IsNull(await connection.Read <City>(new { city.CityId }));
            }
        }
        public async Task Insert_With_Identity()
        {
            using (IDbConnection connection = LocalDbTestHelper.OpenTestConnection(TestContext.CurrentContext.Test.FullName))
            {
                // Act
                City city = await connection.Create <City>(new City()
                {
                    CityCode = "BRI", CityName = "Brighton", Area = "Sussex"
                })
                            .ConfigureAwait(false);

                // 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()
        {
            using (IDbConnection connection = LocalDbTestHelper.OpenTestConnection(TestContext.CurrentContext.Test.FullName))
            {
                // Act
                DateTime  now = DateTime.Now;
                DateStamp row = await connection.Create(new DateStamp()
                {
                    Name = "Key", Value = "Value"
                })
                                .ConfigureAwait(false);

                // 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)));
            }
        }
示例#19
0
        public async Task Read_All_With_Assigned()
        {
            using (IDbConnection connection = LocalDbTestHelper.OpenTestConnection(TestContext.CurrentContext.Test.FullName))
            {
                // Arrange
                await connection.Create(new CityManual()
                {
                    CityCode = "PUP", CityName = "Portsmouth"
                });

                await connection.Create(new CityManual()
                {
                    CityCode = "NYC", CityName = "New York City"
                });

                // Act
                IEnumerable <CityManual> cities = await connection.ReadAll <CityManual>();

                // Assert
                Assert.AreEqual(2, cities.Count());
            }
        }
示例#20
0
        public async Task Read_By_Id_With_Assigned_Single_Typed_Argument()
        {
            using (IDbConnection connection = LocalDbTestHelper.OpenTestConnection(TestContext.CurrentContext.Test.FullName))
            {
                // Arrange
                await connection.Create(new CityManual()
                {
                    CityCode = "PUP", CityName = "Portsmouth"
                });

                await connection.Create(new CityManual()
                {
                    CityCode = "NYC", CityName = "New York City"
                });

                // Act
                CityManual city = await connection.Read <CityManual>("NYC");

                // Assert
                Assert.AreEqual("NYC", city.CityCode);
                Assert.AreEqual("New York City", city.CityName);
            }
        }
示例#21
0
        public async Task Read_All_With_Identity()
        {
            using (IDbConnection connection = LocalDbTestHelper.OpenTestConnection(TestContext.CurrentContext.Test.FullName))
            {
                // Arrange
                await connection.Create(new City()
                {
                    CityCode = "PUP", CityName = "Portsmouth", Area = "Hampshire"
                });

                await connection.Create(new City()
                {
                    CityCode = "BOU", CityName = "Bournemouth", Area = "Dorset"
                });

                // Act
                IEnumerable <City> cities = await connection.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 Update_Read_Only_Column()
        {
            using (IDbConnection connection = LocalDbTestHelper.OpenTestConnection(TestContext.CurrentContext.Test.FullName))
            {
                // Arrange
                ReadOnly readOnly = await connection.Create <ReadOnly>(new ReadOnly()
                {
                    Editable         = "Hello",
                    ReadOnlyProperty = "World"
                });

                // Act
                readOnly = await connection.Update <ReadOnly>(new
                {
                    readOnly.SequentialId,
                    Editable         = "Goodbye",
                    ReadOnlyProperty = "Yesterday"
                });

                // Assert
                Assert.AreEqual("Goodbye", readOnly.Editable);
                Assert.AreEqual("World", readOnly.ReadOnlyProperty);
            }
        }
示例#23
0
        public async Task Read_By_Id_With_Identity_Property_Bag()
        {
            using (IDbConnection connection = LocalDbTestHelper.OpenTestConnection(TestContext.CurrentContext.Test.FullName))
            {
                // Arrange
                City pup = await connection.Create(new City()
                {
                    CityCode = "PUP", CityName = "Portsmouth", Area = "Hampshire"
                });

                await connection.Create(new City()
                {
                    CityCode = "NYC", CityName = "New York City", Area = "New York"
                });

                // Act
                City city = await connection.Read <City>(new { pup.CityId });

                // Assert
                Assert.AreEqual(pup.CityId, city.CityId);
                Assert.AreEqual("PUP", city.CityCode);
                Assert.AreEqual("Portsmouth", city.CityName);
            }
        }
 public void TearDown()
 {
     LocalDbTestHelper.DeleteTestDatabase(TestContext.CurrentContext.Test.FullName);
 }
 public void Setup()
 {
     LocalDbTestHelper.CreateTestDatabase(TestContext.CurrentContext.Test.FullName);
 }