proclaim 0.5.6 → 0.6.0

data/test/controllers/proclaim/comments_controller_test.rb

@@ -1,228 +0,0 @@
-require 'test_helper'
-
-module Proclaim
-	class CommentsControllerTest < ActionController::TestCase
-		setup do
-			@routes = Engine.routes
-
-			@controller.stubs(:current_user).returns(nil)
-			@controller.stubs(:authenticate_user).returns(false)
-		end
-
-		test "should create root comment if logged in" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			# Users should be able to make comments on unpublished posts
-			newComment = FactoryGirl.build(:comment)
-			assert_create_comment newComment
-
-			# Users should also be able to make comments on published posts
-			newComment = FactoryGirl.build(:published_comment)
-			assert_create_comment newComment
-		end
-
-		test "should create reply if logged in" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			# Users should be able to make replies to comments on unpublished posts
-			parent = FactoryGirl.create(:comment)
-			reply = FactoryGirl.build(:comment,
-			                          post: parent.post,
-			                          parent: parent)
-			assert_create_comment reply, 1, 1, parent
-
-			# Users should be able to make replies to comments on published posts
-			parent = FactoryGirl.create(:published_comment)
-			reply = FactoryGirl.build(:published_comment,
-			                          post: parent.post,
-			                          parent: parent)
-			assert_create_comment reply, 1, 1, parent
-		end
-
-		test "should create root comment if not logged in" do
-			# Guests should not be able to make comments on unpublished comments
-			newComment = FactoryGirl.build(:comment)
-			refute_create_comment newComment
-
-			# Guests should be able to make comments on published comments
-			newComment = FactoryGirl.build(:published_comment)
-			assert_create_comment newComment
-		end
-
-		test "should create reply if not logged in" do
-			# Guests should not be able to make replies to comments on unpublished posts
-			parent = FactoryGirl.create(:comment)
-			reply = FactoryGirl.build(:comment,
-			                          post: parent.post,
-			                          parent: parent)
-			refute_create_comment reply, 1, 1, parent
-
-			# Guests should be able to make replies to comments on published posts
-			parent = FactoryGirl.create(:published_comment)
-			reply = FactoryGirl.build(:published_comment,
-			                          post: parent.post,
-			                          parent: parent)
-			assert_create_comment reply, 1, 1, parent
-		end
-
-		test "should not create root comment if spammy" do
-			newComment = FactoryGirl.build(:published_comment)
-			refute_create_comment newComment, 1, 2
-		end
-
-		test "should not create reply if spammy" do
-			parent = FactoryGirl.create(:published_comment)
-			reply = FactoryGirl.build(:published_comment,
-			                          post: parent.post,
-			                          parent: parent)
-			refute_create_comment reply, 3, 4, parent
-		end
-
-		test "should update root comment if logged in" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			newComment = FactoryGirl.create(:comment)
-			assert_update_comment newComment
-		end
-
-		test "should not update root comment if not logged in" do
-			newComment = FactoryGirl.create(:comment)
-			refute_update_comment newComment
-		end
-
-		test "should destroy root comment if logged in" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			newComment = FactoryGirl.create(:comment)
-
-			assert_difference('Comment.count', -1) do
-				delete :destroy, format: :json, id: newComment
-			end
-		end
-
-		test "should not destroy root comment if not logged in" do
-			newComment = FactoryGirl.create(:comment)
-
-			assert_no_difference('Comment.count') do
-				delete :destroy, format: :json, id: newComment
-			end
-
-			assert_response :unauthorized
-		end
-
-		private
-
-		def assert_create_comment(comment, antispam_solution = 1,
-		                          antispam_answer = 1, parent = nil,
-		                          subscription = nil)
-			subscription_params = nil
-		   if subscription
-		   	subscription_params = {
-		   		subscribe: true,
-		   		email: subscription.email
-		   	}
-			end
-
-			antispam_params = nil
-			if antispam_solution and antispam_answer
-				antispam_params = {
-					solution: antispam_solution,
-					answer: antispam_answer
-				}
-			end
-
-			assert_difference('Comment.count', 1,
-			                  "A comment should have been created") do
-				post :create, format: :json,
-					comment: {
-						author: comment.author,
-						body: comment.body,
-						post_id: comment.post_id,
-						parent_id: comment.parent_id
-					},
-					subscription: subscription_params,
-					antispam: antispam_params
-			end
-
-			if parent
-				parent.reload # Refresh parent to pull in new associations
-				assert_equal 1, parent.children.count,
-				             "The parent should have a child!"
-
-				newComment = parent.children.first
-				assert_equal comment.author, newComment.author
-				assert_equal comment.body, newComment.body
-			end
-
-			json = JSON.parse(@response.body)
-			assert_not_nil json["id"], "The returned JSON should include the ID!"
-			assert_not_nil json["html"],
-			               "The returned JSON should include the HTML containing the comment!"
-		end
-
-		def refute_create_comment(comment, antispam_solution = 1,
-		                          antispam_answer = 1, parent = nil,
-		                          subscription = nil)
-			subscription_params = nil
-		   if subscription
-		   	subscription_params = {
-		   		subscribe: true,
-		   		email: subscription.email
-		   	}
-			end
-
-			antispam_params = nil
-			if antispam_solution and antispam_answer
-				antispam_params = {
-					solution: antispam_solution,
-					answer: antispam_answer
-				}
-			end
-
-			assert_no_difference('Comment.count',
-			                     "A comment should not be created!") do
-				post :create, format: :json,
-					comment: {
-						author: comment.author,
-						body: comment.body,
-						post_id: comment.post_id,
-						parent_id: comment.parent_id
-					},
-					subscription: subscription_params,
-					antispam: antispam_params
-			end
-
-			if antispam_solution == antispam_answer
-				assert_response :not_found
-			else
-				assert_response :unprocessable_entity
-			end
-		end
-
-		def assert_update_comment(comment)
-			patch :update, format: :json, id: comment, comment: {
-				author: comment.author,
-				body: comment.body,
-				post_id: comment.post_id
-			}
-
-			json = JSON.parse(@response.body)
-			assert_not_nil json["id"]
-			assert_not_nil json["html"]
-		end
-
-		def refute_update_comment(comment)
-			patch :update, format: :json, id: comment, comment: {
-				author: comment.author,
-				body: comment.body,
-				post_id: comment.post_id
-			}
-
-			assert_response :unauthorized
-		end
-	end
-end

