quilted-harvested 0.3.1

data/features/step_definitions/assignment_steps.rb

@@ -0,0 +1,100 @@
+When 'I create and assign a task "$1" to the project "$2"' do |task_name, project_name|
+  project = Then %Q{there should be a project "#{project_name}"}
+  p = harvest_api.projects.create_task(project, task_name)
+  p.should == project
+end
+
+When 'I assign the task "$1" to the project "$2"' do |task_name, project_name|
+  task = Then %Q{there should be a task "#{task_name}"}
+  project = Then %Q{there should be a project "#{project_name}"}
+  assignment = Harvest::TaskAssignment.new(:project => project, :task => task)
+  harvest_api.task_assignments.create(assignment)
+end
+
+Then 'the task "$1" should be assigned to the project "$2"' do |task_name, project_name|
+  task = Then %Q{there should be a task "#{task_name}"}
+  project = Then %Q{there should be a project "#{project_name}"}
+  assignments = harvest_api.task_assignments.all(project)
+  assignment = assignments.detect {|a| a.project_id == project.to_i && a.task_id == task.to_i }
+  assignment.should_not be_nil
+  assignment
+end
+
+Then 'the task "$1" should not be assigned to the project "$2"' do |task_name, project_name|
+  task = Then %Q{there should be a task "#{task_name}"}
+  project = Then %Q{there should be a project "#{project_name}"}
+  assignments = harvest_api.task_assignments.all(project)
+  assignment = assignments.detect {|a| a.project_id == project.to_i && a.task_id == task.to_i }
+  assignment.should be_nil
+end
+
+When 'I update the task "$1" for the project "$2" with the following:' do |task_name, project_name, table|
+  assignment = Then %Q{the task "#{task_name}" should be assigned to the project "#{project_name}"}
+  assignment.attributes = table.rows_hash
+  harvest_api.task_assignments.update(assignment)
+end
+
+Then 'the task "$1" for the project "$2" should have the following attributes:' do |task_name, project_name, table|
+  assignment = Then %Q{the task "#{task_name}" should be assigned to the project "#{project_name}"}
+  table.rows_hash.each do |key, value|
+    assignment.send(key).to_s.should == value
+  end
+end
+
+When 'I remove the task "$1" from the project "$2"' do |task_name, project_name|
+  assignment = Then %Q{the task "#{task_name}" should be assigned to the project "#{project_name}"}
+  id = harvest_api.task_assignments.delete(assignment)
+  id.should == assignment.id
+end
+
+When 'I try to remove the task "$1" from the project "$2"' do |task_name, project_name|
+  assignment = Then %Q{the task "#{task_name}" should be assigned to the project "#{project_name}"}
+  begin
+    harvest_api.task_assignments.delete(assignment)
+  rescue Harvest::HTTPError => e
+    @error = e
+  end
+end
+
+When 'I assign the user "$1" to the project "$2"' do |email, project_name|
+  user = Then %Q{there should be a user "#{email}"}
+  project = Then %Q{there should be a project "#{project_name}"}
+  assignment = Harvest::UserAssignment.new(:project => project, :user => user)
+  harvest_api.user_assignments.create(assignment)
+end
+
+When 'I remove the user "$1" from the project "$2"' do |email, project_name|
+  assignment = Then %Q{the user "#{email}" should be assigned to the project "#{project_name}"}
+  id = harvest_api.user_assignments.delete(assignment)
+  id.should == assignment.id
+end
+
+Then 'the user "$1" should be assigned to the project "$2"' do |email, project_name|
+  user = Then %Q{there should be a user "#{email}"}
+  project = Then %Q{there should be a project "#{project_name}"}
+  assignments = harvest_api.user_assignments.all(project)
+  assignment = assignments.detect {|a| a.project_id == project.to_i && a.user_id == user.to_i }
+  assignment.should_not be_nil
+  assignment
+end
+
+Then 'the user "$1" should not be assigned to the project "$2"' do |email, project_name|
+  user = Then %Q{there should be a user "#{email}"}
+  project = Then %Q{there should be a project "#{project_name}"}
+  assignments = harvest_api.user_assignments.all(project)
+  assignment = assignments.detect {|a| a.project_id == project.to_i && a.user_id == user.to_i }
+  assignment.should be_nil
+end
+
+When 'I update the user "$1" on the project "$2" with the following:' do |email, project_name, table|
+  assignment = Then %Q{the user "#{email}" should be assigned to the project "#{project_name}"}
+  assignment.attributes = table.rows_hash
+  harvest_api.user_assignments.update(assignment)
+end
+
+Then 'the user "$1" on the project "$2" should have the following attributes:' do |email, project_name, table|
+  assignment = Then %Q{the user "#{email}" should be assigned to the project "#{project_name}"}
+  table.rows_hash.each do |key, value|
+    assignment.send(key).to_s.should == value
+  end
+end

