public void ThrowArgumentException_IfEfRepositoyryIsNull()
        {
            EfGenericRepository <User> carRepo = null;

            Assert.Throws <ArgumentException>(() => new UsersService(carRepo));
            Assert.IsNull(carRepo);
        }
Example #2
0
        public void RepositoryGetById()
        {
            //arrange
            var connection = DbConnectionFactory.CreateTransient();
            var stubDB     = new GroceryStoreContext(connection);
            var userRepo   = new EfGenericRepository <User>(stubDB);

            var userToAdd = new User
            {
                FirstName   = "Pesho",
                LastName    = "Pesho",
                Username    = "******",
                Password    = "******",
                PhoneNumber = "Pesho"
            };

            userRepo.Add(userToAdd);
            stubDB.SaveChanges();

            //act
            var actual = userRepo.GetById(1);

            //assert
            Assert.AreEqual(userToAdd.Username, actual.Username);
        }
        public void ThrowArgumentNullExceptionWhenPassedEntityIsNull()
        {
            //Arrange
            var pages = new List <Page>
            {
                new Page()
                {
                    Id = Guid.NewGuid(), Title = "page", Content = "cntnt"
                },
                new Page()
                {
                    Id = Guid.NewGuid(), Title = "page", Content = "cntnt"
                }
            };
            var mockedDbContext = new Mock <ISotnWikiDbContext>();
            var mockedPageSet   = QueryableDbSetMock.GetQueryableMockDbSet <Page>(pages);

            mockedDbContext.Setup(c => c.Set <Page>()).Returns(mockedPageSet);
            mockedDbContext.Setup(c => c.Pages).Returns(mockedPageSet);
            string expectedExceptionMessage = "entity";

            var repositoryUnderTest = new EfGenericRepository <Page>(mockedDbContext.Object);

            //Act & Assert
            var exc = Assert.Throws <ArgumentNullException>(() => repositoryUnderTest.Add(null));

            //Assert
            StringAssert.Contains(expectedExceptionMessage, exc.Message);
        }
        public ArtistController()
        {
            var db = new ArtistsDbContext();

            this.artistData  = new EfGenericRepository <Artist>(db);
            this.countryData = new EfGenericRepository <Country>(db);
        }
Example #5
0
        public void RepositoryUpdate()
        {
            //arrange
            var connection = DbConnectionFactory.CreateTransient();
            var stubDB     = new GroceryStoreContext(connection);
            var userRepo   = new EfGenericRepository <User>(stubDB);

            var user = new User
            {
                FirstName   = "Pesho",
                LastName    = "Pesho",
                Username    = "******",
                Password    = "******",
                PhoneNumber = "Pesho"
            };

            userRepo.Add(user);
            stubDB.SaveChanges();

            //act
            user.Password = "******";
            userRepo.Update(user);

            string actual = userRepo.GetById(1).Password;

            //assert
            Assert.AreEqual("newPassword", actual);
        }
Example #6
0
        public void Delete_ShouldDeleteItemFromCollection()
        {
            // Arrange
            var item1           = new Item();
            var item2           = new Item();
            var item3           = new Item();
            var itemsCollection = new List <Item>();

            this.itemsDbSet.Setup(i => i.Add(It.IsAny <Item>()))
            .Callback <Item>(i => itemsCollection.Add(i));

            this.itemsDbSet.Setup(i => i.Remove(It.IsAny <Item>()))
            .Callback <Item>(i => itemsCollection.Remove(i));

            this.context.Setup(c => c.Set <Item>()).Returns(this.itemsDbSet.Object);

            this.repo = new EfGenericRepository <Item>(this.context.Object);

            // Act
            this.repo.Add(item1);
            this.repo.Add(item2);
            this.repo.Add(item3);

            this.repo.Delete(item2);

            // Assert
            Assert.AreEqual(item1, itemsCollection[0]);
            Assert.AreEqual(item3, itemsCollection[1]);
        }
        public static void Main()
        {
            Database.SetInitializer(new MigrateDatabaseToLatestVersion<ErisSystemContext, Data.Migrations.EfConfiguration>());

            Importer.ImportCountries();

            var db = new ErisSystemContext();

            var date = new DateTime(1991, 01, 01);

            var country = db.Countries.Find(3);

            var hitman = new User();
            hitman.AboutMe = "Thug life";
            hitman.UserName = "******";
            hitman.PasswordHash = "ASFADSFDEFE@#@$@$@ASDFAS";
            hitman.DateOfBirth = date;
            hitman.CountriesOfOperation.Add(country);

            db.Users.AddOrUpdate(hitman);
            db.SaveChanges();

            var repositoryTest = new EfGenericRepository<User>(db);

            var hitmen = repositoryTest.All();

            foreach (var x in hitmen)
            {
                Console.WriteLine(x.UserName);
                Console.WriteLine(x.Gender);
                Console.WriteLine(x.AboutMe);
                Console.WriteLine(x.DateOfBirth);
            }
        }
