noaa_weather_client 0.0.1

data/spec/lib/noaa_client/responses/station_spec.rb

@@ -0,0 +1,53 @@
+require 'nokogiri'
+require_relative '../../../spec_helper'
+require_relative '../../../../lib/noaa_weather_client/responses/station'
+
+module NoaaWeatherClient
+  module Responses
+    describe Station do
+      let(:source) {
+        <<-xml
+  <station>
+    <station_id>TAPA</station_id>
+    <state>AG</state>
+    <station_name>Vc Bird Intl Airport Antigua</station_name>
+    <latitude>17.117</latitude>
+    <longitude>-61.783</longitude>
+    <html_url>http://weather.noaa.gov/weather/current/TAPA.html</html_url>
+    <rss_url>http://weather.gov/xml/current_obs/TAPA.rss</rss_url>
+    <xml_url>http://weather.gov/xml/current_obs/TAPA.xml</xml_url>
+  </station>
+        xml
+      }
+      let(:station) { Station.new Nokogiri::XML.parse(source) }
+
+      it "accepts an attributes hash" do
+        station
+      end
+
+      it "exposes station id" do
+        expect(station.station_id).to eq('TAPA')
+      end
+
+      it "exposes station name" do
+        expect(station.station_name).to eq('Vc Bird Intl Airport Antigua')
+      end
+
+      it "exposes state" do
+        expect(station.state).to eq('AG')
+      end
+
+      it "exposes latitude" do
+        expect(station.latitude).to eq(17.117)
+      end
+
+      it "exposes longitude" do
+        expect(station.longitude).to eq(-61.783)
+      end
+
+      it "exposes xml url" do
+        expect(station.xml_url).to eq('http://w1.weather.gov/xml/current_obs/TAPA.xml')
+      end
+    end
+  end
+end

data/spec/lib/noaa_client/responses/stations_spec.rb

@@ -0,0 +1,86 @@
+require 'nokogiri'
+require_relative '../../../spec_helper'
+require_relative '../../../../lib/noaa_weather_client/responses/stations'
+
+module NoaaWeatherClient
+  module Responses
+    describe Stations do
+      let(:fake_response) { STATIONS_XML }
+      let(:stations) { Stations.new fake_response }
+
+      it "requires a response" do
+        stations
+        expect { Stations.new }.to raise_error(ArgumentError)
+      end
+
+      it "exposes a list of stations via enumerable" do
+        count = 0
+        expect { stations.each { |d| count += 1 } }.to change { count }.by(2)
+      end
+
+      it "passes station xml to the station class" do
+        mock_station_class = double(new: nil)
+        first, last = Nokogiri::XML.parse(fake_response).css('station')
+        expect(mock_station_class).to receive(:new).with { |station|
+          station.to_xml == first.to_xml
+        }
+        expect(mock_station_class).to receive(:new).with { |station|
+          station.to_xml == last.to_xml
+        }
+        Stations.new(fake_response, station_class: mock_station_class).each { |s| }
+      end
+
+      it "allows fetching of stations via array#fetch" do
+        expect(stations.fetch(0).station_id).to eq('TAPA')
+      end
+
+      it "allows fetching of stations via array#[]" do
+        expect(stations[0].station_id).to eq('TAPA')
+      end
+
+      it "exposes number of stations via size" do
+        expect(stations.size).to eq(2)
+      end
+
+      it "exposes source xml" do
+        expect(stations.to_xml).to eq(Nokogiri::XML.parse(fake_response).to_xml)
+      end
+
+      STATIONS_XML =<<-RESPONSE
+<?xml version="1.0" encoding="UTF-8"?>
+<wx_station_index>
+  <credit>NOAA's National Weather Service</credit>
+  <credit_URL>http://weather.gov/</credit_URL>
+  <image>
+    <url>http://weather.gov/images/xml_logo.gif</url>
+    <title>NOAA's National Weather Service</title>
+    <link>http://weather.gov</link>
+  </image>
+  <suggested_pickup>08:00 EST</suggested_pickup>
+  <suggested_pickup_period>1140</suggested_pickup_period>
+  <station>
+    <station_id>TAPA</station_id>
+    <state>AG</state>
+    <station_name>Vc Bird Intl Airport Antigua</station_name>
+    <latitude>17.117</latitude>
+    <longitude>-61.783</longitude>
+    <html_url>http://weather.noaa.gov/weather/current/TAPA.html</html_url>
+    <rss_url>http://weather.gov/xml/current_obs/TAPA.rss</rss_url>
+    <xml_url>http://weather.gov/xml/current_obs/TAPA.xml</xml_url>
+  </station>
+
+  <station>
+    <station_id>TKPN</station_id>
+    <state>AG</state>
+    <station_name>Charlestown/Newcast</station_name>
+    <latitude>17.2</latitude>
+    <longitude>-62.583</longitude>
+    <html_url>http://weather.noaa.gov/weather/current/TKPN.html</html_url>
+    <rss_url>http://weather.gov/xml/current_obs/TKPN.rss</rss_url>
+    <xml_url>http://weather.gov/xml/current_obs/TKPN.xml</xml_url>
+  </station>
+</wx_station_index>
+      RESPONSE
+    end
+  end
+end

