landable 1.7.0

data/spec/lib/landable/partial_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+module Landable
+  describe Partial do
+    # Defined in spec/dummy/app/views/partials/...
+    let(:partials) { ['partials/test', 'partials/foobazz'] }
+
+    describe '#to_template' do
+      context 'with configured partials' do
+        before :each do
+          Landable.configuration.stub(:partials_to_templates).and_return(partials)
+          Partial.all.map(&:to_template)
+
+          @foobazz = Landable::Template.where(file: 'partials/foobazz').first
+          @test    = Landable::Template.where(file: 'partials/test').first
+        end
+
+        it 'creates the templates' do
+          Landable::Template.all.should include(@foobazz)
+          Landable::Template.all.should include(@test)
+        end
+
+        context 'the templates' do
+          it 'populates a name by humanizing the file' do
+            @foobazz.name.should == 'Partials Foobazz'
+            @test.name.should    == 'Partials Test'
+          end
+
+          it 'populates a description' do
+            @foobazz.description.should == 'Defined in Source Code at partials/foobazz'
+            @test.description.should    == 'Defined in Source Code at partials/test'
+          end
+
+          it 'are not editable' do
+            @foobazz.editable.should == false
+            @test.editable.should    == false
+          end
+
+          it 'are not layouts' do
+            @foobazz.is_layout.should == false
+            @test.is_layout.should    == false
+          end
+
+          it 'popules a thumbnail_url' do
+            @foobazz.thumbnail_url.should == 'http://placehold.it/300x200'
+            @test.thumbnail_url.should    == 'http://placehold.it/300x200'
+          end
+
+          it 'populates a body' do
+            @foobazz.body.should == ''
+            @test.body.should    == ''
+          end
+
+          it 'references the flle path' do
+            @foobazz.file.should == 'partials/foobazz'
+            @test.file.should    == 'partials/test'
+          end
+
+          it 'creates a slug by underscoring the name' do
+            @test.slug.should    == 'partials_test'
+            @foobazz.slug.should == 'partials_foobazz'
+          end
+        end
+      end
+    end
+
+    describe '::files' do
+      it 'returns an array of files' do
+        Landable.configuration.stub(:partials_to_templates).and_return(partials)
+
+        Partial.files.count.should == 2
+        Partial.files.should include('partials/test', 'partials/foobazz')
+      end
+
+      context 'with no configured partials' do
+        it 'has no files' do
+          Landable.configuration.stub(:partials_to_templates).and_return([])
+
+          Partial.files.should == []
+        end
+      end
+    end
+  end
+end

data/spec/lib/landable/tracking_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+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 }) }
+
+    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" }) 
+        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 })
+
+        Landable::Traffic::Tracker.for(controller).should be_a(Landable::Traffic::UserTracker)
+      end
+
+      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 })
+
+        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 })
+
+        Landable::Traffic::Tracker.for(controller).should be_a(Landable::Traffic::UserTracker)
+      end
+    end
+
+    describe '#referer_uri' do
+      it 'should encode special characters' do
+        tracker = Landable::Traffic::UserTracker.new controller
+
+        tracker.send(:referer_uri).path.should == "/something/%20valid"
+      end
+    end
+
+  end
+
+end

data/spec/lib/landable/traffic_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+ 
+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
+    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)
+
+    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

data/spec/models/landable/access_token_spec.rb

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

data/spec/models/landable/asset_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Landable::Asset do
+  def asset_fixture(name)
+    File.expand_path("../../../fixtures/assets/#{name}", __FILE__)
+  end
+
+  let(:png) { File.open(asset_fixture('panda.png')) }
+  let(:pdf) { File.open(asset_fixture('small.pdf')) }
+
+  after do
+    png.close
+    pdf.close
+  end
+
+  it { should_not have_valid(:name).when(nil, '', 'No Spaces') }
+  it { should_not have_valid(:author).when(nil) }
+  it { should_not have_valid(:md5sum).when(nil, '') }
+  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
+    asset = build(:asset, data: png)
+    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)
+    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
+    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"])
+  end
+end

