lc_alchemy_cms 3.2.0

data/spec/libraries/resource_spec.rb

@@ -0,0 +1,371 @@
+require 'spec_helper'
+
+class Party
+end
+
+module Namespace1
+  module Namespace2
+    class Party
+    end
+  end
+end
+
+module Namespace
+  class Party
+  end
+end
+
+module PartyEngine
+  module Namespace
+    class Party
+    end
+  end
+end
+
+module Alchemy
+  describe Resource do
+    # Alchemy's standard module definition. Only engine_name is relevant here
+    let(:module_definition) do
+      {
+        "name" => "party_list",
+        "engine_name" => "party_engine",
+        "navigation" => {
+          "name" => "modules.party_list",
+          "controller" => "/admin/parties",
+          "action" => "index",
+          "image" => "/assets/party_list_module.png"
+        }
+      }
+    end
+
+    let(:columns) do
+      [
+        double(:column, {name: 'name', type: :string, array: false}),
+        double(:column, {name: 'hidden_value', type: :string, array: false}),
+        double(:column, {name: 'description', type: :string, array: false}),
+        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}),
+      ]
+    end
+
+    let(:resource) { Resource.new("admin/parties", module_definition) }
+
+    before :each do
+      # stubbing an ActiveRecord::ModelSchema...
+      allow(Party).to receive(:columns).and_return columns
+    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")
+      end
+
+      context "when initialized with a module definition" do
+        it "sets an instance variable that holds the module definition" do
+          expect(resource.instance_variable_get(:@module_definition)).to eq(module_definition)
+        end
+      end
+
+      context "when initialized with a custom model" do
+        it "sets @model to custom model" do
+          CustomParty = Class.new
+          resource = Resource.new("admin/parties", nil, CustomParty)
+          expect(resource.instance_variable_get(:@model)).to eq(CustomParty)
+        end
+      end
+
+      context "when initialized without custom model" do
+        it "guesses the model by the controller_path" do
+          resource = Resource.new("admin/parties", nil, nil)
+          expect(resource.instance_variable_get(:@model)).to eq(Party)
+        end
+      end
+
+      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
+          end
+        end
+
+        context ", but not an ActiveRecord association" do
+          before do
+            allow(Party).to receive(:respond_to?) do |arg|
+              case arg
+              when :reflect_on_all_associations
+                then false
+              when :alchemy_resource_relations
+                then true
+              end
+            end
+          end
+
+          it "should raise error." do
+            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
+
+    describe "#resource_array" do
+      it "splits the controller_path and returns it as array." do
+        resource = Resource.new("namespace1/namespace2/parties")
+        expect(resource.resource_array).to eql(%w(namespace1 namespace2 parties))
+      end
+
+      it "deletes 'admin' if found hence our model isn't in the admin-namespace by convention" do
+        expect(resource.resource_array).to eql(%w(parties))
+      end
+    end
+
+    describe "#model" do
+      it "returns the @model instance variable" do
+        expect(resource.model).to eq(resource.instance_variable_get(:@model))
+      end
+    end
+
+    describe "#resources_name" do
+      it "returns plural name (like parties for model Party)" do
+        expect(resource.resources_name).to eq("parties")
+      end
+    end
+
+    describe "#resource_name" do
+      it "returns the resources name as singular" do
+        expect(resource.resource_name).to eq("party")
+      end
+    end
+
+    describe "#namespaced_resource_name" do
+      it "returns resource_name with namespace (namespace_party for Namespace::Party), i.e. for use in forms" do
+        namespaced_resource = Resource.new("admin/namespace/parties")
+        expect(namespaced_resource.namespaced_resource_name).to eq('namespace_party')
+      end
+
+      it "equals resource_name if resource not namespaced" do
+        namespaced_resource = Resource.new("admin/parties")
+        expect(namespaced_resource.namespaced_resource_name).to eq('party')
+      end
+
+      it "doesn't include the engine's name" do
+        namespaced_resource = Resource.new("admin/party_engine/namespace/parties", module_definition)
+        expect(namespaced_resource.namespaced_resource_name).to eq('namespace_party')
+      end
+    end
+
+    describe "#engine_name" do
+      it "should return the engine name of the module" do
+        resource = Resource.new("admin/party_engine/namespace/parties", module_definition)
+        expect(resource.engine_name).to eq("party_engine")
+      end
+    end
+
+    describe "#namespace_for_scope" do
+      it "returns a scope for use in url_for based path helpers" do
+        expect(resource.namespace_for_scope).to eq(%w(admin))
+      end
+    end
+
+    describe "#attributes" do
+      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},
+        ])
+      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})
+      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})
+        end
+      end
+    end
+
+    context "when `skipped_alchemy_resource_attributes` is defined as class method in the model" do
+      before do
+        Party.class_eval do
+          def self.skipped_alchemy_resource_attributes
+            %w(hidden_name)
+          end
+        end
+      end
+
+      describe '#attributes' do
+        it "does not return the attributes returned by that method" do
+          expect(resource.attributes.detect { |a| a[:name] == 'hidden_name' }).to be_nil
+          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}
+        ])
+      end
+
+      context "with an array attribute" do
+        let(:columns) do
+          [
+            double(:column, {name: 'name', type: :string, array: false}),
+            double(:column, {name: 'languages', type: :string, array: true})
+          ]
+        end
+
+        it "does not include this column" do
+          is_expected.to eq([{name: "name", type: :string}])
+        end
+      end
+    end
+
+    describe "#editable_attributes" do
+      subject { resource.editable_attributes }
+
+      let(:columns) do
+        [
+          double(:column, {name: 'name', type: :string}),
+          double(:column, {name: 'title', type: :string}),
+          double(:column, {name: 'synced_at', type: :datetime}),
+          double(:column, {name: 'remote_record_id', type: :string})
+        ]
+      end
+
+      before  { resource.restricted_attributes = [:synced_at, :remote_record_id] }
+
+      it "does not contain restricted attributes" do
+        is_expected.to eq([{name: "name", type: :string}, {name: "title", type: :string}])
+      end
+    end
+
+    context "when alchemy_resource_relations defined as class method in the model" do
+      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
+        end
+      end
+
+      describe '#resource_relations' do
+        it "should contain model_association from ActiveRecord::Reflections" do
+          relation = resource.resource_relations[:location_id]
+          expect(relation.keys).to include(:model_association)
+          expect(relation[:model_association].class).to be(ActiveRecord::Reflection::BelongsToReflection)
+        end
+
+        it "adds '_id' to relation key" do
+          expect(resource.resource_relations[:location_id]).not_to be_nil
+        end
+
+        it "stores the relation name" do
+          relation = resource.resource_relations[:location_id]
+          expect(relation.keys).to include(:name)
+          expect(relation[:name]).to eq('location')
+        end
+      end
+
+      describe '#model_associations' do
+        it "skip default alchemy model associations" do
+          expect(resource.model_associations.collect(&:name)).not_to include(*resource.class.const_get(:DEFAULT_SKIPPED_ASSOCIATIONS).map(&:to_sym))
+        end
+      end
+
+      describe '#model_association_names' do
+        it 'returns an array of association names' do
+          expect(resource.model_association_names).to eq [:location]
+        end
+      end
+
+      describe '#attributes' do
+        it "contains the attribute of the related model" do
+          expect(resource.attributes.detect { |a| a[:name] == 'location_id' }.keys).to include(:relation)
+        end
+
+        it "contains the related model's column type as type" do
+          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
+      it "should return the engine name of the module" do
+        expect(resource.engine_name).to eq("party_engine")
+      end
+    end
+
+    describe "#in_engine?" do
+      it "should return true if the module is shipped within an engine" do
+        expect(resource.in_engine?).to eq(true)
+      end
+    end
+
+  end
+end

