alchemy_cms 3.2.1 → 3.3.0.rc1

data/spec/helpers/{url_helper_spec.rb → alchemy/url_helper_spec.rb}

@@ -12,45 +12,59 @@ module Alchemy
 
     context 'page path helpers' do
       describe "#show_page_path_params" do
-        context "when multi_language" do
+        subject(:show_page_path_params) { helper.show_page_path_params(page) }
 
+        context "if prefix_locale? is false" do
           before do
-            allow(helper).to receive(:multi_language?).and_return(true)
+            expect(helper).to receive(:prefix_locale?) { false }
           end
 
-          it "should return a Hash with urlname and language_id parameter" do
-            allow(helper).to receive(:multi_language?).and_return(true)
-            expect(helper.show_page_path_params(page)).to include(urlname: 'testpage', locale: 'en')
+          it "returns a Hash with urlname and no locale parameter" do
+            expect(show_page_path_params).to include(urlname: 'testpage')
+            expect(show_page_path_params).to_not include(locale: 'en')
           end
 
-          it "should return a Hash with urlname, language_id and query parameter" do
-            allow(helper).to receive(:multi_language?).and_return(true)
-            expect(helper.show_page_path_params(page, {query: 'test'})).to include(urlname: 'testpage', locale: 'en', query: 'test')
+          context "with addiitonal parameters" do
+            subject(:show_page_path_params) do
+              helper.show_page_path_params(page, {query: 'test'})
+            end
+
+            it "returns a Hash with urlname, no locale and query parameter" do
+              expect(show_page_path_params).to \
+                include(urlname: 'testpage', query: 'test')
+              expect(show_page_path_params).to_not \
+                include(locale: 'en')
+            end
           end
         end
 
-        context "not multi_language" do
+        context "if prefix_locale? is false" do
           before do
-            allow(helper).to receive(:multi_language?).and_return(false)
+            expect(helper).to receive(:prefix_locale?) { true }
           end
 
-          it "should return a Hash with the urlname but without language_id parameter" do
-            expect(helper.show_page_path_params(page)).to include(urlname: 'testpage')
-            expect(helper.show_page_path_params(page)).not_to include(locale: 'en')
+          it "returns a Hash with urlname and locale parameter" do
+            expect(show_page_path_params).to \
+              include(urlname: 'testpage', locale: 'en')
           end
 
-          it "should return a Hash with urlname and query parameter" do
-            expect(helper.show_page_path_params(page, {query: 'test'})).to include(urlname: 'testpage', query: 'test')
-            expect(helper.show_page_path_params(page)).not_to include(locale: 'en')
+          context "with additional parameters" do
+            subject(:show_page_path_params) do
+              helper.show_page_path_params(page, {query: 'test'})
+            end
+
+            it "returns a Hash with urlname, locale and query parameter" do
+              expect(show_page_path_params).to \
+                include(urlname: 'testpage', locale: 'en', query: 'test')
+            end
           end
         end
       end
 
       describe "#show_alchemy_page_path" do
-        context "when multi_language" do
-
+        context "when prefix_locale? set to true" do
           before do
-            allow(helper).to receive(:multi_language?).and_return(true)
+            expect(helper).to receive(:prefix_locale?) { true }
           end
 
           it "should return the correct relative path string" do
@@ -58,13 +72,14 @@ module Alchemy
           end
 
           it "should return the correct relative path string with additional parameters" do
-            expect(helper.show_alchemy_page_path(page, {query: 'test'})).to eq("/#{page.language_code}/testpage?query=test")
+            expect(helper.show_alchemy_page_path(page, {query: 'test'})).to \
+              eq("/#{page.language_code}/testpage?query=test")
           end
         end
 
-        context "not multi_language" do
+        context "when prefix_locale? set to false" do
           before do
-            allow(helper).to receive(:multi_language?).and_return(false)
+            expect(helper).to receive(:prefix_locale?) { false }
           end
 
           it "should return the correct relative path string" do
@@ -72,38 +87,42 @@ module Alchemy
           end
 
           it "should return the correct relative path string with additional parameter" do
-            expect(helper.show_alchemy_page_path(page, {query: 'test'})).to eq("/testpage?query=test")
+            expect(helper.show_alchemy_page_path(page, {query: 'test'})).to \
+              eq("/testpage?query=test")
           end
         end
       end
 
       describe "#show_alchemy_page_url" do
