public void Can_Filter_BlogPosts_By_Tag()
 {
     // Arrange: Given a series of blogposts with tags associated, a repository and a blog controller
     var tag = new Tag {TagID = 1, Name = "tag 1"};
     var tag2 = new Tag {TagID = 2, Name = "tag 2"};
     var blogPost = new BlogPost {ContentID = 1};
     var blogPost2 = new BlogPost() {ContentID = 2};
     var blogPost3 = new BlogPost() {ContentID = 3};
     blogPost.Tags.Add(tag);
     blogPost2.Tags.Add(tag2);
     blogPost3.Tags.Add(tag);
     blogPost3.Tags.Add(tag2);
     // mock blog post repository
     var moqBlogPostRepository = UnitTestHelpers.MockBlogPostRepositoryReturnsMoqObject(blogPost, blogPost2, blogPost3);
     moqBlogPostRepository.
         Setup(x => x.GetQueryableBlogPostByTagName(tag.Name)).             // when a user wants to filter by tag
         Returns((new List<BlogPost> {blogPost, blogPost3}).AsQueryable()); // They will obtain the filtered blogposts
     var controller = new BlogController(moqBlogPostRepository.Object);
     // Act: when the user clicks on a tag
     var result = controller.Tag("tag-1");
     // Assert: the result will be a view with a list of blogposts filtered by tag
     var model = ((BlogPostViewModel) result.ViewData.Model).BlogPostPagedList;
     model.Count.ShouldEqual(2);
     model.Single(x => x.ContentID == 1).ContentID.ShouldEqual(1);
     model.Single(x => x.ContentID == 3).ContentID.ShouldEqual(3);
     Assert.IsNull(model.FirstOrDefault(x => x.ContentID == 2));
 }
 public void Can_Filter_Blogposts_By_Category()
 {
     // Arrange: Given a series of blogs associated with a categories, a repository that manages
     // the access to those blogposts, and a blog controller
     var category = new Category {CategoryID = 1, Name = "category 1"};
     var category2 = new Category {CategoryID = 2, Name = "category 2"};
     var blogPost = new BlogPost { ContentID = 1 };
     var blogPost2 = new BlogPost() { ContentID = 2 };
     var blogPost3 = new BlogPost() { ContentID = 3 };
     blogPost.Categories.Add(category);
     blogPost2.Categories.Add(category2);
     blogPost3.Categories.Add(category);
     var moqBlogPostRepository = UnitTestHelpers.MockBlogPostRepositoryReturnsMoqObject(blogPost, blogPost2,
                                                                                        blogPost3);
     moqBlogPostRepository.
         Setup(x => x.GetQueryableBlogPostByCategory(category.Name)).        // when a user wants to filter by category
         Returns((new List<BlogPost> {blogPost, blogPost3}).AsQueryable());  // They will obtain the filtered blogposts
     var controller = new BlogController(moqBlogPostRepository.Object);
     // Act: when the user clicks on category
     var result = controller.Category("category-1");
     // Assert: the result will be a view with a list of blogposts filtered by category
     var model = ((BlogPostViewModel) result.ViewData.Model).BlogPostPagedList;
     model.Count.ShouldEqual(2);
     model.Single(x => x.ContentID == 1).ContentID.ShouldEqual(1);
     model.Single(x => x.ContentID == 3).ContentID.ShouldEqual(3);
     Assert.IsNull(model.FirstOrDefault(x => x.ContentID == 2));
 }
Esempio n. 3
0
 /// <summary>
 ///  Adds a blog post to the context with its categories
 /// </summary>
 /// <param name="blogPost"></param>
 /// <param name="categories"></param>
 /// <param name="listOfTags"></param>
 public void AddBlogPost(BlogPost blogPost, int[] categories, string listOfTags)
 {
     // add blogPost to Context
     blogPost.IsDraft = true;
     Add(blogPost);
     // add categories
     AddCategoriesToContentContainer(blogPost, categories);
     // add tags
     IEnumerable<string> formattedListOfTags = ExtractTagsFromString(listOfTags);
     AddListOfTagsToContentContainer(blogPost, formattedListOfTags);
 }
Esempio n. 4
0
 public void GivenASeriesOfTags()
 {
     Tag1 = new Tag {Name = "tag 1", TagID = 1};
     Tag2 = new Tag {Name = "tag 2", TagID = 2};
     Tag3 = new Tag {Name = "tag 3", TagID = 3};
     Tag4 = new Tag {Name = "tag 4", TagID = 4};
     Post1 = new BlogPost {ContentID = 1};
     Post2 = new BlogPost {ContentID = 2};
     Tag1.ContentContainers.Add(Post1);
     Tag1.ContentContainers.Add(Post2);
     Tag2.ContentContainers.Add(Post1);
 }
