proclaim 0.5.6 → 0.6.0

data/test/models/proclaim/subscription_test.rb

@@ -1,77 +0,0 @@
-# == 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 require a name" do
-			subscription = FactoryGirl.build(:subscription, name: nil)
-			refute subscription.save, "Subscription should require a name!"
-		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 "an invalid token should raise a NotFound" do
-			assert_raises ActiveRecord::RecordNotFound do
-				Subscription.from_token("123456")
-			end
-		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/application_policy_test.rb

@@ -1,87 +0,0 @@
-require 'test_helper'
-
-class ApplicationPolicyTest < ActiveSupport::TestCase
-	test "application index" do
-		user = FactoryGirl.create(:user)
-
-		# Verify that a user cannot visit the index by default
-		policy = ApplicationPolicy.new(user, nil)
-		refute policy.index?, "A user should be not able to visit the index by default"
-
-		# Verify that a guest cannot visit the index by default
-		policy = ApplicationPolicy.new(nil, nil)
-		refute policy.index?, "A guest should not be able to visit the index by default"
-	end
-
-	test "application show" do
-		user = FactoryGirl.create(:user)
-
-		# Verify that a user cannot view an object by default
-		policy = ApplicationPolicy.new(user, nil)
-		refute policy.show?, "A user should be not able to view an object by default"
-
-		# Verify that a guest cannot view an object by default
-		policy = ApplicationPolicy.new(nil, nil)
-		refute policy.show?, "A guest should not be able to view an object by default"
-	end
-
-	test "application create" do
-		user = FactoryGirl.create(:user)
-
-		# Verify that a user cannot create an object by default
-		policy = ApplicationPolicy.new(user, nil)
-		refute policy.create?, "A user should be not able to create an object by default"
-
-		# Verify that a guest cannot create an object by default
-		policy = ApplicationPolicy.new(nil, nil)
-		refute policy.create?, "A guest should not be able to create an object by default"
-	end
-
-	test "application new" do
-		user = FactoryGirl.create(:user)
-
-		# Verify that a user cannot visit the new action by default
-		policy = ApplicationPolicy.new(user, nil)
-		refute policy.new?, "A user should be not able to visit the new action by default"
-
-		# Verify that a guest cannot visit the new action by default
-		policy = ApplicationPolicy.new(nil, nil)
-		refute policy.new?, "A guest should not be able to visit the new action by default"
-	end
-
-	test "application update" do
-		user = FactoryGirl.create(:user)
-
-		# Verify that a user cannot update an object by default
-		policy = ApplicationPolicy.new(user, nil)
-		refute policy.update?, "A user should be not able to update an object by default"
-
-		# Verify that a guest cannot update an object by default
-		policy = ApplicationPolicy.new(nil, nil)
-		refute policy.update?, "A guest should not be able to update an object by default"
-	end
-
-	test "application edit" do
-		user = FactoryGirl.create(:user)
-
-		# Verify that a user cannot visit the edit action by default
-		policy = ApplicationPolicy.new(user, nil)
-		refute policy.edit?, "A user should be not able to visit the edit action by default"
-
-		# Verify that a guest cannot visit the edit action by default
-		policy = ApplicationPolicy.new(nil, nil)
-		refute policy.edit?, "A guest should not be able to visit the edit action by default"
-	end
-
-	test "application destroy" do
-		user = FactoryGirl.create(:user)
-
-		# Verify that a user cannot destroy an object by default
-		policy = ApplicationPolicy.new(user, nil)
-		refute policy.destroy?, "A user should be not able to destroy an object by default"
-
-		# Verify that a guest cannot destroy an object by default
-		policy = ApplicationPolicy.new(nil, nil)
-		refute policy.destroy?, "A guest should not be able to destroy an object by default"
-	end
-end

data/test/policies/proclaim/comment_policy_test.rb

@@ -1,71 +0,0 @@
-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/image_policy_test.rb

