locomotivecms 3.0.0.pre.alpha

data/features/step_definitions/api_steps.rb

@@ -0,0 +1,179 @@
+def api_base_url
+  "http://#{Locomotive::Site.first.domains.first}/locomotive/api/"
+end
+
+def do_api_request(type, url, param_string_or_hash = nil)
+  begin
+    if param_string_or_hash
+      if param_string_or_hash.is_a? Hash
+        params = param_string_or_hash
+      else
+        # Do memory substitution from json_spec
+        params = JSON.parse(JsonSpec.remember(param_string_or_hash))
+      end
+    else
+      params = {}
+    end
+    transform_filenames_to_fixtured_files(params)
+    @json_response = do_request(type, api_base_url, url,
+                               params.merge({ 'CONTENT_TYPE' => 'application/json' }))
+  rescue Pundit::NotAuthorizedError, Mongoid::Errors::DocumentNotFound
+    @error = $!
+  end
+end
+
+def last_json
+  @json_response.try(:body) || page.source
+end
+
+def last_status
+  @json_response.try(:status) || page.status
+end
+
+# Deal with file fields
+
+def file_fields
+  @file_fields ||= []
+end
+
+def add_file_field(json_path)
+  file_fields << json_path
+end
+
+def get_field_at_path(hash, path)
+  val = hash
+  path.split('/').each do |key|
+    if val.is_a?(Array)
+      val = val[key.to_i]
+    elsif val.has_key?(key)
+      val = val[key]
+    else
+      return nil
+    end
+  end
+  val
+end
+
+def set_field_at_path(hash, path, value)
+  obj = hash
+  keys = path.split('/')
+  last_key = keys.slice!(-1)
+  keys.each do |key|
+    if obj.is_a?(Array)
+      obj = obj[key.to_i]
+    else
+      obj = obj[key]
+    end
+  end
+  obj[last_key] = value
+end
+
+def transform_filenames_to_fixtured_files(params)
+  file_fields.each do |path|
+    filename = get_field_at_path(params, path)
+    return unless filename
+
+    file = Rack::Test::UploadedFile.new(Rails.root.join('..', 'fixtures', filename))
+    set_field_at_path(params, path, file)
+  end
+end
+
+Given /^I have an? "([^"]*)" API token$/ do |role|
+  @membership = Locomotive::Site.first.memberships.where(:role => role.downcase).first \
+    || FactoryGirl.create(role.downcase.to_sym, :site => Locomotive::Site.first)
+
+  login_params = {
+    'email'     => @membership.account.email,
+    'password'  => 'easyone'
+  }
+
+  response = do_request('POST', api_base_url, 'tokens.json',
+                        login_params.merge({ 'CONTENT_TYPE' => 'application/json' }))
+
+  if response.status == 200
+    @auth_token = JSON.parse(response.body)['token']
+  else
+    raise JSON.parse(response.body)['message']
+  end
+
+  add_default_params(:auth_token => @auth_token)
+end
+
+Given /^I do not have an API token$/ do
+  @auth_token = nil
+end
+
+Given /^the JSON request at "([^"]*)" is a file$/ do |path|
+  add_file_field(path)
+end
+
+When /^I visit "([^"]*)"$/ do |path|
+  @json_response = get("http://#{@site.domains.first}#{path}", { auth_token: @auth_token }, { 'CONTENT_TYPE' => 'application/json' })
+end
+
+# http://stackoverflow.com/questions/9009392/racktest-put-method-with-json-fails-to-convert-json-to-params
+When /^I post to "([^"]*)"$/ do |path|
+  @json_response = post("http://#{@site.domains.first}#{path}", '', { 'CONTENT_TYPE' => 'application/json' })
+end
+
+When /^I post to "([^"]*)" with:$/ do |path, json_string|
+  @json_response = post("http://#{@site.domains.first}#{path}", json_string, { 'CONTENT_TYPE' => 'application/json' })
+end
+
+When /^I do an API (\w+) (?:request )?to ([\w.\/]+)$/ do |request_type, url|
+  do_api_request(request_type, url)
+end
+
+When /^I do an API (\w+) (?:request )?to ([\w.\/]+) with:$/ do |request_type, url, param_string|
+  do_api_request(request_type, url, param_string)
+end
+
+Then /^an access denied error should occur$/ do
+  if @error
+    @error.is_a?(CanCan::AccessDenied).should be_true
+  else
+    last_status.should == 401
+  end
+end
+
+Then /^it should not exist$/ do
+  if @error
+    @error.is_a?(Mongoid::Errors::DocumentNotFound).should be_true
+  else
+    last_status.should == 404
+  end
+end
+
+When /^I do a multipart API (\w+) (?:request )?to ([\w.\/]+) with base key "([^"]*)" and:$/ \
+    do |request_type, url, base_key, table|
+  params = {}
+  params = table.rows_hash
+  params.each do |key, filename|
+    params[key] = Rack::Test::UploadedFile.new(Rails.root.join('..', 'fixtures', filename))
+  end
+  do_api_request(request_type, url, { base_key => params })
+end
+
+Then /^the JSON at "([^"]*)" should match \/(.+)\/$/ do |path, regex|
+  parse_json(last_json, path).should =~ /#{regex}/
+end
+
+Then /^the response content type should match \/(.+)\/$/ do |regex|
+  @json_response.header['Content-Type'].should =~ /#{regex}/
+end
+
+Then /^the JSON at "([^"]*)" should be the time "(.+)"$/ do |path, time_str|
+  format = '%Y-%m-%dT%H:%M:%S%Z'
+  json_time_str = parse_json(last_json, path)
+  json_time = Time.strptime(json_time_str, format)
+  time = Time.strptime(time_str, format)
+  json_time.should == time
+end
+
+Then /^I print the JSON response$/ do
+  puts %{JSON (status=#{@json_response.status}): "#{last_json}" / #{last_json.inspect}}
+end
+
+Then /^I print the editable elements for page "([^"]*)"$/ do |id|
+  puts @site.pages.find(id).editable_elements.inspect
+end

