releaf-core 0.2.1 → 1.0.3

data/spec/controllers/releaf/{base_controller_spec.rb → action_controller_spec.rb}

@@ -1,14 +1,22 @@
 require 'rails_helper'
 
-describe Releaf::BaseController do
+describe Releaf::ActionController do
   let(:new_resource){ Author.new }
   let(:resource){ create(:author) }
   let(:subject){ DummyController.new }
-  class DummyController < Releaf::BaseController
+
+  module DummyControllerModule; end;
+
+  class DummyController < Releaf::ActionController
+    include DummyControllerModule
     def resource_class
       Author
     end
   end
+
+  class Dummy::ChildDummyController < DummyController; end;
+  class Dummy::GrandChildDummyController < Dummy::ChildDummyController; end;
+
   class FooFormBuilder; end
 
   describe "#action_views"  do
@@ -22,33 +30,6 @@ describe Releaf::BaseController do
     end
   end
 
-  describe "#action_features" do
-    before do
-      subject.setup
-    end
-
-    it "returns action > feature mapped hash" do
-      expect(subject.action_features).to eq({
-        index: :index,
-        new: :create,
-        create: :create,
-        show: :edit,
-        edit: :edit,
-        update: :edit,
-        confirm_destroy: :destroy,
-        destroy: :destroy
-      }.with_indifferent_access)
-    end
-
-    context "when `show` feature is available" do
-      it "returns show > show feature mapping" do
-        allow(subject).to receive(:feature_available?).and_call_original
-        allow(subject).to receive(:feature_available?).with(:show).and_return(true)
-        expect(subject.action_features[:show]).to eq(:show)
-      end
-    end
-  end
-
   describe "#action_view" do
     context "when given view does not exists within action views hash" do
       it "returns given action" do
@@ -75,79 +56,88 @@ describe Releaf::BaseController do
     end
   end
 
-  describe "#form_url" do
-    context "when given resource is new record" do
-      it "returns url for create method" do
-        allow(subject).to receive(:url_for).with(action: 'create', id: nil).and_return("/res/new")
-        expect(subject.form_url(:edit, new_resource)).to eq("/res/new")
+  describe "#page_title" do
+    before do
+      allow(Rails.application.class).to receive(:parent_name).and_return("DummyApp")
+    end
+
+    context "when controller definition exists" do
+      it "returns localized controller name from definitioned followed by application name" do
+        definition = Releaf::ControllerDefinition.new("xx")
+        allow(definition).to receive(:localized_name).and_return("Books")
+        allow(subject).to receive(:definition).and_return(definition)
+        expect(subject.page_title).to eq("Books - DummyApp")
       end
     end
 
-    context "when given resource is existing record" do
-      it "returns url for update method" do
-        allow(subject).to receive(:url_for).with(action: 'update', id: resource.id).and_return("/res/edit/")
-        expect(subject.form_url(:edit, resource)).to eq("/res/edit/")
+    context "when controller definition does not exist" do
+      it "returns only application name" do
+        allow(subject).to receive(:definition).and_return(nil)
+        expect(subject.page_title).to eq("DummyApp")
       end
     end
   end
 
-  describe "#form_attributes" do
-    it "returns basic releaf form attributes" do
-      attributes = {
-         multipart: true,
-         novalidate: "",
-         class: ["new-user"],
-         id: "new-user",
-         data: {
-           "remote"=>true,
-           "remote-validation"=>true,
-           "type"=>:json
-         }
-      }
-      expect(subject.form_attributes(:edit, new_resource, :user)).to eq(attributes)
+  describe "#builder_class" do
+    it "returns controller class scoped builder for given builder type" do
+      allow(subject).to receive(:builder_scopes).and_return(["a", "b"])
+      allow(Releaf::Builders).to receive(:builder_class).with(["a", "b"], :form).and_return("x")
+      expect(subject.builder_class(:form)).to eq("x")
     end
+  end
 
