lc_alchemy_cms 3.2.0

data/lib/alchemy/test_support/controller_requests.rb

@@ -0,0 +1,73 @@
+# Use this module to easily test Alchemy actions within Alchemy components
+# or inside your application to test routes for the mounted Alchemy engine.
+#
+# Inside your spec_helper.rb, include this module inside the RSpec.configure
+# block by doing this:
+#
+#   require 'alchemy/test_support/controller_requests'
+#   RSpec.configure do |c|
+#     c.include Alchemy::TestSupport::ControllerRequests, type: :controller
+#   end
+#
+# Then, in your controller tests, you can access alchemy routes like this:
+#
+#   require 'spec_helper'
+#
+#   describe Alchemy::Admin::PagesController do
+#     it "can see all the pages" do
+#       alchemy_get :index
+#     end
+#   end
+#
+# Use alchemy_get, alchemy_post, alchemy_put or alchemy_delete to make requests
+# to the Alchemy engine, and use regular get, post, put or delete to make
+# requests to your application.
+#
+# Note: Based on Spree::TestingSupport::ControllerRequests. Thanks <3
+#
+module Alchemy
+  module TestSupport
+    module ControllerRequests
+      extend ActiveSupport::Concern
+
+      # Executes a request simulating GET HTTP method
+      def alchemy_get(action, parameters = nil, session = nil, flash = nil)
+        process_alchemy_action(action, parameters, session, flash, "GET")
+      end
+
+      # Executes a request simulating POST HTTP method
+      def alchemy_post(action, parameters = nil, session = nil, flash = nil)
+        process_alchemy_action(action, parameters, session, flash, "POST")
+      end
+
+      # Executes a request simulating PUT HTTP method
+      def alchemy_put(action, parameters = nil, session = nil, flash = nil)
+        process_alchemy_action(action, parameters, session, flash, "PUT")
+      end
+
+      # Executes a request simulating DELETE HTTP method
+      def alchemy_delete(action, parameters = nil, session = nil, flash = nil)
+        process_alchemy_action(action, parameters, session, flash, "DELETE")
+      end
+
+      # Executes a simulated XHR request
+      def alchemy_xhr(method, action, parameters = nil, session = nil, flash = nil)
+        process_alchemy_xhr_action(method, action, parameters, session, flash)
+      end
+
+      private
+
+      def process_alchemy_action(action, parameters = nil, session = nil, flash = nil, method = "GET")
+        @routes = Alchemy::Engine.routes
+        parameters ||= {}
+        process(action, method, parameters, session, flash)
+      end
+
+      def process_alchemy_xhr_action(method, action, parameters = nil, session = nil, flash = nil)
+        @routes = Alchemy::Engine.routes
+        parameters ||= {}
+        xml_http_request(method, action, parameters, session, flash)
+      end
+    end
+  end
+end

data/lib/alchemy/test_support/essence_shared_examples.rb