data/features/step_definitions/backoffice/mounting_steps.rb

@@ -0,0 +1,22 @@
+Given /^the engine is mounted on a non standard path$/ do
+  Rails.application.routes.draw do
+    mount Locomotive::Engine => '/my-custom-path', as: 'locomotive'
+    match '/foo' => 'foo#index', as: 'foo'
+  end
+end
+
+Then /^I should be able to access the backend$/ do
+  # Ensure we can access the backend
+  visit '/my-custom-path'
+  page.should have_content 'LocomotiveCMS'
+
+  # Ensure we can update the homepage content
+  within('#pages-list') do
+    click_link 'Home page'
+  end
+  click_button 'Save'
+  page.should have_content 'Page was successfully updated'
+
+  # Reset the routes back to normal once we are done
+  Rails.application.reload_routes!
+end

data/features/step_definitions/backoffice_steps.rb

@@ -0,0 +1,47 @@
+### Authentication
+
+Given /^I am not authenticated$/ do
+  visit('/locomotive/sign_out')
+end
+
+Given /^I am an authenticated "([^"]*)"$/ do |role|
+  @member = Locomotive::Site.first.memberships.where(:role => role.downcase).first || FactoryGirl.create(role.downcase.to_sym, :site => Locomotive::Site.first)
+
+  step %{I go to login}
+  step %{I fill in "Email" with "#{@member.account.email}"}
+  step %{I fill in "Password" with "easyone"}
+  step %{I press "Log in"}
+end
+
+Given /^I am an authenticated user$/ do
+  step %{I am an authenticated "admin"}
+end
+
+Then /^I should see the access denied message$/ do
+  page.body.include?("You are not authorized to access this page").should be_true
+end
+
+Then /^I am redirected to "([^\"]*)"$/ do |url|
+  assert [301, 302].include?(@integration_session.status), "Expected status to be 301 or 302, got #{@integration_session.status}"
+  location = @integration_session.headers["Location"]
+  assert_equal url, location
+  visit location
+end
+
+### Cross-domain authentication
+
+When /^I forget to press the button on the cross-domain notice page$/ do
+  @admin.updated_at = 2.minutes.ago
+  Mongoid::Persistence::Update.new(@admin).send(:update)
+end
+
+### Common
+
+When(/^I change the number of items to display per page to (\d+)$/) do |per_page|
+  Locomotive.config.ui[:per_page] = per_page
+end
+
+Then /^I debug$/ do
+  debugger
+  0
+end

data/features/step_definitions/content_assets_steps.rb

