landable 1.7.0

data/spec/models/landable/template_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+module Landable
+  describe Template do
+    describe 'validators' do
+      # some valid seed data
+      before(:each) { create :template }
+
+      it { should validate_presence_of :name }
+      it { should validate_presence_of :description }
+      it { should validate_presence_of :slug }
+      it { should validate_uniqueness_of :slug }
+    end
+
+    describe '#name=' do
+      context 'without a slug' do
+        it 'should assign a slug' do
+          template = build(:template, slug: nil)
+          template.name = 'Six Seven'
+          template.name.should == 'Six Seven'
+          template.slug.should == 'six_seven'
+        end
+      end
+
+      context 'with a slug' do
+        it 'should leave the slug alone' do
+          template = build(:template, slug: 'six')
+          template.name = 'seven'
+          template.name.should == 'seven'
+          template.slug.should == 'six'
+        end
+      end
+    end
+
+    describe '#partial?' do
+      it 'returns true when template references a file' do
+        template = create :template, :partial
+        template.partial?.should be_true
+      end
+
+      it 'returns false when template has no file' do
+        template = create :template
+        template.partial?.should be_false
+      end
+    end
+  end
+end

data/spec/models/landable/theme_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+module Landable
+  describe Theme do
+    it { should have_valid(:thumbnail_url).when(nil) }
+    it { should be_a HasAssets }
+  end
+end

data/spec/responders/page_render_responder_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Landable::PageRenderResponder do
+
+  let(:page) { build :page }
+  let(:responder) { Landable::PageRenderResponder.new double(request: double, formats: []), [page] }
+
+  describe '#to_html' do
+    context 'okay' do
+      it 'should render a 200' do
+        content = double
+        content_type = double
+        Landable::RenderService.should_receive(:call) { content }
+        page.should_receive(:content_type) { content_type }
+
+        responder.should_receive(:render).with(text: content, content_type: content_type, layout: false)
+
+        responder.to_html
+      end
+    end
+
+    context 'redirect' do
+      let(:page) { build :page, :redirect }
+
+      it 'should render a redirect' do
+        responder.should_receive(:redirect_to).with(page.redirect_url, status: page.status_code)
+        responder.should_not_receive(:render)
+
+        responder.to_html
+      end
+    end
+
+    context 'missing' do
+      let(:page) { build :page, :gone }
+
+      it 'should render a 410' do
+        expect { responder.to_html }.to raise_error(Landable::Page::GoneError)
+        responder.should_not_receive(:render)
+      end
+    end
+  end
+
+end

data/spec/routing/public_page_route_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe 'public page routes' do
+
+  routes { Landable::Engine.routes }
+
+  context 'should match' do
+    let(:author) { create :author }
+    let(:pages) do
+      [ create(:page, status_code: 200),
+        create(:page, status_code: 301, redirect_url: 'http://google.com/'),
+        create(:page, status_code: 302, redirect_url: 'http://foobar.com/'),
+        create(:page, status_code: 410)
+      ].each do |page|
+        page.publish! author: author, status_code: page.status_code
+      end
+    end
+
+    specify 'published pages with any status_code' do
+      pages.each do |page|
+        expect(get: page.path).to route_to(controller: 'landable/public/pages', action: 'show', url: page.path[1..-1])
+      end
+    end
+  end
+
+  context 'should not match' do
+    specify 'random stuff' do
+      expect(get: '/foobar').to_not be_routable
+    end
+
+    specify 'unpublished pages' do
+      page = create :page
+      expect(get: page.path).to_not be_routable
+    end
+  end
+end

data/spec/services/landable/authentication_service_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Landable::AuthenticationService do
+  let(:simple_auth) do
+    proc do |username, password|
+      if username == 'simple' && password == 'authenticator'
+        { username: 'simple', email: 'simple@example.com', first_name: 'Simple', last_name: 'Ton' }
+      end
+    end
+  end
+
+  let(:echo_auth) do
+    Landable::AuthenticationService::EchoAuthenticator
+  end
+
+  before do
+    Landable.configuration.stub!(authenticators: [simple_auth, echo_auth])
+  end
+
+  it "returns the result of the first successful authentication strategy" do
+    described_class.call('simple', 'authenticator')[:username].should == 'simple'
+    described_class.call('echo', 'echo')[:username].should == 'echo'
+  end
+
+  it "raises AuthenticationFailedError if no strategy worked" do
+    expect {
+      described_class.call('will', 'fail')
+    }.to raise_error(Landable::AuthenticationFailedError)
+  end
+
+  describe 'EchoAuthenticator' do
+    it 'returns nil outside of development and test environments' do
+      Rails.env.stub(development?: false, test?: false)
+      echo_auth.call('would-have', 'worked').should be_nil
+
+      Rails.env.stub(development?: true, test?: false)
+      echo_auth.call('will-now', 'work').should_not be_nil
+
+      Rails.env.stub(development?: false, test?: true)
+      echo_auth.call('will-now', 'work').should_not be_nil
+    end
+
+    it 'returns nil for password "fail"' do
+      echo_auth.call('will', 'fail').should be_nil
+    end
+
+    it 'returns an author for the given username' do
+      entry = echo_auth.call('anyone', 'anything')
+      entry.should include(username: 'anyone', email: 'anyone@example.com')
+      entry.should have_key(:first_name)
+      entry.should have_key(:last_name)
+    end
+
+    it 'can be instantiated to only echo a certain username/password' do
+      instance = echo_auth.new('trogdor', 'some-pass')
+      instance.call('previously', 'worked').should be_nil
+      instance.call('trogdor', 'trogdor').should be_nil
+      instance.call('trogdor', 'some-pass')[:username].should == 'trogdor'
+    end
+  end
+end

