barometer 0.3.2 → 0.5.0

data/spec/spec_helper.rb

@@ -16,24 +16,148 @@ def geocode_google_key_message
   puts
   puts "Please update the key_file '#{KEY_FILE}' with your google api key"
   puts "example:"
-  puts "geocode_google: YOUR_KEY_KERE"
+  puts "google: geocode: YOUR_KEY_KERE"
   puts
 end
 
 if File.exists?(KEY_FILE)
 	keys = YAML.load_file(KEY_FILE)
-	if keys["geocode_google"]
-	  KEY = keys["geocode_google"]
+	if keys["google"]
+	  KEY = keys["google"]["geocode"]
   else
     geocode_google_key_message
     exit
   end
+  if keys["weather"]
+  	WEATHER_PARTNER_KEY = keys["weather"]["partner"]
+  	WEATHER_LICENSE_KEY = keys["weather"]["license"]
+	end
+    
 else
-  File.open(KEY_FILE, 'w') {|f| f << "geocode_google: YOUR_KEY_KERE" }
+  File.open(KEY_FILE, 'w') {|f| f << "google: geocode: YOUR_KEY_KERE" }
   geocode_google_key_message
   exit
 end
 
+
+  #
+  # for geocoding
+  #
+  geo_url = "http://maps.google.com/maps/geo?"
+  FakeWeb.register_uri(:get, 
+    "#{geo_url}gl=US&q=90210&output=xml&key=#{KEY}",
+    :string => File.read(File.join(File.dirname(__FILE__),  
+      'fixtures/geocode',
+      '90210.xml')
+    )
+  )
+  FakeWeb.register_uri(:get, 
+    "#{geo_url}gl=&q=#{CGI.escape("40.756054,-73.986951")}&output=xml&key=#{KEY}",
+    :string => File.read(File.join(File.dirname(__FILE__),  
+      'fixtures/geocode',
+      '40_73.xml')
+    )
+  )
+  
+  # FakeWeb.register_uri(:get, 
+  #   "#{geo_url}gl=&q=90210&output=xml&key=#{KEY}",
+  #   :string => File.read(File.join(File.dirname(__FILE__),  
+  #     'fixtures/geocode',
+  #     '90210.xml')
+  #   )
+  # )
+  FakeWeb.register_uri(:get, 
+    "#{geo_url}gl=&q=New%20York%2C%20NY&output=xml&key=#{KEY}",
+    :string => File.read(File.join(File.dirname(__FILE__),  
+      'fixtures/geocode',
+      'newyork_ny.xml')
+    )
+  )
+  FakeWeb.register_uri(:get, 
+    "#{geo_url}gl=CA&key=#{@key}&output=xml&q=T5B%204M9",
+    :string => File.read(File.join(File.dirname(__FILE__),  
+      'fixtures/geocode',
+      'T5B4M9.xml')
+    )
+  )
+  
+  FakeWeb.register_uri(:get, 
+    "#{geo_url}gl=&q=T5B%204M9&output=xml&key=#{KEY}",
+    :string => File.read(File.join(File.dirname(__FILE__), 
+      'fixtures/geocode',
+      'T5B4M9.xml')
+    )
+  )  
+  FakeWeb.register_uri(:get, 
+    "#{geo_url}output=xml&q=T5B%204M9&gl=CA&key=#{KEY}",
+    :string => File.read(File.join(File.dirname(__FILE__), 
+      'fixtures/geocode',
+      'T5B4M9.xml')
+    )
+  )
+  FakeWeb.register_uri(:get, 
+    "#{geo_url}gl=US&q=KSFO&output=xml&key=#{KEY}",
+    :string => File.read(File.join(File.dirname(__FILE__), 
+      'fixtures/geocode',
+      'ksfo.xml')
+    )
+  )
+  FakeWeb.register_uri(:get, 
+    "#{geo_url}gl=&q=Atlanta%2C%20GA%2C%20US&output=xml&key=#{KEY}",
+    :string => File.read(File.join(File.dirname(__FILE__),  
+      'fixtures/geocode',
+      'atlanta.xml')
+    )
+  )
+  FakeWeb.register_uri(:get, 
+    "#{geo_url}output=xml&q=Atlanta%2C%20GA%2C%20US&gl=US&key=#{KEY}",
+    :string => File.read(File.join(File.dirname(__FILE__),  
+      'fixtures/geocode',
+      'atlanta.xml')
+    )
+  )
+  #
+  # for weather.com searches
+  #
+  FakeWeb.register_uri(:get, 
+    "http://xoap.weather.com:80/search/search?where=Beverly%20Hills%2C%20CA%2C%20USA",
+    :string => File.read(File.join(File.dirname(__FILE__), 
+      'fixtures/formats/weather_id', 
+      '90210.xml')
+    )
+  )
+  FakeWeb.register_uri(:get, 
+    "http://xoap.weather.com:80/search/search?where=New%20York%2C%20NY",
+    :string => File.read(File.join(File.dirname(__FILE__), 
+      'fixtures/formats/weather_id',
+      'new_york.xml')
+    )
+  )
+  FakeWeb.register_uri(:get, 
+    "http://xoap.weather.com:80/search/search?where=New%20York%2C%20NY%2C%20USA",
+    :string => File.read(File.join(File.dirname(__FILE__), 
+      'fixtures/formats/weather_id',
+      'new_york.xml')
+    )
+  )
+  FakeWeb.register_uri(:get, 
+    "http://xoap.weather.com:80/search/search?where=90210",
+    :string => File.read(File.join(File.dirname(__FILE__), 
+      'fixtures/formats/weather_id',
+      '90210.xml')
+    )
+  )
+  #
+  # for yahoo.com searches
+  #
+  FakeWeb.register_uri(:get, 
+    "http://weather.yahooapis.com:80/forecastrss?p=USGA0028",
+    :string => File.read(File.join(File.dirname(__FILE__), 
+      'fixtures/formats/weather_id', 
+      'from_USGA0028.xml')
+    )
+  )
+
 Spec::Runner.configure do |config|
   
 end

data/spec/{service_google_spec.rb → weather_services/google_spec.rb}

@@ -1,4 +1,5 @@
 require 'spec_helper'
+include Barometer
 
 describe "Google" do
   
@@ -10,7 +11,7 @@ describe "Google" do
   describe "the class methods" do
     
     it "defines accepted_formats" do
-      Barometer::Google.accepted_formats.should == @accepted_formats
+      WeatherService::Google.accepted_formats.should == @accepted_formats
     end
     
     # it "defines base_uri" do
@@ -18,7 +19,7 @@ describe "Google" do
     # end
     
     it "defines get_all" do
-      Barometer::Google.respond_to?("get_all").should be_true
+      WeatherService::Google.respond_to?("get_all").should be_true
     end
     
   end
@@ -26,17 +27,17 @@ describe "Google" do
   describe "building the current data" do
     
     it "defines the build method" do
-      Barometer::Google.respond_to?("build_current").should be_true
+      WeatherService::Google.respond_to?("build_current").should be_true
     end
     
     it "requires Hash input" do