Example #8
0
        public void Add_ShouldAddItemToCollection_CaseManyObjects()
        {
            // Arrange
            var item1           = new Item();
            var item2           = new Item();
            var item3           = new Item();
            var itemsCollection = new List <Item>();

            this.itemsDbSet.Setup(i => i.Add(It.IsAny <Item>()))
            .Callback <Item>(i => itemsCollection.Add(i));

            this.context.Setup(c => c.Set <Item>()).Returns(this.itemsDbSet.Object);

            this.repo = new EfGenericRepository <Item>(this.context.Object);

            // Act
            this.repo.Add(item1);
            this.repo.Add(item2);
            this.repo.Add(item3);

            // Assert
            Assert.AreEqual(item1, itemsCollection[0]);
            Assert.AreEqual(item2, itemsCollection[1]);
            Assert.AreEqual(item3, itemsCollection[2]);
        }
Example #9
0
        public static void Main()
        {
            Database.SetInitializer(new MigrateDatabaseToLatestVersion <ErisSystemContext, Data.Migrations.EfConfiguration>());

            Importer.ImportCountries();

            var db = new ErisSystemContext();

            var date = new DateTime(1991, 01, 01);

            var country = db.Countries.Find(3);

            var hitman = new User();

            hitman.AboutMe      = "Thug life";
            hitman.UserName     = "******";
            hitman.PasswordHash = "ASFADSFDEFE@#@$@$@ASDFAS";
            hitman.DateOfBirth  = date;
            hitman.CountriesOfOperation.Add(country);

            db.Users.AddOrUpdate(hitman);
            db.SaveChanges();

            var repositoryTest = new EfGenericRepository <User>(db);

            var hitmen = repositoryTest.All();

            foreach (var x in hitmen)
            {
                Console.WriteLine(x.UserName);
                Console.WriteLine(x.Gender);
                Console.WriteLine(x.AboutMe);
                Console.WriteLine(x.DateOfBirth);
            }
        }
        public void EfGenericRepository_ShouldCreateUserIRepository_WhenThePassedParametersAreValid()
        {
            var context = new Mock <ICarsSystemDbContext>();

            var repository = new EfGenericRepository <User>(context.Object);

            Assert.IsInstanceOf <IRepository <User> >(repository);
        }
        public CommentsService()
        {
            var data = new SimpleBlogSystemDbContext();

            this.posts = new EfGenericRepository<Post>(data);
            this.comments = new EfGenericRepository<Comment>(data);
            this.users = new EfGenericRepository<User>(data);
        }
        public PostsService()
        {
            var data = new SimpleBlogSystemDbContext();

            this.posts = new EfGenericRepository<Post>(data);
            this.categories = new EfGenericRepository<Category>(data);
            this.users = new EfGenericRepository<User>(data);
        }
        public void CreateCorrectlyUsersService_IfEfRepositoyryIsNotNull()
        {
            CarsSystemDbContext        context = new CarsSystemDbContext();
            EfGenericRepository <User> carRepo = new EfGenericRepository <User>(context);

            Assert.DoesNotThrow(() => new UsersService(carRepo));
            Assert.IsNotNull(carRepo);
        }
        public void CreateInstance_OfTypeIUsersService()
        {
            CarsSystemDbContext        context = new CarsSystemDbContext();
            EfGenericRepository <User> carRepo = new EfGenericRepository <User>(context);

            var usersService = new UsersService(carRepo);

            Assert.IsInstanceOf <IUsersService>(usersService);
        }
        public void ThrowArgumentException_IfEfRepositoryIsNull()
        {
            // Arrange
            EfGenericRepository <Car> carRepo = null;

            // Act & Assert
            Assert.Throws <ArgumentException>(() => new CarsService(carRepo));
            Assert.IsNull(carRepo);
        }
        public void CreateCorrectlyCarsService_IfEfRepositoryIsNotNull()
        {
            // Arrange
            CarsSystemDbContext       context = new CarsSystemDbContext();
            EfGenericRepository <Car> carRepo = new EfGenericRepository <Car>(context);

            // Act & Assert
            Assert.DoesNotThrow(() => new CarsService(carRepo));
            Assert.IsNotNull(carRepo);
        }
