days 0.2.0 → 1.0.0.rc1

data/spec/controllers/admin/entries_spec.rb

@@ -2,24 +2,76 @@ require 'spec_helper'
 
 describe Days::App, type: :controller do
   describe "admin: entries" do
-    fixtures :users, :categories, :entries
-    let(:entry) { entries(:entry_one) }
-    let(:user)  { users(:blogger) }
+    let!(:entry) { Days::Entry.create!(title: 'foo', body: 'foo') }
+    let!(:draft) { Days::Entry.create!(title: 'draft', body: 'foo', draft: true) }
+    let!(:scheduled) { Days::Entry.create!(title: 'scheduled', body: 'foo', published_at: Time.now + (86400 * 365)) }
+    let(:user)  { Days::User.create!(login_name: 'blogger', name: 'blogger', password: 'x', password_confirmation: 'x') }
 
     before { login(user) }
 
     describe "GET /admin/entries" do
+      let(:now) { Time.now }
+
+      before do
+        # fix the time to fix time in SQL statement (might have difference in microsec)
+        allow(Time).to receive(:now).and_return(now)
+      end
+
       subject { get '/admin/entries', {}, env }
 
       it_behaves_like 'an admin page'
 
-      it { should be_ok }
+      it { is_expected.to be_ok }
 
       it "lists up entries" do
-        render[:data].should == :'admin/entries/index'
+        expect(render[:data]).to eq(:'admin/entries/index')
 
         entries = render[:ivars][:@entries]
-        entries.should == Days::Entry.order('id DESC').all
+        expect(entries).to eq(Days::Entry.order(id: :desc).page(nil))
+      end
+
+      describe "with page" do
+        subject { get '/admin/entries?page=2', {}, env }
+
+        it "lists up entries for specified page" do
+          expect(render[:data]).to eq(:'admin/entries/index')
+
+          entries = render[:ivars][:@entries]
+          expect(entries).to eq(Days::Entry.order(id: :desc).page(2))
+        end
+      end
+
+      describe "with draft=1" do
+        subject { get '/admin/entries?draft=1', {}, env }
+
+        it "lists up drafts" do
+          expect(render[:data]).to eq(:'admin/entries/index')
+
+          entries = render[:ivars][:@entries]
+          expect(entries).to eq(Days::Entry.order(id: :desc).draft.page(nil))
+        end
+      end
+
+      describe "with scheduled=1" do
+        subject { get '/admin/entries?scheduled=1', {}, env }
+
+        it "lists up scheduled entries" do
+          expect(render[:data]).to eq(:'admin/entries/index')
+
+          entries = render[:ivars][:@entries]
+          expect(entries).to eq(Days::Entry.order(id: :desc).scheduled.page(1))
+        end
+      end
+
+      describe "with published=1" do
+        subject { get '/admin/entries?published=1', {}, env }
+
+        it "lists up published entries" do
+          expect(render[:data]).to eq(:'admin/entries/index')
+
+          entries = render[:ivars][:@entries]
+          expect(entries).to eq(Days::Entry.order(id: :desc).published.page(nil))
+        end
       end
     end
 
@@ -28,13 +80,13 @@ 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/entries/form'
+        expect(render[:data]).to eq(:'admin/entries/form')
         entry = render[:ivars][:@entry]
-        entry.should be_a(Days::Entry)
-        entry.should be_new_record
+        expect(entry).to be_a(Days::Entry)
+        expect(entry).to be_new_record
       end
     end
 
@@ -47,26 +99,56 @@ describe Days::App, type: :controller do
       it_behaves_like 'an admin page'
 
       it "creates entry" do
-        subject.should be_redirect
+        expect(subject).to be_redirect
 
-        entry.title.should == "Hello"
-        entry.body.should == "World"
-        entry.user.should == user
+        entry = Days::Entry.last
+        expect(entry.title).to eq("Hello")
+        expect(entry.body).to eq("World")
+        expect(entry.user).to eq(user)
       end
 
       context "when entry is invalid" do
         before do
-          Days::Entry.any_instance.stub(:valid? => false, :save => false)
+          allow_any_instance_of(Days::Entry).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/entries/form'
+          expect(render[:data]).to eq(:'admin/entries/form')
           ientry = render[:ivars][:@entry]
-          ientry.should be_a_new_record
-          ientry.title.should == 'Hello'
-          ientry.body.should == 'World'
+          expect(ientry).to be_a_new_record
+          expect(ientry.title).to eq('Hello')
+          expect(ientry.body).to eq('World')
+        end
+      end
+
+      context "with config.html_pipeline" do
+        let(:pipeline) do
+          double('pipeline')
+        end
+
+        let(:entry) do
+          Days::Entry.new(entry_params)
+        end
+
+        before do
+          Days::App.config.html_pipeline = pipeline
+          allow(Days::Entry).to receive(:new).and_return(entry)
+        end
+
+        it "sets pipeline to entry" do
+          allow(entry).to receive(:save).and_wrap_original do |m, *args|
+            expect(entry.pipeline).to eq(pipeline)
+            entry.pipeline = nil
+            m.call
+          end
+
+          expect(subject).to be_redirect
+        end
+
+        after do
+          Days::App.config.html_pipeline = nil
         end
       end
 
