landable 1.13.1 → 1.13.2

data/spec/controllers/landable/api/categories_controller_spec.rb

@@ -1,44 +1,46 @@
 require 'spec_helper'
 
-module Landable::Api
-  describe CategoriesController, json: true do
-    routes { Landable::Engine.routes }
-
-    describe '#show' do
-      include_examples 'Authenticated API controller', :make_request
-
-      let(:category) { create :category }
-
-      def make_request(id = category.id)
-        get :show, id: id
+module Landable
+  module Api
+    describe CategoriesController, json: true do
+      routes { Landable::Engine.routes }
+
+      describe '#show' do
+        include_examples 'Authenticated API controller', :make_request
+
+        let(:category) { create :category }
+
+        def make_request(id = category.id)
+          get :show, id: id
+        end
+
+        it 'returns the selected category' do
+          make_request
+          response.status.should eq 200
+          last_json['category']['id'].should eq category.id
+        end
+
+        it '404s on page not found' do
+          make_request random_uuid
+          response.status.should eq 404
+        end
       end
 
-      it 'returns the selected category' do
-        make_request
-        response.status.should == 200
-        last_json['category']['id'].should == category.id
-      end
+      describe '#index' do
+        include_examples 'Authenticated API controller', :make_request
 
-      it '404s on page not found' do
-        make_request random_uuid
-        response.status.should == 404
-      end
-    end
-
-    describe '#index' do
-      include_examples 'Authenticated API controller', :make_request
-
-      def make_request
-        get :index
-      end
+        def make_request
+          get :index
+        end
 
-      it 'returns all categories' do
-        Landable::Category.delete_all
-        create_list :category, 5
+        it 'returns all categories' do
+          Landable::Category.delete_all
+          create_list :category, 5
 
-        make_request
-        response.status.should == 200
-        last_json['categories'].size.should == 5
+          make_request
+          response.status.should eq 200
+          last_json['categories'].size.should eq 5
+        end
       end
     end
   end

data/spec/controllers/landable/api/configuration_controller_spec.rb

@@ -1,20 +1,22 @@
 require 'spec_helper'
 
-module Landable::Api
-  describe ConfigurationsController, json: true do
-    routes { Landable::Engine.routes }
+module Landable
+  module Api
+    describe ConfigurationsController, json: true do
+      routes { Landable::Engine.routes }
 
-    describe '#show' do
-      include_examples 'Authenticated API controller', :make_request
+      describe '#show' do
+        include_examples 'Authenticated API controller', :make_request
 
-      def make_request
-        get :show
-      end
+        def make_request
+          get :show
+        end
 
-      it 'renders the page as JSON' do
-        make_request
-        # defined in Landable Dummy Initalizer
-        last_json['configurations'][0]['audit_flags'].should == %w(loans apr)
+        it 'renders the page as JSON' do
+          make_request
+          # defined in Landable Dummy Initalizer
+          last_json['configurations'][0]['audit_flags'].should eq %w(loans apr)
+        end
       end
     end
   end

data/spec/controllers/landable/api/directories_controller_spec.rb

@@ -1,55 +1,57 @@
 require 'spec_helper'
 
