barometer 0.8.0 → 0.9.0

data/spec/measurements/result_array_spec.rb

@@ -1,150 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Barometer::Measurement::ResultArray do
-  describe "instance methods" do
-    before(:each) do
-      @array = Barometer::Measurement::ResultArray.new
-    end
-
-    describe "'<<'" do
-      it "requires Barometer::Measurement::Result" do
-        lambda { @array << "invalid" }.should raise_error(ArgumentError)
-      end
-
-      it "adds ForecastMeasurement" do
-        @array.size.should == 0
-        forecast = Barometer::Measurement::Result.new
-        @array << forecast
-        @array.size.should == 1
-      end
-    end
-
-    describe "when searching forecasts using 'for'" do
-      before(:each) do
-        1.upto(4) do |i|
-          forecast_measurement = Barometer::Measurement::Result.new
-          forecast_measurement.date = Date.parse((Time.now + (i * 60 * 60 * 24)).to_s)
-          @array << forecast_measurement
-        end
-        @array.size.should == 4
-
-        @tommorrow = (Time.now + (60 * 60 * 24))
-      end
-
-      it "returns nil when there are no forecasts" do
-        @array = Barometer::Measurement::ResultArray.new
-        @array.size.should == 0
-        @array.for(@tommorrow).should be_nil
-      end
-
-      it "finds the date using a String" do
-        tommorrow = @tommorrow.to_s
-        tommorrow.class.should == String
-        @array.for(tommorrow).should == @array.first
-      end
-
-      it "finds the date using a Date" do
-        tommorrow = Date.parse(@tommorrow.to_s)
-        tommorrow.class.should == Date
-        @array.for(tommorrow).should == @array.first
-      end
-
-      it "finds the date using a DateTime" do
-        tommorrow = DateTime.parse(@tommorrow.to_s)
-        tommorrow.class.should == DateTime
-        @array.for(tommorrow).should == @array.first
-      end
-
-      it "finds the date using a Time" do
-        @tommorrow.class.should == Time
-        @array.for(@tommorrow).should == @array.first
-      end
-
-      it "finds the date using Data::LocalDateTime" do
-        tommorrow = Data::LocalDateTime.parse(@tommorrow.to_s)
-        tommorrow.class.should == Data::LocalDateTime
-        @array.for(tommorrow).should == @array.first
-      end
-
-      it "finds nothing when there is not a match" do
-        yesterday = (Time.now - (60 * 60 * 24))
-        yesterday.class.should == Time
-        @array.for(yesterday).should be_nil
-      end
-
-      it "finds using '[]'" do
-        tommorrow = @tommorrow.to_s
-        tommorrow.class.should == String
-        @array[tommorrow].should == @array.first
-      end
-    end
-  end
-
-  describe "simple questions" do
-    before(:each) do
-      @array = Barometer::Measurement::ResultArray.new
-      @now = Time.utc(2009,5,5,10,30,25)
-
-      @sun_icons = %w(sunny)
-
-      0.upto(1) do |i|
-        forecast_measurement = Barometer::Measurement::Result.new
-        forecast_measurement.date = Date.parse((@now + (i * 60 * 60 * 24)).to_s)
-        wind = Data::Speed.new
-        wind << (i * 5)
-        forecast_measurement.wind = wind
-        forecast_measurement.sun = Data::Sun.new(
-          Data::LocalTime.parse("9:00 am"), Data::LocalTime.parse("3:00 pm"))
-        forecast_measurement.icon = "sunny"
-        forecast_measurement.pop = 40
-        forecast_measurement.humidity = 95
-        @array << forecast_measurement
-      end
-      @array.size.should == 2
-      @tommorrow = (@now + (60 * 60 * 24))
-      @yesterday = (@now - (60 * 60 * 24))
-      @earlier = (@now - (60 * 60 * 3))
-      @later = (@now + (60 * 60 * 6))
-    end
-
-    it "answers windy?" do
-      @array.windy?(@tommorrow).should be_false
-      @array.windy?(@tommorrow,1).should be_true
-      @array.windy?(@yesterday).should be_nil
-    end
-
-    it "answers day?" do
-      @array.day?(@yesterday).should be_nil
-      @array.day?(@earlier).should be_false
-      @array.day?(@later).should be_false
-      @array.day?(@tommorrow).should be_true
-      @array.day?(@now).should be_true
-    end
-
-    it "answers sunny?" do
-      @array.sunny?(@tommorrow,%w(rain)).should be_false
-      @array.sunny?(@tommorrow,@sun_icons).should be_true
-      @array.sunny?(@yesterday).should be_nil
-    end
-
-    describe "wet?" do
-      it "answers via pop" do
-        @array.wet?(@tommorrow).should be_false
-        @array.wet?(@tommorrow,nil,50).should be_false
-        @array.wet?(@tommorrow,nil,30).should be_true
-      end
-
-      it "answers via humidity" do
-        @array.wet?(@tommorrow).should be_false
-        @array.wet?(@tommorrow,nil,50,99).should be_false
-        @array.wet?(@tommorrow,nil,50,90).should be_true
-      end
-
-      it "answers via icon" do
-        @array.wet?(@tommorrow,%w(rain)).should be_false
-        # pretend that "sun" means wet
-        @array.wet?(@tommorrow,@sun_icons).should be_true
-      end
-    end
-  end
-end

data/spec/measurements/result_spec.rb

@@ -1,632 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Barometer::Measurement::Result do
-  describe "when initialized" do
-    before(:each) do
-      @result = Barometer::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 = Barometer::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 = Barometer::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 = Barometer::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 = Barometer::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 = Barometer::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 = Barometer::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