alchemy_cms 3.2.1 → 3.3.0.rc1

data/spec/controllers/{admin → alchemy/admin}/pictures_controller_spec.rb

@@ -1,36 +1,78 @@
 require 'spec_helper'
 
+RSpec.shared_examples :redirecting_to_picture_library do
+  let(:params) do
+    {
+      filter: 'latest',
+      page: 2,
+      q: {name_cont: 'kitten'},
+      size: 'small',
+      tagged_with: 'cat'
+    }
+  end
+
+  it 'redirects to index keeping all query, filter and page params' do
+    is_expected.to redirect_to admin_pictures_path(params)
+  end
+end
+
 module Alchemy
   describe Admin::PicturesController do
-
     before do
       authorize_user(:as_admin)
     end
 
-    describe "#index" do
-      it "should always paginate the records" do
-        expect(Picture).to receive(:find_paginated)
-        alchemy_get :index
+    describe '#index' do
+      context 'with search params' do
+        let!(:picture_1) { create(:alchemy_picture, name: 'cute kitten') }
+        let!(:picture_2) { create(:alchemy_picture, name: 'nice beach') }
+
+        it 'assigns @pictures with filtered pictures' do
+          alchemy_get :index, q: {name_cont: 'kitten'}
+          expect(assigns(:pictures)).to include(picture_1)
+          expect(assigns(:pictures)).to_not include(picture_2)
+        end
       end
 
-      context "when params[:filter] is set" do
-        it "should filter the pictures collection by the given filter string." do
-          expect(Picture).to receive(:filtered_by).with('recent').and_return(Picture.all)
-          alchemy_get :index, filter: 'recent'
+      context 'with filter params' do
+        let!(:picture_1) { create(:alchemy_picture) }
+        let!(:picture_2) { create(:alchemy_picture, tag_list: %w(kitten)) }
+
+        it 'assigns @pictures with filtered pictures' do
+          alchemy_get :index, filter: 'without_tag'
+          expect(assigns(:pictures)).to include(picture_1)
+          expect(assigns(:pictures)).to_not include(picture_2)
         end
       end
 
-      context "when params[:tagged_with] is set" do
-        it "should filter the records by tags" do
-          expect(Picture).to receive(:tagged_with).and_return(Picture.all)
-          alchemy_get :index, tagged_with: "red"
+      context 'with tag params' do
+        let!(:picture_1) { create(:alchemy_picture, tag_list: %w(water)) }
+        let!(:picture_2) { create(:alchemy_picture, tag_list: %w(kitten)) }
+
+        it 'assigns @pictures with filtered pictures' do
+          alchemy_get :index, tagged_with: 'water'
+          expect(assigns(:pictures)).to include(picture_1)
+          expect(assigns(:pictures)).to_not include(picture_2)
         end
       end
 
-      context "when params[:content_id]" do
+      it 'assigns @size to default value' do
+        alchemy_get :index
+        expect(assigns(:size)).to eq('medium')
+      end
+
+      context "with params[:size] set to 'large'" do
+        it 'assigns @size to large' do
+          alchemy_get :index, size: 'large'
+          expect(assigns(:size)).to eq('large')
+        end
+      end
+
+      context "when params[:element_id]" do
         context "is set" do
           before do
-            allow(Element).to receive(:find).with('1', {:select => 'id'}).and_return(mock_model(Element))
+            allow(Element).to \
+              receive(:find).with('1', {select: 'id'}).and_return(mock_model(Element))
           end
 
           it "for html requests it renders the archive_overlay partial" do
@@ -53,45 +95,6 @@ module Alchemy
       end
     end
 
-    describe '#new' do
-      subject { alchemy_get :new, params }
-
-      let(:params) { Hash.new }
-
-      context 'if inside of archive overlay' do
-        let(:params)  { {element_id: 1, content_id: 1} }
-        let(:element) { mock_model('Element') }
-        let(:content) { mock_model('Content') }
-
-        before do
-          expect(Content).to receive(:select).and_return(double(find_by: content))
-          expect(Element).to receive(:select).and_return(double(find_by: element))
-        end
-
-        it "assigns lots of instance variables" do
-          subject
-          expect(assigns(:options)).to eq({})
-          expect(assigns(:while_assigning)).to be_truthy
-          expect(assigns(:content)).to eq(content)
-          expect(assigns(:element)).to eq(element)
-          expect(assigns(:page)).to eq(1)
-          expect(assigns(:per_page)).to eq(9)
-        end
-      end
-
-      context 'with size param given' do
-        let(:params) { {size: '200x200'} }
-        before { subject }
-        it { expect(assigns(:size)).to eq('200x200') }
-      end
-
-      context 'without size param given' do
-        let(:params) { {size: nil} }
-        before { subject }
-        it { expect(assigns(:size)).to eq('medium') }
-      end
-    end
-
     describe '#create' do
       subject { alchemy_post :create, params }
 