data/test/controllers/proclaim/images_controller_test.rb

@@ -1,166 +0,0 @@
-require 'test_helper'
-
-module Proclaim
-	class ImagesControllerTest < ActionController::TestCase
-		setup do
-			@routes = Engine.routes
-
-			@controller.stubs(:current_user).returns(nil)
-			@controller.stubs(:authenticate_user).returns(false)
-		end
-
-		teardown do
-			image = FactoryGirl.build(:image, image: nil)
-			FileUtils.rm_rf(File.join(Rails.public_path, image.image.cache_dir))
-			FileUtils.rm_rf(File.join(Rails.public_path, image.image.store_dir))
-		end
-
-		test "should create image if logged in" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			image = FactoryGirl.build(:image, image: nil)
-
-			assert_difference('Image.count') do
-				post :create, format: :json, image: {
-					post_id: image.post_id,
-					image: Rack::Test::UploadedFile.new(File.join(Rails.root, '../', 'support', 'images', 'test.jpg'))
-				}
-			end
-
-			# Response should be the URL to the newly stored image
-			assert_match image.image.store_dir, @response.body
-		end
-
-		test "should not create image if not logged in" do
-			image = FactoryGirl.build(:image, image: nil)
-
-			assert_no_difference('Image.count') do
-				post :create, format: :json, image: {
-					post_id: image.post_id,
-					image: Rack::Test::UploadedFile.new(File.join(Rails.root, '../', 'support', 'images', 'test.jpg'))
-				}
-			end
-
-			assert_response :unauthorized
-		end
-
-		test "should not create image without a post" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			image = FactoryGirl.build(:image, post: nil, image: nil)
-
-			assert_no_difference('Image.count') do
-				post :create, format: :json, image: {
-					image: Rack::Test::UploadedFile.new(File.join(Rails.root, '../', 'support', 'images', 'test.jpg'))
-				}
-			end
-
-			assert_response :unprocessable_entity
-		end
-
-		test "should not create image without actual image" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			image = FactoryGirl.build(:image, image: nil)
-
-			assert_no_difference('Image.count') do
-				post :create, format: :json, image: {
-					post_id: image.post_id
-				}
-			end
-
-			assert_response :unprocessable_entity
-		end
-
-		test "should cache image if logged in" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			image = FactoryGirl.build(:image, image: nil)
-
-			# This is only caching! No new image should be inserted into the database
-			assert_no_difference('Image.count', "Caching shouldn't create new images!") do
-				post :cache, format: :json, file: Rack::Test::UploadedFile.new(test_image_file_path)
-			end
-
-			# Response should be the URL to the newly cached image
-			assert_match image.image.cache_dir, @response.body
-		end
-
-		test "should not cache image if not logged in" do
-			assert_no_difference('Image.count') do
-				post :cache, format: :json, file: Rack::Test::UploadedFile.new(test_image_file_path)
-			end
-
-			assert_response :unauthorized
-		end
-
-		test "should discard image if logged in" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			image = FactoryGirl.build(:image)
-
-			# This is only discarding from the cache! No images should be removed
-			# from the database.
-			assert_no_difference('Image.count', "Discarding shouldn't remove images!") do
-				post :discard, format: :json, file: image.image.url
-			end
-
-			assert_response :success
-		end
-
-		test "should not discard image if not logged in" do
-			image = FactoryGirl.build(:image)
-
-			assert_no_difference('Image.count') do
-				post :discard, format: :json, file: image.image.url
-			end
-
-			assert_response :unauthorized
-		end
-
-		test "discard should not destroy image if logged in but return ID" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			image = FactoryGirl.create(:image)
-
-			assert_no_difference('Image.count', -1) do
-				post :discard, format: :json, file: image.image.url
-			end
-
-			assert_response :success
-			assert_not_nil @response.body
-			json = JSON.parse(@response.body)
-
-			assert_equal image.id.to_s, json["id"]
-		end
-
-		test "should destroy image if logged in" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			image = FactoryGirl.create(:image)
-
-			assert_difference('Image.count', -1) do
-				delete :destroy, format: :json, id: image.id
-			end
-
-			assert_response :success
-		end
-
-		test "should not destroy image if not logged in" do
-			image = FactoryGirl.create(:image)
-
-			assert_no_difference('Image.count') do
-				delete :destroy, format: :json, id: image.id
-			end
-
-			assert_response :unauthorized
-		end
-	end
-end

