releaf-content 2.0.0 → 2.0.1

data/spec/lib/releaf/content/route_spec.rb

@@ -1,229 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Content::Route do
-  let(:node_route) { FactoryBot.build(:node_route, node_class: Node, node_id: 12, locale: "en", path: "/en") }
-
-
-  describe ".default_controller" do
-    context "when given node class inherits `ActionController::Base`" do
-      it "returns undercored, stripped down controller class" do
-        expect(described_class.default_controller(HomePagesController)).to eq("home_pages")
-      end
-    end
-
-    context "when given node class does not inherit `ActionController::Base`" do
-      it "returns pluralized, underscorized class" do
-        expect(described_class.default_controller(TextPage)).to eq("text_pages")
-      end
-    end
-  end
-
-
-  describe '#params' do
-    let(:options_argument) { { foo: :bar } }
-
-    it "returns params for router method" do
-      expect(node_route.params("home#index")).to eq ['/en', {to: "home#index", node_class: "Node", node_id: "12", locale: "en", as: nil }]
-    end
-
-    it "uses #path_for to calculate path" do
-      allow(node_route).to receive(:path_for).with("home#index", options_argument).and_return( "foo_path" )
-      expect(node_route.params("home#index", options_argument)[0]).to eq "foo_path"
-    end
-
-    it "uses #options_for to calculate options" do
-      allow(node_route).to receive(:options_for).with("home#index", options_argument).and_return( some: :options )
-      expect(node_route.params("home#index", options_argument)[1]).to eq( some: :options )
-    end
-
-    it "converts method_or_path argument to string" do
-      expect(node_route).to receive(:path_for).with("foo", options_argument)
-      expect(node_route).to receive(:options_for).with("foo", options_argument)
-      node_route.params(:foo, options_argument)
-    end
-
-    it "does not require options argument" do
-      expect(node_route).to receive(:path_for).with("home#index", {})
-      expect(node_route).to receive(:options_for).with("home#index", {})
-      node_route.params("home#index")
-    end
-
-  end
-
-  describe "#path_for" do
-
-    it "returns route path" do
-      expect( node_route.path_for( "foo", {} ) ).to eq "/en"
-    end
-
-    context "when options contain a :to key" do
-      it "returns route path combined with given method_or_path" do
-        expect( node_route.path_for( "foo", { to: "bar" } ) ).to eq "/en/foo"
-      end
-    end
-
-    context "when first argument contains a controller#action or #action string" do
-      it "returns the route path" do
-        expect( node_route.path_for( "home#index", { to: "bar" } ) ).to eq "/en"
-      end
-    end
-
-  end
-
-  describe "#options_for" do
-
-    it "returns route options hash" do
-      expect( node_route.options_for( "home#index", {} ) ).to be_a Hash
-    end
-
-    it "sets :node_class to route node class name string" do
-      expect( node_route.options_for( "home#index", {} ) ).to include( node_class: "Node" )
-    end
-
-    it "sets :node_id to route node id string" do
-      expect( node_route.options_for( "home#index", {} ) ).to include( node_id: "12" )
-    end
-
-    it "sets :locale to route locale" do
-      expect( node_route.options_for( "home#index", {} ) ).to include( locale: "en" )
-    end
-
-    it "sets :to to the result of #controller_and_action_for" do
-      allow(node_route).to receive(:controller_and_action_for).with( "home#index", foo: :bar).and_return("ok")
-      expect( node_route.options_for( "home#index", foo: :bar ) ).to include( to: "ok" )
-    end
-
-    it "sets :as to the result of #name by passing all other calculated options" do
-      expected_name_options = {
-        foo: :bar,
-        to: "home#index",
-        node_class: "Node",
-        node_id: "12",
-        locale: "en"
-      }
-
-      allow(node_route).to receive(:name).with( expected_name_options ).and_return("ok")
-      expect( node_route.options_for( "home#index", foo: :bar ) ).to include( as: "ok" )
-    end
-
-    it "preserves unrecognized option keys" do
-      expect( node_route.options_for( "home#index", foo: :bar ) ).to include( foo: :bar )
-    end
-
-    it "uses calculated keys in case conflicting option keys given" do
-      in_options = { to: "invalid", node_class: "invalid", node_id: "invalid", locale: "invalid" }
-
-      expect( node_route.options_for( "home#index", in_options ) ).to include({
-        to: "home#index",
-        node_class: "Node",
-        node_id: "12",
-        locale: "en"
-      })
-    end
-
-    context "when node route has site" do
-
-      it "sets :site to route site" do
-        node_route.site = "ok"
-        expect( node_route.options_for( "home#index", {} ) ).to include( site: "ok" )
-      end
-
-      it "overrides site given in options" do
-        node_route.site = "ok"
-        expect( node_route.options_for( "home#index", { site: "foo" } ) ).to include( site: "ok" )
-      end
-
-    end
-
-    context "when node route does not have site" do
-
-      it "does not set :site" do
-        expect( node_route.options_for( "home#index", {} ) ).to_not include( :site )
-      end
-
-      it "allows site from options" do
-        expect( node_route.options_for( "home#index", { site: "ok" } ) ).to include( site: "ok" )
-      end
-
-    end
-
-
-  end
-
-  describe "#name" do
-
-    context "when route options contain :as option" do
-
-      context "when neither :site nor :locale are set or are blank in route options" do
-        it "returns the value intact" do
-          expect(node_route.name( { as: "foo" } )).to eq "foo"
-          expect(node_route.name( { as: "foo", site: nil, locale: nil } )).to eq "foo"
-        end
-      end
-
-      context "when :site is set in route options" do
-        it "returns the value with site prepended" do
-          expect(node_route.name( { as: "foo", site: "sss" } )).to eq "sss_foo"
-        end
-      end
-
-      context "when :locale is set in route options" do
-        it "returns the value with locale prepended" do
-          expect(node_route.name( { as: "foo", locale: "lll" } )).to eq "lll_foo"
-        end
-      end
-
-      context "when both :site and :locale are set in route options" do
-        it "returns the value with site and locale prepended" do
-          expect(node_route.name( { as: "foo", site: "sss", locale: "lll" } )).to eq "sss_lll_foo"
-        end
-      end
-
-    end
-
-    context "when route options do not contain :as option" do
-      it "returns nil" do
-        expect(node_route.name( {} )).to be_nil
-      end
-    end
-
-  end
-
-  describe ".for" do
-    before do
-      create(:home_page_node)
-    end
-
-    it "returns an array" do
-      expect(described_class.for(Node, HomePage, 'foo')).to be_a Array
-    end
-
-    context "when database doesn't exists" do
-      it "returns an empty array" do
-        allow(Node).to receive(:where).and_raise(ActiveRecord::NoDatabaseError.new("xxx"))
-        expect(described_class.for(Node, HomePage, 'foo')).to eq([])
-      end
-    end
-
-    context "when node table doesn't exist" do
-      it "returns an empty array" do
-        allow(Node).to receive(:where).and_raise(ActiveRecord::StatementInvalid.new("xxx"))
-        expect(described_class.for(Node, HomePage, 'foo')).to eq([])
-      end
-    end
-
-    context "when node table exists" do
-      it "returns an array of Node::Route objects processed by Releaf::Content::BuildRouteObjects" do
-        expect(Releaf::Content::BuildRouteObjects).to receive(:call).with(node_class: Node, node_content_class: HomePage, default_controller: 'foo').and_call_original
-        result = described_class.for(Node, HomePage, 'foo')
-        expect(result.count).to eq(1)
-        expect(result.first.class).to eq(described_class)
-      end
-
-      it "accepts node_class as string also" do
-        result = described_class.for('Node', HomePage, 'foo')
-        expect(result.count).to eq(1)
-      end
-    end
-  end
-end

