releaf-core 0.2.1 → 1.0.3

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

@@ -1,230 +0,0 @@
-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/error_formatter_spec.rb

@@ -1,242 +0,0 @@
-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

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

@@ -1,18 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Core::ResourceTableFields do
-  subject{ described_class.new(Book) }
-
-  describe "#excluded_attributes" do
-    it "returns attributes to exclude from table alongside parent method list" do
-      allow(subject).to receive(:table_excluded_attributes).and_return(%w(xxx yyy))
-      expect(subject.excluded_attributes).to include("id", "created_at", "xxx", "yyy")
-    end
-  end
-
-  describe "#table_excluded_attributes" do
-    it "returns array with attributes matching *_html pattern" do
-      expect(subject.table_excluded_attributes).to eq(%w(summary_html))
-    end
-  end
-end