public void GetItemsViaStoredProcedureWithParameterNotParameterisedTest()
        {
            //Given
            var databseFactory =
                new EfCoreDatabaseFactoryBase <SharedLibraryContext>("SharedLibraryContext");

            using (var efCoreUnitOfWork = new EfCoreUnitOfWork <SharedLibraryContext>(databseFactory))
            {
                var repository  = new EfCoreAccountRepository(databseFactory);
                var reference   = "TestReference";
                var listOfItems = GetItemsWithTwoItemsContainingTestReference(reference);
                repository.AddRange(listOfItems);
                efCoreUnitOfWork.Commit();

                //When
                var filter = new SqlParameter("@CompanyName", SqlDbType.VarChar)
                {
                    Value = $"%{reference}%"
                };
                var items = repository.ExecuteQuery <Account>("exec GetAccounts @CompanyName", filter).ToList();

                //Then
                EqualityHelper.AssertListsAreEqual(items.OrderBy(x => x.CompanyName).ToList(), listOfItems.OrderBy(x => x.CompanyName).Take(2).ToList(), new[] { "AccountID", "LastModified", "LastModifiedBy", "Contacts" });
            }
        }
        public void GetAllSuccessTest()
        {
            //Given
            var databseFactory =
                new EfCoreDatabaseFactoryBase <SharedLibraryContext>("SharedLibraryContext");

            using (var efCoreUnitOfWork = new EfCoreUnitOfWork <SharedLibraryContext>(databseFactory))
            {
                var repository  = new EfCoreAccountRepository(databseFactory);
                var listOfItems = AccountEntityHelper.CreateEfCoreTestAccounts(3);
                listOfItems[0].CompanyName = "1";
                listOfItems[1].CompanyName = "2";
                listOfItems[2].CompanyName = "3";

                repository.AddRange(listOfItems);
                efCoreUnitOfWork.Commit();

                //When
                var allItems = repository.GetAll();

                //Then
                EqualityHelper.AssertListsAreEqual(allItems.OrderBy(x => x.CompanyName).ToList(), listOfItems.OrderBy(x => x.CompanyName).ToList(),
                                                   new[] { "AccountID", "LastModified", "LastModifiedBy", "Contacts" });
            }
        }
        public async Task AddListOfItemsTestAsync()
        {
            //Given
            var repository    = new EfCoreAsyncAccountRepository(_databaseFactory);
            var listOfItems   = AccountEntityHelper.CreateEfCoreTestAccounts(3);
            var originalItems = await repository.GetAllAsync().ConfigureAwait(true);

            //When
            await repository.AddRangeAsync(listOfItems).ConfigureAwait(true);

            //Then
            var allNewItems = await repository.GetAllAsync().ConfigureAwait(true);

            var itemsAdded = allNewItems.Except(originalItems).ToList();

            EqualityHelper.AssertListsAreEqual(itemsAdded, listOfItems,
                                               new[] { "AccountID", "LastModified", "Contacts" });
        }
        public async Task GetAsyncItemsViaStoredProcedureWithNoParameterNotParameterisedTestAsync()
        {
            //Given
            using (var efCoreAsyncUnitOfWork = new EfCoreAsyncUnitOfWork <SharedLibraryContext>(_databaseFactory))
            {
                var repository  = new EfCoreAsyncAccountRepository(_databaseFactory);
                var listOfItems = AccountEntityHelper.CreateEfCoreTestAccounts(3);
                await repository.AddRangeAsync(listOfItems).ConfigureAwait(true);

                await efCoreAsyncUnitOfWork.CommitAsync().ConfigureAwait(true);

                //When
                var items = await repository.ExecuteQueryAsync <Account>("exec GetAccounts").ConfigureAwait(true);

                //Then
                EqualityHelper.AssertListsAreEqual(items.OrderBy(x => x.CompanyName).ToList(), listOfItems.OrderBy(x => x.CompanyName).ToList(), new[] { "AccountID", "LastModified", "LastModifiedBy", "Contacts" });
            }
        }
        public void AddListOfItemsTest()
        {
            //Given
            var databseFactory =
                new EfCoreDatabaseFactoryBase <SharedLibraryContext>("SharedLibraryContext");
            var repository    = new EfCoreAccountRepository(databseFactory);
            var listOfItems   = AccountEntityHelper.CreateEfCoreTestAccounts(3);
            var originalItems = repository.GetAll();

            //When
            repository.AddRange(listOfItems);

            //Then
            var allNewItems = repository.GetAll();
            var itemsAdded  = allNewItems.Except(originalItems).ToList();

            EqualityHelper.AssertListsAreEqual(itemsAdded, listOfItems,
                                               new[] { "AccountID", "LastModified", "Contacts" });
        }
        public async Task GetAsyncMAnyAsyncWithWhereClauseSuccessTestAsync()
        {
            //Given
            using (var efCoreAsyncUnitOfWork = new EfCoreAsyncUnitOfWork <SharedLibraryContext>(_databaseFactory))
            {
                var repository  = new EfCoreAsyncAccountRepository(_databaseFactory);
                var reference   = "TestReference";
                var listOfItems = GetAsyncItemsWithTwoItemsContainingTestReference(reference);
                await repository.AddRangeAsync(listOfItems).ConfigureAwait(true);

                await efCoreAsyncUnitOfWork.CommitAsync().ConfigureAwait(true);

                //When
                var items = await repository.GetManyAsync(x => x.CompanyName.Contains(reference)).ConfigureAwait(true);

                //Then
                EqualityHelper.AssertListsAreEqual(items.OrderBy(x => x.CompanyName).ToList(), listOfItems.OrderBy(x => x.CompanyName).Take(2).ToList(), new[] { "AccountID", "LastModified", "LastModifiedBy", "Contacts" });
            }
        }
        public void GetItemsViaStoredProcedureWithNoParameterNotParameterisedTest()
        {
            //Given
            var databseFactory =
                new EfCoreDatabaseFactoryBase <SharedLibraryContext>("SharedLibraryContext");

            using (var efCoreUnitOfWork = new EfCoreUnitOfWork <SharedLibraryContext>(databseFactory))
            {
                var repository  = new EfCoreAccountRepository(databseFactory);
                var listOfItems = AccountEntityHelper.CreateEfCoreTestAccounts(3);
                repository.AddRange(listOfItems);
                efCoreUnitOfWork.Commit();

                //When
                var items = repository.ExecuteQuery <Account>("exec GetAccounts").ToList();

                //Then
                EqualityHelper.AssertListsAreEqual(items.OrderBy(x => x.CompanyName).ToList(), listOfItems.OrderBy(x => x.CompanyName).ToList(), new[] { "AccountID", "LastModified", "LastModifiedBy", "Contacts" });
            }
        }
        public void GetManyWithWhereClauseSuccessTest()
        {
            //Given
            var databseFactory =
                new EfCoreDatabaseFactoryBase <SharedLibraryContext>("SharedLibraryContext");

            using (var efCoreUnitOfWork = new EfCoreUnitOfWork <SharedLibraryContext>(databseFactory))
            {
                var repository  = new EfCoreAccountRepository(databseFactory);
                var reference   = "TestReference";
                var listOfItems = GetItemsWithTwoItemsContainingTestReference(reference);
                repository.AddRange(listOfItems);
                efCoreUnitOfWork.Commit();

                //When
                var items = repository.GetMany(x => x.CompanyName.Contains(reference));

                //Then
                EqualityHelper.AssertListsAreEqual(items.OrderBy(x => x.CompanyName).ToList(), listOfItems.OrderBy(x => x.CompanyName).Take(2).ToList(), new[] { "AccountID", "LastModified", "LastModifiedBy", "Contacts" });
            }
        }
        public async Task GetAsyncItemsViaStoredProcedureWithParameterTestAsync()
        {
            //Given
            using (var efCoreAsyncUnitOfWork = new EfCoreAsyncUnitOfWork <SharedLibraryContext>(_databaseFactory))
            {
                var repository  = new EfCoreAsyncAccountRepository(_databaseFactory);
                var reference   = "TestReference";
                var listOfItems = GetAsyncItemsWithTwoItemsContainingTestReference(reference);
                await repository.AddRangeAsync(listOfItems).ConfigureAwait(true);

                await efCoreAsyncUnitOfWork.CommitAsync().ConfigureAwait(true);

                //When
                var filter = new SqlParameter("@CompanyName", SqlDbType.VarChar)
                {
                    Value = $"%{reference}%"
                };
                var items = await repository.ExecuteQueryAsync("exec GetAccounts @CompanyName", filter).ConfigureAwait(true);

                //Then
                EqualityHelper.AssertListsAreEqual(items.OrderBy(x => x.CompanyName).ToList(), listOfItems.OrderBy(x => x.CompanyName).Take(2).ToList(), new[] { "AccountID", "LastModified", "LastModifiedBy", "Contacts" });
            }
        }
        public async Task GetAllAsyncSuccessTestAsync()
        {
            //Given
            using (var efCoreAsyncUnitOfWork = new EfCoreAsyncUnitOfWork <SharedLibraryContext>(_databaseFactory))
            {
                var repository  = new EfCoreAsyncAccountRepository(_databaseFactory);
                var listOfItems = AccountEntityHelper.CreateEfCoreTestAccounts(3);
                listOfItems[0].CompanyName = "1";
                listOfItems[1].CompanyName = "2";
                listOfItems[2].CompanyName = "3";

                await repository.AddRangeAsync(listOfItems).ConfigureAwait(true);

                await efCoreAsyncUnitOfWork.CommitAsync().ConfigureAwait(true);

                //When
                var allItems = await repository.GetAllAsync().ConfigureAwait(true);

                //Then
                EqualityHelper.AssertListsAreEqual(allItems.OrderBy(x => x.CompanyName).ToList(), listOfItems.OrderBy(x => x.CompanyName).ToList(),
                                                   new[] { "AccountID", "LastModified", "LastModifiedBy", "Contacts" });
            }
        }