alchemy_cms 3.3.0.rc1 → 3.3.0.rc2

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

@@ -1,63 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  module Admin
-    describe TagsController do
-      before { authorize_user(:as_admin) }
-
-      describe '#create' do
-        context 'without required params' do
-          render_views
-
-          it "does not create tag" do
-            alchemy_post :create, tag: {name: ''}
-            expect(response.body).to have_content("can't be blank")
-          end
-        end
-
-        context 'with required params' do
-          it "creates tag and redirects to tags view" do
-            expect {
-              alchemy_post :create, tag: {name: 'Foo'}
-            }.to change { ActsAsTaggableOn::Tag.count }.by(1)
-            expect(response).to redirect_to admin_tags_path
-          end
-        end
-      end
-
-      describe '#edit' do
-        let(:tag) { ActsAsTaggableOn::Tag.create(name: 'Sputz') }
-        let(:another_tag) { ActsAsTaggableOn::Tag.create(name: 'Hutzl') }
-
-        before { another_tag; tag }
-
-        it "loads alls tags but not the one editing" do
-          alchemy_get :edit, id: tag.id
-          expect(assigns(:tags)).to include(another_tag)
-          expect(assigns(:tags)).not_to include(tag)
-        end
-      end
-
-      describe '#update' do
-        let(:tag) { ActsAsTaggableOn::Tag.create(name: 'Sputz') }
-
-        it "changes tags name" do
-          alchemy_put :update, id: tag.id, tag: {name: 'Foo'}
-          expect(response).to redirect_to(admin_tags_path)
-          expect(tag.reload.name).to eq('Foo')
-        end
-
-        context 'with merg_to param given' do
-          let(:another_tag) { ActsAsTaggableOn::Tag.create(name: 'Hutzl') }
-
-          it "replaces tag with other tag" do
-            expect(Alchemy::Tag).to receive(:replace)
-            expect_any_instance_of(ActsAsTaggableOn::Tag).to receive(:destroy)
-            alchemy_put :update, id: tag.id, tag: {merge_to: another_tag.id}
-            expect(response).to redirect_to(admin_tags_path)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  module Admin
-    describe TrashController do
-      render_views
-
-      let(:alchemy_page) { create(:alchemy_page, :public) }
-      let(:element) { create(:alchemy_element, public: false, page: alchemy_page) }
-
-      before {
-        authorize_user(:as_admin)
-        element.trash!
-      }
-
-      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")
-      end
-
-      it "should not hold elements that are not trashed" do
-        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) { 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
-          before do
-            allow(alchemy_page).to receive(:elements).and_return double(not_trashed: double(pluck: []))
-          end
-
-          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")
-          end
-        end
-
-        context "and with an unique element on the page" do
-          let(:unique) { build_stubbed(:alchemy_element, :unique) }
-          let(:page) { build_stubbed(:alchemy_page, :public) }
-
-          before do
-            allow(Page).to receive(:find).and_return(page)
-            allow(page).to receive(:elements).and_return double(not_trashed: double(pluck: [unique.name]))
-          end
-
-          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")
-          end
-        end
-      end
-
-      describe "#clear" do
-        it "should destroy all containing elements" do
-          expect(Element.trashed).not_to be_empty
-          alchemy_xhr :post, :clear, page_id: alchemy_page.id
-          expect(Element.trashed).to be_empty
-        end
-      end
-    end
-  end
-end

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

@@ -1,125 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe Api::ContentsController do
-    describe '#index' do
-      let!(:page)    { create(:alchemy_page) }
-      let!(:element) { create(:alchemy_element, page: page) }
-      let!(:content) { create(:alchemy_content, element: element) }
-
-      it "returns all public contents as json objects" do
-        alchemy_get :index, format: :json
-
-        expect(response.status).to eq(200)
-        expect(response.content_type).to eq('application/json')
-
-        result = JSON.parse(response.body)
-
-        expect(result).to have_key("contents")
-        expect(result['contents'].size).to eq(Alchemy::Content.count)
-      end
-
-      context 'with element_id' do
-        let!(:other_element) { create(:alchemy_element, page: page) }
-        let!(:other_content) { create(:alchemy_content, element: other_element) }
-
-        it "returns only contents from this element" do
-          alchemy_get :index, element_id: other_element.id, format: :json
-
-          expect(response.status).to eq(200)
-          expect(response.content_type).to eq('application/json')
-
-          result = JSON.parse(response.body)
-
-          expect(result).to have_key("contents")
-          expect(result['contents'].size).to eq(1)
-          expect(result['contents'][0]['element_id']).to eq(other_element.id)
-        end
-      end
-
-      context 'with empty element_id' do
-        it "returns all contents" do
-          alchemy_get :index, element_id: element.id, format: :json
-
-          expect(response.status).to eq(200)
-          expect(response.content_type).to eq('application/json')
-
-          result = JSON.parse(response.body)
-
-          expect(result).to have_key("contents")
-          expect(result['contents'].size).to eq(Alchemy::Content.count)
-        end
-      end
-    end
-
-    describe '#show' do
-      context 'with no other params given' do
-        let(:page)    { create(:alchemy_page) }
-        let(:element) { create(:alchemy_element, page: page) }
-        let(:content) { create(:alchemy_content, element: element) }
-
-        before do
-          expect(Content).to receive(:find).and_return(content)
-        end
-
-        it "returns content as json" do
-          alchemy_get :show, id: content.id, format: :json
-
-          expect(response.status).to eq(200)
-          expect(response.content_type).to eq('application/json')
-
-          result = JSON.parse(response.body)
-
-          expect(result['id']).to eq(content.id)
-        end
-
-        context 'requesting an restricted content' do
-          let(:page) { create(:alchemy_page, restricted: true) }
-
-          it "responds with 403" do
-            alchemy_get :show, id: content.id, format: :json
-
-            expect(response.content_type).to eq('application/json')
-            expect(response.status).to eq(403)
-
-            result = JSON.parse(response.body)
-
-            expect(result).to have_key("error")
-            expect(result['error']).to eq("Not authorized")
-          end
-        end
-      end
-
-      context 'with element_id and name params given' do
-        let!(:page)    { create(:alchemy_page) }
-        let!(:element) { create(:alchemy_element, page: page) }
-        let!(:content) { create(:alchemy_content, element: element) }
-
-        it 'returns the named content from element with given id.' do
-          alchemy_get :show, element_id: element.id, name: content.name, format: :json
-
-          expect(response.status).to eq(200)
-          expect(response.content_type).to eq('application/json')
-
-          result = JSON.parse(response.body)
-
-          expect(result['id']).to eq(content.id)
-        end
-      end
-
-      context 'with empty element_id or name param' do
-        it 'returns 404 error.' do
-          alchemy_get :show, element_id: '', name: '', format: :json
-
-          expect(response.status).to eq(404)
-          expect(response.content_type).to eq('application/json')
-
-          result = JSON.parse(response.body)
-
-          expect(result).to have_key("error")
-          expect(result['error']).to eq("Record not found")
-        end
-      end
-    end
-  end
-end

data/spec/controllers/alchemy/api/elements_controller_spec.rb

@@ -1,124 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe Api::ElementsController do
-    describe '#index' do
-      let(:page) { create(:alchemy_page, :public) }
-
-      before do
-        2.times { create(:alchemy_element, page: page) }
-      end
-
-      it "returns all public elements as json objects" do
-        alchemy_get :index, format: :json
-
-        expect(response.status).to eq(200)
-        expect(response.content_type).to eq('application/json')
-
-        result = JSON.parse(response.body)
-
-        expect(result).to have_key('elements')
-        expect(result['elements'].size).to eq(Alchemy::Element.count)
-      end
-
-      context 'with page_id param' do
-        let!(:other_page)    { create(:alchemy_page, :public) }
-        let!(:other_element) { create(:alchemy_element, page: other_page) }
-
-        it "returns only elements from this page" do
-          alchemy_get :index, page_id: other_page.id, format: :json
-
-          expect(response.status).to eq(200)
-          expect(response.content_type).to eq('application/json')
-
-          result = JSON.parse(response.body)
-
-          expect(result).to have_key('elements')
-          expect(result['elements'].size).to eq(1)
-          expect(result['elements'][0]['page_id']).to eq(other_page.id)
-        end
-      end
-
-      context 'with empty page_id param' do
-        it "returns all elements" do
-          alchemy_get :index, page_id: '', format: :json
-
-          expect(response.status).to eq(200)
-          expect(response.content_type).to eq('application/json')
-
-          result = JSON.parse(response.body)
-
-          expect(result).to have_key('elements')
-          expect(result['elements'].size).to eq(Alchemy::Element.count)
-        end
-      end
-
-      context 'with named param' do
-        let!(:other_element) { create(:alchemy_element, page: page, name: 'news') }
-
-        it "returns only elements named like this." do
-          alchemy_get :index, named: 'news', format: :json
-
-          expect(response.status).to eq(200)
-          expect(response.content_type).to eq('application/json')
-
-          result = JSON.parse(response.body)
-
-          expect(result).to have_key('elements')
-          expect(result['elements'].size).to eq(1)
-          expect(result['elements'][0]['name']).to eq('news')
-        end
-      end
-
-      context 'with empty named param' do
-        it "returns all elements" do
-          alchemy_get :index, named: '', format: :json
-
-          expect(response.status).to eq(200)
-          expect(response.content_type).to eq('application/json')
-
-          result = JSON.parse(response.body)
-
-          expect(result).to have_key('elements')
-          expect(result['elements'].size).to eq(Alchemy::Element.count)
-        end
-      end
-    end
-
-    describe '#show' do
-      let(:page)    { build_stubbed(:alchemy_page) }
-      let(:element) { build_stubbed(:alchemy_element, page: page, position: 1) }
-
-      before do
-        expect(Element).to receive(:find).and_return(element)
-      end
-
-      it "returns element as json" do
-        alchemy_get :show, id: element.id, format: :json
-
-        expect(response.status).to eq(200)
-        expect(response.content_type).to eq('application/json')
-
-        result = JSON.parse(response.body)
-
-        expect(result['id']).to eq(element.id)
-      end
-
-      context 'requesting an restricted element' do
-        let(:page) { build_stubbed(:alchemy_page, restricted: true) }
-
-        it "responds with 403" do
-          alchemy_get :show, id: element.id, format: :json
-
-          expect(response.status).to eq(403)
-          expect(response.content_type).to eq('application/json')
-
-          result = JSON.parse(response.body)
-
-          expect(result).to have_key('error')
-          expect(result['error']).to eq("Not authorized")
-        end
-      end
-    end
-  end
-end

data/spec/controllers/alchemy/api/pages_controller_spec.rb

@@ -1,167 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe Api::PagesController do
-    describe '#index' do
-      let!(:page) { create(:alchemy_page, :public) }
-
-      it "returns all public pages as json objects" do
-        alchemy_get :index, format: :json
-
-        expect(response.status).to eq(200)
-        expect(response.content_type).to eq('application/json')
-
-        result = JSON.parse(response.body)
-
-        expect(result).to have_key('pages')
-        expect(result['pages'].size).to eq(2)
-      end
-
-      context 'with page_layout' do
-        let!(:other_page) { create(:alchemy_page, :public, page_layout: 'news') }
-
-        it "returns only page with this page layout" do
-          alchemy_get :index, {page_layout: 'news', format: :json}
-
-          expect(response.status).to eq(200)
-          expect(response.content_type).to eq('application/json')
-
-          result = JSON.parse(response.body)
-
-          expect(result).to have_key('pages')
-          expect(result['pages'].size).to eq(1)
-        end
-      end
-
-      context 'with empty string as page_layout' do
-        it "returns all pages" do
-          alchemy_get :index, {page_layout: '', format: :json}
-
-          expect(response.status).to eq(200)
-          expect(response.content_type).to eq('application/json')
-
-          result = JSON.parse(response.body)
-
-          expect(result).to have_key('pages')
-          expect(result['pages'].size).to eq(2)
-        end
-      end
-    end
-
-    describe '#show' do
-      context 'for existing page' do
-        let(:page) { build_stubbed(:alchemy_page, :public, urlname: 'a-page') }
-
-        before do
-          expect(Page).to receive(:find_by).and_return(page)
-        end
-
-        it "returns page as json" do
-          alchemy_get :show, {urlname: page.urlname, format: :json}
-
-          expect(response.status).to eq(200)
-          expect(response.content_type).to eq('application/json')
-
-          result = JSON.parse(response.body)
-
-          expect(result['id']).to eq(page.id)
-        end
-
-        context 'requesting an restricted page' do
-          let(:page) { build_stubbed(:alchemy_page, restricted: true, urlname: 'a-page') }
-
-          it "responds with 403" do
-            alchemy_get :show, {urlname: page.urlname, format: :json}
-
-            expect(response.status).to eq(403)
-            expect(response.content_type).to eq('application/json')
-
-            result = JSON.parse(response.body)
-
-            expect(result).to have_key('error')
-            expect(result['error']).to eq("Not authorized")
-          end
-        end
-
-        context 'requesting a not public page' do
-          let(:page) { build_stubbed(:alchemy_page, urlname: 'a-page') }
-
-          it "responds with 403" do
-            alchemy_get :show, {urlname: page.urlname, format: :json}
-
-            expect(response.status).to eq(403)
-            expect(response.content_type).to eq('application/json')
-
-            result = JSON.parse(response.body)
-
-            expect(result).to have_key('error')
-            expect(result['error']).to eq("Not authorized")
-          end
-        end
-      end
-
-      context 'requesting an unknown page' do
-        it "responds with 404" do
-          alchemy_get :show, {urlname: 'not-existing', format: :json}
-
-          expect(response.status).to eq(404)
-          expect(response.content_type).to eq('application/json')
-
-          result = JSON.parse(response.body)
-
-          expect(result).to have_key('error')
-          expect(result['error']).to eq("Record not found")
-        end
-
-        context "because of requesting not existing language" do
-          let(:page) { create(:alchemy_page, :public) }
-
-          it "responds with 404" do
-            alchemy_get :show, {urlname: page.urlname, locale: 'na', format: :json}
-            expect(response.status).to eq(404)
-          end
-        end
-      end
-
-      context 'requesting a page with id' do
-        let(:page) { create(:alchemy_page, :public) }
-
-        it "responds with json" do
-          alchemy_get :show, {id: page.id, format: :json}
-
-          expect(response.status).to eq(200)
-          expect(response.content_type).to eq('application/json')
-
-          result = JSON.parse(response.body)
-
-          expect(result['id']).to eq(page.id)
-        end
-      end
-
-      context 'in an environment with multiple languages' do
-        let(:klingon) { create(:alchemy_language, :klingon) }
-
-        context 'having two pages with the same url names in different languages' do
-          let!(:english_page) { create(:alchemy_page, :public, language: Language.default, name: "same-name") }
-          let!(:klingon_page) { create(:alchemy_page, :public, language: klingon, name: "same-name") }
-
-          context 'when a locale is given' do
-            it 'renders the page related to its language' do
-              alchemy_get :show, {urlname: "same-name", locale: klingon_page.language_code, format: :json}
-              result = JSON.parse(response.body)
-              expect(result['id']).to eq(klingon_page.id)
-            end
-          end
-
-          context 'when no locale is given' do
-            it 'renders the page of the default language' do
-              alchemy_get :show, {urlname: "same-name", format: :json}
-              result = JSON.parse(response.body)
-              expect(result['id']).to eq(english_page.id)
-            end
-          end
-        end
-      end
-    end
-  end
-end