data/spec/lib/noaa_client/rest_client_factory_spec.rb

@@ -0,0 +1,15 @@
+require 'uri'
+require_relative '../../spec_helper'
+require_relative '../../../lib/noaa_weather_client/rest_client_factory'
+
+module NoaaWeatherClient
+  describe RestClientFactory do
+    it "builds a rest client with the provided url" do
+      mock_provider = double()
+      url = "http://www.google.com"
+      uri = URI(url)
+      expect(mock_provider).to receive(:new).with(uri.host, uri.port)
+      RestClientFactory.build_client provider: mock_provider, url: url
+    end
+  end
+end

data/spec/lib/noaa_client/services/calculate_distance_between_lat_lon_spec.rb

@@ -0,0 +1,16 @@
+require_relative '../../../spec_helper'
+require_relative '../../../../lib/noaa_weather_client/services/calculate_distance_between_lat_lon'
+
+module NoaaWeatherClient
+  module Services
+    describe CalculateDistanceBetweenLatLon do
+      let(:springfield) { [ 37.1962, -93.2861 ] }
+      let(:kansas_city) { [ 39.1000, -94.5800 ] }
+
+      it "calculates the distance between two points" do
+        expect(CalculateDistanceBetweenLatLon.get_distance(*springfield, *kansas_city))
+        .to eq(240.02560432981815)
+      end
+    end
+  end
+end

data/spec/lib/noaa_client/services/current_observations_spec.rb

@@ -0,0 +1,47 @@
+require_relative '../../../spec_helper'
+require_relative '../../../../lib/noaa_weather_client/services/current_observations'
+
+module NoaaWeatherClient
+  module Services
+    describe CurrentObservations do
+      let(:mock_station) { double(xml_url: 'http://w1.weather.gov/xml/current_obs/KSGF.xml') }
+      let(:current_observations) { CurrentObservations.new options }
+
+      it "accepts an options hash" do
+        CurrentObservations.new {}
+      end
+
+      context "#fetch" do
+        let(:options) { { rest_service: double(object_from_response: nil) } }
+
+        it "requires a station" do
+          current_observations.fetch mock_station, options
+          expect { current_observations.fetch }.to raise_error(ArgumentError)
+        end
+
+        it "accepts an options hash" do
+          current_observations.fetch mock_station, options
+        end
+
+        it "passes the stations xml url to the service" do
+          expect(options[:rest_service]).to receive(:object_from_response)
+            .with(anything, mock_station.xml_url, anything)
+          current_observations.fetch mock_station
+        end
+
+        it "passes the get action to the service" do
+          expect(options[:rest_service]).to receive(:object_from_response)
+            .with(:get, anything, anything)
+          current_observations.fetch mock_station
+        end
+
+        it "passes an optional response class to the service" do
+          options[:response_class] = :some_response_class
+          expect(options[:rest_service]).to receive(:object_from_response)
+            .with(anything, anything, hash_including(response_class: options[:response_class]))
+          current_observations.fetch mock_station
+        end
+      end
+    end
+  end
+end

data/spec/lib/noaa_client/services/find_nearest_station_spec.rb

