google_distance_matrix 0.4.0 → 0.5.0

data/spec/lib/google_distance_matrix/log_subscriber_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module GoogleDistanceMatrix
@@ -9,22 +11,23 @@ module GoogleDistanceMatrix
         @logged = []
       end
 
-      def info(msg, tag)
+      def info(msg, _tag)
         @logged << msg
       end
 
       def error(msg)
-        fail msg
+        raise msg
       end
     end
 
     # Little helper to clean up examples
     def notify(instrumentation)
-      ActiveSupport::Notifications.instrument "client_request_matrix_data.google_distance_matrix", instrumentation do
+      ActiveSupport::Notifications.instrument(
+        'client_request_matrix_data.google_distance_matrix', instrumentation
+      ) do
       end
     end
 
-
     let(:mock_logger) { MockLogger.new }
     let(:config) { Configuration.new }
 
@@ -32,57 +35,23 @@ module GoogleDistanceMatrix
     before do
       @old_subscribers = LogSubscriber.subscribers.dup
       LogSubscriber.subscribers.clear
-      LogSubscriber.attach_to "google_distance_matrix", LogSubscriber.new(logger: mock_logger, config: config)
+      LogSubscriber.attach_to 'google_distance_matrix',
+                              LogSubscriber.new(logger: mock_logger, config: config)
     end
 
     after do
       @old_subscribers.each do |subscriber|
-        LogSubscriber.attach_to "google_distance_matrix", subscriber
+        LogSubscriber.attach_to 'google_distance_matrix', subscriber
       end
     end
 
-
-    it "logs the url and elements" do
+    it 'logs the url and elements' do
       url = 'https://example.com'
-      instrumentation = {url: url, elements: 0}
+      instrumentation = { filtered_url: url, elements: 0 }
 
       expect { notify instrumentation }.to change(mock_logger.logged, :length).from(0).to 1
 
-      expect(mock_logger.logged.first).to include "(elements: 0) GET https://example.com"
-    end
-
-    describe "filtering of logged url" do
-      it "filters nothing if config has no keys to be filtered" do
-        config.filter_parameters_in_logged_url.clear
-
-        instrumentation = {url: 'https://example.com/?foo=bar&sensitive=secret'}
-        notify instrumentation
-
-        expect(mock_logger.logged.first).to include "https://example.com/?foo=bar&sensitive=secret"
-      end
-
-      it "filters sensitive GET param if config has it in list of params to filter" do
-        config.filter_parameters_in_logged_url << 'sensitive'
-
-        instrumentation = {url: 'https://example.com/?foo=bar&sensitive=secret'}
-        notify instrumentation
-
-        expect(mock_logger.logged.first).to include "https://example.com/?foo=bar&sensitive=[FILTERED]"
-      end
-
-      it "filters key and signature as defaul from configuration" do
-        instrumentation = {url: 'https://example.com/?key=bar&signature=secret&other=foo'}
-        notify instrumentation
-
-        expect(mock_logger.logged.first).to include "https://example.com/?key=[FILTERED]&signature=[FILTERED]&other=foo"
-      end
-
-      it "filters all appearances of a param" do
-        instrumentation = {url: 'https://example.com/?key=bar&key=secret&other=foo'}
-        notify instrumentation
-
-        expect(mock_logger.logged.first).to include "https://example.com/?key=[FILTERED]&key=[FILTERED]&other=foo"
-      end
+      expect(mock_logger.logged.first).to include '(elements: 0) GET https://example.com'
     end
   end
 end

data/spec/lib/google_distance_matrix/logger_spec.rb

@@ -1,36 +1,39 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 describe GoogleDistanceMatrix::Logger do
-  context "without a logger backend" do
+  context 'without a logger backend' do
     subject { described_class.new }
 
     described_class::LEVELS.each do |level|
       it "logging #{level} does not fail" do
-        subject.public_send level, "log msg"
+        subject.public_send level, 'log msg'
       end
     end
   end
 
-  context "with a logger backend" do
+  context 'with a logger backend' do
     let(:backend) { double }
 
     subject { described_class.new backend }
 
     described_class::LEVELS.each do |level|
       describe level do
