sniff 0.11.2 → 0.11.3

data/lib/sniff/database.rb

@@ -24,8 +24,6 @@ module Sniff
           fixtures_path = File.join(Sniff.root, 'lib', 'test_support', 'db', 'fixtures')
           environments << init_environment(Sniff.root, :fixtures_path => fixtures_path)
         end
-        
-        environments.each { |e| e.populate_fixtures }
       end
 
       def init_environment(root, options = {})

data/lib/sniff/fixture.rb

@@ -4,6 +4,8 @@ module Sniff
   module Fixture
     extend self
 
+    # FIXME TODO this doesn't work for models where the model name is different from the table name
+    # (e.g. PetroleumAdministrationForDefenseDistrict, ResidentialEnergyConsumptionSurveyResponse)
     def load_fixtures(fixtures_path)
       Encoding.default_external = 'UTF-8' if Object.const_defined?('Encoding')
       Dir.glob(File.join(fixtures_path, '**/*.csv')) do |fixture_file|

data/lib/sniff/version.rb

@@ -1,3 +1,3 @@
 module Sniff
-  VERSION = "0.11.2"
+  VERSION = "0.11.3"
 end

data/lib/test_support/cucumber/step_definitions/committee_steps.rb

@@ -49,12 +49,14 @@ Then /^the conclusion should not comply with standards? "(.*)"$/ do |standard_li
 end
 
 Then /^the conclusion of the committee should be "(.*)"$/ do |conclusion|
-  compare_values(@report.try(:conclusion), conclusion)
+  conclusion = @report.try(:conclusion)
+  conclusion = conclusion.respond_to?(:value) ? conclusion.value : conclusion
+  compare_values(conclusion, coerce_value(conclusion))
 end
 
 Then /^the conclusion of the committee should be timeframe "(.*)"$/ do |conclusion|
   timeframe = Timeframe.interval(conclusion)
-  compare_values(@report.try(:conclusion), timeframe)
+  compare_values(@report.try(:conclusion), coerce_value(timeframe))
 end
 
 Then /^the conclusion of the committee should be nil$/ do
@@ -69,16 +71,17 @@ Then /^the conclusion of the committee should include a key of "(.*)" and value
   end
 
   if value.present?
+    string_keyed_hash = {}
     @report.conclusion.each do |k, v|
-      @report.conclusion[k.to_s] == v
+      string_keyed_hash[k.to_s] = v
     end
-    compare_values(@report.conclusion[key.to_s], value)
+    compare_values(string_keyed_hash[key.to_s], coerce_value(value))
   end
 end
 
 Then /^the conclusion of the committee should have "(.*)" of "(.*)"$/ do |attribute, value|
   report_value = coerce_value @report.conclusion.send(attribute)
-  compare_values report_value, value
+  compare_values report_value, coerce_value(value)
 end
 
 Then /^the conclusion of the committee should include "(.*)"$/ do |value|
@@ -96,7 +99,7 @@ Then /^the conclusion of the committee should have a( single)? record identified
     records = @report.conclusion
     record = records.to_a.find { |r| equality? r.send(id_field), id }
     record.should_not be_nil
-    compare_values record.send(field), value
+    compare_values record.send(field), coerce_value(value)
     if single
       records.count.should == 1
     end
@@ -111,16 +114,16 @@ end
 
 Then /^the conclusion of the committee should have a record with "([^"]*)" equal to "([^"]*)"$/ do |field, value|
   record = @report.conclusion
-  compare_values(coerce_value(record.send(field)),value)
+  compare_values(coerce_value(record.send(field)), coerce_value(value))
 end
 
 Then /^the conclusion of the committee should include a key of "(.*)" and subvalue "(.*)" of "(.*)" and subvalue "(.*)" of "(.*)"$/ do |key, subkey1, subvalue1, subkey2, subvalue2|
   if key.present?
     @report.conclusion.keys.map(&:to_s).should include(key)
     actual_subvalue1 = coerce_value(@report.conclusion[key.to_s][subkey1.to_sym].to_s)
-    compare_values(actual_subvalue1, subvalue1)
+    compare_values(actual_subvalue1, coerce_value(subvalue1))
     actual_subvalue2 = coerce_value(@report.conclusion[key.to_s][subkey2.to_sym].to_s)
-    compare_values(actual_subvalue2, subvalue2)
+    compare_values(actual_subvalue2, coerce_value(subvalue2))
   else
     @report.conclusion.keys.map(&:to_s).should be_blank
   end

data/lib/test_support/cucumber/support/values.rb

@@ -30,23 +30,13 @@ module CucumberValueParser
 
   def compare_values(a, b)
     if b.blank?
-      a.should be_blank
+      a.blank?
+    elsif a.is_a?(Float)
+      a.should be_within(0.00001).of(b)
+    elsif a.is_a? Date
+      a.strftime('%Y-%m-%d').should == b.strftime('%Y-%m-%d')
     elsif a.is_a? Time
-      b = Chronic.parse b unless b.is_a?(Time)
-      a.should == b
-    elsif a.is_a? Date 
-      b = Date.parse b unless b.is_a?(Date)
-      a.should == b
-    elsif b =~ /\d+.*,.*\d/
-      a.should == b
-    elsif b =~ /\d+\.\d+/
-      b = b.to_f
-      a.to_f.should be_within(0.00001).of(b)
-    elsif b =~ /^0/
-      a.to_s.should == b
-    elsif b =~ /^\d+$/
-      b = b.to_i
-      a.to_i.should == b
+      a.strftime('%Y-%m-%d %H:%M:%s').should == b.strftime('%Y-%m-%d %H:%M:%s')
     else
       a.should == b
     end

metadata

@@ -2,7 +2,7 @@
 name: sniff
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.11.2
+  version: 0.11.3
 platform: ruby
 authors: 
 - Derek Kastner