Example #17
0
        public void CreateCarIRepository_WhenThePassedParametersAreValid()
        {
            // Arrange
            var context = new Mock <ICarsSystemDbContext>();

            // Act
            var repository = new EfGenericRepository <Car>(context.Object);

            // Assert
            Assert.IsInstanceOf <IEfGenericRepository <Car> >(repository);
        }
Example #18
0
        public void GetAll_OrderedByPrice_ShouldReturnCorrectResult()
        {
            // Arrange
            var item1 = new Item()
            {
                Id = 1, MainMaterial = MainMaterialType.Alloy, MainColour = MainColourType.Red, Price = 10
            };
            var item2 = new Item()
            {
                Id = 2, MainMaterial = MainMaterialType.Swarovski, MainColour = MainColourType.Blue, Price = 14
            };
            var item3 = new Item()
            {
                Id = 3, MainMaterial = MainMaterialType.Swarovski, MainColour = MainColourType.Golden, Price = 15
            };
            var item4 = new Item()
            {
                Id = 4, MainMaterial = MainMaterialType.Alloy, MainColour = MainColourType.Red, Price = 1000
            };
            var item5 = new Item()
            {
                Id = 5, MainMaterial = MainMaterialType.PinkGold, MainColour = MainColourType.Blue, Price = 250
            };
            var item6 = new Item()
            {
                Id = 6, MainMaterial = MainMaterialType.Alloy, MainColour = MainColourType.Red, Price = 5
            };

            var itemsCollection = new List <Item>()
            {
                item1, item2, item3, item4, item5, item6
            };

            var queryData = itemsCollection.AsQueryable();

            this.itemsDbSet.As <IQueryable <Item> >().Setup(m => m.Provider).Returns(queryData.Provider);
            this.itemsDbSet.As <IQueryable <Item> >().Setup(m => m.Expression).Returns(queryData.Expression);
            this.itemsDbSet.As <IQueryable <Item> >().Setup(m => m.ElementType).Returns(queryData.ElementType);
            this.itemsDbSet.As <IQueryable <Item> >().Setup(m => m.GetEnumerator()).Returns(queryData.GetEnumerator());

            this.context.Setup(c => c.Set <Item>()).Returns(this.itemsDbSet.Object);

            this.repo = new EfGenericRepository <Item>(this.context.Object);

            // Act
            var actualFiltered   = this.repo.GetAll(null, i => i.Price).ToList();
            var expectedFiltered = new List <Item>()
            {
                item6, item1, item2, item3, item5, item4
            };

            // Assert
            CollectionAssert.AreEqual(actualFiltered, expectedFiltered);
        }
Example #19
0
        public void ConstructorForOrderRepository_ShouldSetDbSet_WhenContextIsNotNull()
        {
            // Arange
            var context = new Mock <IFancyDbContext>();

            // Act
            var efGenericRepository = new EfGenericRepository <Item>(context.Object);

            // Assert
            context.Verify(c => c.Set <Item>(), Times.Once);
        }
        public void ThrowArgumentNullExceptionWhitCorrectMessage_WhenEntityParameterIsNull()
        {
            // Arrange
            var         dbContext           = new Mock <ICarAdvertsSystemDbContext>();
            var         efGenericRepository = new EfGenericRepository <MockDbModel>(dbContext.Object);
            MockDbModel entity = null;

            // Act and Assert
            Assert.That(
                () => efGenericRepository.Add(entity),
                Throws.InstanceOf <ArgumentNullException>().With.Message.Contains(nameof(entity)));
        }
        public void CreateInstance_OfTypeICarsService()
        {
            // Arrange
            CarsSystemDbContext       context = new CarsSystemDbContext();
            EfGenericRepository <Car> carRepo = new EfGenericRepository <Car>(context);

            // Act
            var carsService = new CarsService(carRepo);

            // Assert
            Assert.IsInstanceOf <ICarsService>(carsService);
        }
Example #22
0
        public IRepository <T> Get <T>() where T : class
        {
            var key = typeof(T).FullName;

            if (!this.repos.ContainsKey(key))
            {
                var repo = new EfGenericRepository <T>(this.DbContext);

                this.repos.Add(key, repo);
            }
            return((IRepository <T>) this.repos[key]);
        }
        public IRepository <TEntity> GetRepository <TEntity>() where TEntity : class
        {
            if (repositories.Keys.Contains(typeof(TEntity)))
            {
                return(repositories[typeof(TEntity)] as IRepository <TEntity>);
            }

            var repository = new EfGenericRepository <TEntity>(ctx);

            repositories.Add(typeof(TEntity), repository);
            return(repository);
        }
        public void ConstructorShould_ReturnNewInstanceOfGenericRepo_IfParamsAreValid()
        {
            // Arrange
            var mockedContext = new Mock <ICarAdvertsSystemDbContext>();
            var mockedModel   = new Mock <DbSet <IAdvert> >();

            mockedContext.Setup(x => x.Set <IAdvert>()).Returns(mockedModel.Object);

            // Act
            var repository = new EfGenericRepository <IAdvert>(mockedContext.Object);

            // Assert
            Assert.That(repository, Is.Not.Null);
        }
