releaf-core 1.1.21 → 2.1.1

data/spec/lib/releaf/controller_definition_spec.rb

@@ -1,78 +0,0 @@
-require "rails_helper"
-
-describe Releaf::ControllerDefinition do
-  subject{ described_class.new(name: "op", controller: "admin/books") }
-
-  describe ".for" do
-    it "returns definition from applicaiton controller config for given controller name" do
-      allow(Releaf.application.config).to receive(:controllers).and_return("xxx" => "yyy")
-      expect(described_class.for("xxx")).to eq("yyy")
-    end
-  end
-
-  describe "#initialize" do
-    it "assigns `name` option value" do
-      expect(subject.name).to eq("op")
-    end
-
-    it "assigns `controller` option value to `controller_name`" do
-      expect(subject.controller_name).to eq("admin/books")
-    end
-
-    context "when `helper` option value given" do
-      it "assigns `helper` option value postfixed with `_path` to helper accessor" do
-        subject = described_class.new(controller: "admin/books", helper: "some-route")
-        expect(subject.helper).to eq("some-route_path")
-      end
-    end
-
-    context "when no `helper` option value given" do
-      it "does not assign anything to helper accessor" do
-        subject = described_class.new(controller: "admin/books")
-        expect(subject.helper).to be nil
-      end
-    end
-
-    context "when no `name` option value given" do
-      it "takes `controller` option value as `name` value" do
-        subject = described_class.new(controller: "admin/books")
-        expect(subject.name).to eq("admin/books")
-      end
-    end
-
-    context "when string passed instead of Hash" do
-      it "takes string as controller option value" do
-        subject = described_class.new("admin/authors")
-        expect(subject.controller_name).to eq("admin/authors")
-      end
-    end
-  end
-
-  describe "#localized_name" do
-    it "returns localized name" do
-      allow(I18n).to receive(:t).with("op", scope: "admin.controllers").and_return("poiugasd")
-      expect(subject.localized_name).to eq("poiugasd")
-    end
-  end
-
-  describe "#path" do
-    context "when helper exists" do
-      it "returns helper value" do
-        subject.helper = "new_admin_chapter_path"
-        expect(subject.path).to eq("/admin/chapters/new")
-      end
-    end
-
-    context "when helper is not set" do
-      it "returns controller index path" do
-        expect(subject.path).to eq("/admin/books")
-      end
-    end
-  end
-
-  describe "#group?" do
-    it "returns false" do
-      expect(subject.group?).to be false
-    end
-  end
-end

data/spec/lib/releaf/controller_group_definition_spec.rb

@@ -1,33 +0,0 @@
-require "rails_helper"
-
-describe Releaf::ControllerGroupDefinition do
-  subject{ described_class.new(name: "xxx", items: [:a, :b]) }
-
-  before do
-    allow(Releaf::ControllerDefinition).to receive(:new).with(:a).and_return("c_a")
-    allow(Releaf::ControllerDefinition).to receive(:new).with(:b).and_return("c_b")
-  end
-
-  describe "#initialize" do
-    it "assigns `name` option value" do
-      expect(subject.name).to eq("xxx")
-    end
-
-    it "assigns array with initialized `Releaf::ControllerDefinition` items built from `items` option value" do
-      expect(subject.controllers).to eq(["c_a", "c_b"])
-    end
-  end
-
-  describe "#localized_name" do
-    it "returns localized name" do
-      allow(I18n).to receive(:t).with("xxx", scope: "admin.controllers").and_return("poiugasd")
-      expect(subject.localized_name).to eq("poiugasd")
-    end
-  end
-
-  describe "#group?" do
-    it "returns true" do
-      expect(subject.group?).to be true
-    end
-  end
-end

data/spec/lib/releaf/default_searchable_fields_spec.rb