data/spec/models/landable/directory_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module Landable
+  describe Directory, '.listing' do
+    def stub_contents
+      ['/seo/foo', '/aff/bar', '/seo/baz', '/aff/deeply/nested', '/aff/deeply_nested', '/quux'].each do |path|
+        create :page, path: path
+      end
+    end
+
+    it 'knows its own path' do
+      dir = Directory.listing '/'
+      dir.path.should == '/'
+    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 = Directory.listing '/aff'
+      dir.subdirectories.map(&:path).should == ['/aff/deeply']
+      dir.pages.map(&:path).should == ['/aff/bar', '/aff/deeply_nested']
+
+      dir = Directory.listing '/seo'
+      dir.subdirectories.should be_empty
+      dir.pages.map(&:path).should == ['/seo/baz', '/seo/foo']
+
+      dir = Directory.listing '/aff/deeply'
+      dir.subdirectories.should be_empty
+      dir.pages.map(&:path).should == ['/aff/deeply/nested']
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+module Landable
+  describe Page do
+
+    describe '#error?' do
+      describe 'yep' do
+        specify { build(:page, status_code: 418).should be_error }
+        specify { build(:page, status_code: 522).should be_error }
+      end
+
+      describe 'nope' do
+        specify { build(:page, status_code: 311).should_not be_error }
+        specify { build(:page, status_code: 200).should_not be_error }
+      end
+    end
+
+    describe '#error' do
+      def error_for code
+        build(:page, status_code: code).error
+      end
+
+      specify { error_for(410).should be_a Landable::Page::GoneError }
+      specify { error_for(555).should be_a Landable::Error }
+      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

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+module Landable
+  describe PageRevision do
+    let(:author) { create(:author) }
+    let(:asset)  { create(:asset)  }
+
+    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')
+    end
+
+    let(:revision) do
+      PageRevision.new page_id: page.id, author_id: author.id
+    end
+
+    it { should be_a HasAssets }
+
+    it 'defaults to is_published = true' do
+      PageRevision.new.is_published.should == 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')
+        attrs.should include(page.attributes.except(*PageRevision.ignored_page_attributes))
+      end
+    end
+
+    describe '#snapshot' do
+      it 'should build a page based on the cached page attributes' do
+        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
+      end
+    end
+
+    describe '#is_published' do
+      it 'should set is_published to true and false as requested' do
+        revision = PageRevision.new
+        revision.page_id = page.id
+        revision.author_id = author.id
+        revision.unpublish!
+        revision.is_published.should == false
+        revision.publish!
+        revision.is_published.should == true
+      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'
+      end
+    end
+
+    describe '#preview_url' do
+      it 'should return the preview url' do
+        revision.should_receive(:public_preview_page_revision_url) { 'foo' }
+        revision.preview_url.should == 'foo'
+      end
+    end
+
+  end
+end

data/spec/models/landable/page_spec.rb

