Ejemplo n.º 1
0
        public void CreateArticle_When_ArticleDto_isNull_Should_Throw_ArgumentNullException()
        {
            // Act
            Action action = () => { articleService.CreateArticle(null); };

            // Assert
            action.Should().Throw <ArgumentNullException>();
        }
Ejemplo n.º 2
0
        public void CreateArticle_InsertingFailed_ThrowDatabaseException()
        {
            database.Setup(d => d.ArticleRepository.Insert(It.IsNotNull <Article>(), false))
            .ReturnsAsync(false);

            Assert.That(() => articleService.CreateArticle(createRequest),
                        Throws.Exception.TypeOf <DatabaseException>());
        }
Ejemplo n.º 3
0
        public async void NewArticleAdded()
        {
            if (CountryName != null && PurchaserUsername != null)
            {
                Country country = await CountryService.GetCountryWithName(CountryName);

                Profile profile = await ProfileService.GetProfileByUsernameAndpassword(PurchaserUsername, "1234");

                Purchaser purchaser = await PurchaserService.GetPurchaserForProfile(profile.Id);

                Article Article = new Article()
                {
                    PurchaserId                = purchaser.Id,
                    SupplierId                 = Id,
                    CountryId                  = country.Id,
                    VailedForCustomer          = ValidForCustomer,
                    DateCreated                = DateTime.Now,
                    ArticleState               = (int)ArticleState.Created,
                    ArticleInformation         = new ArticleInformation(),
                    InternalArticleInformation = new InternalArticleInformation()
                };

                Article.ArticleInformation.CompanyName           = Supplier.CompanyName;
                Article.ArticleInformation.CompanyLocation       = Supplier.CompanyLocation;
                Article.ArticleInformation.FreightResponsibility = Supplier.FreightResponsibility;
                Article.ArticleInformation.PalletExchange        = Supplier.PalletExchange;
                Article.ArticleInformation.Email = Supplier.Profile.Username;

                Article newArticle = await ArticleService.CreateArticle(Article);

                NavigationManager.NavigateTo($"/supplier_info_form/{newArticle.ArticleInformation.Id}", true);
            }
        }
Ejemplo n.º 4
0
        public void CallSaveChanges_WhenInputDataIsValid()
        {
            // Arrange
            var    contextMock        = new Mock <ITravelGuideContext>();
            var    factoryMock        = new Mock <IArticleFactory>();
            var    commentFactoryMock = new Mock <IArticleCommentFactory>();
            var    id                  = "some name";
            var    title               = "some name";
            var    city                = "some name";
            var    country             = "some content";
            var    contentMain         = "some content";
            var    contnentBudget      = "some content";
            var    contentAccomodation = "some content";
            var    contentMustSee      = "some name";
            var    imageUrl            = "some name";
            var    secondImage         = "some name";
            var    thirdImage          = "some name";
            string coverImage          = "some name";

            contextMock.Setup(x => x.Articles.Add(It.IsAny <Article>()));
            contextMock.Setup(x => x.Users.Find(It.IsAny <string>())).Returns(new User());
            var service = new ArticleService(contextMock.Object, factoryMock.Object, commentFactoryMock.Object);

            // Act
            service.CreateArticle(id, title, city, country, contentMain, contentMustSee, contnentBudget, contentAccomodation, imageUrl, secondImage, thirdImage, coverImage);

            // Assert
            contextMock.Verify(x => x.SaveChanges(), Times.Once);
        }
Ejemplo n.º 5
0
        public void ThrowInvalidOperationException_WhenNoSuchUserIsFound()
        {
            // Arrange
            var    contextMock        = new Mock <ITravelGuideContext>();
            var    factoryMock        = new Mock <IArticleFactory>();
            var    commentFactoryMock = new Mock <IArticleCommentFactory>();
            var    id                  = "some name";
            var    title               = "some name";
            var    city                = "some name";
            var    country             = "some content";
            var    contentMain         = "some content";
            var    contnentBudget      = "some content";
            var    contentAccomodation = "some content";
            var    contentMustSee      = "some name";
            var    imageUrl            = "some name";
            var    secondImage         = "some name";
            var    thirdImage          = "some name";
            string coverImage          = "some name";

            contextMock.Setup(x => x.Users.Find(It.IsAny <string>())).Returns((User)null);
            var service = new ArticleService(contextMock.Object, factoryMock.Object, commentFactoryMock.Object);

            // Act & Assert
            var ex = Assert.Throws <InvalidOperationException>(() => service.CreateArticle(id, title, city, country, contentMain, contentMustSee, contnentBudget, contentAccomodation, imageUrl, secondImage, thirdImage, coverImage));
        }
