barometer 0.7.3 → 0.8.0

data/spec/spec_helper.rb

@@ -1,16 +1,34 @@
 require 'rubygems'
 require 'rspec'
-require 'mocha'
 require 'cgi'
-
-require File.expand_path(File.dirname(__FILE__) + '/fakeweb_helper')
+require 'pry'
+require 'vcr'
+require 'fakefs/spec_helpers'
 
 $:.unshift((File.join(File.dirname(__FILE__), '..', 'lib')))
 require 'barometer'
 
-#Barometer.debug!
-Barometer.yahoo_placemaker_app_id = "YAHOO"
+WEATHERBUG_CODE = Barometer::KeyFileParser.find(:weather_bug, :code) || 'weatherbug'
+YAHOO_KEY = Barometer::KeyFileParser.find(:yahoo, :app_id) || 'yahoo'
+downcased_weatherbug_code = WEATHERBUG_CODE.to_s
+downcased_weatherbug_code[0] = WEATHERBUG_CODE.to_s[0..0].downcase
+
+# Barometer.debug!
+Barometer.yahoo_placemaker_app_id = 'placemaker'
+
+VCR.configure do |config|
+  config.cassette_library_dir = 'spec/cassettes'
+  config.hook_into :webmock
+  config.default_cassette_options = { :record => :none, :serialize_with => :json }
+
+  config.filter_sensitive_data('WEATHERBUG_CODE') { WEATHERBUG_CODE.to_s }
+  config.filter_sensitive_data('WEATHERBUG_CODE') { downcased_weatherbug_code }
+  config.filter_sensitive_data('<YAHOO_KEY>') { YAHOO_KEY.to_s }
+  config.filter_sensitive_data('<PLACEMAKER_KEY>') { Barometer.yahoo_placemaker_app_id.to_s }
+
+  config.configure_rspec_metadata!
+end
 
 RSpec.configure do |config|
-  
+  config.treat_symbols_as_metadata_keys_with_true_values = true
 end

data/spec/weather_services/noaa_spec.rb

