barometer 0.8.0 → 0.9.0

data/spec/weather_services/base_spec.rb

@@ -0,0 +1,116 @@
+require_relative '../spec_helper'
+
+module Barometer
+  describe WeatherService::Base do
+    around do |example|
+      services_cache = WeatherService.services
+      WeatherService.services = Utils::VersionedRegistration.new
+      example.run
+      WeatherService.services = services_cache
+    end
+
+    describe "#measure" do
+      let(:test_weather) { double(:test_weather) }
+      let(:query) { build_query }
+      let(:options) { {} }
+      let(:test_response) { Response.new }
+
+      before do
+        test_weather.stub(call: test_response)
+        WeatherService.register(:test_weather, test_weather)
+      end
+
+      it "calls the requested weather service" do
+        WeatherService.new(:test_weather).measure(query)
+        expect( test_weather ).to have_received(:call).with(query, {})
+      end
+
+      it "calls the requested version of the weather service" do
+        test_weather_v2 = double(:test_weather, call: test_response)
+        WeatherService.register(:test_weather, :v2, test_weather_v2)
+
+        WeatherService.new(:test_weather, :v2).measure(query)
+
+        expect( test_weather_v2 ).to have_received(:call).with(query, {})
+      end
+
+      it "passes along query and options" do
+        WeatherService.new(:test_weather).measure(query, options)
+        expect( test_weather ).to have_received(:call).with(query, options)
+      end
+
+      describe "timing information" do
+        it "adds response_started_at" do
+          response = WeatherService.new(:test_weather).measure(query)
+          expect( response.response_started_at ).to be
+        end
+
+        it "adds response_ended_at" do
+          response = WeatherService.new(:test_weather).measure(query)
+          expect( response.response_ended_at ).to be
+        end
+      end
+
+      describe "source information" do
+        it "adds the source" do
+          response = WeatherService.new(:test_weather).measure(query)
+          expect( response.source ).to eq :test_weather
+        end
+
+        it "adds the source weight" do
+          response = WeatherService.new(:test_weather).measure(query, {weight: 10})
+          expect( response.weight ).to eq 10
+        end
+
+        it "adds the default source weight" do
+          response = WeatherService.new(:test_weather).measure(query)
+          expect( response.weight ).to eq 1
+        end
+      end
+
+      describe "error handling" do
+        it "adds code 200 if no errors" do
+          test_response.stub(complete?: true)
+
+          response = WeatherService.new(:test_weather).measure(query)
+          expect( response.status_code ).to eq 200
+        end
+
+        it "adds code 204 if service has no data" do
+          test_response.stub(complete?: false)
+
+          response = WeatherService.new(:test_weather).measure(query)
+          expect( response.status_code ).to eq 204
+        end
+
+        it "adds code 401 if required key not provided" do
+          test_weather.stub(:call).and_raise(WeatherService::KeyRequired)
+
+          response = WeatherService.new(:test_weather).measure(query)
+          expect( response.status_code ).to eq 401
+        end
+
+        it "adds code 406 if query format unsupported" do
+          test_weather.stub(:call).and_raise(Query::ConversionNotPossible)
+
+          response = WeatherService.new(:test_weather).measure(query)
+          expect( response.status_code ).to eq 406
+        end
+
+        it "adds code 406 if query region unsupported" do
+          test_weather.stub(:call).and_raise(Query::UnsupportedRegion)
+
+          response = WeatherService.new(:test_weather).measure(query)
+          expect( response.status_code ).to eq 406
+        end
+
+        it "adds code 408 if service unavailable (timeout)" do
+          test_weather.stub(:call).and_raise(Timeout::Error)
+
+          response = WeatherService.new(:test_weather).measure(query)
+          expect( response.status_code ).to eq 408
+        end
+      end
+    end
+  end
+end

data/spec/weather_services/forecast_io_spec.rb

@@ -0,0 +1,71 @@
+require_relative '../spec_helper'
+
+describe Barometer::WeatherService::ForecastIo, vcr: {
+  cassette_name: "WeatherService::ForecastIo"
+} do
+
+  it "auto-registers this weather service as :forecast_io" do
+    Barometer::WeatherService.source(:forecast_io).should == Barometer::WeatherService::ForecastIo
+  end
+
+  describe ".call" do
+    context "when no keys provided" do
+      let(:query) { build_query }
+
+      it "raises error" do
+        expect {
+          Barometer::WeatherService::ForecastIo.call(query)
+        }.to raise_error(Barometer::WeatherService::KeyRequired)
+      end
+    end
+
+    context "when keys are provided" do
+      let(:converted_query) { Barometer::ConvertedQuery.new('42.7243,-73.6927', :coordinates, :metric) }
+      let(:query) { build_query.tap{|q|q.stub(:convert! => converted_query)} }
+      let(:config) { {keys: {api: FORECAST_IO_APIKEY}} }
+
+      subject { Barometer::WeatherService::ForecastIo.call(query, config) }
+
+      it "asks the query to convert to accepted formats" do
+        query.should_receive(:convert!).with(:coordinates)
+        subject
+      end
+
+      it "includes the expected data" do
+        subject.query.should == '42.7243,-73.6927'
+        subject.format.should == :coordinates
+        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).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, :latitude).as_value(42.7243)
+        should have_data(:location, :longitude).as_value(-73.6927)
+
+        should have_data(:timezone, :to_s).as_value('America/New_York')
+        should have_data(:timezone, :code).as_format(/^E[DS]T$/i)
+
+        subject.forecast.size.should == 8
+        should have_forecast(:starts_at).as_format(:time)
+        should have_forecast(:ends_at).as_format(:time)
+        should have_forecast(:icon).as_format(:string)
+        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
+end