Esempio n. 5
0
 /// <summary>
 /// Gets a IList of Blogposts related to a given blogPost that is passed to the method
 /// Related in terms of categories
 /// </summary>
 /// <param name="blogPost"></param>
 /// <param name="numberOfRelatedPosts"></param>
 /// <returns></returns>
 public IList<BlogPost> GetListOfRelatedBlogPosts(BlogPost blogPost, int numberOfRelatedPosts)
 {
     // simplified solution, check first category
     Category category = blogPost.Categories.FirstOrDefault();
     if (category == null)
     {
         return null;
     }
     else
     {
         var query = from post in GetQueryableEntitySet()
                     from postCategory in post.Categories
                     where postCategory.CategoryID == category.CategoryID
                     orderby post.PublishingDate descending
                     select post;
         return query.Take(numberOfRelatedPosts).ToList();
     }
 }
Esempio n. 6
0
 /// <summary>
 /// Adds a new blogPost to the context
 /// </summary>
 /// <param name="entity"></param>
 public void Add(BlogPost entity)
 {
     _context.ContentContainers.AddObject(entity);
 }
Esempio n. 7
0
        private void FixupBlogPost(BlogPost previousValue)
        {
            if (previousValue != null && previousValue.Comments.Contains(this))
            {
                previousValue.Comments.Remove(this);
            }

            if (BlogPost != null)
            {
                if (!BlogPost.Comments.Contains(this))
                {
                    BlogPost.Comments.Add(this);
                }
                if (BlogPostID != BlogPost.ContentID)
                {
                    BlogPostID = BlogPost.ContentID;
                }
            }
            else if (!_settingFK)
            {
                BlogPostID = null;
            }
        }
Esempio n. 8
0
 /// <summary>
 /// Deletes a blogPost from the context
 /// </summary>
 /// <param name="entity"></param>
 public void Delete(BlogPost entity)
 {
     _context.ContentContainers.DeleteObject(entity);
 }
Esempio n. 9
0
 /// <summary>
 /// Method that manages the post of the CreateBlogPost action when the user clicks on the 'Publish' Button.
 /// It saves the blogpost and publishes it
 /// </summary>
 /// <param name="blogPost"></param>
 /// <param name="categoryID"></param>
 /// <param name="listOfTags"></param>
 /// <returns></returns>
 private ActionResult CreateBlogPost_OnPublish(BlogPost blogPost, int[] categoryID, string listOfTags)
 {
     // Add BlogPost to Context
     BlogPostRepo.AddBlogPost(blogPost, categoryID, listOfTags);
     BlogPostRepo.PublishBlogPost(blogPost);
     // Submits changes
     // BlogPostRepo.SubmitChanges();
     // Redirects to Index with a message for the user
     TempData[vinCMS.Infraestructure.Constants.VIEW_MESSAGE] = SUCCESS_PUBLISH;
     return RedirectToAction("Index");
 }
 public void Can_Get_A_Related_List_Of_BLogPosts()
 {
     // Arrange: Given a series of blogposts that are related by tags and categories, a repository
     // that manages those blogposts and a blog controller
     // categories
     var category = new Category() { CategoryID = 1, Name = "category 1" };
     var category2 = new Category() { CategoryID = 2, Name = "category 2" };
     // blogposts
     var blogPost = new BlogPost() { ContentID = 1 , Title = "blogPost 1", Path="blogpost-1", PublishingDate = DateTime.Now};
     var blogPost2 = new BlogPost() { ContentID = 2 };
     var blogPost3 = new BlogPost() { ContentID = 3 };
     var blogPost4 = new BlogPost()  { ContentID = 4 };
     // add categories to blogposts
     blogPost.Categories.Add(category);
     blogPost2.Categories.Add(category2);
     blogPost3.Categories.Add(category);
     // create mock repository
     var moqBlogPostRepository = UnitTestHelpers.MockBlogPostRepositoryReturnsMoqObject(blogPost, blogPost2,
                                                                                        blogPost3);
     const int numberOfRelatedPosts = 5;
     //moq get by id
     moqBlogPostRepository.Setup(x => x.GetByPath(blogPost.PublishingDate.Year,
                                     blogPost.PublishingDate.Month,
                                     blogPost.PublishingDate.Day, blogPost.Path)).Returns(blogPost);
     //moq getQueryableRelatedBlogPosts
     moqBlogPostRepository.
         Setup(x => x.GetListOfRelatedBlogPosts(blogPost, numberOfRelatedPosts)). // when a user wants to get related posts
         Returns((new List<BlogPost> { blogPost3 }));                  // They will obtain the related posts
     var controller = new BlogController(moqBlogPostRepository.Object);
     // Act: when the user goes into the detail screen
     var result = controller.Details(blogPost.PublishingDate.Year,
                                     blogPost.PublishingDate.Month,
                                     blogPost.PublishingDate.Day,
                                     blogPost.Path);
     // Assert: then he can see a series of related blogposts
     var viewResult = ((ViewResult) result);
     var model = ((BlogPostDetailModel) viewResult.ViewData.Model);
     model.HasRelatedBlogPosts.ShouldEqual(true);
     model.RelatedBlogPosts.Count.ShouldEqual(1);
 }