data/features/step_definitions/contact_steps.rb

@@ -0,0 +1,11 @@
+Then 'there should be a contact "$1" for the client "$2"' do |email, client_name|
+  client = Then %Q{there should be a client "#{client_name}"}
+  contact = Then %Q{there should be a contact "#{email}"}
+  contact.client_id.should == client.id
+  
+  contacts = harvest_api.contacts.all(client.id)
+  contact2 = contacts.detect {|c| c.email == email}
+  contact2.should == contact
+  
+  contact
+end

data/features/step_definitions/debug_steps.rb

@@ -0,0 +1,3 @@
+Then 'I debug' do
+  debugger
+end

data/features/step_definitions/error_steps.rb

@@ -0,0 +1,113 @@
+Given /^the next request will receive a (bad request|not found|bad gateway|server error|rate limit) response$/ do |type|
+  statuses = {
+    'bad request' => ['400', 'Bad Request'],
+    'not found' => ['404', 'Not Found'],
+    'bad gateway' => ['502', 'Bad Gateway'],
+    'server error' => ['500', 'Server Error'],
+    'rate limit' => ['503', 'Rake Limited']
+  }
+  
+  if status = statuses[type]
+    FakeWeb.register_uri(:get, /\/clients/, [
+      {:status => status, :times => 1},
+      {:body => File.read(File.dirname(__FILE__) + '/../support/fixtures/empty_clients.xml')}
+    ])
+  else
+    pending
+  end
+end
+
+Given /^the next request will receive a rate limit response with a refresh in (\d+) seconds$/ do |seconds|
+  FakeWeb.register_uri(:get, /\/clients/, [
+    {:status => ['503', 'Rake Limited'], "Retry-After" => seconds},
+    {:body => File.read(File.dirname(__FILE__) + '/../support/fixtures/empty_clients.xml')}
+  ])
+end
+
+Given 'the next request will receive a rate limit response without a refresh set' do
+  FakeWeb.register_uri(:get, /\/clients/, [
+    {:status => ['503', 'Rake Limited']},
+    {:body => File.read(File.dirname(__FILE__) + '/../support/fixtures/empty_clients.xml')}
+  ])
+end
+
+When 'I make a request with the standard client' do
+  set_time_and_return_and_error do
+    standard_api.clients.all
+  end
+end
+
+When 'I make a request with the hardy client' do
+  set_time_and_return_and_error do
+    harvest_api.clients.all
+  end
+end
+
+When /^I make a request with the hardy client with (\d+) max retries$/ do |times|
+  set_time_and_return_and_error do
+    api = Harvest.hardy_client(@subdomain, @username, @password, :ssl => @ssl, :retry => times.to_i)
+    api.clients.all
+  end
+end
+
+Then /a (\d+) error should be raised/ do |code|
+  case code
+  when '400'
+    @error.should be_a(Harvest::BadRequest)
+  when '404'
+    @error.should be_a(Harvest::NotFound)
+  when '502'
+    @error.should be_a(Harvest::Unavailable)
+  when '500'
+    @error.should be_a(Harvest::ServerError)
+  when '503'
+    @error.should be_a(Harvest::RateLimited)
+  else
+    pending
+  end
+end
+
+Then /the hardy client should wait (\d+) seconds for the rate limit to reset/ do |seconds|
+  Time.now.should be_close(@time + seconds.to_i, 2)
+end
+
+Then 'I should be able to make a request again' do
+  harvest_api.clients.all
+  harvest_api.clients.all
+end
+
+Given /^the next (\d+) requests will receive a bad gateway response$/ do |times|
+  FakeWeb.register_uri(:get, /\/clients/, [
+    {:status => ['502', 'Bad Gateway'], :times => times.to_i},
+    {:body => File.read(File.dirname(__FILE__) + '/../support/fixtures/empty_clients.xml')}
+  ])
+end
+
+Given /^the next (\d+) requests will receive a server error response$/ do |times|
+  FakeWeb.register_uri(:get, /\/clients/, [
+    {:status => ['500', 'Server Error'], :times => times.to_i},
+    {:body => File.read(File.dirname(__FILE__) + '/../support/fixtures/empty_clients.xml')}
+  ])
+end
+
+Given /^the next (\d+) requests will receive an HTTP Error$/ do |times|
+  FakeWeb.register_uri(:get, /\/clients/, [
+    {:exception => Net::HTTPError, :times => times.to_i},
+    {:body => File.read(File.dirname(__FILE__) + '/../support/fixtures/empty_clients.xml')}
+  ])
+end
+
+Then 'no errors should be raised' do
+  @error.should be_nil
+  @clients.should == []
+end
+
+Given 'the rate limit status indicates I\'m over my limit' do
+  over_limit_response = File.read(File.dirname(__FILE__) + '/../support/fixtures/over_limit.xml')
+  FakeWeb.register_uri(:get, /\/account\/rate_limit_status/, :body => over_limit_response)
+end
+
+Given 'the rate limit status indicates I\'m under my limit' do
+  over_limit_response = File.read(File.dirname(__FILE__) + '/../support/fixtures/under_limit.xml')
+  FakeWeb.register_uri(:get, /\/account\/rate_limit_status/, :body => over_limit_response)
+end

