locomotivecms 3.0.0.pre.alpha

data/features/step_definitions/membership_steps.rb

@@ -0,0 +1,19 @@
+
+Given /^I have accounts:$/ do |accounts_table|
+  accounts_table.hashes.each do |account_hash|
+    FactoryGirl.create(:account, account_hash)
+  end
+end
+
+Given /^I have memberships:$/ do |members_table|
+  members_table.hashes.each do |member_hash|
+    email = member_hash[:email]
+    account = Locomotive::Account.where(:email => email).first \
+      || FactoryGirl.create(:account, :email => email)
+
+    member_hash.delete(:email)
+    member_hash.merge!({ :account => account, :site => @site })
+
+    FactoryGirl.create(:membership, member_hash)
+  end
+end

data/features/step_definitions/more_web_steps.rb

@@ -0,0 +1,131 @@
+When(/^the locale of the current ruby thread changes to "(.*?)"$/) do |locale|
+  ::I18n.locale = ::Mongoid::Fields::I18n.locale = 'fr'
+end
+
+When /^I follow image link "([^"]*)"$/ do |img_alt|
+  find(:xpath, "//img[@alt = '#{img_alt}']/parent::a").click()
+end
+
+When /^I click on the "([^"]*)" folder$/ do |name|
+  find('fieldset.foldable legend span', text: name).click
+end
+
+Then /^I should get a download with the filename "([^\"]*)"$/ do |filename|
+  page.response_headers['Content-Disposition'].should include("filename=#{filename}")
+end
+
+When /^I wait until "([^"]*)" is visible$/ do |selector|
+  page.has_css?("#{selector}", visible: true)
+end
+
+When /^I wait until ([^"]*) is visible$/ do |locator|
+  page.has_css?(selector_for(locator), visible: true)
+end
+
+When /^I sync my form with my backbone model because of Firefox$/ do
+  page.execute_script("$(':input').trigger('change')")
+end
+
+When /^I fill in "(.*?)" with the tags "(.*?)"$/ do |field, tags|
+  input = field_labeled(field)
+  tags.split(',').each do |tag|
+    _tag = tag.strip
+    page.execute_script("$('input[name=\"#{input[:name]}\"]').tagit('createTag', '#{_tag}')")
+  end
+end
+
+Then /^"([^"]*)" should not be visible$/ do |text|
+  begin
+    assert page.find(text).visible? != true
+  rescue Capybara::ElementNotFound
+  end
+end
+
+Then(/^I should see "(.*?)" in the html code$/) do |content|
+  page.body.include?(content).should be_true
+end
+
+Then(/^I should not see "(.*?)" in the html code$/) do |content|
+  page.body.include?(content).should be_false
+end
+
+Then /^"([^"]*)" should( not)? be an option for "([^"]*)"(?: within "([^\"]*)")?$/ do |value, negate, field, selector|
+  with_scope(selector) do
+    expectation = negate ? :should_not : :should
+    field_labeled(field).first(:xpath, ".//option[text() = '#{value}']").send(expectation, be_present)
+  end
+end
+
+Then /^"([^"]*)" should be selected for "([^"]*)"$/ do |value, field|
+  assert page.has_xpath?("//select[@name='#{field}' and option[@selected and contains(text(), '#{value}')]]")
+end
+
+When /^I reload the page$/ do
+  visit current_path
+end
+
+When(/^I switch the locale to "(.*?)"$/) do |locale|
+  click_on 'content-locale-picker-link'
+  within '#content-locale-picker' do
+    find("[data-locale='#{locale}']").click
+  end
+end
+
+Then(/^I should see a "(.*?)" link to "(.*?)"$/) do |text, path|
+  page.should have_link(text, href: path)
+end
+
+Given /^I enable the CSRF protection for public submission requests$/ do
+  Locomotive.config.csrf_protection = true
+  Locomotive::Public::ContentEntriesController.any_instance.stubs(:protect_against_forgery?).returns(true)
+end
+
+Given /^I disable the CSRF protection for public submission requests$/ do
+  Locomotive.config.csrf_protection = false
+  # pending # express the regexp above with the code you wish you had
+end
+
+Then /^the response status should be (\d+)$/ do |status|
+  page.status_code.should == status.to_i
+end
+
+Then /^it returns a (\d+) error page$/ do |code|
+  page.status_code.should == code.to_i
+end
+
+Then /^I should see the following xml output:$/ do |xml_output|
+  xml_output.gsub!(':now', Time.now.utc.to_date.to_s)
+  response = Hash.from_xml(page.source)
+  expected = Hash.from_xml(xml_output)
+  expected.diff(response).should == {}
+end
+
+When /^I take a screenshot$/ do
+  page.save_screenshot('/Users/didier/Desktop/cucumber.png', full: true)
+end
+
+def wait_for_ajax(&block)
+  start_time = Time.now
+  while Time.now < start_time + Capybara.default_wait_time
+    begin
+      block.call
+      break
+    rescue RSpec::Expectations::ExpectationNotMetError => e
+      raise e
+    rescue
+      # Try again
+    end
+  end
+end
+
+Then /^after the AJAX finishes, (.*)$/ do |*args|
+  step_str = args[0]
+  step_arg = args[1]
+  wait_for_ajax do
+    step(step_str, step_arg)
+  end
+end
+
+When(/^I wait (\d+)ms$/) do |delay|
+  sleep(delay.to_i / 1000.0)
+end

data/features/step_definitions/page_steps.rb

@@ -0,0 +1,133 @@
+### Pages
+
+# helps create a simple content page (parent: "index") with a slug and template
+def create_content_page(slug, template = nil)
+  new_content_page(slug, template).tap do |page|
+    page.save!.should be_true
+  end
+  # page = new_content_page(slug, page_contents, template)
+  # raise "Invalid page: #{page.errors.full_messages}" unless page.valid?
+  # page.should be_valid
+  # page.save!
+  # page
+end
+
+# build page without saving
+def new_content_page(slug, template = nil)
+  @home = @site.pages.where(slug: 'index').first || FactoryGirl.create(:page)
+  title = slug.gsub(/-/, '_').humanize
+  @site.pages.new(title: title, slug: slug, parent: @home, published: true, raw_template: template)
+end
+
+# creates a page
+# Given /^a simple page named "([^"]*)" with the body:$/ do |page_slug, page_contents|
+#   @page = create_content_page(page_slug, page_contents)
+# end
+
+Given /^a page named "([^"]*)" with the template:$/ do |slug, template|
+  @page = create_content_page(slug, template)
+end
+
+Given /^a page named "([^"]*)" with id "([^"]*)"$/ do |slug, id|
+  @page = new_content_page(slug, '')
+  @page.id = BSON::ObjectId(id)
+  @page.save!
+end
+
+Given /^a page named "([^"]*)" with id "([^"]*)" and template:$/ do |slug, id, template|
+  @page = new_content_page(slug, template)
+  @page.id = BSON::ObjectId(id)
+  @page.save!
+end
+
+Given(/^a page named "(.*?)" with the handle "(.*?)"$/) do |slug, handle|
+  page = new_content_page(slug, '')
+  page.handle = handle
+  page.save!
+end
+
+Given(/^the page named "(.*?)" has the title "(.*?)" in the "(.*?)" locale$/) do |slug, title, locale|
+  page = @site.pages.where(slug: slug).first
+  ::Mongoid::Fields::I18n.with_locale(locale) do
+    page.update_attributes!(title: title, slug: title.permalink)
+  end
+end
+
+Given /^a templatized page for the "(.*?)" model and with the template:$/ do |model_name, template|
+  content_type = Locomotive::ContentType.where(name: model_name).first
+  parent = create_content_page(content_type.slug, '')
+  @page = @site.pages.new(parent: parent, title: "Template for #{model_name}", published: true,
+    templatized: true, target_klass_name: content_type.entries_class_name,
+    raw_template: template)
+  @page.save!
+end
+
+# change the title
+When /^I change the page title to "([^"]*)"$/ do |title|
+  page.evaluate_script "window.prompt = function() { return '#{title}'; }"
+  page.find('h2 a.editable').click
+end
+
+# change the template
+When /^I change the page template to "([^"]*)"$/ do |template|
+  page.evaluate_script "window.application_view.view.model.set({ 'raw_template': '#{template}' })"
+end
+
+# update a page
+When /^I update the "([^"]*)" page with the template:$/ do |slug, template|
+  page = @site.pages.where(slug: slug).first
+  page.raw_template = template
+  page.save!
+end
+
+Given /^I delete the following code "([^"]*)" from the "([^"]*)" page$/ do |code, slug|
+  page = @site.pages.where(slug: slug).first
+  page.raw_template = page.raw_template.gsub(code, '')
+  page.save!
+end
+
+Given(/^the page "(.*?)" is unpublished$/) do |slug|
+  page = @site.pages.where(slug: slug).first
+  page.published = false
+  page.save!
+end
+
+
+# try to render a page by slug
+When /^I view the rendered page at "([^"]*)"$/ do |path|
+  # If we're running poltergeist then we need to use a different port
+  if Capybara.current_driver == :poltergeist
+    visit "http://#{@site.domains.first}:#{Capybara.server_port}#{path}"
+  else
+    visit "http://#{@site.domains.first}#{path}"
+  end
+end
+
+# checks to see if a string is in the slug
+Then /^I should have "(.*)" in the (.*) page$/ do |content, slug|
+  page = @site.pages.where(slug: slug).first
+  raise "Could not find page: #{slug}" unless page
+  page.raw_template.should == content
+end
+
+# checks if the rendered body matches a string
+Then /^the rendered output should look like:$/ do |body_contents|
+  # page.source.should == body_contents
+  page.source.index(body_contents).should_not be_nil
+end
+
+Then /^I should see delete page buttons$/ do
+  page.has_css?("ul#pages-list li .more a.remove").should be_true
+end
+
+Then /^I should not see delete page buttons$/ do
+  page.has_css?("ul#pages-list li .more a.remove").should be_false
+end
+
+Then /^updated_at of the (.*) page should respect site's timezone$/ do |slug|
+  edited_page = @site.pages.where(slug: slug).first
+  t = edited_page.updated_at.in_time_zone(@site.timezone)
+  page.source.should =~ /#{t.strftime('%-d %b %H:%M')}/
+end
+
+

