hookercookerman-amee 0.0.2

data/features/profile/update.profile_item.feature

@@ -0,0 +1,14 @@
+Feature: Update Amee Profile Item
+  In order to update profile item information which means we can keep
+  In order co2 histroy and calcuations and profit big time
+  As a amee developer
+  I want to be able to update a profile items
+  
+  Scenario: Update Amee profile item with path /profiles/155DD3C63646/transport/motorcycle/generic/D47C465B8157
+    Given I have a valid amee session
+    When I ask the session for: get_profile_item with path: "/profiles/155DD3C63646/transport/motorcycle/generic/D47C465B8157"
+    
+    
+    And I update the profile item with: distance=400
+    
+    Then the profile item item_value: with name: "Distance" should have value: "400"

data/features/session/reauthenticate.feature

@@ -0,0 +1,16 @@
+Feature: ReAuthenticate the session
+  In order to keep make stale session fresh so we dont lose money from broken calculators
+  As a amee developer
+  I want to keep my session fresh
+  
+  Scenario: Keep session fresh
+    Given I have a valid amee session
+    And the session is stale for path: "/profiles/E0BCB3704D15"
+    
+    When when I try to get the profile with id: "E0BCB3704D15" the session should be refreshed
+    And the amee profile should have: "uid" with: "E0BCB3704D15"
+  
+  
+  
+
+  

data/features/step_definitions/amee_steps.rb