-module Landable::Api
-  describe DirectoriesController, json: true do
-    routes { Landable::Engine.routes }
-
-    describe '#index' do
-      include_examples 'Authenticated API controller', :make_request
-
-      def make_request(ids = nil)
-        get :index, ids: ids
-      end
-
-      def dirs
-        last_json['directories']
-      end
-
-      def dir(path)
-        dirs.find { |dir| dir['id'] == path }
-      end
-
-      def subdirs(path)
-        dir(path)['subdirectory_ids']
-      end
-
-      def pages(path)
-        dir(path)['page_ids']
-      end
-
-      it 'defaults to the root path' do
-        pages = ['/a', '/b/c', '/b/d'].map { |path| create :page, path: path }
-        make_request
-        response.status.should == 200
-
-        dirs.length.should == 1
-        dirs.first['id'].should == '/'
-
-        subdirs('/').length.should == 1
-        pages('/').length.should == 1
-      end
-
-      it 'returns multiple directory listings' do
-        pages = ['/a', '/b/c', '/b/d', '/c/e', '/c/f/g'].map { |path| create :page, path: path }
-        make_request ['/b', '/c']
-        response.status.should == 200
-        dirs.length.should == 2
-
-        pages('/b').length.should == 2
-        pages('/c').length.should == 1
-
-        subdirs('/b').length.should == 0
-        subdirs('/c').length.should == 1
+module Landable
+  module Api
+    describe DirectoriesController, json: true do
+      routes { Landable::Engine.routes }
+
+      describe '#index' do
+        include_examples 'Authenticated API controller', :make_request
+
+        def make_request(ids = nil)
+          get :index, ids: ids
+        end
+
+        def dirs
+          last_json['directories']
+        end
+
+        def dir(path)
+          dirs.find { |dir| dir['id'] == path }
+        end
+
+        def subdirs(path)
+          dir(path)['subdirectory_ids']
+        end
+
+        def pages(path)
+          dir(path)['page_ids']
+        end
+
+        it 'defaults to the root path' do
+          ['/a', '/b/c', '/b/d'].map { |path| create :page, path: path }
+          make_request
+          response.status.should eq 200
+
+          dirs.length.should eq 1
+          dirs.first['id'].should eq '/'
+
+          subdirs('/').length.should eq 1
+          pages('/').length.should eq 1
+        end
+
+        it 'returns multiple directory listings' do
+          ['/a', '/b/c', '/b/d', '/c/e', '/c/f/g'].map { |path| create :page, path: path }
+          make_request ['/b', '/c']
+          response.status.should eq 200
+          dirs.length.should eq 2
+
+          pages('/b').length.should eq 2
+          pages('/c').length.should eq 1
+
+          subdirs('/b').length.should eq 0
+          subdirs('/c').length.should eq 1
+        end
       end
     end
   end

data/spec/controllers/landable/api/page_revisions_controller_spec.rb

@@ -1,28 +1,30 @@
 require 'spec_helper'
 
-module Landable::Api
-  describe PageRevisionsController, json: true do
-    routes { Landable::Engine.routes }
+module Landable
+  module Api
+    describe PageRevisionsController, json: true do
+      routes { Landable::Engine.routes }
 
-    describe '#index' do
-      include_examples 'Authenticated API controller', :make_request
+      describe '#index' do
+        include_examples 'Authenticated API controller', :make_request
 
-      let(:page) { create :page }
+        let(:page) { create :page }
 
-      def make_request(page_id = page.id)
-        get :index, page_id: page_id
-      end
+        def make_request(page_id = page.id)
+          get :index, page_id: page_id
+        end
 
-      it "returns all of a page's revisions" do
-        page.publish! author: current_author
-        make_request
-        response.status.should == 200
-        last_json['page_revisions'].length.should == 1
-      end
+        it "returns all of a page's revisions" do
+          page.publish! author: current_author
+          make_request
+          response.status.should eq 200
+          last_json['page_revisions'].length.should eq 1
+        end
 
-      it "404s on page not found" do
-        make_request random_uuid
-        response.status.should == 404
+        it '404s on page not found' do
+          make_request random_uuid
+          response.status.should eq 404
+        end
       end
     end
   end

data/spec/controllers/landable/api/pages_controller_spec.rb

@@ -1,270 +1,271 @@
 require 'spec_helper'
 
-module Landable::Api
-  describe PagesController, json: true do
-    routes { Landable::Engine.routes }
+module Landable
+  module Api
+    describe PagesController, json: true do
+      routes { Landable::Engine.routes }
 
-    describe '#create' do
-      include_examples 'Authenticated API controller', :make_request
+      describe '#create' do
+        include_examples 'Authenticated API controller', :make_request
 