-        context "when multi_language" do
-
+        context "when prefix_locale? set to true" do
           before do
-            allow(helper).to receive(:multi_language?).and_return(true)
+            expect(helper).to receive(:prefix_locale?) { true }
           end
 
           it "should return the correct url string" do
-            expect(helper.show_alchemy_page_url(page)).to eq("http://#{helper.request.host}/#{page.language_code}/testpage")
+            expect(helper.show_alchemy_page_url(page)).to \
+              eq("http://#{helper.request.host}/#{page.language_code}/testpage")
           end
 
           it "should return the correct url string with additional parameters" do
-            expect(helper.show_alchemy_page_url(page, {query: 'test'})).to eq("http://#{helper.request.host}/#{page.language_code}/testpage?query=test")
+            expect(helper.show_alchemy_page_url(page, {query: 'test'})).to \
+              eq("http://#{helper.request.host}/#{page.language_code}/testpage?query=test")
           end
         end
 
-        context "not multi_language" do
+        context "when prefix_locale? set to false" do
           before do
-            allow(helper).to receive(:multi_language?).and_return(false)
+            expect(helper).to receive(:prefix_locale?) { false }
           end
 
           it "should return the correct url string" do
-            expect(helper.show_alchemy_page_url(page)).to eq("http://#{helper.request.host}/testpage")
+            expect(helper.show_alchemy_page_url(page)).to \
+              eq("http://#{helper.request.host}/testpage")
           end
 
           it "should return the correct url string with additional parameter" do
-            expect(helper.show_alchemy_page_url(page, {query: 'test'})).to eq("http://#{helper.request.host}/testpage?query=test")
+            expect(helper.show_alchemy_page_url(page, {query: 'test'})).to \
+              eq("http://#{helper.request.host}/testpage?query=test")
           end
         end
       end
@@ -114,19 +133,22 @@ module Alchemy
 
       describe '#show_alchemy_picture_path' do
         it "should return the correct relative path string" do
-          expect(helper.show_alchemy_picture_path(picture)).to match(Regexp.new("/pictures/42/show/cute_kitten.jpg"))
+          expect(helper.show_alchemy_picture_path(picture)).to \
+            match(Regexp.new("/pictures/42/show/cute_kitten.jpg"))
         end
       end
 
       describe '#show_alchemy_picture_url' do
         it "should return the correct url string" do
-          expect(helper.show_alchemy_picture_url(picture)).to match(Regexp.new("http://#{helper.request.host}/pictures/42/show/cute_kitten.jpg"))
+          expect(helper.show_alchemy_picture_url(picture)).to \
+            match(Regexp.new("http://#{helper.request.host}/pictures/42/show/cute_kitten.jpg"))
         end
       end
 
       describe '#show_picture_path_params' do
         it "should return the correct params for rendering a picture" do
-          expect(helper.show_picture_path_params(picture)).to include(name: 'cute_kitten', format: 'jpg')
+          expect(helper.show_picture_path_params(picture)).to \
+            include(name: 'cute_kitten', format: 'jpg')
         end
 
         it "should include the secure hash parameter" do
@@ -136,13 +158,15 @@ module Alchemy
 
         context "with additional params" do
           it "should include these params" do
-            expect(helper.show_picture_path_params(picture, {format: 'png'})).to include(name: 'cute_kitten', format: 'png')
+            expect(helper.show_picture_path_params(picture, {format: 'png'})).to \
+              include(name: 'cute_kitten', format: 'png')
           end
         end
 
         context "with additional params crop set to true" do
           it "should include crop as parameter" do
-            expect(helper.show_picture_path_params(picture, {crop: true})).to include(name: 'cute_kitten', crop: 'crop')
+            expect(helper.show_picture_path_params(picture, {crop: true})).to \
+              include(name: 'cute_kitten', crop: 'crop')
           end
         end
       end
@@ -152,18 +176,20 @@ module Alchemy
       let(:attachment) { mock_model(Attachment, urlname: 'test-attachment.pdf') }
 
       it 'should return the correct relative path to download an attachment' do
-        expect(helper.download_alchemy_attachment_path(attachment)).to eq("/attachment/#{attachment.id}/download/#{attachment.urlname}")
+        expect(helper.download_alchemy_attachment_path(attachment)).to \
+          eq("/attachment/#{attachment.id}/download/#{attachment.urlname}")
       end
 
       it 'should return the correct url to download an attachment' do
