google_distance_matrix 0.0.1

data/lib/google_distance_matrix/url_builder.rb

@@ -0,0 +1,63 @@
+module GoogleDistanceMatrix
+  class UrlBuilder
+    BASE_URL = "maps.googleapis.com/maps/api/distancematrix/json"
+    DELIMITER = CGI.escape("|")
+    MAX_URL_SIZE = 2048
+
+    attr_reader :matrix
+    delegate :configuration, to: :matrix
+
+    def initialize(matrix)
+      @matrix = matrix
+
+      fail InvalidMatrix.new matrix if matrix.invalid?
+    end
+
+    def url
+      @url ||= build_url
+    end
+
+
+    private
+
+    def build_url
+      url = [protocol, BASE_URL, "?", get_params_string].join
+
+      if sign_url?
+        url = GoogleBusinessApiUrlSigner.add_signature(url, configuration.google_business_api_private_key)
+      end
+
+      if url.length > MAX_URL_SIZE
+        fail MatrixUrlTooLong.new url, MAX_URL_SIZE
+      end
+
+      url
+    end
+
+    def sign_url?
+      configuration.google_business_api_client_id.present? and
+      configuration.google_business_api_private_key.present?
+    end
+
+    def get_params_string
+      params.to_a.map { |key_value| key_value.join("=") }.join("&")
+    end
+
+    def params
+      places_to_param_config = {lat_lng_scale: configuration.lat_lng_scale}
+
+      configuration.to_param.merge(
+        origins: matrix.origins.map { |o| escape o.to_param(places_to_param_config) }.join(DELIMITER),
+        destinations: matrix.destinations.map { |d| escape d.to_param(places_to_param_config) }.join(DELIMITER),
+      )
+    end
+
+    def protocol
+      configuration.protocol + "://"
+    end
+
+    def escape(string)
+      CGI.escape string
+    end
+  end
+end

data/lib/google_distance_matrix/version.rb

@@ -0,0 +1,3 @@
+module GoogleDistanceMatrix
+  VERSION = "0.0.1"
+end

data/spec/lib/google_distance_matrix/client_spec.rb

@@ -0,0 +1,67 @@
+require "spec_helper"
+
+describe GoogleDistanceMatrix::Client, :request_recordings do
+  let(:origin_1) { GoogleDistanceMatrix::Place.new address: "Karl Johans gate, Oslo" }
+  let(:destination_1) { GoogleDistanceMatrix::Place.new address: "Drammensveien 1, Oslo" }
+  let(:matrix) { GoogleDistanceMatrix::Matrix.new(origins: [origin_1], destinations: [destination_1]) }
+
+  let(:url_builder) { GoogleDistanceMatrix::UrlBuilder.new matrix }
+  let(:url) { url_builder.url }
+
+  subject { GoogleDistanceMatrix::Client.new }
+
+  describe "success" do
+    before { stub_request(:get, url).to_return body: recorded_request_for(:success) }
+
+    it "makes the request" do
+      expect(subject.get(url_builder.url).body).to eq recorded_request_for(:success).read
+    end
+  end
+
+  describe "client errors" do
+    describe "server issues 4xx client error" do
+      it "wraps the error http response" do
+        stub_request(:get, url).to_return status: [400, "Client error"]
+        expect { subject.get(url_builder.url) }.to raise_error GoogleDistanceMatrix::ClientError
+      end
+
+      it "wraps uri too long error" do
+        stub_request(:get, url).to_return status: [414, "Client error"]
+        expect { subject.get(url_builder.url) }.to raise_error GoogleDistanceMatrix::MatrixUrlTooLong
+      end
+    end
+
+    described_class::CLIENT_ERRORS.each do |error|
+      it "wraps '#{error}' client error" do
+        stub_request(:get, url).to_return body: JSON.generate({status: error})
+        expect { subject.get(url_builder.url) }.to raise_error GoogleDistanceMatrix::ClientError
+      end
+    end
+  end
+
+  describe "request errors" do
+    describe "server error" do
+      before { stub_request(:get, url).to_return status: [500, "Internal Server Error"] }
+
+      it "wraps the error http response" do
+        expect { subject.get(url_builder.url) }.to raise_error GoogleDistanceMatrix::RequestError
+      end
+    end
+
+    describe "timeout" do
+      before { stub_request(:get, url).to_timeout }
+
+      it "wraps the error from Net::HTTP" do
+        expect { subject.get(url_builder.url).body }.to raise_error GoogleDistanceMatrix::RequestError
+      end
+    end
+
+    describe "server error" do
+      before { stub_request(:get, url).to_return status: [999, "Unknown"] }
+
+      it "wraps the error http response" do
+        expect { subject.get(url_builder.url) }.to raise_error GoogleDistanceMatrix::RequestError
+      end
+    end
+  end
+end

