barometer 0.8.0 → 0.9.0

data/spec/query/formats/short_zipcode_spec.rb

@@ -0,0 +1,18 @@
+require_relative '../../spec_helper'
+
+describe Barometer::Query::Format::ShortZipcode do
+  it ".country_code" do
+    Barometer::Query::Format::ShortZipcode.country_code(nil).should == "US"
+    Barometer::Query::Format::ShortZipcode.country_code("ignored").should == "US"
+  end
+
+  describe ".is?" do
+    it "recognizes a valid format" do
+      Barometer::Query::Format::ShortZipcode.is?("90210").should be_true
+    end
+
+    it "recognizes non-valid format" do
+      Barometer::Query::Format::ShortZipcode.is?("90210-5555").should be_false
+    end
+  end
+end

data/spec/query/formats/unknown_spec.rb

@@ -0,0 +1,9 @@
+require_relative '../../spec_helper'
+
+describe Barometer::Query::Format::Unknown do
+  describe ".is?" do
+    it "returns true" do
+      Barometer::Query::Format::Unknown.is?("New York, NY").should be_true
+    end
+  end
+end

data/spec/query/formats/weather_id_spec.rb

@@ -0,0 +1,31 @@
+require_relative '../../spec_helper'
+
+describe Barometer::Query::Format::WeatherID do
+  it ".country_code" do
+    Barometer::Query::Format::WeatherID.country_code(nil).should be_nil
+    Barometer::Query::Format::WeatherID.country_code("i").should be_nil
+    Barometer::Query::Format::WeatherID.country_code("USGA0000").should == "US"
+    Barometer::Query::Format::WeatherID.country_code("CAAB0000").should == "CA"
+    Barometer::Query::Format::WeatherID.country_code("SPXX0000").should == "ES"
+  end
+
+  describe ".is?" do
+    it "recognizes a valid format" do
+      Barometer::Query::Format::WeatherID.is?("USGA0028").should be_true
+    end
+
+    it "recognizes non-valid format" do
+      Barometer::Query::Format::WeatherID.is?("invalid").should be_false
+    end
+  end
+
+  describe "fixing country codes" do
+    it "doesn't fix a correct code" do
+      Barometer::Query::Format::WeatherID.send("_fix_country", "CA").should == "CA"
+    end
+
+    it "fixes an incorrect code" do
+      Barometer::Query::Format::WeatherID.send("_fix_country", "SP").should == "ES"
+    end
+  end
+end

data/spec/query/formats/woe_id_spec.rb

@@ -0,0 +1,45 @@
+require_relative '../../spec_helper'
+
+module Barometer::Query
+  describe Format::WoeID do
+    describe '.is?' do
+      it 'recognizes a valid 4 digit code format' do
+        expect( Format::WoeID.is?('8775') ).to be_true
+      end
+
+      it 'recognizes a valid 6 digit code format' do
+        expect( Format::WoeID.is?('615702') ).to be_true
+      end
+
+      it 'recognizes a valid 7 digit code format' do
+        expect( Format::WoeID.is?('2459115') ).to be_true
+      end
+
+      it 'recognizes a valid 5 digit code with a prepended "w"' do
+        expect( Format::WoeID.is?('w90210') ).to be_true
+      end
+
+      it 'does not recognize a zip code' do
+        expect( Format::WoeID.is?('90210') ).to be_false
+      end
+
+      it 'recognizes non-valid format' do
+        expect( Format::WoeID.is?('USGA0028') ).to be_false
+      end
+    end
+
+    describe '.convert_query' do
+      it 'recognizes standard woe ids' do
+        query_no_conversion = '2459115'
+        query = Barometer::Query.new(query_no_conversion)
+        expect( query.q ).to eq query_no_conversion
+      end
+
+      it 'removes the prefix from "w" prefixed queries' do
+        query_with_conversion = 'w90210'
+        query = Barometer::Query.new(query_with_conversion)
+        expect( query.q ).to eq '90210'
+      end
+    end
+  end
+end

data/spec/query/formats/zipcode_spec.rb

@@ -0,0 +1,18 @@
+require_relative '../../spec_helper'
+
+describe Barometer::Query::Format::Zipcode do
+  it ".country_code" do
+    Barometer::Query::Format::Zipcode.country_code(nil).should == "US"
+    Barometer::Query::Format::Zipcode.country_code("ignored").should == "US"
+  end
+
+  describe ".is?" do
+    it "recognizes a valid format" do
+      Barometer::Query::Format::Zipcode.is?("90210-5555").should be_true
+    end
+
+    it "recognizes non-valid format" do
+      Barometer::Query::Format::Zipcode.is?("invalid").should be_false
+    end
+  end
+end