-      let(:default_params) do
-        { page: attributes_for(:page) }
-      end
-
-      let(:page) do
-        Landable::Page.where(path: default_params[:page][:path]).first
-      end
-
-      def make_request(params = {})
-        post :create, default_params.deep_merge(page: params)
-      end
-
-      context 'success' do
-        it 'returns 201 Created' do
-          make_request
-          response.status.should == 201
+        let(:default_params) do
+          { page: attributes_for(:page) }
         end
 
-        it 'returns header Location with the page URL' do
-          make_request
-          response.headers['Location'].should == page_url(page)
+        let(:page) do
+          Landable::Page.where(path: default_params[:page][:path]).first
         end
 
-        it 'renders the page as JSON' do
-          make_request
-          path, body = default_params[:page].values_at(:path, :body)
-          last_json['page'].should include('path' => path, 'body' => body)
+        def make_request(params = {})
+          post :create, default_params.deep_merge(page: params)
         end
-      end
 
-      context 'invalid' do
-        it 'returns 422 Unprocessable Entity' do
-          make_request path: nil
-          response.status.should == 422
+        context 'success' do
+          it 'returns 201 Created' do
+            make_request
+            response.status.should eq 201
+          end
+
+          it 'returns header Location with the page URL' do
+            make_request
+            response.headers['Location'].should eq page_url(page)
+          end
+
+          it 'renders the page as JSON' do
+            make_request
+            path, body = default_params[:page].values_at(:path, :body)
+            last_json['page'].should include('path' => path, 'body' => body)
+          end
         end
 
-        it 'includes the errors in the JSON response' do
-          make_request status_code: 302, redirect_url: nil
-          last_json['errors'].should have_key('redirect_url')
+        context 'invalid' do
+          it 'returns 422 Unprocessable Entity' do
+            make_request path: nil
+            response.status.should eq 422
+          end
+
+          it 'includes the errors in the JSON response' do
+            make_request status_code: 302, redirect_url: nil
+            last_json['errors'].should have_key('redirect_url')
+          end
         end
       end
-    end
 
-    describe '#index' do
-      include_examples 'Authenticated API controller', :make_request
+      describe '#index' do
+        include_examples 'Authenticated API controller', :make_request
 
-      let(:pages) { @pages ||= create_list(:page, 5) }
-      before(:each) { pages }
+        let(:pages) { @pages ||= create_list(:page, 5) }
+        before(:each) { pages }
 
-      def make_request(params = {})
-        get :index, params
-      end
+        def make_request(params = {})
+          get :index, params
+        end
 
-      it 'renders pages as json' do
-        make_request
-        last_json['pages'].collect { |p| p['id'] }.sort.should == pages.map(&:id).sort
-      end
+        it 'renders pages as json' do
+          make_request
+          last_json['pages'].collect { |p| p['id'] }.sort.should eq pages.map(&:id).sort
+        end
 
-      it 'filters pages according to requested ids' do
-        filtered_for_pages = pages[0..2]
+        it 'filters pages according to requested ids' do
+          filtered_for_pages = pages[0..2]
 
-        make_request ids: filtered_for_pages.map(&:id)
-        last_json['pages'].collect { |p| p['id'] }.sort.should == filtered_for_pages.map(&:id).sort
-      end
+          make_request ids: filtered_for_pages.map(&:id)
+          last_json['pages'].collect { |p| p['id'] }.sort.should eq filtered_for_pages.map(&:id).sort
+        end
 
-      describe 'search' do
-        describe 'by path' do
-          before(:each) do
-            ['/foo', '/foo/bar', '/foo/bar/baz', '/bar'].each do |path|
-              create :page, path: path
+        describe 'search' do
+          describe 'by path' do
+            before(:each) do
+              ['/foo', '/foo/bar', '/foo/bar/baz', '/bar'].each do |path|
+                create :page, path: path
+              end
             end