-        expect(helper.download_alchemy_attachment_url(attachment)).to eq("http://#{helper.request.host}/attachment/#{attachment.id}/download/#{attachment.urlname}")
+        expect(helper.download_alchemy_attachment_url(attachment)).to \
+          eq("http://#{helper.request.host}/attachment/#{attachment.id}/download/#{attachment.urlname}")
       end
     end
 
     describe '#full_url_for_element' do
       subject { full_url_for_element(element) }
 
-      let(:element) { build_stubbed(:element, name: 'headline', page: page) }
+      let(:element) { build_stubbed(:alchemy_element, name: 'headline', page: page) }
       let(:current_server) { '' }
 
       it "returns the url to this element" do

data/spec/libraries/config_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 
 module Alchemy
   describe Config do
-
     describe ".get" do
       it "should call #show" do
         expect(Config).to receive(:show).and_return({})
@@ -55,7 +54,7 @@ module Alchemy
 
     describe '.read_file' do
       context 'when given path to yml file exists' do
-        before { allow(File).to receive(:exists?).and_return(true) }
+        before { allow(File).to receive(:exist?).and_return(true) }
 
         it 'should call YAML.load_file with the given config path' do
           expect(YAML).to receive(:load_file).once.with('path/to/config.yml').and_return({})
@@ -64,7 +63,7 @@ module Alchemy
 
         context 'but its empty' do
           before do
-            allow(File).to receive(:exists?).with('empty_file.yml').and_return(true)
+            allow(File).to receive(:exist?).with('empty_file.yml').and_return(true)
             allow(YAML).to receive(:load_file).and_return(false) # YAML.load_file returns false if file is empty.
           end
 

data/spec/libraries/controller_actions_spec.rb

@@ -53,7 +53,7 @@ describe 'Alchemy::ControllerActions', type: 'controller' do
 
   describe "#set_alchemy_language" do
     let(:default_language) { Alchemy::Language.default }
-    let(:klingonian)       { FactoryGirl.create(:klingonian) }
+    let(:klingon)          { create(:alchemy_language, :klingon) }
 
     after do
       # We must never change the app's locale
@@ -62,25 +62,25 @@ describe 'Alchemy::ControllerActions', type: 'controller' do
 
     context "with a Language argument" do
       it "should set the language to the passed Language instance" do
-        controller.send :set_alchemy_language, klingonian
-        expect(assigns(:language)).to eq(klingonian)
-        expect(Alchemy::Language.current).to eq(klingonian)
+        controller.send :set_alchemy_language, klingon
+        expect(assigns(:language)).to eq(klingon)
+        expect(Alchemy::Language.current).to eq(klingon)
       end
     end
 
     context "with a language id argument" do
       it "should set the language to the language specified by the passed id" do
-        controller.send :set_alchemy_language, klingonian.id
-        expect(assigns(:language)).to eq(klingonian)
-        expect(Alchemy::Language.current).to eq(klingonian)
+        controller.send :set_alchemy_language, klingon.id
+        expect(assigns(:language)).to eq(klingon)
+        expect(Alchemy::Language.current).to eq(klingon)
       end
     end
 
     context "with a language code argument" do
       it "should set the language to the language specified by the passed code" do
-        controller.send :set_alchemy_language, klingonian.code
-        expect(assigns(:language)).to eq(klingonian)
-        expect(Alchemy::Language.current).to eq(klingonian)
+        controller.send :set_alchemy_language, klingon.code
+        expect(assigns(:language)).to eq(klingon)
+        expect(Alchemy::Language.current).to eq(klingon)
       end
     end
 
@@ -96,24 +96,24 @@ describe 'Alchemy::ControllerActions', type: 'controller' do
 
     context "with language in the session" do
       before do
-        allow(controller).to receive(:session).and_return(alchemy_language_id: klingonian.id)
-        allow(Alchemy::Language).to receive(:current).and_return(klingonian)
+        allow(controller).to receive(:session).and_return(alchemy_language_id: klingon.id)
+        allow(Alchemy::Language).to receive(:current).and_return(klingon)
       end
 
       it "should use the language from the session" do
         controller.send :set_alchemy_language
-        expect(assigns(:language)).to eq(klingonian)
-        expect(Alchemy::Language.current).to eq(klingonian)
+        expect(assigns(:language)).to eq(klingon)
+        expect(Alchemy::Language.current).to eq(klingon)
       end
     end
 
     context "with lang param" do
       it "should set the language" do
