alchemy_cms 4.5.0 → 5.0.0.rc1

data/lib/alchemy/test_support/config_stubbing.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Alchemy
   module TestSupport
     # Allows you to stub the Alchemy configuration in your specs

data/lib/alchemy/test_support/essence_shared_examples.rb

@@ -1,36 +1,36 @@
 # frozen_string_literal: true
 
-require 'shoulda-matchers'
-require 'alchemy/test_support/factories/page_factory'
-require 'alchemy/test_support/factories/element_factory'
-require 'alchemy/test_support/factories/content_factory'
+require "shoulda-matchers"
+require "alchemy/test_support/factories/page_factory"
+require "alchemy/test_support/factories/element_factory"
+require "alchemy/test_support/factories/content_factory"
 
 RSpec.shared_examples_for "an essence" do
   let(:element) { Alchemy::Element.new }
-  let(:content) { Alchemy::Content.new(name: 'foo') }
-  let(:content_definition) { {'name' => 'foo'} }
+  let(:content) { Alchemy::Content.new(name: "foo") }
+  let(:content_definition) { { "name" => "foo" } }
 
-  describe 'eager loading' do
+  describe "eager loading" do
     before do
       2.times { described_class.create! }
     end
 
-    it 'does not throw error if eager loaded' do
+    it "does not throw error if eager loaded" do
       expect {
         described_class.all.includes(:ingredient_association).to_a
       }.to_not raise_error
     end
   end
 
-  it "touches the content after update" do
+  it "touches the element after save" do
     element = FactoryBot.create(:alchemy_element)
     content = FactoryBot.create(:alchemy_content, element: element, essence: essence, essence_type: essence.class.name)
 
-    content.update_column(:updated_at, 3.days.ago)
+    element.update_column(:updated_at, 3.days.ago)
     content.essence.update(essence.ingredient_column.to_sym => ingredient_value)
 
-    content.reload
-    expect(content.updated_at).to be_within(3.seconds).of(Time.current)
+    element.reload
+    expect(element.updated_at).to be_within(3.seconds).of(Time.current)
   end
 
   it "should have correct partial path" do
@@ -38,28 +38,28 @@ RSpec.shared_examples_for "an essence" do
     expect(essence.to_partial_path).to eq("alchemy/essences/#{underscored_essence}_view")
   end
 
-  describe '#definition' do
+  describe "#definition" do
     subject { essence.definition }
 
-    context 'without element' do
+    context "without element" do
       it { is_expected.to eq({}) }
     end
 
-    context 'with element' do
+    context "with element" do
       before do
         expect(essence).to receive(:element).at_least(:once).and_return(element)
       end
 
-      context 'but without content definitions' do
+      context "but without content definitions" do
         it { is_expected.to eq({}) }
       end
 
-      context 'and content definitions' do
+      context "and content definitions" do
         before do
           allow(essence).to receive(:content).and_return(content)
         end
 
-        context 'containing the content name' do
+        context "containing the content name" do
           before do
             expect(element).to receive(:content_definitions).at_least(:once).and_return([content_definition])
           end
@@ -69,7 +69,7 @@ RSpec.shared_examples_for "an essence" do
           end
         end
 
-        context 'not containing the content name' do
+        context "not containing the content name" do
           before do
             expect(element).to receive(:content_definitions).at_least(:once).and_return([])
           end
@@ -80,200 +80,200 @@ RSpec.shared_examples_for "an essence" do
     end
   end
 
-  describe '#ingredient=' do
-    it 'should set the value to ingredient column' do
+  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 definition in elements.yml' do
-      it 'should return an empty array' do
+  describe "validations" do
+    context "without essence definition in elements.yml" do
+      it "should return an empty array" do
         allow(essence).to receive(:definition).and_return nil
         expect(essence.validations).to eq([])
       end
     end
 
-    context 'without validations defined in essence definition in elements.yml' do
-      it 'should return an empty array' do
-        allow(essence).to receive(:definition).and_return({name: 'test', type: 'EssenceText'})
+    context "without validations defined in essence definition in elements.yml" do
+      it "should return an empty array" do
+        allow(essence).to receive(:definition).and_return({ name: "test", type: "EssenceText" })
         expect(essence.validations).to eq([])
       end
     end
 
-    describe 'presence' do
-      context 'with string given as validation type' do
+    describe "presence" do
+      context "with string given as validation type" do
         before do
-          allow(essence).to receive(:definition).and_return({'validate' => ['presence']})
+          allow(essence).to receive(:definition).and_return({ "validate" => ["presence"] })
         end
 
