barometer 0.8.0 → 0.9.0

data/spec/weather_services/wunderground_v1_spec.rb

@@ -0,0 +1,78 @@
+require_relative '../spec_helper'
+
+module Barometer::WeatherService
+  describe WundergroundV1, vcr: {
+    cassette_name: "WeatherService::WundergroundV1"
+  } do
+
+    it "auto-registers this weather service as :wunderground" do
+      Barometer::WeatherService.source(:wunderground, :v1).should == WundergroundV1
+    end
+
+    describe ".call" do
+      let(:converted_query) { Barometer::ConvertedQuery.new('Calgary,AB', :geocode, :metric) }
+      let(:query) { build_query.tap{|q|q.stub(:convert! => converted_query)} }
+
+      subject { WundergroundV1.call(query) }
+
+      it "asks the query to convert to accepted formats" do
+        query.should_receive(:convert!).with(:zipcode, :postalcode, :icao, :coordinates, :geocode)
+        subject
+      end
+
+      it "includes the expected data" do
+        subject.query.should == 'Calgary,AB'
+        subject.format.should == :geocode
+        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(:string)
+        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, :heat_index).as_format(:optional_string)
+        should have_data(:current, :wind).as_format(:vector)
+        should have_data(:current, :visibility).as_format(:distance)
+        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("CYYC")
+        should have_data(:station, :name).as_value("Calgary,")
+        should have_data(:station, :city).as_value("Calgary")
+        should have_data(:station, :state_code).as_format(:optional_string)
+        should have_data(:station, :country_code).as_value("CA")
+        should have_data(:station, :latitude).as_value(51.11999893)
+        should have_data(:station, :longitude).as_value(-114.01999664)
+
+        should have_data(:location, :name).as_value("Calgary, Alberta")
+        should have_data(:location, :city).as_value("Calgary")
+        should have_data(:location, :state_code).as_value("AB")
+        should have_data(:location, :state_name).as_value("Alberta")
+        should have_data(:location, :zip_code).as_value("00000")
+        should have_data(:location, :country_code).as_value("CA")
+        should have_data(:location, :latitude).as_value(51.11999893)
+        should have_data(:location, :longitude).as_value(-114.01999664)
+
+        should have_data(:timezone, :code).as_format(/^M[DS]T$/i)
+        should have_data(:timezone, :to_s).as_value('America/Edmonton')
+
+        subject.forecast.size.should == 6
+        should have_forecast(:starts_at).as_format(:time)
+        should have_forecast(:ends_at).as_format(:time)
+
+        subject.forecast[0].ends_at.to_i.should == (subject.forecast[0].starts_at + (60 * 60 * 24 - 1)).to_i
+        should have_forecast(:pop).as_format(:float)
+        should have_forecast(:icon).as_format(:string)
+        should have_forecast(:high).as_format(:temperature)
+        should have_forecast(:low).as_format(:temperature)
+        should have_forecast(:sun, :rise).as_format(:time)
+        should have_forecast(:sun, :set).as_format(:time)
+      end
+    end
+  end
+end

data/spec/weather_services/yahoo/response_spec.rb

