landable 1.13.1 → 1.13.2

data/spec/lib/landable/tracking_spec.rb

@@ -4,28 +4,28 @@ module Landable
   describe Landable::Traffic::Tracker do
     let(:referer)    { '/something/ valid' }
     let(:user_agent) { 'type' }
-    let(:format)     { double('format', { html?: true}) }
-    let(:request)    { double('request', { query_parameters: {}, user_agent: user_agent, referer: referer, format: format }) }
-    let(:controller) { double('controller', { request: request }) }
+    let(:format)     { double('format', html?: true) }
+    let(:request)    { double('request', query_parameters: {}, user_agent: user_agent, referer: referer, format: format) }
+    let(:controller) { double('controller', request: request) }
 
-    describe "#for" do
+    describe '#for' do
       it 'should default to UserTracker if user_agent does not exist' do
         Landable::Traffic::Tracker.for(controller).should be_a(Landable::Traffic::UserTracker)
       end
 
       it 'should create the appropriate type of tracker based on user_agent' do
-        type = double('type', { user_agent_type: "Scan" })
+        type = double('type', user_agent_type: 'Scan')
         fake_agent = {}
-        fake_agent["type"] = type
-        stub_const("Landable::Traffic::UserAgent", fake_agent)
+        fake_agent['type'] = type
+        stub_const('Landable::Traffic::UserAgent', fake_agent)
 
         Landable::Traffic::Tracker.for(controller).should be_a(Landable::Traffic::ScanTracker)
       end
 
       it 'should not bark if user_agent is nil' do
         user_agent = nil
-        request = double('request', { query_parameters: {}, user_agent: user_agent, format: format })
-        controller = double('controller', { request: request })
+        request = double('request', query_parameters: {}, user_agent: user_agent, format: format)
+        controller = double('controller', request: request)
 
         Landable::Traffic::Tracker.for(controller).should be_a(Landable::Traffic::UserTracker)
       end
@@ -33,31 +33,31 @@ module Landable
       it 'should set type to noop when non-html content' do
         user_agent = nil
         Landable.configuration.stub(:traffic_enabled).and_return(:html)
-        format = double('format', { html?: false })
-        request = double('request', { query_parameters: {}, user_agent: user_agent, format: format })
-        controller = double('controller', { request: request })
+        format = double('format', html?: false)
+        request = double('request', query_parameters: {}, user_agent: user_agent, format: format)
+        controller = double('controller', request: request)
 
         Landable::Traffic::Tracker.for(controller).should be_a(Landable::Traffic::NoopTracker)
       end
 
       it 'should allow non-html content if config says so' do
-        format = double('format', { html?: false})
-        request = double('request', { query_parameters: {}, user_agent: user_agent, format: format })
-        controller = double('controller', { request: request })
+        format = double('format', html?: false)
+        request = double('request', query_parameters: {}, user_agent: user_agent, format: format)
+        controller = double('controller', request: request)
 
         Landable::Traffic::Tracker.for(controller).should be_a(Landable::Traffic::UserTracker)
       end
     end
 
     context 'referer' do
-      let(:visit_referer) { double('visit_referer', { url: 'http://www.fakedomain.yes/mypath', uri: URI("http://www.fakedomain.yes/mypath") }) }
-      let(:visit) { double('visit', { referer: visit_referer }) }
+      let(:visit_referer) { double('visit_referer', url: 'http://www.fakedomain.yes/mypath', uri: URI('http://www.fakedomain.yes/mypath')) }
+      let(:visit) { double('visit', referer: visit_referer) }
 
       describe '#referer_uri' do
         it 'should encode special characters' do
           tracker = Landable::Traffic::UserTracker.new controller
 
-          tracker.send(:referer_uri).path.should == "/something/%20valid"
+          tracker.send(:referer_uri).path.should eq '/something/%20valid'
         end
       end
 
@@ -66,7 +66,7 @@ module Landable
           tracker = Landable::Traffic::UserTracker.new controller
           tracker.stub(:visit) { visit }
 
-          tracker.send(:visit_referer_domain).should == 'www.fakedomain.yes'
+          tracker.send(:visit_referer_domain).should eq 'www.fakedomain.yes'
         end
       end
 
@@ -75,7 +75,7 @@ module Landable
           tracker = Landable::Traffic::UserTracker.new controller
           tracker.stub(:visit) { visit }
 