data/spec/query/formats_spec.rb

@@ -0,0 +1,55 @@
+require_relative '../spec_helper'
+
+describe Barometer::Query::Format do
+  def clear_formats
+    @formats_cache = Barometer::Query::Format.formats
+    Barometer::Query::Format.formats = []
+  end
+
+  def reset_formats
+    Barometer::Query::Format.formats = @formats_cache
+  end
+
+  describe ".register" do
+    before { clear_formats }
+    after { reset_formats }
+
+    it "adds the query format to the list of available formats" do
+      expect {
+        Barometer::Query::Format.register(:test_format, double(:format))
+      }.to change { Barometer::Query::Format.formats.count }.by(1)
+    end
+
+    it "raises an error if no format class given" do
+      expect {
+        Barometer::Query::Format.register(:test_format)
+      }.to raise_error(ArgumentError)
+    end
+
+    it "only registers a key once" do
+      format = double(:format)
+      Barometer::Query::Format.register(:test_format, format)
+      expect {
+        Barometer::Query::Format.register(:test_format, format)
+      }.not_to change { Barometer::Query::Format.formats.count }
+    end
+  end
+
+  describe ".find" do
+    before { clear_formats }
+    after { reset_formats }
+
+    it "returns a registered format" do
+      test_format = double(:test_format)
+      Barometer::Query::Format.register(:test_format, test_format)
+
+      Barometer::Query::Format.find(:test_format).should == test_format
+    end
+
+    it "raises an error if the format does not exist" do
+      expect {
+        Barometer::Query::Format.find(:test_format)
+      }.to raise_error(Barometer::Query::Format::NotFound)
+    end
+  end
+end

data/spec/query/services/from_weather_id_spec.rb

@@ -0,0 +1,54 @@
+require_relative '../../spec_helper'
+
+module Barometer::Query
+  describe Service::FromWeatherId, vcr: {
+    cassette_name: 'Service::FromWeatherId'
+  } do
+    describe '#call' do
+      context 'when the query format is not :weather_id' do
+        let(:query) { Barometer::Query.new('90210') }
+
+        it 'returns nothing' do
+          geo = Service::FromWeatherId.new(query).call
+          expect( geo ).to be_nil
+        end
+
+        context 'and a :weather_id conversion exists' do
+          it 'returns the correct geo data' do
+            query.add_conversion(:weather_id, 'USNY0996')
+            geo = Service::FromWeatherId.new(query).call
+
+            expect( geo.latitude ).to eq 40.67
+            expect( geo.longitude ).to eq -73.94
+            expect( geo.locality ).to eq 'New York'
+            expect( geo.region ).to eq 'NY'
+            expect( geo.country_code ).to eq 'US'
+
+            expect( geo.query ).to be_nil
+            expect( geo.country ).to be_nil
+            expect( geo.address ).to be_nil
+            expect( geo.postal_code ).to be_nil
+          end
+        end
+      end
+
+      context 'when the query format is :weather_id' do
+        it 'returns the correct geo data' do
+          query = Barometer::Query.new('USNY0996')
+          geo = Service::FromWeatherId.new(query).call
+
+          expect( geo.latitude ).to eq 40.67
+          expect( geo.longitude ).to eq -73.94
+          expect( geo.locality ).to eq 'New York'
+          expect( geo.region ).to eq 'NY'
+          expect( geo.country_code ).to eq 'US'
+
+          expect( geo.query ).to be_nil
+          expect( geo.country ).to be_nil
+          expect( geo.address ).to be_nil
+          expect( geo.postal_code ).to be_nil
+        end
+      end
+    end
+  end
+end

data/spec/query/services/google_geocode_spec.rb

