proclaim 0.1.0

data/test/models/proclaim/comment_test.rb

@@ -0,0 +1,41 @@
+# == Schema Information
+#
+# Table name: proclaim_comments
+#
+#  id         :integer          not null, primary key
+#  post_id    :integer
+#  parent_id  :integer
+#  author     :string
+#  body       :text
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#
+
+require 'test_helper'
+
+module Proclaim
+	class CommentTest < ActiveSupport::TestCase
+		test "ensure factory is good" do
+			comment = FactoryGirl.build(:comment)
+
+			assert comment.save, "Factory needs to be updated to save successfully"
+		end
+
+		test "ensure body is required" do
+			comment = FactoryGirl.build(:comment, body: "")
+
+			refute comment.save, "Comment should require a body!"
+		end
+
+		test "ensure post is required" do
+			comment = FactoryGirl.build(:comment, post_id: nil)
+
+			refute comment.save, "Comment should require a post_id!"
+
+			# Post with 12345 shouldn't exist
+			comment = FactoryGirl.build(:comment, post_id: 12345)
+
+			refute comment.save, "Comment should require a valid post!"
+		end
+	end
+end

data/test/models/proclaim/image_test.rb

@@ -0,0 +1,70 @@
+# == Schema Information
+#
+# Table name: proclaim_images
+#
+#  id         :integer          not null, primary key
+#  post_id    :integer
+#  image      :string
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#
+
+require 'test_helper'
+
+module Proclaim
+	class ImageTest < ActiveSupport::TestCase
+		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 "ensure factory is good" do
+			image = FactoryGirl.build(:image)
+
+			assert image.save, "Factory needs to be updated to save successfully"
+		end
+
+		test "ensure post is required" do
+			image = FactoryGirl.build(:image, post_id: nil)
+
+			refute image.save, "Image should require a post_id!"
+		end
+
+		test "ensure post validity is verified" do
+			# Post with 12345 shouldn't exist
+			image = FactoryGirl.build(:image, post_id: 12345)
+
+			refute image.save, "Image should require a valid post!"
+		end
+
+		test "ensure image is required" do
+			image = FactoryGirl.build(:image, image: nil)
+
+			refute image.save, "Image should require an image to be uploaded!"
+		end
+
+		test "ensure image is cached, saved, and removed correctly" do
+			image = FactoryGirl.build(:image)
+
+			cache_file_path = File.join(Rails.public_path, image.image.cache_dir, image.image.cache_name)
+			cache_path = File.dirname(cache_file_path)
+
+			assert File.exist?(cache_file_path), "File should have been cached: #{cache_file_path}"
+
+			assert image.save, "Image should have saved!"
+
+			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}"
+			refute File.exist?(cache_file_path), "Should have removed cache file: #{cache_file_path}"
+			refute File.exist?(cache_path), "Should have removed cache path: #{cache_path}"
+
+			assert image.destroy
+
+			refute File.exist?(saved_file_path), "Should have removed file: #{saved_file_path}"
+			refute File.exist?(save_path), "Should have removed saved path: #{save_path}"
+		end
+	end
+end

data/test/models/proclaim/post_test.rb