-          tracker.send(:visit_referer_path).should == '/mypath'
+          tracker.send(:visit_referer_path).should eq '/mypath'
         end
       end
 
@@ -84,7 +84,7 @@ module Landable
           tracker = Landable::Traffic::UserTracker.new controller
           tracker.stub(:visit) { visit }
 
-          tracker.send(:visit_referer_url).should == 'http://www.fakedomain.yes/mypath'
+          tracker.send(:visit_referer_url).should eq 'http://www.fakedomain.yes/mypath'
         end
       end
     end
@@ -98,7 +98,7 @@ module Landable
             tracker = Landable::Traffic::UserTracker.new controller
             tracker.stub(:user_agent) { user_agent }
 
-            tracker.send(:get_user_agent).should == user_agent
+            tracker.send(:get_user_agent).should eq user_agent
           end
         end
 
@@ -114,8 +114,8 @@ module Landable
     end
 
     context 'no referer' do
-      let(:referer) { double('referer', { path: nil}) }
-      let(:visit) { double('visit', { referer: nil }) }
+      let(:referer) { double('referer', path: nil) }
+      let(:visit) { double('visit', referer: nil) }
 
       describe '#referer_uri_path' do
         it 'should return empty string' do
@@ -131,7 +131,7 @@ module Landable
           tracker = Landable::Traffic::UserTracker.new controller
           tracker.stub(:visit) { visit }
 
-          tracker.send(:visit_referer_domain).should == nil
+          tracker.send(:visit_referer_domain).should.nil?
         end
       end
 
@@ -140,7 +140,7 @@ module Landable
           tracker = Landable::Traffic::UserTracker.new controller
           tracker.stub(:visit) { visit }
 
-          tracker.send(:visit_referer_path).should == nil
+          tracker.send(:visit_referer_path).should.nil?
         end
       end
 
@@ -149,11 +149,9 @@ module Landable
           tracker = Landable::Traffic::UserTracker.new controller
           tracker.stub(:visit) { visit }
 
-          tracker.send(:visit_referer_url).should == nil
+          tracker.send(:visit_referer_url).should.nil?
         end
       end
     end
-
   end
-
 end

data/spec/lib/landable/traffic_spec.rb

@@ -1,45 +1,41 @@
 require 'spec_helper'
- 
-module Landable
 
+module Landable
   class TrackError < StandardError
   end
 
   class SaveError < StandardError
   end
- 
-describe Traffic, type: :controller do
- 
-  controller(ApplicationController) do
-    include Landable::Traffic
-    prepend_around_action :track_with_landable!
-
-    def my_method
-      render nothing: true
+
+  describe Traffic, type: :controller do
+    controller(ApplicationController) do
+      include Landable::Traffic
+      prepend_around_action :track_with_landable!
+
+      def my_method
+        render nothing: true
+      end
+    end
+
+    before do
+      routes.draw do
+        get 'my_method' => 'anonymous#my_method'
+      end
     end
-  end
-  
-  before do
-   routes.draw do
-     get 'my_method' => 'anonymous#my_method'
-   end
-  end
- 
-  describe 'track_with_landable!' do
-   it 'should log errors' do
-    tracker = double('tracker')
 
-    Landable::Traffic::Tracker.stub(:for).and_return(tracker)
-    tracker.stub(:track).and_raise(TrackError)
-    tracker.stub(:save).and_raise(SaveError)
+    describe 'track_with_landable!' do
+      it 'should log errors' do
+        tracker = double('tracker')
 
-    controller.should_receive(:newrelic_notice_error) { |error| error.should be_an_instance_of TrackError }
-    controller.should_receive(:newrelic_notice_error) { |error| error.should be_an_instance_of SaveError }
+        Landable::Traffic::Tracker.stub(:for).and_return(tracker)
+        tracker.stub(:track).and_raise(TrackError)
+        tracker.stub(:save).and_raise(SaveError)
 
-    get :my_method
-   end
+        controller.should_receive(:newrelic_notice_error) { |error| error.should be_an_instance_of TrackError }
+        controller.should_receive(:newrelic_notice_error) { |error| error.should be_an_instance_of SaveError }
+
+        get :my_method
+      end
+    end
   end
- 
- end
- 
-end
+end

data/spec/models/landable/access_token_spec.rb

@@ -4,7 +4,7 @@ module Landable
   describe AccessToken do
     it { should_not have_valid(:author_id).when(nil) }
 