@@ -106,39 +109,6 @@ module Alchemy
           expect(picture).to receive(:save).and_return(true)
         end
 
-        context 'if inside of archive overlay' do
-          let(:params)  { {picture: {name: ''}, element_id: 1} }
-          let(:element) { mock_model('Element') }
-          let(:content) { mock_model('Content') }
-
-          before do
-            expect(Content).to receive(:select).and_return(double(find_by: content))
-            expect(Element).to receive(:select).and_return(double(find_by: element))
-          end
-
-          it "assigns lots of instance variables" do
-            subject
-            expect(assigns(:options)).to eq({})
-            expect(assigns(:while_assigning)).to be_truthy
-            expect(assigns(:content)).to eq(content)
-            expect(assigns(:element)).to eq(element)
-            expect(assigns(:page)).to eq(1)
-            expect(assigns(:per_page)).to eq(9)
-          end
-        end
-
-        context 'with size param given' do
-          let(:params) { {picture: {name: ''}, size: '200x200'} }
-          before { subject }
-          it { expect(assigns(:size)).to eq('200x200') }
-        end
-
-        context 'without size param given' do
-          let(:params) { {picture: {name: ''}, size: nil} }
-          before { subject }
-          it { expect(assigns(:size)).to eq('medium') }
-        end
-
         it "renders json response with success message" do
           subject
           expect(response.content_type).to eq('application/json')
@@ -161,6 +131,45 @@ module Alchemy
       end
     end
 
+    describe '#show' do
+      let(:picture) { create(:alchemy_picture, name: 'kitten') }
+
+      it 'assigns @picture' do
+        alchemy_get :show, id: picture.id
+        expect(assigns(:picture).id).to eq(picture.id)
+      end
+
+      context 'with assignments' do
+        let!(:page) { create(:alchemy_page) }
+        let!(:element) { create(:alchemy_element, page: page) }
+        let!(:content) { create(:alchemy_content, element: element) }
+        let!(:essence) { create(:alchemy_essence_picture, content: content, picture: picture) }
+
+        it 'assigns @pages to assignments grouped by page' do
+          alchemy_get :show, id: picture.id
+          expect(assigns(:pages)).to eq({page => [essence]})
+        end
+      end
+
+      context 'with previous picture existing' do
+        let!(:previous) { create(:alchemy_picture, name: 'abraham') }
+
+        it 'assigns @previous to previous picture' do
+          alchemy_get :show, id: picture.id
+          expect(assigns(:previous).id).to eq(previous.id)
+        end
+      end
+
+      context 'with next picture existing' do
+        let!(:next_picture) { create(:alchemy_picture, name: 'zebra') }
+
+        it 'assigns @next to next picture' do
+          alchemy_get :show, id: picture.id
+          expect(assigns(:next).id).to eq(next_picture.id)
+        end
+      end
+    end
+
     describe '#edit_multiple' do
       let(:pictures) { [mock_model('Picture', tag_list: 'kitten')] }
       before { expect(Picture).to receive(:where).and_return(pictures) }
@@ -177,9 +186,9 @@ module Alchemy
     end
 
     describe '#update' do
-      subject { alchemy_put :update, {id: 1, picture: {name: ''}} }
+      subject { alchemy_xhr :put, :update, {id: 1, picture: {name: ''}} }
 
-      let(:picture) { build_stubbed(:picture, name: 'Cute kitten') }
+      let(:picture) { build_stubbed(:alchemy_picture, name: 'Cute kitten') }
 
       before do
         expect(Picture).to receive(:find).and_return(picture)
@@ -187,37 +196,32 @@ module Alchemy
 
       context 'with passing validations' do
         before do
-          expect(picture).to receive(:update_attributes).and_return(true)
+          expect(picture).to receive(:update).and_return(true)
         end
 
         it "sets success notice" do
           subject
-          expect(flash[:notice]).not_to be_blank
-        end
-
-        it "redirects to index path" do
-          is_expected.to redirect_to admin_pictures_path
+          expect(assigns(:message)[:body]).to \
+            eq(Alchemy.t(:picture_updated_successfully, name: picture.name))
+          expect(assigns(:message)[:type]).to eq('notice')
         end
       end
 
       context 'with failing validations' do
         before do
-          expect(picture).to receive(:update_attributes).and_return(false)
+          expect(picture).to receive(:update).and_return(false)
         end
 