@@ -0,0 +1,60 @@
+require_relative '../../spec_helper'
+
+module Barometer::Query
+  describe Service::GoogleGeocode, vcr: {
+    cassette_name: 'Service::GoogleGeocode'
+  } do
+    describe '.call' do
+      context 'when the query is a :zipcode' do
+        it 'returns the correct Geo data' do
+          query = Barometer::Query.new('90210')
+          geo = Service::GoogleGeocode.new(query).call
+
+          expect( geo.query ).to eq '90210'
+          expect( geo.latitude ).to eq 34.1030032
+          expect( geo.longitude ).to eq -118.4104684
+          expect( geo.locality ).to eq 'Beverly Hills'
+          expect( geo.region ).to eq 'CA'
+          expect( geo.country ).to eq 'United States'
+          expect( geo.country_code ).to eq 'US'
+          expect( geo.address ).to be_nil
+          expect( geo.postal_code ).to eq '90210'
+        end
+      end
+
+      context 'when the query is a city/region' do
+        it 'returns the correct Geo data' do
+          query = Barometer::Query.new('New York, NY')
+          geo = Service::GoogleGeocode.new(query).call
+
+          expect( geo.query ).to eq 'New York, NY, US'
+          expect( geo.latitude ).to eq 40.7143528
+          expect( geo.longitude ).to eq -74.00597309999999
+          expect( geo.locality ).to eq 'New York'
+          expect( geo.region ).to eq 'NY'
+          expect( geo.country ).to eq 'United States'
+          expect( geo.country_code ).to eq 'US'
+          expect( geo.address ).to be_nil
+          expect( geo.postal_code ).to be_nil
+        end
+      end
+
+      context 'when the query is :coordinates' do
+        it 'returns the correct Geo data' do
+          query = Barometer::Query.new('47,-114')
+          geo = Service::GoogleGeocode.new(query).call
+
+          expect( geo.query ).to be_nil
+          expect( geo.latitude ).to eq 47.000623
+          expect( geo.longitude ).to eq -114.0016495
+          expect( geo.locality ).to eq 'Missoula'
+          expect( geo.region ).to eq 'MT'
+          expect( geo.country ).to eq 'United States'
+          expect( geo.country_code ).to eq 'US'
+          expect( geo.address ).to be_nil
+          expect( geo.postal_code ).to eq '59808'
+        end
+      end
+    end
+  end
+end

data/spec/query/services/noaa_station_id_spec.rb

@@ -0,0 +1,23 @@
+require_relative '../../spec_helper'
+
+describe Barometer::Query::Service::NoaaStation, vcr: {
+  cassette_name: "Service::NoaaStation"
+} do
+  describe ".fetch," do
+    it "returns nohing if query doesn't have coordinates format" do
+      query = Barometer::Query.new("90210")
+      Barometer::Query::Service::NoaaStation.fetch(query).should be_nil
+    end
+
+    it "returns a station_id if the query is format coordinates" do
+      query = Barometer::Query.new("34.10,-118.41")
+      Barometer::Query::Service::NoaaStation.fetch(query).should == "KSMO"
+    end
+
+    it "returns a station_id if the query has a corrdinates conversion" do
+      query = Barometer::Query.new("90210")
+      query.add_conversion(:coordinates, "34.10,-118.41")
+      Barometer::Query::Service::NoaaStation.fetch(query).should == "KSMO"
+    end
+  end
+end

data/spec/query/services/to_weather_id_spec.rb

@@ -0,0 +1,23 @@
+require_relative '../../spec_helper'
+
+describe Barometer::Query::Service::ToWeatherId, vcr: {
+  cassette_name: "Service::ToWeatherId"
+} do
+  describe ".call," do
+    it "returns nothing if query doesn't have a supported format" do
+      query = Barometer::Query.new("90210")
+      Barometer::Query::Service::ToWeatherId.call(query).should be_nil
+    end
+
+    it "returns a weather_id if the query is format unknown" do
+      query = Barometer::Query.new("Paris, France")
+      Barometer::Query::Service::ToWeatherId.call(query).should == "FRXX0076"
+    end
+
+    it "returns a weather_id if the query has a supported conversion" do
+      query = Barometer::Query.new("10001")
+      query.add_conversion(:geocode, "New York, NY")
+      Barometer::Query::Service::ToWeatherId.call(query).should == "USNY0996"
+    end
+  end
+end

data/spec/query/services/to_woe_id_spec.rb