Example #25
0
        public void GetFirstOrDefault_ShouldReturnFirstResult_IfManyItemsArePresentInDatabase()
        {
            // Arrange
            var id1 = 1;
            var id2 = 2;
            var id3 = 3;

            var item1 = new Item()
            {
                Id = id1
            };
            var item2 = new Item()
            {
                Id = id2
            };
            var item3 = new Item()
            {
                Id = id3
            };
            var item4 = new Item()
            {
                Id = id2
            };
            var item5 = new Item()
            {
                Id = id2
            };

            var itemsCollection = new List <Item>()
            {
                item1, item2, item3, item4, item5
            };

            var queryData = itemsCollection.AsQueryable();

            this.itemsDbSet.As <IQueryable <Item> >().Setup(m => m.Provider).Returns(queryData.Provider);
            this.itemsDbSet.As <IQueryable <Item> >().Setup(m => m.Expression).Returns(queryData.Expression);
            this.itemsDbSet.As <IQueryable <Item> >().Setup(m => m.ElementType).Returns(queryData.ElementType);
            this.itemsDbSet.As <IQueryable <Item> >().Setup(m => m.GetEnumerator()).Returns(queryData.GetEnumerator());

            this.context.Setup(c => c.Set <Item>()).Returns(this.itemsDbSet.Object);

            this.repo = new EfGenericRepository <Item>(this.context.Object);

            // Act
            var item = this.repo.GetFirstOrDefault(i => i.Id == id2);

            // Assert
            Assert.AreEqual(item, item2);
        }
Example #26
0
        public void InvockeDbSet_MethodFindOnce(int?id)
        {
            // Arrange
            var mockedDbSet     = new Mock <DbSet <IAdvert> >();
            var mockedDbContext = new Mock <ICarAdvertsSystemDbContext>();

            mockedDbContext.Setup(mock => mock.Set <IAdvert>()).Returns(mockedDbSet.Object);
            var repository = new EfGenericRepository <IAdvert>(mockedDbContext.Object);

            repository.GetById(id);

            // Assert
            mockedDbSet.Verify(x => x.Find(It.IsAny <int?>()), Times.Once);
        }
Example #27
0
        public void Add_ShouldThrowArgumentNullException_WhenAddedEntityIsNull()
        {
            // Arrange
            Item item1           = null;
            var  itemsCollection = new List <Item>();

            this.itemsDbSet.Setup(i => i.Add(It.IsAny <Item>()))
            .Callback <Item>(i => itemsCollection.Add(i));

            this.context.Setup(c => c.Set <Item>()).Returns(this.itemsDbSet.Object);

            this.repo = new EfGenericRepository <Item>(this.context.Object);

            this.repo.Add(item1);
        }
        public void ThrowNullReferenceExceptionWhithCorrectMessage_WhenPassedArgumentIsNull()
        {
            // Arrange
            var mockedDbContext = new Mock <ICarAdvertsSystemDbContext>();
            var mockedSet       = new Mock <DbSet <IAdvert> >();

            mockedDbContext.Setup(set => set.Set <IAdvert>()).Returns(mockedSet.Object);
            var     repository = new EfGenericRepository <IAdvert>(mockedDbContext.Object);
            IAdvert entity     = null;

            // Act and Assert
            Assert.That(() => repository.Delete(entity),
                        Throws.ArgumentNullException.With.Message.Contains
                            (nameof(entity)));
        }
        public void ConstructorShould_ReturnCorrectDbSet_IfValidParamsPassed()
        {
            // Arrange
            var mockedContext = new Mock <ICarAdvertsSystemDbContext>();
            var mockedModel   = new Mock <DbSet <IAdvert> >();

            mockedContext.Setup(x => x.Set <IAdvert>()).Returns(mockedModel.Object);

            // Act
            var repository = new EfGenericRepository <IAdvert>(mockedContext.Object);

            // Assert
            Assert.That(repository.DbSet, Is.Not.Null);
            Assert.That(repository.DbSet, Is.EqualTo(mockedModel.Object));
        }
