alchemy_cms 3.3.0.rc1 → 3.3.0.rc2

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

@@ -1,193 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe Admin::AttachmentsController do
-    let(:attachment) { build_stubbed(:alchemy_attachment) }
-
-    before do
-      authorize_user(:as_admin)
-    end
-
-    describe "#index" do
-      it "should always paginate the records" do
-        expect_any_instance_of(ActiveRecord::Relation).to receive(:page).and_call_original
-        alchemy_get :index
-      end
-
-      context "when params[:tagged_with] is set" do
-        it "should filter the records by tags" do
-          expect(Attachment).to receive(:tagged_with).and_return(Attachment.all)
-          alchemy_get :index, tagged_with: "pdf"
-        end
-      end
-
-      context "when params[:content_id]" do
-        let(:content) { mock_model(Content) }
-
-        context "is set" do
-          it "it renders the archive_overlay partial" do
-            expect(Content).to receive(:find_by).and_return(content)
-            alchemy_get :index, {content_id: content.id}
-            expect(response).to render_template(partial: '_archive_overlay')
-            expect(assigns(:content)).to eq(content)
-          end
-        end
-
-        context "is not set" do
-          it "should render the default index view" do
-            alchemy_get :index
-            expect(response).to render_template(:index)
-          end
-        end
-      end
-
-      describe 'only and expect options' do
-        let!(:png) { create(:alchemy_attachment) }
-        let!(:jpg) { create(:alchemy_attachment, file: File.new(File.expand_path('../../../../fixtures/image3.jpeg', __FILE__))) }
-
-        context 'with params[:only]' do
-          it 'only loads attachments with matching content type' do
-            alchemy_get :index, only: 'jpeg'
-            expect(assigns(:attachments).to_a).to eq([jpg])
-            expect(assigns(:attachments).to_a).to_not eq([png])
-          end
-        end
-
-        context 'with params[:except]' do
-          it 'does not load attachments with matching content type' do
-            alchemy_get :index, except: 'jpeg'
-            expect(assigns(:attachments).to_a).to eq([png])
-            expect(assigns(:attachments).to_a).to_not eq([jpg])
-          end
-        end
-      end
-    end
-
-    describe '#show' do
-      before do
-        expect(Attachment).to receive(:find).and_return(attachment)
-      end
-
-      it "renders the show template" do
-        alchemy_get :show, id: attachment.id
-        expect(response).to render_template(:show)
-      end
-    end
-
-    describe '#create' do
-      subject { alchemy_post :create, params }
-
-      let(:attachment) { mock_model('Attachment', name: 'contract.pdf', to_jq_upload: {}) }
-      let(:params)     { {attachment: {name: ''}} }
-
-      context 'with passing validations' do
-        before do
-          expect(Attachment).to receive(:new).and_return(attachment)
-          expect(attachment).to receive(:save).and_return(true)
-        end
-
-        it "renders json response with success message" do
-          subject
-          expect(response.content_type).to eq('application/json')
-          expect(response.status).to eq(201)
-          json = JSON.parse(response.body)
-          expect(json).to have_key('growl_message')
-          expect(json).to have_key('files')
-        end
-      end
-
-      context 'without passing validations' do
-        it "renders json response with error message" do
-          subject
-          expect(response.content_type).to eq('application/json')
-          expect(response.status).to eq(422)
-          json = JSON.parse(response.body)
-          expect(json).to have_key('growl_message')
-          expect(json).to have_key('files')
-        end
-      end
-    end
-
-    describe '#update' do
-      subject { alchemy_put :update, {id: 1, attachment: {name: ''}} }
-
-      let(:attachment) { build_stubbed(:alchemy_attachment) }
-
-      before do
-        expect(Attachment).to receive(:find).and_return(attachment)
-      end
-
-      context 'with passing validations' do
-        before do
-          expect(attachment).to receive(:update_attributes).and_return(true)
-        end
-
-        it "redirects to index path" do
-          is_expected.to redirect_to admin_attachments_path
-        end
-
-        context 'with search params' do
-          let(:search_params) do
-            {
-              q: {name_cont: 'kitten'},
-              per_page: 20,
-              page: 2
-            }
-          end
-
-          subject do
-            alchemy_put :update, {id: 1, attachment: {name: ''}}.merge(search_params)
-          end
-
-          it "passes them along" do
-            is_expected.to redirect_to admin_attachments_path(search_params)
-          end
-        end
-      end
-
-      context 'with failing validations' do
-        before do
-          expect(attachment).to receive(:update_attributes).and_return(false)
-          expect(attachment).to receive(:errors).and_return double(empty?: false)
-        end
-
-        it "renders edit form" do
-          is_expected.to render_template(:edit)
-        end
-      end
-    end
-
-    describe '#destroy' do
-      let(:attachment) { build_stubbed(:alchemy_attachment) }
-
-      before do
-        expect(Attachment).to receive(:find).and_return(attachment)
-      end
-
-      it "destroys the attachment and sets and success message" do
-        expect(attachment).to receive(:destroy)
-        alchemy_xhr :delete, :destroy, id: 1
-        expect(assigns(:attachment)).to eq(attachment)
-        expect(assigns(:url)).not_to be_blank
-        expect(flash[:notice]).not_to be_blank
-      end
-    end
-
-    describe "#download" do
-      before do
-        expect(Attachment).to receive(:find).with(attachment.id.to_s).and_return(attachment)
-        allow(controller).to receive(:render).and_return(nil)
-      end
-
-      it "should assign @attachment with Attachment found by id" do
-        alchemy_get :download, id: attachment.id
-        expect(assigns(:attachment)).to eq(attachment)
-      end
-
-      it "should send the data to the browser" do
-        expect(controller).to receive(:send_file)
-        alchemy_get :download, id: attachment.id
-      end
-    end
-  end
-end

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

