releaf-core 0.2.1

data/spec/lib/releaf/core/configuration_spec.rb

@@ -0,0 +1,230 @@
+require "rails_helper"
+
+describe Releaf::Core::Configuration do
+  describe "#configure" do
+    it "calls all initializators" do
+      expect(subject).to receive(:initialize_defaults).ordered
+      expect(subject).to receive(:initialize_locales).ordered
+      expect(subject).to receive(:initialize_controllers).ordered
+      expect(subject).to receive(:initialize_components).ordered
+      subject.configure
+    end
+  end
+
+  describe "#assets_resolver" do
+    it "returns assets resolver class" do
+      allow(subject).to receive(:assets_resolver_class_name).and_return("Book")
+      expect(subject.assets_resolver).to eq(Book)
+    end
+  end
+
+  describe "#access_control_module" do
+    it "returns access control module class" do
+      allow(subject).to receive(:access_control_module_name).and_return("Book")
+      expect(subject.access_control_module).to eq(Book)
+    end
+  end
+
+  describe "#initialize_defaults" do
+    it "ovewrites only nil values with default ones" do
+      allow(subject).to receive(:default_values).and_return(menu: "aa", components: "lk")
+      subject.menu = "x"
+      subject.components = nil
+      expect{ subject.initialize_defaults }.to change{ [subject.menu, subject.components] }.to(["x", "lk"])
+    end
+  end
+
+  describe "#initialize_locales" do
+    before do
+      subject.available_locales = [:a, :b]
+      subject.available_admin_locales = [:b, :c]
+      allow(::I18n).to receive(:available_locales=)
+    end
+
+    it "assigns available locales to `I18n.available_locales`" do
+      expect(::I18n).to receive(:available_locales=).with([:a, :b])
+      subject.initialize_locales
+    end
+
+    context "when no `available_admin_locales` defined" do
+      it "overwrites it with available locales" do
+        expect{ subject.initialize_locales }.to_not change{ subject.available_admin_locales }
+
+        subject.available_admin_locales = nil
+        expect{ subject.initialize_locales }.to change{ subject.available_admin_locales }.to eq([:a, :b])
+      end
+    end
+
+    it "merges unique locales form admin and available locales, casts it to strings and assign to `all_locales`" do
+      expect{ subject.initialize_locales }.to change{ subject.all_locales }.to eq(["a", "b", "c"])
+    end
+  end
+
+  describe "#initialize_components" do
+    before do
+      class DummyComponentA; end
+      class DummyComponentB
+        def self.initialize_component; end
+      end
+      allow(subject).to receive(:flatten_components).with(["x", "s"])
+        .and_return([DummyComponentA, DummyComponentB])
+      subject.components = ["x", "s"]
+    end
+
+    it "reassign normalized components" do
+      expect{ subject.initialize_components }.to change{ subject.components }.to([DummyComponentA, DummyComponentB])
+    end
+
+    it "calls component initializing method if available" do
+      expect(DummyComponentB).to receive(:initialize_component)
+      subject.initialize_components
+    end
+  end
+
+  describe "#flatten_components" do
+    it "returns recursively flattened component list" do
+      class DummyComponentA; end
+      class DummyComponentB
+        def self.components
+          ["o", "p"]
+        end
+      end
+
+      allow(subject).to receive(:flatten_components).and_call_original
+      allow(subject).to receive(:flatten_components).with(["o", "p"]).and_return(["x", "y"])
+      expect(subject.flatten_components([DummyComponentA, DummyComponentB])).to eq([DummyComponentA, "x", "y", DummyComponentB])
+    end
+  end
+
+  describe "#initialize_controllers" do
+    before do
+      subject.menu = ["a"]
+      subject.additional_controllers = ["b"]
+      allow(subject).to receive(:normalize_controllers).with(["a"]).and_return(["aa"])
+      allow(subject).to receive(:normalize_controllers).with(["b"]).and_return(["bb"])
+      allow(subject).to receive(:extract_controllers).with(["aa", "bb"]).and_return({"c" => "d"})
+    end
+
+    it "normalizes menu" do
+      expect{ subject.initialize_controllers }.to change{ subject.menu }.from(["a"]).to(["aa"])
+    end
+
+    it "normalizes additional controllers" do
+      expect{ subject.initialize_controllers }.to change{ subject.additional_controllers }.from(["b"]).to(["bb"])
+    end
+
+    it "extract controller items from menu and additional controllers and assign then to controllers" do
+      expect{ subject.initialize_controllers }.to change{ subject.controllers }.from(nil).to("c" => "d")
+    end
+
+    it "extract controller names and assign to available controllers" do
+      expect{ subject.initialize_controllers }.to change{ subject.available_controllers }.from(nil).to(["c"])
+    end
+  end
+
+  describe "#extract_controllers" do
+    it "returns recursively built hash with controllers from given array" do
+      list = [{controller: "a"}, {items: [{controller: "b"}, {controller: "c"}, {xx: "x"}]}, {controller: "d"}, {asd: "xx"}]
+      result = {"a"=>{controller: "a"}, "b"=>{controller: "b"}, "c"=>{controller: "c"}, "d" => {controller: "d"}}
+      expect(subject.extract_controllers(list)).to eq(result)
+    end
+  end
+
+  describe "#normalize_controllers" do
+    it "returns list of normalized controllers" do
+      allow(subject).to receive(:normalize_controller_item).with(:a).and_return("ab")
+      allow(subject).to receive(:normalize_controller_item).with(:b).and_return("bc")
+      expect(subject.normalize_controllers([:a, :b])).to eq(["ab", "bc"])
+    end
+  end
+
+  describe "#normalize_controller_item" do
+    describe ":controller" do
+      context "when given value is instance of `String`" do
+        it "use value as controller name" do
+          expect(subject.normalize_controller_item("a")[:controller]).to eq("a")
+        end
+      end
+
+      context "when given value is hash" do
+        it "does not add controller value" do
+          expect(subject.normalize_controller_item(a: "x")[:controller]).to be nil
+        end
+
+        it "does not modify controller value" do
+          expect(subject.normalize_controller_item(controller: "x")[:controller]).to eq("x")
+        end
+      end
+    end
+
+    describe ":name" do
+      context "when controller hash does not have name value" do
+        it "assigns controller value as name" do
+          expect(subject.normalize_controller_item(controller: "x")[:name]).to eq("x")
+        end
+      end
+
+      context "when controller hash has name value" do
+        it "does not change existing name value" do
+          expect(subject.normalize_controller_item(controller: "x", name: "b")[:name]).to eq("b")
+        end
+      end
+    end
+
+    describe ":url_helper" do
+      context "when controller hash does not have neither helper or controller values" do
+        it "does not add url helper value" do
+          expect(subject.normalize_controller_item(x: "x")[:url_helper]).to be nil
+        end
+      end
+
+      context "when controller hash has helper value" do
+        it "assigns symbolized helper value" do
+          expect(subject.normalize_controller_item(controller: "x", helper: "b")[:url_helper]).to eq(:b)
+        end
+      end
+
+      context "when controller hash has controller value" do
+        it "assigns convert controller name to url helper" do
+          expect(subject.normalize_controller_item(controller: "a/b")[:url_helper]).to eq(:a_b)
+        end
+      end
+    end
+
+    describe ":items" do
+      before do
+        allow(subject).to receive(:normalize_controllers).with(["a", "b"]).and_return(["c", "d"])
+      end
+
+      context "when controller hash does not have items value" do
+        it "does not add items value" do
+          expect(subject.normalize_controller_item(x: "x")[:items]).to be nil
+        end
+      end
+
+      context "when controller hash has items value" do
+        it "does normalizes items" do
+          expect(subject.normalize_controller_item(x: "x", items: ["a", "b"])[:items]).to eq(["c", "d"])
+        end
+      end
+    end
+  end
+
+  describe "#default_values" do
+    it "returns default configuration key, value hash" do
+      result = {
+        menu: [],
+        devise_for: 'releaf/permissions/user',
+        additional_controllers: [],
+        controllers: {},
+        components: [],
+        assets_resolver_class_name:  'Releaf::Core::AssetsResolver',
+        layout_builder_class_name: 'Releaf::Builders::Page::LayoutBuilder',
+        access_control_module_name: 'Releaf::Permissions'
+      }
+      expect(subject.default_values).to eq(result)
+    end
+  end
+end
+
+