-    it "changes class/id depending whether given object is persisted" do
-      expect(subject.form_attributes(:edit, new_resource, :user)[:id]).to eq("new-user")
-      expect(subject.form_attributes(:edit, new_resource, :user)[:class]).to eq(["new-user"])
+  describe "#short_name" do
+    it "returns undercored class name with  Controller suffix removed" do
+      allow(subject).to receive(:class).and_return(Admin::BooksController)
+      expect(subject.short_name).to eq("admin/books")
+    end
+  end
 
-      expect(subject.form_attributes(:edit, resource, :user)[:id]).to eq("edit-user")
-      expect(subject.form_attributes(:edit, resource, :user)[:class]).to eq(["edit-user"])
+  describe "#definition" do
+    it "returns controller definition for controller short name" do
+      allow(Releaf::ControllerDefinition).to receive(:for).with("xxx").and_return("yyy")
+      allow(subject).to receive(:short_name).and_return("xxx")
+      expect(subject.definition).to eq("yyy")
     end
+  end
 
-    it "adds has-error class if object has any errors" do
-      resource.name = nil
-      expect(resource.valid?).to be false
-      expect(subject.form_attributes(:edit, resource, :user)[:class]).to eq(["edit-user", "has-error"])
+  describe "#builder_scopes" do
+    context "when controller is a direct child of Releaf::ActionController" do
+      it "returns an array with own and application builder scopes" do
+        allow(subject).to receive(:application_scope).and_return("xxx")
+        expect(subject.builder_scopes).to eq(["Dummy", "xxx"])
+      end
     end
 
+    context "when controller is a deeper descendant of Releaf::ActionController" do
+      let(:subject) { Dummy::GrandChildDummyController.new }
+      it "includes ancestor scopes up to but not including Releaf::ActionController" do
+        allow(subject).to receive(:application_scope).and_return("xxx")
+        expect(subject.class).to receive(:ancestor_controllers).and_call_original
+        expect(subject.builder_scopes).to eq(["Dummy::GrandChildDummy", "Dummy::ChildDummy", "Dummy", "xxx"])
+      end
+    end
   end
 
-  describe "#builder_class" do
-    it "returns controller class scoped builder for given builder type" do
-      allow(subject).to receive(:builder_scopes).and_return(["a", "b"])
-      allow(Releaf::Builders).to receive(:builder_class).with(["a", "b"], :form).and_return("x")
-      expect(subject.builder_class(:form)).to eq("x")
+  describe ".own_builder_scope" do
+    it "returns controller class name without 'Controller'" do
+      expect(DummyController.own_builder_scope).to eq "Dummy"
     end
   end
 
-  describe "#builder_scopes" do
-    it "returns array with normalized controller class name scope and project builder scope" do
-      allow(subject).to receive(:application_builder_scope).and_return("xxx")
-      expect(subject.builder_scopes).to eq(["Dummy", "xxx"])
+  describe ".ancestor_controllers" do
+    it "return all ancestor controllers up to but not including Releaf::ActionController" do
+      expect(DummyController.ancestor_controllers).to eq []
+      expect(Dummy::GrandChildDummyController.ancestor_controllers).to eq([Dummy::ChildDummyController, DummyController])
     end
   end
 
-  describe "#application_builder_scope" do
-    it "returns node builder scope within releaf mount location scope" do
-      allow(subject).to receive(:application_scope).and_return("Admin")
-      expect(subject.application_builder_scope).to eq("Admin::Builders")
-
-      allow(subject).to receive(:application_scope).and_return("")
-      expect(subject.application_builder_scope).to eq("Builders")
+  describe ".ancestor_builder_scopes" do
+    it "return builder scopes for all ancestor controllers" do
+      allow(Dummy::ChildDummyController).to receive(:own_builder_scope).and_call_original
+      allow(DummyController).to receive(:own_builder_scope).and_call_original
 