data/features/step_definitions/pagination_steps.rb

@@ -0,0 +1,35 @@
+Then /^I should be able to display paginated models$/ do
+  # Create our article model and three articles
+  @article_model = FactoryGirl.build(:content_type, site: @site, name: 'Articles', order_by: '_position').tap do |ct|
+    ct.entries_custom_fields.build label: 'Body', type: 'string', required: false
+    ct.save!
+  end
+
+  %w(First Second Third).each do |body|
+    @article_model.entries.create!(body: body)
+  end
+
+  # Create a page with template
+  raw_template = %{
+  {% paginate contents.articles by 2 %}
+    {% for article in paginate.collection %}
+      {{ article.body }}
+    {% endfor %}
+    {{ paginate | default_pagination }}
+  {% endpaginate %}
+  }
+  FactoryGirl.create(:page, site: @site, slug: 'hello', parent: @site.pages.root.first, raw_template: raw_template)
+
+  # The page should have the first two articles
+  visit '/hello'
+  page.should have_content 'First'
+  page.should have_content 'Second'
+  page.should_not have_content 'Third'
+
+  # The second page should have the last article
+  click_link '2'
+  page.should_not have_content 'First'
+  page.should_not have_content 'Second'
+  page.should     have_content 'Third'
+end
+

data/features/step_definitions/pickle_steps.rb