-          end
 
-          it 'filters by starting path fragment' do
-            make_request search: {path: '/foo/ba'}
-            last_json['pages'].collect { |p| p['path'] }.should == ['/foo/bar', '/foo/bar/baz']
-          end
+            it 'filters by starting path fragment' do
+              make_request search: { path: '/foo/ba' }
+              last_json['pages'].collect { |p| p['path'] }.should eq ['/foo/bar', '/foo/bar/baz']
+            end
 
-          it 'matches all paths with the search term in them' do
-            make_request search: {path: 'ba'}
-            last_json['pages'].collect { |p| p['path'] }.should == ['/bar', '/foo/bar', '/foo/bar/baz']
+            it 'matches all paths with the search term in them' do
+              make_request search: { path: 'ba' }
+              last_json['pages'].collect { |p| p['path'] }.should eq ['/bar', '/foo/bar', '/foo/bar/baz']
+            end
           end
         end
-      end
 
-      it 'only include 100 results, and include the total result count as meta data' do
-        create_list :page, (100 - pages.size)
-        make_request search: {path: '/'}
+        it 'only include 100 results, and include the total result count as meta data' do
+          create_list :page, (100 - pages.size)
+          make_request search: { path: '/' }
 
-        last_json['pages'].size.should == 100
-        last_json['meta']['search']['total_results'].should == 100
+          last_json['pages'].size.should eq 100
+          last_json['meta']['search']['total_results'].should eq 100
+        end
       end
-    end
 
-    describe '#show' do
-      include_examples 'Authenticated API controller', :make_request
-      let(:page) { @page || create(:page) }
+      describe '#show' do
+        include_examples 'Authenticated API controller', :make_request
+        let(:page) { @page || create(:page) }
 
-      def make_request(id = page.id)
-        get :show, id: id
-      end
-
-      it 'renders the page as JSON' do
-        make_request
-        last_json['page']['body'].should == page.body
-      end
+        def make_request(id = page.id)
+          get :show, id: id
+        end
 
-      it 'includes an empty meta_tags hash instead of a null' do
-        page.update_attributes meta_tags: nil
-        make_request
-        last_json['page']['meta_tags'].should == {}
-      end
+        it 'renders the page as JSON' do
+          make_request
+          last_json['page']['body'].should eq page.body
+        end
 
+        it 'includes an empty meta_tags hash instead of a null' do
+          page.update_attributes meta_tags: nil
+          make_request
+          last_json['page']['meta_tags'].should eq({})
+        end
 
-      context 'no such page' do
-        it 'returns 404' do
-          make_request random_uuid
-          response.status.should == 404
+        context 'no such page' do
+          it 'returns 404' do
+            make_request random_uuid
+            response.status.should eq 404
+          end
         end
       end
-    end
-
-    describe '#update' do
-      include_examples 'Authenticated API controller', :make_request
 
-      let(:page) { @page || create(:page) }
-      let(:default_params) do
-        { page: { body: 'Different body content' } }
-      end
+      describe '#update' do
+        include_examples 'Authenticated API controller', :make_request
 
-      def make_request(changes = {})
-        id = changes.delete(:id) || page.id
-        patch :update, default_params.deep_merge(id: id, page: changes)
-      end
+        let(:page) { @page || create(:page) }
+        let(:default_params) do
+          { page: { body: 'Different body content' } }
+        end
 
-      it 'saves the changes' do
-        make_request body: 'updated body!'
-        response.status.should == 200
-        page.reload.body.should == 'updated body!'
-        page.reload.updated_by_author.should == current_author
-      end
+        def make_request(changes = {})
+          id = changes.delete(:id) || page.id
+          patch :update, default_params.deep_merge(id: id, page: changes)
+        end
 
-      it 'renders the page as JSON' do
-        make_request body: 'also updated'
-        last_json['page']['body'].should == 'also updated'
-      end
+        it 'saves the changes' do
+          make_request body: 'updated body!'
+          response.status.should eq 200
+          page.reload.body.should eq 'updated body!'
+          page.reload.updated_by_author.should eq current_author
+        end
 
