RubyGems - barometer - Versions diffs - 0.6.1 → 0.6.2 - Mend

barometer 0.6.1 → 0.6.2

Files changed (42) hide show

data/README.rdoc +1 -1
data/VERSION.yml +1 -1
data/bin/barometer +4 -12
data/lib/barometer/data.rb +2 -5
data/lib/barometer/data/local_datetime.rb +2 -2
data/lib/barometer/measurements/measurement.rb +6 -6
data/lib/barometer/measurements/result.rb +207 -0
data/lib/barometer/measurements/{forecast_array.rb → result_array.rb} +16 -13
data/lib/barometer/translations/weather_country_codes.yml +3 -3
data/lib/barometer/weather_services/google.rb +3 -3
data/lib/barometer/weather_services/weather_bug.rb +3 -3
data/lib/barometer/weather_services/weather_dot_com.rb +65 -38
data/lib/barometer/weather_services/wunderground.rb +3 -3
data/lib/barometer/weather_services/yahoo.rb +3 -3
data/lib/demometer/demometer.rb +2 -2
data/lib/demometer/public/css/master.css +4 -75
data/lib/demometer/public/css/print.css +1 -2
data/lib/demometer/public/css/syntax.css +1 -2
data/lib/demometer/views/about.erb +1 -1
data/lib/demometer/views/contributing.erb +4 -4
data/lib/demometer/views/index.erb +8 -9
data/lib/demometer/views/layout.erb +1 -2
data/spec/measurements/measurement_spec.rb +29 -53
data/spec/measurements/{forecast_array_spec.rb → result_array_spec.rb} +8 -8
data/spec/measurements/result_spec.rb +660 -0
data/spec/spec_helper.rb +1 -0
data/spec/weather_services/google_spec.rb +4 -4
data/spec/weather_services/services_spec.rb +1 -1
data/spec/weather_services/weather_bug_spec.rb +3 -3
data/spec/weather_services/weather_dot_com_spec.rb +19 -22
data/spec/weather_services/wunderground_spec.rb +2 -2
data/spec/weather_services/yahoo_spec.rb +2 -2
data/spec/weather_spec.rb +14 -39
metadata +6 -12
data/lib/barometer/measurements/common.rb +0 -113
data/lib/barometer/measurements/current.rb +0 -76
data/lib/barometer/measurements/forecast.rb +0 -62
data/lib/barometer/measurements/night.rb +0 -27
data/spec/measurements/common_spec.rb +0 -352
data/spec/measurements/current_spec.rb +0 -186
data/spec/measurements/forecast_spec.rb +0 -135
data/spec/measurements/night_measurement_spec.rb +0 -49

data/lib/demometer/views/layout.erb CHANGED Viewed

@@ -6,8 +6,7 @@
   <link rel='stylesheet' href='/css/master.css' type='text/css' media="screen, projection">
   <link rel='stylesheet' href='/css/syntax.css' type='text/css' media="screen, projection">
   <link rel='stylesheet' href='/css/print.css' type='text/css' media="print">
-  <!--><link rel='shortcut icon' href='/images/favicon.ico'>-->
-  <link rel='alternate' href='http://attack.github.com/feed.xml' type='application/atom+xml' title='Barometers Blog'>
+  <link rel='alternate' href='http://attack.github.com/feed.xml' type='application/atom+xml' title='Barometer Feed'>
 </head>
 <body id=''>

data/spec/measurements/measurement_spec.rb CHANGED Viewed

@@ -99,23 +99,23 @@ describe "Measurement" do
       lambda { @measurement.utc_time_stamp = valid_data }.should_not raise_error(ArgumentError)
     end
-    it "only accepts Data::CurrentMeasurement for current" do
+    it "only accepts Measurement::Result for current" do
       invalid_data = "invalid"
-      invalid_data.class.should_not == Measurement::Current
+      invalid_data.class.should_not == Measurement::Result
       lambda { @measurement.current = invalid_data }.should raise_error(ArgumentError)
-      valid_data = Measurement::Current.new
-      valid_data.class.should == Measurement::Current
+      valid_data = Measurement::Result.new
+      valid_data.class.should == Measurement::Result
       lambda { @measurement.current = valid_data }.should_not raise_error(ArgumentError)
     end
-    it "only accepts Data::ForecastArray for forecast" do
+    it "only accepts Data::ResultArray for forecast" do
       invalid_data = 1
