landable 1.7.0

data/features/public/content_types.feature

@@ -0,0 +1,17 @@
+Feature: Content types by extension
+  As a content author
+  I want Landable to deliver the right content type for my content
+
+  Scenario Outline:
+    Given a published page "/foo.<ext>"
+    When  I GET "/foo.<ext>"
+    Then  the response header "Content-Type" should be "<content_type>"
+
+    Examples:
+      | ext  | content_type     |
+      | xml  | application/xml  |
+      | json | application/json |
+      | txt  | text/plain       |
+      | html | text/html        |
+      | htm  | text/html        |
+      | foo  | text/plain       |

data/features/public/publishing.feature

@@ -0,0 +1,45 @@
+Feature: Only published revisions are publicly available
+
+  @allow-rescue
+  Scenario: Never-published page
+    Given a page "/unpub"
+    When I GET "/unpub"
+    Then the response status should be 404
+    When I publish the page "/unpub"
+    And  I GET "/unpub"
+    Then the response status should be 200
+
+  Scenario: Currently published revision
+    Given a published page "/pubbed"
+    When I GET "/pubbed"
+    Then the response status should be 200
+    And  the response body should include the body of page "/pubbed"
+
+  Scenario: Unpublished change from one theme to another
+    Given a published page "/pubbed" with a theme containing "foo"
+    When I choose another theme containing "bar"
+    And  I GET "/pubbed"
+    Then I should see "foo"
+    When I publish the page with another theme
+    And  I GET "/pubbed"
+    Then I should see "bar"
+
+  Scenario: Changes to the theme itself do not need to be published (for now?)
+    Given a published page "/pubbed" with a theme containing "foo"
+    When I change the theme to contain "bar"
+    And  I GET "/pubbed"
+    Then I should see "bar"
+
+  @allow-rescue
+  Scenario: Unpublished status change
+    Given a published page "/pubbed"
+    When  I change the page to a 410
+    And   I GET "/pubbed"
+    Then  the response status should be 200
+    When  I publish the page
+    And   I GET "/pubbed"
+    Then  the response status should be 410
+    When  I revert to the previous revision
+    And   I publish the page
+    And   I GET "/pubbed"
+    Then  the response status should be 200

data/features/public/status_codes.feature

@@ -0,0 +1,25 @@
+Feature: Page status codes
+
+  @allow-rescue
+  Scenario Outline: HTTP response status
+    Given a published page "/foo" with status <code>
+    When  I GET "/foo"
+    Then  the response status should be <code>
+
+    Examples:
+      | code |
+      |  200 |
+      |  301 |
+      |  302 |
+      |  410 |
+
+  Scenario Outline: Redirects
+    Given page "/foo" redirects to "http://google.com" with status <code>
+    When  I GET "/foo"
+    Then  the response status should be <code>
+    And   I should have been redirected to "http://google.com"
+
+    Examples:
+      | code |
+      |  301 |
+      |  302 |

data/features/public/views.feature

@@ -0,0 +1,17 @@
+Feature: Helpers are provided for Rails views that Landable didn't serve
+  The dummy app defines a few routes before mounting
+  Landable; we want to ensure those routes still function
+  from both the application and Landable's perspective.
+
+  Scenario: Application view references landable helpers
+    Given a page "/priority" with title "Landable4Life"
+    And   the robots meta tag of "/priority" is "noindex,nofollow"
+    And   the body of page "/priority" is:
+      """
+      <h1>Inline HTML!</h1>
+      """
+    When  I GET "/priority"
+    Then  the response status should be 200
+    And   the element "title" should have inner text "Home: Landable4Life"
+    And   the element "#path" should have inner text "/priority"
+    And   the element "meta[name='robots'][content='noindex,nofollow']" should exist

data/features/step_definitions/asset_steps.rb

@@ -0,0 +1,60 @@
+# a bit specific eh ...
+Given '2 assets named "panda" and "disclaimer"' do
+  @assets = [create(:asset, name: 'panda', fixture: 'panda.png'),
+             create(:asset, name: 'disclaimer', fixture: 'small.pdf')]
+end
+
+When 'I POST an asset to "$path"' do |path|
+  post path, asset: attributes_for(:asset, fixture: 'panda.png')
+  last_request.should be_form_data
+end
+
+When 'I POST that asset to "$path" again' do |path|
+  post path, asset: attributes_for(:asset, fixture: 'panda.png')
+  last_request.should be_form_data
+end
+
+When 'I POST an asset to "$path" with both $assoc IDs' do |path, assoc|
+  ary = instance_variable_get("@#{assoc}s")
+  key = :"#{assoc}_ids"
+
+  post path, asset: attributes_for(:asset).merge({
+    key => ary.map(&:id)
+  })
+end
+
+Then 'the response should contain an "asset"' do
+  last_json.should have_key('asset')
+  last_json['asset']['mime_type'].should == 'image/png'
+end
+
+Then 'the response should contain the $version "asset"' do |version|
+  # version is intentionally ignored; it just reads better in the steps.
+
+  @asset ||= Landable::Asset.order('created_at DESC').first
+  at_json('asset/id').should == @asset.id
+end
+
+Then /^the asset ID should( not)? be in the array at "([^"]+)"$/ do |negative, json_path|
+  array = at_json json_path
+  if negative
+    array.should_not include(@asset.id)
+  else
+    array.should include(@asset.id)
+  end
+end
+
+Then 'both $assoc IDs should be in the array at "$json_path"' do |assoc, json_path|
+  ids = instance_variable_get("@#{assoc}s").map &:id
+  at_json(json_path).should include(*ids)
+end
+
+Then 'the rendered body should be the correct assets' do
+  <<-eos
+    <link href="/assets/application-/#{/./}.css" media="screen" rel="stylesheet" />
+    <script src="/assets/application-#{/./}.js"></script>
+    <img alt="Foo" src="/assets/foo-#{/./}.jpg" />
+    <img alt="Foo" src="/assets/foo-#{/./}.jpg" />
+    <img alt="Baz!" src="https://landable.dev/_assets//uploads/panda.png" />
+  eos
+end