@@ -0,0 +1,179 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+include Barometer
+
+describe Barometer::WeatherService::Noaa, :vcr => {
+  :cassette_name => "WeatherService::Noaa"
+} do
+  before(:each) do
+    @accepted_formats = [:zipcode, :coordinates]
+  end
+
+  describe "the class methods" do
+    it "defines accepted_formats" do
+      WeatherService::Noaa._accepted_formats.should == @accepted_formats
+    end
+
+    it "defines source_name" do
+      WeatherService::Noaa._source_name.should == :noaa
+    end
+
+    it "defines fetch_current" do
+      WeatherService::Noaa.respond_to?("_fetch_current").should be_true
+    end
+
+    it "defines fetch_forecast" do
+      WeatherService::Noaa.respond_to?("_fetch_forecast").should be_true
+    end
+
+    it "defines get_all" do
+      WeatherService::Noaa.respond_to?("_fetch").should be_true
+    end
+
+    describe "acceptable countries" do
+      before(:each) do
+        @query = Barometer::Query.new("90210")
+        @measurement = Barometer::Measurement.new
+      end
+
+      it "accepts nil" do
+        @query.country_code = nil
+        WeatherService::Noaa._supports_country?(@query).should be_true
+      end
+
+      it "accepts blank" do
+        @query.country_code = ""
+        WeatherService::Noaa._supports_country?(@query).should be_true
+      end
+
+      it "accepts US" do
+        @query.country_code = "US"
+        WeatherService::Noaa._supports_country?(@query).should be_true
+      end
+
+      it "rejects other" do
+        @query.country_code = "CA"
+        WeatherService::Noaa._supports_country?(@query).should be_false
+      end
+    end
+  end
+
+  describe "building the current data" do
+    it "defines the build method" do
+      WeatherService::Noaa.respond_to?("_build_current").should be_true
+    end
+
+    it "requires Hash input" do
+      lambda { WeatherService::Noaa._build_current }.should raise_error(ArgumentError)
+      lambda { WeatherService::Noaa._build_current({}) }.should_not raise_error(ArgumentError)
+    end
+
+    it "returns Barometer::CurrentMeasurement object" do
+      current = WeatherService::Noaa._build_current({})
+      current.is_a?(Measurement::Result).should be_true
+    end
+  end
+
+  describe "building the forecast data" do
+    it "defines the build method" do
+      WeatherService::Noaa.respond_to?("_build_forecast").should be_true
+    end
+
+    it "requires Hash input" do
+      lambda { WeatherService::Noaa._build_forecast }.should raise_error(ArgumentError)
+      lambda { WeatherService::Noaa._build_forecast({}) }.should_not raise_error(ArgumentError)
+    end
+
+    it "returns Array object" do
+      current = WeatherService::Noaa._build_forecast({})
+      current.is_a?(Array).should be_true
+    end
+  end
+
+  describe "when measuring" do
+    before(:each) do
+      @query = Barometer::Query.new("90210")
+      @measurement = Barometer::Measurement.new
+    end
+
+    describe "all" do
+      it "responds to _measure" do
+        Barometer::WeatherService::Noaa.respond_to?("_measure").should be_true
+      end
+
+      it "requires a Barometer::Measurement object" do
+        lambda { Barometer::WeatherService::Noaa._measure(nil, @query) }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService::Noaa._measure("invalid", @query) }.should raise_error(ArgumentError)
+
+        lambda { Barometer::WeatherService::Noaa._measure(@measurement, @query) }.should_not raise_error(ArgumentError)
+      end
+
+      it "requires a Barometer::Query query" do
+        lambda { Barometer::WeatherService::Noaa._measure }.should raise_error(ArgumentError)
+        lambda { Barometer::WeatherService::Noaa._measure(@measurement, 1) }.should raise_error(ArgumentError)
+
+        lambda { Barometer::WeatherService::Noaa._measure(@measurement, @query) }.should_not raise_error(ArgumentError)
+      end
+
+      it "returns a Barometer::Measurement object" do
+        result = Barometer::WeatherService::Noaa._measure(@measurement, @query)
+        result.is_a?(Barometer::Measurement).should be_true
+        result.current.is_a?(Barometer::Measurement::Result).should be_true
+        result.forecast.is_a?(Barometer::Measurement::ResultArray).should be_true
+      end
+    end
+  end
+
+  describe "overall data correctness" do
+    before(:each) do
+      @query = Barometer::Query.new("90210")
+      @measurement = Barometer::Measurement.new
+    end
+
+    it "should correctly build the data" do
+      result = WeatherService::Noaa._measure(@measurement, @query)
+
+      # build current
+      @measurement.current.humidity.to_s.should match(/^\d{0,2}$/i)
+      @measurement.current.condition.should match(/^[\w ]{2,}$/i)
+      @measurement.current.icon.to_s.should match(/^\w{1,4}$/i)
+      @measurement.current.temperature.to_s.should match(/^\d{1,3}[ ]?[cfCF]?$/i)
+      @measurement.current.dew_point.to_s.should match(/^\d{1,3}[ ]?[cfCF]?$/i)
+      @measurement.current.wind_chill.to_s.should match(/^\d{0,3}[ ]?[cfCF]?$/i)
+      @measurement.current.wind.to_s.should match(/^\d{1,3}[ ]?[a-zA-Z]{0,3}$/i)
+      @measurement.current.wind.direction.to_s.should match(/^[neswNESW][\w ]{3,}$/i)
+      @measurement.current.wind.degrees.to_s.should match(/^\d{1,3}$/i)
+      @measurement.current.pressure.to_s.should match(/^\d{1,4}[ ]?[a-zA-Z]{0,3}$/i)
+
+      # build station
+      @measurement.station.id.should == "KSMO"
+      @measurement.station.name.should == "Santa Monica Muni, CA"
+      @measurement.station.city.should == "Santa Monica Muni"
+      @measurement.station.state_code.should == "CA"
+      @measurement.station.country_code.should == "US"
+      @measurement.station.latitude.to_f.should == 34.03
+      @measurement.station.longitude.to_f.should == -118.45
+
+      # builds location
+      @measurement.location.city.should == "Santa Monica Muni"
+      @measurement.location.state_code.should == "CA"
+      @measurement.location.country_code.should == "US"
+
+      # builds forecasts
+      @measurement.forecast.size.should == 7
+
+      @measurement.forecast[0].valid_start_date.to_s.should match(/^\d{2,4}-\d{1,2}-\d{1,2}/i)
+      @measurement.forecast[0].valid_end_date.to_s.should match(/^\d{2,4}-\d{1,2}-\d{1,2}/i)
+      @measurement.forecast[0].condition.should match(/^[\w ]+$/i)
+      @measurement.forecast[0].icon.should match(/^[\w ]+$/i)
+      @measurement.forecast[0].high.f.to_s.should match(/^\d{1,3}[ ]?[cfCF]?$/i)
+      @measurement.forecast[0].low.f.to_s.should match(/^\d{1,3}[ ]?[cfCF]?$/i)
+
+      # builds local time
+      @measurement.measured_at.to_s.should match(/^\d{1,2}:\d{1,2}[ ]?[apmAPM]{0,2}$/i)
+      @measurement.current.current_at.to_s.should match(/^\d{1,2}:\d{1,2}[ ]?[apmAPM]{0,2}$/i)
+
+      # builds timezone
+      @measurement.timezone.code.should match(/(PDT|PST)/i)
+    end
+  end
+end