data/test/controllers/proclaim/posts_controller_test.rb

@@ -1,465 +0,0 @@
-require 'test_helper'
-
-module Proclaim
-	class PostsControllerTest < ActionController::TestCase
-		setup do
-			@routes = Engine.routes
-
-			@controller.stubs(:current_user).returns(nil)
-			@controller.stubs(:authenticate_user).returns(false)
-		end
-
-		teardown do
-			image = Image.new
-			FileUtils.rm_rf(File.join(Rails.public_path, image.image.cache_dir))
-			FileUtils.rm_rf(File.join(Rails.public_path, image.image.store_dir))
-		end
-
-		test "should get index if logged in" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			post1 = FactoryGirl.create(:post)
-			post2 = FactoryGirl.create(:published_post)
-
-			get :index
-			assert_response :success
-			assert_not_nil assigns(:posts)
-			assert_includes assigns(:posts), post1
-			assert_includes assigns(:posts), post2
-		end
-
-		test "should get index even if not logged in" do
-			post1 = FactoryGirl.create(:post)
-			post2 = FactoryGirl.create(:published_post)
-
-			get :index
-			assert_response :success
-			assert_not_nil assigns(:posts)
-			assert_not_includes assigns(:posts), post1
-			assert_includes assigns(:posts), post2
-		end
-
-		test "posts should be ordered by publication date" do
-			post1 = FactoryGirl.create(:published_post)
-			post2 = FactoryGirl.create(:published_post)
-
-			get :index
-			assert_response :success
-			assert_not_nil assigns(:posts)
-			assert_equal 2, assigns(:posts).count
-			assert_equal post2, assigns(:posts).first
-			assert_equal post1, assigns(:posts).last
-		end
-
-		test "drafts should be ordered by updated date" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			post1 = FactoryGirl.create(:post)
-			post2 = FactoryGirl.create(:post)
-			post3 = FactoryGirl.create(:post)
-
-			# Update post1 so its updated_at is newest
-			post2.body = "Updated Body"
-			post2.save
-
-			get :index
-			assert_response :success
-			assert_not_nil assigns(:posts)
-			assert_equal 3, assigns(:posts).count
-			assert_equal post2, assigns(:posts).first
-			assert_equal post3, assigns(:posts).second
-			assert_equal post1, assigns(:posts).last
-		end
-
-		test "should get new if logged in" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			get :new
-			assert_response :success
-		end
-
-		test "should not get new if not logged in" do
-			get :new
-			assert_response :redirect
-			assert_match /not authorized/, flash[:error]
-		end
-
-		test "should create post if logged in" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			newPost = FactoryGirl.build(:post)
-
-			assert_difference('Post.count') do
-				post :create, post: {
-					author_id: newPost.author_id,
-					body: newPost.body,
-					title: newPost.title
-				}
-			end
-
-			assert_redirected_to post_path(assigns(:post))
-			assert_match /successfully created/, flash[:notice]
-			refute assigns(:post).published?
-		end
-
-		test "should create published post if logged in" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			newPost = FactoryGirl.build(:post)
-
-			assert_difference('Post.count') do
-				post :create, post: {
-					author_id: newPost.author_id,
-					body: newPost.body,
-					title: newPost.title
-				}, publish: "true"
-			end
-
-			assert_redirected_to post_path(assigns(:post))
-			assert_match  /successfully created/, flash[:notice]
-			assert assigns(:post).published?
-		end
-
-		test "should not create post without title" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			newPost = FactoryGirl.build(:post)
-
-			assert_no_difference('Post.count') do
-				post :create, post: {
-					author_id: newPost.author_id,
-					body: newPost.body
-					# Leave off title
-				}
-			end
-
-			assert assigns(:post).errors.any?,
-			       "Expected an error due to lack of post title"
-			assert_template :new, "Expected new view to be rendered again"
-		end
-
-		test "should not create post without body" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			newPost = FactoryGirl.build(:post)
-
-			assert_no_difference('Post.count') do
-				post :create, post: {
-					author_id: newPost.author_id,
-					title: newPost.title
-					# Leave off body
-				}
-			end
-
-			assert assigns(:post).errors.any?,
-			       "Expected an error due to lack of post body"
-			assert_template :new, "Expected new view to be rendered again"
-		end
-
-		test "should upload images when creating post" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			newPost = FactoryGirl.build(:post)
-			image = FactoryGirl.build(:image, post: newPost)
-
-			newPost.body = "<img src=\"#{image.image.url}\"></img>"
-
-			post :create, post: {
-				author_id: newPost.author_id,
-				body: newPost.body,
-				title: newPost.title
-			}
-
-			post = Post.first # This works since there's only one
-			assert_equal 1, post.images.count, "The post should have an image"
-
-			image = post.images.first
-
-			save_path = File.join(Rails.public_path, image.image.store_dir)
-			saved_file_path = File.join(save_path, image.image_identifier)
-			assert File.exist?(saved_file_path), "File should be saved: #{saved_file_path}"
-
-			document = Nokogiri::HTML.fragment(post.body)
-			image_tags = document.css("img")
-			assert_equal 1, image_tags.count, "Post body should have one image tag"
-
-			# Note that, now that the image is saved, this URL is different than
-			# the one submitted to :create
-			assert_equal image.image.url, image_tags.first.attributes["src"].value
-		end
-
-		test "should not create post if not logged in" do
-			newPost = FactoryGirl.build(:post)
-
-			assert_no_difference('Post.count') do
-				post :create, post: {
-					author_id: newPost.author_id,
-					body: newPost.body,
-					title: newPost.title
-				}
-			end
-
-			assert_response :redirect
-			assert_match /not authorized/, flash[:error]
-		end
-
-		test "should show draft post if logged in" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			# Should show draft post
-			newPost = FactoryGirl.create(:post)
-
-			get :show, id: newPost
-			assert_response :success
-			assert_equal newPost, assigns(:post)
-		end
-
-		test "should show published post if logged in" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			# Should show published post
-			newPost = FactoryGirl.create(:published_post)
-
-			get :show, id: newPost
-			assert_response :success
-			assert_equal newPost, assigns(:post)
-		end
-
-		test "should not show draft post if not logged in" do
-			# Should not show draft post
-			newPost = FactoryGirl.create(:post)
-
-			# Controller should hide the "permission denied" in a "not-found"
-			assert_raises ActiveRecord::RecordNotFound do
-				get :show, id: newPost
-			end
-		end
-
-		test "should show published post if not logged in" do
-			# Should show published post
-			newPost = FactoryGirl.create(:published_post)
-
-			get :show, id: newPost
-			assert_response :success
-			assert_equal newPost, assigns(:post)
-		end
-
-		test "should show post via id" do
-			post = FactoryGirl.create(:published_post, title: "New Post")
-
-			# Test with ID
-			get :show, id: post.id
-			assert_response :redirect,
-			                "Visiting a post by ID should redirect to slug"
-			assert_equal post, assigns(:post)
-		end
-
-		test "should show post via slug" do
-			post = FactoryGirl.create(:published_post, title: "New Post")
-
-			# Test with slug
-			get :show, id: post.friendly_id
-			assert_response :success
-			assert_equal post, assigns(:post)
-		end
-
-		test "should not show draft post via old slugs" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			post = FactoryGirl.create(:post, title: "New Post")
-			old_slug = post.friendly_id
-
-			# Now change slug
-			post.title = "New Post Modified"
-			post.save
-
-			# Verify that old slug doesn't work
-			assert_raises ActiveRecord::RecordNotFound,
-			              "Draft posts should not maintain slug history" do
-				get :show, id: old_slug
-			end
-		end
-
-		test "should show published post via old slugs" do
-			post = FactoryGirl.create(:published_post, title: "New Post")
-			old_slug = post.friendly_id
-
-			# Now change slug
-			post.title = "New Post Modified"
-			post.save
-
-			# Verify that old slug still works
-			get :show, id: old_slug
-			assert_response :redirect, "This should redirect to the current slug"
-			assert_equal assigns(:post), post
-		end
-
-		test "should get edit if logged in" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			newPost = FactoryGirl.create(:post)
-
-			get :edit, id: newPost
-			assert_response :success
-			assert_equal assigns(:post), newPost
-		end
-
-		test "should not get edit if not logged in" do
-			newPost = FactoryGirl.create(:post)
-
-			get :edit, id: newPost
-			assert_response :redirect
-			assert_match /not authorized/, flash[:error]
-		end
-
-		test "should update post if logged in" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			newPost = FactoryGirl.create(:post)
-
-			patch :update, id: newPost, post: {
-				author_id: newPost.author_id,
-				body: newPost.body,
-				title: newPost.title
-			}
-
-			assert_redirected_to post_path(assigns(:post))
-			assert_match /successfully updated/, flash[:notice]
-			refute assigns(:post).published?
-		end
-
-		test "should publish post if logged in" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			newPost = FactoryGirl.create(:post)
-
-			patch :update, id: newPost, post: {
-				author_id: newPost.author_id,
-				body: newPost.body,
-				title: newPost.title
-			}, publish: "true"
-
-			assert_redirected_to post_path(assigns(:post))
-			assert_match /successfully updated/, flash[:notice]
-			assert assigns(:post).published?, "Post should now be published!"
-		end
-
-		test "should upload images when updating a post" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			newPost = FactoryGirl.create(:post)
-			image = FactoryGirl.build(:image, post: newPost)
-
-			newPost.body = "<img src=\"#{image.image.url}\">"
-
-			patch :update, id: newPost, post: {
-				author_id: newPost.author_id,
-				body: newPost.body,
-				title: newPost.title
-			}
-
-			post = Post.first # This works since there's only one
-			assert_equal 1, post.images.count, "The post should have an image"
-
-			image = post.images.first
-
-			save_path = File.join(Rails.public_path, image.image.store_dir)
-			saved_file_path = File.join(save_path, image.image_identifier)
-			assert File.exist?(saved_file_path), "File should be saved: #{saved_file_path}"
-
-			document = Nokogiri::HTML.fragment(post.body)
-			image_tags = document.css("img")
-			assert_equal 1, image_tags.count,
-			             "Post body should contain one image tag"
-
-			# Note that, now that the image is saved, this URL is different than
-			# the one submitted to :create
-			assert_equal image.image.url, image_tags.first.attributes["src"].value
-		end
-
-		test "should not update post if not logged in" do
-			newPost = FactoryGirl.create(:post)
-
-			patch :update, id: newPost, post: {
-				author_id: newPost.author_id,
-				body: newPost.body,
-				title: newPost.title
-			}
-
-			assert_response :redirect
-			assert_match /not authorized/, flash[:error]
-		end
-
-		test "should not update post without title" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			newPost = FactoryGirl.create(:post)
-
-			patch :update, id: newPost, post: {
-				author_id: newPost.author_id,
-				title: "" # Remove title
-			}
-
-			assert assigns(:post).errors.any?,
-			       "Expected an error due to lack of post title"
-			assert_template :edit, "Expected edit view to be rendered again"
-		end
-
-		test "should not update post without body" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			newPost = FactoryGirl.create(:post)
-
-			patch :update, id: newPost, post: {
-				author_id: newPost.author_id,
-				body: "" # Remove body
-			}
-
-			assert assigns(:post).errors.any?,
-			       "Expected an error due to lack of post body"
-			assert_template :edit, "Expected edit view to be rendered again"
-		end
-
-		test "should destroy post if logged in" do
-			user = FactoryGirl.create(:user)
-			sign_in user
-
-			newPost = FactoryGirl.create(:post)
-
-			assert_difference('Post.count', -1) do
-				delete :destroy, id: newPost
-			end
-
-			assert_redirected_to posts_path
-			assert_match /successfully destroyed/, flash[:notice]
-		end
-
-		test "should not destroy post if not logged in" do
-			newPost = FactoryGirl.create(:post)
-
-			assert_no_difference('Post.count') do
-				delete :destroy, id: newPost
-			end
-
-			assert_response :redirect
-			assert_match /not authorized/, flash[:error]
-		end
-  end
-end