@@ -0,0 +1,36 @@
+require_relative '../../../spec_helper'
+require_relative '../../../../lib/noaa_weather_client/services/find_nearest_station'
+
+module NoaaWeatherClient
+  module Services
+    describe FindNearestStation do
+      let(:location) { double(latitude:39.1000, longitude: -94.5800) } #kansas city
+      let(:washington_dc) { double(station_name: 'Washington D.C.', latitude: 38.8951 , longitude: -77.0367) }
+      let(:detroit) { double(station_name: 'Detroit', latitude: 42.3314 , longitude: -83.0458) }
+      let(:stations) { [ washington_dc, detroit ] }
+
+      it "requires latitude, longitude, and a list of stations" do
+        FindNearestStation.find(location.latitude, location.longitude, stations)
+        expect { FindNearestStation.find }.to raise_error(ArgumentError)
+        expect { FindNearestStation.find location.latitude}.to raise_error(ArgumentError)
+        expect { FindNearestStation.find location.latitude, location.longitude}.to raise_error(ArgumentError)
+      end
+
+      it "accepts an options hash" do
+        FindNearestStation.find(location.latitude, location.longitude, stations, {})
+      end
+
+      it "accepts a callable filter for the stations" do
+        mock_filter = ->(station) { station == washington_dc ? true : false }
+        FindNearestStation.find(location.latitude, location.longitude, stations, { filter: mock_filter })
+      end
+
+      it "returns the closest of the provided stations" do
+        expect(
+          FindNearestStation.find(location.latitude, location.longitude, stations)
+          .station_name
+        ).to eq(detroit.station_name)
+      end
+    end
+  end
+end

data/spec/lib/noaa_client/services/forecast_by_day_spec.rb

@@ -0,0 +1,62 @@
+require_relative '../../../spec_helper'
+require_relative '../../../../lib/noaa_weather_client/services/forecast_by_day'
+
+module NoaaWeatherClient
+  module Services
+    describe ForecastByDay do
+      it "accepts an options hash" do
+        ForecastByDay.new {}
+      end
+
+      context "#fetch" do
+        let(:options) { { soap_service: double(object_from_response: nil) } }
+        let(:forecast) { ForecastByDay.new options }
+        let(:lat) { 37.1962 }
+        let(:lon) { -93.2861 }
+
+        it "requires lat and lon" do
+          forecast.fetch lat, lon
+          expect { forecast.fetch }.to raise_error(ArgumentError)
+        end
+
+        it "accepts an options hash" do
+          forecast.fetch lat, lon, {}
+        end
+
+        it "passes optional arguments to the service" do
+          args = { key: 'value' }
+          expect(options[:soap_service]).to receive(:object_from_response)
+            .with(anything, hash_including(key: 'value'), anything)
+          forecast.fetch lat, lon, args
+        end
+
+        it "passes lat as string to the service" do
+          expect(options[:soap_service]).to receive(:object_from_response)
+            .with(anything, hash_including(latitude: lat.to_s), anything)
+          forecast.fetch lat, lon
+        end
+
+        it "passes lon as string to the service" do
+          expect(options[:soap_service]).to receive(:object_from_response)
+            .with(anything, hash_including(longitude: lon.to_s), anything)
+          forecast.fetch lat, lon
+        end
+
+        it "passes the soap action to the service" do
+          expect(options[:soap_service]).to receive(:object_from_response)
+            .with(:ndf_dgen_by_day, anything, anything)
+          forecast.fetch lat, lon
+        end
+
+        it "passes an optional response class to the service" do
+          options[:response_class] = :some_response_class
+          expect(options[:soap_service]).to receive(:object_from_response)
+            .with(anything, anything, hash_including(response_class: options[:response_class]))
+
+          forecast = ForecastByDay.new options
+          forecast.fetch lat, lon
+        end
+      end
+    end
+  end
+end

data/spec/lib/noaa_client/services/postal_code_to_coordinate_spec.rb