data/spec/weather_services/services_spec.rb

@@ -1,56 +1,52 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-describe "WeatherServices" do
-  
+describe Barometer::WeatherService, :vcr => {
+  :cassette_name => "WeatherService"
+} do
   before(:each) do
     query_term = "Calgary,AB"
     @query = Barometer::Query.new(query_term)
     @service = Barometer::WeatherService.source(:wunderground)
     @time = Time.now
   end
-  
+
   describe "and the class method" do
-    
     describe "source" do
-      
       it "responds" do
         Barometer::WeatherService.respond_to?("source").should be_true
       end
-      
+
       it "requires a Symbol or String" do
         lambda { Barometer::WeatherService.source }.should raise_error(ArgumentError)
         lambda { Barometer::WeatherService.source(1) }.should raise_error(ArgumentError)
-        
+
         lambda { Barometer::WeatherService.source("wunderground") }.should_not raise_error(ArgumentError)
         lambda { Barometer::WeatherService.source(:wunderground) }.should_not raise_error(ArgumentError)
       end
-      
+
       it "raises an error if source doesn't exist" do
         lambda { Barometer::WeatherService.source(:not_valid) }.should raise_error(ArgumentError)
         lambda { Barometer::WeatherService.source(:wunderground) }.should_not raise_error(ArgumentError)
       end
-      
+
       it "returns the corresponding Service object" do
         Barometer::WeatherService.source(:wunderground).should == Barometer::WeatherService::Wunderground
         Barometer::WeatherService.source(:wunderground).superclass.should == Barometer::WeatherService
       end
-      
+
       it "raises an error when retrieving the wrong class" do
         lambda { Barometer::WeatherService.source(:temperature) }.should raise_error(ArgumentError)
       end
-      
     end
-    
   end
-  
+
   describe "when initialized" do
-    
     before(:each) do
       @service = Barometer::WeatherService.new
       @measurement = Barometer::Measurement.new
       @query = Barometer::Query.new("test")
     end
-    
+
     it "defaults _meets_requirements?" do
       Barometer::WeatherService.send("_meets_requirements?").should be_true
     end
@@ -62,82 +58,78 @@ describe "WeatherServices" do
     it "stubs _accepted_formats" do
       lambda { Barometer::WeatherService.send("_accepted_formats") }.should raise_error(NotImplementedError)
     end
-    
+
     it "stubs _measure" do
       Barometer::WeatherService._measure(@measurement,@query,true).is_a?(Barometer::Measurement).should be_true
     end
-    
+
     it "stubs _build_extra" do
       Barometer::WeatherService._build_extra.should be_nil
     end
-    
+
     it "stubs _fetch" do
       Barometer::WeatherService._fetch.should be_nil
     end
-    
+
     it "stubs _build_current" do
       Barometer::WeatherService._build_current.should be_nil
     end
-    
+
     it "stubs _build_forecast" do
       Barometer::WeatherService._build_forecast.should be_nil
     end
-    
+
     it "stubs _build_location" do
       Barometer::WeatherService._build_location.should be_nil
     end
-    
+
     it "stubs _build_sun" do
       Barometer::WeatherService._build_sun.should be_nil
     end
-    
+
     it "stubs _build_links" do
       Barometer::WeatherService._build_links.should == {}
     end