-        context 'when the ingredient column is empty' do
+        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
+          it "should not be valid" do
             expect(essence).to_not be_valid
           end
         end
 
-        context 'when the ingredient column is not nil' do
+        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
+          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
+      context "with hash given as validation type" do
+        context "where the value is true" do
           before do
-            allow(essence).to receive(:definition).and_return({'validate' => [{'presence' => true}]})
+            allow(essence).to receive(:definition).and_return({ "validate" => [{ "presence" => true }] })
           end
 
-          context 'when the ingredient column is empty' do
+          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
+            it "should not be valid" do
               expect(essence).to_not be_valid
             end
           end
 
-          context 'when the ingredient column is not nil' do
+          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
+            it "should be valid" do
               expect(essence).to be_valid
             end
           end
         end
 
-        context 'where the value is false' do
+        context "where the value is false" do
           before do
-            allow(essence).to receive(:definition).and_return({'validate' => [{'presence' => false}]})
+            allow(essence).to receive(:definition).and_return({ "validate" => [{ "presence" => false }] })
           end
 
-          it 'should be valid' do
+          it "should be valid" do
             expect(essence).to be_valid
           end
         end
       end
     end
 
-    describe 'uniqueness' do
+    describe "uniqueness" do
       before do
-        allow(essence).to receive(:element).and_return(FactoryBot.build_stubbed(:alchemy_element))
+        allow(essence).to receive(:element).and_return(FactoryBot.create(:alchemy_element))
         essence.update(essence.ingredient_column.to_sym => ingredient_value)
       end
 
-      context 'with string given as validation type' do
+      context "with string given as validation type" do
         before do
-          expect(essence).to receive(:definition).at_least(:once).and_return({'validate' => ['uniqueness']})
+          expect(essence).to receive(:definition).at_least(:once).and_return({ "validate" => ["uniqueness"] })
         end
 
-        context 'when a duplicate exists' do
+        context "when a duplicate exists" do
           before do
             allow(essence).to receive(:duplicates).and_return([essence.dup])
           end
 
-          it 'should not be valid' do
+          it "should not be valid" do
             expect(essence).to_not be_valid
           end
 
-          context 'when validated essence is not public' do
+          context "when validated essence is not public" do
             before do
               expect(essence).to receive(:public?).and_return(false)
             end
 
-            it 'should be valid' do
+            it "should be valid" do
               expect(essence).to be_valid
             end
           end
         end
 
-        context 'when no duplicate exists' do
+        context "when no duplicate exists" do
           before do
             expect(essence).to receive(:duplicates).and_return([])
           end
 
-          it 'should be valid' do
+          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
+      context "with hash given as validation type" do
+        context "where the value is true" do
           before do
-            expect(essence).to receive(:definition).at_least(:once).and_return({'validate' => [{'uniqueness' => true}]})
+            expect(essence).to receive(:definition).at_least(:once).and_return({ "validate" => [{ "uniqueness" => true }] })
           end
 
-          context 'when a duplicate exists' do
+          context "when a duplicate exists" do
             before do
               allow(essence).to receive(:duplicates).and_return([essence.dup])
             end
 
-            it 'should not be valid' do
+            it "should not be valid" do
               expect(essence).to_not be_valid
             end
 
-            context 'when validated essence is not public' do
+            context "when validated essence is not public" do
               before do
                 expect(essence).to receive(:public?).and_return(false)
               end
 
-              it 'should be valid' do
+              it "should be valid" do
                 expect(essence).to be_valid
               end
             end
           end
 
-          context 'when no duplicate exists' do
+          context "when no duplicate exists" do
             before do
               expect(essence).to receive(:duplicates).and_return([])
             end
 
-            it 'should be valid' do
+            it "should be valid" do
               expect(essence).to be_valid
             end
           end
         end
 
-        context 'where the value is false' do
+        context "where the value is false" do
           before do
-            allow(essence).to receive(:definition).and_return({'validate' => [{'uniqueness' => false}]})
+            allow(essence).to receive(:definition).and_return({ "validate" => [{ "uniqueness" => false }] })
           end
 
-          it 'should be valid' do
+          it "should be valid" do
             expect(essence).to be_valid
           end
         end
       end
     end
 
-    describe '#acts_as_essence?' do
-      it 'should return true' do
+    describe "#acts_as_essence?" do
+      it "should return true" do
         expect(essence.acts_as_essence?).to be_truthy
       end
     end
   end
 
-  context 'delegations' do
+  context "delegations" do
     it { should delegate_method(:restricted?).to(:page) }
     it { should delegate_method(:trashed?).to(:element) }
