public async Task TestIfGetAllCategoryNamesReturnsAllNamesCorrectly(string category, string category1, string category2, string category3)
        {
            var     context = PCHUBDbContextInMemoryInitializer.InitializeContext();
            Account cloudinaryCredentials = new Account(
                CloudinaryAccountTests.CloudName,
                CloudinaryAccountTests.ApiKey,
                CloudinaryAccountTests.ApiSecret);

            var cloudinaryUtility = new Cloudinary(cloudinaryCredentials);
            var cloudinary        = new CloudinaryServices(cloudinaryUtility);

            var adminProductServices = new Areas.Administration.Services.AdminProductsServices(context, cloudinary);

            await adminProductServices.CreateCategoryAsync(category);

            await adminProductServices.CreateCategoryAsync(category1);

            await adminProductServices.CreateCategoryAsync(category2);

            await adminProductServices.CreateCategoryAsync(category3);


            var result = await adminProductServices.GetAllCategoryNamesAsync();

            Assert.NotEmpty(result);
            Assert.Contains(result, x => x == category);
            Assert.Contains(result, x => x == category1);
            Assert.Contains(result, x => x == category2);
            Assert.Contains(result, x => x == category3);
        }
        public async Task TestIfUpdateHtmlDescriptionWorksProperly(string productId)
        {
            var     context = PCHUBDbContextInMemoryInitializer.InitializeContext();
            Account cloudinaryCredentials = new Account(
                CloudinaryAccountTests.CloudName,
                CloudinaryAccountTests.ApiKey,
                CloudinaryAccountTests.ApiSecret);

            var cloudinaryUtility = new Cloudinary(cloudinaryCredentials);
            var cloudinary        = new CloudinaryServices(cloudinaryUtility);

            var adminProductServices = new Areas.Administration.Services.AdminProductsServices(context, cloudinary);

            var form = new InserHtmlInProductViewModel();

            await context.Products.AddAsync(new Product
            {
                Id = productId,
            });

            await context.SaveChangesAsync();

            form.ProductId = productId;

            form.HtmlContent = "<p>Hello World</p>";

            await adminProductServices.UpdateHtmlDescriptionAsync(form);

            var result = await context.Products.FirstOrDefaultAsync(x => x.Id == productId);

            Assert.NotNull(result.HtmlDescription);

            Assert.Equal("<p>Hello World</p>", result.HtmlDescription);
        }
        public async Task TestIfGetProductReturnsCorrectResult(string productId)
        {
            var     context = PCHUBDbContextInMemoryInitializer.InitializeContext();
            Account cloudinaryCredentials = new Account(
                CloudinaryAccountTests.CloudName,
                CloudinaryAccountTests.ApiKey,
                CloudinaryAccountTests.ApiSecret);

            var cloudinaryUtility = new Cloudinary(cloudinaryCredentials);
            var cloudinary        = new CloudinaryServices(cloudinaryUtility);

            var adminProductServices = new Areas.Administration.Services.AdminProductsServices(context, cloudinary);

            await context.Products.AddAsync(new Product
            {
                Id = productId,
            });

            await context.SaveChangesAsync();

            var result = await adminProductServices.GetProductAsync(productId);

            Assert.NotNull(result);

            Assert.Equal(result.Id, productId);
        }
        public async Task TestIfCreateCategoryWorksProperly(string category)
        {
            var     context = PCHUBDbContextInMemoryInitializer.InitializeContext();
            Account cloudinaryCredentials = new Account(
                CloudinaryAccountTests.CloudName,
                CloudinaryAccountTests.ApiKey,
                CloudinaryAccountTests.ApiSecret);

            var cloudinaryUtility = new Cloudinary(cloudinaryCredentials);
            var cloudinary        = new CloudinaryServices(cloudinaryUtility);

            var adminProductServices = new Areas.Administration.Services.AdminProductsServices(context, cloudinary);

            await adminProductServices.CreateCategoryAsync(category);

            Assert.Contains(await context.Categories.ToListAsync(), x => x.Name == category);
        }
        public async Task TestIfCreateJSONKeyboardWorksAsExpected(string category, string articleNumber)
        {
            var     context = PCHUBDbContextInMemoryInitializer.InitializeContext();
            Account cloudinaryCredentials = new Account(
                CloudinaryAccountTests.CloudName,
                CloudinaryAccountTests.ApiKey,
                CloudinaryAccountTests.ApiSecret);

            var cloudinaryUtility = new Cloudinary(cloudinaryCredentials);
            var cloudinary        = new CloudinaryServices(cloudinaryUtility);

            var adminProductServices = new Areas.Administration.Services.AdminProductsServices(context, cloudinary);

            var model = new InsertJsonProductViewModel();

            var keyboardsJson = await
                                File.ReadAllTextAsync(
                @"C:\Users\velis\source\repos\PCHUBStore\PCHUBStore.Tests\AdminServicesTests\JSONKeyboards\keyboards.json");

            var keyboards = JsonConvert.DeserializeObject <List <JsonProductModel> >(keyboardsJson);

            await adminProductServices.CreateCategoryAsync(category);

            foreach (var keyboard in keyboards)
            {
                var jsonBasic = JsonConvert.SerializeObject(keyboard.BasicChars);

                var jsonAdvanced = JsonConvert.SerializeObject(keyboard.AdvancedChars);
                model.Category             = category;
                model.BasicCharacteristics = jsonBasic;
                model.FullCharacteristics  = jsonAdvanced;

                await adminProductServices.CreateKeyboardFromJSONAsync(model);
            }

            var result = await context.Products.ToListAsync();

            Assert.Equal(4, result.Count);

            Assert.Contains(result, x => x.Title == "Геймърска механична клавиатура Cooler Master CK530 TKL RGB Brown swithces (CM-KEY-CK-530-GKGM1-US)");
            Assert.Contains(result, x => x.ArticleNumber.Contains(articleNumber));
        }
        public async Task TestIfCreateJSONLaptopWorksAsExpected(string category)
        {
            var     context = PCHUBDbContextInMemoryInitializer.InitializeContext();
            Account cloudinaryCredentials = new Account(
                CloudinaryAccountTests.CloudName,
                CloudinaryAccountTests.ApiKey,
                CloudinaryAccountTests.ApiSecret);

            var cloudinaryUtility = new Cloudinary(cloudinaryCredentials);
            var cloudinary        = new CloudinaryServices(cloudinaryUtility);

            var adminProductServices = new Areas.Administration.Services.AdminProductsServices(context, cloudinary);

            var model = new InsertJsonProductViewModel();

            var laptopsJson = await
                              File.ReadAllTextAsync(
                @"C:\Users\velis\source\repos\PCHUBStore\PCHUBStore.Tests\AdminServicesTests\JSONLaptops\laptops.json");

            var laptops = JsonConvert.DeserializeObject <List <JsonProductModel> >(laptopsJson);

            await adminProductServices.CreateCategoryAsync(category);

            foreach (var laptop in laptops)
            {
                var jsonBasic = JsonConvert.SerializeObject(laptop.BasicChars);

                var jsonAdvanced = JsonConvert.SerializeObject(laptop.AdvancedChars);
                model.Category             = category;
                model.BasicCharacteristics = jsonBasic;
                model.FullCharacteristics  = jsonAdvanced;

                await adminProductServices.CreateLaptopFromJSONAsync(model);
            }

            var result = await context.Products.ToListAsync();

            Assert.Equal(2, result.Count);

            Assert.Contains(result, x => x.Make == "Acer");
            Assert.Contains(result, x => x.Price == 878);
        }
        public async Task TestIfUpdateHtmlDescriptionThrowsError()
        {
            var     context = PCHUBDbContextInMemoryInitializer.InitializeContext();
            Account cloudinaryCredentials = new Account(
                CloudinaryAccountTests.CloudName,
                CloudinaryAccountTests.ApiKey,
                CloudinaryAccountTests.ApiSecret);

            var cloudinaryUtility = new Cloudinary(cloudinaryCredentials);
            var cloudinary        = new CloudinaryServices(cloudinaryUtility);

            var adminProductServices = new Areas.Administration.Services.AdminProductsServices(context, cloudinary);

            var form = new InserHtmlInProductViewModel();

            await Assert.ThrowsAsync <NullReferenceException>(async() =>
            {
                await adminProductServices.UpdateHtmlDescriptionAsync(form);
            });
        }
