Exemple #1
0
        public async Task GetAllWishProductsCountReturnsZero()
        {
            //Arrange
            var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
                          .UseInMemoryDatabase("GetAllWishProductsCountReturnsZero")
                          .Options;
            var dbContext       = new MarketplaceDbContext(options);
            var profile         = new MarketplaceProfile();
            var configuration   = new MapperConfiguration(x => x.AddProfile(profile));
            var mapper          = new Mapper(configuration);
            var userStoreMock   = new Mock <IUserStore <MarketplaceUser> >();
            var userManagerMock = new Mock <UserManager <MarketplaceUser> >(userStoreMock.Object, null, null, null, null, null, null, null, null);
            var userService     = new UserService(dbContext, mapper, userManagerMock.Object);

            var user = new MarketplaceUser()
            {
                Id = "eb243391-a7ee-42f6-bb4e-f28c74a68d84"
            };

            dbContext.Users.Add(user);
            await dbContext.SaveChangesAsync();

            //Act
            var actual   = userService.GetAllWishProductsCount(user);
            var expected = 0;

            //Assert
            Assert.Equal(expected, actual);
        }
Exemple #2
0
        public void GetAllUsersReturnsRightUserModelEmail()
        {
            //Arrange
            var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
                          .UseInMemoryDatabase("GetAllUsersReturnsRightUserModelEmail")
                          .Options;
            var dbContext       = new MarketplaceDbContext(options);
            var profile         = new MarketplaceProfile();
            var configuration   = new MapperConfiguration(x => x.AddProfile(profile));
            var mapper          = new Mapper(configuration);
            var userStoreMock   = new Mock <IUserStore <MarketplaceUser> >();
            var userManagerMock = new Mock <UserManager <MarketplaceUser> >(userStoreMock.Object, null, null, null, null, null, null, null, null);
            var userService     = new UserService(dbContext, mapper, userManagerMock.Object);

            var user1 = new MarketplaceUser()
            {
                Id = "eb243391-a7ee-42f6-bb4e-f28c74a68d84", FirstName = "Georgi", LastName = "Horozov", Email = "*****@*****.**"
            };

            dbContext.Users.Add(user1);
            dbContext.SaveChanges();

            //Act
            var result   = userService.GetAllUsers <UserViewModel>();
            var actual   = result.First().Email;
            var expected = "*****@*****.**";

            //Assert
            Assert.Equal(expected, actual);
        }
        public async Task CreateIfUserDoesNotHasCartThrowExeption()
        {
            //Arrange
            var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
                          .UseInMemoryDatabase("CreateIfUserDoesNotHasCartThrowExeption")
                          .Options;
            var dbContext     = new MarketplaceDbContext(options);
            var profile       = new MarketplaceProfile();
            var configuration = new MapperConfiguration(x => x.AddProfile(profile));
            var mapper        = new Mapper(configuration);
            var orderService  = new OrderService(dbContext, mapper);

            var user = new MarketplaceUser()
            {
                Id        = "8ca6c061-52de-4f0a-8885-a7501b6dae79",
                FirstName = "Ivan",
                LastName  = "Ivanov",
                Email     = "*****@*****.**"
            };

            dbContext.Users.Add(user);
            await dbContext.SaveChangesAsync();

            var phone           = "0883288905";
            var shippingAddress = "ul.Stara Planina 23";
            //Act
            //Assert
            await Assert.ThrowsAsync <NullReferenceException>(() => orderService.Create(user, phone, shippingAddress));
        }
        public void GetAllCategoriesInputTwoCategoriesReturnFirstNameAnIdShouldMatch()
        {
            //Arrange
            var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
                          .UseInMemoryDatabase("GetAllCategoriesInputTwoCategoriesReturnFirstNameShouldMatch")
                          .Options;
            var dbContext       = new MarketplaceDbContext(options);
            var profile         = new MarketplaceProfile();
            var configuration   = new MapperConfiguration(x => x.AddProfile(profile));
            var mapper          = new Mapper(configuration);
            var categoryService = new CategoryService(dbContext, mapper);

            var category1 = new Category()
            {
                Id = "42a27ec6-3abb-4e7b-a224-6fd873564368", Name = "Smartphones"
            };
            var category2 = new Category()
            {
                Id = "7821b986-e16a-4a50-99c5-e5d0dc71488d", Name = "Laptops"
            };

            dbContext.Categories.Add(category1);
            dbContext.Categories.Add(category2);
            dbContext.SaveChanges();

            //Act
            var result   = categoryService.GetAllCategories <IndexCategoryViewModel>();
            var actual   = result.First().Name;
            var expected = "Smartphones";

            //Assert
            Assert.Equal(expected, actual);
            Assert.Equal("42a27ec6-3abb-4e7b-a224-6fd873564368", result.First().CategoryId);
        }
        public async Task EditWithInCorectInputEmptyNameReturnsFalse()
        {
            //Arrange
            var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
                          .UseInMemoryDatabase("EditWithInCorectInputEmptyNameReturnsFalse")
                          .Options;
            var dbContext       = new MarketplaceDbContext(options);
            var profile         = new MarketplaceProfile();
            var configuration   = new MapperConfiguration(x => x.AddProfile(profile));
            var mapper          = new Mapper(configuration);
            var categoryService = new CategoryService(dbContext, mapper);

            var category = new Category()
            {
                Id = "42a27ec6-3abb-4e7b-a224-6fd873564368", Name = "Smartphones"
            };

            dbContext.Categories.Add(category);
            dbContext.SaveChanges();

            var id   = "42a27ec6-3abb-4e7b-a224-6fd873564368";
            var name = " ";
            //Act
            var actual = await categoryService.Edit(id, name);

            var expected = false;

            //Assert
            Assert.Equal(expected, actual);
        }
        public async Task GetCategoryByNameInCorrectinputReturnsNull()
        {
            //Arrange
            var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
                          .UseInMemoryDatabase("GetCategoryByNameInCorrectinputReturnsNull")
                          .Options;
            var dbContext       = new MarketplaceDbContext(options);
            var profile         = new MarketplaceProfile();
            var configuration   = new MapperConfiguration(x => x.AddProfile(profile));
            var mapper          = new Mapper(configuration);
            var categoryService = new CategoryService(dbContext, mapper);

            var category = new Category()
            {
                Id = "42a27ec6-3abb-4e7b-a224-6fd873564368", Name = "Smartphones"
            };

            dbContext.Categories.Add(category);
            dbContext.SaveChanges();

            var categoryName = "";
            //Act
            var actual = await categoryService.GetCategoryByName(categoryName);

            Category expected = null;

            //Assert
            Assert.Equal(expected, actual);
        }
        public async Task GetCategoryByIdWithCorectIdreturnsCategoryType()
        {
            //Arrange
            var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
                          .UseInMemoryDatabase("GetCategoryByIdWithCorectIdreturnsCategory")
                          .Options;
            var dbContext       = new MarketplaceDbContext(options);
            var profile         = new MarketplaceProfile();
            var configuration   = new MapperConfiguration(x => x.AddProfile(profile));
            var mapper          = new Mapper(configuration);
            var categoryService = new CategoryService(dbContext, mapper);

            var category = new Category()
            {
                Id = "42a27ec6-3abb-4e7b-a224-6fd873564368", Name = "Smartphones"
            };

            dbContext.Categories.Add(category);
            dbContext.SaveChanges();

            var categoryId = "42a27ec6-3abb-4e7b-a224-6fd873564368";
            //Act
            var result = await categoryService.GetCategoryById(categoryId);

            var actual   = result.GetType();
            var expected = typeof(Category);

            //Assert
            Assert.Equal(expected, actual);
            Assert.Equal("Smartphones", result.Name);
        }