data/features/step_definitions/expenses_steps.rb

@@ -0,0 +1,46 @@
+When 'I create an expense for the project "$1" with the category "$2" with the following:' do |project_name, category_name, table|
+  project = Then %Q{there should be a project "#{project_name}"}
+  category = Then %Q{there should be an expense category "#{category_name}"}
+  
+  expense = Harvest::Expense.new(table.rows_hash.merge("expense_category_id" => category.id, "project_id" => project.id))
+  harvest_api.expenses.create(expense)
+end
+
+Then 'there should be an expense "$1" on "$2"' do |notes, date|
+  expenses = harvest_api.expenses.all(date)
+  expense = expenses.detect {|e| e.notes == notes}
+  expense.should_not be_nil
+  expense
+end
+
+Then 'there should not be an expense "$1" on "$2"' do |notes, date|
+  expenses = harvest_api.expenses.all(date)
+  expense = expenses.detect {|e| e.notes == notes}
+  expense.should be_nil
+end
+
+When 'I delete the expense "$1" on "$2"' do |notes, date|
+  expense = Then %Q{there should be an expense "#{notes}" on "#{date}"}
+  id = harvest_api.expenses.delete(expense)
+  expense.id.should == id
+end
+
+Then 'the expense "$1" on "$2" should have the following attributes:' do |notes, date, table|
+  expense = Then %Q{there should be an expense "#{notes}" on "#{date}"}
+  table.rows_hash.each do |key, value|
+    expense.send(key).to_s.should == value
+  end
+end
+
+When 'I update the expense "$1" on "$2" with the following:' do |notes, date, table|
+  expense = Then %Q{there should be an expense "#{notes}" on "#{date}"}
+  expense.attributes = table.rows_hash
+  harvest_api.expenses.update(expense)
+end
+
+When 'I attach the receipt "$1" to the expense "$2" on "$3"' do |path, notes, date|
+  path = "#{File.dirname(__FILE__)}/../#{path}"
+  receipt = StringIO.new(File.read(path))
+  expense = Then %Q{there should be an expense "#{notes}" on "#{date}"}
+  harvest_api.expenses.attach(expense, "receipt.png", receipt)
+end

data/features/step_definitions/harvest_steps.rb

@@ -0,0 +1,8 @@
+Given 'I am using the credentials from "$1"' do |path|
+  raise "You need a credentials file in support/harvest_credentials.yml!!" unless File.exist?("#{File.dirname(__FILE__)}/../#{path}")
+  credentials = YAML.load_file("#{File.dirname(__FILE__)}/../#{path}")
+  @username = credentials["username"]
+  @password = credentials["password"]
+  @subdomain = credentials["subdomain"]
+  @ssl = credentials["ssl"]
+end

data/features/step_definitions/model_steps.rb