-        allow(controller).to receive(:params).and_return(locale: klingonian.code)
+        allow(controller).to receive(:params).and_return(locale: klingon.code)
         controller.send :set_alchemy_language
-        expect(assigns(:language)).to eq(klingonian)
-        expect(Alchemy::Language.current).to eq(klingonian)
-        expect(controller.session).to include_language_information_for(klingonian)
+        expect(assigns(:language)).to eq(klingon)
+        expect(Alchemy::Language.current).to eq(klingon)
+        expect(controller.session).to include_language_information_for(klingon)
       end
 
       context "for language that does not exist" do

data/spec/libraries/i18n_spec.rb

@@ -1,6 +1,13 @@
 require 'spec_helper'
 
 module Alchemy
+  describe ".t" do
+    it 'scopes translations intro alchemy namespace' do
+      expect(::I18n).to receive(:t).with(:foo, default: 'Foo', scope: ['alchemy'])
+      ::Alchemy.t(:foo)
+    end
+  end
+
   describe I18n do
     describe '.translation_files' do
       subject { I18n.translation_files }

data/spec/libraries/page_layout_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 
 module Alchemy
   describe PageLayout do
-
     describe ".all" do
       # skip memoization
       before { PageLayout.instance_variable_set("@definitions", nil) }
@@ -27,7 +26,7 @@ module Alchemy
       end
 
       context "with missing layouts file" do
-        before { expect(File).to receive(:exists?).and_return(false) }
+        before { expect(File).to receive(:exist?).and_return(false) }
 
         it "raises error empty array" do
           expect { subject }.to raise_error(LoadError)
@@ -49,12 +48,20 @@ module Alchemy
     end
 
     describe ".get" do
-      it "should return the page_layout description found by given name" do
+      it "should return the page_layout definition found by given name" do
         allow(PageLayout).to receive(:all).and_return([{'name' => 'default'}, {'name' => 'contact'}])
         expect(PageLayout.get('default')).to eq({'name' => 'default'})
       end
     end
 
+    describe ".get_all_by_attributes" do
+      subject { PageLayout.get_all_by_attributes(unique: true) }
+
+      it "should return all page layout with the given attribute" do
+        expect(subject.map { |page_layout| page_layout['name'] }.to_a).to eq(['index', 'news', 'contact', 'erb_layout'])
+      end
+    end
+
     describe '.layouts_with_own_for_select' do
       it "should not hold a layout twice" do
         layouts = PageLayout.layouts_with_own_for_select('standard', 1, false)
@@ -91,7 +98,7 @@ module Alchemy
         end
 
         before do
-          allow(Site).to receive(:layout_definitions).and_return(definitions)
+          allow(Site).to receive(:definitions).and_return(definitions)
         end
 
         it "should only return layouts for site" do
@@ -113,7 +120,7 @@ module Alchemy
         end
       end
 
-      context "when page_layout description does not contain the elements key" do
+      context "when page_layout definition does not contain the elements key" do
         it "should return an empty array" do
           allow(PageLayout).to receive(:get).with('layout_without_elements_key').and_return({'name' => 'layout_without_elements_key'})
           expect(PageLayout.element_names_for('layout_without_elements_key')).to eq([])
@@ -132,13 +139,12 @@ module Alchemy
       end
 
       context "with translation present" do
-        before { expect(I18n).to receive(:t).and_return('Kontakt') }
+        before { expect(Alchemy).to receive(:t).and_return('Kontakt') }
 
         it "returns the translated name" do
           is_expected.to eq('Kontakt')
         end
       end
     end
-
   end
 end

data/spec/libraries/paths_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+module Alchemy
+  describe 'Paths' do
+    describe 'defaults' do
+      it 'has default value for Alchemy.admin_path' do
+        expect(Alchemy.admin_path).to eq('/admin')
+      end
+
+      it 'has default value for Alchemy.admin_constraints' do
+        expect(Alchemy.admin_constraints).to eq({})
+      end
+    end
+  end
+end

data/spec/libraries/permissions_spec.rb

@@ -9,12 +9,12 @@ describe Alchemy::Permissions do
   let(:restricted_attachment)   { mock_model(Alchemy::Attachment, restricted?: true) }
   let(:picture)                 { mock_model(Alchemy::Picture, restricted?: false) }
   let(:restricted_picture)      { mock_model(Alchemy::Picture, restricted?: true) }
