xrono 1.0.0

data/features/step_definitions/file_attachment_steps.rb

@@ -0,0 +1,8 @@
+Given /^the following file attachments:$/ do |file_attachments|
+  FileAttachment.create!(clients.hashes)
+end
+
+When /^I attach a file$/ do
+  attach_file("file_attachment[attachment_file]", File.join(::Rails.root.to_s,'..', '..', 'features', 'step_definitions', 'file_attachment_steps.rb'))
+end
+

data/features/step_definitions/modified_web_steps.rb

@@ -0,0 +1,25 @@
+Then /^the "([^"]*)" field(?: under (.*))? should hold "([^"]*)"$/ do |field, parent, value|
+  with_scope(parent) do
+    field = find_field(field)
+    field_value = (field.tag_name == 'textarea') ? field.text : field.value
+    if field_value.respond_to? :should
+      field_value.should =~ /#{value}/
+    else
+      assert_match(/#{value}/, field_value)
+    end
+  end
+end
+
+Then /^"([^"]*)" should be seen within "([^"]*)"$/ do |value, field|
+  assert page.has_xpath?("//option[contains(string(), '#{value}')]") 
+end
+
+Then /^"([^\"]+)" should not be visible$/ do |text|
+  paths = [
+    "//*[@class='hidden']/*[contains(.,'#{text}')]",
+    "//*[@class='invisible']/*[contains(.,'#{text}')]",
+    "//*[@style='display: none;']/*[contains(.,'#{text}')]"
+  ]
+  xpath = paths.join '|'
+  page.should have_xpath(xpath)
+end

data/features/step_definitions/pickle_steps.rb

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+# 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/project_steps.rb

@@ -0,0 +1,32 @@
+Given /^I am assigned to the project$/ do
+  User.last.has_role!(:developer, Project.last)
+end
+
+Given /^the following projects:$/ do |projects|
+  client = Client.create(:name => 'test', :status => 'test')
+  projects.hashes.each do |hash|
+    Project.create(hash.merge(:client_id => client.id))
+  end
+end
+
+When /^I visit the projects index page for a given client$/ do
+  client = Client.create(:name => 'test', :status => 'test')
+  visit projects_path
+end
+
+When /^(?:|I )visit the new project page for a given client$/ do
+  client = Client.create(:name => 'test', :status => 'test')
+  visit new_client_project_path(client)
+end
+
+When /^I delete the (\d+)(?:st|nd|rd|th) project$/ do |pos|
+  visit projects_path
+  within("table tbody tr:nth-child(#{pos.to_i})") do
+    click_link "Destroy"
+  end
+end
+
+Then /^I should see the following projects:$/ do |expected_projects_table|
+  expected_projects_table.diff!(find('table').all('tr').map { |row| row.all('th, td').map { |cell| cell.text.strip } })
+end
+

data/features/step_definitions/search_steps.rb

@@ -0,0 +1,3 @@
+Given /^I can't access the search page for a work unit$/ do
+  visit "/work_units"
+end

data/features/step_definitions/ticket_board_steps.rb

@@ -0,0 +1,39 @@
+When /^I drag "([^"]*)" fridge ticket to "([^"]*)"$/ do |arg1, arg2|
+  ticket = page.find_by_id('fridge_ul').find('li')
+  development_bucket = page.find_by_id('development_ul')
+  ticket.drag_to(development_bucket)
+end
+
+Then /^the ticket named "([^"]*)" should have a state of "([^"]*)"$/ do |ticket_name, state|
+  ticket = Ticket.find_by_name ticket_name
+  ticket.state.should == state
+end
+
+Then /^ticket "([^"]*)" should appear in "([^"]*)" bucket$/ do |ticket_name, bucket|
+  ticket = page.find_by_id("#{bucket}_ul").find('li')  
+end
+
+When /^I drag "([^"]*)" development ticket to "([^"]*)"$/ do |arg1, arg2|
+  ticket = page.find_by_id('development_ul').find('li')
+  peer_review_bucket = page.find_by_id('peer_review_ul')
+  ticket.drag_to(peer_review_bucket)
+end
+
+When /^I drag "([^"]*)" peer_review ticket to "([^"]*)"$/ do |arg1, arg2|
+  ticket = page.find_by_id('peer_review_ul').find('li')
+  user_acceptance_bucket = page.find_by_id('user_acceptance_ul')
+  ticket.drag_to(user_acceptance_bucket)
+end
+
+When /^I drag "([^"]*)" user_acceptance ticket to "([^"]*)"$/ do |arg1, arg2|
+  ticket = page.find_by_id('user_acceptance_ul').find('li')
+  archived_bucket = page.find_by_id('archived_ul')
+  ticket.drag_to(archived_bucket)
+end
+
+Then /^the ticket named "([^"]*)" in "([^"]*)" should have html id equal to ActiveRecord model id$/ do |ticket_name, bucket|
+  ticket_AR = Ticket.find_by_name ticket_name
+  ticket_HTML = page.find_by_id("#{bucket}_ul").find('li')
+  ticket_HTML["id"].should == ticket_AR.id.to_s
+end
+

data/features/step_definitions/ticket_detail_steps.rb

@@ -0,0 +1,9 @@
+When /^(?:|I )double[-\s]?click "([^"]*)"$/ do |locator|
+  element = page.find_by_id('fridge_ul').find('li')
+  page.driver.browser.mouse.double_click(element.native)
+end
+
+Given /^ticket "([^"]*)" has a work unit with description: "([^"]*)"$/ do |ticket_name, desc|
+  ticket = Ticket.find_by_name ticket_name
+  WorkUnit.create!(:hours_type => "Normal", :description => desc, :ticket_id => ticket.id, :hours => 8, :scheduled_at => "2010-10-01 12:00:00", :user_id => @current_user.id) 
+end

data/features/step_definitions/ticket_steps.rb

@@ -0,0 +1,12 @@
+Then /^I should see the following tickets:$/ do |expected_tickets_table|
+  expected_tickets_table.diff!(find('table').all('tr').map { |row| row.all('th, td').map { |cell| cell.text.strip } })
+end
+
+Then /^I should be able to create a new ticket$/ do
+  step %{I follow "New Ticket"}
+  step %{I fill in "Name" with "test"}
+  step %{I fill in "Description" with "test description"}
+  step %{I press "Create Ticket"}
+  step %{I should see "Ticket created successfully"}
+end
+

data/features/step_definitions/unentered_time_report_steps.rb

@@ -0,0 +1,3 @@
+Given /^user is assigned to the project$/ do
+  User.last.has_role!(:developer, Project.last)
+end

data/features/step_definitions/user_steps.rb

@@ -0,0 +1,43 @@
+Given /^the following user records:$/ do |users|
+  users.hashes.each do |user|
+    the_role = user.delete("role")
+    u = User.create(user)
+    # add role
+    u.has_role!(the_role.to_sym)
+  end
+end
+
+Given /^the user "([^"]*)" has (?:a|an) "([^"]*)" role(?: on #{capture_model})?$/ do |email, role, model_name|
+  if model_name
+    User.find_by_email(email).has_role!(role.to_sym, find_model(model_name))
+  else
+    User.find_by_email(email).has_role!(role.to_sym)
+  end
+end
+
+When /^I delete the (\d+)(?:st|nd|rd|th) user$/ do |pos|
+  visit admin_users_path
+  within("table tbody tr:nth-child(#{pos.to_i})") do
+    click_button "Destroy"
+  end
+end
+
+Then /^there should be a user with a client login in the database$/ do
+  email = "client_login@user.com"
+  User.find(:all, :conditions => ["email = ? AND client = ?", email, true]).any?.should == true
+end
+
+Given /^I am an authenticated client on an existing project page$/ do
+  visit destroy_user_session_path
+  current_user = User.make(:email => "current_user@example.com", :password => "password", :password_confirmation => "password")
+  current_user.has_role!("client")
+  c = Client.create(:name => "Test Client", :status => "Active")
+  p = Project.create(:name => "Test Project", :client_id => c.id)
+  current_user.has_role!(:client, p)
+  visit new_user_session_path
+  step %{I fill in "user_email" with "current_user@example.com"}
+  step %{I fill in "user_password" with "password"}
+  step %{I press "Sign in"}
+  visit client_login_project_path(p)
+end
+

data/features/step_definitions/web_steps.rb

@@ -0,0 +1,274 @@
+# TL;DR: YOU SHOULD DELETE THIS FILE
+#
+# This file was generated by Cucumber-Rails and is only here to get you a head start
+# These step definitions are thin wrappers around the Capybara/Webrat API that lets you
+# visit pages, interact with widgets and make assertions about page content.
+#
+# If you use these step definitions as basis for your features you will quickly end up
+# with features that are:
+#
+# * Hard to maintain
+# * Verbose to read
+#
+# A much better approach is to write your own higher level step definitions, following
+# the advice in the following blog posts:
+#
+# * http://benmabey.com/2008/05/19/imperative-vs-declarative-scenarios-in-user-stories.html
+# * http://dannorth.net/2011/01/31/whose-domain-is-it-anyway/
+# * http://elabs.se/blog/15-you-re-cuking-it-wrong
+#
+
+
+require 'uri'
+require 'cgi'
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "paths"))
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "selectors"))
+
+module WithinHelpers
+  def with_scope(locator)
+    locator ? within(*selector_for(locator)) { yield } : yield
+  end
+end
+World(WithinHelpers)
+
+# Single-line step scoper
+When /^(.*) within (.*[^:])$/ do |step_name, parent|
+  with_scope(parent) { step step_name }
+end
+
+# Multi-line step scoper
+When /^(.*) within (.*[^:]):$/ do |step_name, parent, table_or_string|
+  with_scope(parent) { step "#{step_name}:", table_or_string }
+end
+
+Given /^(?:|I )am on (.+)$/ do |page_name|
+  visit path_to(page_name)
+end
+
+When /^(?:|I )go to (.+)$/ do |page_name|
+  visit path_to(page_name)
+end
+
+Given /^(?:|I )visit (.+)$/ do |path|
+    visit path
+end
+
+When /^(?:|I )press "([^"]*)"$/ do |button|
+  click_button(button)
+end
+
+When /^(?:|I )follow "([^"]*)"$/ do |link|
+  click_link(link)
+end
+
+When /^(?:|I )follow ([^"]*)$/ do |link|
+  find(*selector_for(link)).click
+end
+
+When /^(?:|I )fill in "([^"]*)" with "([^"]*)"$/ do |field, value|
+  fill_in(field, :with => value)
+end
+
+When /^(?:|I )fill in "([^"]*)" for "([^"]*)"$/ do |value, field|
+  fill_in(field, :with => value)
+end
+
+# Use this to fill in an entire form with data from a table. Example:
+#
+#   When I fill in the following:
+#     | Account Number | 5002       |
+#     | Expiry date    | 2009-11-01 |
+#     | Note           | Nice guy   |
+#     | Wants Email?   |            |
+#
+# TODO: Add support for checkbox, select or option
+# based on naming conventions.
+#
+When /^(?:|I )fill in the following:$/ do |fields|
+  fields.rows_hash.each do |name, value|
+    step %{I fill in "#{name}" with "#{value}"}
+  end
+end
+
+When /^(?:|I )select "([^"]*)" from "([^"]*)"$/ do |value, field|
+  select(value, :from => field)
+end
+
+When /^(?:|I )check "([^"]*)"$/ do |field|
+  check(field)
+end
+
+When /^(?:|I )uncheck "([^"]*)"$/ do |field|
+  uncheck(field)
+end
+
+When /^(?:|I )choose "([^"]*)"$/ do |field|
+  choose(field)
+end
+
+When /^(?:|I )attach the file "([^"]*)" to "([^"]*)"$/ do |path, field|
+  attach_file(field, File.expand_path(path))
+end
+
+Then /^(?:|I )should see "([^"]*)"$/ do |text|
+  if page.respond_to? :should
+    page.should have_content(text)
+  else
+    assert page.has_content?(text)
+  end
+end
+
+Then /^(?:|I )should see \/([^\/]*)\/$/ do |regexp|
+  regexp = Regexp.new(regexp)
+
+  if page.respond_to? :should
+    page.should have_xpath('//*', :text => regexp)
+  else
+    assert page.has_xpath?('//*', :text => regexp)
+  end
+end
+
+Then /^(?:|I )should not see "([^"]*)"$/ do |text|
+  if page.respond_to? :should
+    page.should have_no_content(text)
+  else
+    assert page.has_no_content?(text)
+  end
+end
+
+Then /^(?:|I )should not see \/([^\/]*)\/$/ do |regexp|
+  regexp = Regexp.new(regexp)
+
+  if page.respond_to? :should
+    page.should have_no_xpath('//*', :text => regexp)
+  else
+    assert page.has_no_xpath?('//*', :text => regexp)
+  end
+end
+
+Then /^the "([^"]*)" field(?: under (.*))? should contain "([^"]*)"$/ do |field, parent, value|
+  with_scope(parent) do
+    field = find_field(field)
+    field_value = (field.tag_name == 'textarea') ? field.text : field.value
+    if field_value.respond_to? :should
+      field_value.should =~ /#{value}/
+    else
+      assert_match(/#{value}/, field_value)
+    end
+  end
+end
+
+Then /^the "([^"]*)" field(?: under (.*))? should not contain "([^"]*)"$/ do |field, parent, value|
+  with_scope(parent) do
+    field = find_field(field)
+    field_value = (field.tag_name == 'textarea') ? field.text : field.value
+    if field_value.respond_to? :should_not
+      field_value.should_not =~ /#{value}/
+    else
+      assert_no_match(/#{value}/, field_value)
+    end
+  end
+end
+
+Then /^the "([^"]*)" field should have the error "([^"]*)"$/ do |field, error_message|
+  element = find_field(field)
+  classes = element.find(:xpath, '..')[:class].split(' ')
+
+  form_for_input = element.find(:xpath, 'ancestor::form[1]')
+  using_formtastic = form_for_input[:class].include?('formtastic')
+  error_class = using_formtastic ? 'error' : 'field_with_errors'
+
+  if classes.respond_to? :should
+    classes.should include(error_class)
+  else
+    assert classes.include?(error_class)
+  end
+
+  if page.respond_to?(:should)
+    if using_formtastic
+      error_paragraph = element.find(:xpath, '../*[@class="inline-errors"][1]')
+      error_paragraph.should have_content(error_message)
+    else
+      page.should have_content("#{field.titlecase} #{error_message}")
+    end
+  else
+    if using_formtastic
+      error_paragraph = element.find(:xpath, '../*[@class="inline-errors"][1]')
+      assert error_paragraph.has_content?(error_message)
+    else
+      assert page.has_content?("#{field.titlecase} #{error_message}")
+    end
+  end
+end
+
+Then /^the "([^"]*)" field should have no error$/ do |field|
+  element = find_field(field)
+  classes = element.find(:xpath, '..')[:class].split(' ')
+  if classes.respond_to? :should
+    classes.should_not include('field_with_errors')
+    classes.should_not include('error')
+  else
+    assert !classes.include?('field_with_errors')
+    assert !classes.include?('error')
+  end
+end
+
+Then /^the "([^"]*)" checkbox(?: under (.*))? should be checked$/ do |label, parent|
+  with_scope(parent) do
+    field_checked = find_field(label)['checked']
+    if field_checked.respond_to? :should
+      field_checked.should be_true
+    else
+      assert field_checked
+    end
+  end
+end
+
+Then /^the "([^"]*)" checkbox(?: under (.*))? should not be checked$/ do |label, parent|
+  with_scope(parent) do
+    field_checked = find_field(label)['checked']
+    if field_checked.respond_to? :should
+      field_checked.should be_false
+    else
+      assert !field_checked
+    end
+  end
+end
+ 
+Then /^(?:|I )should be on (.+)$/ do |page_name|
+  current_path = URI.parse(current_url).path
+  if current_path.respond_to? :should
+    current_path.should == path_to(page_name)
+  else
+    assert_equal path_to(page_name), current_path
+  end
+end
+
+Then /^I should see a link with text "([^\"]*)"$/ do |text|
+  page.should have_link(text)
+end
+
+Then /^I should see selector ([^\"]*)$/ do |text|
+  page.should have_selector(*selector_for(text))
+end
+
+Then /^I should not see a link with text "([^\"]*)"$/ do |text|
+  page.should have_no_link(text)
+end
+
+Then /^(?:|I )should have the following query string:$/ do |expected_pairs|
+  query = URI.parse(current_url).query
+  actual_params = query ? CGI.parse(query) : {}
+  expected_params = {}
+  expected_pairs.rows_hash.each_pair{|k,v| expected_params[k] = v.split(',')}
+
+  if actual_params.respond_to? :should
+    actual_params.should == expected_params
+  else
+    assert_equal expected_params, actual_params
+  end
+end
+
+Then /^show me the page$/ do
+  save_and_open_page
+end