Ejemplo n.º 6
0
 public ActionResult Create(ArticleGetViewModel journalView)
 {
     if (journalView == null)
     {
         return(HttpNotFound());
     }
     if (ModelState.IsValid)
     {
         _articleService.CreateArticle(journalView);
     }
     return(RedirectToAction("Index"));
 }
Ejemplo n.º 7
0
        public void CreateArticleValidation(string name, DateTime date, string text)
        {
            var mockBlogRepository = new Mock <IBlogRepository>();

            mockBlogRepository.Setup(m => m.Articles.Create(It.IsAny <Article>()));

            var _articleService = new ArticleService(mockBlogRepository.Object);

            Assert.Throws <ValidationException>(() => _articleService.CreateArticle(new ArticleDTO()
            {
                Name = name, Date = date, Text = text
            }));
        }
        public async Task <IActionResult> Post([FromBody] NewArticleRequest newArticleRequest)
        {
            try
            {
                var tokenHeader = Request.Headers["Authorization"];
                var token       = tokenHeader.Count > 0
                    ? tokenHeader.First().Split(' ')[1]
                    : null;

                User currentUser = null;

                if (!string.IsNullOrWhiteSpace(token))
                {
                    currentUser = UserService.GetCurrentUser(token);
                }

                if (currentUser == null)
                {
                    return(Unauthorized());
                }

                var article = await ArticleService.CreateArticle(newArticleRequest.Article, token);

                return(article != null
                    ? Created($"api/articles/{article.Slug}",
                              new SingleArticleResponse
                {
                    Article = new ArticleModel(
                        article.Slug,
                        article.Title,
                        article.Description,
                        article.Body,
                        article.ArticleTags.Select(t => t.Tag.TagName).ToList(),
                        article.CreatedAt,
                        article.UpdatedAt,
                        article.GetFavorited(currentUser),
                        article.FavoritesCount,
                        article.Author.Profile
                        )
                })
                    : (IActionResult)BadRequest("Not created."));
            }
            catch (Exception ex)
            {
                var genericErrorModel = new GenericErrorModel(new GenericErrorModelErrors(new[] { ex.ToString() }));
                return(BadRequest(genericErrorModel));
            }
        }
Ejemplo n.º 9
0
        public async Task <ActionResult <ClientArticle> > Create([FromBody] ArticleChange change)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            try
            {
                return(await service.CreateArticle(change, User));
            }
            catch (Exception e)
            {
                return(BadRequest(e.Message));
            }
        }
Ejemplo n.º 10
0
        public async Task OnSaveArticleClicked()
        {
            Article.Content = await RichTextEditor.GetContentAsync();

            if (string.IsNullOrEmpty(Article.Id))
            {
                Article.Id = Guid.NewGuid().ToString();
            }

            if (string.IsNullOrEmpty(Id))
            {
                await ArticleService.CreateArticle(Article);
            }
            else
            {
                await ArticleService.UpdateArticle(Article);
            }

            NavigationManager.NavigateTo("articles");
        }
Ejemplo n.º 11
0
        public void CreateArticleShouldReturnFalseForWrongArticleType()
        {
            var options   = new DbContextOptionsBuilder <ApplicationDbContext>().UseInMemoryDatabase("Database_For_Tests").Options;
            var dbContext = new ApplicationDbContext(options);
            var service   = new ArticleService(dbContext);

            var model = new ArticleViewModel
            {
                Title                  = "Title",
                ArticleImage           = "Something",
                AdditionalContent      = "Something",
                AdditionalContentImage = "Something",
                Content                = "Something",
                ContentImage           = "Something",
                Type = "Normal",
            };

            var article = service.CreateArticle(model);

            Assert.False(article);
        }
Ejemplo n.º 12
0
        public void ThrowArgumentNullException_WhenPassedCountryIsNull(string country)
        {
            // Arrange
            var contextMock        = new Mock <ITravelGuideContext>();
            var factoryMock        = new Mock <IArticleFactory>();
            var commentFactoryMock = new Mock <IArticleCommentFactory>();
            var id                  = "some name";
            var title               = "some name";
            var city                = "some name";
            var contentMain         = "some content";
            var contnentBudget      = "some content";
            var contentAccomodation = "some content";
            var contentMustSee      = "some content";
            var imageUrl            = "some name";
            var secondImage         = "some name";
            var thirdImage          = "some name";
            var coverImage          = "some name";

            var service = new ArticleService(contextMock.Object, factoryMock.Object, commentFactoryMock.Object);

            // Act & Assert
            var ex = Assert.Throws <ArgumentNullException>(() => service.CreateArticle(id, title, city, country, contentMain, contentMustSee, contnentBudget, contentAccomodation, imageUrl, secondImage, thirdImage, coverImage));
        }