@@ -0,0 +1,127 @@
+# == Schema Information
+#
+# Table name: proclaim_posts
+#
+#  id               :integer          not null, primary key
+#  author_id        :integer
+#  title            :string           default(""), not null
+#  body             :text             default(""), not null
+#  published        :boolean          default("f"), not null
+#  publication_date :datetime
+#  created_at       :datetime         not null
+#  updated_at       :datetime         not null
+#
+
+require 'test_helper'
+
+module Proclaim
+	class PostTest < ActiveSupport::TestCase
+		test "ensure factory is good" do
+			post = FactoryGirl.build(:post)
+
+			assert post.save, "Factory needs to be updated to save successfully"
+		end
+
+		test "ensure title is required" do
+			post = FactoryGirl.build(:post, title: "")
+
+			refute post.save, "Post should require a title!"
+		end
+
+		test "ensure body is required" do
+			post = FactoryGirl.build(:post, body: nil)
+			refute post.save, "Post should require a body!"
+
+			post = FactoryGirl.build(:post, body: "")
+			refute post.save, "Post should require a body!"
+
+			post = FactoryGirl.build(:post, body: "<p></p>")
+			refute post.save, "Post should require a body to have text!"
+
+			post = FactoryGirl.build(:post, body: "\r\n \n \r")
+			refute post.save, "Post should require a body to have text!"
+
+			post = FactoryGirl.build(:post, body: "<p></p>\r\n<p></p>\n<p></p>\r")
+			refute post.save, "Post should require a body to have text!"
+		end
+
+		test "ensure author is required" do
+			post = FactoryGirl.build(:post, author_id: nil)
+
+			refute post.save, "Post should require an author_id!"
+
+			# Author with 12345 shouldn't exist
+			post = FactoryGirl.build(:post, author_id: 12345)
+
+			refute post.save, "Post should require a valid author!"
+		end
+
+		test "verify publication date requirement" do
+			post = FactoryGirl.build(:post, published_at: nil)
+			assert post.save, "Post should save without a publication date if not published!"
+
+			post = FactoryGirl.build(:post, published_at: DateTime.now)
+			refute post.save, "Post should not save with a publication date if not published!"
+
+			post = FactoryGirl.build(:published_post)
+			post.published_at = nil
+			refute post.save, "Post should not save if published without a publication date!"
+
+			post = FactoryGirl.build(:published_post)
+			assert post.save, "Post should save successfully if published with a publication date!"
+		end
+
+		test "ensure publication date when published" do
+			post = FactoryGirl.build(:post)
+			assert_nil post.published_at
+
+			post.publish
+			assert_not_nil post.published_at
+
+			assert post.save
+		end
+
+		test "verify publication can't be taken back" do
+			post = FactoryGirl.build(:published_post)
+			assert post.save
+
+			assert_raises AASM::NoDirectAssignmentError do
+				post.state = "draft"
+			end
+		end
+
+		test "verify excerpt" do
+			post = FactoryGirl.build(:post, body: "<div><p></p><p></p></div>")
+
+			assert_equal "", post.excerpt
+
+			post = FactoryGirl.build(:post, body: "<p>foo bar baz qux</p><p>y</p>")
+
+			assert_equal "foo bar baz qux", post.excerpt
+
+			post.excerpt_length = 10
+			assert_equal "foo bar", post.excerpt
+
+			post.excerpt_length = 11
+			assert_equal "foo bar baz", post.excerpt
+
+			post.excerpt_length = 12
+			assert_equal "foo bar baz", post.excerpt
+
+			post.excerpt_length = 15
+			assert_equal "foo bar baz qux", post.excerpt
+
+			post = FactoryGirl.build(:post,
+			                         body: "<p>This is <strong>emphasized</strong>. This is a <a href=\"http://example.com\">link</a>.</p><p>foo</p>")
+			assert_equal "This is emphasized. This is a link.", post.excerpt
+
+			post = FactoryGirl.build(:post,
+			                         body: "<p></p><div></div><p>foo</p>")
+			assert_equal "foo", post.excerpt
+
+			post = FactoryGirl.build(:post,
+			                         body: "This is outside.<p>This is inside.</p>")
+			assert_equal "This is outside.", post.excerpt
+		end
+	end
+end

data/test/models/proclaim/subscription_test.rb

