blogit 1.0.0.rc1 → 1.0.0

data/spec/lib/configuration_spec.rb

@@ -1,15 +1,15 @@
-require "spec_helper"
+require "rails_helper"
 
 describe Blogit::Configuration do
 
   let(:blog_configuration) { @blog_configuration = Blogit::Configuration.new }
 
   it "should set :include_comments to :active_record" do
-    blog_configuration.include_comments.should == :active_record
+    expect(blog_configuration.include_comments).to eq(:active_record)
   end
 
   it "should set :disqus_shortname to blank" do
-    blog_configuration.disqus_shortname.should == ""
+    expect(blog_configuration.disqus_shortname).to be_nil
   end
 
   it "should print a warning to the console if disqus_shortname is set but include_comments is not disqus" do
@@ -18,71 +18,46 @@ describe Blogit::Configuration do
     blog_configuration.disqus_shortname = "bodacious"
   end
 
-  it "should print a warning to the console if twitter_username is set but include_share_bar is false" do
-    blog_configuration.expects(:warn)
-    blog_configuration.include_share_bar = false
-    blog_configuration.twitter_username = "bodacious"
-  end
-
   it "should set :include_share_bar to false" do
-    blog_configuration.include_share_bar.should == false
+    expect(blog_configuration.include_share_bar).to eq(true)
   end
 
   it "should set :twitter_username to blank" do
-    blog_configuration.twitter_username.should == ""
+    expect(blog_configuration.twitter_username).to be_nil
   end
 
   it "should set :current_blogger_method to :current_user" do
-    blog_configuration.current_blogger_method.should eql(:current_user)
+    expect(blog_configuration.current_blogger_method).to eql(:current_user)
   end
 
   it "should set :blogger_display_name_method to :username" do
-    blog_configuration.blogger_display_name_method.should eql(:username)
+    expect(blog_configuration.blogger_display_name_method).to eql(:username)
   end
 
   it "should set :posts_per_page to 5" do
-    blog_configuration.posts_per_page.should eql(5)
+    expect(blog_configuration.posts_per_page).to eql(5)
   end
 
-  it "should set :authentication_method to :login_required" do
-    blog_configuration.authentication_method.should == :login_required
-  end
 
   it "should set datetime format to :short" do
-    blog_configuration.datetime_format.should == :short
-  end
-
-  it "should set author_edits_only to false" do
-    blog_configuration.author_edits_only.should be_false
+    expect(blog_configuration.datetime_format).to eq(:short)
   end
 
   it "should set ajax comments to true" do
-    blog_configuration.ajax_comments.should be_true
-  end
-
-  it "should set include admin actions to true" do
-    blog_configuration.include_admin_actions.should be_true
-  end
-
-  it "should set include admin links to true" do
-    blog_configuration.include_admin_links.should be_true
-  end
-
-  it "should set page caching to false by default" do
-    blog_configuration.cache_pages.should be_false
+    expect(blog_configuration.ajax_comments).to be_truthy
   end
 
   it "should set default_parser to :markdown" do
-    blog_configuration.default_parser.should eql(:markdown)
+    expect(blog_configuration.default_parser).to eql(:markdown)
   end
 
   it "should return default_parser as class with default_parser_class" do
     blog_configuration.default_parser = :textile
-    blog_configuration.default_parser_class.should eql(Blogit::Parsers::TextileParser)
+    expect(blog_configuration.default_parser_class).to eql(Blogit::Parsers::TextileParser)
   end
 
   it "should set redcarpet default options" do
-    blog_configuration.redcarpet_options.should ==
+    expect(blog_configuration.redcarpet_options).to eq(
       {
         hard_wrap: true,
         filter_html: true,
@@ -91,38 +66,35 @@ describe Blogit::Configuration do
         fenced_code_blocks: true,
         gh_blockcode: true
       }
-  end
-
-  it "should set the Pingr mode to :test unless Rails env is production" do
-    Pingr.mode.should eql(:test)
+    )
   end
 
   it "should set highlight_code_syntax to true" do