-      allow(subject).to receive(:application_scope).and_return(nil)
-      expect(subject.application_builder_scope).to eq("Builders")
+      expect(Dummy::GrandChildDummyController.ancestor_builder_scopes).to eq(['Dummy::ChildDummy', 'Dummy'])
     end
   end
 
@@ -168,91 +158,89 @@ describe Releaf::BaseController do
       expect(subject.application_scope).to eq(nil)
     end
   end
-
-  describe "#table_options" do
-    it "returns table options" do
-      allow(subject).to receive(:builder_class).with(:table).and_return("CustomTableBuilderClassHere")
-      allow(subject).to receive(:feature_available?).with(:toolbox).and_return("boolean_value_here")
-
-      options = {
-        builder: "CustomTableBuilderClassHere",
-        toolbox: "boolean_value_here"
-      }
-      expect(subject.table_options).to eq(options)
-    end
-  end
-
-  describe "#form_options" do
-    it "returns form options" do
-      allow(subject).to receive(:builder_class).with(:form).and_return("CustomFormBuilderClassHere")
-      allow(subject).to receive(:form_url).with(:delete, resource).and_return("/some-url-here")
-      allow(subject).to receive(:form_attributes).with(:delete, resource, :author).and_return(some: "options_here")
-
-      options = {
-        builder: "CustomFormBuilderClassHere",
-        as: :author,
-        url: "/some-url-here",
-        html: {some: "options_here"}
-      }
-      expect(subject.form_options(:delete, resource, :author)).to eq(options)
-    end
-  end
 end
 
-# use Admin::BooksController / Admin::AuthorsController as it inherit Releaf::BaseController and
+# use Admin::BooksController / Admin::AuthorsController as it inherit Releaf::ActionController and
 # have no extra methods or overrides
 describe Admin::AuthorsController do
   before do
     sign_in FactoryGirl.create(:user)
   end
 
-  describe "#index_url" do
+  describe "#index_path" do
     context "when action is other than :index" do
-      context "when params have 'index_url' defined" do
-        it "returns params 'index_url'" do
-          url = "/admin/something?a=1&b=2"
-          get :new, index_url: url
-          expect(subject.index_url).to eq(url)
+      context "when params have valid `index_path` value" do
+        it "returns params 'index_path'" do
+          get :new, index_path: "xxxxxxxx"
+          allow(subject).to receive(:valid_index_path?).with("xxxxxxxx").and_return(true)
+          expect(subject.index_path).to eq("xxxxxxxx")
         end
       end
 
-      context "when does not have 'index_url' defined" do
-        it "returns index action url" do
-          get :new
-          expect(subject.index_url).to eq("http://test.host/admin/authors")
+      context "when params have invalid `index_path` value" do
+        it "returns index action path" do
+          get :new, index_path: "xxxxxxxx"
+          allow(subject).to receive(:valid_index_path?).with("xxxxxxxx").and_return(false)
+          expect(subject.index_path).to eq("/admin/authors")
         end
       end
     end
 
     context "when action is :index" do
-      it "returns #current_url value" do
+      it "returns #current_path value" do
         get :index
-        allow(subject).to receive(:current_url).and_return("random_string")
-        expect(subject.index_url).to eq("random_string")
+        allow(subject).to receive(:current_path).and_return("random_string")
+        expect(subject.index_path).to eq("random_string")
+      end
+    end
+  end
+
+  describe "#valid_index_path?" do
+    context "when given value is string that starts with `/`" do
+      it "returns true" do
+        expect(subject.valid_index_path?("/admin/something?a=1&b=2")).to be true
+      end
+    end
+
+    context "when given value is string that starts with other char than `/`" do
+      it "returns false" do
+        expect(subject.valid_index_path?("http:///admin/something?a=1&b=2")).to be false
+      end
+    end
+
+    context "when given value is not string" do
+      it "returns false" do
+        expect(subject.valid_index_path?(123)).to be false
+      end
+    end
+
+    context "when given value is blank" do
+      it "returns false" do
+        expect(subject.valid_index_path?(nil)).to be false
       end
     end
   end
 