-    it "generates an expiration timestamp before creation" do
+    it 'generates an expiration timestamp before creation' do
       author = create :author
       token  = AccessToken.create!(author: author)
       expect(token.expires_at).not_to be_nil

data/spec/models/landable/asset_spec.rb

@@ -19,30 +19,28 @@ describe Landable::Asset do
   it { should_not have_valid(:mime_type).when(nil, '') }
   it { should_not have_valid(:file_size).when(nil, 1.5) }
 
-  it "stores an md5sum of its contents" do
+  it 'stores an md5sum of its contents' do
     asset = build(:asset, data: png)
-    expect {
-      asset.valid?
-    }.to change { asset.md5sum }.from(nil).to('0f62ef551dbebcdb7379401528b6115c')
+    expect { asset.valid? }.to change { asset.md5sum }.from(nil).to('0f62ef551dbebcdb7379401528b6115c')
   end
 
-  it "requires the md5sum to be unique" do
-    orig = create(:asset, data: png)
+  it 'requires the md5sum to be unique' do
+    create(:asset, data: png)
     dupe = build(:asset, data: png)
 
     expect(dupe).not_to be_valid
     expect(dupe.errors_on(:md5sum)).to eql(['has already been taken'])
   end
 
-  it "provides access to the other asset with the same contents" do
+  it 'provides access to the other asset with the same contents' do
     orig = create(:asset, data: png)
     dupe = build(:asset, data: png)
     expect(dupe.duplicate_of).to eql(orig)
   end
 
-  it "returns a list of pages using the asset" do
-    page = create(:page, body: "panda.png", path: "/testing/assets")
-    asset = create(:asset, data:pdf, name: "panda.png")
-    asset.associated_pages.should eq(["/testing/assets"])
+  it 'returns a list of pages using the asset' do
+    create(:page, body: 'panda.png', path: '/testing/assets')
+    asset = create(:asset, data: pdf, name: 'panda.png')
+    asset.associated_pages.should eq(['/testing/assets'])
   end
 end

data/spec/models/landable/directory_spec.rb

@@ -10,27 +10,27 @@ module Landable
 
     it 'knows its own path' do
       dir = Directory.listing '/'
-      dir.path.should == '/'
+      dir.path.should eq '/'
     end
 
     it 'lists immediate children' do
       stub_contents
 
       dir = Directory.listing '/'
-      dir.subdirectories.map(&:path).should == ['/aff', '/seo']
-      dir.pages.map(&:path).should == ['/quux']
+      dir.subdirectories.map(&:path).should eq ['/aff', '/seo']
+      dir.pages.map(&:path).should eq ['/quux']
 
       dir = Directory.listing '/aff'
-      dir.subdirectories.map(&:path).should == ['/aff/deeply']
-      dir.pages.map(&:path).should == ['/aff/bar', '/aff/deeply_nested']
+      dir.subdirectories.map(&:path).should eq ['/aff/deeply']
+      dir.pages.map(&:path).should eq ['/aff/bar', '/aff/deeply_nested']
 
       dir = Directory.listing '/seo'
       dir.subdirectories.should be_empty
-      dir.pages.map(&:path).should == ['/seo/baz', '/seo/foo']
+      dir.pages.map(&:path).should eq ['/seo/baz', '/seo/foo']
 
       dir = Directory.listing '/aff/deeply'
       dir.subdirectories.should be_empty
-      dir.pages.map(&:path).should == ['/aff/deeply/nested']
+      dir.pages.map(&:path).should eq ['/aff/deeply/nested']
     end
   end
 end

data/spec/models/landable/page/errors_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 
 module Landable
   describe Page do
-
     describe '#error?' do
       describe 'yep' do
         specify { build(:page, status_code: 418).should be_error }
@@ -16,7 +15,7 @@ module Landable
     end
 
     describe '#error' do
-      def error_for code
+      def error_for(code)
         build(:page, status_code: code).error
       end
 
@@ -25,6 +24,5 @@ module Landable
       specify { error_for(200).should be_nil }
       specify { error_for(302).should be_nil }
     end
-
   end
 end

data/spec/models/landable/page_revision_spec.rb