-      invalid_data.class.should_not == Measurement::ForecastArray
+      invalid_data.class.should_not == Measurement::ResultArray
       lambda { @measurement.forecast = invalid_data }.should raise_error(ArgumentError)
-      valid_data = Measurement::ForecastArray.new
-      valid_data.class.should == Measurement::ForecastArray
+      valid_data = Measurement::ResultArray.new
+      valid_data.class.should == Measurement::ResultArray
       lambda { @measurement.forecast = valid_data }.should_not raise_error(ArgumentError)
     end
@@ -194,7 +194,7 @@ describe "Measurement" do
       @measurement.current.should be_nil
       @measurement.success.should be_false
-      @measurement.current = Measurement::Current.new
+      @measurement.current = Measurement::Result.new
       @measurement.current.temperature = Data::Temperature.new
       @measurement.current.temperature.c = 10
       @measurement.utc_time_stamp.should_not be_nil
@@ -203,7 +203,7 @@ describe "Measurement" do
     end
     it "returns successful state" do
-      @measurement.current = Measurement::Current.new
+      @measurement.current = Measurement::Result.new
       @measurement.current.temperature = Data::Temperature.new
       @measurement.current.temperature.c = 10
       @measurement.success!
@@ -226,7 +226,7 @@ describe "Measurement" do
       @measurement.current.should be_nil
       @measurement.current?.should be_true
-      @measurement.current = Measurement::Current.new
+      @measurement.current = Measurement::Result.new
       @measurement.current.current_at.should be_nil
       @measurement.current?.should be_true
@@ -288,11 +288,11 @@ describe "Measurement" do
     before(:each) do
       @measurement = Barometer::Measurement.new
-      # create a measurement object with a forecast array that includes
+      # create a measurement object with a result array that includes
       # dates for 4 consecutive days starting with tommorrow
-      @measurement.forecast = Measurement::ForecastArray.new
+      @measurement.forecast = Measurement::ResultArray.new
       1.upto(4) do |i|
-        forecast_measurement = Measurement::Forecast.new
+        forecast_measurement = Measurement::Result.new
         forecast_measurement.date = Date.parse((Time.now + (i * 60 * 60 * 24)).to_s)
         @measurement.forecast << forecast_measurement
       end
@@ -302,7 +302,7 @@ describe "Measurement" do
     end
     it "returns nil when there are no forecasts" do
-      @measurement.forecast = Measurement::ForecastArray.new
+      @measurement.forecast = Measurement::ResultArray.new
       @measurement.forecast.size.should == 0
       @measurement.for.should be_nil
     end
@@ -348,7 +348,7 @@ describe "Measurement" do
     before(:each) do
       @measurement = Barometer::Measurement.new(:wunderground)
-      @measurement.current = Measurement::Current.new
+      @measurement.current = Measurement::Result.new
       @now = Data::LocalDateTime.parse("2009-05-01 2:05 pm")
     end
@@ -366,16 +366,12 @@ describe "Measurement" do
     describe "windy?" do
       it "returns true if a current_measurement returns true" do
-        module Barometer; class Measurement::Current < Measurement::Common
-          def windy?(a=nil); true; end
-        end; end
+        @measurement.current.stubs(:windy?).returns(true)
         @measurement.windy?.should be_true
       end
       it "returns false if a current_measurement returns false" do
-        module Barometer; class Measurement::Current < Measurement::Common
-          def windy?(a=nil); false; end
-        end; end
+        @measurement.current.stubs(:windy?).returns(false)
         @measurement.windy?.should be_false
       end
@@ -384,16 +380,12 @@ describe "Measurement" do
      describe "wet?" do
        it "returns true if the current_measurement returns true" do
-         module Barometer; class Measurement::Current < Measurement::Common
-           def wet?(a=nil,b=nil,c=nil); true; end
-         end; end
+         @measurement.current.stubs(:wet?).returns(true)
          @measurement.wet?.should be_true
        end
        it "returns false if the current_measurement returns false" do
-         module Barometer; class Measurement::Current < Measurement::Common
-           def wet?(a=nil,b=nil,c=nil); false; end
-         end; end
+         @measurement.current.stubs(:wet?).returns(false)
          @measurement.wet?.should be_false
        end
@@ -402,16 +394,12 @@ describe "Measurement" do
     describe "day?" do
       it "returns true if the current_measurement returns true" do
-        module Barometer; class Measurement::Current < Measurement::Common
-          def day?(a=nil); true; end
-        end; end
+        @measurement.current.stubs(:day?).returns(true)
         @measurement.day?.should be_true
       end
       it "returns false if the current_measurement returns false" do