-  describe "#current_url" do
+  describe "#current_path" do
     it "returns current url without `ajax` param" do
       get :index, ajax: 1, search: "something", page: 1
-      expect(subject.current_url).to eq("/admin/authors?page=1&search=something")
+      expect(subject.current_path).to eq("/admin/authors?page=1&search=something")
     end
 
     context "when no query parameters exists" do
       it "returns only request path" do
         get :index
-        expect(subject.current_url).to eq("/admin/authors")
+        expect(subject.current_path).to eq("/admin/authors")
       end
     end
 
     it "caches current url value" do
       get :index
       expect(subject).to receive(:request).twice.and_call_original
-      subject.current_url
-      subject.current_url
-      subject.current_url
-      subject.current_url
+      subject.current_path
+      subject.current_path
+      subject.current_path
+      subject.current_path
     end
   end
 
@@ -319,7 +307,7 @@ describe Admin::AuthorsController do
       end
     end
 
-    context "when @resources_per_page is nil" do
+    context "when resources_per_page is nil" do
       it "assigns all resources to @collection" do
         get :index, show_all: 1
         expect(assigns(:collection).is_a?(ActiveRecord::Relation)).to be true
@@ -327,7 +315,7 @@ describe Admin::AuthorsController do
       end
     end
 
-    context "when @resources_per_page is not nil" do
+    context "when resources_per_page is not nil" do
       it "assigns maximum 20 resources to @collection" do
         get :index
         expect(assigns(:collection).is_a?(ActiveRecord::Relation)).to be true
@@ -338,9 +326,9 @@ describe Admin::AuthorsController do
 
   describe "DELETE #destroy" do
     before do
-       @author = FactoryGirl.create(:author)
-       FactoryGirl.create(:book, title: "The book", author: @author)
-       FactoryGirl.create(:book, title: "Almost the book", author: @author)
+      @author = FactoryGirl.create(:author)
+      FactoryGirl.create(:book, title: "The book", author: @author)
+      FactoryGirl.create(:book, title: "Almost the book", author: @author)
     end
 
     it "creates flash error with message" do
@@ -350,13 +338,11 @@ describe Admin::AuthorsController do
   end
 end
 
-
 describe Admin::BooksController do
   before do
     sign_in FactoryGirl.create(:user)
     @breadcrumbs_base = [
-      {name: I18n.t('home', scope: 'admin.breadcrumbs'), url: releaf_root_path},
-      {name: I18n.t('admin/books', scope: "admin.controllers"), url: admin_books_path},
+      {name: I18n.t('admin/books'), url: admin_books_path}
     ]
   end
 
@@ -399,17 +385,14 @@ describe Admin::BooksController do
   describe "GET #new" do
     it "assigns the requested record to @resource" do
       get :new
-
       expect(assigns(:resource).new_record?).to be true
     end
 
-    context "when the requested record responds to #to_text" do
-      it "uses the result of #to_text for resource's breadcrumb name" do
-        get :new
-        breadcrumbs = @breadcrumbs_base + [{name: "New record", url: new_admin_book_path}]
+    it "assigns special breadcrumb part for new record" do
+      get :new
+      breadcrumbs = @breadcrumbs_base + [{name: "New record", url: new_admin_book_path}]
 
-        expect(assigns(:breadcrumbs)).to eq(breadcrumbs)
-      end
+      expect(assigns(:breadcrumbs)).to eq(breadcrumbs)
     end
   end
 
@@ -424,24 +407,12 @@ describe Admin::BooksController do
       expect(assigns(:resource)).to eq(@resource)
     end
 