data/spec/weather_services/noaa/current_response_spec.rb

@@ -0,0 +1,22 @@
+require_relative '../../spec_helper'
+
+module Barometer::WeatherService
+  describe Noaa::CurrentResponse do
+    let(:forecast_response) { Barometer::Response.new }
+
+    it "parses the timezones correctly" do
+      payload = Barometer::Utils::Payload.new({
+        "observation_time_rfc822" => "Sun, 14 Apr 2013 10:51:00 -0700",
+        "observation_time" => "Last Updated on Apr 14 2013, 10:51 am PDT"
+      })
+      response = Noaa::CurrentResponse.new(forecast_response).parse(payload)
+
+      utc_observed_at = Time.utc(2013,04,14,17,51,00)
+      utc_stale_at = Time.utc(2013,04,14,18,51,00)
+
+      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/noaa/forecast_response_spec.rb

@@ -0,0 +1,33 @@
+require_relative '../../spec_helper'
+
+module Barometer::WeatherService
+  describe Noaa::ForecastResponse do
+    it "parses the timezones correctly" do
+      payload = Barometer::Utils::Payload.new({
+        "time_layout" => [
+          {
+            "layout_key"=> "k-p12h-n14-2",
+            "start_valid_time" => ["2013-02-09T06:00:00-08:00"],
+            "end_valid_time" => ["2013-02-09T18:00:00-08:00"]
+          }
+        ],
+        "parameters" => {
+          "temperature" => [
+            {"value"=>["55"], "@type"=>"maximum"},
+            {"@type"=>"minimum"}
+          ],
+          "probability_of_precipitation" => { "value" => [] },
+          "weather" => { "weather_conditions" => [] },
+          "conditions_icon" => { "icon_link" => [] }
+        }
+      })
+      response = Noaa::ForecastResponse.new.parse(payload)
+
+      utc_starts_at = Time.utc(2013,2,9,14,0,0)
+      utc_ends_at = Time.utc(2013,2,10,2,0,0)
+
+      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/noaa_spec.rb

@@ -1,179 +1,81 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-include Barometer
+require_relative '../spec_helper'
 
-describe Barometer::WeatherService::Noaa, :vcr => {
-  :cassette_name => "WeatherService::Noaa"
+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
+  it "auto-registers this weather service as :noaa" do
+    Barometer::WeatherService.source(:noaa).should == Barometer::WeatherService::Noaa
   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
+  describe ".call" do
+    let(:query) { build_query.tap{|q|q.stub(add_conversion: nil)} }
 
-    it "returns Barometer::CurrentMeasurement object" do
-      current = WeatherService::Noaa._build_current({})
-      current.is_a?(Measurement::Result).should be_true
-    end
-  end
+    subject { Barometer::WeatherService::Noaa.call(query) }
 
-  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
+    before do
+      query.stub(:convert!).and_return do |*formats|
+        if formats.include?(:noaa_station_id)
+          Barometer::ConvertedQuery.new("KSMO", :station_id)
+        elsif formats.include?(:zipcode)
+          Barometer::ConvertedQuery.new("90210", :zipcode)
+        end
       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)
+    it "asks the query to convert to accepted formats" do
+      query.should_receive(:convert!).with(:zipcode, :coordinates)
+      subject
+    end
+
+    it "adds a coordinate conversion to the query" do
+      query.should_receive(:add_conversion).with(:coordinates, '34.1,-118.41')
+      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(:string)
+      should have_data(:current, :temperature).as_format(:temperature)
+      # should have_data(:current, :wind_chill).as_format(:temperature)
+      should have_data(:current, :dew_point).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(:location, :name).as_value("Santa Monica Muni, CA")
+      should have_data(:location, :city).as_value("Santa Monica Muni")
+      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.10)
+      should have_data(:location, :longitude).as_value(-118.41)
+
+      should have_data(:station, :id).as_value("KSMO")
+      should have_data(:station, :name).as_value("Santa Monica Muni, CA")
+      should have_data(:station, :city).as_value("Santa Monica Muni")
+      should have_data(:station, :state_code).as_value("CA")
+      should have_data(:station, :country_code).as_value("US")
+      should have_data(:station, :latitude).as_value(34.10)
+      should have_data(:station, :longitude).as_value(-118.41)
+
+      should have_data(:timezone, :to_s).as_format(/^P[DS]T$/i)
+
+      subject.forecast.size.should == 14
+      should have_forecast(:starts_at).as_format(:time)
+      should have_forecast(:ends_at).as_format(:time)
+      should have_forecast(:icon).as_format(:string)
+      should have_forecast(:condition).as_format(:string)
+      should have_forecast(:pop).as_format(:float)
+      should have_forecast(:high).as_format(:temperature)
+      should have_forecast(:low).as_format(:temperature)
     end
   end
 end