@@ -0,0 +1,377 @@
+require 'spec_helper'
+
+module Landable
+  describe Page do
+    it { should be_a HasAssets }
+    it { should_not have_valid(:status_code).when(nil,'') }
+    it { should have_valid(:status_code).when(200, 301, 302, 410) }
+    it { should_not have_valid(:status_code).when(201, 303, 405, 500, 404) }
+
+    # config.reserved_paths = %w(/reserved_path_set_in_initializer /reject/.* /admin.*)
+    context 'PathValidator' do
+      it { should_not have_valid(:path).when(nil, '', '/reserved_path_set_in_initializer') }
+      it { should_not have_valid(:path).when('/reject/this', '/admin', '/ADMIN', '/admin_something' '/admin/path') }
+      it { should     have_valid(:path).when('/reserved_path_set_in_initializer_not', '/do/not/reject/path', '/', '/rejectwhatever', '/reject') }
+    end
+
+    it 'should set is_publishable to true on before_save' do
+      page = FactoryGirl.build :page, is_publishable: false
+      page.save!
+      page.is_publishable.should be_true
+    end
+
+    specify "#redirect?" do
+      Page.new.should_not be_redirect
+      Page.new().should_not be_redirect
+      Page.new(status_code: 200).should_not be_redirect
+      Page.new(status_code: 410).should_not be_redirect
+
+      Page.new(status_code: 301).should be_redirect
+      Page.new(status_code: 302).should be_redirect
+    end
+
+    describe '#published?' do
+      context 'when published' do
+        it 'should be true' do
+          page = create :page
+          page.publish! author: create(:author), notes: 'yo'
+          page.should be_published
+        end
+      end
+
+      context 'when not published' do
+        it 'should be false' do
+          page = create :page
+          page.should_not be_published
+        end
+      end
+    end
+
+    specify '#path_extension' do
+      Page.new(path: 'foo').path_extension.should be_nil
+      Page.new(path: 'foo.bar').path_extension.should == 'bar'
+      Page.new(path: 'foo.bar.baz').path_extension.should == 'baz'
+      Page.new(path: 'foo.bar-baz').path_extension.should be_nil
+    end
+
+    describe '#content_type' do
+      def content_type_for path
+        Page.new(path: path).content_type
+      end
+
+      it 'should be text/html for html pages' do
+        content_type_for('asdf').should == 'text/html'
+        content_type_for('asdf.htm').should == 'text/html'
+        content_type_for('asdf.html').should == 'text/html'
+      end
+
+      it 'should be application/json for json' do
+        content_type_for('asdf.json').should == 'application/json'
+      end
+
+      it 'should be application/xml for xml' do
+        content_type_for('asdf.xml').should == 'application/xml'
+      end
+
+      it 'should be text/plain for everything else' do
+        content_type_for('foo.bar').should == 'text/plain'
+        content_type_for('foo.txt').should == 'text/plain'
+      end
+    end
+
+    describe '#html?' do
+      let(:page) { build :page }
+
+      it 'should be true if content_type is text/html' do
+        page.should_receive(:content_type) { 'text/html' }
+        page.should be_html
+      end
+
+      it 'should be false if content_type is not text/html' do
+        page.should_receive(:content_type) { 'text/plain' }
+        page.should_not be_html
+      end
+    end
+
+    describe '#redirect_url' do
+      it 'is required if redirect?' do
+        page = Page.new status_code: 301
+        page.should_not have_valid(:redirect_url).when(nil, '')
+        page.should have_valid(:redirect_url).when('http://example.com', 'http://www.somepath.com')
+      end
+
+      it 'not required for 200, 410' do
+        page = Page.new
+        page.should have_valid(:redirect_url).when(nil, '')
+      end
+    end
+
+    describe '#meta_tags' do
+      it { subject.should have_valid(:meta_tags).when(nil) }
+
+      specify "quacks like a Hash" do
+        # Note the change from symbol to string; thus, always favor strings.
+        page = create :page, meta_tags: { keywords: 'foo' }
+        page.meta_tags.keys.should == [:keywords]
+
+        tags = Page.first.meta_tags
+        tags.should be_a(Enumerable)
+        tags.keys.should == ['keywords']
+        tags.values.should == ['foo']
+      end
+    end
+
+    describe '#head_content' do
+      it { subject.should have_valid(:meta_tags).when(nil) }
+
+      it 'works as a basic text area' do
+        page = create :page, head_content: "<head en='en'/>"
+        page.head_content.should ==  "<head en='en'/>"
+        
+        page.head_content = "<head en='magic'/>"
+        page.save
+
+        page.head_content.should == "<head en='magic'/>"
+      end
+    end
+
+    describe '#path=' do
+      it 'ensures a leading "/" on path' do
+        Page.new(path: 'foo/bar').path.should == '/foo/bar'
+      end
+
+      it 'leaves nil and empty paths alone' do
+        Page.new(path: '').path.should == ''
+        Page.new(path: nil).path.should == nil
+      end
+    end
+
+    describe '#publish' do
+      let(:page) { FactoryGirl.create :page }
+      let(:author) { FactoryGirl.create :author }
+
+      it 'should create a page_revision' do
+        expect {page.publish!(author: author)}.to change{page.revisions.count}.from(0).to(1)
+      end
+
+      it 'should have the provided author' do
+        page.publish! author: author
+        revision = page.revisions.last
+
+        revision.author.should == author
+      end
+
+      it 'should update the published_revision_id' do
+        page.publish! author: author
+        revision = page.revisions.last
+
+        page.published_revision.should == revision
+      end
+
+      it 'should set is_publishable to false' do
+        page.is_publishable = true
+        page.publish! author: author
+        page.is_publishable.should be_false
+      end
+
+      it 'should unset previous revision.is_published' do
+        page.publish! author: author
+        revision1 = page.published_revision
+        page.publish! author: author
+        revision1.is_published.should be_false
+      end
+    end
+
+    describe '#revert_to' do
+      let(:page) { FactoryGirl.create :page }
+      let(:author) { FactoryGirl.create :author }
+
+      it 'should NOT update published_revision for the page' do
+        page.title = 'Bar'
+        page.publish! author: author
+        revision = page.published_revision
+
+        page.title = 'Foo'
+        page.publish! author: author
+
+        page.revert_to! revision
+
+        page.published_revision.id.should_not == revision.id
+      end
+
+      it 'should copy revision attributes into the page model' do
+        page.title = 'Bar'
+        page.publish! author: author
+
+        revision = page.published_revision
+
+        page.title = 'Foo'
+        page.save!
+        page.publish! author: author
+
+        # ensure assignment for all copied attributes
+        keys = %w(title path body category_id theme_id status_code meta_tags redirect_url)
+        keys.each do |key|
+          page.should_receive("#{key}=").with(revision.send(key))
+        end
+
+        page.revert_to! revision
+      end
+    end
+
+    describe '#forbid_changing_path' do
+      context 'created_record' do
+        it 'does not allow a path to be changed' do
+          page = create :page, path: '/test'
+          page.path = '/different'
+          expect { page.save! }.to raise_error
+
+          page.reload
+          page.path.should == '/test'
+        end
+      end
+
+      context 'new_record' do
+        it 'allows the path to be changed' do
+          page = build :page, path: '/test'
+          page.save!
+
+          page.path.should == '/test'
+        end
+      end
+    end
+
+    describe '#preview_path' do
+      it 'should return the preview path' do
+        page = build :page
+        page.should_receive(:public_preview_page_path) { 'foo' }
+        page.preview_path.should == 'foo'
+      end
+    end
+
+    describe '#preview_url' do
+      it 'should return the preview url' do
+        page = build :page
+        page.should_receive(:public_preview_page_url) { 'foo' }
+        page.preview_url.should == 'foo'
+      end
+    end
+
+    describe '::sitemappable' do
+      let(:page) { create :page }
+      let(:page_2) { create :page, :redirect }
+      let(:page_3) { create :page, meta_tags: { 'robots' => 'noindex' } }
+
+      it 'only returns pages with a status code of 200 and dont have a noindex tag' do 
+        page_2.status_code.should == 301
+
+        Landable::Page.sitemappable.should include(page)
+        Landable::Page.sitemappable.should_not include(page_2, page_3)
+      end
+    end
+
+    describe '#downcase_path' do
+      it 'should force a path to be lowercase' do
+        page = build :page, path: '/SEO'
+        page.should be_valid
+        page.path.should == '/seo'
+      end
+
+      it 'doesnt change a downcase path' do
+        page = build :page, path: '/seo'
+        page.should be_valid
+        page.path.should == '/seo'
+      end
+    end
+
+    describe '#redirect_url' do
+      context 'validater' do
+        before(:each) { @page = build :page, path: '/' }
+
+        it 'should correctly validate http://' do
+          @page.redirect_url = 'http://www.google.com'
+          @page.should be_valid
+        end
+
+        it 'should correctly validate https://' do
+          @page.redirect_url = 'http://www.google.com'
+          @page.should be_valid
+        end
+
+        it 'should correctly validate /' do
+          @page.redirect_url = '/some/uri'
+          @page.should be_valid
+        end
+
+        it 'should not validate www' do
+          @page.redirect_url = 'www.google.com'
+          @page.should_not be_valid
+        end
+
+        it 'should not validate bad urls' do
+          @page.redirect_url = 'hdasdfpou'
+          @page.should_not be_valid
+        end
+
+      end
+    end
+
+    describe '::generate_sitemap' do
+      it 'returns a sitemap' do
+        page = create :page
+        Landable::Page.generate_sitemap(host: 'example.com',
+                                        protocol: 'http',
+                                        exclude_categories: [],
+                                        sitemap_additional_paths: []).should include("<loc>http://example.com#{page.path}</loc>")
+      end
+
+      it 'does not include excluded categories' do
+        cat = create :category, name: 'Testing'
+        page = create :page, category: cat
+        Landable::Page.generate_sitemap(host: 'example.com',
+                                        protocol: 'http',
+                                        exclude_categories: ['Testing'],
+                                        sitemap_additional_paths: []).should_not include("<loc>http://example.com#{page.path}</loc>")
+      end
+
+      it 'can handle https protocol' do
+        page = create :page
+        Landable::Page.generate_sitemap(host: 'example.com',
+                                        protocol: 'https',
+                                        exclude_categories: [],
+                                        sitemap_additional_paths: []).should include("<loc>https://example.com#{page.path}</loc>")
+      end
+
+      it 'can handle additional pages' do
+        Landable::Page.generate_sitemap(host: 'example.com',
+                                        protocol: 'https',
+                                        exclude_categories: [],
+                                        sitemap_additional_paths: ['/terms.html']).should include("<loc>https://example.com/terms.html</loc>")
+      end
+    end
+
+    describe '::by_path' do
+      it 'returns first page with path name' do
+        page  = create :page, path: '/seo'
+        Landable::Page.by_path('/seo').should == page
+      end
+    end
+
+    describe 'validate#body_strip_search' do
+      it 'raises errors if errors!' do
+        page = build :page, path: '/'
+        page.body = "{% image_tag 'bad_image' %}"
+        page.should_not be_valid
+        page.errors[:body].should_not be_empty
+      end
+
+      it 'does not raise error when no syntax error' do
+        page = build :page, path: '/'
+        page.body = 'body'
+        page.should be_valid
+        page.save!
+        page.body.should == 'body'
+      end
+    end
+  end
+end