-        it "sends log message to the backend" do
-          expect(backend).to receive(level).with("[google_distance_matrix] log msg")
-          subject.public_send level, "log msg"
+        it 'sends log message to the backend' do
+          expect(backend).to receive(level).with('[google_distance_matrix] log msg')
+          subject.public_send level, 'log msg'
         end
 
-        it "supports sending in a tag" do
-          expect(backend).to receive(level).with("[google_distance_matrix] [client] log msg")
-          subject.public_send level, "log msg", tag: :client
+        it 'supports sending in a tag' do
+          expect(backend).to receive(level).with('[google_distance_matrix] [client] log msg')
+          subject.public_send level, 'log msg', tag: :client
         end
 
-        it "supports sending in multiple tags" do
-          expect(backend).to receive(level).with("[google_distance_matrix] [client] [request] log msg")
-          subject.public_send level, "log msg", tag: ['client', 'request']
+        it 'supports sending in multiple tags' do
+          expect(backend).to receive(level)
+            .with('[google_distance_matrix] [client] [request] log msg')
+          subject.public_send level, 'log msg', tag: %w[client request]
         end
       end
     end

data/spec/lib/google_distance_matrix/matrix_spec.rb

@@ -1,14 +1,16 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 describe GoogleDistanceMatrix::Matrix do
-  let(:origin_1) { GoogleDistanceMatrix::Place.new address: "Karl Johans gate, Oslo" }
-  let(:origin_2) { GoogleDistanceMatrix::Place.new address: "Askerveien 1, Asker" }
+  let(:origin_1) { GoogleDistanceMatrix::Place.new address: 'Karl Johans gate, Oslo' }
+  let(:origin_2) { GoogleDistanceMatrix::Place.new address: 'Askerveien 1, Asker' }
 
-  let(:destination_1) { GoogleDistanceMatrix::Place.new address: "Drammensveien 1, Oslo" }
-  let(:destination_2) { GoogleDistanceMatrix::Place.new address: "Skjellestadhagen, Heggedal" }
+  let(:destination_1) { GoogleDistanceMatrix::Place.new address: 'Drammensveien 1, Oslo' }
+  let(:destination_2) { GoogleDistanceMatrix::Place.new address: 'Skjellestadhagen, Heggedal' }
 
   let(:url_builder) { GoogleDistanceMatrix::UrlBuilder.new subject }
-  let(:url) { url_builder.url }
+  let(:url) { url_builder.sensitive_url }
 
   subject do
     described_class.new(
@@ -17,24 +19,24 @@ describe GoogleDistanceMatrix::Matrix do
     )
   end
 
-  describe "#initialize" do
-    it "takes a list of origins" do
+  describe '#initialize' do
+    it 'takes a list of origins' do
       matrix = described_class.new origins: [origin_1, origin_2]
       expect(matrix.origins).to include origin_1, origin_2
     end
 
-    it "takes a list of destinations" do
+    it 'takes a list of destinations' do
       matrix = described_class.new destinations: [destination_1, destination_2]
       expect(matrix.destinations).to include destination_1, destination_2
     end
 
-    it "has a default configuration" do
+    it 'has a default configuration' do
       expect(subject.configuration).to be_present
     end
   end
 
-  describe "#configuration" do
-    it "is by default set from default_configuration" do
+  describe '#configuration' do
+    it 'is by default set from default_configuration' do
       config = double
       allow(config).to receive(:dup).and_return config
       expect(GoogleDistanceMatrix).to receive(:default_configuration).and_return config
@@ -43,47 +45,58 @@ describe GoogleDistanceMatrix::Matrix do
     end
 
     it "has it's own configuration" do
-      expect {
+      expect do
         subject.configure { |c| c.mode = !GoogleDistanceMatrix.default_configuration.mode }
-      }.to_not change(GoogleDistanceMatrix.default_configuration, :mode)
+      end.to_not change(GoogleDistanceMatrix.default_configuration, :mode)
     end
 