@@ -0,0 +1,66 @@
+# == Schema Information
+#
+# Table name: proclaim_subscriptions
+#
+#  id         :integer          not null, primary key
+#  post_id    :integer
+#  email      :string
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#
+
+require 'test_helper'
+
+module Proclaim
+	class SubscriptionTest < ActiveSupport::TestCase
+		test "subscriptions should be unique" do
+			FactoryGirl.create(:subscription, email: "foo@bar.com")
+			subscription = FactoryGirl.build(:subscription, email: "foo@bar.com")
+			refute subscription.save,
+			       "Blog subscriptions should have unique emails!"
+
+			subscription = FactoryGirl.create(:post_subscription, email: "foo@bar.com")
+			subscription = FactoryGirl.build(:post_subscription,
+			                                 post: subscription.post,
+			                                 email: subscription.email)
+			refute subscription.save,
+			       "Post subscriptions should have unique emails!"
+		end
+
+		test "should not save without valid email address" do
+			subscription = FactoryGirl.build(:subscription, email: nil)
+			refute subscription.save,
+			       "Subscription should require an email address!"
+
+			subscription = FactoryGirl.build(:subscription, email: "blah")
+			refute subscription.save,
+			       "Subscription should require a valid email address!"
+		end
+
+		test "token should be able to identify subscriptions" do
+			subscription1 = FactoryGirl.create(:subscription)
+			subscription2 = FactoryGirl.create(:subscription)
+
+			token1 = subscription1.token
+			token2 = subscription2.token
+
+			assert_equal subscription1, Subscription.from_token(token1)
+			assert_equal subscription2, Subscription.from_token(token2)
+		end
+
+		test "should require valid post or none at all" do
+			# Post 12345 doesn't exist
+			subscription = FactoryGirl.build(:subscription, post_id: 12345)
+			refute subscription.save,
+			       "Subscription should require a valid post!"
+
+			subscription = FactoryGirl.build(:subscription,
+			                                 post: FactoryGirl.create(:published_post))
+			assert subscription.save
+
+			subscription = FactoryGirl.build(:subscription, post: nil)
+			assert subscription.save,
+			       "Subscription shouldn't require a post!"
+		end
+	end
+end

data/test/policies/proclaim/comment_policy_test.rb

@@ -0,0 +1,71 @@
+require 'test_helper'
+
+class CommentPolicyTest < ActiveSupport::TestCase
+	test "comment scope" do
+		user = FactoryGirl.create(:user)
+		comment1 = FactoryGirl.create(:comment)
+		comment2 = FactoryGirl.create(:comment)
+
+		# Verify that a user can view both comments
+		comments = Pundit.policy_scope(user, Proclaim::Comment)
+		assert_includes comments, comment1
+		assert_includes comments, comment2
+
+		# Verify that even without a user, both comments can still be viewed
+		comments = Pundit.policy_scope(nil, Proclaim::Comment)
+		assert_includes comments, comment1
+		assert_includes comments, comment2
+	end
+
+	test "comment creation" do
+		user = FactoryGirl.create(:user)
+		publishedComment = FactoryGirl.build(:published_comment)
+		unpublishedComment = FactoryGirl.build(:comment)
+
+		# Verify that a user can create a comment on a published post
+		policy = Proclaim::CommentPolicy.new(user, publishedComment)
+		assert policy.create?,
+		       "A user should be able to create comments on published posts!"
+
+		# Verify that a user can create a comment on an unpublished post
+		policy = Proclaim::CommentPolicy.new(user, unpublishedComment)
+		assert policy.create?,
+		       "A user should be able to create comments on unpublished posts!"
+
+		# Verify that a guest can create a comment on a published post
+		policy = Proclaim::CommentPolicy.new(nil, publishedComment)
+		assert policy.create?,
+		       "A guest should be able to create comments on published posts!"
+
+		# Verify that a guest cannot create a comment on an unpublished post
+		policy = Proclaim::CommentPolicy.new(nil, unpublishedComment)
+		refute policy.create?,
+		       "A guest should not be able to create comments on unpublished posts!"
+	end
+
+	test "comment update" do
+		user = FactoryGirl.create(:user)
+		comment = FactoryGirl.create(:comment)
+
+		# Verify that a user can update a comment
+		policy = Proclaim::CommentPolicy.new(user, comment)
+		assert policy.update?, "A user should be able to update comments!"
+
+		# Verify that a guest cannot update a comment
+		policy = Proclaim::CommentPolicy.new(nil, comment)
+		refute policy.update?, "A guest should not be able to update comments!"
+	end
+
+	test "comment destroy" do
+		user = FactoryGirl.create(:user)
+		comment = FactoryGirl.create(:comment)
+
+		# Verify that a user can destroy a comment
+		policy = Proclaim::CommentPolicy.new(user, comment)
+		assert policy.destroy?, "A user should be able to destroy comments!"
+
+		# Verify that a guest cannot destroy a comment
+		policy = Proclaim::CommentPolicy.new(nil, comment)
+		refute policy.destroy?, "A guest should not be able to destroy comments!"
+	end
+end