@@ -0,0 +1,73 @@
+require_relative '../../spec_helper'
+
+module Barometer::WeatherService
+  describe Yahoo::Response do
+    it "parses the timezones correctly for current weather" do
+      payload = Barometer::Utils::Payload.new({
+        "item" => {
+          "pubDate" => "Sun, 14 Apr 2013 1:24 pm PDT"
+        }
+      })
+      response = Yahoo::Response.new.parse(payload)
+
+      utc_observed_at = Time.utc(2013,4,14,20,24,0)
+      utc_stale_at = Time.utc(2013,4,14,21,24,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 the timezones correctly for forecasted weather" do
+      payload = Barometer::Utils::Payload.new({
+        "item" => {
+          "pubDate" => "Sun, 14 Apr 2013 1:24 pm PDT",
+          "forecast" => [
+            {
+              "@date" => "14 Apr 2013"
+            }
+          ]
+        },
+        "astronomy" => {
+          "@sunrise" => "6:44 am",
+          "@sunset" => "5:32 pm"
+        }
+      })
+      response = Yahoo::Response.new.parse(payload)
+
+      utc_starts_at = Time.utc(2013,4,14,7,0,0)
+      utc_ends_at = Time.utc(2013,4,15,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
+
+    it "parses sun timezones correctly" do
+      payload = Barometer::Utils::Payload.new({
+        "item" => {
+          "pubDate" => "Sun, 14 Apr 2013 1:24 pm PDT",
+          "forecast" => [
+            {
+              "@date" => "15 Apr 2013"
+            }
+          ]
+        },
+        "astronomy" => {
+          "@sunrise" => "6:44 am",
+          "@sunset" => "5:32 pm"
+        }
+      })
+      response = Yahoo::Response.new.parse(payload)
+
+      utc_current_sun_rise = Time.utc(2013,4,14,13,44,0)
+      utc_current_sun_set = Time.utc(2013,4,15,0,32,0)
+      utc_forecast_sun_rise = Time.utc(2013,4,15,13,44,0)
+      utc_forecast_sun_set = Time.utc(2013,4,16,0,32,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 ).to eq utc_forecast_sun_rise
+      expect( response.forecast[0].sun.set.utc ).to eq utc_forecast_sun_set
+    end
+  end
+end

data/spec/weather_services/yahoo_spec.rb

@@ -1,143 +1,60 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-include Barometer
+require_relative '../spec_helper'
 
-describe Barometer::WeatherService::Yahoo, :vcr => {
-  :cassette_name => "WeatherService::Yahoo"
+describe Barometer::WeatherService::Yahoo, vcr: {
+  cassette_name: "WeatherService::Yahoo"
 } do
-  before(:each) do
-    @accepted_formats = [:zipcode, :weather_id, :woe_id]
-  end
-
-  describe "the class methods" do
-    it "defines accepted_formats" do
-      WeatherService::Yahoo._accepted_formats.should == @accepted_formats
-    end
-
-    it "defines source_name" do
-      WeatherService::Yahoo._source_name.should == :yahoo
-    end
-
-    it "defines get_all" do
-      WeatherService::Yahoo.respond_to?("_fetch").should be_true
-    end
-  end
-
-  describe "building the current data" do
-    it "defines the build method" do
-      WeatherService::Yahoo.respond_to?("_build_current").should be_true
-    end
-
-    it "requires Hash input" do
-      lambda { WeatherService::Yahoo._build_current }.should raise_error(ArgumentError)
-      lambda { WeatherService::Yahoo._build_current({}) }.should_not raise_error(ArgumentError)
-    end
-
-    it "returns Barometer::CurrentMeasurement object" do
-      current = WeatherService::Yahoo._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::Yahoo.respond_to?("_build_forecast").should be_true
-    end
-
-    it "requires Hash input" do
-      lambda { WeatherService::Yahoo._build_forecast }.should raise_error(ArgumentError)
-      lambda { WeatherService::Yahoo._build_forecast({}) }.should_not raise_error(ArgumentError)
-    end
-
-    it "returns Array object" do
-      current = WeatherService::Yahoo._build_forecast({})
-      current.is_a?(Array).should be_true
-    end
-  end
-
-  describe "building the location data" do
-    it "defines the build method" do
-      WeatherService::Yahoo.respond_to?("_build_location").should be_true
-    end
-
-    it "requires Hash input" do
-      lambda { WeatherService::Yahoo._build_location }.should raise_error(ArgumentError)
-      lambda { WeatherService::Yahoo._build_location({}) }.should_not raise_error(ArgumentError)
-    end
 
-    it "requires Barometer::Geo input" do
-      geo = Data::Geo.new({})
-      lambda { WeatherService::Yahoo._build_location({}, {}) }.should raise_error(ArgumentError)
-      lambda { WeatherService::Yahoo._build_location({}, geo) }.should_not raise_error(ArgumentError)
-    end
-
-    it "returns Barometer::Location object" do
-      location = WeatherService::Yahoo._build_location({})
-      location.is_a?(Data::Location).should be_true
-    end
+  it "auto-registers this weather service as :yahoo" do
+    Barometer::WeatherService.source(:yahoo).should == Barometer::WeatherService::Yahoo
   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::Yahoo.respond_to?("_measure").should be_true
-      end
-
-      it "requires a Barometer::Measurement object" do
-        lambda { WeatherService::Yahoo._measure(nil, @query) }.should raise_error(ArgumentError)
-        lambda { WeatherService::Yahoo._measure("invlaid", @query) }.should raise_error(ArgumentError)
-
-        lambda { WeatherService::Yahoo._measure(@measurement, @query) }.should_not raise_error(ArgumentError)
-      end
-
-      it "requires a Barometer::Query query" do
-        lambda { WeatherService::Yahoo._measure }.should raise_error(ArgumentError)
-        lambda { WeatherService::Yahoo._measure(@measurement, 1) }.should raise_error(ArgumentError)
-
-        lambda { WeatherService::Yahoo._measure(@measurement, @query) }.should_not raise_error(ArgumentError)
-      end
-
-      it "returns a Barometer::Measurement object" do
-        result = WeatherService::Yahoo._measure(@measurement, @query)
-        result.is_a?(Barometer::Measurement).should be_true
-        result.current.is_a?(Measurement::Result).should be_true
-        result.forecast.is_a?(Array).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::Yahoo._measure(@measurement, @query)
-
-      # build current
-      @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)
-
-      # builds location
-      @measurement.location.city.should == "Beverly Hills"
-
-      # builds forecasts
-      @measurement.forecast.size.should == 2
-
-      @measurement.forecast[0].condition.should match(/^[\w ]+$/i)
-      @measurement.forecast[0].icon.to_s.should match(/^\d{1,3}$/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[1].condition.should match(/^[\w ]+$/i)
-      @measurement.forecast[1].icon.to_s.should match(/^\d{1,3}$/i)
-      @measurement.forecast[1].sun.rise.to_s.should match(/^\d{1,2}:\d{1,2}[ ]?[apmAPM]{0,2}$/i)
-      @measurement.forecast[1].sun.set.to_s.should match(/^\d{1,2}:\d{1,2}[ ]?[apmAPM]{0,2}$/i)
+  describe ".call" do
+    let(:converted_query) { Barometer::ConvertedQuery.new('90210', :zipcode, :metric) }
+    let(:query) { build_query.tap{|q|q.stub(:convert! => converted_query)} }
+
+    subject { Barometer::WeatherService::Yahoo.call(query) }
+
+    it "asks the query to convert to accepted formats" do
+      query.should_receive(:convert!).with(:zipcode, :weather_id, :woe_id)
+      subject
+    end
+
+    it "includes the expected data" do
+      subject.query.should == '90210'
+      subject.format.should == :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, :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, :visibility).as_format(:distance)
+      should have_data(:current, :sun, :rise).as_format(:time)
+      should have_data(:current, :sun, :set).as_format(:time)
+
+      should have_data(:location, :city).as_value("Beverly Hills")
+      should have_data(:location, :state_code).as_value("CA")
+      should have_data(:location, :country_code).as_value("US")
+      should have_data(:location, :latitude).as_value(34.08)
+      should have_data(:location, :longitude).as_value(-118.4)
+
+      should have_data(:timezone, :to_s).as_format(/^P[DS]T$/i)
+
+      subject.forecast.size.should == 5
+      should have_forecast(:starts_at).as_format(:time)
+      should have_forecast(:ends_at).as_format(:time)
+      should have_forecast(:icon).as_format(:number)
+      should have_forecast(:condition).as_format(:string)
+      should have_forecast(:high).as_format(:temperature)
+      should have_forecast(:low).as_format(:temperature)
+      should have_forecast(:sun, :rise).as_format(:time)
+      should have_forecast(:sun, :set).as_format(:time)
     end
   end
 end

data/spec/weather_services_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+module Barometer
+  describe WeatherService do
+    around do |example|
+      services_cache = WeatherService.services
+      WeatherService.services = Utils::VersionedRegistration.new
+      example.run
+      WeatherService.services = services_cache
+    end
+
+    describe ".register" do
+      it "adds the weather service to the list of available services" do
+        expect {
+          WeatherService.register(:test_weather, double(:weather_service))
+        }.to change { WeatherService.services.size }.by(1)
+      end
+
+      it "registers the service for a given version" do
+        weather_service = double(:weather_service)
+        WeatherService.register(:test_weather, :v1, weather_service)
+        expect {
+          WeatherService.register(:test_weather, :v2, weather_service)
+        }.to change { WeatherService.services.size }.by(1)
+      end
+
+      it "adds the block as an available weather service" do
+        expect {
+          WeatherService.register(:test_weather) do
+            Response.new.tap do |r|
+              r.current = Response::Current.new
+              r.current.temperature = 30
+            end
+          end
+        }.to change { WeatherService.services.size }.by(1)
+
+        expect( WeatherService.new(:test_weather).measure(build_query).current.temperature.to_i ).to eq 30
+      end
+
+      it "raises an error if no service or block given" do
+        expect {
+          WeatherService.register(:test_weather)
+        }.to raise_error(ArgumentError)
+      end
+
+      it "allows the serivce to be referenced by key" do
+        expect( WeatherService.services ).not_to have_key :test_weather
+        WeatherService.register(:test_weather, double(:weather_service))
+        expect( WeatherService.services ).to have_key :test_weather
+      end
+
+      it "only registers a key once" do
+        weather_service = double(:weather_service)
+        WeatherService.register(:test_weather, weather_service)
+        expect {
+          WeatherService.register(:test_weather, weather_service)
+        }.not_to change { WeatherService.services.size }
+      end
+
+      it "only registers a version once" do
+        weather_service = double(:weather_service)
+        WeatherService.register(:test_weather, :v1, weather_service)
+        expect {
+          WeatherService.register(:test_weather, :v1, weather_service)
+        }.not_to change { WeatherService.services.size }
+      end
+    end
+
+    describe ".source" do
+      it "returns a registered source" do
+        test_weather = double(:test_weather)
+        WeatherService.register(:test_weather, test_weather)
+
+        expect( WeatherService.source(:test_weather) ).to eq test_weather
+      end
+
+      it "raises an error if the source does not exist" do
+        expect {
+          WeatherService.source(:test_weather)
+        }.to raise_error(WeatherService::NotFound)
+      end
+
+      it "raises an error if the version does not exist" do
+        expect {
+          WeatherService.source(:test_weather, :v1)
+        }.to raise_error(WeatherService::NotFound)
+      end
+
+      context "when multiple versions are registered" do
+        it "returns the requested version" do
+          test_weather = double(:test_weather)
+          other_weather = double(:other_weather)
+          WeatherService.register(:test_weather, nil, test_weather)
+          WeatherService.register(:test_weather, :v1, other_weather)
+
+          expect( WeatherService.source(:test_weather) ).to eq test_weather
+          expect( WeatherService.source(:test_weather, nil) ).to eq test_weather
+          expect( WeatherService.source(:test_weather, :v1) ).to eq other_weather
+        end
+      end
+    end
+  end
+end