示例#8
0
        public async Task TestIfUpdateCategoryWorksAccordinglyForKeyboards(string category)
        {
            var context = PCHUBDbContextInMemoryInitializer.InitializeContext();

            var filtersService = new Areas.Administration.Services.AdminFiltersServices(context);

            Account cloudinaryCredentials = new Account(
                CloudinaryAccountTests.CloudName,
                CloudinaryAccountTests.ApiKey,
                CloudinaryAccountTests.ApiSecret);

            var cloudinaryUtility = new Cloudinary(cloudinaryCredentials);
            var cloudinary        = new CloudinaryServices(cloudinaryUtility);

            var adminProductServices = new Areas.Administration.Services.AdminProductsServices(context, cloudinary);

            var model = new InsertJsonProductViewModel();

            var keyboardsJson = await
                                File.ReadAllTextAsync(
                @"C:\Users\velis\source\repos\PCHUBStore\PCHUBStore.Tests\AdminServicesTests\JSONKeyboards\keyboards.json");

            var keyboards = JsonConvert.DeserializeObject <List <JsonProductModel> >(keyboardsJson);

            await adminProductServices.CreateCategoryAsync(category);

            foreach (var keyboard in keyboards)
            {
                var jsonBasic = JsonConvert.SerializeObject(keyboard.BasicChars);

                var jsonAdvanced = JsonConvert.SerializeObject(keyboard.AdvancedChars);
                model.Category             = category;
                model.BasicCharacteristics = jsonBasic;
                model.FullCharacteristics  = jsonAdvanced;

                await adminProductServices.CreateKeyboardFromJSONAsync(model);
            }

            var listOfSubNames = new List <string>
            {
                "Make", "Type", "Interface", "Mechanical",
            };

            for (int i = 0; i < listOfSubNames.Count; i++)
            {
                var formFilterCategory = new InserFilterCategoryViewModel();
                formFilterCategory.CategoryViewSubName = listOfSubNames[i];
                formFilterCategory.Category            = category;
                await filtersService.CreateFilterCategoryAsync(formFilterCategory);
            }

            await filtersService.UpdateCategoryAsync(category);


            for (int i = 0; i < listOfSubNames.Count; i++)
            {
                var result = await context.FilterCategories.FirstOrDefaultAsync(x => x.CategoryName == category && x.ViewSubCategoryName == listOfSubNames[i]);

                Assert.NotNull(result);

                Assert.NotEmpty(result.Filters);
            }
        }
        public async Task TestIfQueryComputersReturnsCorrectResults(string category)
        {
            var context        = PCHUBDbContextInMemoryInitializer.InitializeContext();
            var productService = new ProductServices(context);

            Account cloudinaryCredentials = new Account(
                CloudinaryAccountTests.CloudName,
                CloudinaryAccountTests.ApiKey,
                CloudinaryAccountTests.ApiSecret);

            var cloudinaryUtility = new Cloudinary(cloudinaryCredentials);
            var cloudinary        = new CloudinaryServices(cloudinaryUtility);

            var adminProductServices = new Areas.Administration.Services.AdminProductsServices(context, cloudinary);

            var model = new InsertJsonProductViewModel();

            var computersJson = await
                                File.ReadAllTextAsync(
                @"C:\Users\velis\source\repos\PCHUBStore\PCHUBStore.Tests\AdminServicesTests\JSONComputers\computers.json");

            var computers = JsonConvert.DeserializeObject <List <JsonProductModel> >(computersJson);

            await adminProductServices.CreateCategoryAsync(category);

            foreach (var computer in computers)
            {
                var jsonBasic = JsonConvert.SerializeObject(computer.BasicChars);

                var jsonAdvanced = JsonConvert.SerializeObject(computer.AdvancedChars);
                model.Category             = category;
                model.BasicCharacteristics = jsonBasic;
                model.FullCharacteristics  = jsonAdvanced;

                await adminProductServices.CreateComputerFromJSONAsync(model);
            }

            var filters = new ProductFiltersUrlModel();

            if (filters.Make == null)
            {
                filters.Make = new string[] { "All" };
            }
            if (filters.Model == null)
            {
                filters.Model = new string[] { "All" };
            }
            if (filters.OrderBy == null)
            {
                filters.OrderBy = "Default";
            }
            if (filters.Processor == null)
            {
                filters.Processor = new string[] { "All" };
            }
            if (filters.VideoCard == null)
            {
                filters.VideoCard = new string[] { "All" };
            }
            if (filters.OS == null)
            {
                filters.OS = new string[] { "All" };
            }
            if (filters.RAM == null)
            {
                filters.RAM = new string[] { "All" };
            }
            if (filters.Resolution == null)
            {
                filters.Resolution = new string[] { "All" };
            }
            if (filters.FPS == null)
            {
                filters.FPS = new string[] { "All" };
            }
            if (filters.ReactionTime == null)
            {
                filters.ReactionTime = new string[] { "All" };
            }
            if (filters.MatrixType == null)
            {
                filters.MatrixType = new string[] { "All" };
            }
            if (filters.DisplaySize == null)
            {
                filters.DisplaySize = new string[] { "All" };
            }
            if (filters.Gaming == null)
            {
                filters.Gaming = new string[] { "All" };
            }
            if (filters.Interface == null)
            {
                filters.Interface = new string[] { "All" };
            }
            if (filters.Connectivity == null)
            {
                filters.Connectivity = new string[] { "All" };
            }
            if (filters.Type == null)
            {
                filters.Type = new string[] { "All" };
            }
            if (filters.Mechanical == null)
            {
                filters.Mechanical = new string[] { "All" };
            }

            var result = await productService.QueryComputersAsync(filters, 1000, 2000);


            Assert.Equal(4, result.Count());

            Assert.Contains(result, x => x.Title.Contains("UPGRADED Компютър Fury (Ryzen 2700, 8GB, 1TB, 120 GB SSD, GTX 1660ti 6GB GDDR6, Win10)"));

            filters.Processor = new string[]
            {
                "AMD",
            };


            var secondResultTest = await productService.QueryComputersAsync(filters, 1800, 1820);

            Assert.Equal(3, secondResultTest.Count());

            Assert.Contains(secondResultTest, x => x.ArticleNumber.Contains("101279_101305"));


            filters.Make = new string[]
            {
                "Dell",
            };
            filters.MinPrice = "800";
            filters.MaxPrice = "900";

            var thirdResultTest = await productService.QueryComputersAsync(filters, 800, 900);

            Assert.Empty(thirdResultTest);
        }