-      context 'invalid' do
-        it 'returns 422 Unprocessable Entity' do
-          make_request path: nil
-          response.status.should == 422
+        it 'renders the page as JSON' do
+          make_request body: 'also updated'
+          last_json['page']['body'].should eq 'also updated'
         end
 
-        it 'includes the errors in the JSON response' do
-          make_request status_code: 302, redirect_url: nil
+        context 'invalid' do
+          it 'returns 422 Unprocessable Entity' do
+            make_request path: nil
+            response.status.should eq 422
+          end
+
+          it 'includes the errors in the JSON response' do
+            make_request status_code: 302, redirect_url: nil
+          end
         end
-      end
 
-      context 'no such page' do
-        it 'returns 404' do
-          make_request id: random_uuid
-          response.status.should == 404
+        context 'no such page' do
+          it 'returns 404' do
+            make_request id: random_uuid
+            response.status.should eq 404
+          end
         end
-      end
 
-      context 'stale page' do
-        it 'throws error when stale body update' do
-          page.save!
-          page1 = Landable::Page.first
-          page2 = Landable::Page.first
+        context 'stale page' do
+          it 'throws error when stale body update' do
+            page.save!
+            page1 = Landable::Page.first
+            page2 = Landable::Page.first
 
-          page1.body = "duh"
-          expect{ page1.save! }.to_not raise_error
-          page2.body = "something"
-          expect{ page2.save! }.to raise_error(ActiveRecord::StaleObjectError)
-        end
+            page1.body = 'duh'
+            expect { page1.save! }.to_not raise_error
+            page2.body = 'something'
+            expect { page2.save! }.to raise_error(ActiveRecord::StaleObjectError)
+          end
 
-        it 'throws error when stale meta_tags update' do
-          page.save!
-          page1 = Landable::Page.first
-          page2 = Landable::Page.first
+          it 'throws error when stale meta_tags update' do
+            page.save!
+            page1 = Landable::Page.first
+            page2 = Landable::Page.first
 
-          page1.meta_tags = "duh"
-          expect{ page1.save! }.to_not raise_error
-          page2.meta_tags = "something"
-          expect{ page2.save! }.to raise_error(ActiveRecord::StaleObjectError)
-        end
+            page1.meta_tags = 'duh'
+            expect { page1.save! }.to_not raise_error
+            page2.meta_tags = 'something'
+            expect { page2.save! }.to raise_error(ActiveRecord::StaleObjectError)
+          end
 
-        it 'throws error when stale path update' do
-          page.save!
-          page1 = Landable::Page.first
-          page2 = Landable::Page.first
+          it 'throws error when stale path update' do
+            page.save!
+            page1 = Landable::Page.first
+            page2 = Landable::Page.first
 
-          page1.body = "duh"
-          expect{ page1.save! }.to_not raise_error
-          page2.body = "something"
-          expect{ page2.save! }.to raise_error(ActiveRecord::StaleObjectError)
-        end
+            page1.body = 'duh'
+            expect { page1.save! }.to_not raise_error
+            page2.body = 'something'
+            expect { page2.save! }.to raise_error(ActiveRecord::StaleObjectError)
+          end
 
-        it 'throws error when stale multi-column update' do
-          page.save!
-          page1 = Landable::Page.first
-          page2 = Landable::Page.first
-          page1.body = "duh"
-          expect{ page1.save! }.to_not raise_error
-          page2.body = "something"
-          expect{ page2.save! }.to raise_error(ActiveRecord::StaleObjectError)
+          it 'throws error when stale multi-column update' do
+            page.save!
+            page1 = Landable::Page.first
+            page2 = Landable::Page.first
+            page1.body = 'duh'
+            expect { page1.save! }.to_not raise_error
+            page2.body = 'something'
+            expect { page2.save! }.to raise_error(ActiveRecord::StaleObjectError)
+          end
         end
       end