@@ -7,8 +7,8 @@ module Landable
 
     let(:page) do
       create(:page, path: '/test/path', title: 'title', status_code: 200,
-             body: 'body', redirect_url: 'http://www.redirect.com/here',
-             meta_tags: {'key'=>'value'}, head_content: 'head_content')
+                    body: 'body', redirect_url: 'http://www.redirect.com/here',
+                    meta_tags: { 'key' => 'value' }, head_content: 'head_content')
     end
 
     let(:revision) do
@@ -18,12 +18,12 @@ module Landable
     it { should be_a HasAssets }
 
     it 'defaults to is_published = true' do
-      PageRevision.new.is_published.should == true
+      PageRevision.new.is_published.should eq true
     end
 
     describe '#page_id=' do
       it 'should set page revision attributes matching the page' do
-        attrs = revision.attributes.except('page_revision_id','ordinal','notes','is_minor','is_published','author_id','created_at','updated_at', 'page_id', 'audit_flags')
+        attrs = revision.attributes.except('page_revision_id', 'ordinal', 'notes', 'is_minor', 'is_published', 'author_id', 'created_at', 'updated_at', 'page_id', 'audit_flags')
         attrs.should include(page.attributes.except(*PageRevision.ignored_page_attributes))
       end
     end
@@ -33,15 +33,15 @@ module Landable
         snapshot = revision.snapshot
         snapshot.should be_new_record
         snapshot.should be_an_instance_of Page
-        snapshot.title.should        == page.title
-        snapshot.path.should         == page.path
-        snapshot.head_content.should == page.head_content
-        snapshot.meta_tags.should    == page.meta_tags
-        snapshot.body.should         == page.body
-        snapshot.redirect_url.should == page.redirect_url
-        snapshot.category_id.should  == page.category_id
-        snapshot.theme_id.should     == page.theme_id
-        snapshot.status_code.should  == page.status_code
+        snapshot.title.should eq page.title
+        snapshot.path.should eq page.path
+        snapshot.head_content.should eq page.head_content
+        snapshot.meta_tags.should eq page.meta_tags
+        snapshot.body.should eq page.body
+        snapshot.redirect_url.should eq page.redirect_url
+        snapshot.category_id.should eq page.category_id
+        snapshot.theme_id.should eq page.theme_id
+        snapshot.status_code.should eq page.status_code
       end
     end
 
@@ -51,9 +51,9 @@ module Landable
         revision.page_id = page.id
         revision.author_id = author.id
         revision.unpublish!
-        revision.is_published.should == false
+        revision.is_published.should eq false
         revision.publish!
-        revision.is_published.should == true
+        revision.is_published.should eq true
       end
     end
 
@@ -62,20 +62,20 @@ module Landable
         template = create :template, name: 'Basic'
         old = PageRevision.create!(page_id: page.id, author_id: author.id, is_published: true)
         new_author = create :author
-        old.republish!({author_id: new_author.id, notes: "Great Note", template: template.name })
+        old.republish!(author_id: new_author.id, notes: 'Great Note', template: template.name)
 
         new_record = PageRevision.order('created_at ASC').last
-        new_record.author_id.should == new_author.id
-        new_record.notes.should == "Publishing update for template #{template.name}: Great Note"
-        new_record.page_id.should == page.id
-        new_record.body.should == page.body
+        new_record.author_id.should eq new_author.id
+        new_record.notes.should eq "Publishing update for template #{template.name}: Great Note"
+        new_record.page_id.should eq page.id
+        new_record.body.should eq page.body
       end
     end
 
     describe '#preview_path' do
       it 'should return the preview path' do
         revision.should_receive(:public_preview_page_revision_path) { 'foo' }
-        revision.preview_path.should == 'foo'
+        revision.preview_path.should eq 'foo'
       end
     end
 
@@ -83,7 +83,7 @@ module Landable
       it 'should return the preview url' do
         Landable.configuration.stub(:public_host) { 'foo' }
         revision.should_receive(:public_preview_page_revision_url).with(revision, host: 'foo') { 'bar' }
-        revision.preview_url.should == 'bar'
+        revision.preview_url.should eq 'bar'
       end
     end
 
@@ -132,7 +132,7 @@ module Landable
           screenshot = double('screenshot', url: 'foobar')
 
           revision.stub(:screenshot) { screenshot }
-          revision.screenshot_url.should == screenshot.url
+          revision.screenshot_url.should eq screenshot.url
         end
       end
 
@@ -143,6 +143,5 @@ module Landable
         end
       end
     end
-
   end
 end