-        module Barometer; class Measurement::Current < Measurement::Common
-          def day?(a=nil); false; end
-        end; end
+        @measurement.current.stubs(:day?).returns(false)
         @measurement.day?.should be_false
       end
@@ -420,34 +408,22 @@ describe "Measurement" do
     describe "sunny?" do
       it "returns true if the current_measurement returns true and day" do
-        module Barometer; class Measurement::Current < Measurement::Common
-          def day?(a=nil); true; end
-        end; end
-        module Barometer; class Measurement::Current < Measurement::Common
-          def sunny?(a=nil,b=nil); true; end
-        end; end
+        @measurement.current.stubs(:day?).returns(true)
+        @measurement.current.stubs(:sunny?).returns(true)
         @measurement.day?.should be_true
         @measurement.sunny?.should be_true
       end
       it "returns false if the current_measurement returns false and day" do
-        module Barometer; class Measurement::Current < Measurement::Common
-          def day?(a=nil); true; end
-        end; end
-        module Barometer; class Measurement::Current < Measurement::Common
-          def sunny?(a=nil,b=nil); false; end
-        end; end
+        @measurement.current.stubs(:day?).returns(true)
+        @measurement.current.stubs(:sunny?).returns(false)
         @measurement.day?.should be_true
         @measurement.sunny?.should be_false
       end
       it "returns false if night time" do
-        module Barometer; class Measurement::Current < Measurement::Common
-          def day?(a=nil); false; end
-        end; end
-        module Barometer; class Measurement::Current < Measurement::Common
-          def sunny?(a=nil,b=nil); true; end
-        end; end
+        @measurement.current.stubs(:day?).returns(false)
+        @measurement.current.stubs(:sunny?).returns(true)
         @measurement.day?.should be_false
         @measurement.sunny?.should be_false
       end

data/spec/measurements/{forecast_array_spec.rb → result_array_spec.rb} RENAMED Viewed

@@ -1,22 +1,22 @@
 require 'spec_helper'
-describe "Forecast Array" do
+describe "Result Array" do
   describe "instance methods" do
     before(:each) do
-      @array = Measurement::ForecastArray.new
+      @array = Measurement::ResultArray.new
     end
     describe "'<<'" do
-      it "requires ForecastMeasurement" do
+      it "requires Measurement::Result" do
         lambda { @array << "invalid" }.should raise_error(ArgumentError)
       end
       it "adds ForecastMeasurement" do
         @array.size.should == 0
-        forecast = Measurement::Forecast.new
+        forecast = Measurement::Result.new
         @array << forecast
         @array.size.should == 1
       end
@@ -27,7 +27,7 @@ describe "Forecast Array" do
       before(:each) do
         1.upto(4) do |i|
-          forecast_measurement = Measurement::Forecast.new
+          forecast_measurement = Measurement::Result.new
           forecast_measurement.date = Date.parse((Time.now + (i * 60 * 60 * 24)).to_s)
           @array << forecast_measurement
         end
@@ -37,7 +37,7 @@ describe "Forecast Array" do
       end
       it "returns nil when there are no forecasts" do
-        @array = Measurement::ForecastArray.new
+        @array = Measurement::ResultArray.new
         @array.size.should == 0
         @array.for(@tommorrow).should be_nil
       end
@@ -90,7 +90,7 @@ describe "Forecast Array" do
   describe "simple questions" do
     before(:each) do
-      @array = Measurement::ForecastArray.new
+      @array = Measurement::ResultArray.new
       #@early = Data::LocalTime("6:00 am")
       #@noon = Data::LocalTime("12:00 pm")
       #@late = Data::LocalTime("8:00 pm")
@@ -99,7 +99,7 @@ describe "Forecast Array" do
       @sun_icons = %w(sunny)
       0.upto(1) do |i|
-        forecast_measurement = Measurement::Forecast.new
+        forecast_measurement = Measurement::Result.new
         forecast_measurement.date = Date.parse((@now + (i * 60 * 60 * 24)).to_s)
         wind = Data::Speed.new
         wind << (i * 5)

data/spec/measurements/result_spec.rb ADDED Viewed

