attack-barometer 0.5.0 → 0.6.0

data/spec/measurements/common_spec.rb

@@ -0,0 +1,352 @@
+require 'spec_helper'
+
+describe "Common Measurement" do
+  
+  describe "when initialized" do
+    
+    before(:each) do
+      @common = Measurement::Common.new
+    end
+    
+    it "responds to humidity" do
+      @common.humidity.should be_nil
+    end
+    
+    it "responds to icon" do
+      @common.icon.should be_nil
+    end
+    
+    it "responds to condition" do
+      @common.condition.should be_nil
+    end
+    
+    it "responds to wind" do
+      @common.wind.should be_nil
+    end
+    
+    it "responds to sun" do
+      @common.sun.should be_nil
+    end
+    
+    it "responds to metric" do
+      @common.metric.should be_true
+    end
+    
+    it "responds to metric?" do
+      @common.metric?.should be_true
+      @common.metric = false
+      @common.metric?.should be_false
+    end
+    
+  end
+  
+  describe "when writing data" do
+    
+    before(:each) do
+      @common = Measurement::Common.new
+    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 { @common.humidity = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = 1.to_i
+      valid_data.class.should == Fixnum
+      lambda { @common.humidity = valid_data }.should_not raise_error(ArgumentError)
+      
+      valid_data = 1.0.to_f
+      valid_data.class.should == Float
+      lambda { @common.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 { @common.icon = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = "valid"
+      valid_data.class.should == String
+      lambda { @common.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 { @common.condition = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = "valid"
+      valid_data.class.should == String
+      lambda { @common.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 { @common.wind = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = Data::Speed.new
+      valid_data.class.should == Data::Speed
+      lambda { @common.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 { @common.sun = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = Data::Sun.new
+      valid_data.class.should == Data::Sun
+      lambda { @common.sun = valid_data }.should_not raise_error(ArgumentError)
+    end
+    
+  end
+  
+  describe "method missing" do
+    
+    before(:each) do
+      @common = Measurement::Common.new
+    end
+    
+    it "responds to method + ?" do
+      valid_method = "humidity"
+      @common.respond_to?(valid_method).should be_true
+      lambda { @common.send(valid_method + "?") }.should_not raise_error(NoMethodError)
+    end
+    
+    it "ignores non_method + ?" do
+      invalid_method = "humid"
+      @common.respond_to?(invalid_method).should be_false
+      lambda { @common.send(invalid_method + "?") }.should raise_error(NoMethodError)
+    end
+    
+    it "returns true if set" do
+      @common.humidity = 10
+      @common.humidity.should_not be_nil
+      @common.humidity?.should be_true
+    end
+    
+    it "returns false if not set" do
+      @common.humidity.should be_nil
+      @common.humidity?.should be_false
+    end
+    
+  end
+  
+  describe "answer simple questions, like" do
+    
+    before(:each) do
+      @common = Measurement::Common.new
+    end
+    
+    describe "windy?" do
+      
+      before(:each) do
+        @wind = Data::Speed.new
+        @wind << 11
+      end
+
+      it "requires real threshold number (or nil)" do
+        lambda { @common.windy?("invalid") }.should raise_error(ArgumentError)
+        lambda { @common.windy? }.should_not raise_error(ArgumentError)
+        lambda { @common.windy?(10) }.should_not raise_error(ArgumentError)
+      end
+      
+      it "returns nil when no wind" do
+        @common.wind?.should be_false
+        @common.windy?.should be_nil
+        @common.wind = @wind
+        @common.wind?.should be_true
+        @common.windy?.should_not be_nil
+      end
+      
+      it "return true when current wind over threshold" do
+        @common.wind = @wind
+        @common.windy?.should be_true
+        @common.windy?(10).should be_true
+      end
+      
+      it "return false when current wind under threshold" do
+        @common.wind = @wind
+        @common.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
+        @common.sun = @sun
+        lambda { @common.day?("invalid") }.should raise_error(ArgumentError)
+        lambda { @common.day? }.should raise_error(ArgumentError)
+        lambda { @common.day?(@mid_time) }.should_not raise_error(ArgumentError)
+      end
+      
+      it "returns nil when no sun" do
+        @common.sun?.should be_false
+        @common.day?(@mid_time).should be_nil
+        @common.sun = @sun
+        @common.sun?.should be_true
+        @common.day?(@mid_time).should_not be_nil
+      end
+      
+      it "return true when time between rise and set" do
+        @common.sun = @sun
+        @common.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)
+        @common.sun = sun
+        @common.day?(@early_time).should be_false
+        
+        sun = Data::Sun.new(@early_time, @mid_time)
+        @common.sun = sun
+        @common.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 { @common.send("_wet_by_humidity?","invalid") }.should raise_error(ArgumentError)
+          lambda { @common.send("_wet_by_humidity?") }.should_not raise_error(ArgumentError)
+          lambda { @common.send("_wet_by_humidity?",99) }.should_not raise_error(ArgumentError)
+        end
+
+        it "returns nil when no humidity" do
+          @common.humidity?.should be_false
+          @common.send("_wet_by_humidity?").should be_nil
+          @common.wet?(nil,99).should be_nil
+          @common.humidity = 100
+          @common.humidity?.should be_true
+          @common.send("_wet_by_humidity?").should_not be_nil
+          @common.wet?(nil,99).should_not be_nil
+        end
+
+        it "return true when current humidity over threshold" do
+          @common.humidity = 100
+          @common.send("_wet_by_humidity?").should be_true
+          @common.send("_wet_by_humidity?",99).should be_true
+          @common.wet?(nil,99).should be_true
+        end
+
+        it "return false when current humidity under threshold" do
+          @common.humidity = 98
+          @common.send("_wet_by_humidity?",99).should be_false
+          @common.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 { @common.send("_wet_by_icon?","invalid") }.should raise_error(ArgumentError)
+          lambda { @common.send("_wet_by_icon?") }.should_not raise_error(ArgumentError)
+          lambda { @common.send("_wet_by_icon?",@wet_icons) }.should_not raise_error(ArgumentError)
+        end
+
+        it "returns nil when no icon or Array" do
+          @common.icon?.should be_false
+          @common.send("_wet_by_icon?",@wet_icons).should be_nil
+          @common.wet?(@wet_icons).should be_nil
+          @common.icon = "rain"
+          @common.icon?.should be_true
+          @common.send("_wet_by_icon?").should be_nil
+          @common.send("_wet_by_icon?",@wet_icons).should_not be_nil
+          @common.wet?(@wet_icons).should_not be_nil
+        end
+
+        it "return true when current icon indicates wet" do
+          @common.icon = "rain"
+          @common.send("_wet_by_icon?",@wet_icons).should be_true
+          @common.wet?(@wet_icons).should be_true
+        end
+
+        it "return false when current icon does NOT indicate wet" do
+          @common.icon = "sun"
+          @common.send("_wet_by_icon?",@wet_icons).should be_false
+          @common.wet?(@wet_icons).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)
+          
+          @common.sun = @sun
+        end
+
+        it "requires Array (or nil)" do
+          lambda { @common.send("_sunny_by_icon?","invalid") }.should raise_error(ArgumentError)
+          lambda { @common.send("_sunny_by_icon?") }.should_not raise_error(ArgumentError)
+          lambda { @common.send("_sunny_by_icon?",@sunny_icons) }.should_not raise_error(ArgumentError)
+        end
+
+        it "returns nil when no icon or Array" do
+          @common.icon?.should be_false
+          @common.send("_sunny_by_icon?",@sunny_icons).should be_nil
+          @common.sunny?(@mid_time,@sunny_icons).should be_nil
+          @common.icon = "sunny"
+          @common.icon?.should be_true
+          @common.send("_sunny_by_icon?").should be_nil
+          @common.send("_sunny_by_icon?",@sunny_icons).should_not be_nil
+          @common.sun?(@mid_time,@sunny_icons).should_not be_nil
+        end
+
+        it "returns true when current icon indicates sunny" do
+          @common.icon = "sunny"
+          @common.send("_sunny_by_icon?",@sunny_icons).should be_true
+          @common.sunny?(@mid_time,@sunny_icons).should be_true
+        end
+
+        it "returns false when current icon does NOT indicate sunny" do
+          @common.icon = "rain"
+          @common.send("_sunny_by_icon?",@sunny_icons).should be_false
+          @common.sunny?(@mid_time,@sunny_icons).should be_false
+        end
+        
+        it "returns false when night" do
+          @common.icon = "sunny"
+          @common.send("_sunny_by_icon?",@sunny_icons).should be_true
+          @common.sunny?(@mid_time,@sunny_icons).should be_true
+          
+          @sun = Data::Sun.new(@mid_time, @late_time)
+          @common.sun = @sun
+          @common.sunny?(@early_time,@sunny_icons).should be_false
+        end
+        
+      end
+      
+    end
+    
+  end
+  
+end

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

@@ -5,19 +5,7 @@ describe "Current Measurement" do
   describe "when initialized" do
     
     before(:each) do
-      @current = Data::CurrentMeasurement.new
-    end
-    
-    it "responds to humidity" do
-      @current.humidity.should be_nil
-    end
-    
-    it "responds to icon" do
-      @current.icon.should be_nil
-    end
-    
-    it "responds to condition" do
-      @current.condition.should be_nil
+      @current = Measurement::Current.new
     end
     
     it "responds to temperature" do
@@ -36,10 +24,6 @@ describe "Current Measurement" do
       @current.wind_chill.should be_nil
     end
     
-    it "responds to wind" do
-      @current.wind.should be_nil
-    end
-    
     it "responds to pressure" do
       @current.pressure.should be_nil
     end
@@ -48,10 +32,6 @@ describe "Current Measurement" do
       @current.pressure.should be_nil
     end
     
-    it "responds to sun" do
-      @current.sun.should be_nil
-    end
-    
     it "responds to current_at" do
       @current.current_at.should be_nil
     end
@@ -65,42 +45,7 @@ describe "Current Measurement" do
   describe "when writing data" do
     
     before(:each) do
-      @current = Data::CurrentMeasurement.new
-    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 { @current.humidity = invalid_data }.should raise_error(ArgumentError)
-      
-      valid_data = 1.to_i
-      valid_data.class.should == Fixnum
-      lambda { @current.humidity = valid_data }.should_not raise_error(ArgumentError)
-      
-      valid_data = 1.0.to_f
-      valid_data.class.should == Float
-      lambda { @current.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 { @current.icon = invalid_data }.should raise_error(ArgumentError)
-      
-      valid_data = "valid"
-      valid_data.class.should == String
-      lambda { @current.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 { @current.condition = invalid_data }.should raise_error(ArgumentError)
-      
-      valid_data = "valid"
-      valid_data.class.should == String
-      lambda { @current.condition = valid_data }.should_not raise_error(ArgumentError)
+      @current = Measurement::Current.new
     end
     
     it "only accepts Data::Temperature for temperature" do
@@ -143,16 +88,6 @@ describe "Current Measurement" do
       lambda { @current.wind_chill = 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 { @current.wind = invalid_data }.should raise_error(ArgumentError)
-      
-      valid_data = Data::Speed.new
-      valid_data.class.should == Data::Speed
-      lambda { @current.wind = 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
@@ -173,16 +108,6 @@ describe "Current Measurement" do
       lambda { @current.visibility = 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 { @current.sun = invalid_data }.should raise_error(ArgumentError)
-      
-      valid_data = Data::Sun.new
-      valid_data.class.should == Data::Sun
-      lambda { @current.sun = 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
@@ -215,35 +140,47 @@ describe "Current Measurement" do
     
   end
   
-  describe "method missing" do
+  describe "answer simple questions, like" do
     
     before(:each) do
-      @current = Data::CurrentMeasurement.new
-    end
-    
-    it "responds to method + ?" do
-      valid_method = "humidity"
-      @current.respond_to?(valid_method).should be_true
-      lambda { @current.send(valid_method + "?") }.should_not raise_error(NoMethodError)
-    end
-    
-    it "ignores non_method + ?" do
-      invalid_method = "humid"
-      @current.respond_to?(invalid_method).should be_false
-      lambda { @current.send(invalid_method + "?") }.should raise_error(NoMethodError)
-    end
-    
-    it "returns true if set" do
-      @current.humidity = 10
-      @current.humidity.should_not be_nil
-      @current.humidity?.should be_true
-    end
-    
-    it "returns false if not set" do
-      @current.humidity.should be_nil
-      @current.humidity?.should be_false
+      @current = Measurement::Current.new
+      @current.temperature = Data::Temperature.new
+      @current.temperature << 5
+      @dew_point = Data::Temperature.new
+      @dew_point << 10
+    end
+    
+    describe "wet?" do
+      
+      describe "wet_by_dewpoint?" do
+        
+        it "returns nil when no dewpoint" do
+          @current.dew_point?.should be_false
+          @current.send("_wet_by_dewpoint?").should be_nil
+          @current.wet?.should be_nil
+          @current.dew_point = @dew_point
+          @current.dew_point?.should be_true
+          @current.send("_wet_by_dewpoint?").should_not be_nil
+          @current.wet?.should_not be_nil
+        end
+
+        it "return true when current dewpoint over temperature" do
+          @current.dew_point = @dew_point
+          @current.send("_wet_by_dewpoint?").should be_true
+          @current.wet?.should be_true
+        end
+
+        it "return false when current dewpoint under temperature" do
+          @current.temperature << 15
+          @current.dew_point = @dew_point
+          @current.send("_wet_by_dewpoint?").should be_false
+          @current.wet?.should be_false
+        end
+
+      end
+      
     end
     
   end
-  
+
 end

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