@@ -0,0 +1,12 @@
+
+Given /^I have the following content assets:$/ do |table|
+  site = Locomotive::Site.first
+  table.hashes.each do |asset_hash|
+    asset_hash['site'] = site
+    asset_hash['source'] = FixturedAsset.open(asset_hash['file'])
+    asset_hash.delete('file')
+
+    asset = FactoryGirl.build(:asset, asset_hash)
+    asset.save.should be_true
+  end
+end

data/features/step_definitions/content_types_steps.rb

@@ -0,0 +1,135 @@
+def build_content_type(name)
+  site = Locomotive::Site.first
+  FactoryGirl.build(:content_type, site: site, name: name, order_by: '_position')
+end
+
+def set_custom_fields_from_table(content_type, fields)
+  fields.hashes.each do |field|
+    # found a belongs_to association
+    if field['type'] == 'belongs_to'
+      target_name   = field.delete('target')
+      target_model  = @site.content_types.where(name: target_name).first
+
+      field['class_name'] = target_model.entries_class_name
+    end
+
+    content_type.entries_custom_fields.build field
+  end
+end
+
+Given %r{^I have a custom model named "([^"]*)" with id "([^"]*)" and$} do |name, id, fields|
+  content_type = build_content_type(name)
+  content_type.id = BSON::ObjectId(id)
+  set_custom_fields_from_table(content_type, fields)
+  content_type.valid?
+  content_type.save.should be_true
+end
+
+Given(/^the "(.*?)" model was created by another thread$/) do |name|
+  content_type = Locomotive::ContentType.where(name: name).first
+  Locomotive.send(:remove_const, :"ContentEntry#{content_type._id}")
+  "Locomotive::ContentEntry#{content_type._id}".constantize
+end
+
+Given %r{^I have a custom model named "([^"]*)" with$} do |name, fields|
+  content_type = build_content_type(name)
+  set_custom_fields_from_table(content_type, fields)
+  content_type.valid?
+  content_type.save.should be_true
+end
+
+Given %r{^I have "([^"]*)" as "([^"]*)" values of the "([^"]*)" model$} do |values, field, name|
+  content_type = Locomotive::ContentType.where(name: name).first
+  field = content_type.entries_custom_fields.detect { |f| f.label == field }
+  field.should_not be_nil
+
+  if field.type == 'select'
+    values.split(',').collect(&:strip).each do |name|
+      field.select_options.build name: name
+    end
+    content_type.save.should be_true
+  else
+    raise "#{field.type} field is not supported"
+  end
+end
+
+Given %r{^I have entries for "([^"]*)" with$} do |name, entries|
+  content_type = Locomotive::ContentType.where(name: name).first
+  entries.hashes.each do |attributes|
+    entry_id  = attributes.delete('id')
+    entry     = content_type.entries.build(attributes)
+    entry.id  = entry_id if entry_id
+    entry.save!
+  end
+  content_type.save.should be_true
+end
+
+When(/^the custom model named "(.*?)" is ordered by "(.*?)"$/) do |name, order_by|
+  content_type = Locomotive::ContentType.where(name: name).first
+  content_type.update_attribute :order_by, order_by
+end
+
+#the "client" "Alpha, Inc" has "Fun project" as one of its "projects"
+Given(/^the "(.*?)" "(.*?)" has "(.*?)" as one of its "(.*?)"$/) do |source, source_label, target_label, target|
+  source_model = Locomotive::ContentType.where(name: source.classify.pluralize).first
+  source_entry = source_model.entries.where(source_model.label_field_name => source_label).first
+  target_model = Locomotive::ContentType.where(name: target.classify.pluralize).first
+  target_entry = target_model.entries.where(target_model.label_field_name => target_label).first
+
+  source_entry.send("#{target}").send("<<", target_entry)
+end
+
+When(/^I choose "(.*?)" in the list$/) do |name|
+  within('#content') do
+    click_link(name)
+  end
+end
+
+When(/^I delete the first content entry$/) do
+  within('#content ul.list li:first') do
+    click_link 'Delete'
+  end
+end
+
+Given %r{^I (enable|disable) the public submission of the "([^"]*)" model$} do |action, name|
+  enabled = action == 'enable'
+  content_type = Locomotive::ContentType.where(name: name).first
+  content_type.public_submission_enabled  = enabled
+  content_type.public_submission_accounts = enabled ? [Locomotive::Account.first._id] : []
+  content_type.save.should be_true
+end
+
+When %r{^I change the presentation of the "([^"]*)" model by grouping items by "([^"]*)"$} do |name, field|
+  content_type = Locomotive::ContentType.where(name: name).first
+  field = content_type.entries_custom_fields.detect { |f| f.label == field }
+  content_type.group_by_field_id = field._id
+  content_type.save.should be_true
+end
+
+Then %r{^I should not see (\d+) times the "([^"]*)" field$} do |n, field|
+  page.all(:css, "#content_#{field.underscore.downcase}_input").size.should_not == n.to_i
+end
+
+When %r{^I unselect the notified accounts$} do
+  page.evaluate_script "window.application_view.view.model.set({ 'public_submission_accounts': null });"
+
+  click_button 'Save'
+
+  page.find('.notice').visible?
+end
+
+Then %r{^there should not be any notified accounts on the "([^"]*)" model$} do |name|
+  content_type = Locomotive::ContentType.where(name: name).first
+  content_type.reload.public_submission_accounts.should eq([])
+end
+
+Given(/^I click on the (\d+)[a-z]+ required flag$/) do |nth|
+  find(".custom-field:nth-child(#{nth}) .required-input .switchHandle").click
+  sleep(0.1)
+end
+
+Given(/^I have the "(.*?)" entries ordered by the "(.*?)" field$/) do |name, field|
+  content_type = Locomotive::ContentType.where(name: name).first
+  field = content_type.entries_custom_fields.detect { |f| f.label == field }
+  content_type.update_attribute :order_by, field.name
+end