Exemple #8
0
        public async Task GetUserRolesWithInCorrectIdThrowsNull()
        {
            //Arrange
            var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
                          .UseInMemoryDatabase("GetUserRolesWithInCorrectIdThrowsNull")
                          .Options;
            var dbContext     = new MarketplaceDbContext(options);
            var profile       = new MarketplaceProfile();
            var configuration = new MapperConfiguration(x => x.AddProfile(profile));
            var mapper        = new Mapper(configuration);

            var usersList = new List <MarketplaceUser>()
            {
                new MarketplaceUser()
                {
                    Id = "eb243391-a7ee-42f6-bb4e-f28c74a68d84", FirstName = "Ivan", Email = "*****@*****.**"
                },
                new MarketplaceUser()
                {
                    Id = "eb243391-a7ee-42f6-bb4e-f28c74a68d83", FirstName = "Gosho", Email = "*****@*****.**"
                },
            };

            dbContext.Users.Add(usersList[0]);
            dbContext.Users.Add(usersList[1]);
            await dbContext.SaveChangesAsync();

            var roleName  = "user";
            var listRoles = new List <string>()
            {
                "user", "admin"
            };

            var userStoreMock   = new Mock <IUserStore <MarketplaceUser> >();
            var userManagerMock = new Mock <UserManager <MarketplaceUser> >(userStoreMock.Object, null, null, null, null, null, null, null, null);

            userManagerMock.Setup(x => x.GetUsersInRoleAsync(roleName))
            .Returns(Task.FromResult <IList <MarketplaceUser> >(usersList.ToList()));

            userManagerMock.Setup(x => x.GetRolesAsync(usersList[0]))
            .Returns(Task.FromResult <IList <string> >(listRoles));

            var userService = new UserService(dbContext, mapper, userManagerMock.Object);

            var id = "";
            //Act
            var result = await userService.GetUserRoles(id);

            var actual   = result.ToList();
            var expected = new List <string>();

            //Assert
            Assert.Equal(expected, actual);
        }
        public async Task CreateWithInCorrectInputIdReturnFalse()
        {
            //Arrange
            var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
                          .UseInMemoryDatabase("CreateWithInCorrectInputIdReturnFalse")
                          .Options;
            var dbContext     = new MarketplaceDbContext(options);
            var profile       = new MarketplaceProfile();
            var configuration = new MapperConfiguration(x => x.AddProfile(profile));
            var mapper        = new Mapper(configuration);

            var user = new MarketplaceUser()
            {
                Id = "cd89dcbc-bb80-4246-b9b8-ad21753111cc", Email = "*****@*****.**"
            };
            var user1 = new MarketplaceUser()
            {
                Id = "cd89dcbc-bb80-4246-b9b8-ad2175311111", Email = "*****@*****.**"
            };
            var listUsers = new List <MarketplaceUser>();

            listUsers.Add(user);
            listUsers.Add(user1);
            dbContext.Users.Add(user);
            dbContext.Users.Add(user1);
            await dbContext.SaveChangesAsync();

            var role = "Administrator";

            var userStoreMock   = new Mock <IUserStore <MarketplaceUser> >();
            var userManagerMock = new Mock <UserManager <MarketplaceUser> >(userStoreMock.Object, null, null, null, null, null, null, null, null);

            userManagerMock.Setup(x => x.GetUsersInRoleAsync(role))
            .Returns(Task.FromResult <IList <MarketplaceUser> >(listUsers.ToList()));

            userManagerMock.Setup(x => x.IsInRoleAsync(user, role))
            .Returns(Task.FromResult(true));

            var messageService = new MessageService(dbContext, mapper, userManagerMock.Object);

            var userId  = "";
            var name    = "Ivan";
            var email   = "*****@*****.**";
            var phone   = "0883477980";
            var message = "This is test message!";

            //Act
            var actual = await messageService.Create(userId, name, email, phone, message);

            var expected = false;

            //Assert
            Assert.Equal(expected, actual);
        }
        public async Task DeleteMessageByIdWithInCorrectMessageIdInputReturnFalse()
        {
            //Arrange
            var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
                          .UseInMemoryDatabase("DeleteMessageByIdWithInCorrectMessageIdInputReturnFalse")
                          .Options;
            var dbContext       = new MarketplaceDbContext(options);
            var profile         = new MarketplaceProfile();
            var configuration   = new MapperConfiguration(x => x.AddProfile(profile));
            var mapper          = new Mapper(configuration);
            var userStoreMock   = new Mock <IUserStore <MarketplaceUser> >();
            var userManagerMock = new Mock <UserManager <MarketplaceUser> >(userStoreMock.Object, null, null, null, null, null, null, null, null);
            var messageService  = new MessageService(dbContext, mapper, userManagerMock.Object);

            var user = new MarketplaceUser()
            {
                Id = "cd89dcbc-bb80-4246-b9b8-ad21753111cc", Email = "*****@*****.**"
            };
            var user1 = new MarketplaceUser()
            {
                Id = "cd89dcbc-bb80-4246-b9b8-ad2175311123", Email = "*****@*****.**"
            };

            dbContext.Users.Add(user);
            await dbContext.SaveChangesAsync();

            var message = new Message()
            {
                MarketplaceUserId = user1.Id,
                Phone             = "0883377905",
                Name           = "Ivan",
                IssuedOn       = DateTime.UtcNow,
                MessageContent = "This is test message!",
                Email          = "*****@*****.**",
                MarkAsRead     = false,
            };

            dbContext.Messages.Add(message);
            await dbContext.SaveChangesAsync();

            user.Messages.Add(message);
            await dbContext.SaveChangesAsync();

            var userId    = "cd89dcbc-bb80-4246-b9b8-ad21753111cc";
            var messageId = "1"; //incorect messageId

            //Act
            var actual = await messageService.DeleteMessageById(userId, messageId);

            var expected = false;

            //Assert
            Assert.Equal(expected, actual);
        }
        public async Task GetUserMessagesCorrectIdMarkAsReadSetToTrueReturnZeroMessages()
        {
            //Arrange
            var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
                          .UseInMemoryDatabase("GetUserMessagesCorrectIdMarkAsReadSetToTrueReturnZeroMessages")
                          .Options;
            var dbContext       = new MarketplaceDbContext(options);
            var profile         = new MarketplaceProfile();
            var configuration   = new MapperConfiguration(x => x.AddProfile(profile));
            var mapper          = new Mapper(configuration);
            var userStoreMock   = new Mock <IUserStore <MarketplaceUser> >();
            var userManagerMock = new Mock <UserManager <MarketplaceUser> >(userStoreMock.Object, null, null, null, null, null, null, null, null);
            var messageService  = new MessageService(dbContext, mapper, userManagerMock.Object);

            var user = new MarketplaceUser()
            {
                Id = "cd89dcbc-bb80-4246-b9b8-ad21753111cc", Email = "*****@*****.**"
            };
            var user1 = new MarketplaceUser()
            {
                Id = "cd89dcbc-bb80-4246-b9b8-ad2175311123", Email = "*****@*****.**"
            };

            dbContext.Users.Add(user);
            await dbContext.SaveChangesAsync();

            var message = new Message()
            {
                MarketplaceUserId = user1.Id,
                Phone             = "0883377905",
                Name           = "Ivan",
                IssuedOn       = DateTime.UtcNow,
                MessageContent = "This is test message!",
                Email          = "*****@*****.**",
                MarkAsRead     = true,
            };

            dbContext.Messages.Add(message);
            await dbContext.SaveChangesAsync();

            user.Messages.Add(message);
            await dbContext.SaveChangesAsync();

            var userId = "cd89dcbc-bb80-4246-b9b8-ad21753111cc";
            //Act
            var result   = messageService.GetUserMessages <AdminMessageViewModel>(userId);
            var actual   = result.Count();
            var expected = 0;

            //Assert
            Assert.Equal(expected, actual);
        }
        public async Task CreateWithCorretInputShouldReturnTrue()
        {
            //Arrange
            var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
                          .UseInMemoryDatabase("CreateWithCorretInputShouldReturnTrue")
                          .Options;
            var dbContext       = new MarketplaceDbContext(options);
            var profile         = new MarketplaceProfile();
            var configuration   = new MapperConfiguration(x => x.AddProfile(profile));
            var mapper          = new Mapper(configuration);
            var categoryService = new CategoryService(dbContext, mapper);

            var CategoryName = "Computers";
            //Act
            var actual = await categoryService.Create(CategoryName);

            var expected = true;

            //Assert
            Assert.Equal(expected, actual);
        }