-        it "sets error notice and redirects to index path" do
+        it "sets error notice" do
           subject
-          expect(flash[:error]).not_to be_blank
-        end
-
-        it "redirects to index path" do
-          is_expected.to redirect_to admin_pictures_path
+          expect(assigns(:message)[:body]).to eq(Alchemy.t(:picture_update_failed))
+          expect(assigns(:message)[:type]).to eq('error')
         end
       end
     end
 
     describe '#update_multiple' do
-      let(:picture)  { build_stubbed(:picture) }
+      let(:picture)  { build_stubbed(:alchemy_picture) }
       let(:pictures) { [picture] }
 
       before do
@@ -229,13 +233,30 @@ module Alchemy
         alchemy_post :update_multiple
         expect(assigns(:pictures)).to eq(pictures)
       end
+
+      it_behaves_like :redirecting_to_picture_library do
+        let(:subject) { alchemy_post(:update_multiple, params) }
+      end
     end
 
     describe "#delete_multiple" do
       subject { alchemy_delete :delete_multiple, picture_ids: picture_ids }
 
-      let(:deletable_picture)     { mock_model('Picture', name: 'pic of the pig', deletable?: true) }
-      let(:not_deletable_picture) { mock_model('Picture', name: 'pic of the chick', deletable?: false) }
+      it_behaves_like :redirecting_to_picture_library do
+        let(:subject) do
+          alchemy_delete :delete_multiple, {
+            picture_ids: %w(1 2)
+          }.merge(params)
+        end
+      end
+
+      let(:deletable_picture) do
+        mock_model('Picture', name: 'pic of the pig', deletable?: true)
+      end
+
+      let(:not_deletable_picture) do
+        mock_model('Picture', name: 'pic of the chick', deletable?: false)
+      end
 
       context "no picture_ids given" do
         let(:picture_ids) { '' }
@@ -248,7 +269,7 @@ module Alchemy
 
       context "picture_ids given" do
         context "all are deletable" do
-          let(:picture_ids) { "#{deletable_picture.id}" }
+          let(:picture_ids) { deletable_picture.id.to_s }
 
           before do
             allow(Picture).to receive(:find).and_return([deletable_picture])
@@ -275,7 +296,7 @@ module Alchemy
         end
 
         context 'with error happening' do
-          let(:picture_ids) { "#{deletable_picture.id}" }
+          let(:picture_ids) { deletable_picture.id.to_s }
 
           before do
             expect(Picture).to receive(:find).and_raise('yada')
@@ -295,7 +316,7 @@ module Alchemy
     end
 
     describe '#destroy' do
-      let(:picture) { build_stubbed(:picture, name: 'Cute kitten') }
+      let(:picture) { build_stubbed(:alchemy_picture, name: 'Cute kitten') }
 
       before do
         expect(Picture).to receive(:find).and_return(picture)
@@ -323,6 +344,10 @@ module Alchemy
           expect(response).to redirect_to admin_pictures_path
         end
       end
+
+      it_behaves_like :redirecting_to_picture_library do
+        let(:subject) { alchemy_delete :destroy, {id: picture.id}.merge(params) }
+      end
     end
 
     describe '#flush' do

data/spec/controllers/alchemy/admin/resources_controller_spec.rb