data/spec/middleware/routes_reloader_spec.rb

@@ -1,96 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Content::RoutesReloader do
-  let(:app) { ->(env) { [200, env, "app"] } }
-
-  let :request do
-    described_class.new(app).call(Rack::MockRequest.env_for('http://example.com'))
-  end
-
-  describe "on application startup" do
-    it "sets routes loading time" do
-      expect(described_class.routes_loaded).to_not be_nil
-    end
-  end
-
-  describe "on each request" do
-    it "compares latest updates" do
-      expect(described_class).to receive(:reload_if_needed)
-      request
-    end
-  end
-
-  describe ".reset!" do
-
-    it "changes class @updated_at instance to nil" do
-      described_class.instance_variable_set(:@updated_at, "x")
-      expect{ described_class.reset! }.to change{ described_class.instance_variable_get(:@updated_at) }.to(nil)
-    end
-
-  end
-
-  describe ".reload_if_needed" do
-
-    context "when reload is needed" do
-      it "reloads routes" do
-        allow(described_class).to receive(:needs_reload?).and_return true
-        expect(Rails.application).to receive(:reload_routes!)
-        described_class.reload_if_needed
-      end
-    end
-
-    context "when reload is not needed" do
-      it "does not reload routes" do
-        allow(described_class).to receive(:needs_reload?).and_return false
-        expect(Rails.application).to_not receive(:reload_routes!)
-        described_class.reload_if_needed
-      end
-    end
-
-  end
-
-  describe ".needs_reload?" do
-
-    context "when no nodes exist" do
-      it "returns false" do
-        allow(Node).to receive(:updated_at).and_return(nil)
-        expect(described_class.needs_reload?).to be false
-      end
-    end
-
-    context "when node routes has not been loaded" do
-      it "returns true" do
-        described_class.instance_variable_set(:@updated_at, nil)
-        allow(Node).to receive(:updated_at).and_return(Time.parse("1991-01-01"))
-        expect(described_class.needs_reload?).to be true
-      end
-    end
-
-    context "when node routes are up to date" do
-      it "returns false" do
-        described_class.instance_variable_set(:@updated_at, Time.parse("1991-01-01"))
-        allow(Node).to receive(:updated_at).and_return(Time.parse("1991-01-01"))
-        expect(described_class.needs_reload?).to be false
-      end
-    end
-
-    context "when node routes are outdated" do
-      it "returns true" do
-        allow(Node).to receive(:updated_at).and_return(Time.now + 1.minute)
-        expect(described_class.needs_reload?).to be true
-      end
-    end
-
-    it "checks all content model classes" do
-      class RouteReloaderDummyNode
-        def self.updated_at
-          Time.now + 1.minute
-        end
-      end
-      allow(Releaf::Content).to receive(:models).and_return [ Node, RouteReloaderDummyNode ]
-      allow(Node).to receive(:updated_at).and_return(nil)
-      expect(described_class.needs_reload?).to be true
-    end
-
-  end
-end