-    it "has a configurable configuration :-)" do
-      expect {
+    it 'has a configurable configuration :-)' do
+      expect do
         subject.configure { |c| c.mode = !GoogleDistanceMatrix.default_configuration.mode }
-      }.to change(subject.configuration, :mode).to !GoogleDistanceMatrix.default_configuration.mode
+      end.to change(
+        subject.configuration, :mode
+      ).to !GoogleDistanceMatrix.default_configuration.mode
     end
   end
 
   %w[origins destinations].each do |attr|
-    let(:place) { GoogleDistanceMatrix::Place.new address: "My street" }
+    let(:place) { GoogleDistanceMatrix::Place.new address: 'My street' }
+    let(:place_2) { GoogleDistanceMatrix::Place.new address: 'Some other street' }
 
     describe "##{attr}" do
-      it "can receive places" do
+      it 'can receive places' do
         subject.public_send(attr) << place
         expect(subject.public_send(attr)).to include place
       end
 
-      it "does not same place twice" do
-        expect {
+      it 'does not same place twice' do
+        expect do
           2.times { subject.public_send(attr) << place }
-        }.to change(subject.public_send(attr), :length).by 1
+        end.to change(subject.public_send(attr), :length).by 1
+      end
+
+      it 'updates the url when adding places' do
+        subject.public_send(attr) << place
+        expect(subject.sensitive_url).to include CGI.escape('My street')
+
+        subject.public_send(attr) << place_2
+        expect(subject.sensitive_url).to include CGI.escape('Some other street')
       end
     end
   end
 
   %w[
-      route_for
-      route_for!
-      routes_for
-      routes_for!
-      shortest_route_by_duration_to
-      shortest_route_by_duration_to!
-      shortest_route_by_distance_to
-      shortest_route_by_distance_to!
-      shortest_route_by_duration_in_traffic_to
-      shortest_route_by_duration_in_traffic_to!
-    ].each do |method|
+    route_for
+    route_for!
+    routes_for
+    routes_for!
+    shortest_route_by_duration_to
+    shortest_route_by_duration_to!
+    shortest_route_by_distance_to
+    shortest_route_by_distance_to!
+    shortest_route_by_duration_in_traffic_to
+    shortest_route_by_duration_in_traffic_to!
+  ].each do |method|
     it "delegates #{method} to routes_finder" do
       finder = double
       result = double
@@ -95,8 +108,8 @@ describe GoogleDistanceMatrix::Matrix do
     end
   end
 
-  describe "making API requests", :request_recordings do
-    it "loads correctly API response data in to route objects" do
+  describe 'making API requests', :request_recordings do
+    it 'loads correctly API response data in to route objects' do
       stub_request(:get, url).to_return body: recorded_request_for(:success)
       expect(subject.data[0][0].distance_text).to eq '2.0 km'
       expect(subject.data[0][0].distance_in_meters).to eq 2032
@@ -104,7 +117,7 @@ describe GoogleDistanceMatrix::Matrix do
       expect(subject.data[0][0].duration_in_seconds).to eq 367
     end
 
-    it "loads correctly API response data in to route objects when it includes in traffic data" do
+    it 'loads correctly API response data in to route objects when it includes in traffic data' do
       stub_request(:get, url).to_return body: recorded_request_for(:success_with_in_traffic)
       expect(subject.data[0][0].distance_text).to eq '1.8 km'
       expect(subject.data[0][0].distance_in_meters).to eq 1752
@@ -114,8 +127,8 @@ describe GoogleDistanceMatrix::Matrix do
       expect(subject.data[0][0].duration_in_traffic_in_seconds).to eq 405
     end
 
-    context "no cache" do
-      it "makes multiple requests to same url" do
+    context 'no cache' do
+      it 'makes multiple requests to same url' do
         stub = stub_request(:get, url).to_return body: recorded_request_for(:success)
         subject.data
         subject.reset!
@@ -125,15 +138,16 @@ describe GoogleDistanceMatrix::Matrix do
       end
     end
 
-    context "with cache" do
+    context 'with cache' do
       before do
         subject.configure do |config|
           config.cache = ActiveSupport::Cache.lookup_store :memory_store
         end
       end
 
-      it "makes one requests to same url" do
+      it 'makes one requests to same url' do
         stub = stub_request(:get, url).to_return body: recorded_request_for(:success)
+
         subject.data
         subject.reset!
         subject.data