-    blog_configuration.highlight_code_syntax.should be_true
+    expect(blog_configuration.highlight_code_syntax).to be_truthy
   end
 
   it "should set rss_feed_title to 'Rails engine name Blog Posts'" do
-    blog_configuration.rss_feed_title.should eql "#{Rails.application.engine_name.titleize} Blog Posts"
+    expect(blog_configuration.rss_feed_title).to eql "Dummy Application Blog Posts"
   end
 
   it "should set rss_feed_description to 'Rails engine name Blog Posts'" do
-    blog_configuration.rss_feed_description.should eql "#{Rails.application.engine_name.titleize} Blog Posts"
+    expect(blog_configuration.rss_feed_description).to eql "Latest from Dummy Application"
   end
 
   it "should set layout to nil by default" do
-    blog_configuration.layout.should be_nil
+    expect(blog_configuration.layout).to be_nil
   end
 
   it "should allow layout to be set to a string" do
-    lambda { blog_configuration.layout = "custom" }.should_not raise_error
+    expect { blog_configuration.layout = "custom" }.not_to raise_error
   end
 
   it 'should set active_states default options' do
-    blog_configuration.active_states.should eql([:published])
+    expect(blog_configuration.active_states).to eql([:published])
   end
 
   it 'should set hidden_states default options' do
-    blog_configuration.hidden_states.should eql([:draft, :archive])
+    expect(blog_configuration.hidden_states).to eql([:draft, :archive])
   end
 
 end

data/spec/models/blogit/comment_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe Comment do
   
@@ -9,54 +9,54 @@ describe Comment do
     # nickname is a honey-pot
     it "has a value for nickname" do
       comment.nickname = "Gavin"
-      comment.should_not be_valid
-      comment.should have(1).error_on(:nickname)
+      expect(comment).not_to be_valid
+      expect(comment.errors[:nickname].size).to eq(1)
     end
 
     it "doesn't have a value for name" do
       comment.name = ""
-      comment.should_not be_valid
-      comment.should have(1).error_on(:name)
+      expect(comment).not_to be_valid
+      expect(comment.errors[:name].size).to eq(1)
     end
 
     it "doesn't have a value for email" do
       comment.email = ""
-      comment.should_not be_valid
-      comment.should have(1).error_on(:email)
+      expect(comment).not_to be_valid
+      expect(comment.errors[:email].size).to eql(1)
     end
 
     it "doesn't have a valid email" do
       comment.email = "notvalid.com"
-      comment.should_not be_valid
-      comment.should have(1).error_on(:email)
+      expect(comment).not_to be_valid
+      expect(comment.errors[:email].size).to eql(1)
 
       # has a space
       comment.email = "something else"
-      comment.should_not be_valid
-      comment.should have(1).error_on(:email)
+      expect(comment).not_to be_valid
+      expect(comment.errors[:email].size).to eql(1)
 
       # Has two @s
       comment.email = "gavin@gavin@notvalid.com"
-      comment.should_not be_valid
-      comment.should have(1).error_on(:email)
+      expect(comment).not_to be_valid
+      expect(comment.errors[:email].size).to eq(1)
     end
 
     it "doesn't have a value for body" do
       comment.body = ""
-      comment.should_not be_valid
-      comment.should have(1).error_on(:body)
+      expect(comment).not_to be_valid
+      expect(comment.errors[:body].size).to eq(1)
     end
 
     it "doesn't have at least 4 characters in the body" do
       comment.body = "abc"
-      comment.should_not be_valid
-      comment.should have(1).error_on(:body)
+      expect(comment).not_to be_valid
+      expect(comment.errors[:body].size).to eq(1)
     end
     
     it "doesn't have a valid website url" do
       comment.website = "not valid"
-      comment.should_not be_valid
-      comment.should have(1).error_on(:website)
+      expect(comment).not_to be_valid
+      expect(comment.errors[:website].size).to eq(1)
     end
 
   end

data/spec/models/blogit/post_spec.rb

