alchemy_cms 3.3.0.rc1 → 3.3.0.rc2

data/spec/libraries/resource_spec.rb

@@ -1,344 +0,0 @@
-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 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
-          allow(Party).to receive(:alchemy_resource_relations) do
-            {location: {attr_method: 'name', type: 'string'}}
-          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
-      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
-      subject { resource.attributes }
-
-      it "parses and returns the resource model's attributes from ActiveRecord::ModelSchema" do
-        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
-        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(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
-        allow(Party).to receive(:skipped_alchemy_resource_attributes) do
-          custom_skipped_attributes
-        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
-    end
-
-    describe "#searchable_attributes" do
-      subject { resource.searchable_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 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}])
-      end
-    end
-
-    context "when alchemy_resource_relations defined as class method in the model" do
-      let(:resource) { Resource.new("admin/events") }
-
-      before do
-        allow(Event).to receive(:alchemy_resource_relations) do
-          {
-            location: {attr_method: "name", attr_type: :string}
-          }
-        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
-    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

@@ -1,193 +0,0 @@
-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
-    subject { controller.render_attribute(resource_item, attributes, options) }
-
-    let(:options) { {} }
-    let(:attributes) { {name: 'name'} }
-
-    it "should return the value from resource attribute" do
-      allow(resource_item).to receive(:name).and_return('my-name')
-      is_expected.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) do
-        {
-          attr_method: 'title',
-          model_association: OpenStruct.new(klass: associated_klass)
-        }
-      end
-      let(:attributes) do
-        {name: 'name', relation: relation}
-      end
-
-      it "should return the value from the related object attribute" do
-        allow(resource_item).to receive(:name).and_return('my-name')
-        is_expected.to eq('Title of related object')
-      end
-    end
-
-    context 'with long values' do
-      before do
-        allow(resource_item).to receive(:name).and_return('*' * 51)
-      end
-
-      it 'truncates the values' do
-        expect(subject.length).to eq(50)
-      end
-
-      context 'but with options[:truncate] set to 10' do
-        let(:options) { {truncate: 10} }
-
-        it 'does not truncate the values' do
-          expect(subject.length).to eq(10)
-        end
-      end
-
-      context 'but with options[:truncate] set to false' do
-        let(:options) { {truncate: false} }
-
-        it 'does not truncate the values' do
-          expect(subject.length).to eq(51)
-        end
-      end
-    end
-  end
-
-  describe "#resource_name" do
-    it "returns resource_handler.resource_name" do
-      expect(controller.resource_name).to eq("my_resource")
-    end
-  end
-
-  describe '#current_location_params' do
-    let(:params) { {q: "some_query", page: 6, action: "some_action"} }
-
-    before do
-      allow(controller).to receive(:params) { params }
-    end
-
-    it 'returns the current location params' do
-      expect(controller.current_location_params).to eq({q: "some_query", page: 6})
-    end
-
-    it 'only includes the q and page parameters' do
-      expect(controller.current_location_params).not_to have_key(:action)
-    end
-  end
-end