data/features/step_definitions/core_api_steps.rb

@@ -0,0 +1,139 @@
+# Lame file name, but I don't know what else to call it atm.
+
+expand_mustache = lambda do |context, str|
+  if str.respond_to?(:gsub)
+    str.gsub(/\{\{([^ ].+?)\}\}/) { context.eval($1) }
+  else
+    str
+  end
+end
+
+module Landable::FeatureHelper
+  def basic_authorize!(author = current_author, token = current_access_token)
+    basic_authorize author.username, token.id
+  end
+
+  def current_author
+    @current_author ||= create :author
+  end
+
+  def current_access_token
+    @current_access_token ||= create :access_token, author: @current_author
+  end
+
+  def last_json(body = last_response.body)
+    JSON.parse body
+  end
+
+  def latest(model)
+    model = model.to_s.classify
+    klass = "Landable::#{model}".constantize
+    klass.order('created_at DESC').first!
+  end
+end
+
+World(Landable::FeatureHelper)
+
+Before '@api' do
+  header 'Accept',       'application/json'
+  header 'Content-Type', 'application/json'
+end
+
+Before '@api', '~@no-api-auth' do
+  basic_authorize!
+end
+
+Given 'I accept HTML' do
+  header 'Accept',      'text/html'
+end
+
+Given 'I accept JSON' do
+  header 'Accept',      'application/json'
+end
+
+Given 'my API requests include a valid access token' do
+  basic_authorize!
+end
+
+Given 'I repeat the request with a valid access token' do
+  basic_authorize!
+  request last_request.url, last_request.env
+end
+
+Given 'my access token will expire in 2 minutes' do
+  current_access_token.update_attributes!(expires_at: 2.minutes.from_now)
+end
+
+Given 'my access token expired 2 minutes ago' do
+  current_access_token.update_attributes!(expires_at: 2.minutes.ago)
+end
+
+When /^I (HEAD|GET|POST|PUT|PATCH|DELETE|OPTIONS)(?: to)? "(.+?)"$/ do |http_method, path|
+  request expand_mustache[binding, path], method: http_method
+end
+
+When /^I (POST|PUT|PATCH|DELETE|OPTIONS)(?: to)? "(.+?)"(?: with)?:$/ do |http_method, path, body|
+  request expand_mustache[binding, path], method: http_method, params: body
+end
+
+When 'I request CORS from "$path" with:' do |path, table|
+  options = table.hashes.first
+
+  header 'Origin', options['origin']
+  header 'Access-Control-Request-Method', options['method']
+  request path, method: 'OPTIONS'
+end
+
+When 'I follow the "Location" header' do
+  get last_response.headers['Location']
+end
+
+Then 'my access token should not expire for at least 2 hours' do
+  token = current_access_token.reload
+  token.expires_at.should be >= 2.hours.from_now
+end
+
+Then /^the response(?: status)? should(?: (not))? be (\d{3})(?: "[A-Za-z ]+")?$/ do |negate, code|
+  code = Integer(code)
+  if negate == 'not'
+    last_response.status.should_not eq(code)
+  else
+    last_response.status.should eq(code)
+  end
+end
+
+Then /^the response should contain (?:a|an) "([^"]+)"$/ do |model|
+  last_json.should have_key(model)
+  last_json[model].should have_key('id')
+end
+
+Then /^the response should contain (\d+) "([^"]+)"$/ do |count, kind|
+  last_json[kind].length.should == Integer(count)
+end
+
+Then 'the response body should be empty' do
+  last_response.body.should be_blank
+end
+
+Then 'the response body should be "$body"' do |body|
+  last_response.body.should == body
+end
+
+Then 'I should have been redirected to "$url"' do |url|
+  last_response.headers['Location'].should == url
+end
+
+Then 'the response headers should include:' do |table|
+  expected = table.hashes.reduce({}) do |acc, row|
+    acc.merge row['header'] => row['value']
+  end
+  last_response.headers.should include(expected)
+end
+
+Then 'the JSON at "$path" should be "$value"' do |json_path, value|
+  at_json(json_path).should == value
+end
+
+Then 'the response header "$header" should be "$content_type"' do |header, content_type|
+  last_response.headers[header].should include(content_type)
+end