-    it { should delegate_method(:public?).to(:element)  }
+    it { should delegate_method(:public?).to(:element) }
   end
 
-  describe 'essence relations' do
-    let(:page)    { FactoryBot.create(:alchemy_page, :restricted) }
+  describe "essence relations" do
+    let(:page) { FactoryBot.create(:alchemy_page, :restricted) }
     let(:element) { FactoryBot.create(:alchemy_element) }
 
     it "registers itself on page as essence relation" do

data/lib/alchemy/test_support/factories.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-Dir["#{File.dirname(__FILE__)}/factories/*.rb"].each do |file|
+Dir["#{File.dirname(__FILE__)}/factories/*.rb"].sort.each do |file|
   require file
 end

data/lib/alchemy/test_support/factories/attachment_factory.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require 'factory_bot'
+require "factory_bot"
 
 FactoryBot.define do
-  factory :alchemy_attachment, class: 'Alchemy::Attachment' do
+  factory :alchemy_attachment, class: "Alchemy::Attachment" do
     file do
-      File.new(Alchemy::Engine.root.join('lib', 'alchemy', 'test_support', 'fixtures', 'image.png'))
+      File.new(Alchemy::Engine.root.join("lib", "alchemy", "test_support", "fixtures", "image.png"))
     end
-    name { 'image' }
-    file_name { 'image.png' }
+    name { "image" }
+    file_name { "image.png" }
   end
 end

data/lib/alchemy/test_support/factories/content_factory.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require 'factory_bot'
-require 'alchemy/test_support/factories/element_factory'
-require 'alchemy/test_support/factories/essence_file_factory'
-require 'alchemy/test_support/factories/essence_picture_factory'
-require 'alchemy/test_support/factories/essence_text_factory'
+require "factory_bot"
+require "alchemy/test_support/factories/element_factory"
+require "alchemy/test_support/factories/essence_file_factory"
+require "alchemy/test_support/factories/essence_picture_factory"
+require "alchemy/test_support/factories/essence_text_factory"
 
 FactoryBot.define do
-  factory :alchemy_content, class: 'Alchemy::Content' do
+  factory :alchemy_content, class: "Alchemy::Content" do
     name { "text" }
     essence_type { "Alchemy::EssenceText" }
     association :essence, factory: :alchemy_essence_text

data/lib/alchemy/test_support/factories/dummy_user_factory.rb

@@ -1,23 +1,23 @@
 # frozen_string_literal: true
 
-require 'factory_bot'
+require "factory_bot"
 
 FactoryBot.define do
-  factory :alchemy_dummy_user, class: 'DummyUser' do
+  factory :alchemy_dummy_user, class: "DummyUser" do
     sequence(:email) { |n| "john.#{n}@doe.com" }
-    password { 's3cr3t' }
-    alchemy_roles { ['member'] }
+    password { "s3cr3t" }
+    alchemy_roles { ["member"] }
 
     trait :as_admin do
-      alchemy_roles { ['admin'] }
+      alchemy_roles { ["admin"] }
     end
 
     trait :as_author do
-      alchemy_roles { ['author'] }
+      alchemy_roles { ["author"] }
     end
 
     trait :as_editor do
-      alchemy_roles { ['editor'] }
+      alchemy_roles { ["editor"] }
     end
   end
 end

data/lib/alchemy/test_support/factories/element_factory.rb

@@ -1,22 +1,22 @@
 # frozen_string_literal: true
 
-require 'factory_bot'
-require 'alchemy/test_support/factories/page_factory'
+require "factory_bot"
+require "alchemy/test_support/factories/page_factory"
 
 FactoryBot.define do
-  factory :alchemy_element, class: 'Alchemy::Element' do
-    name { 'article' }
+  factory :alchemy_element, class: "Alchemy::Element" do
+    name { "article" }
     autogenerate_contents { false }
     association :page, factory: :alchemy_page
 
     trait :fixed do
       fixed { true }
-      name { 'right_column' }
+      name { "right_column" }
     end
 
     trait :unique do
       unique { true }
-      name { 'header' }
+      name { "header" }
     end
 
     trait :trashed do
@@ -26,12 +26,12 @@ FactoryBot.define do
     end
 
     trait :with_nestable_elements do
-      name { 'slider' }
+      name { "slider" }
     end
 
     trait :nested do
-      association :parent_element, factory: :alchemy_element, name: 'slider'
-      name { 'slide' }
+      association :parent_element, factory: :alchemy_element, name: "slider"
+      name { "slide" }
     end
 
     trait :with_contents do