@@ -1,161 +0,0 @@
-require "rails_helper"
-
-describe Releaf::DefaultSearchableFields do
-  # emulate klass::Translations
-  with_model :SearchableObjectTranslations, scope: :all do
-    table do |t|
-      t.string :name
-    end
-  end
-
-  with_model :SearchableObject, scope: :all do
-    table do |t|
-      t.string :email
-      t.string :first_name
-      t.string :forename
-      t.string :last_name
-      t.string :login
-      t.string :middle_name
-      t.string :name
-      t.string :surname
-      t.string :title
-      t.string :username
-      t.string :non_searchable
-      t.string :password
-      t.integer :size
-      t.boolean :bool
-      t.text :text
-    end
-
-    model do
-      # emulate globalize accessors
-      def self.translates?
-        true
-      end
-    end
-  end
-
-  with_model :NonSearchableObject, scope: :all do
-    table do |t|
-      t.integer :email
-      t.integer :first_name
-      t.integer :forename
-      t.integer :last_name
-      t.integer :login
-      t.integer :middle_name
-      t.integer :name
-      t.integer :surname
-      t.integer :title
-      t.integer :username
-    end
-  end
-
-  before(:all) do
-    # emulate globalize accessors
-    SearchableObject.const_set('Translation', SearchableObjectTranslations)
-  end
-
-  subject { described_class.new(SearchableObject) }
-
-  describe "#possible_field_names" do
-    it "returns array of possible field names to search" do
-      expect( subject.possible_field_names ).to match_array %w[
-        email
-        first_name
-        forename
-        last_name
-        login
-        middle_name
-        name
-        surname
-        title
-        username
-      ]
-    end
-  end
-
-  describe "#find" do
-    context "when searchable fields exist" do
-      it "returns array of searchable string columns" do
-        expect( described_class.new(SearchableObject).find ).to match_array %w[
-          email
-          first_name
-          forename
-          last_name
-          login
-          middle_name
-          name
-          surname
-          title
-          username
-        ] + [translations: %w[name]]
-      end
-    end
-
-    context "when searchable fields doesn't exist" do
-      it "returns array of searchable string columns" do
-        expect( described_class.new(NonSearchableObject).find ).to be_blank
-      end
-    end
-  end
-
-  describe "#string_columns" do
-    it "returns string columsn of model" do
-      expect( subject.string_columns ).to match_array %w[
-        email
-        first_name
-        forename
-        last_name
-        login
-        middle_name
-        name
-        surname
-        title
-        username
-        non_searchable
-        password
-      ]
-    end
-  end
-
-  describe "#has_searchable_translated_string_columns?" do
-    context "when #klass isn't translated" do
-      it "returns false" do
-        allow(SearchableObject).to receive(:translates?).and_return(false)
-        expect( subject.has_searchable_translated_string_columns? ).to eq false
-      end
-    end
-
-    context "when #klass is translated and has translated searchable columns" do
-      it "returns true" do
-        expect( subject.has_searchable_translated_string_columns? ).to eq true
-      end
-    end
-
-    context "when #klass is translated but has no translated searchable columns" do
-      it "returns false" do
-        allow( subject ).to receive(:searchable_translated_string_columns).and_return([])
-        expect( subject.has_searchable_translated_string_columns? ).to eq false
-      end
-    end
-
-  end
-
-  describe "#searchable_translated_string_columns" do
-    it "returns translated string columns of klass::Translation" do
-      expect( subject.searchable_translated_string_columns ).to match_array %w[name]
-    end
-
-    it "caches result" do
-      searchable_fields = double(described_class)
-      expect( searchable_fields ).to receive(:find).once.and_return []
-
-      subject # init subject
-
-      allow( described_class ).to receive(:new).with(SearchableObject::Translation).and_return(searchable_fields)
-
-      subject.searchable_translated_string_columns
-      subject.searchable_translated_string_columns
-    end
-  end
-end

data/spec/lib/releaf/instance_cache_spec.rb

@@ -1,98 +0,0 @@
-require "rails_helper"
-
-describe Releaf::InstanceCache, type: :class do
-  class InstanceCacheIncluder
-    include Releaf::InstanceCache
-    cache_instance_methods :some_value, :another_value
-    cache_instance_method :one_more_another_value
-
-    def calculated_value
-      instance_cache(:calculated_value) do
-        some_value
-      end
-    end
-
-    def some_value
-      1 + 2
-    end
-
-    def another_value
-      "xx"
-    end
-
-    def one_more_another_value
-      "yy"
-    end
-  end
-
-  subject{ InstanceCacheIncluder.new }
-
-  it "keeps previously defined `method_added` method" do
-    class InstanceCacheIncluder2
-      cattr_accessor :test_value
-
-      def self.method_added(method_name)
-        self.test_value = method_name if method_name == :some_value
-      end
-      include Releaf::InstanceCache
-      cache_instance_method :some_value
-
-      def some_value
-        :xx
-      end
-    end
-
-    subject = InstanceCacheIncluder2.new
-    expect(InstanceCacheIncluder2.test_value).to eq(:some_value)
-    allow(subject).to receive(:instance_cache_original_some_value).and_return(:yyy).once
-    expect(subject.some_value).to eq(:yyy)
-    subject.some_value
-  end
-
-  describe ".instance_cache_original_method_name" do
-    it "returns name of uncached original method name" do
-      expect(subject.class.instance_cache_original_method_name(:some_method)).to eq("instance_cache_original_some_method")
-    end
-  end
-
-  describe "#instance_cache" do
-    it "stores block value to instance cache store" do
-      expect{ subject.calculated_value }.to change{ subject.instance_cache_store[:calculated_value] }.to(3)
-    end
-
-    it "returns returns value when caching happen" do
-      expect(subject.calculated_value).to eq(3)
-    end
-
-    it "returns cached value when called second time" do
-      subject.calculated_value
-      expect(subject.calculated_value).to eq(3)
-    end
-
-    it "does not evaluate block twice when called second time" do
-      expect(subject).to receive(:some_value).and_call_original.once
-      subject.calculated_value
-      subject.calculated_value
-    end
-  end
-
-  describe "#reset_instance_cache" do
-    it "assigns empty hash to instance hash store" do
-      subject.instance_cache_store[:x] = 1
-      expect{ subject.reset_instance_cache }.to change{ subject.instance_cache_store }.from(x: 1).to({})
-    end
-  end
-
-  describe ".cache_instance_methods" do
-    it "adds cache wrapper for all given methods" do
-      expect(subject.class.cached_instance_methods).to eq([:some_value, :another_value, :one_more_another_value])
-
-      allow(subject).to receive(:instance_cache_original_another_value).and_return("xxx").once
-      expect(subject).to receive(:instance_cache) do|x, &block|
-        expect(block.call).to eq("xxx")
-      end.and_return("yyy")
-
-      expect(subject.another_value).to eq("yyy")
-    end
-  end
-end