data/test/policies/proclaim/post_policy_test.rb

@@ -0,0 +1,87 @@
+require 'test_helper'
+
+class PostPolicyTest < ActiveSupport::TestCase
+	test "post scope" do
+		user = FactoryGirl.create(:user)
+		post1 = FactoryGirl.create(:post)
+		post2 = FactoryGirl.create(:published_post)
+
+		# Verify that a user can see all posts
+		posts = Pundit.policy_scope(user, Proclaim::Post)
+		assert_includes posts, post1
+		assert_includes posts, post2
+
+		# Verify that guests can only see published posts
+		posts = Pundit.policy_scope(nil, Proclaim::Post)
+		assert_not_includes posts, post1
+		assert_includes posts, post2
+	end
+
+
+	test "post create" do
+		user = FactoryGirl.create(:user)
+		post = FactoryGirl.create(:post)
+
+		# Verify that a user can create posts
+		policy = Proclaim::PostPolicy.new(user, post)
+		assert policy.create?
+
+		# Verify that guests can't create posts
+		policy = Proclaim::PostPolicy.new(nil, post)
+		refute policy.create?
+	end
+
+	test "post show" do
+		user = FactoryGirl.create(:user)
+		post1 = FactoryGirl.create(:post)
+		post2 = FactoryGirl.create(:published_post)
+
+		# Verify that a user can see both posts
+		policy = Proclaim::PostPolicy.new(user, post1)
+		assert policy.show?
+		policy = Proclaim::PostPolicy.new(user, post2)
+		assert policy.show?
+
+		# Verify that a guest can only see published post
+		policy = Proclaim::PostPolicy.new(nil, post1)
+		refute policy.show?
+		policy = Proclaim::PostPolicy.new(nil, post2)
+		assert policy.show?
+	end
+
+	test "post update" do
+		user = FactoryGirl.create(:user)
+		post1 = FactoryGirl.create(:post)
+		post2 = FactoryGirl.create(:published_post)
+
+		# Verify that a user can update any post
+		policy = Proclaim::PostPolicy.new(user, post1)
+		assert policy.update?
+		policy = Proclaim::PostPolicy.new(user, post2)
+		assert policy.update?
+
+		# Verify that guests can't update post
+		policy = Proclaim::PostPolicy.new(nil, post1)
+		refute policy.update?
+		policy = Proclaim::PostPolicy.new(nil, post2)
+		refute policy.update?
+	end
+
+	test "post destroy" do
+		user = FactoryGirl.create(:user)
+		post1 = FactoryGirl.create(:post)
+		post2 = FactoryGirl.create(:published_post)
+
+		# Verify that a user can destroy any post
+		policy = Proclaim::PostPolicy.new(user, post1)
+		assert policy.destroy?
+		policy = Proclaim::PostPolicy.new(user, post2)
+		assert policy.destroy?
+
+		# Verify that guests can't destroy post
+		policy = Proclaim::PostPolicy.new(nil, post1)
+		refute policy.destroy?
+		policy = Proclaim::PostPolicy.new(nil, post2)
+		refute policy.destroy?
+	end
+end