@@ -1,87 +0,0 @@
-require 'spec_helper'
-
-describe Alchemy::Admin::BaseController do
-  describe '#options_from_params' do
-    subject { controller.send(:options_from_params) }
-
-    context "params[:options] is a JSON string" do
-      before { expect(controller).to receive(:params).at_least(:once).and_return(options: '{"hallo":"World"}') }
-
-      it "parses the string into an object" do
-        expect(subject).to be_an_instance_of(Hash)
-        expect(subject).to eq({hallo: 'World'})
-      end
-    end
-
-    context "params[:options] is already an object" do
-      before { expect(controller).to receive(:params).at_least(:once).and_return(options: {hallo: "World"}) }
-
-      it "parses the string into an object" do
-        expect(subject).to be_an_instance_of(Hash)
-      end
-    end
-
-    context "params[:options] is not present" do
-      before { expect(controller).to receive(:params).at_least(:once).and_return({}) }
-
-      it "returns ampty object" do
-        expect(subject).to be_an_instance_of(Hash)
-        expect(subject).to eq({})
-      end
-    end
-  end
-
-  describe '#raise_exception?' do
-    subject { controller.send(:raise_exception?) }
-
-    context 'in test mode' do
-      before { expect(Rails.env).to receive(:test?).and_return true }
-      it { is_expected.to be_truthy }
-    end
-
-    context 'not in test mode' do
-      before { expect(Rails.env).to receive(:test?).and_return false }
-      it { is_expected.to be_falsey }
-
-      context 'and in page preview' do
-        before { expect(controller).to receive(:is_page_preview?).and_return true }
-        it { is_expected.to be_truthy }
-      end
-
-      context 'and not in page preview' do
-        before { expect(controller).to receive(:is_page_preview?).and_return false }
-        it { is_expected.to be_falsey }
-      end
-    end
-  end
-
-  describe '#is_page_preview?' do
-    subject { controller.send(:is_page_preview?) }
-
-    it { is_expected.to be_falsey }
-
-    context 'is pages controller and show action' do
-      before do
-        expect(controller).to receive(:controller_path).and_return('alchemy/admin/pages')
-        expect(controller).to receive(:action_name).and_return('show')
-      end
-
-      it { is_expected.to be_truthy }
-    end
-  end
-
-  context 'when current_alchemy_user is present' do
-    let!(:page) { create(:alchemy_page) }
-    let!(:user) { create(:alchemy_dummy_user, :as_admin) }
-
-    before do
-      allow(controller).to receive(:current_alchemy_user) { user }
-      page.lock_to!(user)
-    end
-
-    it 'loads locked pages' do
-      controller.send(:load_locked_pages)
-      expect(assigns(:locked_pages)).to include(page)
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe Admin::ClipboardController do
-    let(:public_page)     { build_stubbed(:alchemy_page, :public) }
-    let(:element)         { build_stubbed(:alchemy_element, page: public_page) }
-    let(:another_element) { build_stubbed(:alchemy_element, page: public_page) }
-
-    before do
-      authorize_user(:as_admin)
-      session[:alchemy_clipboard] = {}
-    end
-
-    context 'for elements' do
-      before do
-        expect(Element).to receive(:find).and_return(element)
-      end
-
-      describe "#insert" do
-        it "should hold element ids" do
-          alchemy_xhr :post, :insert, {remarkable_type: 'elements', remarkable_id: element.id}
-          expect(session[:alchemy_clipboard]['elements']).to eq([{'id' => element.id.to_s, 'action' => 'copy'}])
-        end
-
-        it "should not have the same element twice" do
-          session[:alchemy_clipboard]['elements'] = [{'id' => element.id.to_s, 'action' => 'copy'}]
-          alchemy_xhr :post, :insert, {remarkable_type: 'elements', remarkable_id: element.id}
-          expect(session[:alchemy_clipboard]['elements'].collect { |e| e['id'] }).not_to eq([element.id, element.id])
-        end
-      end
-
-      describe "#delete" do
-        it "should remove element ids from clipboard" do
-          session[:alchemy_clipboard]['elements'] = [{'id' => element.id.to_s, 'action' => 'copy'}]
-          session[:alchemy_clipboard]['elements'] << {'id' => another_element.id.to_s, 'action' => 'copy'}
-          alchemy_xhr :delete, :remove, {remarkable_type: 'elements', remarkable_id: another_element.id}
-          expect(session[:alchemy_clipboard]['elements']).to eq([{'id' => element.id.to_s, 'action' => 'copy'}])
-        end
-      end
-    end
-
-    describe "#clear" do
-      context "with elements as remarkable_type" do
-        it "should clear the elements clipboard" do
-          session[:alchemy_clipboard]['elements'] = [{'id' => element.id.to_s}]
-          alchemy_xhr :delete, :clear, {remarkable_type: 'elements'}
-          expect(session[:alchemy_clipboard]['elements']).to be_empty
-        end
-      end
-
-      context "with pages as remarkable_type" do
-        it "should clear the pages clipboard" do
-          session[:alchemy_clipboard]['pages'] = [{'id' => public_page.id.to_s}]
-          alchemy_xhr :delete, :clear, {remarkable_type: 'pages'}
-          expect(session[:alchemy_clipboard]['pages']).to be_empty
-        end
-      end
-    end
-  end
-end

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