@@ -1,83 +0,0 @@
-require 'test_helper'
-
-class ImagePolicyTest < ActiveSupport::TestCase
-	teardown do
-		image = Proclaim::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 "image scope" do
-		user = FactoryGirl.create(:user)
-		image = FactoryGirl.create(:image)
-
-		# Verify that a user can view the image
-		images = Pundit.policy_scope(user, Proclaim::Image)
-		assert_includes images, image
-
-		# Verify that a guest cannot see any images
-		images = Pundit.policy_scope(nil, Proclaim::Image)
-		assert_empty images
-	end
-
-	test "image caching" do
-		user = FactoryGirl.create(:user)
-		image = FactoryGirl.build(:image)
-
-		# Verify that a user can cache an image
-		policy = Proclaim::ImagePolicy.new(user, image)
-		assert policy.cache?, "A user should be able to cache images"
-
-		# Verify that a guest cannot cache an image
-		policy = Proclaim::ImagePolicy.new(nil, image)
-		refute policy.cache?, "A guest should not be able to cache images"
-	end
-
-	test "image creation" do
-		user = FactoryGirl.create(:user)
-		image = FactoryGirl.build(:image)
-
-		# Verify that a user can create an image
-		policy = Proclaim::ImagePolicy.new(user, image)
-		assert policy.create?, "A user should be able to create images"
-
-		# Verify that a guest cannot create an image
-		policy = Proclaim::ImagePolicy.new(nil, image)
-		refute policy.create?, "A guest should not be able to create images"
-	end
-
-	test "image discard" do
-		user = FactoryGirl.create(:user)
-		cached_image = FactoryGirl.build(:image)
-		saved_image = FactoryGirl.create(:image)
-
-		# Verify that a user can discard a cached image
-		policy = Proclaim::ImagePolicy.new(user, cached_image)
-		assert policy.discard?, "A user should be able to discard a cached image"
-
-		# Verify that a user can discard a saved image
-		policy = Proclaim::ImagePolicy.new(user, saved_image)
-		assert policy.discard?, "A user should be able to discard a saved image"
-
-		# Verify that a guest cannot discard a cached image
-		policy = Proclaim::ImagePolicy.new(nil, cached_image)
-		refute policy.discard?, "A guest should not be able to discard a cached image"
-
-		# Verify that a guest cannot discard a saved image
-		policy = Proclaim::ImagePolicy.new(nil, saved_image)
-		refute policy.discard?, "A guest should not be able to discard a saved image"
-	end
-
-	test "image destroy" do
-		user = FactoryGirl.create(:user)
-		image = FactoryGirl.create(:image)
-
-		# Verify that a user can destroy an image
-		policy = Proclaim::ImagePolicy.new(user, image)
-		assert policy.destroy?, "A user should be able to destroy image"
-
-		# Verify that a guest cannot destroy an image
-		policy = Proclaim::ImagePolicy.new(nil, image)
-		refute policy.destroy?, "A guest should not be able to destroy image"
-	end
-end

data/test/policies/proclaim/post_policy_test.rb

@@ -1,98 +0,0 @@
-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 index" do
-		user = FactoryGirl.create(:user)
-
-		# Verify that a user can visit the index
-		policy = Proclaim::PostPolicy.new(user, Proclaim::Post)
-		assert policy.index?, "A user should be able to visit the index"
-
-		# Verify that a guest can also visit the index
-		policy = Proclaim::PostPolicy.new(nil, Proclaim::Post)
-		assert policy.index?, "A guest should be able to visit the index"
-	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

data/test/policies/proclaim/subscription_policy_test.rb

