days 0.2.0 → 1.0.0.rc1

data/spec/controllers/admin/users_spec.rb

@@ -2,8 +2,7 @@ require 'spec_helper'
 
 describe Days::App, type: :controller do
   describe "admin: users" do
-    fixtures :users
-    let(:user)  { users(:blogger) }
+    let(:user) { Days::User.create!(login_name: 'blogger', name: 'blogger', password: 'x', password_confirmation: 'x') }
 
     before { login(user) }
 
@@ -12,13 +11,13 @@ describe Days::App, type: :controller do
 
       it_behaves_like 'an admin page'
 
-      it { should be_ok }
+      it { is_expected.to be_ok }
 
       it "lists up users" do
-        render[:data].should == :'admin/users/index'
+        expect(render[:data]).to eq(:'admin/users/index')
 
         users = render[:ivars][:@users]
-        users.should == Days::User.all
+        expect(users).to eq(Days::User.all)
       end
     end
 
@@ -27,19 +26,18 @@ describe Days::App, type: :controller do
 
       it_behaves_like 'an admin page'
 
-      it { should be_ok }
+      it { is_expected.to be_ok }
 
       it "renders form page" do
-        render[:data].should == :'admin/users/form'
+        expect(render[:data]).to eq(:'admin/users/form')
         user = render[:ivars][:@user]
-        user.should be_a(Days::User)
-        user.should be_new_record
+        expect(user).to be_a(Days::User)
+        expect(user).to be_new_record
       end
     end
 
     describe "POST /admin/users" do
       subject { post '/admin/users', params, env }