-    
+
     it "defaults _supports_country?" do
       Barometer::WeatherService._supports_country?.should be_true
     end
-    
+
     it "defaults _requires_keys?" do
       Barometer::WeatherService._requires_keys?.should be_false
     end
-    
+
     it "defaults _has_keys?" do
       lambda { Barometer::WeatherService._has_keys? }.should raise_error(NotImplementedError)
     end
-    
   end
-  
+
   describe "when measuring," do
-    
     it "responds to measure" do
       Barometer::WeatherService.respond_to?("measure").should be_true
     end
-    
+
     # since Barometer::WeatherService defines the measure method, you could actually just
     # call Barometer::WeatherService.measure ... but this will not invoke a specific
     # weather API driver.  Make sure this usage raises an error.
     it "requires an actuall driver" do
       lambda { Barometer::WeatherService.measure(@query) }.should raise_error(NotImplementedError)
     end
-    
+
     it "requires a Barometer::Query object" do
       lambda { Barometer::WeatherService.measure("invalid") }.should raise_error(ArgumentError)
       @query.is_a?(Barometer::Query).should be_true
       lambda { Barometer::WeatherService.measure(@query) }.should_not raise_error(ArgumentError)
     end
-    
+
     it "returns a Barometer::Measurement object" do
       @service.measure(@query).is_a?(Barometer::Measurement).should be_true
     end
-    
+
     it "returns current and future" do
       measurement = @service.measure(@query)
       measurement.current.is_a?(Barometer::Measurement::Result).should be_true
       measurement.forecast.is_a?(Array).should be_true
     end
-    
   end
-  
-end
+end

data/spec/weather_services/weather_bug_spec.rb

@@ -1,178 +1,162 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 include Barometer
 
-describe "WeatherBug" do
-  
+describe Barometer::WeatherService::WeatherBug, :vcr => {
+  :cassette_name => "WeatherService::WeatherBug"
+} do
   before(:each) do
     @accepted_formats = [:short_zipcode, :coordinates]
   end
-  
+
   describe "the class methods" do
-    
     it "defines accepted_formats" do
       WeatherService::WeatherBug._accepted_formats.should == @accepted_formats
     end
-    
+
     it "defines source_name" do
       WeatherService::WeatherBug._source_name.should == :weather_bug
     end
-    
+
     it "defines fetch_current" do
       WeatherService::WeatherBug.respond_to?("_fetch_current").should be_true
     end
-    
+
     it "defines fetch_forecast" do
       WeatherService::WeatherBug.respond_to?("_fetch_forecast").should be_true
     end
-    
+
     it "defines _requires_keys?" do
       WeatherService::WeatherBug.respond_to?("_requires_keys?").should be_true
       WeatherService::WeatherBug._requires_keys?.should be_true
     end
-    
+
     it "defines _has_keys?" do
       WeatherService::WeatherBug.respond_to?("_has_keys?").should be_true
       WeatherService::WeatherBug._has_keys?.should be_false
       WeatherService::WeatherBug.keys = { :code => WEATHERBUG_CODE }
       WeatherService::WeatherBug._has_keys?.should be_true
     end
-
   end
-  
+
   describe "building the current data" do
-    
     it "defines the build method" do
       WeatherService::WeatherBug.respond_to?("_build_current").should be_true
     end
-    
+
     it "requires Hash input" do
       lambda { WeatherService::WeatherBug._build_current }.should raise_error(ArgumentError)
       lambda { WeatherService::WeatherBug._build_current({}) }.should_not raise_error(ArgumentError)
     end
-    
+
     it "returns Measurement::Current object" do
       current = WeatherService::WeatherBug._build_current({})
       current.is_a?(Measurement::Result).should be_true
     end
-    
   end
-  
+
   describe "building the forecast data" do
-    
     it "defines the build method" do
       WeatherService::WeatherBug.respond_to?("_build_forecast").should be_true
     end
-    
+
     it "requires Hash input" do
       lambda { WeatherService::WeatherBug._build_forecast }.should raise_error(ArgumentError)
       lambda { WeatherService::WeatherBug._build_forecast({}) }.should_not raise_error(ArgumentError)
     end
-    
+
     it "returns Array object" do
       current = WeatherService::WeatherBug._build_forecast({})
       current.is_a?(Array).should be_true
     end
-    
   end
-  
+
   describe "building the location data" do