@@ -0,0 +1,100 @@
+# this file generated by script/generate pickle
+
+# create a model
+Given(/^#{capture_model} exists?(?: with #{capture_fields})?$/) do |name, fields|
+  create_model(name, fields)
+end
+
+# create n models
+Given(/^(\d+) #{capture_plural_factory} exist(?: with #{capture_fields})?$/) do |count, plural_factory, fields|
+  count.to_i.times { create_model(plural_factory.singularize, fields) }
+end
+
+# create models from a table
+Given(/^the following #{capture_plural_factory} exists?:?$/) do |plural_factory, table|
+  create_models_from_table(plural_factory, table)
+end
+
+# find a model
+Then(/^#{capture_model} should exist(?: with #{capture_fields})?$/) do |name, fields|
+  find_model!(name, fields)
+end
+
+# not find a model
+Then(/^#{capture_model} should not exist(?: with #{capture_fields})?$/) do |name, fields|
+  find_model(name, fields).should be_nil
+end
+
+# find models with a table
+Then(/^the following #{capture_plural_factory} should exists?:?$/) do |plural_factory, table|
+  find_models_from_table(plural_factory, table).should_not be_any(&:nil?)
+end
+
+# find exactly n models
+Then(/^(\d+) #{capture_plural_factory} should exist(?: with #{capture_fields})?$/) do |count, plural_factory, fields|
+  find_models(plural_factory.singularize, fields).size.should == count.to_i
+end
+
+# assert equality of models
+Then(/^#{capture_model} should be #{capture_model}$/) do |a, b|
+  model!(a).should == model!(b)
+end
+
+# assert model is in another model's has_many assoc
+Then(/^#{capture_model} should be (?:in|one of|amongst) #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
+  model!(owner).send(association).should include(model!(target))
+end
+
+# assert model is not in another model's has_many assoc
+Then(/^#{capture_model} should not be (?:in|one of|amongst) #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
+  model!(owner).send(association).should_not include(model!(target))
+end
+
+# assert model is another model's has_one/belongs_to assoc
+Then(/^#{capture_model} should be #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
+  model!(owner).send(association).should == model!(target)
+end
+
+# assert model is not another model's has_one/belongs_to assoc
+Then(/^#{capture_model} should not be #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
+  model!(owner).send(association).should_not == model!(target)
+end
+
+# assert model.predicate? 
+Then(/^#{capture_model} should (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
+  if model!(name).respond_to?("has_#{predicate.gsub(' ', '_')}")
+    model!(name).should send("have_#{predicate.gsub(' ', '_')}")
+  else
+    model!(name).should send("be_#{predicate.gsub(' ', '_')}")
+  end
+end
+
+# assert not model.predicate?
+Then(/^#{capture_model} should not (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
+  if model!(name).respond_to?("has_#{predicate.gsub(' ', '_')}")
+    model!(name).should_not send("have_#{predicate.gsub(' ', '_')}")
+  else
+    model!(name).should_not send("be_#{predicate.gsub(' ', '_')}")
+  end
+end
+
+# model.attribute.should eql(value)
+# model.attribute.should_not eql(value)
+Then(/^#{capture_model}'s (\w+) (should(?: not)?) be #{capture_value}$/) do |name, attribute, expectation, expected|
+  actual_value  = model(name).send(attribute)
+  expectation   = expectation.gsub(' ', '_')
+  
+  case expected
+  when 'nil', 'true', 'false'
+    actual_value.send(expectation, send("be_#{expected}"))
+  when /^[+-]?[0-9_]+(\.\d+)?$/
+    actual_value.send(expectation, eql(expected.to_f))
+  else
+    actual_value.to_s.send(expectation, eql(eval(expected)))
+  end
+end
+
+# assert size of association
+Then /^#{capture_model} should have (\d+) (\w+)$/ do |name, size, association|
+  model!(name).send(association).size.should == size.to_i
+end

data/features/step_definitions/relationships_steps.rb

@@ -0,0 +1,110 @@
+Given %r{^I have an? "([^"]*)" model which has many "([^"]*)"$} do |parent_model, child_model|
+  @parent_model = FactoryGirl.build(:content_type, site: @site, name: parent_model).tap do |ct|
+    ct.entries_custom_fields.build label: 'Body', type: 'string', required: false
+    ct.save!
+  end
+  @child_model = FactoryGirl.build(:content_type, site: @site, name: child_model).tap do |ct|
+    ct.entries_custom_fields.build label: 'Body', type: 'string', required: false
+    ct.entries_custom_fields.build label: parent_model.singularize.downcase, type: 'belongs_to', required: false, class_name: @parent_model.entries_class_name
+    ct.save!
+  end
+
+  @parent_model.entries_custom_fields.build({
+    label:          child_model,
+    type:           'has_many',
+    class_name:     @child_model.entries_class_name,
+    inverse_of:     parent_model.singularize.downcase
+  })
+
+  @parent_model.save
+end
+
+Given %r{^I set up a has_many relationship between "([^"]*)" and "([^"]*)"$} do |source_name, target_name|
+  source_model = @site.content_types.where(name: source_name).first
+  target_model = @site.content_types.where(name: target_name).first
+
+  source_model.entries_custom_fields.build({
+    label:          target_name,
+    type:           'has_many',
+    class_name:     target_model.entries_class_name,
+    inverse_of:     source_name.singularize.downcase
+  })
+
+  source_model.save
+end
+
+Given %r{^I set up a many_to_many relationship between "([^"]*)" and "([^"]*)"$} do |first_name, last_name|
+  first_model = @site.content_types.where(name: first_name).first
+  last_model  = @site.content_types.where(name: last_name).first
+
+  first_model.entries_custom_fields.build({
+    label:          last_name,
+    type:           'many_to_many',
+    class_name:     last_model.entries_class_name,
+    inverse_of:     first_name.pluralize.downcase
+  })
+
+  first_model.save
+
+  last_model.entries_custom_fields.build({
+    label:          first_name,
+    type:           'many_to_many',
+    class_name:     first_model.entries_class_name,
+    inverse_of:     last_name.pluralize.downcase
+  })
+
+  last_model.save
+end
+
+Given %r{^I attach the "([^"]*)" ([\S]*) to the "([^"]*)" ([\S]*)$} do |target_name, target_model_name, souce_name, source_model_name|
+  target_model  = @site.content_types.where(name: target_model_name.pluralize.capitalize).first
+  source_model  = @site.content_types.where(name: source_model_name.pluralize.capitalize).first
+
+  target_entry = target_model.entries.where(_slug: target_name.permalink).first
+  source_entry = source_model.entries.where(_slug: souce_name.permalink).first
+
+  source_entry.send(target_model_name.pluralize.downcase.parameterize('_').to_sym).push(target_entry)
+end
+
+Then /^I should be able to view a paginated list of a has many association$/ do
+  # Create models
+  step %{I have an "Articles" model which has many "Comments"}
+
+  # Create contents
+  article = @parent_model.entries.create!(slug: 'parent', body: 'Parent')
+  @child_model.entries.create!(slug: 'one', body: 'One', article: article)
+  @child_model.entries.create!(slug: 'two', body: 'Two', article: article)
+  @child_model.entries.create!(slug: 'three', body: 'Three', article: article)
+  @child_model.entries.create!(slug: 'four', body: 'Four', article: article, _visible: false)
+
+  # Create a page
+  raw_template = %{
+  {% for article in models.articles %}
+    {{ article.body }}
+    {% paginate article.comments by 2 %}
+      {% for comment in paginate.collection %}
+        {{ comment.body }}
+      {% endfor %}
+      {{ paginate | default_pagination }}
+    {% endpaginate %}
+  {% endfor %}
+  }
+
+  # Create a page
+  FactoryGirl.create(:page, site: @site, slug: 'hello', parent: @site.pages.root.first, raw_template: raw_template)
+
+  # The page should have the first two comments
+  visit '/hello'
+
+  page.should have_content 'One'
+  page.should have_content 'Two'
+  page.should_not have_content 'Three'
+  page.should_not have_content 'Four'
+
+  # The second page should have the last comment
+  click_link '2'
+  page.should_not have_content 'One'
+  page.should_not have_content 'Two'
+  page.should     have_content 'Three'
+  page.should_not have_content 'Four'
+end