data/features/step_definitions/debug_steps.rb

@@ -0,0 +1,3 @@
+When 'I pry' do
+  binding.pry
+end

data/features/step_definitions/factory_steps.rb

@@ -0,0 +1,124 @@
+Given /^(\d+) ([\w\s]+)$/ do |count, kind|
+  klass = kind.gsub(/\s+/, '_').singularize.classify.gsub(/^/, 'Landable::').constantize
+  klass.destroy_all
+
+  result = Integer(count).times.map do
+    create kind.gsub(/\s+/, '_').singularize.to_sym
+  end
+
+  instance_variable_set :"@#{kind}", result
+end
+
+Given 'there are no authors in the database' do
+  Landable::Author.delete_all
+end
+
+Given /^an author "([^"]+)"$/ do |username|
+  create :author, username: username
+end
+
+Given '"$username" has an unexpired access token' do |username|
+  create :access_token, author: Landable::Author.where(username: username).first!
+end
+
+Given 'I also have an older, expired access token' do
+  @expired_access_token = create :access_token, author: @current_author, expires_at: 2.minutes.ago
+end
+
+Given "there is another author's access token in the database" do
+  @foreign_access_token = create :access_token, author: create(:author)
+end
+
+Given /^an? (page|theme|asset|template)$/ do |model|
+  instance_variable_set :"@#{model}", create(model.to_sym)
+end
+
+Given /^a (page|theme) with an asset attached$/ do |model|
+  record = create model.to_sym
+  @asset = create :asset
+  record.assets.push @asset
+  instance_variable_set :"@#{model}", record
+end
+
+Given /^a page "([^"]+)"$/ do |path|
+  create :page, path: path, body: "<HTML>BODY</HTML>"
+end
+
+Given /^a page "([^"]+)" with title "(.+)"$/ do |path, title|
+  create :page, path: path, title: title, body: "<HTML>BODY</HTML>"
+end
+
+Given /^a "(\w+)" page with title "(.+)" and category "(.+)"$/ do |published, title, category|
+  category_obj = Landable::Category.where('lower(name) = ?', category.downcase).first
+  @page = create :page, title: title, category: category_obj
+  @page.publish! author: create(:author) if published == 'published'
+end
+
+Given 'page "$path" redirects to "$url" with status $code' do |path, url, code|
+  page = create :page, :redirect, path: path, redirect_url: url, status_code: code, body: "BODY"
+  page.publish! author: create(:author)
+end
+
+Given 'a published page "$path"' do |path|
+  @page = create :page, path: path
+  @page.publish! author: create(:author)
+end
+
+Given 'a published page "$path" with status $code' do |path, code|
+  code = Integer(code)
+  page = case code
+         when 301, 302 then create :page, :redirect, path: path, status_code: code, body: "BODY"
+         when 410 then create :page, :gone, path: path, body: "BODY"
+         else create :page, path: path, body: "BODY"
+         end
+  page.publish! author: create(:author)
+end
+
+Given 'a published page "$path" titled "$title" with theme "$name"' do |path, title, theme|
+  page = create :page, path: path, title: title, theme: create(:theme, name: theme)
+  page.publish! author: create(:author)
+end
+
+Given 'the body of theme "$name" is "$body"' do |name, body|
+  theme = Landable::Theme.where(name: name).first!
+  theme.update_attributes! body: body
+end
+
+Given 'the $tag meta tag of "$path" is "$value"' do |tag, path, value|
+  page = Landable::Page.by_path!(path)
+  page.meta_tags ||= {}
+  page.meta_tags.merge! tag => value
+  page.save!
+end
+
+Given 'the body of page "$path" is:' do |path, body|
+  Landable::Page.by_path!(path).update_attributes(body: body)
+end
+
+When 'I publish the page "$path"' do |path|
+  Landable::Page.by_path!(path).publish! author: create(:author)
+end
+
+When(/^I change the page to a (\d+)$/) do |code|
+  @page.status_code = code
+  @page.save!
+end
+
+Then /^there should be (\d+) ([\w\s]+) in the database$/ do |count, kind|
+  name  = kind.gsub(/\s+/, '_').classify
+  klass = "Landable::#{name}".constantize
+  klass.count.should eql(Integer(count))
+end
+
+Then 'an author "$username" should exist' do |username|
+  Landable::Author.where(username: username).first!
+end
+
+Then /^the author "(.+?)" should have (\d+) access tokens?$/ do |username, n|
+  author = Landable::Author.where(username: username).first!
+  author.access_tokens.count.should == Integer(n)
+end
+
+Then 'the response body should include the body of page "$path"' do |path|
+  last_response.body.should include(Landable::Page.by_path!(path).body)
+end

data/features/step_definitions/html_steps.rb

@@ -0,0 +1,9 @@
+Then 'the element "$css" should exist' do |css|
+  doc = Nokogiri::HTML(last_response.body)
+  doc.at(css).should be_present
+end
+
+Then 'the element "$css" should have inner text "$text"' do |css, text|
+  doc = Nokogiri::HTML(last_response.body)
+  doc.at(css).text.should == text
+end