data/spec/services/landable/render_service_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+module Landable
+  describe RenderService do
+    let(:page)  { build  :page, body: 'render test', theme: theme }
+    let(:theme) { create :theme }
+
+    def render(*args)
+      options = args.extract_options!
+      target = args.first || page
+
+      RenderService.call(target, options)
+    end
+
+    it 'returns a string' do
+      page.body = 'Hi mom'
+      theme.body = '{{body}}'
+      render.should == 'Hi mom'
+    end
+
+    context 'without a theme' do
+      it 'returns the bare page body' do
+        page.theme = nil
+        render.should == page.body
+      end
+
+      it 'returns the bare page body if the theme is defined, but has no liquid body template' do
+        page.theme.body = nil
+        render.should == page.body
+      end
+
+      it 'returns an empty string if there is also no page body' do
+        page.theme = nil
+        page.body = nil
+        render.should == ''
+      end
+    end
+
+    context 'without a body' do
+      it 'renders the bare theme' do
+        theme.body = 'foo {{body}}'
+        page.body  = nil
+        render.should == 'foo '
+      end
+    end
+
+    context 'for a redirect' do
+      let(:page)  { build :page, :redirect  }
+
+      context 'previewing' do
+        let(:rendered) { render(preview: true) }
+
+        it 'conveys information about the redirect' do
+          rendered.should include "#{page.status_code}"
+          rendered.should include "<a href=\"#{page.redirect_url}\">#{page.redirect_url}</a>"
+        end
+      end
+
+      context 'not previewing' do
+        let(:rendered) { render }
+
+        it 'should not include those things' do
+          rendered.should_not include "#{page.status_code}"
+          rendered.should_not include "<a href=\"#{page.redirect_url}\">#{page.redirect_url}</a>"
+        end
+      end
+    end
+
+    context 'for non-html' do
+      let(:page) { build :page, body: 'render test', path: 'foo.txt', theme: theme }
+
+      it 'renders without a theme' do
+        render.should == 'render test'
+      end
+
+      context 'previewing' do
+        let(:rendered) { render(preview: true) }
+
+        it 'renders with <pre> around the content' do
+          rendered.should == '<pre>render test</pre>'
+        end
+      end
+    end
+
+    context 'with a Responder' do
+      # setup
+      let(:controller) { double('MockController', fetch_landable_variables: { 'hello_world' => "I'm a Loner, Dottie. A Rebel." }) }
+      let(:responder) { double('responder', controller: controller) }
+      let(:rendered) { render(responder: responder) }
+
+      # tests
+      it 'should include registered variables from an external controller source' do
+        # setup
+        page.body = '{{hello_world}}'
+        # actions
+        # expectations
+        rendered.should match "I'm a Loner, Dottie. A Rebel."
+        # end
+      end
+      # end
+    end
+  end
+end