Ejemplo n.º 13
0
        public ActionResult Create(FormCollection form, string submitButton)
        {
            ViewData["articleTypeId_0"] = new SelectList(CreateArticleTypeList(0), "Value", "Text");
            try
            {
                var article = new Articles()
                {
                    articleTypeId = Convert.ToInt32(form["articleTypeId_0"]),
                    body          = form["Body"],
                    dateCreated   = DateTime.Now,
                    headline      = form["headline"],
                    strapline     = form["strapline"]
                };

                _articleService.CreateArticle(article);
                Publish(form, submitButton, article);
                return(RedirectToAction("Index"));
            }
            catch
            {
                return(View());
            }
        }
        public ActionResult <Article> Create(Article newArticle)
        {
            _articleService.CreateArticle(newArticle);

            return(CreatedAtRoute("CreatedArticle", newArticle));
        }
Ejemplo n.º 15
0
        public async Task <IActionResult> CreateArticle([FromBody] CreateArticleInput input)
        {
            var id = await _articleService.CreateArticle(input);

            return(Created($"/api/v1/articles/{id}", null));
        }
        public async Task <ActionResult <Article> > Create(Article article)
        {
            articleService.CreateArticle(article);

            return(CreatedAtAction(nameof(GetById), new { id = article.Id }, article));
        }
Ejemplo n.º 17
0
        public async Task <IActionResult> CreateArticle([FromBody] ArticleCreateDto createArticle)
        {
            var id = await _articleService.CreateArticle(createArticle);

            return(Created($"api/articles/{id}", id));
        }
Ejemplo n.º 18
0
        public async Task UpdateArticleUpdateTheGivenArticle()
        {
            // arrange
            ArticleService   articleService   = new ArticleService(_client);
            PurchaserService purchaserService = new PurchaserService(_client);
            CountryService   countryService   = new CountryService(_client);
            SupplierService  supplierService  = new SupplierService(_client);

            Article article = new Article()
            {
                Id                                  = 0,
                PurchaserId                         = 1,
                CountryId                           = 1,
                SupplierId                          = 1,
                ArticleInformationId                = 0,
                InternalArticleInformationId        = 0,
                VailedForCustomer                   = "Customer",
                DateCreated                         = DateTime.Now,
                ArticleInformationCompleted         = 0,
                InternalArticalInformationCompleted = 0,
                ArticleState                        = 0,
                ErrorReported                       = 0,
                ErrorField                          = "Field",
                ErrorMessage                        = "Message",
                ErrorOwner                          = "Owner",
                ArticleInformation                  = new ArticleInformation(),
                InternalArticleInformation          = new InternalArticleInformation()
            };

            Country country = new Country()
            {
                Id          = 0,
                ProfileId   = 0,
                CountryName = "Name",
                CountryCode = "Code",
                Profile     = new Profile()
                {
                    Id       = 0,
                    Username = "******",
                    Password = "******",
                    Usertype = 0
                }
            };

            Purchaser purchaser = new Purchaser()
            {
                Id        = 0,
                ProfileId = 0,
                CountryId = 1,
                Profile   = new Profile()
                {
                    Id       = 0,
                    Username = "******",
                    Password = "******",
                    Usertype = 2
                }
            };

            Supplier supplier = new Supplier()
            {
                Id                    = 0,
                ProfileId             = 0,
                CompanyName           = "Name",
                CompanyLocation       = "Location",
                FreightResponsibility = "EXW",
                PalletExchange        = 1,
                Profile               = new Profile()
                {
                    Id       = 0,
                    Username = "******",
                    Password = "******",
                    Usertype = 2
                }
            };

            Country countryToDelete = await countryService.CreateCountry(country);

            purchaser.CountryId = countryToDelete.Id;
            Purchaser purchaserToDelete = await purchaserService.CreatePurchaser(purchaser);

            Supplier supplierToDelete = await supplierService.CreateSupplier(supplier);

            article.CountryId   = countryToDelete.Id;
            article.SupplierId  = supplierToDelete.Id;
            article.PurchaserId = purchaserToDelete.Id;
            Article expected = await articleService.CreateArticle(article);

            expected.ArticleState = 3;

            // act
            await articleService.UpdateArticle(expected.Id, expected);

            Article actual = await articleService.GetArticle(expected.Id);

            // assert
            Assert.IsTrue(expected.ArticleState == actual.ArticleState);
            List <Country> now = await countryService.GetCountries();

            await articleService.DeleteArticle(expected.Id);

            await purchaserService.DeletePurchaserForProfile(purchaserToDelete.ProfileId);

            await supplierService.DeleteSupplier(supplierToDelete.Id);

            await countryService.DeleteCountry(countryToDelete.Id);

            await _context.DisposeAsync();

            List <Country> late = await countryService.GetCountries();
        }