-  let(:public_page)             { build_stubbed(:public_page, restricted: false) }
-  let(:unpublic_page)           { build_stubbed(:page, public: false) }
-  let(:visible_page)            { build_stubbed(:page, restricted: false, visible: true) }
-  let(:not_visible_page)        { build_stubbed(:public_page, restricted: false, visible: false) }
-  let(:restricted_page)         { build_stubbed(:public_page, public: true, restricted: true) }
-  let(:visible_restricted_page) { build_stubbed(:page, visible: true, restricted: true) }
+  let(:public_page)             { build_stubbed(:alchemy_page, :public, restricted: false) }
+  let(:unpublic_page)           { build_stubbed(:alchemy_page, public: false) }
+  let(:visible_page)            { build_stubbed(:alchemy_page, restricted: false, visible: true) }
+  let(:not_visible_page)        { build_stubbed(:alchemy_page, :public, restricted: false, visible: false) }
+  let(:restricted_page)         { build_stubbed(:alchemy_page, :public, public: true, restricted: true) }
+  let(:visible_restricted_page) { build_stubbed(:alchemy_page, visible: true, restricted: true) }
   let(:published_element)       { mock_model(Alchemy::Element, restricted?: false, public?: true, trashed?: false) }
   let(:restricted_element)      { mock_model(Alchemy::Element, restricted?: true, public?: true, trashed?: false) }
   let(:published_content)       { mock_model(Alchemy::Content, restricted?: false, public?: true, trashed?: false) }
@@ -165,7 +165,6 @@ describe Alchemy::Permissions do
 
     it "can see all pictures" do
       is_expected.to be_able_to(:read, Alchemy::Picture)
-      is_expected.to be_able_to(:info, Alchemy::Picture)
     end
 
     it "can manage contents" do

data/spec/libraries/resource_spec.rb

@@ -46,7 +46,7 @@ module Alchemy
         double(:column, {name: 'id', type: :integer, array: false}),
         double(:column, {name: 'starts_at', type: :datetime, array: false}),
         double(:column, {name: 'location_id', type: :integer, array: false}),
-        double(:column, {name: 'organizer_id', type: :integer, array: false}),
+        double(:column, {name: 'organizer_id', type: :integer, array: false})
       ]
     end
 
@@ -58,16 +58,6 @@ module Alchemy
     end
 
     describe "#initialize" do
-      it "sets the standard database attributes (rails defaults) to be skipped" do
-        resource = Resource.new("admin/parties")
-        expect(resource.skipped_attributes).to eq(%w(id updated_at created_at creator_id updater_id))
-      end
-
-      it "sets the restricted attributes accessor to an empty array by default" do
-        resource = Resource.new("admin/parties")
-        expect(resource.restricted_attributes).to eq([])
-      end
-
       it "sets an instance variable that holds the controller path" do
         resource = Resource.new("admin/parties")
         expect(resource.instance_variable_get(:@controller_path)).to eq("admin/parties")
@@ -96,10 +86,8 @@ module Alchemy
 
       context "when model has alchemy_resource_relations defined" do
         before do
-          Party.class_eval do
-            def self.alchemy_resource_relations
-              {location: {attr_method: 'name', type: 'string'}}
-            end
+          allow(Party).to receive(:alchemy_resource_relations) do
+            {location: {attr_method: 'name', type: 'string'}}
           end
         end
 
@@ -119,14 +107,6 @@ module Alchemy
             expect { Resource.new("admin/parties") }.to raise_error(MissingActiveRecordAssociation)
           end
         end
-
-        after do
-          Party.class_eval do
-            class << self
-              undef alchemy_resource_relations
-            end
-          end
-        end
       end
     end
 
@@ -190,37 +170,54 @@ module Alchemy
     end
 
     describe "#attributes" do
+      subject { resource.attributes }
+
       it "parses and returns the resource model's attributes from ActiveRecord::ModelSchema" do