@@ -141,7 +155,22 @@ describe GoogleDistanceMatrix::Matrix do
         expect(stub).to have_been_requested.once
       end
 
-      it "clears the cache key on reload" do
+      it 'makes one request when filtered params to same url' do
+        was = GoogleDistanceMatrix.default_configuration.filter_parameters_in_logged_url
+        GoogleDistanceMatrix.default_configuration.filter_parameters_in_logged_url = ['origins']
+
+        stub = stub_request(:get, url).to_return body: recorded_request_for(:success)
+
+        subject.data
+        subject.reset!
+        subject.data
+
+        expect(stub).to have_been_requested.once
+
+        GoogleDistanceMatrix.default_configuration.filter_parameters_in_logged_url = was
+      end
+
+      it 'clears the cache key on reload' do
         stub = stub_request(:get, url).to_return body: recorded_request_for(:success)
         subject.data
         subject.reload
@@ -152,30 +181,32 @@ describe GoogleDistanceMatrix::Matrix do
     end
   end
 
-  describe "#data", :request_recordings do
-    context "success" do
-      let!(:api_request_stub) { stub_request(:get, url).to_return body: recorded_request_for(:success) }
+  describe '#data', :request_recordings do
+    context 'success' do
+      let!(:api_request_stub) do
+        stub_request(:get, url).to_return body: recorded_request_for(:success)
+      end
 
       it "loads from Google's API" do
         subject.data
         expect(api_request_stub).to have_been_requested
       end
 
-      it "does not load twice" do
+      it 'does not load twice' do
         2.times { subject.data }
         expect(api_request_stub).to have_been_requested
       end
 
-      it "contains one row" do
+      it 'contains one row' do
         expect(subject.data.length).to eq 2
       end
 
-      it "contains two columns each row" do
+      it 'contains two columns each row' do
         expect(subject.data[0].length).to eq 2
         expect(subject.data[1].length).to eq 2
       end
 
-      it "assigns correct origin on routes in the data" do
+      it 'assigns correct origin on routes in the data' do
         expect(subject.data[0][0].origin).to eq origin_1
         expect(subject.data[0][1].origin).to eq origin_1
 
@@ -183,7 +214,7 @@ describe GoogleDistanceMatrix::Matrix do
         expect(subject.data[1][1].origin).to eq origin_2
       end
 
-      it "assigns correct destination on routes in the data" do
+      it 'assigns correct destination on routes in the data' do
         expect(subject.data[0][0].destination).to eq destination_1
         expect(subject.data[0][1].destination).to eq destination_2
 
@@ -192,36 +223,38 @@ describe GoogleDistanceMatrix::Matrix do
       end
     end
 
-    context "some elements is not OK" do
-      let!(:api_request_stub) { stub_request(:get, url).to_return body: recorded_request_for(:zero_results) }
+    context 'some elements is not OK' do
+      let!(:api_request_stub) do
+        stub_request(:get, url).to_return body: recorded_request_for(:zero_results)
+      end
 
       it "loads from Google's API" do
         subject.data
         expect(api_request_stub).to have_been_requested
       end
 
-      it "adds loaded route with errors correctly" do
+      it 'adds loaded route with errors correctly' do
         route = subject.data[0][1]
 
-        expect(route.status).to eq "zero_results"
+        expect(route.status).to eq 'zero_results'
         expect(route.duration_in_seconds).to be_nil
       end
     end
   end
 
-  describe "#reload" do
+  describe '#reload' do
     before do
       allow(subject).to receive(:load_matrix) { ['loaded'] }
       subject.data.clear
     end
 
     it "reloads matrix' data from the API" do
-      expect {
+      expect do
         subject.reload
-      }.to change(subject, :data).from([]).to ['loaded']
+      end.to change(subject, :data).from([]).to ['loaded']
     end
 
-    it "is chainable" do
+    it 'is chainable' do
       expect(subject.reload.data).to eq ['loaded']
     end
   end

data/spec/lib/google_distance_matrix/place_spec.rb