@@ -1,15 +1,16 @@
-require "spec_helper"
+require "rails_helper"
   
 describe Blogit::Post do
 
   context "should not be valid" do
 
     context "if blogger" do
+      
+      let(:blog_post) { Blogit::Post.new }
 
       it "is nil" do
-        @blog_post = Blogit::Post.new
-        @blog_post.should_not be_valid
-        @blog_post.should have(1).error_on(:blogger_id)
+        expect(blog_post).not_to be_valid
+        expect(blog_post.errors[:blogger_id].size).to eq(1)
       end
 
     end
@@ -20,8 +21,8 @@ describe Blogit::Post do
       end
 
       after do
-        @blog_post.should_not be_valid
-        @blog_post.errors[:title].should_not be_blank
+        expect(@blog_post).not_to be_valid
+        expect(@blog_post.errors[:title]).not_to be_blank
       end
 
       it "is less than 10 characters" do
@@ -40,8 +41,8 @@ describe Blogit::Post do
       end
 
       after do
-        @blog_post.should_not be_valid
-        @blog_post.errors[:body].should_not be_blank
+        expect(@blog_post).not_to be_valid
+        expect(@blog_post.errors[:body]).not_to be_blank
       end
 
       it "is blank" do
@@ -59,8 +60,8 @@ describe Blogit::Post do
       before(:each) { @blog_post = Blogit::Post.new(state: nil) }
 
       it "is nil" do
-        @blog_post.should_not be_valid
-        @blog_post.should have(1).error_on(:state)
+        expect(@blog_post).not_to be_valid
+        expect(@blog_post.errors[:state].size).to eq(1)
       end
 
     end
@@ -68,7 +69,7 @@ describe Blogit::Post do
   end
 
   it "sets the first value of Blogit::configuration.hidden_states as default" do
-    Blogit::Post.new.state.should eql(Blogit::configuration.hidden_states[0].to_s)
+    expect(Blogit::Post.new.state).to eql(Blogit::configuration.hidden_states[0].to_s)
   end
 
   context "with Blogit.configuration.comments == active_record" do
@@ -79,7 +80,7 @@ describe Blogit::Post do
       end
       User.blogs
       @blog_post = Blogit::Post.new
-      lambda { @blog_post.comments }.should_not raise_exception
+      expect { @blog_post.comments }.not_to raise_exception
     end
 
   end
@@ -94,21 +95,21 @@ describe Blogit::Post do
 
     it "should return the display name of the blogger if set" do
       @post = user.blog_posts.build
-      @post.blogger_display_name.should == "Jeronimo"
+      expect(@post.blogger_display_name).to eq("Jeronimo")
       Blogit.configuration.blogger_display_name_method = :password
-      @post.blogger_display_name.should == "password"
+      expect(@post.blogger_display_name).to eq("password")
     end
 
     it "should return an empty string if blogger doesn't exist" do
       Blogit.configuration.blogger_display_name_method = :username
       @post = Blogit::Post.new
-      @post.blogger_display_name.should == ""
+      expect(@post.blogger_display_name).to eq("")
     end
 
     it "should raise an exception if blogger display_name method doesn't exist" do
       Blogit.configuration.blogger_display_name_method = :display_name
       @post = user.blog_posts.build
-      lambda { @post.blogger_display_name }.should raise_exception(Blogit::ConfigurationError)
+      expect { @post.blogger_display_name }.to raise_exception(Blogit::ConfigurationError)
     end
 
   end
@@ -119,32 +120,33 @@ describe Blogit::Post do
 
       before :all do
         Blogit::Post.destroy_all
-        15.times { |i| create :post, created_at: i.days.ago }
+        15.times { |i| create(:post, :active, created_at: i.days.ago) }
       end
 
       it "should order posts by created_at DESC" do
-        Blogit::Post.for_index.first.should == Blogit::Post.order("created_at DESC").first
+        expect(Blogit::Post.for_index.first).to eq(Blogit::Post.order("created_at DESC").first)
       end
 
       it "should paginate posts in blocks of 5" do