示例#10
0
        public async Task TestIfQueryProductsReturnsCorrectResults(string category)
        {
            var context        = PCHUBDbContextInMemoryInitializer.InitializeContext();
            var productService = new ProductServices(context);

            Account cloudinaryCredentials = new Account(
                CloudinaryAccountTests.CloudName,
                CloudinaryAccountTests.ApiKey,
                CloudinaryAccountTests.ApiSecret);

            var cloudinaryUtility = new Cloudinary(cloudinaryCredentials);
            var cloudinary        = new CloudinaryServices(cloudinaryUtility);

            var adminProductServices = new Areas.Administration.Services.AdminProductsServices(context, cloudinary);

            var model = new InsertJsonProductViewModel();

            var laptopsJson = await
                              File.ReadAllTextAsync(
                @"C:\Users\velis\source\repos\PCHUBStore\PCHUBStore.Tests\AdminServicesTests\JSONLaptops\laptops.json");

            var laptops = JsonConvert.DeserializeObject <List <JsonProductModel> >(laptopsJson);

            await adminProductServices.CreateCategoryAsync(category);

            foreach (var laptop in laptops)
            {
                var jsonBasic = JsonConvert.SerializeObject(laptop.BasicChars);

                var jsonAdvanced = JsonConvert.SerializeObject(laptop.AdvancedChars);
                model.Category             = category;
                model.BasicCharacteristics = jsonBasic;
                model.FullCharacteristics  = jsonAdvanced;

                await adminProductServices.CreateLaptopFromJSONAsync(model);
            }

            var filters = new ProductFiltersUrlModel();
            var result  = await productService.QueryProductsAsync(filters, category);

            Assert.Equal(2, result.Count());

            Assert.Contains(result, x => x.Title.Contains("Acer"));

            filters.Make = new string[]
            {
                "Acer",
            };

            filters.MinPrice = "700";
            filters.MaxPrice = "750";

            var secondResultTest = await productService.QueryProductsAsync(filters, category);

            Assert.Equal(1, secondResultTest.Count());

            Assert.Contains(secondResultTest, x => x.ArticleNumber.Contains("83366"));


            filters.Make = new string[]
            {
                "Dell",
            };
            filters.MinPrice = "800";
            filters.MaxPrice = "900";

            var thirdResultTest = await productService.QueryProductsAsync(filters, category);

            Assert.Empty(thirdResultTest);
        }