-        expect(resource.attributes).to eq([
-          {:name => "name", :type => :string},
-          {:name => "hidden_value", :type => :string},
-          {:name => "description", :type => :string},
-          {:name => "starts_at", :type => :datetime},
-          {:name => "location_id", :type => :integer},
-          {:name => "organizer_id", :type => :integer},
+        expect(subject).to eq([
+          {name: "name", type: :string},
+          {name: "hidden_value", type: :string},
+          {name: "description", type: :string},
+          {name: "starts_at", type: :datetime},
+          {name: "location_id", type: :integer},
+          {name: "organizer_id", type: :integer}
         ])
       end
 
+      it "skips the standard database attributes (rails defaults)" do
+        expect(subject.map { |el| el[:name] }).not_to include(%w(id updated_at created_at creator_id updater_id))
+      end
+
       it "skips attributes returned by skipped_alchemy_resource_attributes" do
-        # attr_accessor, hence skipped_alchemy_resource_attributes= works
-        resource.skipped_attributes = %w(hidden_value)
-        expect(resource.attributes).to include({:name => "id", :type => :integer})
-        expect(resource.attributes).not_to include({:name => "hidden_value", :type => :string})
+        allow(Party).to receive(:skipped_alchemy_resource_attributes) { %w(hidden_value) }
+        expect(subject).to include({name: "id", type: :integer})
+        expect(subject).not_to include({name: "hidden_value", type: :string})
       end
 
       context "when resource_relations are not defined" do
         it "includes the attribute" do
-          expect(resource.attributes.detect { |a| a[:name] == "location_id" }).to eq({:name => "location_id", :type => :integer})
+          expect(subject.detect { |a| a[:name] == "location_id" }).to eq({name: "location_id", type: :integer})
+        end
+      end
+
+      context "with restricted attributes set" do
+        before do
+          allow(Party).to receive(:restricted_alchemy_resource_attributes) do
+            [{name: "name", type: :string}]
+          end
+        end
+
+        it "should include the restricted attributes" do
+          expect(subject).to include(name: "name", type: :string)
         end
       end
     end
 
     context "when `skipped_alchemy_resource_attributes` is defined as class method in the model" do
+      let(:custom_skipped_attributes) { %w(hidden_name) }
+
       before do
-        Party.class_eval do
-          def self.skipped_alchemy_resource_attributes
-            %w(hidden_name)
-          end
+        allow(Party).to receive(:skipped_alchemy_resource_attributes) do
+          custom_skipped_attributes
         end
       end
 
@@ -230,33 +227,16 @@ module Alchemy
           expect(resource.attributes.detect { |a| a[:name] == 'name' }).not_to be_nil
         end
       end
-
-      describe '#skipped_attributes' do
-        it "returns the result of Model.skipped_alchemy_resource_attributes" do
-          custom_skipped_attributes = %w(hidden_name)
-          resource.skipped_attributes = custom_skipped_attributes
-        end
-      end
-
-      after do
-        Party.class_eval do
-          class << self
-            undef skipped_alchemy_resource_attributes
-          end
-        end
-      end
     end
 
     describe "#searchable_attributes" do
       subject { resource.searchable_attributes }
 
-      before { resource.skipped_attributes = [] }
-
       it "returns all attributes of type string" do
         is_expected.to eq([
-          {:name => "name", :type => :string},
-          {:name => "hidden_value", :type => :string},
-          {:name => "description", :type => :string}
+          {name: "name", type: :string},
+          {name: "hidden_value", type: :string},
+          {name: "description", type: :string}
         ])
       end
 
@@ -286,7 +266,11 @@ module Alchemy
         ]
       end
 
-      before  { resource.restricted_attributes = [:synced_at, :remote_record_id] }
+      before do
+        allow(Party).to receive(:restricted_alchemy_resource_attributes) do
+          [:synced_at, :remote_record_id]
+        end
+      end
 
       it "does not contain restricted attributes" do
         is_expected.to eq([{name: "name", type: :string}, {name: "title", type: :string}])
@@ -297,12 +281,10 @@ module Alchemy
       let(:resource) { Resource.new("admin/events") }
 
       before do
-        Event.class_eval do
-          def self.alchemy_resource_relations
-            {
-              :location => {:attr_method => "name", :attr_type => :string}
-            }
-          end
+        allow(Event).to receive(:alchemy_resource_relations) do
+          {
+            location: {attr_method: "name", attr_type: :string}
+          }
         end
       end
 
@@ -345,14 +327,6 @@ module Alchemy
           expect(resource.attributes.detect { |a| a[:name] == "location_id" }[:type]).to eq(:string)
         end
       end
-
-      after do
-        Event.class_eval do
-          class << self
-            undef :alchemy_resource_relations
-          end
-        end
-      end
     end
 
     describe "#engine_name" do
@@ -366,6 +340,5 @@ module Alchemy
         expect(resource.in_engine?).to eq(true)
       end
     end
-
   end
 end