Exemple #13
0
        public void GetAllUsersWithNoUsersReturnsCountZero()
        {
            //Arrange
            var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
                          .UseInMemoryDatabase("GetAllUsersWithNoUsersReturnsCountZero")
                          .Options;
            var dbContext       = new MarketplaceDbContext(options);
            var profile         = new MarketplaceProfile();
            var configuration   = new MapperConfiguration(x => x.AddProfile(profile));
            var mapper          = new Mapper(configuration);
            var userStoreMock   = new Mock <IUserStore <MarketplaceUser> >();
            var userManagerMock = new Mock <UserManager <MarketplaceUser> >(userStoreMock.Object, null, null, null, null, null, null, null, null);
            var userService     = new UserService(dbContext, mapper, userManagerMock.Object);

            //Act
            var result   = userService.GetAllUsers <UserViewModel>();
            var actual   = result.Count();
            var expected = 0;

            //Assert
            Assert.Equal(expected, actual);
        }
        public async Task CreateWithInputUserEqualTonullOrderShouldReturnFalse()
        {
            //Arrange
            var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
                          .UseInMemoryDatabase("CreateWithInputUserEqualTonullOrderShouldThrollExeption")
                          .Options;
            var dbContext     = new MarketplaceDbContext(options);
            var profile       = new MarketplaceProfile();
            var configuration = new MapperConfiguration(x => x.AddProfile(profile));
            var mapper        = new Mapper(configuration);
            var orderService  = new OrderService(dbContext, mapper);

            MarketplaceUser user            = null;
            var             phone           = "0883288905";
            var             shippingAddress = "ul.Stara Planina 23";
            //Act
            var actual = await orderService.Create(user, phone, shippingAddress);

            var expected = false;

            //Assert
            Assert.True(actual.Equals(expected));
        }