@@ -0,0 +1,286 @@
+require 'spec_helper'
+
+shared_examples_for "an essence" do
+  let(:element) { Alchemy::Element.new }
+  let(:content) { Alchemy::Content.new(name: 'foo') }
+  let(:content_description) { {'name' => 'foo'} }
+
+  it "touches the content after update" do
+    essence.save
+    content.update(essence: essence, essence_type: essence.class.name)
+    date = content.updated_at
+    content.essence.update(essence.ingredient_column.to_sym => ingredient_value)
+    content.reload
+    expect(content.updated_at).not_to eq(date)
+  end
+
+  it "should have correct partial path" do
+    underscored_essence = essence.class.name.demodulize.underscore
+    expect(essence.to_partial_path).to eq("alchemy/essences/#{underscored_essence}_view")
+  end
+
+  describe '#description' do
+    subject { essence.description }
+
+    context 'without element' do
+      it { is_expected.to eq({}) }
+    end
+
+    context 'with element' do
+      before do
+        expect(essence).to receive(:element).at_least(:once).and_return(element)
+      end
+
+      context 'but without content descriptions' do
+        it { is_expected.to eq({}) }
+      end
+
+      context 'and content descriptions' do
+        before do
+          allow(essence).to receive(:content).and_return(content)
+        end
+
+        context 'containing the content name' do
+          before do
+            expect(element).to receive(:content_descriptions).at_least(:once).and_return([content_description])
+          end
+
+          it "returns the content description" do
+            is_expected.to eq(content_description)
+          end
+        end
+
+        context 'not containing the content name' do
+          before do
+            expect(element).to receive(:content_descriptions).at_least(:once).and_return([])
+          end
+
+          it { is_expected.to eq({}) }
+        end
+      end
+    end
+  end
+
+  describe '#ingredient=' do
+    it 'should set the value to ingredient column' do
+      essence.ingredient = ingredient_value
+      expect(essence.ingredient).to eq ingredient_value
+    end
+  end
+
+  describe 'validations' do
+    context 'without essence description in elements.yml' do
+      it 'should return an empty array' do
+        allow(essence).to receive(:description).and_return nil
+        expect(essence.validations).to eq([])
+      end
+    end
+
+    context 'without validations defined in essence description in elements.yml' do
+      it 'should return an empty array' do
+        allow(essence).to receive(:description).and_return({name: 'test', type: 'EssenceText'})
+        expect(essence.validations).to eq([])
+      end
+    end
+
+    describe 'presence' do
+      context 'with string given as validation type' do
+        before do
+          allow(essence).to receive(:description).and_return({'validate' => ['presence']})
+        end
+
+        context 'when the ingredient column is empty' do
+          before do
+            essence.update(essence.ingredient_column.to_sym => nil)
+          end
+
+          it 'should not be valid' do
+            expect(essence).to_not be_valid
+          end
+        end
+
+        context 'when the ingredient column is not nil' do
+          before do
+            essence.update(essence.ingredient_column.to_sym => ingredient_value)
+          end
+
+          it 'should be valid' do
+            expect(essence).to be_valid
+          end
+        end
+      end
+
+      context 'with hash given as validation type' do
+        context 'where the value is true' do
+          before do
+            allow(essence).to receive(:description).and_return({'validate' => [{'presence' => true}]})
+          end
+
+          context 'when the ingredient column is empty' do
+            before do
+              essence.update(essence.ingredient_column.to_sym => nil)
+            end
+
+            it 'should not be valid' do
+              expect(essence).to_not be_valid
+            end
+          end
+
+          context 'when the ingredient column is not nil' do
+            before do
+              essence.update(essence.ingredient_column.to_sym => ingredient_value)
+            end
+
+            it 'should be valid' do
+              expect(essence).to be_valid
+            end
+          end
+        end
+
+        context 'where the value is false' do
+          before do
+            allow(essence).to receive(:description).and_return({'validate' => [{'presence' => false}]})
+          end
+
+          it 'should be valid' do
+            expect(essence).to be_valid
+          end
+        end
+      end
+    end
+
+    describe 'uniqueness' do
+      before do
+        allow(essence).to receive(:element).and_return(build_stubbed(:element))
+        essence.update(essence.ingredient_column.to_sym => ingredient_value)
+      end
+
+      context 'with string given as validation type' do
+        before do
+          expect(essence).to receive(:description).at_least(:once).and_return({'validate' => ['uniqueness']})
+        end
+
+        context 'when a duplicate exists' do
+          before do
+            allow(essence).to receive(:duplicates).and_return([essence.dup])
+          end
+
+          it 'should not be valid' do
+            expect(essence).to_not be_valid
+          end
+
+          context 'when validated essence is not public' do
+            before do
+              expect(essence).to receive(:public?).and_return(false)
+            end
+
+            it 'should be valid' do
+              expect(essence).to be_valid
+            end
+          end
+        end
+
+        context 'when no duplicate exists' do
+          before do
+            expect(essence).to receive(:duplicates).and_return([])
+          end
+
+          it 'should be valid' do
+            expect(essence).to be_valid
+          end
+        end
+      end
+
+      context 'with hash given as validation type' do
+        context 'where the value is true' do
+          before do
+            expect(essence).to receive(:description).at_least(:once).and_return({'validate' => [{'uniqueness' => true}]})
+          end
+
+          context 'when a duplicate exists' do
+            before do
+              allow(essence).to receive(:duplicates).and_return([essence.dup])
+            end
+
+            it 'should not be valid' do
+              expect(essence).to_not be_valid
+            end
+
+            context 'when validated essence is not public' do
+              before do
+                expect(essence).to receive(:public?).and_return(false)
+              end
+
+              it 'should be valid' do
+                expect(essence).to be_valid
+              end
+            end
+          end
+
+          context 'when no duplicate exists' do
+            before do
+              expect(essence).to receive(:duplicates).and_return([])
+            end
+
+            it 'should be valid' do
+              expect(essence).to be_valid
+            end
+          end
+        end
+
+        context 'where the value is false' do
+          before do
+            allow(essence).to receive(:description).and_return({'validate' => [{'uniqueness' => false}]})
+          end
+
+          it 'should be valid' do
+            expect(essence).to be_valid
+          end
+        end
+      end
+    end
+
+    describe '#acts_as_essence?' do
+      it 'should return true' do
+        expect(essence.acts_as_essence?).to be_truthy
+      end
+    end
+  end
+
+  context 'delegations' do
+    let(:page)    { create(:restricted_page) }
+    let(:element) { create(:element, name: 'headline', create_contents_after_create: true, page: page) }
+    let(:content) { element.contents.find_by(essence_type: 'Alchemy::EssenceText') }
+    let(:essence) { content.essence }
+
+    it "delegates restricted? to page" do
+      expect(page.restricted?).to be(true)
+      expect(essence.restricted?).to be(true)
+    end
+
+    it "delegates trashed? to element" do
+      element.update!(position: nil)
+      expect(element.trashed?).to be true
+      expect(essence.trashed?).to be true
+    end
+
+    it "delegates public? to element" do
+      element.update!(public: false)
+      expect(element.public?).to be false
+      expect(essence.public?).to be false
+    end
+  end
+
+  describe 'essence relations' do
+    let(:page)    { create(:restricted_page) }
+    let(:element) { create(:element) }
+
+    it "registers itself on page as essence relation" do
+      expect(page.respond_to?(essence.class.model_name.route_key)).to be(true)
+    end
+
+    it "registers itself on element as essence relation" do
+      expect(element.respond_to?(essence.class.model_name.route_key)).to be(true)
+    end
+  end
+end