data/spec/routing/node_mapper_spec.rb

@@ -1,311 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Content::NodeMapper do
-
-  let(:multiple_node_resources) {{
-    'Node' => {
-      controller: 'Releaf::Content::NodesController',
-      routing: { site: "main_site", constraints: { host: /^releaf\.local$/ } }
-    },
-    'OtherSite::OtherNode' => {
-      controller: 'Admin::OtherSite::OtherNodesController',
-      routing: { site: "other_site", constraints: { host: /^other\.releaf\.local$/ } }
-    }
-  }}
-
-  before do
-    @text_page = create(:text_page)
-    @lv_root_node = create(:home_page_node, name: "lv", locale: "lv", slug: 'lv')
-    @node = create(:node, slug: 'test-page', content: @text_page, parent: @lv_root_node)
-  end
-
-  before with_multiple_node_classes: true do
-    allow( Releaf.application.config ).to receive(:content).and_return(
-      Releaf::Content::Configuration.new(resources: multiple_node_resources)
-    )
-    @other_text_page = create(:text_page)
-    @other_lv_root_node = create(:other_home_page_node, name: "lv", locale: "lv", slug: 'lv')
-    @other_node = create(:other_node, slug: 'test-page', content: @other_text_page, parent: @other_lv_root_node)
-  end
-
-  after do
-    Dummy::Application.reload_routes!
-  end
-
-  after(:all) do
-    # without this the test environent remains polluted with test node class config.
-    # the routing configuration gets already reset after each test in the after block above
-    # but that seems to not be enough
-    Dummy::Application.reload_routes!
-  end
-
-  describe "#node_routes_for", create_nodes: true do
-
-    it "draws public website routes for default node class" do
-
-      routes.draw do
-        node_routes_for(TextPage) do |route|
-          get 'show'
-          delete :destroy
-        end
-      end
-
-      expect(get: '/lv/test-page').to route_to(
-        "controller" => "text_pages",
-        "action" => "show",
-        "node_class" => "Node",
-        "node_id" => @node.id.to_s,
-        "locale" => 'lv'
-      )
-
-      expect(delete: '/lv/test-page').to route_to(
-        "controller" => "text_pages",
-        "action" => "destroy",
-        "node_class" => "Node",
-        "node_id" => @node.id.to_s,
-        "locale" => 'lv'
-      )
-    end
-
-    context "when a controller is given in arguments" do
-
-      it "draws the public website route to given controller" do
-        routes.draw do
-          node_routes_for(TextPage, controller: 'home_pages') do |route|
-            get 'show'
-          end
-        end
-
-        expect(get: '/lv/test-page').to route_to(
-          "controller" => "home_pages",
-          "action" => "show",
-          "node_class" => "Node",
-          "node_id" => @node.id.to_s,
-          "locale" => 'lv'
-        )
-      end
-
-    end
-
-    context "when a controller is passed in route options" do
-      it "draws the public website route using the controller from options" do
-        routes.draw do
-          node_routes_for(TextPage, controller: 'doesnt_matter') do |route|
-            get 'home_pages#hide'
-          end
-        end
-
-        expect(get: '/lv/test-page').to route_to(
-          "controller" => "home_pages",
-          "action" => "hide",
-          "node_class" => "Node",
-          "node_id" => @node.id.to_s,
-          "locale" => 'lv'
-        )
-      end
-    end
-
-    context "when custom action is given in :to" do
-      it "draws the public website route using the action from :to" do
-        routes.draw do
-          node_routes_for(TextPage) do |route|
-            get '' , to: '#list'
-          end
-        end
-
-        expect(get: '/lv/test-page').to route_to(
-          "controller" => "text_pages",
-          "action" => "list",
-          "node_class" => "Node",
-          "node_id" => @node.id.to_s,
-          "locale" => 'lv'
-        )
-
-      end
-    end
-
-    context "when custom controller and action are given in :to" do
-      it "draws the public website route using the given controller and action from :to" do
-        routes.draw do
-          node_routes_for(TextPage) do |route|
-            get '' , to: 'home_pages#list'
-          end
-        end
-
-        expect(get: '/lv/test-page').to route_to(
-          "controller" => "home_pages",
-          "action" => "list",
-          "node_class" => "Node",
-          "node_id" => @node.id.to_s,
-          "locale" => 'lv'
-        )
-      end
-    end
-
-    context "when additional params are given in route path" do
-      it "passes the params to the public website route" do
-        routes.draw do
-          node_routes_for(TextPage) do |route|
-            get ':some_id', to: "#view"
-          end
-        end
-
-        expect(get: '/lv/test-page/8888').to route_to(
-          "controller" => "text_pages",
-          "action" => "view",
-          "node_class" => "Node",
-          "node_id" => @node.id.to_s,
-          "locale" => 'lv',
-          "some_id" => '8888'
-        )
-      end
-    end
-
-    context "when custom path is given for route" do
-      it "uses the custom path for public website route" do
-        routes.draw do
-          node_routes_for(TextPage) do |route|
-            route.path += "/abc/:my_id"
-            get 'home_pages#show'
-          end
-        end
-
-        expect(get: '/lv/test-page/abc/333').to route_to(
-          "controller" => "home_pages",
-          "action" => "show",
-          "node_class" => "Node",
-          "node_id" => @node.id.to_s,
-          "locale" => 'lv',
-          "my_id" => '333'
-        )
-      end
-    end
-
-    context "when custom node class is given as an argument", with_multiple_node_classes: true do
-
-      it "uses that node class for the public website route" do
-        routes.draw do
-          node_routes_for(TextPage, node_class: "OtherSite::OtherNode") do |route|
-            get 'show'
-          end
-        end
-
-        expect(get: '/lv/test-page').to route_to(
-          "controller" => "text_pages",
-          "action" => "show",
-          "node_class" => "OtherSite::OtherNode",
-          "node_id" => @other_node.id.to_s,
-          "locale" => 'lv',
-          "site"   => 'other_site'
-        )
-      end
-
-    end
-
-  end
-
-  describe "#for_node_class", with_multiple_node_classes: true do
-
-    it "uses given node class as a default when drawing public website routes in the given block" do
-      routes.draw do
-        for_node_class "OtherSite::OtherNode" do
-          node_routes_for(TextPage) do |route|
-            get 'show'
-          end
-        end
-      end
-
-      expect(get: '/lv/test-page').to route_to(
-        "controller" => "text_pages",
-        "action" => "show",
-        "node_class" => "OtherSite::OtherNode",
-        "node_id" => @other_node.id.to_s,
-        "locale" => 'lv',
-        "site"   => 'other_site'
-      )
-    end
-
-    it "restores default node class after block has been executed" do
-      routes.draw do
-        for_node_class "OtherSite::OtherNode" do
-          node_routes_for(TextPage) do |route|
-            get 'show'
-          end
-        end
-        node_routes_for(HomePage) do |route|
-            get 'show'
-        end
-      end
-
-      expect(get: '/lv').to route_to(
-        "controller" => "home_pages",
-        "action" => "show",
-        "node_class" => "Node",
-        "node_id" => @lv_root_node.id.to_s,
-        "locale" => 'lv',
-        "site"   => 'main_site'
-      )
-    end
-
-  end
-
-  describe "#node_routing", with_multiple_node_classes: true do
-
-    it "draws public website routes for all node classes in the given routing hash using respective route constraints" do
-
-      routes.draw do
-        node_routing( Releaf::Content.routing ) do
-          node_routes_for(TextPage) do |route|
-            get 'show'
-          end
-        end
-      end
-
-      expect(get: 'http://releaf.local/lv/test-page').to route_to(
-        "controller" => "text_pages",
-        "action" => "show",
-        "node_class" => "Node",
-        "node_id" => @node.id.to_s,
-        "locale" => 'lv',
-        "site"   => 'main_site'
-      )
-
-      expect(get: 'http://other.releaf.local/lv/test-page').to route_to(
-        "controller" => "text_pages",
-        "action" => "show",
-        "node_class" => "OtherSite::OtherNode",
-        "node_id" => @other_node.id.to_s,
-        "locale" => 'lv',
-        "site"   => 'other_site'
-      )
-
-    end
-
-    context "when passed a routing hash for only a subset of available node classes" do
-      it "draws constrained public website routes only for the given node classes" do
-        routes.draw do
-          routing_hash = Releaf::Content.routing.except('Node')
-          node_routing( routing_hash ) do
-            node_routes_for(TextPage) do |route|
-              get 'show'
-            end
-          end
-        end
-
-        expect(get: 'http://other.releaf.local/lv/test-page').to route_to(
-          "controller" => "text_pages",
-          "action" => "show",
-          "node_class" => "OtherSite::OtherNode",
-          "node_id" => @other_node.id.to_s,
-          "locale" => 'lv',
-          "site"   => 'other_site'
-        )
-
-        expect(get: 'http://releaf.local/lv/test-page').to_not be_routable
-
-      end
-    end
-
-  end
-
-end