-      lambda { Barometer::Google.build_current }.should raise_error(ArgumentError)
-      lambda { Barometer::Google.build_current({}) }.should_not raise_error(ArgumentError)
+      lambda { WeatherService::Google.build_current }.should raise_error(ArgumentError)
+      lambda { WeatherService::Google.build_current({}) }.should_not raise_error(ArgumentError)
     end
     
     it "returns Barometer::CurrentMeasurement object" do
-      current = Barometer::Google.build_current({})
-      current.is_a?(Barometer::CurrentMeasurement).should be_true
+      current = WeatherService::Google.build_current({})
+      current.is_a?(Data::CurrentMeasurement).should be_true
     end
     
   end
@@ -44,16 +45,16 @@ describe "Google" do
   describe "building the forecast data" do
     
     it "defines the build method" do
-      Barometer::Google.respond_to?("build_forecast").should be_true
+      WeatherService::Google.respond_to?("build_forecast").should be_true
     end
     
     it "requires Hash input" do
-      lambda { Barometer::Google.build_forecast }.should raise_error(ArgumentError)
-      lambda { Barometer::Google.build_forecast({}) }.should_not raise_error(ArgumentError)
+      lambda { WeatherService::Google.build_forecast }.should raise_error(ArgumentError)
+      lambda { WeatherService::Google.build_forecast({}) }.should_not raise_error(ArgumentError)
     end
     
     it "returns Array object" do
-      current = Barometer::Google.build_forecast({})
+      current = WeatherService::Google.build_forecast({})
       current.is_a?(Array).should be_true
     end
     
@@ -62,19 +63,19 @@ describe "Google" do
   describe "building the location data" do
     
     it "defines the build method" do
-      Barometer::Google.respond_to?("build_location").should be_true
+      WeatherService::Google.respond_to?("build_location").should be_true
     end
     
     it "requires Barometer::Geo input" do
-      geo = Barometer::Geo.new({})
-      lambda { Barometer::Google.build_location({}) }.should raise_error(ArgumentError)
-      lambda { Barometer::Google.build_location(geo) }.should_not raise_error(ArgumentError)
+      geo = Data::Geo.new({})
+      lambda { WeatherService::Google.build_location({}) }.should raise_error(ArgumentError)
+      lambda { WeatherService::Google.build_location(geo) }.should_not raise_error(ArgumentError)
     end
     
     it "returns Barometer::Location object" do
-      geo = Barometer::Geo.new({})
-      location = Barometer::Google.build_location(geo)
-      location.is_a?(Barometer::Location).should be_true
+      geo = Data::Geo.new({})
+      location = WeatherService::Google.build_location(geo)
+      location.is_a?(Data::Location).should be_true
     end
     
   end
@@ -96,14 +97,13 @@ describe "Google" do
   
     before(:each) do
       @query = Barometer::Query.new("Calgary,AB")
-      @query.preferred = "Calgary,AB"
-      @measurement = Barometer::Measurement.new
+      @measurement = Data::Measurement.new
       
       FakeWeb.register_uri(:get, 
-        "http://google.com/ig/api?weather=#{CGI.escape(@query.preferred)}&hl=en-GB",
+        "http://google.com/ig/api?weather=#{CGI.escape(@query.q)}&hl=en-GB",
         :string => File.read(File.join(File.dirname(__FILE__), 
-          'fixtures', 
-          'google_calgary_ab.xml')
+          '../fixtures/services/google', 
+          'calgary_ab.xml')
         )
       )  
     end
@@ -111,27 +111,27 @@ describe "Google" do
     describe "all" do
       
       it "responds to _measure" do
-        Barometer::Google.respond_to?("_measure").should be_true
+        Barometer::WeatherService::Google.respond_to?("_measure").should be_true
       end
       
       it "requires a Barometer::Measurement object" do
-        lambda { Barometer::Google._measure(nil, @query) }.should raise_error(ArgumentError)
-        lambda { Barometer::Google._measure("invlaid", @query) }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService::Google._measure(nil, @query) }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService::Google._measure("invlaid", @query) }.should raise_error(ArgumentError)
   
-        lambda { Barometer::Google._measure(@measurement, @query) }.should_not raise_error(ArgumentError)
+        lambda { Barometer::WeatherService::Google._measure(@measurement, @query) }.should_not raise_error(ArgumentError)
       end
   
       it "requires a Barometer::Query query" do
-        lambda { Barometer::Google._measure }.should raise_error(ArgumentError)
-        lambda { Barometer::Google._measure(@measurement, 1) }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService::Google._measure }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService::Google._measure(@measurement, 1) }.should raise_error(ArgumentError)
         
-        lambda { Barometer::Google._measure(@measurement, @query) }.should_not raise_error(ArgumentError)
+        lambda { Barometer::WeatherService::Google._measure(@measurement, @query) }.should_not raise_error(ArgumentError)
       end
       
       it "returns a Barometer::Measurement object" do
-        result = Barometer::Google._measure(@measurement, @query)
-        result.is_a?(Barometer::Measurement).should be_true
-        result.current.is_a?(Barometer::CurrentMeasurement).should be_true
+        result = Barometer::WeatherService::Google._measure(@measurement, @query)
+        result.is_a?(Data::Measurement).should be_true
+        result.current.is_a?(Data::CurrentMeasurement).should be_true
         result.forecast.is_a?(Array).should be_true
         
         result.source.should == :google
@@ -144,25 +144,25 @@ describe "Google" do
   describe "when answering the simple questions," do
     
     before(:each) do
-      @measurement = Barometer::Measurement.new
+      @measurement = Data::Measurement.new
     end
     
     describe "currently_wet_by_icon?" do
       
       before(:each) do
-        @measurement.current = Barometer::CurrentMeasurement.new
+        @measurement.current = Data::CurrentMeasurement.new
       end
     
       it "returns true if matching icon code" do
         @measurement.current.icon = "rain"
         @measurement.current.icon?.should be_true
-        Barometer::Google.currently_wet_by_icon?(@measurement.current).should be_true
+        WeatherService::Google.currently_wet_by_icon?(@measurement.current).should be_true
       end
       
       it "returns false if NO matching icon code" do
         @measurement.current.icon = "sunny"
         @measurement.current.icon?.should be_true
-        Barometer::Google.currently_wet_by_icon?(@measurement.current).should be_false
+        WeatherService::Google.currently_wet_by_icon?(@measurement.current).should be_false
       end
       
     end
@@ -170,7 +170,7 @@ describe "Google" do
     describe "forecasted_wet_by_icon?" do
       
       before(:each) do
-        @measurement.forecast = [Barometer::ForecastMeasurement.new]
+        @measurement.forecast = [Data::ForecastMeasurement.new]
         @measurement.forecast.first.date = Date.today
         @measurement.forecast.size.should == 1
       end
@@ -178,13 +178,13 @@ describe "Google" do
       it "returns true if matching icon code" do
         @measurement.forecast.first.icon = "rain"
         @measurement.forecast.first.icon?.should be_true