-    
     it "defines the build method" do
       WeatherService::WeatherBug.respond_to?("_build_location").should be_true
     end
-    
+
     it "requires Hash input" do
       lambda { WeatherService::WeatherBug._build_location }.should raise_error(ArgumentError)
       lambda { WeatherService::WeatherBug._build_location({}) }.should_not raise_error(ArgumentError)
     end
-    
+
     it "requires Barometer::Geo input" do
       geo = Data::Geo.new({})
       lambda { WeatherService::WeatherBug._build_location({}, {}) }.should raise_error(ArgumentError)
       lambda { WeatherService::WeatherBug._build_location({}, geo) }.should_not raise_error(ArgumentError)
     end
-    
+
     it "returns Barometer::Location object" do
       location = WeatherService::WeatherBug._build_location({})
       location.is_a?(Data::Location).should be_true
     end
-    
   end
-  
+
   describe "building the sun data" do
-    
     it "defines the build method" do
       WeatherService::WeatherBug.respond_to?("_build_sun").should be_true
     end
-    
+
     it "requires Hash input" do
       lambda { WeatherService::WeatherBug._build_sun }.should raise_error(ArgumentError)
       lambda { WeatherService::WeatherBug._build_sun({}) }.should_not raise_error(ArgumentError)
     end
-    
+
     it "returns Barometer::Sun object" do
       sun = WeatherService::WeatherBug._build_sun({})
       sun.is_a?(Data::Sun).should be_true
     end
-    
   end
-  
+
   describe "builds other data" do
-    
     it "defines _build_extra" do
       WeatherService::WeatherBug.respond_to?("_build_extra").should be_true
     end
-    
+
     it "defines _parse_local_time" do
       WeatherService::WeatherBug.respond_to?("_parse_local_time").should be_true
     end
-    
+
     it "defines _build_timezone" do
       WeatherService::WeatherBug.respond_to?("_build_timezone").should be_true
     end
-    
   end
 
   describe "when measuring" do
-  
     before(:each) do
       @query = Barometer::Query.new("90210")
       @measurement = Barometer::Measurement.new
     end
-  
+
     describe "all" do
-      
       it "responds to _measure" do
         WeatherService::WeatherBug.respond_to?("_measure").should be_true
       end
-      
+
       it "requires a Barometer::Measurement object" do
         lambda { WeatherService::WeatherBug._measure(nil, @query) }.should raise_error(ArgumentError)
         lambda { WeatherService::WeatherBug._measure("invalid", @query) }.should raise_error(ArgumentError)
 
         lambda { WeatherService::WeatherBug._measure(@measurement, @query) }.should_not raise_error(ArgumentError)
       end
-  
+
       it "requires a Barometer::Query query" do
         lambda { WeatherService::WeatherBug._measure }.should raise_error(ArgumentError)
         lambda { WeatherService::WeatherBug._measure(@measurement, 1) }.should raise_error(ArgumentError)
-        
+
         lambda { WeatherService::WeatherBug._measure(@measurement, @query) }.should_not raise_error(ArgumentError)
       end
-      
+
       it "returns a Barometer::Measurement object" do
         result = WeatherService::WeatherBug._measure(@measurement, @query)
         result.is_a?(Barometer::Measurement).should be_true
         result.current.is_a?(Measurement::Result).should be_true
         result.forecast.is_a?(Measurement::ResultArray).should be_true
       end
-      
     end
-  
   end
-  
-  describe "overall data correctness" do
 
+  describe "overall data correctness" do
     before(:each) do
       @query = Barometer::Query.new("90210")
       @measurement = Barometer::Measurement.new
@@ -182,20 +166,20 @@ describe "WeatherBug" do
       result = WeatherService::WeatherBug._measure(@measurement, @query)
 
       # build current
