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

barometer 0.6.1 → 0.6.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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