-        Blogit::Post.for_index.count.should == 5
+        expect(Blogit::Post.for_index.count).to eq(5)
       end
 
       it "should accept page no as an argument" do
-        Blogit::Post.for_index(2).should == Blogit::Post.order("created_at DESC").offset(5).limit(5)
+        expect(Blogit::Post.for_index(2)).to eq(Blogit::Post.active.
+          order("created_at DESC").offset(5).limit(5))
       end
 
       it "should change the no of posts per page if paginates_per is set" do
         Blogit::Post.paginates_per 3
-        Blogit::Post.for_index.count.should eql(3)
+        expect(Blogit::Post.for_index.count).to eql(3)
       end
 
     end
 
     describe :active do
       it 'should include only posts in active states blogit.config.active_states' do
-        published_post = create(:published_post)
-        Blogit::Post.active.should include (published_post)
+        published_post = create(:post, :active)
+        expect(Blogit::Post.active).to include (published_post)
       end
     end
   end
@@ -157,7 +159,7 @@ describe Blogit::Post do
       end
       User.blogs
       @blog_post = Blogit::Post.new
-      lambda { @blog_post.comments }.should raise_exception(RuntimeError)
+      expect { @blog_post.comments }.to raise_exception(RuntimeError)
     end
 
   end
@@ -166,26 +168,59 @@ describe Blogit::Post do
     it "should not truncate a short body" do
       post = Blogit::Post.new(body: "short body")
 
-      post.short_body.should == post.body
+      expect(post.short_body).to eq(post.body)
     end
 
     it "should not truncate a long body" do
       post = Blogit::Post.new(body: "t\n"*300)
 
-      post.short_body.should == "t\n"*198 + "t..."
+      expect(post.short_body).to eq("t\n"*198 + "t...")
     end
 
     it "should not cut the body in the middle of an image declaration" do
       body = "some text\n"*35 + '"!http://www.images.com/blogit/P6876.thumb.jpg(Look at this)!\":http://www.images.com/blogit/P6976.jpb'
       post = Blogit::Post.new(body: body)
 
-      post.short_body.should_not include('"!http://www.images.com')
+      expect(post.short_body).not_to include('"!http://www.images.com')
     end
   end
+  
+  describe "blogger_twitter_username" do
+    
+    let(:post) { build(:post) }
+    
+    context "when the blogger responds to :twitter_username" do
+      
+      before do
+        class << post.blogger
+          def twitter_username
+            "@gavin_morrice"
+          end
+        end
+      end
+      
+      it "returns the blogger's twitter username" do
+        expect(post.blogger_twitter_username).to eql("@gavin_morrice")
+      end
+      
+    end
+    
+    context "when the blogger doesn't respond to :twitter_username" do
+      
+      before do
+        Blogit.configuration.twitter_username = '@katana_code'
+      end
 
+      it "returns nil" do
+        expect(post.blogger_twitter_username).to be_nil
+      end
+      
+    end
+  end
+  
   describe 'AVAILABLE_STATUS'  do
     it "returns all the statues in Blogit::configuration" do
-      Blogit::Post::AVAILABLE_STATUS.should  == (Blogit.configuration.hidden_states + Blogit.configuration.active_states)
+      expect(Blogit::Post::AVAILABLE_STATUS).to  eq(Blogit.configuration.hidden_states + Blogit.configuration.active_states)
     end
     
   end

data/spec/rails_helper.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+ENV['RAILS_ENV'] ||= 'test'
+ENV["DB"] ||= "sqlite"
+
+require File.expand_path('../dummy/config/environment', __FILE__)
+
+require 'rspec/rails'
+
+require 'factory_girl'
+require 'factories'
+
+require 'support/authentication'
+require 'support/helpers/css_matchers'
+
+silence_stream STDOUT do
+  load "#{Rails.root}/db/schema.rb"
+end if ENV["DB"] == "sqlite"
+
+
+include Blogit
+
+RSpec.configure do |config|
+  config.infer_spec_type_from_file_location! 
+  config.include FactoryGirl::Syntax::Methods
+end
+