示例#11
0
        public async Task TestIfQueryMiceReturnsCorrectResults(string category)
        {
            var context        = PCHUBDbContextInMemoryInitializer.InitializeContext();
            var productService = new ProductServices(context);

            Account cloudinaryCredentials = new Account(
                CloudinaryAccountTests.CloudName,
                CloudinaryAccountTests.ApiKey,
                CloudinaryAccountTests.ApiSecret);

            var cloudinaryUtility = new Cloudinary(cloudinaryCredentials);
            var cloudinary        = new CloudinaryServices(cloudinaryUtility);

            var adminProductServices = new Areas.Administration.Services.AdminProductsServices(context, cloudinary);

            var model = new InsertJsonProductViewModel();

            var miceJson = await
                           File.ReadAllTextAsync(
                @"C:\Users\velis\source\repos\PCHUBStore\PCHUBStore.Tests\AdminServicesTests\JSONMice\mice.json");

            var mice = JsonConvert.DeserializeObject <List <JsonProductModel> >(miceJson);

            await adminProductServices.CreateCategoryAsync(category);

            foreach (var mouse in mice)
            {
                var jsonBasic = JsonConvert.SerializeObject(mouse.BasicChars);

                var jsonAdvanced = JsonConvert.SerializeObject(mouse.AdvancedChars);
                model.Category             = category;
                model.BasicCharacteristics = jsonBasic;
                model.FullCharacteristics  = jsonAdvanced;

                await adminProductServices.CreateMouseFromJSONAsync(model);
            }

            var filters = new ProductFiltersUrlModel();

            if (filters.Make == null)
            {
                filters.Make = new string[] { "All" };
            }
            if (filters.Model == null)
            {
                filters.Model = new string[] { "All" };
            }
            if (filters.OrderBy == null)
            {
                filters.OrderBy = "Default";
            }
            if (filters.Processor == null)
            {
                filters.Processor = new string[] { "All" };
            }
            if (filters.VideoCard == null)
            {
                filters.VideoCard = new string[] { "All" };
            }
            if (filters.OS == null)
            {
                filters.OS = new string[] { "All" };
            }
            if (filters.RAM == null)
            {
                filters.RAM = new string[] { "All" };
            }
            if (filters.Resolution == null)
            {
                filters.Resolution = new string[] { "All" };
            }
            if (filters.FPS == null)
            {
                filters.FPS = new string[] { "All" };
            }
            if (filters.ReactionTime == null)
            {
                filters.ReactionTime = new string[] { "All" };
            }
            if (filters.MatrixType == null)
            {
                filters.MatrixType = new string[] { "All" };
            }
            if (filters.DisplaySize == null)
            {
                filters.DisplaySize = new string[] { "All" };
            }
            if (filters.Gaming == null)
            {
                filters.Gaming = new string[] { "All" };
            }
            if (filters.Interface == null)
            {
                filters.Interface = new string[] { "All" };
            }
            if (filters.Connectivity == null)
            {
                filters.Connectivity = new string[] { "All" };
            }
            if (filters.Type == null)
            {
                filters.Type = new string[] { "All" };
            }
            if (filters.Mechanical == null)
            {
                filters.Mechanical = new string[] { "All" };
            }

            var result = await productService.QueryMiceAsync(filters, 50, 100);


            Assert.Equal(2, result.Count());

            Assert.Contains(result, x => x.Title.Contains("Геймърска мишка Kingston HyperX Pulsefire Surge, RGB"));

            filters.Gaming = new string[]
            {
                "ДА",
            };


            var secondResultTest = await productService.QueryMiceAsync(filters, 50, 200);

            Assert.Equal(3, secondResultTest.Count());

            Assert.Contains(secondResultTest, x => x.ArticleNumber.Contains("110703"));


            filters.Make = new string[]
            {
                "Dell",
            };
            filters.MinPrice = "800";
            filters.MaxPrice = "900";

            var thirdResultTest = await productService.QueryMiceAsync(filters, 800, 900);

            Assert.Empty(thirdResultTest);
        }