Example #30
0
        public void ReturnNull_WhenRequestedIdIsNull()
        {
            // Arrange
            var dbContext = new Mock <ICarAdvertsSystemDbContext>();

            var entities = new Mock <DbSet <MockDbModel> >();

            dbContext.Setup(c => c.Set <MockDbModel>()).Returns(entities.Object);

            var efGenericRepository = new EfGenericRepository <MockDbModel>(dbContext.Object);

            var fakeData = new HashSet <MockDbModel>()
            {
                new MockDbModel()
                {
                    Id = 1
                },
                new MockDbModel()
                {
                    Id = 2
                },
                new MockDbModel()
                {
                    Id = 3
                },
                new MockDbModel()
                {
                    Id = 4
                },
                new MockDbModel()
                {
                    Id = 5
                }
            };

            var fakeDataQueryable = fakeData.AsQueryable();

            entities.As <IQueryable>().Setup(e => e.GetEnumerator()).Returns(fakeDataQueryable.GetEnumerator());
            entities.As <IQueryable>().Setup(e => e.ElementType).Returns(fakeDataQueryable.ElementType);
            entities.As <IQueryable>().Setup(e => e.Expression).Returns(fakeDataQueryable.Expression);
            entities.As <IQueryable>().Setup(e => e.Provider).Returns(fakeDataQueryable.Provider);

            // Act
            var actualReturnedTEntity = efGenericRepository.GetById(null);

            // Assert
            Assert.That(actualReturnedTEntity, Is.Null);
        }
        public void CallMethod_GetByIdOnce()
        {
            // Arrange
            var mockedDbContext = new Mock <ICarAdvertsSystemDbContext>();
            var mockedSet       = new Mock <DbSet <IAdvert> >();

            mockedDbContext.Setup(set => set.Set <IAdvert>()).Returns(mockedSet.Object);
            var repository = new EfGenericRepository <IAdvert>(mockedDbContext.Object);
            int id         = 1;

            // Act
            repository.Delete(id);

            // Assert
            //Assert.That(() => repository.GetById(1), Times.Once());
        }
        public static ICollection <Match> GetMatchesInTwentyFourHours()
        {
            IRepository <Match> matchesContext = new EfGenericRepository <Match>(new BetsDbContext());

            var startPeriod = DateTime.Now;
            var endPeriod   = startPeriod.AddHours(24);

            var matches = matchesContext
                          .All()
                          .Where(m =>
                                 DateTime.Compare(m.StartDate, startPeriod) > 0 &&
                                 DateTime.Compare(m.StartDate, endPeriod) < 0)
                          .ToList();

            return(matches);
        }
Example #33
0
        public void GetSingle_ShouldThrowInvalidOperationException_IfNoItemsAreFound()
        {
            // Arrange
            var id1       = 1;
            var id2       = 2;
            var id3       = 3;
            var invalidId = 4;

            var item1 = new Item()
            {
                Id = id1
            };
            var item2 = new Item()
            {
                Id = id2
            };
            var item3 = new Item()
            {
                Id = id3
            };

            var itemsCollection = new List <Item>()
            {
                item1, item2, item3
            };

            itemsCollection.Add(item1);

            var queryData = itemsCollection.AsQueryable();

            this.itemsDbSet.As <IQueryable <Item> >().Setup(m => m.Provider).Returns(queryData.Provider);
            this.itemsDbSet.As <IQueryable <Item> >().Setup(m => m.Expression).Returns(queryData.Expression);
            this.itemsDbSet.As <IQueryable <Item> >().Setup(m => m.ElementType).Returns(queryData.ElementType);
            this.itemsDbSet.As <IQueryable <Item> >().Setup(m => m.GetEnumerator()).Returns(queryData.GetEnumerator());

            this.context.Setup(c => c.Set <Item>()).Returns(this.itemsDbSet.Object);

            this.repo = new EfGenericRepository <Item>(this.context.Object);

            // Act
            var item = this.repo.GetSingle(i => i.Id == invalidId);

            // Assert
            Assert.AreEqual(item, item1);
        }
 public ArtistController()
 {
     var db = new ArtistsDbContext();
     this.artistData = new EfGenericRepository<Artist>(db);
     this.countryData = new EfGenericRepository<Country>(db);
 }
 public CategoriesService()
 {
     this.categories = new EfGenericRepository<Category>(new SimpleBlogSystemDbContext());
 }
 public ReminderAppUnitOfWork()
 {
     _personRepo = new EfGenericRepository<Person>(People);
     _messageRepo = new EfGenericRepository<Message>(Messages);
     base.Configuration.ProxyCreationEnabled = false;
 }