@@ -1,23 +1,25 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 describe GoogleDistanceMatrix::Place do
-  let(:address) { "Karl Johans gate, Oslo" }
+  let(:address) { 'Karl Johans gate, Oslo' }
   let(:lat) { 1.4 }
   let(:lng) { 2.2 }
 
-  describe "#initialize" do
-    it "builds with an address" do
+  describe '#initialize' do
+    it 'builds with an address' do
       place = described_class.new(address: address)
       expect(place.address).to eq address
     end
 
-    it "builds with lat lng" do
+    it 'builds with lat lng' do
       place = described_class.new(lat: lat, lng: lng)
       expect(place.lat).to eq lat
       expect(place.lng).to eq lng
     end
 
-    it "builds with an object responding to lat and lng" do
+    it 'builds with an object responding to lat and lng' do
       point = double lat: 1, lng: 2
       place = described_class.new(point)
 
@@ -25,22 +27,21 @@ describe GoogleDistanceMatrix::Place do
       expect(place.lng).to eq point.lng
     end
 
-
-    it "keeps a record of the object it built itself from" do
+    it 'keeps a record of the object it built itself from' do
       point = double lat: 1, lng: 2
       place = described_class.new(point)
 
       expect(place.extracted_attributes_from).to eq point
     end
-    it "builds with an object responding to address" do
+    it 'builds with an object responding to address' do
       object = double address: address
       place = described_class.new(object)
 
       expect(place.address).to eq object.address
     end
 
-    it "builds with an object responding to lat, lng and address" do
-      object = double lat: 1, lng:2, address: address
+    it 'builds with an object responding to lat, lng and address' do
+      object = double lat: 1, lng: 2, address: address
       place = described_class.new(object)
 
       expect(place.lat).to eq object.lat
@@ -48,46 +49,50 @@ describe GoogleDistanceMatrix::Place do
       expect(place.address).to be_nil
     end
 
-    it "fails if no valid attributes given" do
+    it 'fails if no valid attributes given' do
       expect { described_class.new }.to raise_error ArgumentError
       expect { described_class.new(lat: lat) }.to raise_error ArgumentError
       expect { described_class.new(lng: lng) }.to raise_error ArgumentError
     end
 
-    it "fails if both address, lat ang lng is given" do
-      expect { described_class.new(address: address, lat: lat, lng: lng) }.to raise_error ArgumentError
+    it 'fails if both address, lat ang lng is given' do
+      expect { described_class.new(address: address, lat: lat, lng: lng) }
+        .to raise_error ArgumentError
     end
   end
 
-  describe "#to_param" do
-    context "with address" do
+  describe '#to_param' do
+    context 'with address' do
       subject { described_class.new address: address }
 
       it { expect(subject.to_param).to eq address }
     end
 
-    context "with lat lng" do
+    context 'with lat lng' do
       subject { described_class.new lng: lng, lat: lat }
 
       it { expect(subject.to_param).to eq "#{lat},#{lng}" }
     end
   end
 
-  describe "#equal?" do
-    it "is considered equal when address is the same" do
+  describe '#equal?' do
+    it 'is considered equal when address is the same' do
       expect(described_class.new(address: address)).to be_eql described_class.new(address: address)
     end
 
-    it "is considered equal when lat and lng are the same" do
-      expect(described_class.new(lat: lat, lng: lng)).to be_eql described_class.new(lat: lat, lng: lng)
+    it 'is considered equal when lat and lng are the same' do
+      expect(described_class.new(lat: lat, lng: lng))
+        .to be_eql described_class.new(lat: lat, lng: lng)
     end
 
-    it "is not considered equal when address differs" do
-      expect(described_class.new(address: address)).to_not be_eql described_class.new(address: address + ", Norway")
+    it 'is not considered equal when address differs' do
+      expect(described_class.new(address: address))
+        .to_not be_eql described_class.new(address: address + ', Norway')
     end
 
-    it "is not considered equal when lat or lng differs" do
-      expect(described_class.new(lat: lat, lng: lng)).to_not be_eql described_class.new(lat: lat, lng: lng + 1)
+    it 'is not considered equal when lat or lng differs' do
+      expect(described_class.new(lat: lat, lng: lng))
+        .to_not be_eql described_class.new(lat: lat, lng: lng + 1)
     end
   end
 end