data/spec/services/landable/tidy_service_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+module Landable
+  describe TidyService do
+    let(:service) { TidyService }
+
+    describe '.tidyable?' do
+      after(:each) { service.class_variable_set :@@is_tidyable, nil }
+
+      context 'when tidyable' do
+        it 'should check on the availability of a `tidy` command' do
+          Kernel.should_receive(:system).with('which tidy > /dev/null') { true }
+          service.should be_tidyable
+          service.class_variable_get(:@@is_tidyable).should be_true
+        end
+      end
+
+      context 'not tidyable' do
+        it 'should return false' do
+          Kernel.should_receive(:system).with('which tidy > /dev/null') { false }
+          service.should_not be_tidyable
+          service.class_variable_get(:@@is_tidyable).should be_false
+        end
+      end
+    end
+
+    describe '.call!' do
+      it 'should call #call with raise_on_error: true' do
+        input = double
+        output = double
+        service.should_receive(:call).with(input, raise_on_error: true) { output }
+        service.call!(input).should == output
+      end
+    end
+
+    describe '.call' do
+      context 'when not tidyable' do
+        it 'should raise an exception' do
+          service.should_receive(:tidyable?) { false }
+          expect { service.call 'foo' }.to raise_error(StandardError)
+        end
+      end
+      
+      context 'when tidyable' do
+        before(:each) do
+          service.should_receive(:tidyable?) { true }
+        end
+
+        it 'should invoke tidy and return a Result' do
+          input = double('input')
+          output = double('output')
+          result = double('result')
+
+          service.should_receive(:wrap_liquid) { |input| input }.ordered # passthrough; will test later
+
+          mock_io = double('io')
+          mock_io.should_receive(:puts).with(input).ordered
+          mock_io.should_receive(:close_write).ordered
+          mock_io.should_receive(:read) { output }
+
+          service.should_receive(:unwrap_liquid) { |input| input }.ordered # passthrough; will test later
+
+          # other setup
+          service.should_receive(:options) { ['one', 'two', 'three'] }
+          IO.should_receive(:popen).with('tidy one two three', 'r+').and_yield(mock_io)
+
+          TidyService::Result.should_receive(:new).with(output) { result }
+
+          service.call(input).should == result
+        end
+
+        it 'should wrap known liquid tags before sending to tidy, and unwrap them after' do
+          original_string = '<div> {% template foobar title: "sixteen" %} <span> {% meta_tags "something" %} </span> </div>'
+          wrapped_string = '<div> <div data-liquid="' + Base64.encode64('{% template foobar title: "sixteen" %}').strip + '"></div> <span> <div data-liquid="' + Base64.encode64('{% meta_tags "something" %}').strip + '"></div> </span> </div>'
+
+          # mock out tidy itself, and make it a no-op
+          mock_io = double('io')
+          mock_io.should_receive(:puts).with(wrapped_string)
+          mock_io.should_receive(:close_write)
+          mock_io.should_receive(:read) { wrapped_string }
+          IO.should_receive(:popen).and_yield(mock_io)
+
+          # ensuring that the output == the input, modulo any new whitespace
+          service.call(original_string).to_s.gsub(/\s+/, ' ').should == original_string.gsub(/\s+/, ' ')
+        end
+
+        context 'raise_on_error is enabled' do
+          it 'should raise TidyError when status is 2' do
+            IO.should_receive(:popen)
+            $?.should_receive(:exitstatus) { 2 }
+
+            # meh, shouldn't have to do this. could use a refactor.
+            service.should_receive(:wrap_liquid) { |input| input }
+
+            expect { service.call('<div>foo</div>', raise_on_error: true) }.to raise_error TidyService::TidyError
+          end
+
+          it 'should be cool when status is 1' do
+            IO.should_receive(:popen)
+            $?.should_receive(:exitstatus) { 1 }
+
+            # meh, shouldn't have to do this. could use a refactor.
+            service.should_receive(:wrap_liquid) { |input| input }
+
+            expect { service.call('<div>foo</div>', raise_on_error: true) }.to_not raise_error TidyService::TidyError
+          end
+        end
+      end
+    end
+  end
+
+  module TidyService
+    describe Result do
+
+      let(:result) { Result.new <<-eof
+<html>
+  <head>
+    <link type="text/css" rel="stylesheet">
+    <title>sup</title>
+    <style type="text/css">
+      body {}
+    </style>
+  </head>
+  <body class="foo">
+    <div>hello</div>
+    <div>friend</div>
+  </body>
+</html>
+eof
+      }
+
+      describe '#to_s' do
+        it 'should return the string given on init' do
+          Result.new('foobar').to_s.should == 'foobar'
+        end
+      end
+
+      describe '#body' do
+        it 'should return the de-indented contents of <body>' do
+          result.body.should == "<div>hello</div>\n<div>friend</div>"
+        end
+      end
+
+      describe '#head' do
+        it 'should return the de-indented contents of <head>' do
+          result.head.should == "<link type=\"text/css\" rel=\"stylesheet\">\n<title>sup</title>\n<style type=\"text/css\">\n  body {}\n</style>"
+        end
+      end
+
+      describe '#css' do
+        it 'should return embedded and linked stylesheets from the head' do
+          result.css.should == "<link type=\"text/css\" rel=\"stylesheet\">\n\n<style type=\"text/css\">\n  body {}\n</style>"
+        end
+      end
+    end
+  end
+end