-        Barometer::Google.forecasted_wet_by_icon?(@measurement.forecast.first).should be_true
+        WeatherService::Google.forecasted_wet_by_icon?(@measurement.forecast.first).should be_true
       end
       
       it "returns false if NO matching icon code" do
         @measurement.forecast.first.icon = "sunny"
         @measurement.forecast.first.icon?.should be_true
-        Barometer::Google.forecasted_wet_by_icon?(@measurement.forecast.first).should be_false
+        WeatherService::Google.forecasted_wet_by_icon?(@measurement.forecast.first).should be_false
       end
       
     end
@@ -192,19 +192,19 @@ describe "Google" do
     describe "currently_sunny_by_icon?" do
       
       before(:each) do
-        @measurement.current = Barometer::CurrentMeasurement.new
+        @measurement.current = Data::CurrentMeasurement.new
       end
 
       it "returns true if matching icon code" do
         @measurement.current.icon = "sunny"
         @measurement.current.icon?.should be_true
-        Barometer::Google.currently_sunny_by_icon?(@measurement.current).should be_true
+        WeatherService::Google.currently_sunny_by_icon?(@measurement.current).should be_true
       end
       
       it "returns false if NO matching icon code" do
         @measurement.current.icon = "rain"
         @measurement.current.icon?.should be_true
-        Barometer::Google.currently_sunny_by_icon?(@measurement.current).should be_false
+        WeatherService::Google.currently_sunny_by_icon?(@measurement.current).should be_false
       end
       
     end
@@ -212,7 +212,7 @@ describe "Google" do
     describe "forecasted_sunny_by_icon?" do
       
       before(:each) do
-        @measurement.forecast = [Barometer::ForecastMeasurement.new]
+        @measurement.forecast = [Data::ForecastMeasurement.new]
         @measurement.forecast.first.date = Date.today
         @measurement.forecast.size.should == 1
       end
@@ -220,13 +220,13 @@ describe "Google" do
       it "returns true if matching icon code" do
         @measurement.forecast.first.icon = "sunny"
         @measurement.forecast.first.icon?.should be_true
-        Barometer::Google.forecasted_sunny_by_icon?(@measurement.forecast.first).should be_true
+        WeatherService::Google.forecasted_sunny_by_icon?(@measurement.forecast.first).should be_true
       end
       
       it "returns false if NO matching icon code" do
         @measurement.forecast.first.icon = "rain"
         @measurement.forecast.first.icon?.should be_true
-        Barometer::Google.forecasted_sunny_by_icon?(@measurement.forecast.first).should be_false
+        WeatherService::Google.forecasted_sunny_by_icon?(@measurement.forecast.first).should be_false
       end
       
     end

data/spec/weather_services/services_spec.rb