-      @measurement.current.humidity.to_i.should == 79
-      @measurement.current.condition.should == "Sunny"
-      @measurement.current.icon.should == "7"
-      @measurement.current.temperature.to_i.should == 13
-      @measurement.current.dew_point.to_i.should == 10
-      @measurement.current.wind_chill.to_i.should == 14
-      @measurement.current.wind.to_i.should == 0
-      @measurement.current.wind.direction.should == "SE"
-      @measurement.current.pressure.to_f.should == 1017.61
+      @measurement.current.humidity.to_s.should match(/^\d{1,2}$/i)
+      @measurement.current.condition.should match(/^[\w ]+$/i)
+      @measurement.current.icon.to_s.should match(/^\d{1,3}$/i)
+      @measurement.current.temperature.to_s.should match(/^\d{1,3}[ ]?[cfCF]?$/i)
+      @measurement.current.dew_point.to_s.should match(/^\d{1,3}[ ]?[cfCF]?$/i)
+      @measurement.current.wind_chill.to_s.should match(/^\d{1,3}[ ]?[cfCF]?$/i)
+      @measurement.current.wind.to_s.should match(/^\d{1,3}[ ]?[a-zA-Z]{0,3}$/i)
+      @measurement.current.wind.direction.to_s.should match(/^[neswNESW]{0,3}$/i)
+      @measurement.current.pressure.to_s.should match(/^\d{1,4}[ ]?[a-zA-Z]{0,3}$/i)
 
       # build sun
-      @measurement.current.sun.rise.to_s.should == "05:42 am"
-      @measurement.current.sun.set.to_s.should == "08:00 pm"
-      
+      @measurement.current.sun.rise.to_s.should match(/^\d{1,2}:\d{1,2}[ ]?[apmAPM]{0,2}$/i)
+      @measurement.current.sun.set.to_s.should match(/^\d{1,2}:\d{1,2}[ ]?[apmAPM]{0,2}$/i)
+
       # build station
       @measurement.station.id.should == "LSNGN"
       @measurement.station.name.should == "Alexander Hamilton Senior HS"
@@ -205,7 +189,7 @@ describe "WeatherBug" do
       @measurement.station.zip_code.should == "90034"
       @measurement.station.latitude.to_f.should == 34.0336112976074
       @measurement.station.longitude.to_f.should == -118.389999389648
-  
+
       # builds location
       @measurement.location.city.should == "Beverly Hills"
       @measurement.location.state_code.should == "CA"
@@ -214,25 +198,21 @@ describe "WeatherBug" do
       # builds forecasts
       @measurement.forecast.size.should == 7
 
-      @measurement.forecast[0].date.should == Date.parse("Jun 2 2011")
-      @measurement.forecast[0].condition.should == "Sunny"
-      @measurement.forecast[0].icon.should == "7"
-      @measurement.forecast[0].high.to_i.should == 24
-      @measurement.forecast[0].low.to_i.should == 11
+      @measurement.forecast[0].date.to_s.should match(/^\d{1,4}-\d{1,2}-\d{1,2}$/i)
+      @measurement.forecast[0].condition.should match(/^[\w ]+$/i)
+      @measurement.forecast[0].icon.to_s.should match(/^\d{1,3}$/i)
+      @measurement.forecast[0].high.to_s.should match(/^\d{1,3}[ ]?[cfCF]?$/i)
+      @measurement.forecast[0].low.to_s.should match(/^\d{1,3}[ ]?[cfCF]?$/i)
+
+      @measurement.forecast[0].sun.rise.to_s.should match(/^\d{1,2}:\d{1,2}[ ]?[apmAPM]{0,2}$/i)
+      @measurement.forecast[0].sun.set.to_s.should match(/^\d{1,2}:\d{1,2}[ ]?[apmAPM]{0,2}$/i)
 
-      @measurement.forecast[0].sun.rise.to_s.should == "05:42 am"
-      @measurement.forecast[0].sun.set.to_s.should == "08:00 pm"
-      
       # builds local time
-      @measurement.measured_at.to_s.should == "07:01 am"
-      @measurement.current.current_at.to_s.should == "07:01 am"
-      
+      @measurement.measured_at.to_s.should match(/^\d{1,2}:\d{1,2}[ ]?[apmAPM]{0,2}$/i)
+      @measurement.current.current_at.to_s.should match(/^\d{1,2}:\d{1,2}[ ]?[apmAPM]{0,2}$/i)
+
       # builds timezone
-      @measurement.timezone.code.should == Data::Zone.new("PDT").code
-      @measurement.timezone.offset.should == Data::Zone.new("PDT").offset
-      @measurement.timezone.today.should == Data::Zone.new("PDT").today
+      @measurement.timezone.code.should match(/^P[DS]T$/i)
     end
-
   end
-  
-end
+end