-    context "when the requested record responds to #to_text" do
-      it "uses the result of #to_text for resource's breadcrumb name" do
-        get :edit, id: @resource
-        breadcrumbs = @breadcrumbs_base + [{name: @resource.to_text, url: edit_admin_book_path(@resource.id)}]
-
-        expect(assigns(:breadcrumbs)).to eq(breadcrumbs)
-      end
-    end
-
-    context "when the requested record does not respond to #to_text" do
-      it "uses default translation for resource's breadcrumb name" do
-        skip "Find out way how to stub loaded resource #respond_to?(:to_text)"
-        allow_any_instance_of(Book).to receive(:respond_to?).with(:to_text).and_return(false)
-        get :edit, id: @resource
-        breadcrumbs = @breadcrumbs_base + [{name: "Edit resource", url: edit_admin_book_path(@resource.id)}]
+    it "assigns breadcrumb for resource" do
+      allow(Releaf::ResourceBase).to receive(:title).with(@resource).and_return("xxx")
+      get :edit, id: @resource
+      breadcrumbs = @breadcrumbs_base + [{name: "xxx", url: edit_admin_book_path(@resource.id)}]
 
-        expect(assigns(:breadcrumbs)).to eq(breadcrumbs)
-      end
+      expect(assigns(:breadcrumbs)).to eq(breadcrumbs)
     end
   end
 end

data/spec/controllers/releaf/root_controller_spec.rb

@@ -0,0 +1,40 @@
+require 'rails_helper'
+
+describe Releaf::RootController do
+  login_as_user :user
+
+  describe "GET home" do
+    it "redirects to default controller resolver returned path authorized as user" do
+      allow(Releaf.application.config.root.default_controller_resolver).to receive(:call)
+        .with(current_controller: subject).and_return("_randompath_")
+      get :home
+      expect(response).to redirect_to("_randompath_")
+    end
+  end
+
+
+  describe "PUT settings" do
+    context 'when params[:settings] is not Hash' do
+      it "has a 422 status code" do
+        post :store_settings
+        expect(Releaf.application.config.settings_manager).to_not receive(:write)
+        expect(response.status).to eq(422)
+      end
+    end
+
+    context 'when params[:settings] is Hash' do
+      it "has a 200 status code" do
+        allow(Releaf.application.config.settings_manager).to receive(:write)
+        post :store_settings, settings: {dummy: 'maybe'}
+        expect(response.status).to eq(200)
+      end
+
+      it "saves given data within current user settings, casting true/false strings to boolean" do
+        expect(Releaf.application.config.settings_manager).to receive(:write).with(controller: subject, key: "dummy", value: "maybe")
+        expect(Releaf.application.config.settings_manager).to receive(:write).with(controller: subject, key: "be_true", value: true)
+        expect(Releaf.application.config.settings_manager).to receive(:write).with(controller: subject, key: "be_false", value: false)
+        post :store_settings, settings: {dummy: "maybe", be_true: 'true', be_false: 'false'}
+      end
+    end
+  end
+end

data/spec/controllers/releaf/settings_controller_spec.rb

@@ -0,0 +1,52 @@
+require 'rails_helper'
+
+describe Releaf::SettingsController do
+  login_as_user :user
+
+  describe "GET index" do
+    login_as_user :user
+    it "lists only settings that not scoped to any object and exists within `Releaf::Settings.registry`" do
+      Releaf::Settings.destroy_all
+      Releaf::Settings.registry = {}
+
+      Releaf::Settings.create(var: "a", value: "1")
+      Releaf::Settings.create(var: "b", value: "2")
+      Releaf::Settings.create(var: "c", value: "2")
+      Releaf::Settings.create(var: "a", value: "3", thing_type: "User", thing_id: "1")
+
+      Releaf::Settings.register(key: "a", default: "x", description: "some setting")
+      Releaf::Settings.register(key: "b", default: "xxxx", description: "some other setting")
+
+      get :index
+      expect(assigns(:collection).size).to eq(2)
+    end
+  end
+
+  describe "PATCH update" do
+    login_as_user :user
+    it "updates settings object with normalized value" do
+      Releaf::Settings.destroy_all
+      Releaf::Settings.registry = {}
+      Releaf::Settings.register(key: "a", default: false, type: "boolean")
+
+      allow(Releaf::Settings::NormalizeValue).to receive(:call).
+        with(value: "1", input_type: :boolean).and_return(88)
+
+      patch :update, {id: Releaf::Settings.first.id, resource: {value: "1"}}
+      expect(Releaf::Settings.first.value).to eq(88)
+    end
+  end
+
+  describe "#features" do
+    it "has `index`, `search` and `edit` features" do
+      expect(subject.features).to eq([:index, :edit, :search])
+    end
+  end
+
+  describe "#resources" do
+    it "returns only registered settings ordered by `var`" do
+      allow(Releaf::Settings).to receive(:registered).and_return(:x)
+      expect(subject.resources).to eq(:x)
+    end
+  end
+end

