attack-barometer 0.5.0 → 0.6.0

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

data/spec/measurements/night_measurement_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe "Forecasted Night Measurement" do
+  
+  describe "when initialized" do
+    
+    before(:each) do
+      @night = Measurement::ForecastNight.new
+    end
+    
+    it "responds to date" do
+      @night.date.should be_nil
+    end
+    
+    it "responds to pop" do
+      @night.pop.should be_nil
+    end
+
+  end
+  
+  describe "when writing data" do
+    
+    before(:each) do
+      @night = Measurement::ForecastNight.new
+    end
+    
+    it "only accepts Date for date" do
+      invalid_data = 1
+      invalid_data.class.should_not == Date
+      lambda { @night.date = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = Date.new
+      valid_data.class.should == Date
+      lambda { @night.date = 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 { @night.pop = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = 50
+      valid_data.class.should == Fixnum
+      lambda { @night.pop = valid_data }.should_not raise_error(ArgumentError)
+    end
+    
+  end
+  
+end

data/spec/query_spec.rb

@@ -23,6 +23,7 @@ describe "Query" do
     @coordinates_to_weather_id = "USNY0996"
     @icao_to_coordinates = "37.615223,-122.389979"
     @icao_to_geocode = "San Francisco Airport, USA"
+    @icao_to_weather_id = "USCA0987"
     
     Barometer.google_geocode_key = nil
     #Barometer.skip_graticule = true
@@ -135,6 +136,14 @@ describe "Query" do
       @query.geo.should be_nil
     end
     
+    it "responds to timezone" do
+      @query.timezone.should be_nil
+    end
+    
+    it "responds to conversions" do
+      @query.conversions.should be_nil
+    end
+    
   end
   
   describe "when returning the query to a Weather API" do
@@ -371,10 +380,11 @@ describe "Query" do
           query.should be_nil
         end
         
-        it "skips converting to weather_id" do
+        it "converts to weather_id" do
           acceptable_formats = [:weather_id]
           query = @query.convert!(acceptable_formats)
-          query.should be_nil
+          query.q.should == @icao_to_weather_id
+          query.country_code.should == "US"
         end
         
         it "skips converting to zipcode" do

data/spec/spec_helper.rb

@@ -32,6 +32,9 @@ if File.exists?(KEY_FILE)
   	WEATHER_PARTNER_KEY = keys["weather"]["partner"]
   	WEATHER_LICENSE_KEY = keys["weather"]["license"]
 	end
+  if keys["weather_bug"]
+  	WEATHERBUG_CODE = keys["weather_bug"]["code"]
+	end
     
 else
   File.open(KEY_FILE, 'w') {|f| f << "google: geocode: YOUR_KEY_KERE" }
@@ -39,7 +42,6 @@ else
   exit
 end
 
-
   #
   # for geocoding
   #
@@ -147,6 +149,13 @@ end
       '90210.xml')
     )
   )
+  FakeWeb.register_uri(:get, 
+    "http://xoap.weather.com:80/search/search?where=San%20Francisco%20%2C%20USA",
+    :string => File.read(File.join(File.dirname(__FILE__), 
+      'fixtures/formats/weather_id',
+      'ksfo.xml')
+    )
+  )
   #
   # for yahoo.com searches
   #
@@ -157,6 +166,24 @@ end
       'from_USGA0028.xml')
     )
   )
+  
+  #
+  # For wunderground weather
+  #
+  FakeWeb.register_uri(:get, 
+    "http://api.wunderground.com/auto/wui/geo/WXCurrentObXML/index.xml?query=51.055149%2C-114.062438",
+    :string => File.read(File.join(File.dirname(__FILE__), 
+      'fixtures/services/wunderground',
+      'current_calgary_ab.xml')
+    )
+  )  
+  FakeWeb.register_uri(:get, 
+    "http://api.wunderground.com/auto/wui/geo/ForecastXML/index.xml?query=51.055149%2C-114.062438",
+    :string => File.read(File.join(File.dirname(__FILE__), 
+      'fixtures/services/wunderground',
+      'forecast_calgary_ab.xml')
+    )
+  )
 
 Spec::Runner.configure do |config|