@@ -1,103 +0,0 @@
-require 'test_helper'
-
-class SubscriptionPolicyTest < ActiveSupport::TestCase
-	test "subscription scope" do
-		user = FactoryGirl.create(:user)
-		subscription1 = FactoryGirl.create(:subscription)
-		subscription2 = FactoryGirl.create(:subscription)
-
-		# Verify that a user can view both subscriptions
-		subscriptions = Pundit.policy_scope(user, Proclaim::Subscription)
-		assert_includes subscriptions, subscription1
-		assert_includes subscriptions, subscription2
-
-		# Verify that without a user, no subscription can be seen
-		subscriptions = Pundit.policy_scope(nil, Proclaim::Subscription)
-		assert_empty subscriptions
-	end
-
-	test "subscription index" do
-		user = FactoryGirl.create(:user)
-
-		# Verify that a user can visit the index
-		policy = Proclaim::SubscriptionPolicy.new(user, Proclaim::Subscription)
-		assert policy.index?, "A user should be able to visit the index"
-
-		# Verify that a guest cannot visit the index
-		policy = Proclaim::SubscriptionPolicy.new(nil, Proclaim::Subscription)
-		refute policy.index?, "A guest should not be able to visit the index"
-	end
-
-	test "subscription show" do
-		user = FactoryGirl.create(:user)
-		subscription = FactoryGirl.create(:subscription)
-
-		# Verify that a user can view a subscription
-		policy = Proclaim::SubscriptionPolicy.new(user, subscription)
-		assert policy.show?, "A user should be able to view a subscription"
-
-		# Verify that a guest can also view a subscription
-		policy = Proclaim::SubscriptionPolicy.new(nil, subscription)
-		assert policy.show?, "A guest should be able to view a subscription"
-	end
-
-	test "subscription creation" do
-		user = FactoryGirl.create(:user)
-
-		# Verify that a user can create a subscription to the blog
-		subscription = FactoryGirl.build(:subscription)
-		policy = Proclaim::SubscriptionPolicy.new(user, subscription)
-		assert policy.create?, "A user should be able to create subscriptions to the blog"
-
-		# Verify that a user can create a subscription to an unpublished post
-		subscription = FactoryGirl.build(:post_subscription)
-		policy = Proclaim::SubscriptionPolicy.new(user, subscription)
-		assert policy.create?, "A user should be able to create subscriptions to unpublished posts"
-
-		# Verify that a user can create a subscription to a published post
-		subscription = FactoryGirl.build(:published_post_subscription)
-		policy = Proclaim::SubscriptionPolicy.new(user, subscription)
-		assert policy.create?, "A user should be able to create subscriptions to published posts"
-
-		# Verify that a guest can create a subscription to the blog
-		subscription = FactoryGirl.build(:subscription)
-		policy = Proclaim::SubscriptionPolicy.new(nil, subscription)
-		assert policy.create?, "A guest should be able to create subscriptions to the blog"
-
-		# Verify that a guest cannot create a subscription to an unpublished post
-		subscription = FactoryGirl.build(:post_subscription)
-		policy = Proclaim::SubscriptionPolicy.new(nil, subscription)
-		refute policy.create?, "A guest should not be able to create subscriptions to unpublished posts"
-
-		# Verify that a guest can create a subscription to a published post
-		subscription = FactoryGirl.build(:published_post_subscription)
-		policy = Proclaim::SubscriptionPolicy.new(nil, subscription)
-		assert policy.create?, "A guest should be able to create subscriptions to published posts"
-	end
-
-	test "subscription update" do
-		user = FactoryGirl.create(:user)
-		subscription = FactoryGirl.create(:subscription)
-
-		# Verify that a even a user can't update a subscription
-		policy = Proclaim::SubscriptionPolicy.new(user, subscription)
-		refute policy.update?, "A user should not be able to update subscriptions!"
-
-		# Verify that a guest cannot update a subscription
-		policy = Proclaim::SubscriptionPolicy.new(nil, subscription)
-		refute policy.update?, "A guest should not be able to update subscription!"
-	end
-
-	test "subscription destroy" do
-		user = FactoryGirl.create(:user)
-		subscription = FactoryGirl.create(:subscription)
-
-		# Verify that a user can destroy a subscription
-		policy = Proclaim::SubscriptionPolicy.new(user, subscription)
-		assert policy.destroy?, "A user should be able to destroy subscriptions!"
-
-		# Verify that a guest can also destroy a subscription
-		policy = Proclaim::SubscriptionPolicy.new(nil, subscription)
-		assert policy.destroy?, "A guest should be able to destroy subscriptions!"
-	end
-end