data/features/step_definitions/current_site_steps.rb

@@ -0,0 +1,43 @@
+Then /^I should see the role dropdown on the "([^"]*)"$/ do |user|
+  find(:css, "#site_memberships_input div.entry[data-role=#{user}] select").should be_present
+end
+
+Then /^I should see the role dropdown on the "([^"]*)" without the "([^"]*)" option$/ do |user, option|
+  find(:css, "#site_memberships_input div.entry[data-role=#{user}] select").text.should_not include option
+end
+
+Then /^I should see the role dropdown on myself$/ do
+  step %{I should see the role dropdown on the "#{@member.role}"}
+end
+
+Then /^I should not see the role dropdown on the "([^"]*)"$/ do |user|
+  page.has_css?("#site_memberships_input div.entry[data-role=#{user}] select").should be_false
+end
+
+Then /^I should not see the role dropdown on myself$/ do
+  step %{I should not see the role dropdown on the "#{@member.role}"}
+end
+
+Then /^I should not see any role dropdowns$/ do
+  page.has_css?('#site_memberships_input div.entry select').should be_false
+end
+
+Then /^I should see delete on the "([^"]*)"$/ do |role|
+  page.has_css?("#site_memberships_input div.entry[data-role=#{role}] .actions a.remove").should be_true
+end
+
+Then /^I should not see delete on the "([^"]*)"$/ do |role|
+  page.has_css?("#site_memberships_input div.entry[data-role=#{role}] .actions a.remove").should be_false
+end
+
+Then /^I should not see delete on myself$/ do
+  step %{I should not see delete on the "#{@member.role}"}
+end
+
+Then /^I should not see any delete buttons$/ do
+ page.has_css?('#site_memberships_input div.entry .actions a.remove').should be_false
+end
+
+When /^I select the "([^"]*)" role for the "author" user/ do |role|
+  step %{I select "#{role}" from "site[memberships_attributes][2][role]"}
+end

data/features/step_definitions/editable_elements_steps.rb

@@ -0,0 +1,24 @@
+# modify an editable element
+Given /^the editable element "([^"]*)" in the "([^"]*)" page with the content "([^"]*)"$/ do |slug, page_slug, content|
+  page = @site.pages.where(:slug => page_slug).first
+  page.find_editable_element(nil, slug).content = content
+  page.save!
+end
+
+# modify an editable element
+Given /^the editable element "([^"]*)" for the "([^"]*)" block in the "([^"]*)" page with the content "([^"]*)"$/ do |slug, block, page_slug, content|
+  page = @site.pages.where(:slug => page_slug).first
+  page.find_editable_element(block, slug).content = content
+  page.save!
+end
+
+When /^I type the content "([^"]*)" into the first editable field$/ do |content|
+  page.execute_script %{
+    $(document).ready(function() {
+      editable = GENTICS.Aloha.editables[0];
+      editable.obj.text('#{content}');
+      editable.blur();
+    });
+  }
+end
+