barometer 0.8.0 → 0.9.0

data/spec/weather_services/weather_bug/current_response_spec.rb

@@ -0,0 +1,64 @@
+require_relative '../../spec_helper'
+
+module Barometer::WeatherService
+  describe WeatherBug::CurrentResponse do
+    it "parses the timezones correctly" do
+      payload = Barometer::Utils::Payload.new({
+        'ob_date' => {
+          'year' => { '@number' => '2013' },
+          'month' => { '@number' => '5' },
+          'day' => { '@number' => '18' },
+          'hour' => { '@hour_24' => '10' },
+          'minute' => { '@number' => '46' },
+          'second' => { '@number' => '0' },
+          'time_zone' => { '@abbrv' => 'PDT' }
+        }
+      })
+      response = WeatherBug::CurrentResponse.new.parse(payload)
+
+      utc_observed_at = Time.utc(2013,5,18,17,46,0)
+      utc_stale_at = Time.utc(2013,5,18,18,46,0)
+
+      expect( response.current.observed_at.utc ).to eq utc_observed_at
+      expect( response.current.stale_at.utc ).to eq utc_stale_at
+      expect( response.timezone.to_s ).to eq 'PDT'
+    end
+
+    it "parses sun timezones correctly" do
+      payload = Barometer::Utils::Payload.new({
+        'ob_date' => {
+          'year' => { '@number' => '2013' },
+          'month' => { '@number' => '4' },
+          'day' => { '@number' => '13' },
+          'hour' => { '@hour_24' => '10' },
+          'minute' => { '@number' => '23' },
+          'second' => { '@number' => '0' },
+          'time_zone' => { '@abbrv' => 'PDT' }
+        },
+        'sunrise' => {
+          'year' => { '@number' => '2013' },
+          'month' => { '@number' => '4' },
+          'day' => { '@number' => '13' },
+          'hour' => { '@hour_24' => '6' },
+          'minute' => { '@number' => '44' },
+          'second' => { '@number' => '19' },
+        },
+        'sunset' => {
+          'year' => { '@number' => '2013' },
+          'month' => { '@number' => '4' },
+          'day' => { '@number' => '13' },
+          'hour' => { '@hour_24' => '17' },
+          'minute' => { '@number' => '31' },
+          'second' => { '@number' => '50' },
+        }
+      })
+      response = WeatherBug::CurrentResponse.new.parse(payload)
+
+      utc_current_sun_rise = Time.utc(2013,4,13,13,44,19)
+      utc_current_sun_set = Time.utc(2013,4,14,0,31,50)
+
+      expect( response.current.sun.rise.utc ).to eq utc_current_sun_rise
+      expect( response.current.sun.set.utc ).to eq utc_current_sun_set
+    end
+  end
+end

data/spec/weather_services/weather_bug/forecast_response_spec.rb

@@ -0,0 +1,23 @@
+require_relative '../../spec_helper'
+
+module Barometer::WeatherService
+  describe WeatherBug::ForecastResponse do
+    let(:current_response) { Barometer::Response.new }
+
+    it "parses the timezones correctly" do
+      current_response.timezone = Barometer::Data::Zone.new('PDT')
+
+      payload = Barometer::Utils::Payload.new({
+        "@date" => "4/13/2013 10:23:00 AM",
+        "forecast" => [{"high" => "13"}]
+      })
+      response = WeatherBug::ForecastResponse.new(current_response).parse(payload)
+
+      utc_starts_at = Time.utc(2013,4,13,7,0,0)
+      utc_ends_at = Time.utc(2013,4,14,6,59,59)
+
+      expect( response.forecast[0].starts_at.utc ).to eq utc_starts_at
+      expect( response.forecast[0].ends_at.utc ).to eq utc_ends_at
+    end
+  end
+end

data/spec/weather_services/weather_bug_spec.rb

@@ -1,218 +1,78 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-include Barometer
+require_relative '../spec_helper'
 
-describe Barometer::WeatherService::WeatherBug, :vcr => {
-  :cassette_name => "WeatherService::WeatherBug"
+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
+  it "auto-registers this weather service as :weather_bug" do
+    Barometer::WeatherService.source(:weather_bug).should == Barometer::WeatherService::WeatherBug
   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 ".call" do
+    context "when no keys provided" do
+      let(:query) { build_query }
 
-  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
+      it "raises error" do
+        expect {
+          Barometer::WeatherService::WeatherBug.call(query)
+        }.to raise_error(Barometer::WeatherService::KeyRequired)
       end
+    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
+    context "when keys are provided" do
+      let(:converted_query) { Barometer::ConvertedQuery.new("90210", :short_zipcode, :metric) }
+      let(:query) { build_query.tap{|q|q.stub(:convert! => converted_query)} }
+      let(:config) { {keys: {code: WEATHERBUG_CODE}} }
 
-      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)
+      subject { Barometer::WeatherService::WeatherBug.call(query, config) }
 
-        lambda { WeatherService::WeatherBug._measure(@measurement, @query) }.should_not raise_error(ArgumentError)
+      it "asks the query to convert to accepted formats" do
+        query.should_receive(:convert!).with(:short_zipcode, :coordinates)
+        subject
       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