@@ -79,11 +161,12 @@ describe Days::App, type: :controller do
           {entry: entry_params.merge(categories: categories)}
         end
 
-        it { should be_redirect }
+        it { is_expected.to be_redirect }
 
         it "creates entry with categories" do
           subject
-          entry.categories.reload.map(&:id).should == Days::Category.pluck(:id)
+          entry = Days::Entry.last
+          expect(entry.categories.reload.map(&:id)).to eq(Days::Category.pluck(:id))
         end
       end
     end
@@ -94,14 +177,14 @@ describe Days::App, type: :controller do
       it_behaves_like 'an admin page'
 
       it "renders form page" do
-        render[:data].should == :'admin/entries/form'
-        render[:ivars][:@entry].should == entry
+        expect(render[:data]).to eq(:'admin/entries/form')
+        expect(render[:ivars][:@entry]).to eq(entry)
       end
 
       context "with invalid entry" do
-        let(:entry) { double.tap { |_| _.stub(id: Days::Entry.last.id.succ) } }
+        before { entry.destroy }
 
-        it { should be_not_found }
+        it { is_expected.to be_not_found }
       end
     end
 
@@ -114,43 +197,71 @@ describe Days::App, type: :controller do
       it_behaves_like 'an admin page'
 
       it "updates entry" 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)
 
         entry.reload
-        entry.title.should == 'New'
-        entry.body.should == 'a rainy day'
+        expect(entry.title).to eq('New')
+        expect(entry.body).to eq('foo')
       end
 
       context "when invalid" do
         before do
-          Days::Entry.any_instance.stub(:valid? => false, :save => false)
+          allow_any_instance_of(Days::Entry).to receive_messages(:valid? => false, :save => false)
         end
 
         it "renders form" do
-          render[:data].should == :'admin/entries/form'
+          expect(render[:data]).to eq(:'admin/entries/form')
           ientry = render[:ivars][:@entry]
-          ientry.id.should == entry.id
-          ientry.title.should == 'New'
-          entry.title.should == 'Today was'
+          expect(ientry.id).to eq(entry.id)
+          expect(ientry.title).to eq('New')
+
+          entry.reload
+          expect(entry.title).to eq('foo')
         end
       end
 
       context "with category" do
+        let(:category) { Days::Category.create!(name: 'daily') }
         let(:params) do
-          {entry: {categories: {categories(:rainy).id.to_s => '1'}}}
+          {entry: {categories: {category.id.to_s => '1'}}}
         end
 
         it "creates entry with categories" do
-          subject.should be_redirect
-          entry.categories.reload.map(&:id).should == [categories(:rainy).id]
+          expect(subject).to be_redirect
+          expect(entry.reload.categories.reload.map(&:id)).to eq([category.id])
         end
       end
 
       context "with invalid entry" do
-        let(:entry) { double.tap { |_| _.stub(id: Days::Entry.last.id.succ) } }
+        before { entry.destroy }
+
+        it { is_expected.to be_not_found }
+      end
+
+      context "with config.html_pipeline" do
+        let(:pipeline) do
+          double('pipeline')
+        end
+
+        before do
+          Days::App.config.html_pipeline = pipeline
+          expect(Days::Entry).to receive(:find_by).with(id: entry.id.to_s).and_return(entry)
+        end
+
+        it "sets pipeline to entry" do
+          allow(entry).to receive(:save).and_wrap_original do |m, *args|
+            expect(entry.pipeline).to eq(pipeline)
+            entry.pipeline = nil
+            m.call
+          end
 
-        it { should be_not_found }
+          expect(subject).to be_redirect
+        end
+
+        after do
+          Days::App.config.html_pipeline = nil
+        end
       end
     end
 
@@ -161,14 +272,14 @@ describe Days::App, type: :controller do
 
       it "destroys entry" do
         expect { subject }.to change { Days::Entry.where(id: entry.id).count }.from(1).to(0)
-        subject.should be_redirect
-        URI.parse(subject.location).path.should == "/admin/entries"
+        expect(subject).to be_redirect
+        expect(URI.parse(subject.location).path).to eq("/admin/entries")
       end
 
       context "with invalid entry" do
-        let(:entry) { double.tap { |_| _.stub(id: Days::Entry.last.id.succ) } }
+        before { entry.destroy }
 
-        it { should be_not_found }
+        it { is_expected.to be_not_found }
       end
     end
 

data/spec/controllers/admin/session_spec.rb

@@ -2,27 +2,18 @@ require 'spec_helper'
 
 describe Days::App, type: :controller do
   describe "admin: sessions" do
-    let(:user) do
+    let!(:user) do
       Days::User.create(
         name: 'Blogger', login_name: 'blogger',
         password: 'password', password_confirmation: 'password'
       )
     end
 
