releaf-core 2.0.0 → 2.0.1

data/spec/builders/releaf/settings/table_builder_spec.rb

@@ -1,23 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Settings::TableBuilder, type: :class do
-  class TableBuilderTestHelper < ActionView::Base; end
-  let(:template){ TableBuilderTestHelper.new(ActionView::LookupContext.new(nil), {}, nil) }
-  let(:resource_class){ Releaf::Settings }
-  let(:subject){ described_class.new([], resource_class, template, {}) }
-
-  describe "#column_names" do
-    it "returns var, value and updated_at as column names array" do
-      expect(subject.column_names).to eq([:var, :value, :updated_at])
-    end
-  end
-
-  describe "#value_content" do
-    it "return value processed with corresponding type content format method" do
-      resource = Releaf::Settings.new(value: :x)
-      allow(resource).to receive(:input_type).and_return(:date)
-      allow(subject).to receive(:format_date_content).with(resource, :value).and_return(:y)
-      expect(subject.value_content(resource)).to eq(:y)
-    end
-  end
-end

data/spec/controllers/concerns/releaf/richtext_attachments_spec.rb

@@ -1,51 +0,0 @@
-require 'rails_helper'
-
-describe Admin::NodesController, type: :controller do
-  before do
-    sign_in create(:user)
-  end
-
-  describe "#create_releaf_richtext_attachment" do
-    let(:file) { Rack::Test::UploadedFile.new(File.expand_path('../../../fixtures/cs.png', __dir__), "image/png") }
-
-    context "when file is uploaded" do
-      it "renders 'create_releaf_richtext_attachment'" do
-        post :create_releaf_richtext_attachment, params: {upload: file}
-        expect( response ).to be_successful
-        expect( response ).to render_template('create_releaf_richtext_attachment')
-      end
-
-      it "creates attachment" do
-        expect do
-          post :create_releaf_richtext_attachment, params: {upload: file}
-        end.to change { Releaf::RichtextAttachment.count }.by(1)
-      end
-    end
-
-    context "when no file is uploaded" do
-      it "responds with success" do
-        post :create_releaf_richtext_attachment
-        expect( response ).to be_successful
-      end
-
-      it "doesn't create attachment" do
-        expect do
-          post :create_releaf_richtext_attachment
-        end.to_not change { Releaf::RichtextAttachment.count }
-      end
-    end
-  end
-
-  describe "#releaf_richtext_attachment_upload_url" do
-    it "returns upload url" do
-      allow(subject).to receive(:url_for).with(action: :create_releaf_richtext_attachment).and_return("a")
-      expect(subject.releaf_richtext_attachment_upload_url).to eq("a")
-    end
-
-    context "when no route exists for controller" do
-      it "returns nil" do
-        expect(subject.releaf_richtext_attachment_upload_url).to be nil
-      end
-    end
-  end
-end

data/spec/controllers/releaf/action_controller_spec.rb