-      let(:user) { Days::User.last }
       let(:user_params) do
         {
           name: "Writer", login_name: "writer",
@@ -51,26 +49,26 @@ describe Days::App, type: :controller do
       it_behaves_like 'an admin page'
 
       it "creates user" do
-        subject.should be_redirect
+        expect(subject).to be_redirect
 
         user = Days::User.last
-        user.name.should == "Writer"
-        user.login_name.should == "writer"
+        expect(user.name).to eq("Writer")
+        expect(user.login_name).to eq("writer")
       end
 
       context "when user is invalid" do
         before do
-          Days::User.any_instance.stub(:valid? => false, :save => false)
+          allow_any_instance_of(Days::User).to receive_messages(:valid? => false, :save => false)
         end
 
-        specify { subject.status.should == 406 } # not acceptable
+        specify { expect(subject.status).to eq(406) } # not acceptable
 
         it "renders form" do
-          render[:data].should == :'admin/users/form'
+          expect(render[:data]).to eq(:'admin/users/form')
           iuser = render[:ivars][:@user]
-          iuser.should be_a_new_record
-          iuser.name.should == 'Writer'
-          iuser.login_name.should == 'writer'
+          expect(iuser).to be_a_new_record
+          expect(iuser.name).to eq('Writer')
+          expect(iuser.login_name).to eq('writer')
         end
       end
     end
@@ -81,14 +79,15 @@ describe Days::App, type: :controller do
       it_behaves_like 'an admin page'
 
       it "renders form page" do
-        render[:data].should == :'admin/users/form'
-        render[:ivars][:@user].should == user
+        expect(render[:data]).to eq(:'admin/users/form')
+        expect(render[:ivars][:@user]).to eq(user)
       end
 
       context "with invalid user" do
-        let(:user) { double.tap { |_| _.stub(id: Days::User.last.id.succ) } }
+        let(:user2) { Days::User.create!(login_name: 'blogger2', name: 'blogger2', password: 'x', password_confirmation: 'x') }
+        before { login(user2); user.destroy }
 
-        it { should be_not_found }
+        it { is_expected.to be_not_found }
       end
     end
 
@@ -101,45 +100,46 @@ describe Days::App, type: :controller do
       it_behaves_like 'an admin page'
 
       it "updates user" do
-        subject.should be_redirect
-        URI.parse(subject['Location']).path.should == path
+        expect(subject).to be_redirect
+        expect(URI.parse(subject['Location']).path).to eq(path)
 
         user.reload
-        user.name.should == 'Newbie'
+        expect(user.name).to eq('Newbie')
       end
 
       context "when invalid" do
         before do
-          Days::User.any_instance.stub(:valid? => false, :save => false)
+          allow_any_instance_of(Days::User).to receive_messages(:valid? => false, :save => false)
         end
 
         it "renders form" do
-          render[:data].should == :'admin/users/form'
+          expect(render[:data]).to eq(:'admin/users/form')
           iuser = render[:ivars][:@user]
-          iuser.id.should == user.id
-          iuser.name.should == 'Newbie'
+          expect(iuser.id).to eq(user.id)
+          expect(iuser.name).to eq('Newbie')
         end
       end
 
       context "with invalid user" do
-        let(:user) { double.tap { |_| _.stub(id: Days::User.last.id.succ) } }
+        let(:user2) { Days::User.create!(login_name: 'blogger2', name: 'blogger2', password: 'x', password_confirmation: 'x') }
+        before { login(user2); user.destroy }
 
-        it { should be_not_found }
+        it { is_expected.to be_not_found }
       end
     end
 
     describe "DELETE /admin/users/:id" do
-      let(:another_user) { users(:writer) }
+      let!(:another_user) { Days::User.create!(login_name: 'blogger2', name: 'blogger2', password: 'x', password_confirmation: 'x') }
       subject { delete "/admin/users/#{another_user.id}", {}, env }
 
       it_behaves_like 'an admin page'
 
       it "destroys user" do
         expect { subject }.to change { Days::User.count }.by(-1)
-        Days::User.where(id: another_user.id).count.should be_zero
+        expect(Days::User.where(id: another_user.id).count).to be_zero
 
-        subject.should be_redirect
-        URI.parse(subject.location).path.should == "/admin/users"
+        expect(subject).to be_redirect
+        expect(URI.parse(subject.location).path).to eq("/admin/users")
       end
 
       context "when tried to delete myself" do
@@ -148,15 +148,14 @@ describe Days::App, type: :controller do
         it "doesn't destroy" do
           expect { subject }.to_not change { Days::User.count }
 
-          subject.status.should == 400
+          expect(subject.status).to eq(400)
         end
       end
 
       context "with invalid user" do
-        subject { delete "/admin/users/#{user.id}", {}, env }
-        let(:user) { users(:blogger).tap(&:destroy) }
+        before { another_user.destroy }
 
-        it { should be_not_found }
+        it { is_expected.to be_not_found }
       end
     end
   end

data/spec/controllers/entries_spec.rb

@@ -2,54 +2,58 @@ require 'spec_helper'
 
 describe Days::App, type: :controller do
   describe "entry page" do
-    fixtures :categories, :entries
     let(:path) { '/2012/12/slug' }
     subject { get path, {}, {} }
 
     before do
-      Days::App.any_instance.should_receive(:lookup_entry).at_least(:once).with(path).and_return(result)
+      expect_any_instance_of(Days::App).to receive(:lookup_entry).at_least(:once).with(path).and_return(result)
     end
 
-    let(:result) { entries(:entry_one) }
+    let(:result) { Days::Entry.create!(title: 'foo', body: 'foo') }
 
-    it { should be_ok }
+    it { is_expected.to be_ok }
 
     it "renders entry.haml" do
-      render[:data].should == :entry
-      render[:options][:locals][:entry].should == result
+      expect(render[:data]).to eq(:entry)
+      expect(render[:options][:locals][:entry]).to eq(result)
     end
 
     context "when lookup_entry returned nil" do
       let(:result) { nil }
 
-      it { should be_not_found }
+      it { is_expected.to be_not_found }
     end
 
     context "when lookup_entry returned Array" do
-      let(:result) { [entries(:entry_one), entries(:entry_two)] }
+      let(:result) {
+        [
+          Days::Entry.create!(title: 'foo', body: 'foo'),
+          Days::Entry.create!(title: 'foo2', body: 'foo')
+        ]
+      }
 
-      it { should be_ok }
+      it { is_expected.to be_ok }
 
       it "renders entry.haml" do
-        render[:data].should == :entries
-        render[:ivars][:@entries].should == result
+        expect(render[:data]).to eq(:entries)
+        expect(render[:ivars][:@entries]).to eq(result)
       end
     end
   end
 
   describe "redirection from old path" do
-    fixtures :categories, :entries
     let(:path) { nil }
     subject { get path, {}, {} }
 
     before do
-      Days::App.any_instance.stub(lookup_entry: nil)
+      allow_any_instance_of(Days::App).to receive_messages(lookup_entry: nil)
+      Days::Entry.create!(title: 'new', body: 'foo', old_path:  '/post/old-path', published_at: Time.local(2012,11,30,0,0,0))
     end
 
     context "when entry not found" do
       let(:path) { '/post/like-old-but-not-exists' }
 
-      it { should be_not_found }
+      it { is_expected.to be_not_found }
     end
 
     context "when entry found by old path" do
@@ -57,98 +61,123 @@ describe Days::App, type: :controller do
 
       it "redirects to present path" do
         expect(subject.status).to eq 301
-        expect(subject['Location']).to eq '/2012/11/today-is-a-rainy-day'
+        expect(subject['Location']).to eq '/2012/11/new'
       end
     end
   end
 
   describe "GET /:year/:month" do
-    fixtures :categories, :entries
     subject { get '/2012/12', params }
     let(:params) { {} }
 
-    it { should be_ok }
+    before do
+      Days::Entry.create!(title: '1', body: 'a', published_at: Time.local(2012, 11, 15, 0, 0, 0))
+      Days::Entry.create!(title: '2', body: 'a', published_at: Time.local(2012, 12, 25, 0, 0, 0))
+      Days::Entry.create!(title: '3', body: 'a', published_at: Time.local(2012, 12, 5, 0, 0, 0))
+    end
+
+    it { is_expected.to be_ok }
 
     it "renders entries" do
-      render[:data].should == :entries
+      expect(render[:data]).to eq(:entries)
 
       base = Time.local(2012, 12, 1, 0, 0, 0)
       range = (base.beginning_of_month .. base.end_of_month)
-      render[:ivars][:@entries].to_a.should == Days::Entry.where(published_at: range).published.to_a
-      render[:ivars][:@entries].current_page.should == 1
+      expect(render[:ivars][:@entries].to_a).to eq(Days::Entry.where(published_at: range).published.to_a)
+      expect(render[:ivars][:@entries].current_page).to eq(1)
     end
 
     context "with page param" do
       let(:params) { {page: 2} }
 
       it "renders entries" do
-        render[:data].should == :entries
-        render[:ivars][:@entries].current_page.should == 2
+        expect(render[:data]).to eq(:entries)
+        expect(render[:ivars][:@entries].current_page).to eq(2)
       end
     end
 
     context "with character" do
       it "returns not found" do
-        get('/aaa/01').should   be_not_found
-        get('/2012/bbb').should be_not_found
-        get('/aaa/bbb').should  be_not_found
+        expect(get('/aaa/01')).to   be_not_found
+        expect(get('/2012/bbb')).to be_not_found
+        expect(get('/aaa/bbb')).to  be_not_found
       end
     end
   end
 
   describe "GET /category/:name" do
-    fixtures :categories, :entries
-    subject { get '/category/daily', params }
+    subject { get '/category/cat', params }
     let(:params) { {} }
 
-    it { should be_ok }
+    it { is_expected.to be_ok }
+
+    let!(:category) { Days::Category.create!(name: 'cat') }
+    let!(:entry) { Days::Entry.create!(title: 'a', body: 'a', categories: [category]) }
 
     it "renders entries" do
-      render[:data].should == :entries
+      expect(render[:data]).to eq(:entries)
 
-      render[:ivars][:@entries].to_a.should == categories(:daily).entries.published.to_a
-      render[:ivars][:@entries].current_page.should == 1
+      expect(render[:ivars][:@entries].to_a).to eq(category.entries.reload.published.to_a)
+      expect(render[:ivars][:@entries].current_page).to eq(1)
     end
 
     context "with page param" do
       let(:params) { {page: 2} }
 
       it "renders entries" do
-        render[:data].should == :entries
-        render[:ivars][:@entries].current_page.should == 2
+        expect(render[:data]).to eq(:entries)
+        expect(render[:ivars][:@entries].current_page).to eq(2)
       end
     end
   end
 
   describe "GET /" do
-    fixtures :categories, :entries
     subject { get '/', params }
     let(:params) { {} }
 
+    before do
+      Days::Entry.create!(title: '1', body: 'a', published_at: Time.local(2012, 11, 15, 0, 0, 0))
+      Days::Entry.create!(title: '2', body: 'a', published_at: Time.local(2012, 12, 25, 0, 0, 0))
+    end
+
+    let!(:draft) do
+      Days::Entry.create!(title: '3', body: 'a', draft: true)
+    end
+
     it "renders entries" do
-      render[:data].should == :entries
-      render[:ivars][:@entries].current_page.should == 1
-      render[:ivars][:@entries].should_not include(entries(:entry_draft))
+      expect(render[:data]).to eq(:entries)
+      expect(render[:ivars][:@entries].current_page).to eq(1)
+      expect(render[:ivars][:@entries]).not_to include(draft)
     end
 
     context "with page param" do
       let(:params) { {page: 2} }
 
       it "renders entries" do
-        render[:data].should == :entries
-        render[:ivars][:@entries].current_page.should == 2
+        expect(render[:data]).to eq(:entries)
+        expect(render[:ivars][:@entries].current_page).to eq(2)
       end
     end
   end
 
   describe "GET /feed" do
-    fixtures :categories, :entries
     subject { get '/feed' }
 
-    it { should be_ok }
+    it { is_expected.to be_ok }
+
+    specify do
+      expect(subject.content_type).to eq('application/atom+xml')
+    end
+  end
+
+  describe "GET /feed/category/:name" do
+    let!(:category) { Days::Category.create!(name: 'cat') }
+    subject { get '/feed/category/cat' }
+
+    it { is_expected.to be_ok }
 
     specify do
-      subject.content_type.should == 'application/atom+xml'
+      expect(subject.content_type).to eq('application/atom+xml')
     end
   end
 end

data/spec/helpers_spec.rb

@@ -6,35 +6,24 @@ describe Days::Helpers do
 
   let(:config) do
     double.tap do |_|
-      _.stub(permalink: permalink)
+      allow(_).to receive_messages(permalink: permalink)
     end
   end
 
-  let(:entry_a) do
-    Days::Entry.where(slug: "sushi").first
-  end
-
-  let(:entry_b) do
-    Days::Entry.where(slug: "neko").first
-  end
-
-  before(:all) do
-    Days::Entry.destroy_all
-    entry_a = Days::Entry.create(
+  let!(:entry_a) do
+    Days::Entry.create!(
       title: 'Sushi', body: 'Sushi!',
       published_at: Time.local(2012, 12, 31, 9, 24, 42),
       slug: "sushi"
     )
-    entry_b = Days::Entry.create(
+  end
+
+  let!(:entry_b) do
+    Days::Entry.create!(
       title: 'Neko', body: 'Meow!',
       published_at: Time.local(2012, 12, 31, 19, 14, 32),
       slug: "neko"
     )
-
-  end
-
-  after(:all) do
-    Days::Entry.destroy_all
   end
 
   let(:permalink) { "/{year}/{month}/{day}/{hour}/{minute}/{second}/{id}-{slug}" }
@@ -42,26 +31,26 @@ describe Days::Helpers do
   describe ".#entry_path" do
     subject { entry_path(entry_a) }
 
-    it { should == "/2012/12/31/09/24/42/#{entry_a.id}-sushi" }
+    it { is_expected.to eq("/2012/12/31/09/24/42/#{entry_a.id}-sushi") }
 
     context "with invalid format (unbalanced parenthesis)" do
       let(:permalink) { "/{year}/{month}/{day/{hour}/{minute}/{second}/{id}-{slug" }
 
-      it { should == "/2012/12/{day/09/24/42/#{entry_a.id}-{slug" }
+      it { is_expected.to eq("/2012/12/{day/09/24/42/#{entry_a.id}-{slug") }
     end
 
     context "with invalid format (invalid tag name)" do
       let(:permalink) { "/{foo}-{slug}" }
 
-      it { should == "/-sushi" }
+      it { is_expected.to eq("/-sushi") }
     end
 
     context "with not published entry" do
       before do
-        entry_a.stub(published?: false)
+        allow(entry_a).to receive_messages(published?: false)
       end
 
-      it { should be_nil }
+      it { is_expected.to be_nil }
     end
   end
 
@@ -71,26 +60,26 @@ describe Days::Helpers do
 
     let(:path) { "/2012/12/31/09/24/42/#{entry_a.id}-sushi" }
 
-    it { should == entry_a }
+    it { is_expected.to eq entry_a }
 
     context "with invalid link" do
       let(:path) { "/2012/12/31/09/24//#{entry_a.id}-sushi" }
 
-      it { should be_nil }
+      it { is_expected.to be_nil }
     end
 
     context "with another format" do
       let(:permalink) { "/{year}/{month}/{day}/{slug}" }
       let(:path) { "/2012/12/31/sushi" }
 
-      it { should == entry_a }
+      it { is_expected.to eq(entry_a) }
     end
 
     context "with invalid format (unbalanced parenthesis)" do
       let(:permalink) { "/{year}/{month}/{day/{slug}" }
       let(:path) { "/2012/12/31/sushi" }
 
-      it { should be_nil }
+      it { is_expected.to be_nil }
     end
 
     context "with invalid format (invalid tag name)" do
@@ -102,7 +91,7 @@ describe Days::Helpers do
       let(:permalink) { "/{year}/{month}/{day}" }
       let(:path) { "/2012/12/31" }
 
-      it { should == [entry_a, entry_b] }
+      it { is_expected.to eq([entry_a, entry_b]) }
     end
 
     context "when entry has not published" do
@@ -111,7 +100,7 @@ describe Days::Helpers do
         entry_a.save
       end
 
-      it { should be_nil }
+      it { is_expected.to be_nil }
     end
   end
 end