@@ -0,0 +1,660 @@
+require 'spec_helper'
+describe "Result Measurement" do
+  describe "when initialized" do
+    before(:each) do
+      @result = Measurement::Result.new
+    end
+    it "responds to temperature" do
+      @result.temperature.should be_nil
+    end
+    it "responds to dew_point" do
+      @result.dew_point.should be_nil
+    end
+    it "responds to heat_index" do
+      @result.heat_index.should be_nil
+    end
+    it "responds to wind_chill" do
+      @result.wind_chill.should be_nil
+    end
+    it "responds to pressure" do
+      @result.pressure.should be_nil
+    end
+    it "responds to visibility" do
+      @result.pressure.should be_nil
+    end
+    it "responds to current_at" do
+      @result.current_at.should be_nil
+    end
+    it "responds to updated_at" do
+      @result.updated_at.should be_nil
+    end
+    it "responds to date" do
+      @result.date.should be_nil
+    end
+    it "responds to low" do
+      @result.low.should be_nil
+    end
+    it "responds to high" do
+      @result.high.should be_nil
+    end
+    it "responds to pop" do
+      @result.pop.should be_nil
+    end
+    it "responds to valid_start_date" do
+      @result.valid_start_date.should be_nil
+    end
+    it "responds to valid_end_date" do
+      @result.valid_end_date.should be_nil
+    end
+    it "responds to description" do
+      @result.description.should be_nil
+    end
+    it "responds to humidity" do
+      @result.humidity.should be_nil
+    end
+    it "responds to icon" do
+      @result.icon.should be_nil
+    end
+    it "responds to condition" do
+      @result.condition.should be_nil
+    end
+    it "responds to wind" do
+      @result.wind.should be_nil
+    end
+    it "responds to sun" do
+      @result.sun.should be_nil
+    end
+    it "responds to metric" do
+      @result.metric.should be_true
+    end
+    it "responds to metric?" do
+      @result.metric?.should be_true
+      @result.metric = false
+      @result.metric?.should be_false
+    end
+  end
+  describe "when writing data" do
+    before(:each) do
+      @result = Measurement::Result.new
+    end
+    it "only accepts Data::Temperature for temperature" do
+      invalid_data = 1
+      invalid_data.class.should_not == Data::Temperature
+      lambda { @result.temperature = invalid_data }.should raise_error(ArgumentError)
+      valid_data = Data::Temperature.new
+      valid_data.class.should == Data::Temperature
+      lambda { @result.temperature = valid_data }.should_not raise_error(ArgumentError)
+    end
+    it "only accepts Data::Temperature for dew_point" do
+      invalid_data = 1
+      invalid_data.class.should_not == Data::Temperature
+      lambda { @result.dew_point = invalid_data }.should raise_error(ArgumentError)
+      valid_data = Data::Temperature.new
+      valid_data.class.should == Data::Temperature
+      lambda { @result.dew_point = valid_data }.should_not raise_error(ArgumentError)
+    end
+    it "only accepts Data::Temperature for heat_index" do
+      invalid_data = 1
+      invalid_data.class.should_not == Data::Temperature
+      lambda { @result.heat_index = invalid_data }.should raise_error(ArgumentError)
+      valid_data = Data::Temperature.new
+      valid_data.class.should == Data::Temperature
+      lambda { @result.heat_index = valid_data }.should_not raise_error(ArgumentError)
+    end
+    it "only accepts Data::Temperature for wind_chill" do
+      invalid_data = 1
+      invalid_data.class.should_not == Data::Temperature
+      lambda { @result.wind_chill = invalid_data }.should raise_error(ArgumentError)
+      valid_data = Data::Temperature.new
+      valid_data.class.should == Data::Temperature
+      lambda { @result.wind_chill = valid_data }.should_not raise_error(ArgumentError)
+    end
+    it "only accepts Data::Pressure for pressure" do
+      invalid_data = 1
+      invalid_data.class.should_not == Data::Pressure
+      lambda { @result.pressure = invalid_data }.should raise_error(ArgumentError)
+      valid_data = Data::Pressure.new
+      valid_data.class.should == Data::Pressure
+      lambda { @result.pressure = valid_data }.should_not raise_error(ArgumentError)
+    end
+    it "only accepts Data::Distance for visibility" do
+      invalid_data = 1
+      invalid_data.class.should_not == Data::Distance
+      lambda { @result.visibility = invalid_data }.should raise_error(ArgumentError)
+      valid_data = Data::Distance.new
+      valid_data.class.should == Data::Distance
+      lambda { @result.visibility = valid_data }.should_not raise_error(ArgumentError)
+    end
+    it "only accepts Data::LocalTime || Data::LocalDateTime current_at" do
+      invalid_data = 1
+      invalid_data.class.should_not == Data::LocalTime
+      invalid_data.class.should_not == Data::LocalDateTime
+      lambda { @result.current_at = invalid_data }.should raise_error(ArgumentError)
+      valid_data = Data::LocalTime.new
+      valid_data.class.should == Data::LocalTime
+      lambda { @result.current_at = valid_data }.should_not raise_error(ArgumentError)
+      valid_data = Data::LocalDateTime.new(2009,1,1)
+      valid_data.class.should == Data::LocalDateTime
+      lambda { @result.current_at = valid_data }.should_not raise_error(ArgumentError)
+    end
+    it "only accepts Data::LocalTime || Data::LocalDateTime current_at" do
+      invalid_data = 1
+      invalid_data.class.should_not == Data::LocalTime
+      invalid_data.class.should_not == Data::LocalDateTime
+      lambda { @result.updated_at = invalid_data }.should raise_error(ArgumentError)
+      valid_data = Data::LocalTime.new
+      valid_data.class.should == Data::LocalTime
+      lambda { @result.updated_at = valid_data }.should_not raise_error(ArgumentError)
+      valid_data = Data::LocalDateTime.new(2009,1,1)
+      valid_data.class.should == Data::LocalDateTime
+      lambda { @result.updated_at = valid_data }.should_not raise_error(ArgumentError)
+    end
+    it "only accepts Date for date" do
+      invalid_data = 1
+      invalid_data.class.should_not == Date
+      lambda { @result.date = invalid_data }.should raise_error(ArgumentError)
+      valid_data = Date.new
+      valid_data.class.should == Date
+      lambda { @result.date = valid_data }.should_not raise_error(ArgumentError)
+    end
+    it "only accepts Data::Temperature for high" do
+      invalid_data = 1
+      invalid_data.class.should_not == Data::Temperature
+      lambda { @result.high = invalid_data }.should raise_error(ArgumentError)
+      valid_data = Data::Temperature.new
+      valid_data.class.should == Data::Temperature
+      lambda { @result.high = valid_data }.should_not raise_error(ArgumentError)
+    end
+    it "only accepts Data::Temperature for low" do
+      invalid_data = 1
+      invalid_data.class.should_not == Data::Temperature
+      lambda { @result.low = invalid_data }.should raise_error(ArgumentError)
+      valid_data = Data::Temperature.new
+      valid_data.class.should == Data::Temperature
+      lambda { @result.low = valid_data }.should_not raise_error(ArgumentError)
+    end
+    it "only accepts Fixnum for pop" do
+      invalid_data = "test"
+      invalid_data.class.should_not == Fixnum
+      lambda { @result.pop = invalid_data }.should raise_error(ArgumentError)
+      valid_data = 50
+      valid_data.class.should == Fixnum
+      lambda { @result.pop = valid_data }.should_not raise_error(ArgumentError)
+    end
+    it "only accepts Data::LocalDateTime for valid_start_date" do
+      invalid_data = 1
+      invalid_data.class.should_not == Data::LocalDateTime
+      lambda { @result.valid_start_date = invalid_data }.should raise_error(ArgumentError)
+      valid_data = Data::LocalDateTime.new(2009,1,1)
+      valid_data.class.should == Data::LocalDateTime
+      lambda { @result.valid_start_date = valid_data }.should_not raise_error(ArgumentError)
+    end
+    it "only accepts Data::LocalDateTime for valid_end_date" do
+      invalid_data = 1
+      invalid_data.class.should_not == Data::LocalDateTime
+      lambda { @result.valid_end_date = invalid_data }.should raise_error(ArgumentError)
+      valid_data = Data::LocalDateTime.new(2009,1,1)
+      valid_data.class.should == Data::LocalDateTime
+      lambda { @result.valid_end_date = valid_data }.should_not raise_error(ArgumentError)
+    end
+    it "sets valid_start_date and valid_end_date if given date" do
+      forecast = Measurement::Result.new
+      forecast.valid_start_date.should be_nil
+      forecast.valid_end_date.should be_nil
+      date = Date.new(2009,05,05)
+      forecast.date = date
+      forecast.valid_start_date.should_not be_nil
+      forecast.valid_start_date.year.should == date.year
+      forecast.valid_start_date.month.should == date.month
+      forecast.valid_start_date.day.should == date.day
+      forecast.valid_start_date.hour.should == 0
+      forecast.valid_start_date.min.should == 0
+      forecast.valid_start_date.sec.should == 0
+      forecast.valid_end_date.should_not be_nil
+      forecast.valid_end_date.year.should == date.year
+      forecast.valid_end_date.month.should == date.month
+      forecast.valid_end_date.day.should == date.day
+      forecast.valid_end_date.hour.should == 23
+      forecast.valid_end_date.min.should == 59
+      forecast.valid_end_date.sec.should == 59
+    end
+    it "returns true if the valid_date range includes the given date" do
+      forecast = Measurement::Result.new
+      forecast.date = Date.new(2009,05,05)
+      forecast.for_datetime?(Data::LocalDateTime.new(2009,5,5,12,0,0)).should be_true
+    end
+    it "returns false if the valid_date range excludes the given date" do
+      forecast = Measurement::Result.new
+      forecast.date = Date.new(2009,05,05)
+      forecast.for_datetime?(Data::LocalDateTime.new(2009,5,4,12,0,0)).should be_false
+    end
+    it "only accepts Fixnum or Float for humidity" do
+      invalid_data = "invalid"
+      invalid_data.class.should_not == Fixnum
+      invalid_data.class.should_not == Float
+      lambda { @result.humidity = invalid_data }.should raise_error(ArgumentError)
+      valid_data = 1.to_i
+      valid_data.class.should == Fixnum
+      lambda { @result.humidity = valid_data }.should_not raise_error(ArgumentError)
+      valid_data = 1.0.to_f
+      valid_data.class.should == Float
+      lambda { @result.humidity = valid_data }.should_not raise_error(ArgumentError)
+    end
+    it "only accepts String for icon" do
+      invalid_data = 1
+      invalid_data.class.should_not == String
+      lambda { @result.icon = invalid_data }.should raise_error(ArgumentError)
+      valid_data = "valid"
+      valid_data.class.should == String
+      lambda { @result.icon = valid_data }.should_not raise_error(ArgumentError)
+    end
+    it "only accepts String for condition" do
+      invalid_data = 1
+      invalid_data.class.should_not == String
+      lambda { @result.condition = invalid_data }.should raise_error(ArgumentError)
+      valid_data = "valid"
+      valid_data.class.should == String
+      lambda { @result.condition = valid_data }.should_not raise_error(ArgumentError)
+    end
+    it "only accepts Data::Speed for wind" do
+      invalid_data = 1
+      invalid_data.class.should_not == Data::Speed
+      lambda { @result.wind = invalid_data }.should raise_error(ArgumentError)
+      valid_data = Data::Speed.new
+      valid_data.class.should == Data::Speed
+      lambda { @result.wind = valid_data }.should_not raise_error(ArgumentError)
+    end
+    it "only accepts Data::Sun for sun" do
+      invalid_data = 1
+      invalid_data.class.should_not == Data::Sun
+      lambda { @result.sun = invalid_data }.should raise_error(ArgumentError)
+      valid_data = Data::Sun.new
+      valid_data.class.should == Data::Sun
+      lambda { @result.sun = valid_data }.should_not raise_error(ArgumentError)
+    end
+  end
+  describe "method missing" do
+    before(:each) do
+      @result = Measurement::Result.new
+    end
+    it "responds to method + ?" do
+      valid_method = "humidity"
+      @result.respond_to?(valid_method).should be_true
+      lambda { @result.send(valid_method + "?") }.should_not raise_error(NoMethodError)
+    end
+    it "ignores non_method + ?" do
+      invalid_method = "humid"
+      @result.respond_to?(invalid_method).should be_false
+      lambda { @result.send(invalid_method + "?") }.should raise_error(NoMethodError)
+    end
+    it "returns true if set" do
+      @result.humidity = 10
+      @result.humidity.should_not be_nil
+      @result.humidity?.should be_true
+    end
+    it "returns false if not set" do
+      @result.humidity.should be_nil
+      @result.humidity?.should be_false
+    end
+  end
+  describe "answer simple questions, like" do
+    before(:each) do
+      @result = Measurement::Result.new
+      @result.temperature = Data::Temperature.new
+      @result.temperature << 5
+      @dew_point = Data::Temperature.new
+      @dew_point << 10
+    end
+    describe "windy?" do
+      before(:each) do
+        @wind = Data::Speed.new
+        @wind << 11
+      end
+      it "requires real threshold number (or nil)" do
+        lambda { @result.windy?("invalid") }.should raise_error(ArgumentError)
+        lambda { @result.windy? }.should_not raise_error(ArgumentError)
+        lambda { @result.windy?(10) }.should_not raise_error(ArgumentError)
+      end
+      it "returns nil when no wind" do
+        @result.wind?.should be_false
+        @result.windy?.should be_nil
+        @result.wind = @wind
+        @result.wind?.should be_true
+        @result.windy?.should_not be_nil
+      end
+      it "return true when current wind over threshold" do
+        @result.wind = @wind
+        @result.windy?.should be_true
+        @result.windy?(10).should be_true
+      end
+      it "return false when current wind under threshold" do
+        @result.wind = @wind
+        @result.windy?(15).should be_false
+      end
+    end
+    describe "day?" do
+      before(:each) do
+        @early_time = Data::LocalTime.parse("6:00 am")
+        @mid_time = Data::LocalTime.parse("11:00 am")
+        @late_time = Data::LocalTime.parse("8:00 pm")
+        @sun = Data::Sun.new(@early_time, @late_time)
+      end
+      it "requires Data::LocalTime object" do
+        @result.sun = @sun
+        lambda { @result.day?("invalid") }.should raise_error(ArgumentError)
+        lambda { @result.day? }.should raise_error(ArgumentError)
+        lambda { @result.day?(@mid_time) }.should_not raise_error(ArgumentError)
+      end
+      it "returns nil when no sun" do
+        @result.sun?.should be_false
+        @result.day?(@mid_time).should be_nil
+        @result.sun = @sun
+        @result.sun?.should be_true
+        @result.day?(@mid_time).should_not be_nil
+      end
+      it "return true when time between rise and set" do
+        @result.sun = @sun
+        @result.day?(@mid_time).should be_true
+      end
+      it "return false when time before rise or after set" do
+        sun = Data::Sun.new(@mid_time, @late_time)
+        @result.sun = sun
+        @result.day?(@early_time).should be_false
+        sun = Data::Sun.new(@early_time, @mid_time)
+        @result.sun = sun
+        @result.day?(@late_time).should be_false
+      end
+    end
+    describe "wet?" do
+      describe "wet_by_humidity?" do
+        it "requires real threshold number (or nil)" do
+          lambda { @result.send("_wet_by_humidity?","invalid") }.should raise_error(ArgumentError)
+          lambda { @result.send("_wet_by_humidity?") }.should_not raise_error(ArgumentError)
+          lambda { @result.send("_wet_by_humidity?",99) }.should_not raise_error(ArgumentError)
+        end
+        it "returns nil when no humidity" do
+          @result.humidity?.should be_false
+          @result.send("_wet_by_humidity?").should be_nil
+          @result.wet?(nil,99).should be_nil
+          @result.humidity = 100
+          @result.humidity?.should be_true
+          @result.send("_wet_by_humidity?").should_not be_nil
+          @result.wet?(nil,99).should_not be_nil
+        end
+        it "return true when current humidity over threshold" do
+          @result.humidity = 100
+          @result.send("_wet_by_humidity?").should be_true
+          @result.send("_wet_by_humidity?",99).should be_true
+          @result.wet?(nil,99).should be_true
+        end
+        it "return false when current humidity under threshold" do
+          @result.humidity = 98
+          @result.send("_wet_by_humidity?",99).should be_false
+          @result.wet?(nil,99).should be_false
+        end
+      end
+      describe "wet_by_icon?" do
+        before(:each) do
+          @wet_icons = %w(rain thunderstorm)
+        end
+        it "requires Array (or nil)" do
+          lambda { @result.send("_wet_by_icon?","invalid") }.should raise_error(ArgumentError)
+          lambda { @result.send("_wet_by_icon?") }.should_not raise_error(ArgumentError)
+          lambda { @result.send("_wet_by_icon?",@wet_icons) }.should_not raise_error(ArgumentError)
+        end
+        it "returns nil when no icon or Array" do
+          @result.icon?.should be_false
+          @result.send("_wet_by_icon?",@wet_icons).should be_nil
+          @result.wet?(@wet_icons).should be_nil
+          @result.icon = "rain"
+          @result.icon?.should be_true
+          @result.send("_wet_by_icon?").should be_nil
+          @result.send("_wet_by_icon?",@wet_icons).should_not be_nil
+          @result.wet?(@wet_icons).should_not be_nil
+        end
+        it "return true when current icon indicates wet" do
+          @result.icon = "rain"
+          @result.send("_wet_by_icon?",@wet_icons).should be_true
+          @result.wet?(@wet_icons).should be_true
+        end
+        it "return false when current icon does NOT indicate wet" do
+          @result.icon = "sun"
+          @result.send("_wet_by_icon?",@wet_icons).should be_false
+          @result.wet?(@wet_icons).should be_false
+        end
+      end
+      describe "wet_by_dewpoint?" do
+        it "returns nil when no dewpoint" do
+          @result.dew_point?.should be_false
+          @result.send("_wet_by_dewpoint?").should be_nil
+          @result.wet?.should be_nil
+          @result.dew_point = @dew_point
+          @result.dew_point?.should be_true
+          @result.send("_wet_by_dewpoint?").should_not be_nil
+          @result.wet?.should_not be_nil
+        end
+        it "return true when current dewpoint over temperature" do
+          @result.dew_point = @dew_point
+          @result.send("_wet_by_dewpoint?").should be_true
+          @result.wet?.should be_true
+        end
+        it "return false when current dewpoint under temperature" do
+          @result.temperature << 15
+          @result.dew_point = @dew_point
+          @result.send("_wet_by_dewpoint?").should be_false
+          @result.wet?.should be_false
+        end
+      end
+      describe "wet_by_pop?" do
+        it "requires real threshold number (or nil)" do
+          lambda { @result.send("_wet_by_pop?","invalid") }.should raise_error(ArgumentError)
+          lambda { @result.send("_wet_by_pop?") }.should_not raise_error(ArgumentError)
+          lambda { @result.send("_wet_by_pop?",50) }.should_not raise_error(ArgumentError)
+        end
+        it "returns nil when no pop" do
+          @result.pop?.should be_false
+          @result.send("_wet_by_pop?",50).should be_nil
+          @result.wet?.should be_nil
+          @result.pop = 60
+          @result.pop?.should be_true
+          @result.send("_wet_by_pop?",50).should_not be_nil
+          @result.wet?.should_not be_nil
+        end
+        it "return true when current pop over threshold" do
+          @result.pop = 60
+          @result.send("_wet_by_pop?",50).should be_true
+          @result.wet?.should be_true
+        end
+        it "return false when current pop under threshold" do
+          @result.pop = 40
+          @result.send("_wet_by_pop?",50).should be_false
+          @result.wet?.should be_false
+        end
+      end
+    end
+    describe "sunny?" do
+      describe "sunny_by_icon?" do
+        before(:each) do
+          @sunny_icons = %w(sunny clear)
+          @early_time = Data::LocalTime.parse("6:00 am")
+          @mid_time = Data::LocalTime.parse("11:00 am")
+          @late_time = Data::LocalTime.parse("8:00 pm")
+          @sun = Data::Sun.new(@early_time, @late_time)
+          @result.sun = @sun
+        end
+        it "requires Array (or nil)" do
+          lambda { @result.send("_sunny_by_icon?","invalid") }.should raise_error(ArgumentError)
+          lambda { @result.send("_sunny_by_icon?") }.should_not raise_error(ArgumentError)
+          lambda { @result.send("_sunny_by_icon?",@sunny_icons) }.should_not raise_error(ArgumentError)
+        end
+        it "returns nil when no icon or Array" do
+          @result.icon?.should be_false
+          @result.send("_sunny_by_icon?",@sunny_icons).should be_nil
+          @result.sunny?(@mid_time,@sunny_icons).should be_nil
+          @result.icon = "sunny"
+          @result.icon?.should be_true
+          @result.send("_sunny_by_icon?").should be_nil
+          @result.send("_sunny_by_icon?",@sunny_icons).should_not be_nil
+          @result.sun?(@mid_time,@sunny_icons).should_not be_nil
+        end
+        it "returns true when current icon indicates sunny" do
+          @result.icon = "sunny"
+          @result.send("_sunny_by_icon?",@sunny_icons).should be_true
+          @result.sunny?(@mid_time,@sunny_icons).should be_true
+        end
+        it "returns false when current icon does NOT indicate sunny" do
+          @result.icon = "rain"
+          @result.send("_sunny_by_icon?",@sunny_icons).should be_false
+          @result.sunny?(@mid_time,@sunny_icons).should be_false
+        end
+        it "returns false when night" do
+          @result.icon = "sunny"
+          @result.send("_sunny_by_icon?",@sunny_icons).should be_true
+          @result.sunny?(@mid_time,@sunny_icons).should be_true
+          @sun = Data::Sun.new(@mid_time, @late_time)
+          @result.sun = @sun
+          @result.sunny?(@early_time,@sunny_icons).should be_false
+        end
+      end
+    end
+  end
+end