data/spec/error_hash_builder_spec.rb

@@ -0,0 +1,83 @@
+require 'rails_helper'
+describe "Errors hash builder" 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
+    accepts_nested_attributes_for :author
+  end
+
+  let(:resource) { DummyResourceValidatorBook.new }
+  let(:error){ ActiveModel::ErrorMessage.new("blank value", :blank) }
+
+  subject do
+    Releaf::BuildErrorsHash.new(resource: resource, field_name_prefix: :resource)
+  end
+
+  describe "#format_errors" do
+    it "adds error to errors" do
+      expected_result = {
+        "resource[title]" => [
+          {error_code: :blank, message: "can't be blank"},
+          {error_code: :invalid, message: "test error"},
+        ],
+        "resource[author_id]" => [
+          {error_code: :blank, message: "can't be blank"},
+          {error_code: :invalid, message: "Invalid author"}
+        ],
+        "resource" => [
+          {error_code: :invalid, message: "error on base"}
+        ]
+      }
+      resource.valid?
+      resource.chapters.new(id: 12)
+      resource.chapters.new(title: 'test')
+      resource.errors.add(:base, 'error on base')
+      resource.errors.add(:title, "test error")
+      resource.errors.add(:author_id, "Invalid author")
+      expect(subject.call).to eq(expected_result)
+
+      resource.title = "xxx"
+      resource.build_author
+      resource.valid?
+
+      expected_result = {
+        "resource[chapters_attributes][0][title]" => [
+          {error_code: :blank, message: "can't be blank"},
+          {error_code: :blank, message: "can't be blank"},
+          {error_code: :blank, message: "can't be blank"}
+        ],
+        "resource[chapters_attributes][0][text]" => [
+          {error_code: :blank, message: "can't be blank"},
+          {error_code: :blank, message: "can't be blank"},
+          {error_code: :blank, message: "can't be blank"}
+        ],
+        "resource[chapters_attributes][0][sample_html]" => [
+          {error_code: :blank, message: "can't be blank"},
+          {error_code: :blank, message: "can't be blank"},
+          {error_code: :blank, message: "can't be blank"}
+        ],
+        "resource[chapters_attributes][1][text]" => [
+          {error_code: :blank, message: "can't be blank"},
+          {error_code: :blank, message: "can't be blank"},
+          {error_code: :blank, message: "can't be blank"}
+        ],
+        "resource[chapters_attributes][1][sample_html]" => [
+          {error_code: :blank, message: "can't be blank"},
+          {error_code: :blank, message: "can't be blank"},
+          {error_code: :blank, message: "can't be blank"}
+        ],
+        "resource[author_attributes][name]" => [
+          {error_code: :blank, message: "can't be blank"}
+        ]
+      }
+      expect(subject.call).to eq(expected_result)
+    end
+  end
+end

data/spec/ext/array_reorder_spec.rb

@@ -0,0 +1,12 @@
+require "rails_helper"
+
+describe Array do
+  let(:subject){ [:a, :b, :c] }
+
+  describe "#reorder" do
+    it "return reordered result for given options from `Array::Reorder` service" do
+      expect(Array::Reorder).to receive(:call).with(array: subject, values: :b, options: :last).and_call_original
+      expect(subject.reorder(:b, :last)).to eq([:a, :c, :b])
+    end
+  end
+end