data/spec/libraries/resources_helper_spec.rb

@@ -0,0 +1,144 @@
+require File.dirname(__FILE__) + "/../../lib/alchemy/resource"
+require File.dirname(__FILE__) + "/../../lib/alchemy/resources_helper"
+
+module Namespace
+  class MyResource
+  end
+end
+
+module EngineResource
+end
+
+class ResourcesController
+  include Alchemy::ResourcesHelper
+
+  def resource_handler
+    @resource_handler ||= Alchemy::Resource.new('admin/namespace/my_resources')
+  end
+end
+
+class ResourcesControllerForEngine
+  include Alchemy::ResourcesHelper
+
+  def resource_handler
+    @resource_handler ||= Alchemy::Resource.new('admin/engine_resources', {'engine_name' => 'my_engine'})
+  end
+end
+
+
+describe Alchemy::ResourcesHelper do
+  let(:controller) { ResourcesController.new }
+  let(:resource_item) { double('resource-item') }
+
+  before {
+    allow(controller).to receive(:main_app).and_return 'main_app_proxy'
+    controller.instance_variable_set('@my_resource', resource_item)
+    controller.instance_variable_set('@my_resources', [resource_item])
+  }
+
+  describe "path-helpers" do
+    describe "#resource_url_proxy" do
+      it "returns the current proxy for url-helper-methods" do
+        expect(controller.resource_url_proxy).to eq('main_app_proxy')
+      end
+
+      context "when resource is in engine" do
+        let(:controller_for_engine) { ResourcesControllerForEngine.new }
+        before { allow(controller_for_engine).to receive('my_engine').and_return('my_engine_proxy') }
+
+        it "returns the engine's proxy" do
+          expect(controller_for_engine.resource_url_proxy).to eq('my_engine_proxy')
+        end
+      end
+    end
+
+    describe "#resource_scope" do
+      it "returns an array containing a proxy and namespaces for url_for-based helper-methods" do
+        expect(controller.resource_scope).to eq(%W[main_app_proxy admin])
+      end
+    end
+
+    describe "#resource_path" do
+      it "invokes polymorphic-path with correct scope and object" do
+        my_resource_item = double
+        expect(controller).to receive(:polymorphic_path).with(["main_app_proxy", "admin", my_resource_item], {})
+        controller.resource_path(my_resource_item)
+      end
+
+      it "uses resource_name when no object is given" do
+        expect(controller).to receive(:polymorphic_path).with(["main_app_proxy", "admin", "my_resource"], {})
+        controller.resource_path
+      end
+    end
+
+    describe "#resources_path" do
+      it "invokes polymorphic-path with correct scope and resources_name" do
+        expect(controller).to receive(:polymorphic_path).with(["main_app_proxy", "admin", "my_resources"], {})
+        controller.resources_path
+      end
+    end
+
+    describe "#new_resource_path" do
+      it "invokes new_polymorphic_path with correct scope and resource_name" do
+        expect(controller).to receive(:new_polymorphic_path).with(["main_app_proxy", "admin", "my_resource"], {})
+        controller.new_resource_path
+      end
+    end
+
+    describe "#edit_resource_path" do
+      it "invokes edit_polymorphic_path with correct scope and resource_name" do
+        my_resource_item = double
+        expect(controller).to receive(:edit_polymorphic_path).with(["main_app_proxy", "admin", my_resource_item], {})
+        controller.edit_resource_path(my_resource_item)
+      end
+    end
+  end
+
+  describe "#resource_instance_variable" do
+    it "returns the resource_item" do
+      expect(controller.resource_instance_variable).to eq(resource_item)
+    end
+  end
+
+  describe "#resources_instance_variable" do
+    it "returns a collection of resource_items" do
+      expect(controller.resources_instance_variable).to eq([resource_item])
+    end
+  end
+
+  describe "#resource_window_size" do
+    it "returns overlay size string depending on resource attributes length" do
+      allow(controller).to receive(:resource_handler).and_return double(attributes: double(length: 4))
+      expect(controller.resource_window_size).to eq("420x260")
+    end
+  end
+
+  describe "#render_attribute" do
+    it "should return the value from resource attribute" do
+      allow(resource_item).to receive(:name).and_return('my-name')
+      expect(controller.render_attribute(resource_item, {name: 'name'})).to eq('my-name')
+    end
+
+    context "resource having a relation" do
+      let(:associated_object) { double("location", title: 'Title of related object') }
+      let(:associated_klass) { double("klass", find: associated_object) }
+      let(:relation) {
+        {
+          attr_method: 'title',
+          model_association: OpenStruct.new(klass: associated_klass)
+        }
+      }
+
+      it "should return the value from the related object attribute" do
+        allow(resource_item).to receive(:name).and_return('my-name')
+        expect(controller.render_attribute(resource_item, {name: 'name', relation: relation})).to eq('Title of related object')
+      end
+    end
+  end
+
+  describe "#resource_name" do
+    it "returns resource_handler.resource_name" do
+      expect(controller.resource_name).to eq("my_resource")
+    end
+  end
+end