data/spec/lib/releaf/core/default_searchable_fields_spec.rb

@@ -0,0 +1,161 @@
+require "rails_helper"
+
+describe Releaf::Core::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/core/error_formatter_spec.rb

@@ -0,0 +1,242 @@
+require 'rails_helper'
+
+describe Releaf::Core::ErrorFormatter do
+
+  class DummyResourceValidatorAuthor < Author
+    self.table_name = 'authors'
+    has_many :books, inverse_of: :author, class_name: :DummyResourceValidatorBook, foreign_key: :author_id
+  end
+
+  class DummyResourceValidatorBook < Book
+    self.table_name = 'books'
+    belongs_to :author, inverse_of: :books, class_name: :DummyResourceValidatorAuthor
+
+    validates_presence_of :author
+    validate :base_validation
+    accepts_nested_attributes_for :author
+
+    attr_accessor :add_error_on_base
+
+    def base_validation
+      return unless add_error_on_base
+      self.errors.add(:base, 'error on base')
+    end
+  end
+
+  let(:book) {
+    b = Book.new
+    b.valid?
+    b
+  }
+
+  subject do
+    described_class.new(book, 'resource')
+  end
+
+  describe "#errors" do
+    it "is a hash" do
+      allow_any_instance_of(described_class).to receive(:format_errors)
+      expect( subject.errors ).to be_an_instance_of Hash
+    end
+  end
+
+  describe "#format_errors" do
+    let(:book) {
+      b = DummyResourceValidatorBook.new
+      b.valid?
+      b
+    }
+
+    def blank_error(attribute, class_name='DummyResourceValidatorBook', id='null')
+      {
+        error_code: :blank,
+        message: "Blank",
+        full_message: "#{class_name} with id #{id} has error \"Blank\" on attribute \"#{attribute}\""
+      }
+    end
+
+    it "is called after initialization" do
+      expect_any_instance_of( described_class ).to receive(:format_errors)
+      described_class.new(Book.new, 'resource')
+    end
+
+    it "doesn't validates resource" do
+      expect( book ).to_not receive(:valid?)
+      expect( book ).to_not receive(:invalid?)
+      subject
+    end
+
+    it "correctly adds errors for fields resource fields" do
+      expect( subject.errors["resource[title]"] ).to eq [blank_error('title')]
+    end
+
+    it "correclty adds errors for missing associated object (belongs_to)" do
+      expect( subject.errors["resource[author_id]"] ).to eq [blank_error('author')]
+    end
+
+    it "correctly adds error for missing associated object attributes (belongs_to)" do
+      book.build_author
+      book.valid?
+      expect( subject.errors["resource[author_attributes][name]"] ).to eq [blank_error('name', 'DummyResourceValidatorAuthor')]
+    end
+
+    it "correctly adds error for missing associated object attributes (has_many)" do
+      book.chapters.new(id: 12)
+      book.chapters.new(:title => 'test')
+      book.valid?
+      expect( subject.errors["resource[chapters_attributes][0][title]"] ).to eq [blank_error('title', 'Chapter', '12')]
+      expect( subject.errors["resource[chapters_attributes][1][title]"] ).to be_nil
+
+      expect( subject.errors["resource[chapters_attributes][0][text]"] ).to eq [blank_error('text', 'Chapter', '12')]
+      expect( subject.errors["resource[chapters_attributes][1][text]"] ).to eq [blank_error('text', 'Chapter')]
+    end
+
+    it "handles errors on base" do
+      book.add_error_on_base = true
+      book.valid?
+      expect( subject.errors["resource"] ).to eq [{
+        error_code: :invalid,
+        message: "Error on base",
+        full_message: 'DummyResourceValidatorBook with id null has error "error on base"'
+      }]
+    end
+  end
+
+  describe "#association" do
+    it "returns active record reflection of association" do
+      expect( subject.send(:association, 'author') ).to eq Book.reflect_on_association(:author)
+    end
+  end
+
+  describe "#association_type" do
+    it "returns active record reflection macro" do
+      expect( subject.send(:association_type, 'author') ).to eq :belongs_to
+    end
+  end
+
+  describe "#single_association?" do
+    context "for :belongs_to association" do
+      it "returns true" do
+        expect( subject.send(:single_association?, 'author') ).to be true
+      end
+    end
+
+    context "for :has_many association" do
+      it "returns false" do
+        expect( subject.send(:single_association?, 'chapters') ).to be false
+      end
+    end
+
+    context "for :has_one association" do
+      it "returns true" do
+        allow(subject).to receive(:association_type).with('author').and_return(:has_one)
+        expect( subject.send(:single_association?, 'author') ).to be true
+      end
+    end
+  end
+
+  describe "#models_attribute?" do
+    context "when attribute name contains dot" do
+      it "returns false" do
+        expect( subject.send(:models_attribute?, 'test.attribute') ).to be false
+      end
+    end
+
+    context "when attribute name doesn't contain dot" do
+      it "returns true" do
+        expect( subject.send(:models_attribute?, 'test') ).to be true
+      end
+    end
+  end
+
+  describe "#field_id" do
+    context "when error is on base" do
+      it "returns resource field_id" do
+        expect( subject.send(:field_id, 'base') ).to eq 'resource'
+      end
+    end
+
+    context "when attribute is association" do
+      it "returns field_id for associations foreign key" do
+        expect( subject.send(:field_id, 'author') ).to eq 'resource[author_id]'
+      end
+    end
+
+    context "when attribute is not association" do
+      it "returns field_id for field" do
+        expect( subject.send(:field_id, 'title') ).to eq 'resource[title]'
+      end
+    end
+  end
+
+  describe "#add_error" do
+    before do
+      # prevent formatting errors when class is initialized
+      allow_any_instance_of(described_class).to receive(:format_errors)
+    end
+
+    it "adds error to errors" do
+      expected_result = {
+        'resource[title]' => [
+          {
+            error_code: 'test error',
+            message: 'Error message',
+            full_message: 'Book with id null has error "error message" on attribute "title"'
+          },
+          {
+            error_code: 'test error',
+            message: 'Jet another error message',
+            full_message: 'Book with id null has error "jet another error message" on attribute "title"'
+          }
+        ],
+        'resource[author_id]' => [
+          {
+            error_code: 'invalid',
+            message: 'Invalid author',
+            full_message: 'Book with id null has error "invalid author" on attribute "author"',
+            data: {foo: :bar}
+          }
+        ]
+      }
+
+      message = ActiveModel::ErrorMessage.new("error message")
+      allow(message).to receive(:error_code).and_return('test error')
+      allow(message).to receive(:data).and_return(nil)
+
+      other_message = ActiveModel::ErrorMessage.new("invalid author")
+      allow(other_message).to receive(:error_code).and_return('invalid')
+      allow(other_message).to receive(:data).and_return({foo: :bar})
+
+      jet_another_message = ActiveModel::ErrorMessage.new("jet another error message")
+      allow(jet_another_message).to receive(:error_code).and_return('test error')
+      allow(jet_another_message).to receive(:data).and_return(nil)
+
+      expect do
+        subject.send(:add_error, 'title', message)
+        subject.send(:add_error, 'author', other_message)
+        subject.send(:add_error, 'title', jet_another_message)
+      end.to change { subject.errors }.from({}).to(expected_result)
+    end
+
+    it "localizes error messages" do
+      message = ActiveModel::ErrorMessage.new("error message")
+      allow(message).to receive(:error_code).and_return('test error')
+      allow(message).to receive(:data).and_return(nil)
+
+      expect( I18n ).to receive(:t).with(message, scope: "activerecord.errors.messages.book").and_call_original
+
+      template = "%{class} with id %{id} has error \"error message\" on attribute \"%{attribute}\""
+      expect( I18n ).to receive(:t).with(template, {
+        default: template,
+        attribute: 'title',
+        class: 'Book',
+        id: 'null',
+        scope: "activerecord.errors.messages.book"
+      }).and_call_original
+
+      subject.send(:add_error, 'title', message)
+    end
+  end
+
+
+end