@@ -0,0 +1,67 @@
+# AMEE SESSION
+Given(/^I have a valid amee session$/) do
+  @models ||= {}
+  Amee::Service.stub!(:auth_token).and_return("random auth token")
+  @amee_session = Amee::Session.create("datest", "datest")
+end
+
+
+# Profiles
+When(/^I ask the session for: profiles$/) do
+  FakeWeb.register_uri(:get, "http://stage.amee.com/profiles", 
+    :string => "#{File.read(File.join(AMEE_FIXTURE_PATH, "profiles.json"))}"
+   )
+  @models["profiles"] = @amee_session.profiles
+end
+
+# Profile
+When(/^I ask the session for: profile with: \"(\S+)\"/) do |param|
+  FakeWeb.register_uri(:get, "http://stage.amee.com/profiles/#{param}", 
+    :file => File.join(AMEE_FIXTURE_PATH, "profiles/#{param}.json")
+   )
+  @models["profile"] = @amee_session.get_profile(param)
+end
+
+# Profile Category
+When(/^I ask the session for: get_profile_category with path: \"(\S+)\"$/) do |path|
+  FakeWeb.register_uri(:get, "http://stage.amee.com#{path}", 
+    :file => File.join(AMEE_FIXTURE_PATH, "#{path.gsub(/^\//, "")}.json")
+   )
+  @models["profile_category"] = @amee_session.get_profile_category(path)
+end
+
+# PROFILE ITEM
+# Profile Category
+When(/^I ask the session for: get_profile_item with path: \"(\S+)\"$/) do |path|
+  FakeWeb.register_uri(:get, "http://stage.amee.com#{path}", 
+    :file => File.join(AMEE_FIXTURE_PATH, "#{path.gsub(/^\//, "")}.json")
+   )
+  @models["profile_item"] = @amee_session.get_profile_item(path)
+end
+
+
+Then(/^there should be an amee profile with the uid of \"(\S+)\"$/) do |uid|
+  @models["profiles"].map{|profile| profile.uid}.should include(uid)
+end
+
+Then(/^each amee profile should have a path, name, created, modified and uid$/) do
+  @models["profiles"].each do |profile|
+    profile.path.should_not be_nil
+    profile.name.should_not be_nil
+    profile.uid.should_not be_nil
+    profile.created.should_not be_nil
+    profile.modified.should_not be_nil
+  end
+end
+
+Given(/^the session is stale for path: \"(\S+)\"$/) do |path|
+  FakeWeb.register_uri(:get, "http://stage.amee.com#{path}", 
+    [{:status => ["401", "NOT COOL"]},
+     {:file => File.join(AMEE_FIXTURE_PATH, "#{path.gsub(/^\//, "")}.json")}
+    ])
+end
+
+When(/^when I try to get the profile with id: \"(\S+)\" the session should be refreshed/) do |id|
+  @amess_sessino.should_receive(:authenticate!)
+  @models["profile"] = @amee_session.get_profile(id)
+end

data/features/step_definitions/common_steps.rb

@@ -0,0 +1,194 @@
+def in_project_folder(&block)
+  project_folder = @active_project_folder || @tmp_root
+  FileUtils.chdir(project_folder, &block)
+end
+
+def in_home_folder(&block)
+  FileUtils.chdir(@home_path, &block)
+end
+
+Given %r{^a safe folder} do
+  FileUtils.rm_rf   @tmp_root = File.dirname(__FILE__) + "/../../tmp"
+  FileUtils.mkdir_p @tmp_root
+  FileUtils.mkdir_p @home_path = File.expand_path(File.join(@tmp_root, "home"))
+  @lib_path = File.expand_path(File.dirname(__FILE__) + '/../../lib')
+  Given "env variable $HOME set to '#{@home_path}'"
+end
+
+Given %r{^this project is active project folder} do
+  Given "a safe folder"
+  @active_project_folder = File.expand_path(File.dirname(__FILE__) + "/../..")
+end
+
+Given %r{^env variable \$([\w_]+) set to '(.*)'} do |env_var, value|
+  ENV[env_var] = value
+end
+
+def force_local_lib_override(project_name = @project_name)
+  rakefile = File.read(File.join(project_name, 'Rakefile'))
+  File.open(File.join(project_name, 'Rakefile'), "w+") do |f|
+    f << "$:.unshift('#{@lib_path}')\n"
+    f << rakefile
+  end
+end
+
+def setup_active_project_folder project_name
+  @active_project_folder = File.join(@tmp_root, project_name)
+  @project_name = project_name
+end
+
+Given %r{'(.*)' folder is deleted} do |folder|
+  in_project_folder do
+    FileUtils.rm_rf folder
+  end
+end
+
+When %r{^'(.*)' generator is invoked with arguments '(.*)'$} do |generator, arguments|
+  @stdout = StringIO.new
+  FileUtils.chdir(@active_project_folder) do
+    if Object.const_defined?("APP_ROOT")
+      APP_ROOT.replace(FileUtils.pwd)
+    else 
+      APP_ROOT = FileUtils.pwd
+    end
+    run_generator(generator, arguments.split(' '), SOURCES, :stdout => @stdout)
+  end
+  File.open(File.join(@tmp_root, "generator.out"), "w") do |f|
+    @stdout.rewind
+    f << @stdout.read
+  end
+end
+
+When %r{run executable '(.*)' with arguments '(.*)'} do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  in_project_folder do
+    system "#{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When %r{run project executable '(.*)' with arguments '(.*)'} do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  in_project_folder do
+    system "ruby #{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When %r{run local executable '(.*)' with arguments '(.*)'} do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  executable = File.expand_path(File.join(File.dirname(__FILE__), "/../../bin", executable))
+  in_project_folder do
+    system "ruby #{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When %r{^task 'rake (.*)' is invoked$} do |task|
+  @stdout = File.expand_path(File.join(@tmp_root, "tests.out"))
+  FileUtils.chdir(@active_project_folder) do
+    system "rake #{task} --trace > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+Then %r{^folder '(.*)' (is|is not) created} do |folder, is|
+  in_project_folder do
+    File.exists?(folder).should(is == 'is' ? be_true : be_false)
+  end
+end
+
+Then %r{^file '(.*)' (is|is not) created} do |file, is|
+  in_project_folder do
+    File.exists?(file).should(is == 'is' ? be_true : be_false)
+  end
+end
+
+Then %r{^file with name matching '(.*)' is created} do |pattern|
+  in_project_folder do
+    Dir[pattern].should_not be_empty
+  end
+end
+
+Then %r{gem file '(.*)' and generated file '(.*)' should be the same} do |gem_file, project_file|
+  File.exists?(gem_file).should be_true
+  File.exists?(project_file).should be_true
+  gem_file_contents = File.read(File.dirname(__FILE__) + "/../../#{gem_file}")
+  project_file_contents = File.read(File.join(@active_project_folder, project_file))
+  project_file_contents.should == gem_file_contents
+end
+
+Then %r{^output same as contents of '(.*)'$} do |file|
+  expected_output = File.read(File.join(File.dirname(__FILE__) + "/../expected_outputs", file))
+  actual_output = File.read(@stdout)
+  actual_output.should == expected_output
+end
+
+Then %r{^(does|does not) invoke generator '(.*)'$} do |does_invoke, generator|
+  actual_output = File.read(@stdout)
+  does_invoke == "does" ?
+    actual_output.should(match(/dependency\s+#{generator}/)) :
+    actual_output.should_not(match(/dependency\s+#{generator}/))
+end
+
+Then %r{help options '(.*)' and '(.*)' are displayed} do |opt1, opt2|
+  actual_output = File.read(@stdout)
+  actual_output.should match(/#{opt1}/)
+  actual_output.should match(/#{opt2}/)
+end
+
+Then %r{^output (does|does not) match \/(.*)\/} do |does, regex|
+  actual_output = File.read(@stdout)
+  (does == 'does') ?
+    actual_output.should(match(/#{regex}/)) :
+    actual_output.should_not(match(/#{regex}/)) 
+end
+
+Then %r{^contents of file '(.*)' (does|does not) match \/(.*)\/} do |file, does, regex|
+  in_project_folder do
+    actual_output = File.read(file)
+    (does == 'does') ?
+      actual_output.should(match(/#{regex}/)) :
+      actual_output.should_not(match(/#{regex}/))
+  end
+end
+
+Then %r{^all (\d+) tests pass} do |expected_test_count|
+  expected = %r{^#{expected_test_count} tests, \d+ assertions, 0 failures, 0 errors}
+  actual_output = File.read(@stdout)
+  actual_output.should match(expected)
+end
+
+Then %r{^all (\d+) examples pass} do |expected_test_count|
+  expected = %r{^#{expected_test_count} examples?, 0 failures}
+  actual_output = File.read(@stdout)
+  actual_output.should match(expected)
+end
+
+Then %r{^yaml file '(.*)' contains (\{.*\})} do |file, yaml|
+  in_project_folder do
+    yaml = eval yaml
+    YAML.load(File.read(file)).should == yaml
+  end
+end
+
+Then %r{^Rakefile can display tasks successfully} do
+  @stdout = File.expand_path(File.join(@tmp_root, "rakefile.out"))
+  FileUtils.chdir(@active_project_folder) do
+    system "rake -T > #{@stdout} 2> #{@stdout}"
+  end
+  actual_output = File.read(@stdout)
+  actual_output.should match(/^rake\s+\w+\s+#\s.*/)
+end
+
+Then %r{^task 'rake (.*)' is executed successfully} do |task|
+  @stdout.should_not be_nil
+  actual_output = File.read(@stdout)
+  actual_output.should_not match(/^Don't know how to build task '#{task}'/)
+  actual_output.should_not match(/Error/i)
+end
+
+Then %r{^gem spec key '(.*)' contains \/(.*)\/} do |key, regex|
+  in_project_folder do
+    gem_file = Dir["pkg/*.gem"].first
+    gem_spec = Gem::Specification.from_yaml(`gem spec #{gem_file}`)
+    spec_value = gem_spec.send(key.to_sym)
+    spec_value.to_s.should match(/#{regex}/)
+  end
+end

data/features/step_definitions/config_steps.rb

@@ -0,0 +1,13 @@
+When "I do not create a config" do
+  # do nothing
+end
+
+Then(/^the amee config: \"(\w+)\" should be: \"(.*)\"$/) do |key, value|
+  Amee::Config[key.intern].to_s.should == value
+end
+
+When(/I set the: \"(\w+)\" on the amee config with: \"(.*)\"$/) do |key, value|
+  Amee::Config.set do |config|
+    config[key.intern] = value
+  end
+end

data/features/step_definitions/data_steps.rb

@@ -0,0 +1,142 @@
+# AMEE DATA CATEGORY
+When(/^I ask the session for: get_data_category with path: \"(.*)\"$/) do |path|
+  FakeWeb.register_uri(:get, "http://stage.amee.com#{path}", 
+    :file => File.join(AMEE_FIXTURE_PATH, "#{path.gsub(/^\//, "")}.json")
+   )
+  @models["data_category"] = @amee_session.get_data_category(path)
+end
+
+When(/^I ask the data category for its: \"(\S+)\"$/) do |method|
+   @models[method] = @models["data_category"].send(method)
+end
+
+Then(/^the data category should have: \"(.*)\" with: \"(.*)\"$/) do |attribute, value|
+  @models["data_category"].send(attribute).should == value
+end
+
+Then(/^the data category should (?:be|have) (?:an? )?(.*)/) do |predicate|
+  @models["data_category"].should send("be_#{predicate.gsub(' ', '_')}")
+end
+
+Then(/^the data category should not (?:be|have) (?:an? )?(.*)/) do |predicate|
+  @models["data_category"].should_not send("be_#{predicate.gsub(' ', '_')}")
+end
+
+Then(/^the data category's (.*) should (?:be|have) (?:an? )?(.*)/) do |method, predicate|
+  @models["data_category"].send(method).should send("be_#{predicate.gsub(' ', '_')}")
+end
+
+Then(/^the data category's (.*) should not (?:be|have) (?:an? )?(.*)/) do |method, predicate|
+  @models["data_category"].send(method).should_not send("be_#{predicate.gsub(' ', '_')}")
+end
+
+# AMEE DATA ITEM YES COULD REFACTOR
+When(/^I ask the session for: get_data_item with path: \"(.*)\"$/) do |path|
+  FakeWeb.register_uri(:get, "http://stage.amee.com#{path}", 
+    :file => File.join(AMEE_FIXTURE_PATH, "#{path.gsub(/^\//, "")}.json")
+   )
+  @models["data_item"] = @amee_session.get_data_item(path)
+end
+
+When(/^I ask the data item for its: \"(\S+)\"$/) do |method|
+   @models[method] = @models["data_item"].send(method)
+end
+
+Then(/^the data item should have: \"(.*)\" with: \"(.*)\"$/) do |attribute, value|
+  @models["data_item"].send(attribute).should == value
+end
+
+Then(/^the data item should (?:be|have) (?:an? )?(.*)/) do |predicate|
+  @models["data_item"].should send("be_#{predicate.gsub(' ', '_')}")
+end
+
+Then(/^the data item should not (?:be|have) (?:an? )?(.*)/) do |predicate|
+  @models["data_item"].should_not send("be_#{predicate.gsub(' ', '_')}")
+end
+
+Then(/^the data item's (\S+) should (?:be|have) (?:an? )?(.*)/) do |method, predicate|
+  @models["data_item"].send(method).should send("be_#{predicate.gsub(' ', '_')}")
+end
+
+Then(/^the data item's (\S+) should not (?:be|have) (?:an? )?(.*)/) do |method, predicate|
+  @models["data_item"].send(method).should_not send("be_#{predicate.gsub(' ', '_')}")
+end
+
+Then(/^the data item's item_definition: (\S+) should be \"(.*)\"/) do |method ,value|
+  @models["data_item"].item_definition.send(method).should == value
+end
+
+
+# YES COULD REFACTOR DATA ITEM VALUE
+# AMEE DATA ITEM YES COULD REFACTOR
+When(/^I ask the session for: get_data_item_value with path: \"(.*)\"$/) do |path|
+  FakeWeb.register_uri(:get, "http://stage.amee.com#{path}", 
+    :file => File.join(AMEE_FIXTURE_PATH, "#{path.gsub(/^\//, "")}.json")
+   )
+  @models["data_item_value"] = @amee_session.get_data_item_value(path)
+end
+
+When(/^I ask the data item value for its: \"(\S+)\"$/) do |method|
+   @models[method] = @models["data_item_value"].send(method)
+end
+
+Then(/^the data item value should have: \"(.*)\" with: \"(.*)\"$/) do |attribute, value|
+  @models["data_item_value"].send(attribute).should == value
+end
+
+Then(/^the data item value should (?:be|have) (?:an? )?(.*)/) do |predicate|
+  @models["data_item_value"].should send("be_#{predicate.gsub(' ', '_')}")
+end
+
+Then(/^the data item value should not (?:be|have) (?:an? )?(.*)/) do |predicate|
+  @models["data_item_value"].should_not send("be_#{predicate.gsub(' ', '_')}")
+end
+
+Then(/^the data item value's (\S+) should (?:be|have) (?:an? )?(.*)/) do |method, predicate|
+  @models["data_item_value"].send(method).should send("be_#{predicate.gsub(' ', '_')}")
+end
+
+Then(/^the data item value's (\S+) should not (?:be|have) (?:an? )?(.*)/) do |method, predicate|
+  @models["data_item_value"].send(method).should_not send("be_#{predicate.gsub(' ', '_')}")
+end
+
+Then(/^the data item value's item_value_definition: (\S+) should be \"(.*)\"/) do |method ,value|
+  @models["data_item_value"].item_value_definition.send(method).should == value
+end
+
+# DRILL DOWNS
+Given(/I drill down with params: \"(.*)\"/) do |params|
+  FakeWeb.register_uri(:get, "http://stage.amee.com#{@models["data_category"].full_path}/drill#{params}", 
+    :file => File.join(AMEE_FIXTURE_PATH, "#{@models["data_category"].full_path.gsub(/^\//, "")}/drill#{params}.json")
+   )
+  # what a wicked line hmmmm
+  input = params.gsub("?", "").split("&").map{|a| a.split("=")}.flatten
+  selection = Hash[*input.flatten]
+
+  @models["drill_down"] = @models["data_category"].drill(selection)
+end
+
+
+Then(/^the drill down should have: \"(.*)\" with: \"(.*)\"$/) do |attribute, value|
+  @models["drill_down"].send(attribute).should == value
+end
+
+Then(/^the drill down should (?:be|have) (?:an? )?(.*)/) do |predicate|
+  @models["drill_down"].should send("be_#{predicate.gsub(' ', '_')}")
+end
+
+Then(/^the drill down should not (?:be|have) (?:an? )?(.*)/) do |predicate|
+  @models["drill_down"].should_not send("be_#{predicate.gsub(' ', '_')}")
+end
+
+Then(/^the drill down's (\S+) should (?:be|have) (?:an? )?(.*)/) do |method, predicate|
+  @models["drill_down"].send(method).should send("be_#{predicate.gsub(' ', '_')}")
+end
+
+Then(/^the drill down's (\S+) should not (?:be|have) (?:an? )?(.*)/) do |method, predicate|
+  @models["drill_down"].send(method).should_not send("be_#{predicate.gsub(' ', '_')}")
+end
+
+Then(/^the drill down data category's should have: \"(\S+)\" with: \"(\S+)\"/) do |method, value|
+  @models["drill_down"].data_category.send(method).should == value
+end