Exemple #15
0
        public async Task DeleteByIdWithInCorrectInputReturnsFalse()
        {
            //Arrange
            var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
                          .UseInMemoryDatabase("DeleteByIdWithInCorrectInputReturnsFalse")
                          .Options;
            var dbContext     = new MarketplaceDbContext(options);
            var profile       = new MarketplaceProfile();
            var configuration = new MapperConfiguration(x => x.AddProfile(profile));
            var mapper        = new Mapper(configuration);

            var user = new MarketplaceUser()
            {
                Id = "eb243391-a7ee-42f6-bb4e-f28c74a68d84", FirstName = "Georgi", LastName = "Horozov", Email = "*****@*****.**"
            };

            dbContext.Users.Add(user);
            await dbContext.SaveChangesAsync();

            var userStoreMock   = new Mock <IUserStore <MarketplaceUser> >();
            var userManagerMock = new Mock <UserManager <MarketplaceUser> >(userStoreMock.Object, null, null, null, null, null, null, null, null);

            userManagerMock.Setup(m => m.FindByIdAsync(user.Id))
            .Returns(Task.FromResult <MarketplaceUser>(null));

            var userService = new UserService(dbContext, mapper, userManagerMock.Object);

            var userId = "eb243391-a7ee-42f6-bb4e-f28c74a68d84";
            //Act
            var actual = await userService.DeleteById(userId);

            var expected = false;

            //Assert
            Assert.Equal(expected, actual);
        }
        public async Task CreateWithCorrectInputOrderShouldReturnTrue()
        {
            //Arrange
            var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
                          .UseInMemoryDatabase("AddProductShouldReturnTrue")
                          .Options;
            var dbContext     = new MarketplaceDbContext(options);
            var profile       = new MarketplaceProfile();
            var configuration = new MapperConfiguration(x => x.AddProfile(profile));
            var mapper        = new Mapper(configuration);
            var orderService  = new OrderService(dbContext, mapper);

            var user = new MarketplaceUser()
            {
                Id        = "8ca6c061-52de-4f0a-8885-a7501b6dae79",
                FirstName = "Ivan",
                LastName  = "Ivanov",
                Email     = "*****@*****.**"
            };

            dbContext.Users.Add(user);
            await dbContext.SaveChangesAsync();

            var cart = new ShoppingCart()
            {
                Id     = "86f81ed7-312e-4760-a594-1c40389440bd",
                UserId = user.Id
            };

            dbContext.ShoppingCarts.Add(cart);
            await dbContext.SaveChangesAsync();

            var product = new Product()
            {
                Id       = "532b377e-83f1-43db-a697-1e623107ae60",
                Name     = "TestProduct",
                Price    = 5.45m,
                Quantity = 1
            };

            dbContext.Products.Add(product);
            await dbContext.SaveChangesAsync();

            var shoppingCartProduct = new ShoppingCartProduct()
            {
                ProductId      = product.Id,
                Quantity       = product.Quantity,
                ShoppingCartId = cart.Id
            };

            cart.Products.Add(shoppingCartProduct);
            dbContext.ShoppingCarts.Update(cart);
            await dbContext.SaveChangesAsync();

            var phone           = "0883288905";
            var shippingAddress = "ul.Stara Planina 23";
            //Act
            var actual = await orderService.Create(user, phone, shippingAddress);

            var expected = true;

            //Assert
            Assert.True(actual.Equals(expected));
        }