barometer 0.5.0 → 0.6.1

data/spec/measurements/forecast_array_spec.rb

@@ -0,0 +1,165 @@
+require 'spec_helper'
+
+describe "Forecast Array" do
+  
+  describe "instance methods" do
+    
+    before(:each) do
+      @array = Measurement::ForecastArray.new
+    end
+    
+    describe "'<<'" do
+    
+      it "requires ForecastMeasurement" do
+        lambda { @array << "invalid" }.should raise_error(ArgumentError)
+      end
+      
+      it "adds ForecastMeasurement" do
+        @array.size.should == 0
+        forecast = Measurement::Forecast.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 = Measurement::Forecast.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 = Measurement::ForecastArray.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 = Measurement::ForecastArray.new
+      #@early = Data::LocalTime("6:00 am")
+      #@noon = Data::LocalTime("12:00 pm")
+      #@late = Data::LocalTime("8:00 pm")
+      @now = Time.utc(2009,5,5,10,30,25)
+      
+      @sun_icons = %w(sunny)
+      
+      0.upto(1) do |i|
+        forecast_measurement = Measurement::Forecast.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/forecast_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+describe "Forecast Measurement" do
+  
+  describe "when initialized" do
+    
+    before(:each) do
+      @forecast = Measurement::Forecast.new
+    end
+    
+    it "responds to date" do
+      @forecast.date.should be_nil
+    end
+
+    it "responds to low" do
+      @forecast.low.should be_nil
+    end
+    
+    it "responds to high" do
+      @forecast.high.should be_nil
+    end
+    
+    it "responds to pop" do
+      @forecast.pop.should be_nil
+    end
+    
+    it "responds to night" do
+      @forecast.night.should be_nil
+    end
+    
+  end
+  
+  describe "when writing data" do
+    
+    before(:each) do
+      @forecast = Measurement::Forecast.new
+    end
+    
+    it "only accepts Date for date" do
+      invalid_data = 1
+      invalid_data.class.should_not == Date
+      lambda { @forecast.date = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = Date.new
+      valid_data.class.should == Date
+      lambda { @forecast.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 { @forecast.high = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = Data::Temperature.new
+      valid_data.class.should == Data::Temperature
+      lambda { @forecast.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 { @forecast.low = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = Data::Temperature.new
+      valid_data.class.should == Data::Temperature
+      lambda { @forecast.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 { @forecast.pop = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = 50
+      valid_data.class.should == Fixnum
+      lambda { @forecast.pop = valid_data }.should_not raise_error(ArgumentError)
+    end
+    
+    it "only accepts Measurement::ForecastNight for night" do
+      invalid_data = 1
+      invalid_data.class.should_not == Measurement::ForecastNight
+      lambda { @forecast.night = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = Measurement::ForecastNight.new
+      valid_data.class.should == Measurement::ForecastNight
+      lambda { @forecast.night = valid_data }.should_not raise_error(ArgumentError)
+    end
+    
+  end
+  
+  describe "answer simple questions, like" do
+    
+    before(:each) do
+      @forecast = Measurement::Forecast.new
+    end
+    
+    describe "wet?" do
+      
+      describe "wet_by_pop?" do
+        
+        it "requires real threshold number (or nil)" do
+          lambda { @forecast.send("_wet_by_pop?","invalid") }.should raise_error(ArgumentError)
+          lambda { @forecast.send("_wet_by_pop?") }.should_not raise_error(ArgumentError)
+          lambda { @forecast.send("_wet_by_pop?",50) }.should_not raise_error(ArgumentError)
+        end
+
+        it "returns nil when no pop" do
+          @forecast.pop?.should be_false
+          @forecast.send("_wet_by_pop?",50).should be_nil
+          @forecast.wet?.should be_nil
+          @forecast.pop = 60
+          @forecast.pop?.should be_true
+          @forecast.send("_wet_by_pop?",50).should_not be_nil
+          @forecast.wet?.should_not be_nil
+        end
+
+        it "return true when current pop over threshold" do
+          @forecast.pop = 60
+          @forecast.send("_wet_by_pop?",50).should be_true
+          @forecast.wet?.should be_true
+        end
+
+        it "return false when current pop under threshold" do
+          @forecast.pop = 40
+          @forecast.send("_wet_by_pop?",50).should be_false
+          @forecast.wet?.should be_false
+        end
+
+      end
+      
+    end
+    
+  end
+  
+end

data/spec/{data → measurements}/measurement_spec.rb

@@ -5,7 +5,7 @@ describe "Measurement" do
   describe "when initialized" do
     
     before(:each) do
-      @measurement = Data::Measurement.new
+      @measurement = Barometer::Measurement.new
     end
     
     it "responds to source" do
@@ -14,7 +14,7 @@ describe "Measurement" do
     
     it "stores the source" do
       source = :wunderground
-      measurement = Data::Measurement.new(source)
+      measurement = Barometer::Measurement.new(source)
       measurement.source.should_not be_nil
       measurement.source.should == source
     end
@@ -48,7 +48,7 @@ describe "Measurement" do
     end
     
     it "responds to current?" do
-      @measurement.current?.should be_false
+      @measurement.current?.should be_true
     end
     
     it "responds to metric" do
@@ -76,7 +76,7 @@ describe "Measurement" do
   describe "when writing data" do
     
     before(:each) do
-      @measurement = Data::Measurement.new
+      @measurement = Barometer::Measurement.new
     end
     
     it "only accepts Symbol for source" do
@@ -101,21 +101,21 @@ describe "Measurement" do
     
     it "only accepts Data::CurrentMeasurement for current" do
       invalid_data = "invalid"
-      invalid_data.class.should_not == Data::CurrentMeasurement
+      invalid_data.class.should_not == Measurement::Current
       lambda { @measurement.current = invalid_data }.should raise_error(ArgumentError)
       
-      valid_data = Data::CurrentMeasurement.new
-      valid_data.class.should == Data::CurrentMeasurement
+      valid_data = Measurement::Current.new
+      valid_data.class.should == Measurement::Current
       lambda { @measurement.current = valid_data }.should_not raise_error(ArgumentError)
     end
     
-    it "only accepts Array for forecast" do
+    it "only accepts Data::ForecastArray for forecast" do
       invalid_data = 1
-      invalid_data.class.should_not == Array
+      invalid_data.class.should_not == Measurement::ForecastArray
       lambda { @measurement.forecast = invalid_data }.should raise_error(ArgumentError)
       
-      valid_data = []
-      valid_data.class.should == Array
+      valid_data = Measurement::ForecastArray.new
+      valid_data.class.should == Measurement::ForecastArray
       lambda { @measurement.forecast = valid_data }.should_not raise_error(ArgumentError)
     end
     
@@ -184,7 +184,7 @@ describe "Measurement" do
   describe "and the helpers" do
     
     before(:each) do
-      @measurement = Data::Measurement.new
+      @measurement = Barometer::Measurement.new
     end
     
     it "changes state to successful (if successful)" do
@@ -194,7 +194,7 @@ describe "Measurement" do
       @measurement.current.should be_nil
       @measurement.success.should be_false
       
-      @measurement.current = Data::CurrentMeasurement.new
+      @measurement.current = Measurement::Current.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 = Data::CurrentMeasurement.new
+      @measurement.current = Measurement::Current.new
       @measurement.current.temperature = Data::Temperature.new
       @measurement.current.temperature.c = 10
       @measurement.success!
@@ -224,11 +224,11 @@ describe "Measurement" do
     
     it "indicates if current" do
       @measurement.current.should be_nil
-      @measurement.current?.should be_false
+      @measurement.current?.should be_true
       
-      @measurement.current = Data::CurrentMeasurement.new
+      @measurement.current = Measurement::Current.new
       @measurement.current.current_at.should be_nil
-      @measurement.current?.should be_false
+      @measurement.current?.should be_true
         
       @measurement.current.current_at = Data::LocalTime.new(9,0,0)
       @measurement.current?.should be_true
@@ -255,7 +255,7 @@ describe "Measurement" do
     describe "changing units" do
 
       before(:each) do
-        @measurement = Data::Measurement.new
+        @measurement = Barometer::Measurement.new
       end
 
       it "indicates if metric?" do
@@ -286,13 +286,13 @@ describe "Measurement" do
   describe "when searching forecasts using 'for'" do
     
     before(:each) do
-      @measurement = Data::Measurement.new
+      @measurement = Barometer::Measurement.new
       
       # create a measurement object with a forecast array that includes
       # dates for 4 consecutive days starting with tommorrow
-      @measurement.forecast = []
+      @measurement.forecast = Measurement::ForecastArray.new
       1.upto(4) do |i|
-        forecast_measurement = Data::ForecastMeasurement.new
+        forecast_measurement = Measurement::Forecast.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.forecast = Measurement::ForecastArray.new
       @measurement.forecast.size.should == 0
       @measurement.for.should be_nil
     end
@@ -347,85 +347,70 @@ describe "Measurement" do
   describe "when answering the simple questions," do
     
     before(:each) do
-      @measurement = Data::Measurement.new(:wunderground)
+      @measurement = Barometer::Measurement.new(:wunderground)
+      @measurement.current = Measurement::Current.new
       @now = Data::LocalDateTime.parse("2009-05-01 2:05 pm")
     end
     
+    # def windy?(time_string=nil, threshold=10)
+    #   local_time = Data::LocalTime.parse(time_string)
+    #   if current?(local_time)
+    #     return nil unless current
+    #     current.windy?(threshold)
+    #   else
+    #     return nil unless forecast && (future = forecast[local_time])
+    #     future.windy?(threshold)
+    #   end
+    # end
+    
     describe "windy?" do
       
-      it "requires threshold as a number" do
-        lambda { @measurement.windy?("a") }.should raise_error(ArgumentError)
-        lambda { @measurement.windy?(1) }.should_not raise_error(ArgumentError)
-        lambda { @measurement.windy?(1.1) }.should_not raise_error(ArgumentError)
-      end
-      
-      it "requires time as a Time object" do
-        #lambda { @measurement.windy?(1,false) }.should raise_error(ArgumentError)
-        lambda { @measurement.windy?(1,@now) }.should_not raise_error(ArgumentError)
-      end
-
-      it "returns true if a source returns true" do
-        module Barometer; class WeatherService
-          def self.windy?(a=nil,b=nil,c=nil); true; end
+      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.windy?.should be_true
       end
 
-      it "returns false if a measurement returns false" do
-        module Barometer; class WeatherService
-          def self.windy?(a=nil,b=nil,c=nil); false; 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.windy?.should be_false
       end
       
     end
     
-    describe "wet?" do
-      
-      it "requires threshold as a number" do
-        lambda { @measurement.wet?("a") }.should raise_error(ArgumentError)
-        lambda { @measurement.wet?(1) }.should_not raise_error(ArgumentError)
-        lambda { @measurement.wet?(1.1) }.should_not raise_error(ArgumentError)
-      end
-      
-      it "requires time as a Time object" do
-        #lambda { @measurement.wet?(1,"a") }.should raise_error(ArgumentError)
-        lambda { @measurement.wet?(1,@now) }.should_not raise_error(ArgumentError)
-      end
-
-      it "returns true if a source returns true" do
-        module Barometer; class WeatherService
-          def self.wet?(a=nil,b=nil,c=nil); true; end
-        end; end
-        @measurement.wet?.should be_true
-      end
-
-      it "returns false if a measurement returns false" do
-        module Barometer; class WeatherService
-          def self.wet?(a=nil,b=nil,c=nil); false; end
-        end; end
-        @measurement.wet?.should be_false
-      end
-      
-    end
-    
+     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.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.wet?.should be_false
+       end
+       
+     end
+     
     describe "day?" do
-      
-      it "requires time as a Time object" do
-        #lambda { @measurement.day?("a") }.should raise_error(ArgumentError)
-        lambda { @measurement.day?(@now) }.should_not raise_error(ArgumentError)
-      end
-
-      it "returns true if a source returns true" do
-        module Barometer; class WeatherService
-          def self.day?(a=nil,b=nil); true; end
+    
+      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.day?.should be_true
       end
-
-      it "returns false if a measurement returns false" do
-        module Barometer; class WeatherService
-          def self.day?(a=nil,b=nil); false; 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.day?.should be_false
       end
@@ -434,45 +419,39 @@ describe "Measurement" do
     
     describe "sunny?" do
       
-      it "requires time as a Time object" do
-        #lambda { @measurement.sunny?("a") }.should raise_error(ArgumentError)
-        lambda { @measurement.sunny?(@now) }.should_not raise_error(ArgumentError)
-      end
-
-      it "returns true if a source returns true" do
-        module Barometer; class WeatherService
-          def self.day?(a=nil,b=nil); true; end
+      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 WeatherService
-          def self.sunny?(a=nil,b=nil); true; end
+        module Barometer; class Measurement::Current < Measurement::Common
+          def sunny?(a=nil,b=nil); true; end
         end; end
+        @measurement.day?.should be_true
         @measurement.sunny?.should be_true
       end
-
-      it "returns false if a measurement returns false" do
-        module Barometer; class WeatherService
-          def self.day?(a=nil,b=nil); 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 WeatherService
-          def self.sunny?(a=nil,b=nil); false; end
+        module Barometer; class Measurement::Current < Measurement::Common
+          def sunny?(a=nil,b=nil); false; end
         end; end
+        @measurement.day?.should be_true
         @measurement.sunny?.should be_false
       end
       
       it "returns false if night time" do
-        module Barometer; class WeatherService
-          def self.day?(a=nil,b=nil); true; end
+        module Barometer; class Measurement::Current < Measurement::Common
+          def day?(a=nil); false; end
         end; end
-        module Barometer; class WeatherService
-          def self.sunny?(a=nil,b=nil); true; end
-        end; end
-        @measurement.sunny?.should be_true
-        module Barometer; class WeatherService
-          def self.day?(a=nil,b=nil); false; end
+        module Barometer; class Measurement::Current < Measurement::Common
+          def sunny?(a=nil,b=nil); true; end
         end; end
+        @measurement.day?.should be_false
         @measurement.sunny?.should be_false
       end
-
+    
     end
     
   end