releaf-content 0.2.1 → 1.0.3

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

@@ -1,26 +1,192 @@
 require "rails_helper"
 
 describe Releaf::Content::Route do
-  let(:node_route) { FactoryGirl.build(:node_route, node_id: 12, locale: "en", path: "/en") }
+  let(:node_route) { FactoryGirl.build(:node_route, node_class: Node, node_id: 12, locale: "en", path: "/en") }
 
-  describe ".node_class" do
-    it "returns ::Node" do
-      expect( described_class.node_class ).to eq ::Node
-    end
-  end
 
-  describe ".node_class_default_controller" do
+  describe ".default_controller" do
     context "when given node class inherits `ActionController::Base`" do
       it "returns undercored, stripped down controller class" do
-        expect(described_class.node_class_default_controller(HomePagesController)).to eq("home_pages")
+        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.node_class_default_controller(TextPage)).to eq("text_pages")
+        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
@@ -29,26 +195,27 @@ describe Releaf::Content::Route do
     end
 
     it "returns an array" do
-      expect(described_class.for(HomePage, 'foo').class).to eq(Array)
+      expect(described_class.for(Node, HomePage, 'foo')).to be_a Array
     end
 
     context "when databse doesn't exists" do
       it "returns an empty array" do
-        allow(described_class.node_class).to receive(:where).and_raise(ActiveRecord::NoDatabaseError.new("xxx"))
-        expect(described_class.for(HomePage, 'foo')).to eq([])
+        allow(Node).to receive(:where).and_raise(ActiveRecord::NoDatabaseError.new("xxx"))
+        expect(described_class.for(Node, HomePage, 'foo')).to eq([])
       end
     end
 
-    context "when releaf_nodes table doesn't exists" do
+    context "when node table doesn't exist" do
       it "returns an empty array" do
-        allow(described_class.node_class).to receive(:where).and_raise(ActiveRecord::StatementInvalid.new("xxx"))
-        expect(described_class.for(HomePage, 'foo')).to eq([])
+        allow(Node).to receive(:where).and_raise(ActiveRecord::StatementInvalid.new("xxx"))
+        expect(described_class.for(Node, HomePage, 'foo')).to eq([])
       end
     end
 
-    context "when releaf_nodes table exists" do
-      it "returns an array of Node::Route objects" do
-        result = described_class.for(HomePage, 'foo')
+    context "when node table exists" do
+      it "returns an array of Node::Route objects returned by build_route_object" do
+        expect(described_class).to receive(:build_route_object).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
@@ -56,30 +223,52 @@ describe Releaf::Content::Route do
       context "when node is not available" do
         it "does not include it in return" do
           allow_any_instance_of(Node).to receive(:available?).and_return(false)
-          expect(described_class.for(HomePage, 'foo')).to eq([])
+          expect(described_class.for(Node, HomePage, 'foo')).to eq([])
         end
       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
 
-  describe '#params' do
-    it "returns params for router method" do
-      expect(node_route.params("home#index")).to eq ['/en', {:node_id=>"12", :locale=>"en", :to=>"home#index"}]
+
+  describe ".build_route_object" do
+
+    let(:node) { create(:home_page_node, id: 23, locale: "lv", slug: "llvv") }
+    let(:controller) { described_class.default_controller( node.class ) }
+    let(:route) { described_class.build_route_object(node, controller) }
+
+    it "returns a route instance" do
+      expect(route).to be_a Releaf::Content::Route
     end
 
-    context "when :as given in args" do
-      context "when node has a locale" do
-        it "prepends locale to :as" do
-          expect(node_route.params("home#index", as: "home").last).to match hash_including(as: "en_home")
-        end
-      end
+    it "assigns node_class from given node" do
+      expect(route.node_class).to be Node
+    end
 
-      context "when node does not have a locale" do
-        it "doesn't modify :as option" do
-          node_route.locale = nil
-          expect(node_route.params("home#index", as: "home").last).to match hash_including(as: "home")
-        end
-      end
+    it "assigns node_id from given node" do
+      expect(route.node_id).to eq "23"
+    end
+
+    it "assigns path from given node" do
+      expect(route.path).to eq "/llvv"
+    end
+
+    it "assigns locale from given node" do
+      expect(route.locale).to eq "lv"
+    end
+
+    it "assigns default_controller from given argument" do
+      expect(route.default_controller).to be controller
+    end
+
+    it "assigns site from content routing configuration" do
+      allow( Releaf::Content).to receive(:routing).and_return('Node' => {site: 'some_site'})
+      expect(route.site).to eq 'some_site'
     end
   end
 end

data/spec/middleware/routes_reloader_spec.rb

@@ -15,34 +15,82 @@ describe Releaf::Content::RoutesReloader do
 
   describe "on each request" do
     it "compares latest updates" do
-      expect(described_class).to receive(:reload_if_expired)
+      expect(described_class).to receive(:reload_if_needed)
       request
     end
   end
 
-  describe ".reload_if_expired" do
-    context "when no nodes exists" do
+  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(Node).to receive(:updated_at).and_return(nil)
+        allow(described_class).to receive(:needs_reload?).and_return false
         expect(Rails.application).to_not receive(:reload_routes!)
-        described_class.reload_if_expired
+        described_class.reload_if_needed
       end
     end
 