@@ -1,78 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe Admin::ContentsController do
-    let(:element) { build_stubbed(:alchemy_element) }
-    let(:content) { build_stubbed(:alchemy_content, element: element) }
-
-    before do
-      authorize_user(:as_admin)
-    end
-
-    context 'with element_id parameter' do
-      before do
-        expect(Element).to receive(:find).and_return(element)
-      end
-
-      describe '#create' do
-        let(:element) { build_stubbed(:alchemy_element, name: 'headline') }
-
-        it "creates a content from name" do
-          expect(Content).to receive(:create_from_scratch).and_return(content)
-          alchemy_xhr :post, :create, {content: {element_id: element.id, name: 'headline'}}
-        end
-
-        it "creates a content from essence_type" do
-          expect(Content).to receive(:create_from_scratch).and_return(content)
-          alchemy_xhr :post, :create, {content: {element_id: element.id, essence_type: 'EssencePicture'}}
-        end
-      end
-
-      context 'inside a picture gallery' do
-        let(:attributes) do
-          {content: {element_id: element.id, essence_type: 'Alchemy::EssencePicture'}, options: {grouped: 'true'}}
-        end
-
-        it "adds it into the gallery editor" do
-          alchemy_xhr :post, :create, attributes
-          expect(assigns(:content_dom_id)).to eq("#add_picture_#{element.id}")
-        end
-
-        context 'with picture_id given' do
-          it "assigns the picture" do
-            expect_any_instance_of(Content).to receive(:update_essence).with(picture_id: '1')
-            alchemy_xhr :post, :create, attributes.merge(picture_id: '1')
-          end
-        end
-      end
-    end
-
-    describe '#update' do
-      before do
-        expect(Content).to receive(:find).and_return(content)
-      end
-
-      it "should update a content via ajax" do
-        expect(content.essence).to receive(:update).with('ingredient' => 'Peters Petshop')
-        alchemy_xhr :post, :update, {id: content.id, content: {ingredient: 'Peters Petshop'}}
-      end
-    end
-
-    describe "#order" do
-      context "with content_ids in params" do
-        let(:element) do
-          create(:alchemy_element, name: 'all_you_can_eat', create_contents_after_create: true)
-        end
-
-        let(:content_ids) { element.contents.pluck(:id).shuffle }
-
-        it "should reorder the contents" do
-          alchemy_xhr :post, :order, {content_ids: content_ids}
-
-          expect(response.status).to eq(200)
-          expect(element.contents(true).pluck(:id)).to eq(content_ids)
-        end
-      end
-    end
-  end
-end

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