data/lib/alchemy/test_support/factories.rb

@@ -0,0 +1,147 @@
+require 'factory_girl'
+
+FactoryGirl.define do
+
+  factory :alchemy_dummy_user, class: 'DummyUser' do
+    sequence(:email) { |n| "john.#{n}@doe.com" }
+    password 's3cr3t'
+    alchemy_roles ['member']
+
+    trait :as_admin do
+      alchemy_roles ['admin']
+    end
+
+    trait :as_author do
+      alchemy_roles ['author']
+    end
+
+    trait :as_editor do
+      alchemy_roles ['editor']
+    end
+  end
+
+  factory :language, :class => 'Alchemy::Language' do
+    name 'Deutsch'
+    code 'de'
+    default true
+    frontpage_name 'Intro'
+    page_layout { Alchemy::Config.get(:default_language)['page_layout'] }
+    public true
+    site { Alchemy::Site.first }
+
+    factory :klingonian do
+      name 'Klingonian'
+      code 'kl'
+      frontpage_name 'Tuq'
+      default false
+    end
+
+    factory :english do
+      name 'English'
+      code 'en'
+      frontpage_name 'Intro'
+      default false
+    end
+  end
+
+  factory :page, :class => 'Alchemy::Page' do
+
+    language { Alchemy::Language.default || FactoryGirl.create(:language) }
+    sequence(:name) { |n| "A Page #{n}" }
+    parent_id { (Alchemy::Page.find_by_language_root(true) || FactoryGirl.create(:language_root_page)).id }
+    page_layout "standard"
+
+    # This speeds up creating of pages dramatically. Pass :do_not_autogenerate => false to generate elements
+    do_not_autogenerate true
+
+    factory :language_root_page do
+      name 'Startseite'
+      page_layout { language.page_layout }
+      language_root true
+      public true
+      parent_id { Alchemy::Page.root.id }
+    end
+
+    factory :public_page do
+      sequence(:name) { |n| "A Public Page #{n}" }
+      public true
+    end
+
+    factory :systempage do
+      name "Systempage"
+      parent_id { Alchemy::Page.root.id }
+      language_root false
+      page_layout nil
+      language nil
+    end
+
+    factory :restricted_page do
+      name "Restricted page"
+      restricted true
+    end
+
+  end
+
+  factory :cell, :class => 'Alchemy::Cell' do
+    page { Alchemy::Page.find_by(language_root: true) || FactoryGirl.create(:language_root_page) }
+    name "a_cell"
+  end
+
+  factory :element, :class => 'Alchemy::Element' do
+    name 'article'
+    create_contents_after_create false
+
+    factory :unique_element do
+      unique true
+      name 'header'
+    end
+  end
+
+  factory :picture, :class => 'Alchemy::Picture' do
+    image_file File.new(File.expand_path('../../../../spec/fixtures/image.png', __FILE__))
+    name 'image'
+    image_file_name 'image.png'
+    upload_hash Time.now.hash
+  end
+
+  factory :content, :class => 'Alchemy::Content' do
+    name "text"
+    essence_type "Alchemy::EssenceText"
+    association :essence, :factory => :essence_text
+  end
+
+  factory :essence_text, :class => 'Alchemy::EssenceText' do
+    body ''
+  end
+
+  factory :essence_picture, :class => 'Alchemy::EssencePicture' do
+    picture
+  end
+
+  factory :essence_file, :class => 'Alchemy::EssenceFile' do
+    attachment
+  end
+
+  factory :attachment, :class => 'Alchemy::Attachment' do
+    file File.new(File.expand_path('../../../../spec/fixtures/image.png', __FILE__))
+    name 'image'
+    file_name 'image.png'
+  end
+
+  factory :event do
+    name 'My Event'
+    hidden_name 'not shown'
+    starts_at DateTime.new(2012, 03, 02, 8, 15)
+    ends_at DateTime.new(2012, 03, 02, 19, 30)
+    lunch_starts_at DateTime.new(2012, 03, 02, 12, 15)
+    lunch_ends_at DateTime.new(2012, 03, 02, 13, 45)
+    description "something\nfancy"
+    published false
+    entrance_fee 12.3
+  end
+
+  factory :site, class: 'Alchemy::Site' do
+    name 'A Site'
+    host 'domain.com'
+  end
+end