-    context "when routes is up to date" do
-      it "does not reload routes" do
+  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(Rails.application).to_not receive(:reload_routes!)
-        described_class.reload_if_expired
+        expect(described_class.needs_reload?).to be true
       end
     end
 
-    context "when routes is outdated" do
-      it "reloads routes" do
-        allow(Node).to receive(:updated_at).and_return(Time.now)
-        expect(Rails.application).to receive(:reload_routes!)
-        described_class.reload_if_expired
+    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,142 +1,310 @@
 require "rails_helper"
 
 describe Releaf::Content::NodeMapper do
-  after(:all) do
-    # reset dummy app routes
+
+  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
 
-  before do
+  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!
-    @text_page = FactoryGirl.create(:text_page)
-    @lv_root = create(:home_page_node, name: "lv", locale: "lv", slug: 'lv')
-    @node = FactoryGirl.create(:node, slug: 'test-page', content: @text_page, parent: @lv_root)
   end
 
-  describe "#releaf_routes_for" do
+  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
 
-    describe "using current node path" do
-      example "using default controller " do
+      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
-          releaf_routes_for(TextPage) do |route|
+          node_routes_for(TextPage, controller: 'home_pages') do |route|
             get 'show'
-            delete :destroy
           end
         end
 
         expect(get: '/lv/test-page').to route_to(
-          "controller" => "text_pages",
+          "controller" => "home_pages",
           "action" => "show",
-          "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
 
-      example "overriding default controller" do
+    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
-          releaf_routes_for(TextPage, controller: 'home_pages') do |route|
-            get 'show'
-            delete :destroy
+          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" => "show",
+          "action" => "hide",
+          "node_class" => "Node",
           "node_id" => @node.id.to_s,
           "locale" => 'lv'
         )
       end
+    end
 
-      example "specifying different than default controller for route" do
+    context "when custom action is given in :to" do
+      it "draws the public website route using the action from :to" do
         routes.draw do
-          releaf_routes_for(TextPage, controller: 'doesnt_matter') do |route|
-            get 'home_pages#hide'
+          node_routes_for(TextPage) do |route|
+            get '' , to: '#list'
           end
         end
 
         expect(get: '/lv/test-page').to route_to(
-          "controller" => "home_pages",
-          "action" => "hide",
+          "controller" => "text_pages",
+          "action" => "list",
+          "node_class" => "Node",
           "node_id" => @node.id.to_s,
           "locale" => 'lv'
         )
+
       end
     end
 
-    describe "adding uri parts to node path" do
-      example "speciffying custom controller and action" do
+    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
-          releaf_routes_for(TextPage) do |route|
-            get ':my_id/list', to: 'home_pages#list'
+          node_routes_for(TextPage) do |route|
+            get '' , to: 'home_pages#list'
           end
         end
 
-        expect(get: '/lv/test-page/8888/list').to route_to(
+        expect(get: '/lv/test-page').to route_to(
           "controller" => "home_pages",
           "action" => "list",
+          "node_class" => "Node",
           "node_id" => @node.id.to_s,
-          "locale" => 'lv',
-          "my_id" => '8888'
+          "locale" => 'lv'
         )
       end
+    end
 
-      example "speciffying action" do
+    context "when additional params are given in route path" do
+      it "passes the params to the public website route" do
         routes.draw do
-          releaf_routes_for(TextPage) do |route|
-            get ':my_id/list', to: '#list'
+          node_routes_for(TextPage) do |route|
+            get ':some_id', to: "#view"
           end
         end
 
-        expect(get: '/lv/test-page/8888/list').to route_to(
+        expect(get: '/lv/test-page/8888').to route_to(
           "controller" => "text_pages",
-          "action" => "list",
+          "action" => "view",
+          "node_class" => "Node",
           "node_id" => @node.id.to_s,
           "locale" => 'lv',
-          "my_id" => '8888'
+          "some_id" => '8888'
         )
       end
+    end
 
-      example "speciffying action and overriding default controller" do
+    context "when custom path is given for route" do
+      it "uses the custom path for public website route" do
         routes.draw do
-          releaf_routes_for(TextPage, controller: 'home_pages') do |route|
-            get ':my_id/list', to: '#list'
+          node_routes_for(TextPage) do |route|
+            get 'home_pages#show', path: "#{route.path}/abc/:my_id"
           end
         end
 
-        expect(get: '/lv/test-page/8888/list').to route_to(
+        expect(get: '/lv/test-page/abc/333').to route_to(
           "controller" => "home_pages",
-          "action" => "list",
+          "action" => "show",
+          "node_class" => "Node",
           "node_id" => @node.id.to_s,
           "locale" => 'lv',
-          "my_id" => '8888'
+          "my_id" => '333'
         )
       end
+    end
 
-      example "speciffying custom path" do
+    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
-          releaf_routes_for(TextPage) do |route|
-            get 'home_pages#show', path: "#{route.path}/abc/:my_id"
+          node_routes_for(TextPage, node_class: "OtherSite::OtherNode") do |route|
+            get 'show'
           end
         end
 
-        expect(get: '/lv/test-page/abc/333').to route_to(
-          "controller" => "home_pages",
+        expect(get: '/lv/test-page').to route_to(
+          "controller" => "text_pages",
           "action" => "show",
-          "node_id" => @node.id.to_s,
+          "node_class" => "OtherSite::OtherNode",
+          "node_id" => @other_node.id.to_s,
           "locale" => 'lv',
-          "my_id" => '333'
+          "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