Esempio n. 11
0
 /// <summary>
 /// Updates an edited blog post. Updates it changes to the persistence layer.
 /// </summary>
 /// <param name="blogPost"></param>
 /// <param name="categoryId"></param>
 /// <param name="listOfTags"></param>
 /// <param name="submitButton"></param>
 /// <returns></returns>
 private ActionResult UpdateEditedBlogPost(BlogPost blogPost, int[] categoryId, string listOfTags, string submitButton)
 {
     // Update through model binding
     TryUpdateModel(blogPost);
     // Update tags and categories
     BlogPostRepo.UpdatePost(blogPost, categoryId, listOfTags);
     switch (submitButton)
     {
         case "Save":
             TempData[vinCMS.Infraestructure.Constants.VIEW_MESSAGE] = SUCCESS_EDIT;
             break;
         case "Publish":
             if (blogPost.IsDraft)
             {
                 BlogPostRepo.PublishBlogPost(blogPost);
                 TempData[vinCMS.Infraestructure.Constants.VIEW_MESSAGE] = SUCCESS_EDITPUBLISH;
             }
             else
             {
                 TempData[vinCMS.Infraestructure.Constants.VIEW_MESSAGE] = SUCCESS_EDIT_ALREADY_PUBLISHED;
             }
             break;
     }
     // Submit changes to context
     // BlogPostRepo.SubmitChanges();
     // Send back to index
     return RedirectToAction("previewblogpost", new{id = blogPost.ContentID});
 }
Esempio n. 12
0
 /// <summary>
 /// Method that manages the post of the CreateBlogPost action when the user clicks on the
 /// 'Preview' Button. It saves the blogpost as a draft and shows a preview to the user
 /// </summary>
 /// <param name="blogPost"></param>
 /// <param name="categoryID"></param>
 /// <param name="listOfTags"></param>
 /// <returns></returns>
 private ActionResult CreateBlogPost_OnPreview(BlogPost blogPost, int[] categoryID, string listOfTags)
 {
     // Add BlogPost to Context
     BlogPostRepo.AddBlogPost(blogPost, categoryID, listOfTags);
     // Submits changes
     // BlogPostRepo.SubmitChanges();
     // Redirects to PreviewBlogPostAction
     return RedirectToAction("PreviewBlogPost", new { id=blogPost.ContentID});
 }
Esempio n. 13
0
 /// <summary>
 /// Method that publishes a specific post that receives as an argument
 /// </summary>
 /// <param name="blogPost"></param>
 public void PublishBlogPost(BlogPost blogPost)
 {
     blogPost.IsDraft = false;
     blogPost.PublishingDate = DateTime.Now;
 }
Esempio n. 14
0
 public void GivenASeriesOfBlogPosts()
 {
     // blogposts
     BlogPost1 = new BlogPost { ContentID = 1, PublishingDate = DateTime.Today};
     BlogPost2 = new BlogPost { ContentID = 2, PublishingDate = DateTime.Today.AddDays(1)};
     BlogPost3 = new BlogPost { ContentID = 3, PublishingDate = DateTime.Today.AddDays(2)};
     BlogPost4 = new BlogPost { ContentID = 4, PublishingDate = DateTime.Today.AddDays(3)};
     BlogPost5 = new BlogPost { ContentID = 5, PublishingDate = DateTime.Today.AddDays(4)};
     BlogPost6 = new BlogPost { ContentID = 6, PublishingDate = DateTime.Today.AddDays(5)};
     // drafts
     BlogPost7 = new BlogPost { ContentID = 7, IsDraft = true, PublishingDate = DateTime.Today.AddDays(6)};
     // blogpost filled by user
     BlogPostFilledByUser = new BlogPost
     {
         ContentID = 11,
         AuthorID = 1,
         BodyContent = "Content",
         Title = "Title",
         CreationDate = DateTime.Now,
         PublishingDate = DateTime.Now,
         IsDraft = true
     };
     // blogpost that is not a draft
     BlogPostNotDraft = new BlogPost() { ContentID = 20, IsDraft = false };
 }
Esempio n. 15
0
 public void GivenANewBlogPostThatHasBeenCreatedAndFilledInByTheUser()
 {
     BlogPostFilledByUser = new BlogPost
                                {
                                    ContentID = 11,
                                    AuthorID = 1,
                                    BodyContent = "Content",
                                    Title = "Title",
                                    CreationDate = DateTime.Now,
                                    PublishingDate = DateTime.Now,
                                    IsDraft = true
                                };
 }