@@ -0,0 +1,41 @@
+require_relative '../../../spec_helper'
+require_relative '../../../../lib/noaa_weather_client/services/postal_code_to_coordinate'
+
+module NoaaWeatherClient
+  module Services
+    describe PostalCodeToCoordinate do
+      it "accepts an options hash" do
+        PostalCodeToCoordinate.new {}
+      end
+
+      context "#resolve" do
+        let(:options) { { rest_service: double(object_from_response: nil) } }
+        let(:zip) { 90210 }
+        let(:zip_lat_lon) { PostalCodeToCoordinate.new options }
+
+        it "accepts an options hash" do
+          zip_lat_lon.resolve options
+        end
+
+        it "passes action to the service" do
+          expect(options[:rest_service]).to receive(:object_from_response)
+          .with(:get, anything, anything)
+          zip_lat_lon.resolve zip
+        end
+
+        it "passes zip as string to the service" do
+          expect(options[:rest_service]).to receive(:object_from_response)
+            .with(anything, /#{zip}/, anything)
+          zip_lat_lon.resolve zip
+        end
+
+        it "passes an optional response class to the service" do
+          options[:response_class] = :some_response_class
+          expect(options[:rest_service]).to receive(:object_from_response)
+            .with(anything, anything, hash_including(response_class: options[:response_class]))
+          zip_lat_lon.resolve zip
+        end
+      end
+    end
+  end
+end

data/spec/lib/noaa_client/services/rest_service_spec.rb

@@ -0,0 +1,45 @@
+require_relative '../../../spec_helper'
+require_relative '../../../../lib/noaa_weather_client/services/rest_service'
+
+module NoaaWeatherClient
+  module Services
+    describe RestService do
+      let(:fake_response) { double(body: 'fake_response_body') }
+      let(:mock_client) { double(request: fake_response) }
+      let(:mock_response_class) { double(new: nil) }
+      let(:implementer) { Class.new { include RestService }.new }
+      let(:args) { [ :get, 'http://www.google.com', { client: mock_client } ] }
+
+      context "#object_from_response" do
+        it "requires an action and url" do
+          implementer.object_from_response :get, 'http://www.google.com', client: mock_client
+          expect { implementer.object_from_response }.to raise_error(ArgumentError)
+        end
+
+        it "accepts an options hash" do
+          implementer.object_from_response :get, 'http://www.google.com', client: mock_client
+        end
+
+        it "builds a request from the args" do
+          expect(implementer).to receive(:build_request_for_action).with(*args)
+          implementer.object_from_response(*args)
+        end
+
+        it "passes the rest response to the response class" do
+          expect(mock_client).to receive(:request).and_return(fake_response)
+          expect(mock_response_class).to receive(:new).with(fake_response.body)
+          action, url, opts = *args
+          implementer.object_from_response(action, url, opts.merge(response_class: mock_response_class))
+        end
+
+        it "returns a new wrapped response body" do
+          expect(mock_response_class).to receive(:new).with(fake_response.body).and_return(mock_response_class)
+          action, url, opts = *args
+          expect(
+            implementer.object_from_response(action, url, opts.merge(response_class: mock_response_class))
+          ).to eq(mock_response_class)
+        end
+      end
+    end
+  end
+end

data/spec/lib/noaa_client/services/soap_service_spec.rb

@@ -0,0 +1,56 @@
+require_relative '../../../spec_helper'
+require_relative '../../../../lib/noaa_weather_client/services/soap_service'
+
+module NoaaWeatherClient
+  module Services
+    describe SoapService do
+      let(:fake_response) { double(body: 'fake_response_body') }
+      let(:mock_client) { double(call: fake_response) }
+      let(:mock_response_class) { double(new: nil) }
+      let(:implementer) { Class.new { include SoapService }.new }
+
+      context "#object_from_response" do
+        it "requires a soap action and message" do
+          implementer.object_from_response :soap_action, :message, client: mock_client
+          expect { implementer.object_from_response }.to raise_error(ArgumentError)
+        end
+
+        it "accepts an options hash" do
+          implementer.object_from_response :soap_action, :message, client: mock_client
+        end
+
+        it "calls the soap client with the soap action" do
+          expect(mock_client).to receive(:call).with(:soap_action, anything)
+          implementer.object_from_response :soap_action, :message, client: mock_client
+        end
+
+        it "calls the soap client with the message" do
+          expect(mock_client).to receive(:call).with(anything, hash_including(message: :message))
+          implementer.object_from_response :soap_action, :message, client: mock_client
+        end
+
+        it "passes the soap response to the response" do
+          expect(mock_client).to receive(:call).and_return(fake_response)
+          expect(mock_response_class).to receive(:new).with(fake_response.body)
+          implementer.object_from_response :soap_action, :message, client: mock_client, response_class: mock_response_class
+        end
+
+        it "returns a new wrapped response body" do
+          expect(mock_response_class).to receive(:new).with(fake_response.body).and_return(mock_response_class)
+          expect(implementer.object_from_response(:soap_action,
+                                                  :message,
+                                                  client: mock_client,
+                                                  response_class: mock_response_class)).to eq(mock_response_class)
+        end
+
+        context "when a Savon:Error occurs" do
+          it "raises a CommunicationError" do
+            allow(mock_client).to receive(:call).and_raise(Savon::Error)
+            expect { implementer.object_from_response :soap_action, :message, client: mock_client }
+              .to raise_error(Errors::CommunicationError)
+          end
+        end
+      end
+    end
+  end
+end