@@ -0,0 +1,1118 @@
+require 'spec_helper'
+
+describe "WeatherServices" do
+  
+  before(:each) do
+    query_term = "Calgary,AB"
+    @query = Barometer::Query.new(query_term)
+    @service = Barometer::WeatherService.source(:wunderground)
+    @time = Time.now
+  end
+  
+  describe "and the class method" do
+    
+    describe "source" do
+      
+      it "responds" do
+        Barometer::WeatherService.respond_to?("source").should be_true
+      end
+      
+      it "requires a Symbol or String" do
+        lambda { Barometer::WeatherService.source }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.source(1) }.should raise_error(ArgumentError)
+        
+        lambda { Barometer::WeatherService.source("wunderground") }.should_not raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.source(:wunderground) }.should_not raise_error(ArgumentError)
+      end
+      
+      it "raises an error if source doesn't exist" do
+        lambda { Barometer::WeatherService.source(:not_valid) }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.source(:wunderground) }.should_not raise_error(ArgumentError)
+      end
+      
+      it "returns the corresponding Service object" do
+        Barometer::WeatherService.source(:wunderground).should == WeatherService::Wunderground
+        Barometer::WeatherService.source(:wunderground).superclass.should == Barometer::WeatherService
+      end
+      
+      it "raises an error when retrieving the wrong class" do
+        lambda { Barometer::WeatherService.source(:temperature) }.should raise_error(ArgumentError)
+      end
+      
+    end
+    
+  end
+  
+  describe "when initialized" do
+    
+    before(:each) do
+      @service = Barometer::WeatherService.new
+    end
+    
+    it "stubs _measure" do
+      lambda { Barometer::WeatherService._measure }.should raise_error(NotImplementedError)
+    end
+    
+    it "stubs accepted_formats" do
+      lambda { Barometer::WeatherService.accepted_formats }.should raise_error(NotImplementedError)
+    end
+    
+    it "defaults meets_requirements?" do
+      Barometer::WeatherService.meets_requirements?.should be_true
+    end
+    
+    it "defaults supports_country?" do
+      Barometer::WeatherService.supports_country?.should be_true
+    end
+    
+    it "defaults requires_keys?" do
+      Barometer::WeatherService.requires_keys?.should be_false
+    end
+    
+    it "defaults has_keys?" do
+      lambda { Barometer::WeatherService.has_keys? }.should raise_error(NotImplementedError)
+    end
+    
+  end
+  
+  describe "when measuring," do
+    
+    it "responds to measure" do
+      Barometer::WeatherService.respond_to?("measure").should be_true
+    end
+    
+    # since Barometer::WeatherService defines the measure method, you could actuall just
+    # call Barometer::WeatherService.measure ... but this will not invoke a specific
+    # weather API driver.  Make sure this usage raises an error.
+    it "requires an actuall driver" do
+      lambda { Barometer::WeatherService.measure(@query) }.should raise_error(NotImplementedError)
+    end
+    
+    it "requires a Barometer::Query object" do
+      lambda { Barometer::WeatherService.measure("invalid") }.should raise_error(ArgumentError)
+      @query.is_a?(Barometer::Query).should be_true
+      lambda { Barometer::WeatherService.measure(@query) }.should_not raise_error(ArgumentError)
+    end
+    
+    it "returns a Data::Measurement object" do
+      @service.measure(@query).is_a?(Data::Measurement).should be_true
+    end
+    
+    it "returns current and future" do
+      measurement = @service.measure(@query)
+      measurement.current.is_a?(Data::CurrentMeasurement).should be_true
+      measurement.forecast.is_a?(Array).should be_true
+    end
+    
+  end
+  
+  describe "when answering the simple questions," do
+    
+    before(:each) do
+      # the function being tested was monkey patched in an earlier test
+      # so the original file must be reloaded
+      load 'lib/barometer/weather_services/service.rb'
+      
+      @measurement = Data::Measurement.new
+      @now = Data::LocalDateTime.parse("01-jan-2009 2:05 pm")
+    end
+    
+    describe "windy?" do
+      
+      it "requires a measurement object" do
+        lambda { Barometer::WeatherService.windy? }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.windy?("a") }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.windy?(@measurement) }.should_not raise_error(ArgumentError)
+      end
+      
+      it "requires threshold as a number" do
+        lambda { Barometer::WeatherService.windy?(@measurement,"a") }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.windy?(@measurement,1) }.should_not raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.windy?(@measurement,1.1) }.should_not raise_error(ArgumentError)
+      end
+      
+      it "requires time as a Data::LocalTime object" do
+        #lambda { Barometer::WeatherService.windy?(@measurement,1,"a") }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.windy?(@measurement,1,@now) }.should_not raise_error(ArgumentError)
+      end
+
+      it "stubs forecasted_windy?" do
+        Barometer::WeatherService.forecasted_windy?(@measurement,nil,nil).should be_nil
+      end
+      
+      describe "and is current" do
+        
+        before(:each) do
+          module Barometer; class Data::Measurement
+            def current?(a=nil); true; end
+          end; end
+        end
+      
+        it "returns nil" do
+          Barometer::WeatherService.windy?(@measurement).should be_nil
+        end
+        
+        it "returns true if currently_windy?" do
+          module Barometer; class WeatherService
+            def self.currently_windy?(a=nil,b=nil); true; end
+          end; end
+          Barometer::WeatherService.windy?(@measurement).should be_true
+        end
+
+        it "returns false if !currently_windy?" do
+          module Barometer; class WeatherService
+            def self.currently_windy?(a=nil,b=nil); false; end
+          end; end
+          Barometer::WeatherService.windy?(@measurement).should be_false
+        end
+        
+      end
+      
+      describe "and is NOT current" do
+        
+        before(:each) do
+          module Barometer; class Data::Measurement
+            def current?(a=nil); false; end
+          end; end
+        end
+      
+        it "returns nil" do
+          Barometer::WeatherService.windy?(@measurement).should be_nil
+        end
+        
+        it "returns true if forecasted_windy?" do
+          module Barometer; class WeatherService
+            def self.forecasted_windy?(a=nil,b=nil,c=nil); true; end
+          end; end
+          Barometer::WeatherService.windy?(@measurement).should be_true
+        end
+
+        it "returns false if !forecasted_windy?" do
+          module Barometer; class WeatherService
+            def self.forecasted_windy?(a=nil,b=nil,c=nil); false; end
+          end; end
+          Barometer::WeatherService.windy?(@measurement).should be_false
+        end
+        
+      end
+      
+    end
+    
+    describe "currently_windy?" do
+
+      before(:each) do
+        # the function being tested was monkey patched in an earlier test
+        # so the original file must be reloaded
+        load 'lib/barometer/weather_services/service.rb'
+        
+        @measurement = Data::Measurement.new
+        @threshold = 10
+      end
+
+      it "requires a measurement object" do
+        lambda { Barometer::WeatherService.currently_windy? }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.currently_windy?("a") }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.currently_windy?(@measurement) }.should_not raise_error(ArgumentError)
+      end
+
+      it "requires threshold as a number" do
+        lambda { Barometer::WeatherService.currently_windy?(@measurement,"a") }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.currently_windy?(@measurement,1) }.should_not raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.currently_windy?(@measurement,1.1) }.should_not raise_error(ArgumentError)
+      end
+
+      it "returns nil when value unavailable" do
+        measurement = Data::Measurement.new
+        Barometer::WeatherService.currently_windy?(measurement,@threshold).should be_nil
+        measurement.current = Data::CurrentMeasurement.new
+        Barometer::WeatherService.currently_windy?(measurement,@threshold).should be_nil
+        measurement.current.wind = Data::Speed.new
+        Barometer::WeatherService.currently_windy?(measurement,@threshold).should be_nil
+      end
+
+      describe "when metric" do
+
+        before(:each) do
+          @measurement = Data::Measurement.new
+          @measurement.current = Data::CurrentMeasurement.new
+          @measurement.current.wind = Data::Speed.new
+          @measurement.metric!
+          @measurement.metric?.should be_true
+        end
+
+        # measurement.current.wind.kph.to_f
+        it "returns true when wind speed (kph) above threshold" do
+          @measurement.current.wind.kph = @threshold + 1
+          Barometer::WeatherService.currently_windy?(@measurement,@threshold).should be_true
+        end
+
+        it "returns false when wind speed (kph) below threshold" do
+          @measurement.current.wind.kph = @threshold - 1
+          Barometer::WeatherService.currently_windy?(@measurement,@threshold).should be_false
+        end
+
+      end
+
+      describe "when imperial" do
+
+        before(:each) do
+          @measurement = Data::Measurement.new
+          @measurement.current = Data::CurrentMeasurement.new
+          @measurement.current.wind = Data::Speed.new
+          @measurement.imperial!
+          @measurement.metric?.should be_false
+        end
+
+        it "returns true when wind speed (mph) above threshold" do
+          @measurement.current.wind.mph = @threshold - 1
+          Barometer::WeatherService.currently_windy?(@measurement,@threshold).should be_false
+        end
+
+        it "returns false when wind speed (mph) below threshold" do
+          @measurement.current.wind.mph = @threshold - 1
+          Barometer::WeatherService.currently_windy?(@measurement,@threshold).should be_false
+        end
+
+      end
+
+    end
+    
+    describe "wet?" do
+      
+      it "requires a measurement object" do
+        lambda { Barometer::WeatherService.wet? }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.wet?("a") }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.wet?(@measurement) }.should_not raise_error(ArgumentError)
+      end
+      
+      it "requires threshold as a number" do
+        lambda { Barometer::WeatherService.wet?(@measurement,"a") }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.wet?(@measurement,1) }.should_not raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.wet?(@measurement,1.1) }.should_not raise_error(ArgumentError)
+      end
+      
+      it "requires time as a Data::LocalTime object" do
+        #lambda { Barometer::WeatherService.wet?(@measurement,1,"a") }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.wet?(@measurement,1,@now) }.should_not raise_error(ArgumentError)
+      end
+
+      describe "and is current" do
+        
+        before(:each) do
+          module Barometer; class Data::Measurement
+            def current?(a=nil); true; end
+          end; end
+        end
+      
+        it "returns nil" do
+          Barometer::WeatherService.wet?(@measurement).should be_nil
+        end
+        
+        it "returns true if currently_wet?" do
+          module Barometer; class WeatherService
+            def self.currently_wet?(a=nil,b=nil); true; end
+          end; end
+          Barometer::WeatherService.wet?(@measurement).should be_true
+        end
+
+        it "returns false if !currently_wet?" do
+          module Barometer; class WeatherService
+            def self.currently_wet?(a=nil,b=nil); false; end
+          end; end
+          Barometer::WeatherService.wet?(@measurement).should be_false
+        end
+        
+      end
+      
+      describe "and is NOT current" do
+        
+        before(:each) do
+          module Barometer; class Data::Measurement
+            def current?(a=nil); false; end
+          end; end
+        end
+      
+        it "returns nil" do
+          Barometer::WeatherService.wet?(@measurement).should be_nil
+        end
+        
+        it "returns true if forecasted_wet?" do
+          module Barometer; class WeatherService
+            def self.forecasted_wet?(a=nil,b=nil,c=nil); true; end
+          end; end
+          Barometer::WeatherService.wet?(@measurement).should be_true
+        end
+
+        it "returns false if !forecasted_wet?" do
+          module Barometer; class WeatherService
+            def self.forecasted_wet?(a=nil,b=nil,c=nil); false; end
+          end; end
+          Barometer::WeatherService.wet?(@measurement).should be_false
+        end
+        
+      end
+      
+    end
+    
+    describe "currently_wet?" do
+    
+      before(:each) do
+        # the function being tested was monkey patched in an earlier test
+        # so the original file must be reloaded
+        load 'lib/barometer/weather_services/service.rb'
+        
+        @measurement = Data::Measurement.new
+        @threshold = 10
+        @temperature = 15
+      end
+    
+      it "requires a measurement object" do
+        lambda { Barometer::WeatherService.currently_wet? }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.currently_wet?("a") }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.currently_wet?(@measurement) }.should_not raise_error(ArgumentError)
+      end
+    
+      it "requires threshold as a number" do
+        lambda { Barometer::WeatherService.currently_wet?(@measurement,"a") }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.currently_wet?(@measurement,1) }.should_not raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.currently_wet?(@measurement,1.1) }.should_not raise_error(ArgumentError)
+      end
+    
+      it "returns nil when value unavailable" do
+        measurement = Data::Measurement.new
+        Barometer::WeatherService.currently_wet?(measurement,@threshold).should be_nil
+        measurement.current = Data::CurrentMeasurement.new
+        Barometer::WeatherService.currently_wet?(measurement,@threshold).should be_nil
+        measurement.current.wind = Data::Speed.new
+        Barometer::WeatherService.currently_wet?(measurement,@threshold).should be_nil
+      end
+      
+      describe "currently_wet_by_icon?" do
+
+        before(:each) do
+          @measurement.current = Data::CurrentMeasurement.new
+        end
+
+        it "requires a Barometer::Measurement object" do
+          lambda { Barometer::WeatherService.currently_wet_by_icon?(nil) }.should raise_error(ArgumentError)
+          lambda { Barometer::WeatherService.currently_wet_by_icon?("invlaid") }.should raise_error(ArgumentError)
+
+          lambda { Barometer::WeatherService.currently_wet_by_icon?(@measurement.current) }.should_not raise_error(ArgumentError)
+        end
+
+        it "returns nil if no icon" do
+          @measurement.current.icon?.should be_false
+          Barometer::WeatherService.currently_wet_by_icon?(@measurement.current).should be_nil
+        end
+
+        it "returns true if matching icon code" do
+          module Barometer; class WeatherService; def self.wet_icon_codes
+            ["rain"]
+          end; end; end
+          @measurement.current.icon = "rain"
+          @measurement.current.icon?.should be_true
+          Barometer::WeatherService.currently_wet_by_icon?(@measurement.current).should be_true
+        end
+
+        it "returns false if NO matching icon code" do
+          module Barometer; class WeatherService; def self.wet_icon_codes
+            ["rain"]
+          end; end; end
+          @measurement.current.icon = "sunny"
+          @measurement.current.icon?.should be_true
+          Barometer::WeatherService.currently_wet_by_icon?(@measurement.current).should be_false
+        end
+
+      end
+      
+      describe "and currently_wet_by_dewpoint?" do
+        
+        describe "when metric" do
+ 
+          before(:each) do
+            @measurement = Data::Measurement.new
+            @measurement.current = Data::CurrentMeasurement.new
+            @measurement.current.temperature = Data::Temperature.new
+            @measurement.current.dew_point = Data::Temperature.new
+            @measurement.metric!
+            @measurement.metric?.should be_true
+          end
+          
+          it "returns true when temperature < dew_point" do
+            @measurement.current.temperature.c = @temperature
+            @measurement.current.dew_point.c = @temperature + 1
+            Barometer::WeatherService.currently_wet_by_dewpoint?(@measurement).should be_true
+          end
+        
+          it "returns false when temperature > dew_point" do
+            @measurement.current.temperature.c = @temperature
+            @measurement.current.dew_point.c = @temperature - 1
+            Barometer::WeatherService.currently_wet_by_dewpoint?(@measurement).should be_false
+          end
+          
+        end
+        
+        describe "when imperial" do
+          
+          before(:each) do
+            @measurement = Data::Measurement.new
+            @measurement.current = Data::CurrentMeasurement.new
+            @measurement.current.temperature = Data::Temperature.new
+            @measurement.current.dew_point = Data::Temperature.new
+            @measurement.imperial!
+            @measurement.metric?.should be_false
+          end
+
+          it "returns true when temperature < dew_point" do
+            @measurement.current.temperature.f = @temperature
+            @measurement.current.dew_point.f = @temperature + 1
+            Barometer::WeatherService.currently_wet_by_dewpoint?(@measurement).should be_true
+          end
+
+          it "returns false when temperature > dew_point" do
+            @measurement.current.temperature.f = @temperature
+            @measurement.current.dew_point.f = @temperature - 1
+            Barometer::WeatherService.currently_wet_by_dewpoint?(@measurement).should be_false
+          end
+
+        end
+      
+      end
+      
+      describe "and currently_wet_by_humidity?" do
+        
+        before(:each) do
+          @measurement = Data::Measurement.new
+          @measurement.current = Data::CurrentMeasurement.new
+        end
+        
+        it "returns true when humidity >= 99%" do
+          @measurement.current.humidity = 99
+          Barometer::WeatherService.currently_wet_by_humidity?(@measurement.current).should be_true
+          @measurement.current.humidity = 100
+          Barometer::WeatherService.currently_wet_by_humidity?(@measurement.current).should be_true
+        end
+      
+        it "returns false when humidity < 99%" do
+          @measurement.current.humidity = 98
+          Barometer::WeatherService.currently_wet_by_humidity?(@measurement.current).should be_false
+        end
+        
+      end
+      
+      describe "and currently_wet_by_pop?" do
+        
+        before(:each) do
+          @measurement = Data::Measurement.new
+          @measurement.forecast = [Data::ForecastMeasurement.new]
+          @measurement.forecast.first.date = Date.today
+          @measurement.forecast.size.should == 1
+        end
+        
+        it "returns true when pop (%) above threshold" do
+          @measurement.forecast.first.pop = @threshold + 1
+          Barometer::WeatherService.currently_wet_by_pop?(@measurement, @threshold).should be_true
+        end
+
+        it "returns false when pop (%) below threshold" do
+          @measurement.forecast.first.pop = @threshold - 1
+          Barometer::WeatherService.currently_wet_by_pop?(@measurement, @threshold).should be_false
+        end
+        
+      end
+    
+    end
+    
+    describe "forecasted_wet?" do
+    
+      before(:each) do
+        # the function being tested was monkey patched in an earlier test
+        # so the original file must be reloaded
+        load 'lib/barometer/weather_services/service.rb'
+        
+        @measurement = Data::Measurement.new
+        @threshold = 10
+        @temperature = 15
+      end
+    
+      it "requires a measurement object" do
+        lambda { Barometer::WeatherService.forecasted_wet? }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.forecasted_wet?("a") }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.forecasted_wet?(@measurement) }.should_not raise_error(ArgumentError)
+      end
+
+      it "requires threshold as a number" do
+        lambda { Barometer::WeatherService.forecasted_wet?(@measurement,"a") }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.forecasted_wet?(@measurement,1) }.should_not raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.forecasted_wet?(@measurement,1.1) }.should_not raise_error(ArgumentError)
+      end
+
+      it "requires utc_time as a Data::LocalTime object" do
+        #lambda { Barometer::WeatherService.forecasted_wet?(@measurement,1,"string") }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.forecasted_wet?(@measurement,1,@now) }.should_not raise_error(ArgumentError)
+      end
+
+      it "returns nil when value unavailable" do
+        measurement = Data::Measurement.new
+        Barometer::WeatherService.forecasted_wet?(measurement,@threshold).should be_nil
+        measurement.forecast = [Data::ForecastMeasurement.new]
+        Barometer::WeatherService.forecasted_wet?(measurement,@threshold).should be_nil
+      end
+      
+      describe "forecasted_wet_by_icon?" do
+
+        before(:each) do
+          @measurement.forecast = [Data::ForecastMeasurement.new]
+          @measurement.forecast.first.date = Date.today
+          @measurement.forecast.size.should == 1
+        end
+
+        it "requires a Barometer::Measurement object" do
+          lambda { Barometer::WeatherService.forecasted_wet_by_icon?(nil) }.should raise_error(ArgumentError)
+          lambda { Barometer::WeatherService.forecasted_wet_by_icon?("invlaid") }.should raise_error(ArgumentError)
+
+          lambda { Barometer::WeatherService.forecasted_wet_by_icon?(@measurement.forecast.first) }.should_not raise_error(ArgumentError)
+        end
+
+        it "returns nil if no icon" do
+          @measurement.forecast.first.icon?.should be_false
+          Barometer::WeatherService.forecasted_wet_by_icon?(@measurement.forecast.first).should be_nil
+        end
+
+        it "returns true if matching icon code" do
+          module Barometer; class WeatherService; def self.wet_icon_codes
+            ["rain"]
+          end; end; end
+          @measurement.forecast.first.icon = "rain"
+          @measurement.forecast.first.icon?.should be_true
+          Barometer::WeatherService.forecasted_wet_by_icon?(@measurement.forecast.first).should be_true
+        end
+
+        it "returns false if NO matching icon code" do
+          module Barometer; class WeatherService; def self.wet_icon_codes
+            ["rain"]
+          end; end; end
+          @measurement.forecast.first.icon = "sunny"
+          @measurement.forecast.first.icon?.should be_true
+          Barometer::WeatherService.forecasted_wet_by_icon?(@measurement.forecast.first).should be_false
+        end
+
+        after(:each) do
+          # the function being tested was monkey patched in an earlier test
+          # so the original file must be reloaded
+          load 'lib/barometer/weather_services/service.rb'
+        end
+
+      end
+
+      describe "and forecasted_wet_by_pop?" do
+        
+        before(:each) do
+          @measurement = Data::Measurement.new
+          @measurement.forecast = [Data::ForecastMeasurement.new]
+          @measurement.forecast.first.date = Date.today
+          @measurement.forecast.size.should == 1
+        end
+        
+        it "returns true when pop (%) above threshold" do
+          @measurement.forecast.first.pop = @threshold + 1
+          Barometer::WeatherService.forecasted_wet_by_pop?(@measurement.forecast.first, @threshold).should be_true
+        end
+
+        it "returns false when pop (%) below threshold" do
+          @measurement.forecast.first.pop = @threshold - 1
+          Barometer::WeatherService.forecasted_wet_by_pop?(@measurement.forecast.first, @threshold).should be_false
+        end
+        
+      end
+
+    end
+    
+    describe "day?" do
+      
+      it "requires a measurement object" do
+        lambda { Barometer::WeatherService.day? }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.day?("a") }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.day?(@measurement) }.should_not raise_error(ArgumentError)
+      end
+      
+      it "requires time as a Data::LocalTime object" do
+        #lambda { Barometer::WeatherService.day?(@measurement,"a") }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.day?(@measurement,@now) }.should_not raise_error(ArgumentError)
+      end
+      
+      describe "and is current" do
+        
+        before(:each) do
+          module Barometer; class Data::Measurement
+            def current?(a=nil); true; end
+          end; end
+        end
+      
+        it "returns nil" do
+          Barometer::WeatherService.day?(@measurement).should be_nil
+        end
+        
+        it "returns true if currently_day?" do
+          module Barometer; class WeatherService
+            def self.currently_day?(a=nil); true; end
+          end; end
+          Barometer::WeatherService.day?(@measurement).should be_true
+        end
+
+        it "returns false if !currently_day?" do
+          module Barometer; class WeatherService
+            def self.currently_day?(a=nil); false; end
+          end; end
+          Barometer::WeatherService.day?(@measurement).should be_false
+        end
+        
+      end
+      
+      describe "and is NOT current" do
+        
+        before(:each) do
+          module Barometer; class Data::Measurement
+            def current?(a=nil); false; end
+          end; end
+        end
+      
+        it "returns nil" do
+          Barometer::WeatherService.day?(@measurement).should be_nil
+        end
+        
+        it "returns true if forecasted_day?" do
+          module Barometer; class WeatherService
+            def self.forecasted_day?(a=nil,b=nil); true; end
+          end; end
+          Barometer::WeatherService.day?(@measurement).should be_true
+        end
+
+        it "returns false if !forecasted_day?" do
+          module Barometer; class WeatherService
+            def self.forecasted_day?(a=nil,b=nil); false; end
+          end; end
+          Barometer::WeatherService.day?(@measurement).should be_false
+        end
+        
+      end
+      
+    end
+    
+    describe "currently_day?" do
+
+      before(:each) do
+        # the function being tested was monkey patched in an earlier test
+        # so the original file must be reloaded
+        load 'lib/barometer/weather_services/service.rb'
+        
+        @measurement = Data::Measurement.new
+      end
+
+      it "requires a measurement object" do
+        lambda { Barometer::WeatherService.currently_day? }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.currently_day?("a") }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.currently_day?(@measurement) }.should_not raise_error(ArgumentError)
+      end
+      
+      it "returns nil when value unavailable" do
+        measurement = Data::Measurement.new
+        Barometer::WeatherService.currently_day?(measurement).should be_nil
+      end
+      
+      describe "and currently_after_sunrise?" do
+        
+        before(:each) do
+          @measurement = Data::CurrentMeasurement.new
+          @now = Data::LocalTime.parse("2:02 pm")
+          @past = @now - (60*60)
+          @future = @now + (60*60)
+        end
+        
+        it "returns true when now is past sun_rise" do
+          @measurement.sun = Data::Sun.new(@past)
+          @measurement.current_at.should be_nil
+          Barometer::WeatherService.currently_after_sunrise?(@measurement).should be_nil
+          
+          @measurement.current_at = @now
+          @measurement.current_at.should_not be_nil
+          Barometer::WeatherService.currently_after_sunrise?(@measurement).should be_true
+        end
+
+        it "returns false when now if before sun_rise" do
+          @measurement.sun = Data::Sun.new(@future)
+          @measurement.current_at.should be_nil
+          Barometer::WeatherService.currently_after_sunrise?(@measurement).should be_nil
+          
+          @measurement.current_at = @now
+          @measurement.current_at.should_not be_nil
+          Barometer::WeatherService.currently_after_sunrise?(@measurement).should be_false
+        end
+        
+      end
+      
+      describe "and currently_before_sunset?" do
+        
+        before(:each) do
+          @measurement = Data::CurrentMeasurement.new
+          @now = Data::LocalTime.parse("2:02 pm")
+          @past = @now - (60*60)
+          @future = @now + (60*60)
+        end
+        
+        it "returns true when now is before sun_set" do
+          @measurement.sun = Data::Sun.new(nil,@future)
+          @measurement.current_at.should be_nil
+          Barometer::WeatherService.currently_before_sunset?(@measurement).should be_nil
+          
+          @measurement.current_at = @now
+          @measurement.current_at.should_not be_nil
+          Barometer::WeatherService.currently_before_sunset?(@measurement).should be_true
+        end
+
+        it "returns false when now if after sun_set" do
+          @measurement.sun = Data::Sun.new(nil,@past)
+          @measurement.current_at.should be_nil
+          Barometer::WeatherService.currently_before_sunset?(@measurement).should be_nil
+          
+          @measurement.current_at = @now
+          @measurement.current_at.should_not be_nil
+          Barometer::WeatherService.currently_before_sunset?(@measurement).should be_false
+        end
+        
+      end
+      
+    end
+    
+    describe "forecasted_day?" do
+
+      before(:each) do
+        # the function being tested was monkey patched in an earlier test
+        # so the original file must be reloaded
+        load 'lib/barometer/weather_services/service.rb'
+        
+        @measurement = Data::Measurement.new
+      end
+
+      it "requires a measurement object" do
+        lambda { Barometer::WeatherService.forecasted_day? }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.forecasted_day?("a") }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.forecasted_day?(@measurement) }.should_not raise_error(ArgumentError)
+      end
+      
+      it "requires time as a Data::LocalTime object" do
+        #lambda { Barometer::WeatherService.forecasted_day?(@measurement,"a") }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.forecasted_day?(@measurement,@now) }.should_not raise_error(ArgumentError)
+      end
+
+      it "returns nil when value unavailable" do
+        measurement = Data::Measurement.new
+        Barometer::WeatherService.forecasted_day?(measurement).should be_nil
+      end
+      
+      describe "and forecasted_after_sunrise?" do
+        
+        before(:each) do
+          @measurement = Data::ForecastMeasurement.new
+          @now = Data::LocalDateTime.parse("2:02 pm")
+          @past = @now - (60*60)
+          @future = @now + (60*60)
+        end
+        
+        it "returns true when now is past sun_rise" do
+          @measurement.sun = Data::Sun.new(@past)
+          Barometer::WeatherService.forecasted_after_sunrise?(@measurement, @now).should be_true
+        end
+      
+        it "returns false when now if before sun_rise" do
+          @measurement.sun = Data::Sun.new(@future)
+          Barometer::WeatherService.forecasted_after_sunrise?(@measurement, @now).should be_false
+        end
+        
+      end
+      
+      describe "and forecasted_before_sunset?" do
+        
+        before(:each) do
+          @measurement = Data::ForecastMeasurement.new
+          @now = Data::LocalDateTime.parse("2:02 pm")
+          @past = @now - (60*60)
+          @future = @now + (60*60)
+        end
+        
+        it "returns true when now is before sun_set" do
+          @measurement.sun = Data::Sun.new(nil,@future)
+          Barometer::WeatherService.forecasted_before_sunset?(@measurement,@now).should be_true
+        end
+      
+        it "returns false when now if after sun_set" do
+          @measurement.sun = Data::Sun.new(nil,@past)
+          Barometer::WeatherService.forecasted_before_sunset?(@measurement,@now).should be_false
+        end
+        
+      end
+      
+    end
+    
+    describe "sunny?" do
+      
+      it "requires a measurement object" do
+        lambda { Barometer::WeatherService.sunny? }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.sunny?("a") }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.sunny?(@measurement) }.should_not raise_error(ArgumentError)
+      end
+      
+      it "requires time as a Data::LocalTime object" do
+        #lambda { Barometer::WeatherService.sunny?(@measurement,"a") }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.sunny?(@measurement,@now) }.should_not raise_error(ArgumentError)
+      end
+
+      it "draws attention to this spot to fix this test"
+      # it "returns false if night time" do
+      #   @measurement.forecast = [Data::ForecastMeasurement.new]
+      #   @measurement.forecast.size.should == 1
+      #   @measurement.forecast[0].date = Date.today
+      #   module Barometer; class WeatherService; def self.day?(a=nil, b=nil)
+      #     true
+      #   end; end; end
+      #   Barometer::WeatherService.forecasted_sunny?(@measurement).should be_true
+      #   module Barometer; class WeatherService; def self.day?(a=nil, b=nil)
+      #     false
+      #   end; end; end
+      #   Barometer::WeatherService.forecasted_sunny?(@measurement).should be_false
+      # end
+
+      describe "and is current" do
+        
+        before(:each) do
+          module Barometer; class Data::Measurement
+            def current?(a=nil); true; end
+          end; end
+        end
+      
+        it "returns nil" do
+          Barometer::WeatherService.sunny?(@measurement).should be_nil
+        end
+        
+        it "returns true if currently_sunny?" do
+          module Barometer; class WeatherService
+            def self.currently_sunny?(a=nil); true; end
+          end; end
+          Barometer::WeatherService.sunny?(@measurement).should be_true
+        end
+
+        it "returns false if !currently_sunny?" do
+          module Barometer; class WeatherService
+            def self.currently_sunny?(a=nil); false; end
+          end; end
+          Barometer::WeatherService.sunny?(@measurement).should be_false
+        end
+        
+      end
+      
+      describe "and is NOT current" do
+        
+        before(:each) do
+          module Barometer; class Data::Measurement
+            def current?(a=nil); false; end
+          end; end
+        end
+      
+        it "returns nil" do
+          Barometer::WeatherService.sunny?(@measurement).should be_nil
+        end
+        
+        it "returns true if forecasted_sunny?" do
+          module Barometer; class WeatherService
+            def self.forecasted_sunny?(a=nil,b=nil); true; end
+          end; end
+          Barometer::WeatherService.sunny?(@measurement).should be_true
+        end
+
+        it "returns false if !forecasted_wet?" do
+          module Barometer; class WeatherService
+            def self.forecasted_sunny?(a=nil,b=nil); false; end
+          end; end
+          Barometer::WeatherService.sunny?(@measurement).should be_false
+        end
+        
+      end
+      
+    end
+    
+    describe "currently_sunny?" do
+    
+      before(:each) do
+        # the function being tested was monkey patched in an earlier test
+        # so the original file must be reloaded
+        load 'lib/barometer/weather_services/service.rb'
+        
+        @measurement = Data::Measurement.new
+      end
+    
+      it "requires a measurement object" do
+        lambda { Barometer::WeatherService.currently_sunny? }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.currently_sunny?("a") }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.currently_sunny?(@measurement) }.should_not raise_error(ArgumentError)
+      end
+    
+      it "returns nil when value unavailable" do
+        measurement = Data::Measurement.new
+        Barometer::WeatherService.currently_sunny?(measurement).should be_nil
+        measurement.current = Data::CurrentMeasurement.new
+        Barometer::WeatherService.currently_sunny?(measurement).should be_nil
+      end
+      
+      it "returns false if night time" do
+        @measurement.current = Data::CurrentMeasurement.new
+        module Barometer; class WeatherService; def self.currently_day?(a=nil)
+          true
+        end; end; end
+        module Barometer; class WeatherService; def self.currently_sunny_by_icon?(a=nil)
+          true
+        end; end; end
+        Barometer::WeatherService.currently_sunny?(@measurement).should be_true
+        module Barometer; class WeatherService; def self.currently_day?(a=nil)
+          false
+        end; end; end
+        Barometer::WeatherService.currently_sunny?(@measurement).should be_false
+      end
+
+      describe "currently_sunny_by_icon?" do
+
+        before(:each) do
+          @measurement.current = Data::CurrentMeasurement.new
+        end
+
+        it "requires a Barometer::Measurement object" do
+          lambda { Barometer::WeatherService.currently_sunny_by_icon?(nil) }.should raise_error(ArgumentError)
+          lambda { Barometer::WeatherService.currently_sunny_by_icon?("invlaid") }.should raise_error(ArgumentError)
+
+          lambda { Barometer::WeatherService.currently_sunny_by_icon?(@measurement.current) }.should_not raise_error(ArgumentError)
+        end
+
+        it "returns nil if no icon" do
+          @measurement.current.icon?.should be_false
+          Barometer::WeatherService.currently_sunny_by_icon?(@measurement.current).should be_nil
+        end
+
+        it "returns true if matching icon code" do
+          module Barometer; class WeatherService; def self.sunny_icon_codes
+            ["sunny"]
+          end; end; end
+          @measurement.current.icon = "sunny"
+          @measurement.current.icon?.should be_true
+          Barometer::WeatherService.currently_sunny_by_icon?(@measurement.current).should be_true
+        end
+
+        it "returns false if NO matching icon code" do
+          module Barometer; class WeatherService; def self.sunny_icon_codes
+            ["sunny"]
+          end; end; end
+          @measurement.current.icon = "rain"
+          @measurement.current.icon?.should be_true
+          Barometer::WeatherService.currently_sunny_by_icon?(@measurement.current).should be_false
+        end
+
+      end
+      
+    end
+    
+    describe "forecasted_sunny?" do
+    
+      before(:each) do
+        # the function being tested was monkey patched in an earlier test
+        # so the original file must be reloaded
+        load 'lib/barometer/weather_services/service.rb'
+        
+        @measurement = Data::Measurement.new
+      end
+    
+      it "requires a measurement object" do
+        lambda { Barometer::WeatherService.forecasted_sunny? }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.forecasted_sunny?("a") }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.forecasted_sunny?(@measurement) }.should_not raise_error(ArgumentError)
+      end
+
+      it "requires utc_time as a Data::LocalTime object" do
+        #lambda { Barometer::WeatherService.forecasted_sunny?(@measurement,"string") }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService.forecasted_sunny?(@measurement,@now) }.should_not raise_error(ArgumentError)
+      end
+
+      it "returns nil when value unavailable" do
+        measurement = Data::Measurement.new
+        Barometer::WeatherService.forecasted_sunny?(measurement).should be_nil
+        measurement.forecast = [Data::ForecastMeasurement.new]
+        measurement.forecast.size.should == 1
+        Barometer::WeatherService.forecasted_sunny?(measurement).should be_nil
+      end
+
+      it "returns false if night time" do
+        @measurement.forecast = [Data::ForecastMeasurement.new]
+        @measurement.forecast.size.should == 1
+        target_date = Date.today
+        @measurement.forecast[0].date = target_date
+        module Barometer; class WeatherService; def self.forecasted_day?(a=nil, b=nil)
+          true
+        end; end; end
+        module Barometer; class WeatherService; def self.forecasted_sunny_by_icon?(a=nil, b=nil)
+          true
+        end; end; end
+        Barometer::WeatherService.forecasted_sunny?(@measurement, target_date).should be_true
+        module Barometer; class WeatherService; def self.forecasted_day?(a=nil, b=nil)
+          false
+        end; end; end
+        Barometer::WeatherService.forecasted_sunny?(@measurement).should be_false
+      end
+      
+      describe "forecasted_sunny_by_icon?" do
+
+        before(:each) do
+          @measurement.forecast = [Data::ForecastMeasurement.new]
+          @measurement.forecast.first.date = Date.today
+          @measurement.forecast.size.should == 1
+        end
+
+        it "requires a Barometer::Measurement object" do
+          lambda { Barometer::WeatherService.forecasted_sunny_by_icon?(nil) }.should raise_error(ArgumentError)
+          lambda { Barometer::WeatherService.forecasted_sunny_by_icon?("invlaid") }.should raise_error(ArgumentError)
+
+          lambda { Barometer::WeatherService.forecasted_sunny_by_icon?(@measurement.forecast.first) }.should_not raise_error(ArgumentError)
+        end
+
+        it "returns nil if no icon" do
+          @measurement.forecast.first.icon?.should be_false
+          Barometer::WeatherService.forecasted_sunny_by_icon?(@measurement.forecast.first).should be_nil
+        end
+
+        it "returns true if matching icon code" do
+          module Barometer; class WeatherService; def self.sunny_icon_codes
+            ["sunny"]
+          end; end; end
+          @measurement.forecast.first.icon = "sunny"
+          @measurement.forecast.first.icon?.should be_true
+          Barometer::WeatherService.forecasted_sunny_by_icon?(@measurement.forecast.first).should be_true
+        end
+
+        it "returns false if NO matching icon code" do
+          module Barometer; class WeatherService; def self.sunny_icon_codes
+            ["sunny"]
+          end; end; end
+          @measurement.forecast.first.icon = "rain"
+          @measurement.forecast.first.icon?.should be_true
+          Barometer::WeatherService.forecasted_sunny_by_icon?(@measurement.forecast.first).should be_false
+        end
+
+        after(:each) do
+          # the function being tested was monkey patched in an earlier test
+          # so the original file must be reloaded
+          load 'lib/barometer/weather_services/service.rb'
+        end
+
+      end
+
+    end
+    
+  end
+  
+end