+      it "includes the expected data" do
+        subject.query.should == '90210'
+        subject.format.should == :short_zipcode
+        subject.should be_metric
+
+        should have_data(:current, :observed_at).as_format(:time)
+        should have_data(:current, :stale_at).as_format(:time)
+
+        should have_data(:current, :humidity).as_format(:float)
+        should have_data(:current, :condition).as_format(:string)
+        should have_data(:current, :icon).as_format(:number)
+        should have_data(:current, :temperature).as_format(:temperature)
+        should have_data(:current, :dew_point).as_format(:temperature)
+        should have_data(:current, :wind_chill).as_format(:temperature)
+        should have_data(:current, :wind).as_format(:vector)
+        should have_data(:current, :pressure).as_format(:pressure)
+        should have_data(:current, :sun, :rise).as_format(:time)
+        should have_data(:current, :sun, :set).as_format(:time)
+
+        should have_data(:station, :id).as_value("NRTSH")
+        should have_data(:station, :name).as_value("Campbell Hall School")
+        should have_data(:station, :city).as_value("Valley Village")
+        should have_data(:station, :state_code).as_value("CA")
+        should have_data(:station, :country).as_value("USA")
+        should have_data(:station, :zip_code).as_value("91617")
+        should have_data(:station, :latitude).as_value(34.1536102294922)
+        should have_data(:station, :longitude).as_value(-118.398056030273)
+
+        should have_data(:location, :city).as_value("Beverly Hills")
+        should have_data(:location, :state_code).as_value("CA")
+        should have_data(:location, :zip_code).as_value("90210")
+
+        should have_data(:timezone, :to_s).as_format(/^P[DS]T$/i)
+
+        subject.forecast.size.should == 7
+        should have_forecast(:starts_at).as_format(:time)
+        should have_forecast(:ends_at).as_format(:time)
+        should have_forecast(:condition).as_format(:string)
+        should have_forecast(:icon).as_format(:number)
+        should have_forecast(:high).as_format(:temperature)
+        should have_forecast(:low).as_format(:temperature)
       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::WeatherBug._measure(@measurement, @query)
-
-      # build current
-      @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 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"
-      @measurement.station.city.should == "Los Angeles"
-      @measurement.station.state_code.should == "CA"
-      @measurement.station.country.should == "USA"
-      @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"
-      @measurement.location.zip_code.should == "90210"
-
-      # builds forecasts
-      @measurement.forecast.size.should == 7
-
-      @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)
-
-      # 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(/^P[DS]T$/i)
-    end
-  end
 end

data/spec/weather_services/wunderground_v1/current_response_spec.rb

@@ -0,0 +1,19 @@
+require_relative '../../spec_helper'
+
+module Barometer::WeatherService
+  describe WundergroundV1::CurrentResponse do
+    it "parses the timezones correctly" do
+      payload = Barometer::Utils::Payload.new({
+        "local_time" => "May 18, 10:46 AM PDT"
+      })
+      response = WundergroundV1::CurrentResponse.new.parse(payload)
+
+      utc_observed_at = Time.utc(2013,5,18,17,46,0)
+      utc_stale_at = Time.utc(2013,5,18,18,0,0)
+
+      expect( response.current.observed_at.utc ).to eq utc_observed_at
+      expect( response.current.stale_at.utc ).to eq utc_stale_at
+      expect( response.timezone.to_s ).to eq 'PDT'
+    end
+  end
+end

data/spec/weather_services/wunderground_v1/forecast_response_spec.rb

@@ -0,0 +1,62 @@
+require_relative '../../spec_helper'
+
+module Barometer::WeatherService
+  describe WundergroundV1::ForecastResponse do
+    let(:current_response) { Barometer::Response.new }
+
+    it "parses the timezones correctly" do
+      payload = Barometer::Utils::Payload.new({
+        "simpleforecast" => { "forecastday" => [
+          {
+            "date" => {
+              "tz_long" => 'America/Los_Angeles',
+              "pretty" => '10:46 PM PDT on May 18, 2013'
+            }
+          }
+        ]}
+      })
+      response = WundergroundV1::ForecastResponse.new(current_response).parse(payload)
+
+      utc_starts_at = Time.utc(2013,5,19,5,46,0)
+      utc_ends_at = Time.utc(2013,5,20,5,45,59)
+
+      expect( response.forecast[0].starts_at.utc ).to eq utc_starts_at
+      expect( response.forecast[0].ends_at.utc ).to eq utc_ends_at
+      expect( response.timezone.to_s ).to eq 'America/Los_Angeles'
+    end
+
+    it "parses sun timezones correctly" do
+      current_response.current = Barometer::Response::Current.new
+      current_response.current.observed_at = Barometer::Utils::Time.parse("May 18, 10:46 AM PDT")
+      payload = Barometer::Utils::Payload.new({
+        "simpleforecast" => { "forecastday" => [
+          {
+            "date" => {
+              "tz_long" => 'America/Los_Angeles',
+              "pretty" => '10:46 PM PDT on May 18, 2013'
+            }
+          }
+        ]},
+          "moon_phase" => {
+          "sunrise" => {
+            "hour" => '7', "minute" => '59'
+          },
+          "sunset" => {
+            "hour" => '17', "minute" => '42'
+          }
+        }
+      })
+      response = WundergroundV1::ForecastResponse.new(current_response).parse(payload)
+
+      utc_current_sun_rise = Time.utc(2013,5,18,14,59,0)
+      utc_current_sun_set = Time.utc(2013,5,19,0,42,0)
+      utc_forecast_sun_rise = Time.utc(2013,5,19,14,59,0)
+      utc_forecast_sun_set = Time.utc(2013,5,20,0,42,0)
+
+      expect( response.current.sun.rise.utc ).to eq utc_current_sun_rise
+      expect( response.current.sun.set.utc ).to eq utc_current_sun_set
+      expect( response.forecast[0].sun.rise.utc ).to eq utc_forecast_sun_rise
+      expect( response.forecast[0].sun.set.utc ).to eq utc_forecast_sun_set
+    end
+  end
+end