data/spec/lib/releaf/resource_base_spec.rb

@@ -1,212 +0,0 @@
-require "rails_helper"
-
-describe Releaf::ResourceBase do
-  subject{ described_class.new(Book) }
-
-  describe "#initialize" do
-    it "assigns given class to resource class accessor" do
-      expect(subject.resource_class).to eq(Book)
-    end
-  end
-
-  describe "#excluded_attributes" do
-    it "returns array with id, created_at and updated_as" do
-      expect(subject.excluded_attributes).to eq(["id", "created_at", "updated_at"])
-    end
-  end
-
-  describe "#localized_attributes?" do
-    context "when resource class has globalize support" do
-      it "returns true" do
-        expect(subject.localized_attributes?).to be true
-      end
-    end
-
-    context "when resource class does not have globalize support" do
-      it "returns false" do
-        allow(subject.resource_class).to receive(:translates?).and_return(false)
-        expect(subject.localized_attributes?).to be false
-      end
-    end
-  end
-
-  describe "#localized_attributes" do
-    before do
-      allow(subject.resource_class).to receive(:translated_attribute_names).and_return([:title, :summary])
-    end
-
-    it "caches returned result" do
-      expect(subject).to receive(:localized_attributes?).and_return(true).once
-      subject.localized_attributes
-      subject.localized_attributes
-    end
-
-    context "when resource has localized attributes" do
-      it "returns array of all localized attributes params" do
-        allow(subject).to receive(:localized_attributes?).and_return(true)
-        expect(subject.localized_attributes).to eq(["title", "summary"])
-      end
-    end
-
-    context "when resource has no localized attributes" do
-      it "returns empty array" do
-        allow(subject).to receive(:localized_attributes?).and_return(false)
-        expect(subject.localized_attributes).to eq([])
-      end
-    end
-  end
-
-  describe "#associations_attributes" do
-    it "returns array with associations attributes within hashes" do
-      association_1 = subject.resource_class.reflections["chapters"]
-      association_2 = subject.resource_class.reflections["sequels"]
-
-      allow(subject).to receive(:associations).and_return([association_1, association_2])
-      allow(subject).to receive(:association_attributes).with(association_1).and_return(["a", "b"])
-      allow(subject).to receive(:association_attributes).with(association_2).and_return(["c", "d"])
-
-      expect(subject.associations_attributes).to eq([{chapters: ["a", "b"]}, {sequels: ["c", "d"]}])
-    end
-  end
-
-  describe "#association_attributes" do
-    it "returns association params without association excluded attributes" do
-      association = subject.resource_class.reflections["chapters"]
-      allow(described_class).to receive(:new).with(association.klass).and_call_original
-      allow_any_instance_of(described_class).to receive(:values).and_return(["a", "b", "c"])
-      allow(subject).to receive(:association_excluded_attributes).and_return(["b"])
-      expect(subject.association_attributes(association)).to eq(["a", "c"])
-    end
-  end
-
-  describe "#association_excluded_attributes" do
-    it "returns `foreign_key` and polymorphic association type key (if exists) casted to strings" do
-      association = subject.resource_class.reflections["chapters"]
-      allow(association).to receive(:foreign_key).and_return(:b)
-      expect(subject.association_excluded_attributes(association)).to eq(["b"])
-
-      allow(association).to receive(:type).and_return("x")
-      expect(subject.association_excluded_attributes(association)).to eq(["b", "x"])
-    end
-  end
-
-  describe "#values" do
-    before do
-      allow(subject).to receive(:associations_attributes).and_return(["x", "y"])
-      allow(subject).to receive(:base_attributes).and_return(["a", "b"])
-      allow(subject).to receive(:localized_attributes).and_return(["c", "d"])
-    end
-
-    it "returns resource base and localized attributes array alongside associations params" do
-      expect(subject.values).to eq(["a", "b", "c", "d", "x", "y"])
-    end
-
-    it "excludes all excludable base and localized attributes from returned array" do
-      allow(subject).to receive(:excluded_attributes).and_return(["a", "d", "x"])
-      expect(subject.values).to eq(["b", "c", "x", "y"])
-    end
-
-    context "when `include_associations` is false" do
-      it "does not include association params" do
-        expect(subject.values(include_associations: false)).to eq(["a", "b", "c", "d"])
-      end
-    end
-  end
-
-  describe "#base_attributes" do
-    it "returns array of resource columns" do
-      allow(subject.resource_class).to receive(:column_names).and_return(["a", "b", "c"])
-      expect(subject.base_attributes).to eq(["a", "b", "c"])
-    end
-  end
-
-  describe "#associations" do
-    it "returns array with includable associations" do
-      reflections = subject.resource_class.reflections
-      allow(subject).to receive(:includable_association?).with(reflections["releaf_richtext_attachments"]).and_return(false)
-      allow(subject).to receive(:includable_association?).with(reflections["chapters"]).and_return(true)
-      allow(subject).to receive(:includable_association?).with(reflections["book_sequels"]).and_return(false)
-      allow(subject).to receive(:includable_association?).with(reflections["sequels"]).and_return(true)
-      allow(subject).to receive(:includable_association?).with(reflections["author"]).and_return(false)
-      allow(subject).to receive(:includable_association?).with(reflections["translations"]).and_return(false)
-
-      expect(subject.associations).to eq([reflections["chapters"], reflections["sequels"]])
-    end
-  end
-
-  describe "#includable_association?" do
-    let(:association){ subject.resource_class.reflections["chapters"] }
-
-    context "when given association type is includable, association is not excluded, not `ThroughReflection` and has nested_attributes for it" do
-      it "returns true" do
-        expect(subject.includable_association?(association)).to be true
-      end
-    end
-
-    context "when given association is not :has_many" do
-      it "returns false" do
-        allow(subject).to receive(:includable_association_types).and_return([:a, :b])
-        expect(subject.includable_association?(association)).to be false
-      end
-    end
-
-    context "when given association is `ThroughReflection`" do
-      it "returns false" do
-        allow(association).to receive(:class).and_return(ActiveRecord::Reflection::ThroughReflection)
-        expect(subject.includable_association?(association)).to be false
-      end
-    end
-
-    context "when given association has no nested_attributes for it" do
-      it "returns false" do
-        allow(subject.resource_class).to receive(:nested_attributes_options).and_return({})
-        expect(subject.includable_association?(association)).to be false
-      end
-    end
-
-    context "when given association is within excluded associations" do
-      it "returns false" do
-        allow(subject).to receive(:excluded_associations).and_return([:chapters])
-        expect(subject.includable_association?(association)).to be false
-      end
-    end
-  end
-
-  describe "#includable_association_types" do
-    it "returns array with `:has_many` and `:has_one` as includable association types" do
-      expect(subject.includable_association_types).to eq([:has_many, :has_one])
-    end
-  end
-
-  describe "#excluded_associations" do
-    it "returns array with `translations`" do
-      expect(subject.excluded_associations).to eq([:translations])
-    end
-  end
-
-  describe ".title" do
-    let(:resource){ Releaf::Permissions::User.new(name: "a", surname: "b") }
-    it "tries all `title_methods` methods and returns first existing method result" do
-      allow(described_class).to receive(:title_methods).and_return([:to_s, :id, :releaf_title])
-      allow(resource).to receive(:to_s).and_return("x")
-      allow(resource).to receive(:id).and_return("zz")
-      allow(resource).to receive(:releaf_title).and_return("yy")
-
-      allow(resource).to receive(:respond_to?).with(:to_s).and_return(false)
-      allow(resource).to receive(:respond_to?).with(:id).and_return(false)
-      allow(resource).to receive(:respond_to?).with(:releaf_title).and_return(true)
-      expect(described_class.title(resource)).to eq("yy")
-
-      allow(resource).to receive(:respond_to?).with(:to_s).and_return(false)
-      allow(resource).to receive(:respond_to?).with(:id).and_return(true)
-      expect(resource).to_not receive(:respond_to?).with(:releaf_title)
-      expect(described_class.title(resource)).to eq("zz")
-    end
-  end
-
-  describe ".title_methods" do
-    it "returns array of methods for trying cast resource to text" do
-      expect(described_class.title_methods).to eq([:releaf_title, :name, :title, :to_s])
-    end
-  end
-end