@@ -1,423 +0,0 @@
-require 'rails_helper'
-
-describe Releaf::ActionController do
-  let(:new_resource){ Author.new }
-  let(:resource){ create(:author) }
-  let(:subject){ DummyController.new }
-
-  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
-    it "returns action > view translation hash" do
-      hash = {
-        new: :edit,
-        update: :edit,
-        create: :edit,
-      }
-      expect(subject.action_views).to eq(hash)
-    end
-  end
-
-  describe "#action_view" do
-    context "when given view does not exists within action views hash" do
-      it "returns given action" do
-        expect(subject.action_view("a")).to eq("a")
-      end
-    end
-
-    context "when given view does not exists within action views hash" do
-      it "returns given action" do
-        expect(subject.action_view(:update)).to eq(:edit)
-      end
-    end
-
-    it "lookup given action as symbol to within action views hash" do
-      expect(subject.action_view("new")).to eq(:edit)
-    end
-  end
-
-  describe "#active_view" do
-    it "returns generic view name for current action" do
-      allow(subject).to receive(:action_name).and_return("a")
-      allow(subject).to receive(:action_view).with("a").and_return("b")
-      expect(subject.active_view).to eq("b")
-    end
-  end
-
-  describe "#page_title" do
-    before do
-      allow(Rails.application.class).to receive(:module_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 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 "#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
-
-  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
-
-  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
-
-  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
-
-    it "excludes nil values from returned array" do
-      allow(subject).to receive(:application_scope).and_return(nil)
-      expect(subject.builder_scopes).to eq(["Dummy"])
-    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 ".own_builder_scope" do
-    it "returns controller class name without 'Controller'" do
-      expect(DummyController.own_builder_scope).to eq "Dummy"
-    end
-  end
-
-  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 ".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
-
-      expect(Dummy::GrandChildDummyController.ancestor_builder_scopes).to eq(['Dummy::ChildDummy', 'Dummy'])
-    end
-  end
-
-  describe "#application_scope" do
-    it "returns node builder scope within releaf mount location scope" do
-      allow(Releaf::Builders).to receive(:constant_defined_at_scope?).and_call_original
-      allow(Releaf.application.config).to receive(:mount_location).and_return("admin")
-
-      allow(Releaf::Builders).to receive(:constant_defined_at_scope?)
-        .with("Admin", Object).and_return(true)
-      expect(subject.application_scope).to eq("Admin")
-
-      allow(Releaf::Builders).to receive(:constant_defined_at_scope?)
-        .with("Admin", Object).and_return(false)
-      expect(subject.application_scope).to eq(nil)
-
-      allow(Releaf.application.config).to receive(:mount_location).and_return("")
-      expect(subject.application_scope).to eq(nil)
-    end
-  end
-end
-
-# 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 FactoryBot.create(:user)
-  end
-
-  describe "#index_path" do
-    context "when action is other than :index" do
-      context "when params have valid `index_path` value" do
-        it "returns params 'index_path'" do
-          get :new, params: {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 params have invalid `index_path` value" do
-        it "returns index action path" do
-          get :new, params: {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_path value" do
-        get :index
-        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_path" do
-    it "returns current url without `ajax` param" do
-      get :index, params: {ajax: 1, search: "something", page: 1}
-      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_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_path
-      subject.current_path
-      subject.current_path
-      subject.current_path
-    end
-  end
-
-  describe "#ajax?" do
-    it "returns @_ajax instance variable value" do
-      subject.instance_variable_set("@_ajax", "ll")
-      expect(subject.ajax?).to eq("ll")
-    end
-
-    context "when @_ajax instance variable has not been set" do
-      it "returns false" do
-        expect(subject.ajax?).to be false
-      end
-    end
-  end
-
-  describe "#manage_ajax" do
-    context "when `ajax` params does not exists within params" do
-      it "assigns `false` to @_ajax instance variable" do
-        expect{ get :index }.to change{ subject.instance_variable_get("@_ajax") }.from(nil).to(false)
-      end
-    end
-
-    context "when `ajax` params exists within params" do
-      it "assigns `true` to @_ajax instance variable" do
-        expect{ get :index, params: {ajax: 1} }.to change{ subject.instance_variable_get("@_ajax") }.from(nil).to(true)
-      end
-
-      it "removes ajax from `params`" do
-        expect{ get :index, params: {ajax: 1} }.to_not change{ subject.params[:ajax] }.from(nil)
-      end
-
-      it "removes ajax from `request.query_parameters`" do
-        expect{ get :index, params: {ajax: 1} }.to_not change{ subject.request.query_parameters[:ajax] }.from(nil)
-      end
-    end
-  end
-
-  describe "GET show" do
-    let(:author){ create(:author) }
-
-    context "when show feature is available" do
-      it "assigns all resources to @collection" do
-        allow(subject).to receive(:feature_available?).with(:show).and_return(true)
-        get :show, params: {id: author}
-        expect(assigns(:resource)).to eq(author)
-      end
-    end
-
-    context "when show feature is not available" do
-      it "does assign resource" do
-        allow(subject).to receive(:feature_available?).and_call_original
-        allow(subject).to receive(:feature_available?).with(:show).and_return(false)
-        get :show, params: {id: author}
-        expect(assigns(:resource)).to be nil
-      end
-    end
-  end
-
-  describe "GET index" do
-    before do
-      21.times do |i|
-        FactoryBot.create(:author)
-      end
-    end
-
-    context "when resources_per_page is nil" do
-      it "assigns all resources to @collection" do
-        get :index, params: {show_all: 1}
-        expect(assigns(:collection).is_a?(ActiveRecord::Relation)).to be true
-        expect(assigns(:collection).size).to eq(21)
-      end
-    end
-
-    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
-        expect(assigns(:collection).size).to eq(20)
-      end
-    end
-  end
-
-  describe "DELETE #destroy" do
-    before do
-      @author = FactoryBot.create(:author)
-      FactoryBot.create(:book, title: "The book", author: @author)
-      FactoryBot.create(:book, title: "Almost the book", author: @author)
-    end
-
-    it "creates flash error with message" do
-      delete :destroy, params: {id: @author}
-      expect(flash["error"]).to eq({"id" => "resource_status", "message" => "Cant destroy, because relations exists"})
-    end
-  end
-end
-
-describe Admin::BooksController do
-  before do
-    sign_in FactoryBot.create(:user)
-    @breadcrumbs_base = [
-      {name: I18n.t('admin/books'), url: admin_books_path}
-    ]
-  end
-
-  describe "GET #index" do
-    before do
-      FactoryBot.create(:book, title: "great one")
-      FactoryBot.create(:book, title: "bad one")
-      FactoryBot.create(:book, title: "average third")
-    end
-
-    context "when empty search string given" do
-      it "shows all records" do
-        get :index, params: {search: ""}
-        expect(assigns(:collection).count).to eq(3)
-      end
-    end
-
-    context "when search string with multiple words given" do
-      it "searches by given string" do
-        get :index, params: {search: "one grea"}
-        expect(assigns(:collection).count).to eq(1)
-      end
-    end
-
-    context "when search string given" do
-      it "searches by given string" do
-        get :index, params: {search: "great"}
-        expect(assigns(:collection).count).to eq(1)
-      end
-    end
-
-    context "when no search given" do
-      it "shows all records" do
-        get :index
-        expect(assigns(:collection).count).to eq(3)
-      end
-    end
-  end
-
-  describe "GET #new" do
-    it "assigns the requested record to @resource" do
-      get :new
-      expect(assigns(:resource).new_record?).to be true
-    end
-
-    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
-  end
-
-  describe "GET #edit" do
-    before do
-      @resource = create(:book)
-    end
-
-    it "assigns the requested record to @resource" do
-      get :edit, params: {id: @resource}
-
-      expect(assigns(:resource)).to eq(@resource)
-    end
-
-    it "assigns breadcrumb for resource" do
-      allow(Releaf::ResourceBase).to receive(:title).with(@resource).and_return("xxx")
-      get :edit, params: {id: @resource}
-      breadcrumbs = @breadcrumbs_base + [{name: "xxx", url: edit_admin_book_path(@resource.id)}]
-
-      expect(assigns(:breadcrumbs)).to eq(breadcrumbs)
-    end
-  end
-end