-    before do
-      Days::User.destroy_all
-      user
-    end
-
-    after do
-      user.destroy
-    end
-
     describe "GET /admin/login" do
       subject { get '/admin/login' }
 
       it "renders login page" do
-        render[:data].should == :'admin/login'
+        expect(render[:data]).to eq(:'admin/login')
       end
     end
 
@@ -36,15 +27,15 @@ describe Days::App, type: :controller do
       end
 
       it "redirects to /admin" do
-        subject.should be_redirect
-        URI.parse(subject.location).path.should == '/admin'
+        expect(subject).to be_redirect
+        expect(URI.parse(subject.location).path).to eq('/admin')
       end
 
       context "without login name" do
         let(:params) { {password: 'password'} }
 
         specify do
-          subject.status.should == 400
+          expect(subject.status).to eq(400)
         end
       end
 
@@ -52,7 +43,7 @@ describe Days::App, type: :controller do
         let(:params) { {login_name: 'blogger'} }
 
         specify do
-          subject.status.should == 400
+          expect(subject.status).to eq(400)
         end
       end
 
@@ -61,12 +52,12 @@ describe Days::App, type: :controller do
 
         it "doesn't log in" do
           subject
-          session[:user_id].should be_nil
+          expect(session[:user_id]).to be_nil
         end
 
         it "returns login page" do
-          subject.status.should == 401
-          render[:data].should == :'admin/login'
+          expect(subject.status).to eq(401)
+          expect(render[:data]).to eq(:'admin/login')
         end
       end
 
@@ -75,12 +66,12 @@ describe Days::App, type: :controller do
 
         it "doesn't log in" do
           subject
-          session[:user_id].should be_nil
+          expect(session[:user_id]).to be_nil
         end
 
         it "returns login page" do
-          subject.status.should == 401
-          render[:data].should == :'admin/login'
+          expect(subject.status).to eq(401)
+          expect(render[:data]).to eq(:'admin/login')
         end
       end
     end
@@ -91,8 +82,8 @@ describe Days::App, type: :controller do
         before { login(user) }
 
         it "redirects to /admin/login" do
-          subject.should be_redirect
-          URI.parse(subject.location).path.should == '/admin/login'
+          expect(subject).to be_redirect
+          expect(URI.parse(subject.location).path).to eq('/admin/login')
         end
 
         specify do
@@ -102,8 +93,8 @@ describe Days::App, type: :controller do
 
       context "when not logged in" do
         it "redirects to /admin/login" do
-          subject.should be_redirect
-          URI.parse(subject.location).path.should == '/admin/login'
+          expect(subject).to be_redirect
+          expect(URI.parse(subject.location).path).to eq('/admin/login')
         end
       end
     end

data/spec/controllers/admin/setup_spec.rb

@@ -3,10 +3,15 @@ require 'spec_helper'
 describe Days::App, type: :controller do
   shared_examples "an setup page" do
     context "when user exists" do
-      fixtures :users
+      before do
+        Days::User.create!(
+          name: 'Blogger', login_name: 'blogger',
+          password: 'password', password_confirmation: 'password'
+        )
+      end
 
       it "denies access" do
-        subject.status.should == 403
+        expect(subject.status).to eq(403)
       end
     end
   end
@@ -18,17 +23,13 @@ describe Days::App, type: :controller do
       it_behaves_like 'an setup page'
 
       context "when user not exists" do
-        before do
-          Days::User.destroy_all
-        end
-
-        it { should be_ok }
+        it { is_expected.to be_ok }
 
         it "renders form page" do
-          render[:data].should == :'admin/setup'
+          expect(render[:data]).to eq(:'admin/setup')
           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
     end
@@ -43,40 +44,36 @@ describe Days::App, type: :controller do
       it_behaves_like 'an setup page'
 
       context "when user not exists" do
-        before do
-          Days::User.destroy_all
-        end
-
         it "creates user" do
           expect { subject }.to change { Days::User.count }.from(0).to(1)
           user = Days::User.last
-          user.name.should == "Newbie"
+          expect(user.name).to eq("Newbie")
         end
 
         it "logs in" do
-          session[:user_id].should be_nil
+          expect(session[:user_id]).to be_nil
           subject
-          session[:user_id].should == Days::User.last.id
+          expect(session[:user_id]).to eq(Days::User.last.id)
         end
 
         it "redirects to /admin" do
-          subject.should be_redirect
-          URI.parse(subject.location).path.should == '/admin'
+          expect(subject).to be_redirect
+          expect(URI.parse(subject.location).path).to eq('/admin')
         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/setup'
+            expect(render[:data]).to eq(:'admin/setup')
             iuser = render[:ivars][:@user]
-            iuser.should be_a_new_record
-            iuser.name.should == 'Newbie'
-            iuser.login_name.should == 'newbie'
+            expect(iuser).to be_a_new_record
+            expect(iuser.name).to eq('Newbie')
+            expect(iuser.login_name).to eq('newbie')
           end
         end
       end