data/spec/lib/google_distance_matrix/configuration_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+describe GoogleDistanceMatrix::Configuration do
+  subject { described_class.new }
+
+  describe "Validations" do
+    it { should ensure_inclusion_of(:sensor).in_array([true, false]) }
+
+    it { should ensure_inclusion_of(:mode).in_array(["driving", "walking", "bicycling"]) }
+    it { should allow_value(nil).for(:mode) }
+
+    it { should ensure_inclusion_of(:avoid).in_array(["tolls", "highways"]) }
+    it { should allow_value(nil).for(:avoid) }
+
+    it { should ensure_inclusion_of(:units).in_array(["metric", "imperial"]) }
+    it { should allow_value(nil).for(:units) }
+
+    it { should ensure_inclusion_of(:protocol).in_array(["http", "https"]) }
+  end
+
+
+  describe "defaults" do
+    its(:sensor) { should be_false }
+    its(:mode) { should eq "driving" }
+    its(:avoid) { should be_nil }
+    its(:units) { should eq "metric" }
+    its(:lat_lng_scale) { should eq 5 }
+    its(:protocol) { should eq "http" }
+
+    its(:google_business_api_client_id) { should be_nil }
+    its(:google_business_api_private_key) { should be_nil }
+
+    its(:logger) { should be_nil }
+  end
+
+
+  describe "#to_param" do
+    described_class::ATTRIBUTES.each do |attr|
+      it "includes #{attr}" do
+        subject[attr] = "foo"
+        expect(subject.to_param[attr]).to eq subject.public_send(attr)
+      end
+
+      it "does not include #{attr} when it is blank" do
+        subject[attr] = nil
+        expect(subject.to_param.with_indifferent_access).to_not have_key attr
+      end
+    end
+
+    described_class::API_DEFAULTS.each_pair do |attr, default_value|
+      it "does not include #{attr} when it equals what is default for API" do
+        subject[attr] = default_value
+
+        expect(subject.to_param.with_indifferent_access).to_not have_key attr
+      end
+    end
+
+    it "includes client if google_business_api_client_id has been set" do
+      subject.google_business_api_client_id = "123"
+      expect(subject.to_param['client']).to eq "123"
+    end
+  end
+end

data/spec/lib/google_distance_matrix/logger_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe GoogleDistanceMatrix::Logger 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"
+      end
+    end
+  end
+
+  context "with a logger backend" do
+    let(:backend) { mock }
+
+    subject { described_class.new backend }
+
+    described_class::LEVELS.each do |level|
+      describe level do
+        it "sends log message to the backend" do
+          backend.should_receive(level).with("[google_distance_matrix] log msg")
+          subject.public_send level, "log msg"
+        end
+
+        it "supports sending in a tag" do
+          backend.should_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
+          backend.should_receive(level).with("[google_distance_matrix] [client] [request] log msg")
+          subject.public_send level, "log msg", tag: ['client', 'request']
+        end
+      end
+    end
+  end
+end

data/spec/lib/google_distance_matrix/matrix_spec.rb