@@ -1,144 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe Admin::DashboardController do
-    let(:user) { build_stubbed(:alchemy_dummy_user, :as_admin) }
-
-    before { authorize_user(user) }
-
-    describe '#index' do
-      before do
-        allow(Page).to receive(:from_current_site).and_return(
-          double(
-            all_last_edited_from: [],
-            locked_by: [],
-            locked: []
-          )
-        )
-      end
-
-      it "assigns @last_edited_pages" do
-        alchemy_get :index
-        expect(assigns(:last_edited_pages)).to eq([])
-      end
-
-      it "assigns @all_locked_pages" do
-        alchemy_get :index
-        expect(assigns(:all_locked_pages)).to eq([])
-      end
-
-      context 'with user class having logged_in scope' do
-        context 'with other users online' do
-          let(:another_user) { mock_model('DummyUser') }
-
-          before do
-            expect(Alchemy.user_class).to receive(:logged_in).and_return([another_user])
-          end
-
-          it "assigns @online_users" do
-            alchemy_get :index
-            expect(assigns(:online_users)).to eq([another_user])
-          end
-        end
-
-        context 'without other users online' do
-          it "does not assign @online_users" do
-            alchemy_get :index
-            expect(assigns(:online_users)).to eq([])
-          end
-        end
-      end
-
-      context 'user having signed in before' do
-        before do
-          expect(user).to receive(:sign_in_count).and_return(5)
-          expect(user).to receive(:last_sign_in_at).and_return(Time.current)
-        end
-
-        it "assigns @first_time" do
-          alchemy_get :index
-          expect(assigns(:first_time)).to eq(false)
-        end
-      end
-
-      it "assigns @sites" do
-        alchemy_get :index
-        expect(assigns(:sites)).to eq(Site.all)
-      end
-    end
-
-    describe '#info' do
-      it "assigns @alchemy_version with the current Alchemy version" do
-        alchemy_get :info
-        expect(assigns(:alchemy_version)).to eq(Alchemy.version)
-      end
-    end
-
-    describe '#update_check' do
-      context "if current Alchemy version equals the latest released version or it is newer" do
-        before {
-          allow(controller).to receive(:latest_alchemy_version).and_return('2.6')
-          allow(Alchemy).to receive(:version).and_return("2.6")
-        }
-
-        it "should render 'false'" do
-          alchemy_get :update_check
-          expect(response.body).to eq('false')
-        end
-      end
-
-      context "if current Alchemy version is older than latest released version" do
-        before {
-          allow(controller).to receive(:latest_alchemy_version).and_return('2.6')
-          allow(Alchemy).to receive(:version).and_return("2.5")
-        }
-
-        it "should render 'true'" do
-          alchemy_get :update_check
-          expect(response.body).to eq('true')
-        end
-      end
-
-      context "requesting rubygems.org" do
-        before {
-          allow_any_instance_of(Net::HTTP).to receive(:request).and_return(
-            OpenStruct.new({code: '200', body: '[{"number": "2.6"}, {"number": "2.5"}]'})
-          )
-          allow(Alchemy).to receive(:version).and_return("2.6")
-        }
-
-        it "should have response code of 200" do
-          alchemy_get :update_check
-          expect(response.code).to eq('200')
-        end
-      end
-
-      context "requesting github.com" do
-        before {
-          allow(controller).to receive(:query_rubygems).and_return(OpenStruct.new({code: '503'}))
-          allow_any_instance_of(Net::HTTP).to receive(:request).and_return(
-            OpenStruct.new({code: '200', body: '[{"name": "2.6"}, {"name": "2.5"}]'})
-          )
-        }
-
-        it "should have response code of 200" do
-          alchemy_get :update_check
-          expect(response.code).to eq('200')
-        end
-      end
-
-      context "rubygems.org and github.com are unavailable" do
-        before {
-          allow_any_instance_of(Net::HTTP).to receive(:request).and_return(
-            OpenStruct.new({code: '503'})
-          )
-        }
-
-        it "should have status code 503" do
-          alchemy_get :update_check
-          expect(response.code).to eq('503')
-        end
-      end
-    end
-  end
-end