@@ -0,0 +1,51 @@
+require_relative '../../spec_helper'
+
+module Barometer::Query
+  describe Service::ToWoeId, vcr: {
+    cassette_name: 'Service::ToWoeId'
+  } do
+    describe '.call,' do
+      it 'returns nothing if query is an unsupported format' do
+        query = Barometer::Query.new('KSFO')
+        expect( Service::ToWoeId.new(query).call ).to be_nil
+      end
+
+      it 'returns a weather_id if the query is format short_zipcode' do
+        query = Barometer::Query.new('90210')
+        expect( Service::ToWoeId.new(query).call ).to eq '12795711'
+      end
+
+      it 'returns a weather_id if the query is format zipcode' do
+        query = Barometer::Query.new('10001-5555')
+        expect( Service::ToWoeId.new(query).call ).to eq '12761333'
+      end
+
+      it 'returns a weather_id if the query is format unknown' do
+        query = Barometer::Query.new('Paris, France')
+        expect( Service::ToWoeId.new(query).call ).to eq '12727257'
+      end
+
+      it 'returns a weather_id if the query is format coordinates' do
+        query = Barometer::Query.new('40.756054,-73.986951')
+        expect( Service::ToWoeId.new(query).call ).to eq '12761367'
+      end
+
+      it 'returns a weather_id if the query is format postal code' do
+        query = Barometer::Query.new('T5B 4M9')
+        expect( Service::ToWoeId.new(query).call ).to eq '12698082'
+      end
+
+      it 'returns a weather_id if the query is format ipv4 address' do
+        query = Barometer::Query.new('98.139.183.24')
+        expect( Service::ToWoeId.new(query).call ).to eq '12763119'
+      end
+
+      it 'returns a weather_id if the query has a converted geocode' do
+        query = Barometer::Query.new('KJFK')
+        query.add_conversion(:zipcode, '10001-5555')
+
+        expect( Service::ToWoeId.new(query).call ).to eq '12761333'
+      end
+    end
+  end
+end

data/spec/query/services/yahoo_geocode_spec.rb

@@ -0,0 +1,72 @@
+require_relative '../../spec_helper'
+
+module Barometer::Query
+  describe Service::YahooGeocode, vcr: {
+    cassette_name: 'Service::YahooGeocode'
+  } do
+    describe '#call' do
+      context 'when the query format is unsupported' do
+        let(:query) { Barometer::Query.new('90210') }
+
+        it 'returns nothing' do
+          geo = Service::YahooGeocode.new(query).call
+          expect( geo ).to be_nil
+        end
+
+        context 'and a :woe_id conversion exists' do
+          it 'returns the correct geo data' do
+            query.add_conversion(:woe_id, '615702')
+            geo = Service::YahooGeocode.new(query).call
+
+            expect( geo.latitude ).to eq 48.85693
+            expect( geo.longitude ).to eq 2.3412
+            expect( geo.locality ).to eq 'Paris'
+            expect( geo.region ).to eq 'Ile-de-France'
+            expect( geo.country ).to eq 'France'
+            expect( geo.country_code ).to eq 'FR'
+            expect( geo.postal_code ).to eq '75001'
+
+            expect( geo.query ).to be_nil
+            expect( geo.address ).to be_nil
+          end
+        end
+      end
+
+      context 'when the query format is :woe_id' do
+        it 'returns the correct geo data' do
+          query = Barometer::Query.new('615702')
+          geo = Service::YahooGeocode.new(query).call
+
+          expect( geo.latitude ).to eq 48.85693
+          expect( geo.longitude ).to eq 2.3412
+          expect( geo.locality ).to eq 'Paris'
+          expect( geo.region ).to eq 'Ile-de-France'
+          expect( geo.country ).to eq 'France'
+          expect( geo.country_code ).to eq 'FR'
+          expect( geo.postal_code ).to eq '75001'
+
+          expect( geo.query ).to be_nil
+          expect( geo.address ).to be_nil
+        end
+      end
+
+      context 'when the query format is :ipv4_address' do
+        it 'returns the correct geo data' do
+          query = Barometer::Query.new('8.8.8.8')
+          geo = Service::YahooGeocode.new(query).call
+
+          expect( geo.latitude ).to eq 37.418726
+          expect( geo.longitude ).to eq -122.072037
+          expect( geo.locality ).to eq 'Mountain View'
+          expect( geo.region ).to eq 'CA'
+          expect( geo.country_code ).to eq 'US'
+          expect( geo.country ).to eq 'United States'
+          expect( geo.postal_code ).to eq '94043'
+
+          expect( geo.query ).to be_nil
+          expect( geo.address ).to be_nil
+        end
+      end
+    end
+  end
+end