@@ -0,0 +1,169 @@
+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(: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 }
+
+  subject do
+    described_class.new(
+      origins: [origin_1, origin_2],
+      destinations: [destination_1, destination_2]
+    )
+  end
+
+  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
+      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
+      expect(subject.configuration).to be_present
+    end
+  end
+
+  describe "#configuration" do
+    it "is by default set from default_configuration" do
+      config = mock
+      config.stub(:dup).and_return config
+      GoogleDistanceMatrix.should_receive(:default_configuration).and_return config
+
+      expect(described_class.new.configuration).to eq config
+    end
+
+    it "has it's own configuration" do
+      expect {
+        subject.configure { |c| c.sensor = !GoogleDistanceMatrix.default_configuration.sensor }
+      }.to_not change(GoogleDistanceMatrix.default_configuration, :sensor)
+    end
+
+    it "has a configurable configuration :-)" do
+      expect {
+        subject.configure { |c| c.sensor = !GoogleDistanceMatrix.default_configuration.sensor }
+      }.to change(subject.configuration, :sensor).to !GoogleDistanceMatrix.default_configuration.sensor
+    end
+  end
+
+  %w[origins destinations].each do |attr|
+    let(:place) { GoogleDistanceMatrix::Place.new address: "My street" }
+
+    describe "##{attr}" 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 {
+          2.times { subject.public_send(attr) << place }
+        }.to change(subject.public_send(attr), :length).by 1
+      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!
+    ].each do |method|
+    it "delegates #{method} to routes_finder" do
+      finder = mock
+      result = mock
+
+      subject.stub(:routes_finder).and_return finder
+
+      finder.should_receive(method).and_return result
+      expect(subject.public_send(method)).to eq result
+    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) }
+
+      it "loads from Google's API" do
+        subject.data
+        api_request_stub.should have_been_requested
+      end
+
+      it "does not load twice" do
+        2.times { subject.data }
+        api_request_stub.should have_been_requested
+      end
+
+      it "contains one row" do
+        expect(subject.data.length).to eq 2
+      end
+
+      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
+        expect(subject.data[0][0].origin).to eq origin_1
+        expect(subject.data[0][1].origin).to eq origin_1
+
+        expect(subject.data[1][0].origin).to eq origin_2
+        expect(subject.data[1][1].origin).to eq origin_2
+      end
+
+      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
+
+        expect(subject.data[1][0].destination).to eq destination_1
+        expect(subject.data[1][1].destination).to eq destination_2
+      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) }
+
+      it "loads from Google's API" do
+        subject.data
+        api_request_stub.should have_been_requested
+      end
+
+      it "as loaded route with errors correctly" do
+        route = subject.data[0][1]
+
+        expect(route.status).to eq "zero_results"
+        expect(route.duration_in_seconds).to be_nil
+      end
+    end
+  end
+
+  describe "#reload" do
+    before do
+      subject.stub(:load_matrix).and_return { ['loaded'] }
+      subject.data.clear
+    end
+
+    it "reloads matrix' data from the API" do
+      expect {
+        subject.reload
+      }.to change(subject, :data).from([]).to ['loaded']
+    end
+
+    it "is chainable" do
+      expect(subject.reload.data).to eq ['loaded']
+    end
+  end
+end

data/spec/lib/google_distance_matrix/place_spec.rb

@@ -0,0 +1,93 @@
+require "spec_helper"
+
+describe GoogleDistanceMatrix::Place do
+  let(:address) { "Karl Johans gate, Oslo" }
+  let(:lat) { 1.4 }
+  let(:lng) { 2.2 }
+
+  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
+      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
+      point = mock lat: 1, lng: 2
+      place = described_class.new(point)
+
+      expect(place.lat).to eq point.lat
+      expect(place.lng).to eq point.lng
+    end
+
+
+    it "keeps a record of the object it built itself from" do
+      point = mock 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
+      object = mock 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 = mock lat: 1, lng:2, address: address
+      place = described_class.new(object)
+
+      expect(place.lat).to eq object.lat
+      expect(place.lng).to eq object.lng
+      expect(place.address).to be_nil
+    end
+
+    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
+    end
+  end
+
+  describe "#to_param" do
+    context "with address" do
+      subject { described_class.new address: address }
+
+      its(:to_param) { should eq address }
+    end
+
+    context "with lat lng" do
+      subject { described_class.new lng: lng, lat: lat }
+
+      its(:to_param) { should eq "#{lat},#{lng}" }
+    end
+  end
+
+  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)
+    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")
+    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)
+    end
+  end
+end