Esempio n. 16
0
 public void GivenABlogPostThatIsNotADraft()
 {
     BlogPostNotDraft = new BlogPost() {ContentID = 20, IsDraft = false};
 }
Esempio n. 17
0
 /// <summary>
 /// Checks whether or not the given url is canonical and has the proper format
 /// </summary>
 /// <param name="blogPost"></param>
 /// <param name="year"></param>
 /// <param name="month"></param>
 /// <param name="day"></param>
 /// <param name="title"></param>
 /// <param name="id"></param>
 /// <returns></returns>
 private bool IsCanonicalUrl(BlogPost blogPost, int year, int month, int day, string title, int id)
 {
     // To avoid accessing url helper and couple the controller with the routing system
     // I use simple yet not very good looking check
     return (blogPost.ContentID == id &&
             blogPost.PublishingDate.Year == year &&
             blogPost.PublishingDate.Month == month &&
             blogPost.PublishingDate.Day == day &&
             Helpers.Routing.RoutingHelpers.MakeSimpleUrlSegment(blogPost.Title) == title);
     /* RouteValueDictionary receivedRouteValues = new RouteValueDictionary
                                                    {
                                                        {"controller", "blog"},
                                                        {"action", "details"},
                                                        {"year", year},
                                                        {"month", month},
                                                        {"day", day},
                                                        {"title", title},
                                                        {"id", id}
                                                    };
      * */
     // If the received route is equal to the expected canonical route then True!
     // return Url.RouteUrl(receivedRouteValues) == Url.RouteUrl(expectedRouteValues);
 }
Esempio n. 18
0
 /// <summary>
 /// Method that updates a blog that has been edited. Deleting the categories and tags with which
 /// it is not longer associated and adding new categories and tags if there are any
 /// </summary>
 /// <param name="blogPost"></param>
 /// <param name="categoryId"></param>
 /// <param name="listOfTags"></param>
 public void UpdatePost(BlogPost blogPost, int[] categoryId, string listOfTags)
 {
     UpdateCategoriesInContentContainer(blogPost, categoryId);
     UpdateTagsInContentContainer(blogPost, listOfTags);
 }
        public void Can_View_A_Selected_BlogPost()
        {
            //Arrange: Given a series of blog posts, a repository and a controller
            const int year = 2010;
            const int month = 10;
            const int day = 10;
            BlogPost selectedBlogPost = new BlogPost
                                            {
                                                ContentID = 1,
                                                Title = "This is a post title",
                                                Path = "this-is-a-post-title",
                                                PublishingDate = new DateTime(year, month, day),
                                            };

            var moqBlogPostRepository = UnitTestHelpers.MockBlogPostRepositoryReturnsMoqObject(selectedBlogPost,
                                                                            new BlogPost() {ContentID = 2});
            moqBlogPostRepository.Setup(x => x.GetByPath(year,  month, day, selectedBlogPost.Path)).Returns(selectedBlogPost);
            var controller = new BlogController(moqBlogPostRepository.Object);
            //Act: if the user clicks on one of the blogpost
            var result = controller.Details(year, month, day,                           // Date
                                            selectedBlogPost.Path);                     // path
            var view = (ViewResult) result;
            //Assert: then the user will be able to see the content of the blogpost
            ((BlogPostDetailModel) view.ViewData.Model).BlogPost.ContentID.ShouldEqual(1);
        }
Esempio n. 20
0
 /// <summary>
 /// Adds a comment to a blog posts
 /// </summary>
 /// <param name="blogPost"></param>
 /// <param name="comment"></param>
 public void AddCommentToBlogPost(BlogPost blogPost, Comment comment)
 {
     comment.CommentDate = DateTime.Now;
     comment.CommentContent = FormatCommentComment(comment.CommentContent);
     blogPost.Comments.Add(comment);
 }
Esempio n. 21
0
 public ActionResult CreateBlogPost(BlogPost blogPost, int[] categoryID, string listOfTags, string submitButton)
 {
     if (!ModelState.IsValid)
     {
         // get list of all categories again, and show form
         ViewData[vinCMS.Infraestructure.Constants.VIEW_CATEGORYLIST] =
             BlogPostRepo.GetListOfCategories();
         return View(blogPost);
     }
     else
     {
         switch (submitButton)
         {
             case "Preview":
                 return CreateBlogPost_OnPreview(blogPost, categoryID, listOfTags);
             case "Publish":
                 return CreateBlogPost_OnPublish(blogPost, categoryID, listOfTags);
             default:
                 return RedirectToAction("Index");
         }
     }
 }