@@ -0,0 +1,81 @@
+require "spec_helper"
+
+class Admin::EventsController < Alchemy::Admin::ResourcesController
+end
+
+describe Admin::EventsController do
+  it "should include ResourcesHelper" do
+    expect(controller.respond_to?(:resource_window_size)).to be_truthy
+  end
+
+  describe '#index' do
+    let(:params)  { Hash.new }
+    let!(:peter)  { Event.create(name: 'Peter') }
+    let!(:lustig) { Event.create(name: 'Lustig') }
+
+    before do
+      authorize_user(:as_admin)
+    end
+
+    it "returns all records" do
+      get :index, params
+      expect(assigns(:events)).to include(peter)
+      expect(assigns(:events)).to include(lustig)
+    end
+
+    context 'with search query given' do
+      let(:params) { {q: {name_or_hidden_name_or_location_name_cont: "PeTer"}} }
+
+      it "returns only matching records" do
+        get :index, params
+        expect(assigns(:events)).to include(peter)
+        expect(assigns(:events)).not_to include(lustig)
+      end
+
+      context "but searching for record with certain association" do
+        let(:bauwagen) { Location.create(name: 'Bauwagen') }
+        let(:params)   { {q: {name_or_hidden_name_or_location_name_cont: "Bauwagen"}} }
+
+        before do
+          peter.location = bauwagen
+          peter.save
+        end
+
+        it "returns only matching records" do
+          get :index, params
+          expect(assigns(:events)).to include(peter)
+          expect(assigns(:events)).not_to include(lustig)
+        end
+      end
+    end
+  end
+
+  describe '#update' do
+    let(:params) { {q: 'some_query', page: 6} }
+    let!(:peter)  { Event.create(name: 'Peter') }
+
+    it 'redirects to index, keeping the current location parameters' do
+      post :update, {id: peter.id, event: {name: "Hans"}}.merge(params)
+      expect(response.redirect_url).to eq("http://test.host/admin/events?page=6&q=some_query")
+    end
+  end
+
+  describe '#create' do
+    let(:params) { {q: 'some_query', page: 6} }
+
+    it 'redirects to index, keeping the current location parameters' do
+      post :create, {event: {name: "Hans"}}.merge(params)
+      expect(response.redirect_url).to eq("http://test.host/admin/events?page=6&q=some_query")
+    end
+  end
+
+  describe '#destroy' do
+    let(:params) { {q: 'some_query', page: 6} }
+    let!(:peter)  { Event.create(name: 'Peter') }
+
+    it 'redirects to index, keeping the current location parameters' do
+      delete :destroy, {id: peter.id}.merge(params)
+      expect(response.redirect_url).to eq("http://test.host/admin/events?page=6&q=some_query")
+    end
+  end
+end

data/spec/controllers/{admin → alchemy/admin}/trash_controller_spec.rb

@@ -5,8 +5,8 @@ module Alchemy
     describe TrashController do
       render_views
 
-      let(:alchemy_page) { FactoryGirl.create(:public_page) }
-      let(:element) { FactoryGirl.create(:element, :public => false, :page => alchemy_page) }
+      let(:alchemy_page) { create(:alchemy_page, :public) }
+      let(:element) { create(:alchemy_element, public: false, page: alchemy_page) }
 
       before {
         authorize_user(:as_admin)
@@ -14,18 +14,18 @@ module Alchemy
       }
 
       it "should hold trashed elements" do
-        alchemy_get :index, :page_id => alchemy_page.id
-        expect(response.body).to have_selector("#element_#{element.id}.element_editor")
+        alchemy_get :index, page_id: alchemy_page.id
+        expect(response.body).to have_selector("#element_#{element.id}.element-editor")
       end
 
       it "should not hold elements that are not trashed" do
-        element = FactoryGirl.create(:element, :page => alchemy_page, :public => false)
-        alchemy_get :index, :page_id => alchemy_page.id
-        expect(response.body).not_to have_selector("#element_#{element.id}.element_editor")
+        element = create(:alchemy_element, page: alchemy_page, public: false)
+        alchemy_get :index, page_id: alchemy_page.id
+        expect(response.body).not_to have_selector("#element_#{element.id}.element-editor")
       end
 
       context "with unique elements inside the trash" do
-        let(:trashed) { FactoryGirl.build_stubbed(:unique_element, position: nil, public: false, folded: true, page: alchemy_page) }
+        let(:trashed) { build_stubbed(:alchemy_element, :unique, position: nil, public: false, folded: true, page: alchemy_page) }
         before { allow(Element).to receive(:trashed).and_return([trashed]) }
 
         context "and no unique elements on the page" do
@@ -35,13 +35,13 @@ module Alchemy
 
           it "unique elements should be draggable" do
             alchemy_get :index, page_id: alchemy_page.id
-            expect(response.body).to have_selector("#element_#{trashed.id}.element_editor.draggable")
+            expect(response.body).to have_selector("#element_#{trashed.id}.element-editor.draggable")
           end
         end
 
         context "and with an unique element on the page" do
-          let(:unique) { FactoryGirl.build_stubbed(:unique_element) }
-          let(:page) { FactoryGirl.build_stubbed(:public_page) }
+          let(:unique) { build_stubbed(:alchemy_element, :unique) }
+          let(:page) { build_stubbed(:alchemy_page, :public) }
 
           before do
             allow(Page).to receive(:find).and_return(page)
@@ -50,7 +50,7 @@ module Alchemy
 
           it "unique elements should not be draggable" do
             alchemy_get :index, page_id: page.id
-            expect(response.body).to have_selector("#element_#{trashed.id}.element_editor.not-draggable")
+            expect(response.body).to have_selector("#element_#{trashed.id}.element-editor.not-draggable")
           end
         end
       end
@@ -62,7 +62,6 @@ module Alchemy
           expect(Element.trashed).to be_empty
         end
       end
-
     end
   end
 end