@@ -0,0 +1,90 @@
+When /^I create an? (client|task|user|expense category) with the following:$/ do |type, table|
+  case type
+  when "client"
+    client = Harvest::Client.new(table.rows_hash)
+    harvest_api.clients.create(client)
+  when "task"
+    task = Harvest::Task.new(table.rows_hash)
+    harvest_api.tasks.create(task)
+  when "user"
+    user = Harvest::User.new(table.rows_hash)
+    harvest_api.users.create(user)
+  when "expense category"
+    expense_cat = Harvest::ExpenseCategory.new(table.rows_hash)
+    harvest_api.expense_categories.create(expense_cat)
+  else pending end
+end
+
+When /^I create a (contact|project) for the client "([^\"]*)" with the following:$/ do |type, client_name, table|
+  client = Then %Q{there should be a client "#{client_name}"}
+  attributes = table.rows_hash.merge("client_id" => client.id)
+  
+  case type
+  when "contact"
+    contact = Harvest::Contact.new(attributes)
+    harvest_api.contacts.create(contact)
+  when "project"
+    project = Harvest::Project.new(attributes)
+    harvest_api.projects.create(project)
+  else pending end
+end
+
+Then /^there should be an? (contact|project|client|task|user|expense category) "([^\"]*)"$/ do |type, identifier|
+  collection = harvest_api.send(pluralize(type)).all
+  attribute = case type
+  when 'contact', 'user' then 'email'
+  when 'project', 'client', 'task', 'expense category' then 'name'
+  else pending end
+  item = collection.detect {|c| c.send(attribute) == identifier}
+  item.should_not be_nil
+  item
+end
+
+Then /^there should not be an? (contact|project|client|task|user|expense category) "([^\"]*)"$/ do |type, identifier|
+  collection = harvest_api.send(pluralize(type)).all
+  attribute = case type
+  when 'contact', 'user' then 'email'
+  when 'project', 'client', 'task', 'expense category' then 'name'
+  else pending end
+  item = collection.detect {|c| c.send(attribute) == identifier}
+  item.should be_nil
+end
+
+When /^I update the (contact|project|client|task|user|expense category) "([^\"]*)" with the following:$/ do |type, name, table|
+  item = Then %Q{there should be a #{type} "#{name}"}
+  item.attributes = table.rows_hash
+  harvest_api.send(pluralize(type)).update(item)
+end
+
+Then /^the (contact|project|client|task|user|expense category) "([^\"]*)" should have the following attributes:$/ do |type, name, table|
+  item = Then %Q{there should be a #{type} "#{name}"}
+  table.rows_hash.each do |key, value|
+    item.send(key).to_s.should == value
+  end
+end
+
+When /^I delete the (contact|project|client|task|user|expense category) "([^\"]*)"$/ do |type, name|
+  item = Then %Q{there should be a #{type} "#{name}"}
+  id = harvest_api.send(pluralize(type)).delete(item)
+  id.should == item.id
+end
+
+Then /^the (client|project|user) "([^\"]*)" should be activated$/ do |type, identifier|
+  item = Then %Q{there should be a #{type} "#{identifier}"}
+  item.should be_active
+end
+
+Then /^the (client|project|user) "([^\"]*)" should be deactivated$/ do |type, identifier|
+  item = Then %Q{there should be a #{type} "#{identifier}"}
+  item.should_not be_active
+end
+
+When /^I deactivate the (client|project|user) "([^\"]*)"$/ do |type, identifier|
+  item = Then %Q{there should be a #{type} "#{identifier}"}
+  harvest_api.send(pluralize(type)).deactivate(item)
+end
+
+When /^I activate the (client|project|user) "([^\"]*)"$/ do |type, identifier|
+  item = Then %Q{there should be a #{type} "#{identifier}"}
+  harvest_api.send(pluralize(type)).activate(item)
+end

data/features/step_definitions/people_steps.rb

@@ -0,0 +1,4 @@
+Then 'I reset the password of "$1"' do |email|
+  user = Then %Q{there should be a user "#{email}"}
+  harvest_api.users.reset_password(user)
+end

data/features/step_definitions/report_steps.rb

@@ -0,0 +1,91 @@
+When /^I run a project report for "([^\"]*)" for "([^\"]*)" and "([^\"]*)" the following entries should be returned:$/ do |project_name, start_date, end_date, table|
+  start_date = Time.parse(start_date)
+  end_date = Time.parse(end_date)
+  project = Then %Q{there should be a project "#{project_name}"}
+  entries = harvest_api.reports.time_by_project(project, start_date, end_date)
+  table.raw.each do |row|
+    entry = entries.detect {|e| e.notes == row.first }
+    entry.should_not be_nil
+  end
+end
+
+When /^I run a project report for "([^\"]*)" for "([^\"]*)" and "([^\"]*)" the following entries should not be returned:$/ do |project_name, start_date, end_date, table|
+  start_date = Time.parse(start_date)
+  end_date = Time.parse(end_date)
+  project = Then %Q{there should be a project "#{project_name}"}
+  entries = harvest_api.reports.time_by_project(project, start_date, end_date)
+  table.raw.each do |row|
+    entry = entries.detect {|e| e.notes == row.first }
+    entry.should be_nil
+  end
+end
+
+When /^I run a a project report for "([^\"]*)" for "([^\"]*)" and "([^\"]*)" filtered by my user the following entries should be returned:$/ do |project_name, start_date, end_date, table|
+  start_date = Time.parse(start_date)
+  end_date = Time.parse(end_date)
+  project = Then %Q{there should be a project "#{project_name}"}
+  user = Then %Q{there should be a user "#{@username}"}
+  entries = harvest_api.reports.time_by_project(project, start_date, end_date, user)
+  table.raw.each do |row|
+    entry = entries.detect {|e| e.notes == row.first }
+    entry.should_not be_nil
+  end
+end
+
+When /^I run a a project report for "([^\"]*)" for "([^\"]*)" and "([^\"]*)" filtered by my user the following entries should not be returned:$/ do |project_name, start_date, end_date, table|
+  start_date = Time.parse(start_date)
+  end_date = Time.parse(end_date)
+  project = Then %Q{there should be a project "#{project_name}"}
+  user = Then %Q{there should be a user "#{@username}"}
+  entries = harvest_api.reports.time_by_project(project, start_date, end_date, user)
+  table.raw.each do |row|
+    entry = entries.detect {|e| e.notes == row.first }
+    entry.should be_nil
+  end
+end
+
+When /^I run a people report for my user for "([^\"]*)" and "([^\"]*)" the following entries should be returned:$/ do |start_date, end_date, table|
+  start_date = Time.parse(start_date)
+  end_date = Time.parse(end_date)
+  user = Then %Q{there should be a user "#{@username}"}
+  entries = harvest_api.reports.time_by_user(user, start_date, end_date)
+  table.raw.each do |row|
+    entry = entries.detect {|e| e.notes == row.first }
+    entry.should_not be_nil
+  end
+end
+
+When /^I run a people report for my user for "([^\"]*)" and "([^\"]*)" filtered by the project "([^\"]*)" the following entries should be returned:$/ do |start_date, end_date, project_name, table|
+  start_date = Time.parse(start_date)
+  end_date = Time.parse(end_date)
+  user = Then %Q{there should be a user "#{@username}"}
+  project = Then %Q{there should be a project "#{project_name}"}
+  entries = harvest_api.reports.time_by_user(user, start_date, end_date, project)
+  table.raw.each do |row|
+    entry = entries.detect {|e| e.notes == row.first }
+    entry.should_not be_nil
+  end
+end
+
+When /^I run a people report for my user for "([^\"]*)" and "([^\"]*)" filtered by the project "([^\"]*)" the following entries should not be returned:$/ do |start_date, end_date, project_name, table|
+  start_date = Time.parse(start_date)
+  end_date = Time.parse(end_date)
+  user = Then %Q{there should be a user "#{@username}"}
+  project = Then %Q{there should be a project "#{project_name}"}
+  entries = harvest_api.reports.time_by_user(user, start_date, end_date, project)
+  table.raw.each do |row|
+    entry = entries.detect {|e| e.notes == row.first }
+    entry.should be_nil
+  end
+end
+
+When /^I run an expense report for my user for "([^\"]*)" and "([^\"]*)" the following entries should be returned:$/ do |start_date, end_date, table|
+  start_date = Time.parse(start_date)
+  end_date = Time.parse(end_date)
+  user = Then %Q{there should be a user "#{@username}"}
+  expenses = harvest_api.reports.expenses_by_user(user, start_date, end_date)
+  table.raw.each do |row|
+    expense = expenses.detect {|e| e.notes == row.first }
+    expense.should_not be_nil
+  end
+end

data/features/step_definitions/time_entry_steps.rb

@@ -0,0 +1,40 @@
+When 'I create a time entry for the project "$1" and the task "$2" with the following:' do |project_name, task_name, table|
+  task = Then %Q{there should be a task "#{task_name}"}
+  project = Then %Q{there should be a project "#{project_name}"}
+  entry = Harvest::TimeEntry.new(table.rows_hash.merge('project_id' => project.id, 'task_id' => task.id))
+  created_entry = harvest_api.time.create(entry)
+  created_entry.project.should == project.name
+  created_entry.task.should == task.name
+end
+
+Then 'there should be a time entry "$1" on "$2"' do |notes, date|
+  entries = harvest_api.time.all(date)
+  entry = entries.detect {|e| e.notes == notes}
+  entry.should_not be_nil
+  entry
+end
+
+Then 'there should not be a time entry "$1" on "$2"' do |notes, date|
+  entries = harvest_api.time.all(date)
+  entry = entries.detect {|e| e.notes == notes}
+  entry.should be_nil
+end
+
+When 'I update the time entry "$1" on "$2" with the following:' do |note, date, table|
+  entry = Then %Q{there should be a time entry "#{note}" on "#{date}"}
+  entry.attributes = table.rows_hash
+  harvest_api.time.update(entry)
+end
+
+Then 'the time entry "$1" on "$2" should have the following attributes:' do |note, date, table|
+  entry = Then %Q{there should be a time entry "#{note}" on "#{date}"}
+  table.rows_hash.each do |key, value|
+    entry.send(key).to_s.should == value
+  end
+end
+
+When 'I delete the time entry "$1" on "$2"' do |note, date|
+  entry = Then %Q{there should be a time entry "#{note}" on "#{date}"}
+  id = harvest_api.time.delete(entry)
+  entry.id.should == id
+end

data/features/support/env.rb

@@ -0,0 +1,37 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'harvested'
+require 'ruby-debug'
+require 'fakeweb'
+
+require 'spec/expectations'
+
+Before do
+  FakeWeb.clean_registry
+  FakeWeb.allow_net_connect = true
+end
+
+Before('@disconnected') do
+  FakeWeb.allow_net_connect = false
+end
+
+Before('@clean') do
+  credentials = YAML.load_file("#{File.dirname(__FILE__)}/harvest_credentials.yml")
+  api = Harvest.hardy_client(credentials["subdomain"], credentials["username"], credentials["password"], :ssl => credentials["ssl"])
+  
+  api.users.all.each do |u|
+    api.users.delete(u) if u.email != credentials["username"]
+  end
+  my_user = api.users.all.first
+  
+  api.reports.time_by_user(my_user, Time.parse('01/01/2000'), Time.now).each do |time|
+    api.time.delete(time)
+  end
+  
+  api.reports.expenses_by_user(my_user, Time.parse('01/01/2000'), Time.now).each do |time|
+    api.expenses.delete(time)
+  end
+  
+  %w(expenses expense_categories projects contacts clients tasks).each do |collection|
+    api.send(collection).all.each {|m| api.send(collection).delete(m) }
+  end
+end

data/features/support/error_helpers.rb

@@ -0,0 +1,18 @@
+module ErrorHelpers
+  def set_time_and_return_and_error
+    @time = Time.now
+    @error = nil
+    begin
+      @clients = yield
+    rescue => e
+      case e
+      when Harvest::HTTPError, Net::HTTPError, Net::HTTPFatalError
+        @error = e
+      else
+        raise e
+      end
+    end
+  end
+end
+
+World(ErrorHelpers)

data/features/support/fixtures/empty_clients.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<nil-classes type="array"/>

data/features/support/fixtures/over_limit.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<hash>
+  <last-access-at type="datetime">2010-04-02T01:34:59+00:00</last-access-at>
+  <count type="integer">41</count>
+  <timeframe-limit type="integer">15</timeframe-limit>
+  <max-calls type="integer">40</max-calls>
+  <lockout-seconds type="integer">5</lockout-seconds>
+</hash>

data/features/support/fixtures/under_limit.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<hash>
+  <last-access-at type="datetime">2010-04-02T01:34:59+00:00</last-access-at>
+  <count type="integer">2</count>
+  <timeframe-limit type="integer">15</timeframe-limit>
+  <max-calls type="integer">40</max-calls>
+  <lockout-seconds type="integer">5</lockout-seconds>
+</hash>

data/features/support/harvest_credentials.example.yml

@@ -0,0 +1,4 @@
+username: "my@email.com"
+password: "secure"
+subdomain: "my-domain"
+ssl: false

data/features/support/harvest_helpers.rb

@@ -0,0 +1,11 @@
+module HarvestHelpers
+  def standard_api
+    Harvest.client(@subdomain, @username, @password, :ssl => @ssl)
+  end
+  
+  def harvest_api
+    Harvest.hardy_client(@subdomain, @username, @password, :ssl => @ssl)
+  end
+end
+
+World(HarvestHelpers)

data/features/support/inflections.rb

@@ -0,0 +1,9 @@
+module Inflections
+  def pluralize(string)
+    case string
+    when 'expense category' then 'expense_categories'
+    else "#{string}s" end
+  end
+end
+
+World(Inflections)