-    end
 
-    describe '#preview', json: false do
-      include_examples 'Authenticated API controller', :make_request
-      render_views
+      describe '#preview', json: false do
+        include_examples 'Authenticated API controller', :make_request
+        render_views
 
-      let(:theme) { create :theme, body: '<html><head>{% head_content %}</head><body>Theme content; page content: {{body}}</body></html>' }
+        let(:theme) { create :theme, body: '<html><head>{% head_content %}</head><body>Theme content; page content: {{body}}</body></html>' }
 
-      before do
-        request.env['HTTP_ACCEPT'] = 'text/html'
-      end
+        before do
+          request.env['HTTP_ACCEPT'] = 'text/html'
+        end
 
-      def make_request(attributes = attributes_for(:page, theme_id: theme.id))
-        post :preview, page: attributes
-      end
+        def make_request(attributes = attributes_for(:page, theme_id: theme.id))
+          post :preview, page: attributes
+        end
 
-      it 'renders JSON' do
-        request.env['HTTP_ACCEPT'] = 'application/json'
-        make_request
-        response.status.should == 200
-        last_json['page']['preview'].should be_present
-      end
+        it 'renders JSON' do
+          request.env['HTTP_ACCEPT'] = 'application/json'
+          make_request
+          response.status.should eq 200
+          last_json['page']['preview'].should be_present
+        end
 
-      it 'renders the layout without content if the body is not present' do
-        request.env['HTTP_ACCEPT'] = 'application/json'
-        make_request attributes_for(:page, body: nil, theme_id: theme.id)
-        response.status.should == 200
-        last_json['page']['preview'].should include('Theme content')
-      end
+        it 'renders the layout without content if the body is not present' do
+          request.env['HTTP_ACCEPT'] = 'application/json'
+          make_request attributes_for(:page, body: nil, theme_id: theme.id)
+          response.status.should eq 200
+          last_json['page']['preview'].should include('Theme content')
+        end
 
-      it 'renders without a layout if no theme is present' do
-        request.env['HTTP_ACCEPT'] = 'application/json'
-        make_request attributes_for(:page, body: 'raw content', theme_id: nil)
-        response.status.should == 200
-        last_json['page']['preview'].should include('raw content')
-      end
+        it 'renders without a layout if no theme is present' do
+          request.env['HTTP_ACCEPT'] = 'application/json'
+          make_request attributes_for(:page, body: 'raw content', theme_id: nil)
+          response.status.should eq 200
+          last_json['page']['preview'].should include('raw content')
+        end
 
-      it 'renders 30x pages with a link to the real thing' do
-        request.env['HTTP_ACCEPT'] = 'application/json'
-        make_request attributes_for(:page, :redirect, body: 'still here', theme_id: theme.id)
-        response.status.should == 200
-        last_json['page']['preview'].should include('301')
-      end
+        it 'renders 30x pages with a link to the real thing' do
+          request.env['HTTP_ACCEPT'] = 'application/json'
+          make_request attributes_for(:page, :redirect, body: 'still here', theme_id: theme.id)
+          response.status.should eq 200
+          last_json['page']['preview'].should include('301')
+        end
 
-      it 'renders 404 pages as if they were 200s' do
-        request.env['HTTP_ACCEPT'] = 'application/json'
-        make_request attributes_for(:page, :gone, body: 'still here', theme_id: theme.id)
-        response.status.should == 200
-        last_json['page']['preview'].should match(/still here/)
+        it 'renders 404 pages as if they were 200s' do
+          request.env['HTTP_ACCEPT'] = 'application/json'
+          make_request attributes_for(:page, :gone, body: 'still here', theme_id: theme.id)
+          response.status.should eq 200
+          last_json['page']['preview'].should match(/still here/)
+        end
       end
     end
   end