shipcloud 0.6.0 → 0.11.0

data/spec/shipcloud/carrier_spec.rb

@@ -24,7 +24,7 @@ describe Shipcloud::Carrier do
   describe '.all' do
     it 'makes a new Get request using the correct API endpoint' do
       expect(Shipcloud).to receive(:request).
-        with(:get, 'carriers', {}).and_return([])
+        with(:get, "carriers", {}, api_key: nil, affiliate_id: nil).and_return([])
 
       Shipcloud::Carrier.all
     end
@@ -66,12 +66,19 @@ describe Shipcloud::Carrier do
           )
         )
     end
+
+    it "use the affiliate ID provided for the request" do
+      expect(Shipcloud).to receive(:request).
+        with(:get, "carriers", {}, api_key: nil, affiliate_id: "affiliate_id").and_return([])
+
+      Shipcloud::Carrier.all(affiliate_id: "affiliate_id")
+    end
   end
 
-  def stub_carriers_request
-    allow(Shipcloud).to receive(:request)
-      .with(:get, 'carriers', {})
-      .and_return(
+  def stub_carriers_request(affiliate_id: nil)
+    allow(Shipcloud).to receive(:request).
+      with(:get, "carriers", {}, api_key: nil, affiliate_id: affiliate_id).
+      and_return(
         [
           {
             'name' => 'carrier_1',

data/spec/shipcloud/pickup_request_spec.rb

@@ -0,0 +1,136 @@
+require "spec_helper"
+
+describe Shipcloud::PickupRequest do
+  valid_attributes = {
+    carrier: "dpd",
+    pickup_time: {
+      earliest: "2015-09-15T09:00:00+02:00",
+      latest: "2015-09-15T18:00:00+02:00"
+    },
+    shipments: [
+      { id: "abc_123" }
+    ]
+  }
+
+  valid_attributes_with_pickup_address = {
+    carrier: "dpd",
+    pickup_time: {
+      earliest: "2015-09-15T09:00:00+02:00",
+      latest: "2015-09-15T18:00:00+02:00"
+    },
+    pickup_address: {
+      company: "Muster-Company",
+      first_name: "Max",
+      last_name: "Mustermann",
+      street: "Musterstraße",
+      street_no: "42",
+      zip_code: "54321",
+      city: "Musterstadt",
+      country: "DE",
+      phone: "555-555"
+    },
+    shipments: [
+      { id: "abc_123" }
+    ]
+  }
+
+  describe "#initialize" do
+    it "initializes all attributes correctly" do
+      pickup_request = Shipcloud::PickupRequest.new(valid_attributes_with_pickup_address)
+
+      expect(pickup_request.carrier).to eq "dpd"
+      expect(pickup_request.pickup_time[:earliest]).to eq "2015-09-15T09:00:00+02:00"
+      expect(pickup_request.pickup_time[:latest]).to eq "2015-09-15T18:00:00+02:00"
+      expect(pickup_request.pickup_address[:company]).to eq "Muster-Company"
+      expect(pickup_request.pickup_address[:first_name]).to eq "Max"
+      expect(pickup_request.pickup_address[:last_name]).to eq "Mustermann"
+      expect(pickup_request.pickup_address[:street]).to eq "Musterstraße"
+      expect(pickup_request.pickup_address[:street_no]).to eq "42"
+      expect(pickup_request.pickup_address[:zip_code]).to eq "54321"
+      expect(pickup_request.pickup_address[:country]).to eq "DE"
+      expect(pickup_request.pickup_address[:phone]).to eq "555-555"
+      expect(pickup_request.shipments).to eq [{ id: "abc_123" }]
+    end
+  end
+
+  describe ".create" do
+    it "makes a new POST request using the correct API endpoint" do
+      expect(Shipcloud).to receive(:request).
+        with(:post, "pickup_requests", valid_attributes, api_key: nil, affiliate_id: nil).
+        and_return("data" => {})
+
+      Shipcloud::PickupRequest.create(valid_attributes)
+    end
+
+    it "returns pickup request id" do
+      allow(Shipcloud).to receive(:request).
+        and_return(
+          "id" => "123456",
+          "carrier_pickup_number" => "abcdef",
+          "carrier" => "dpd",
+          "pickup_time" => {
+            "earliest" => "2015-09-15T09:00:00+02:00",
+            "latest" => "2015-09-15T18:00:00+02:00"
+          }
+        )
+
+      pickup_request = Shipcloud::PickupRequest.create(valid_attributes)
+
+      expect(pickup_request.id).to eq "123456"
+      expect(pickup_request.carrier_pickup_number).to eq "abcdef"
+    end
+
+    it "returns a pickup_address" do
+      allow(Shipcloud).to receive(:request).
+        and_return(
+          "id" => "123456",
+          "carrier_pickup_number" => "abcdef",
+          "carrier" => "dpd",
+          "pickup_time" => {
+            "earliest" => "2015-09-15T09:00:00+02:00",
+            "latest" => "2015-09-15T18:00:00+02:00"
+          },
+          "pickup_address" => {
+            "id" => "522a7cb1-d6c8-418c-ac26-011127ab5bbe",
+            "company" => "Muster-Company",
+            "first_name" => "Max",
+            "last_name" => "Mustermann",
+            "street" => "Musterstraße",
+            "street_no" => "42",
+            "zip_code" => "54321",
+            "city" => "Musterstadt",
+            "country" => "DE",
+            "phone" => "555-555"
+          }
+        )
+
+      pickup_request = Shipcloud::PickupRequest.create(valid_attributes_with_pickup_address)
+
+      expect(pickup_request.pickup_address).to eq(
+        "id" => "522a7cb1-d6c8-418c-ac26-011127ab5bbe",
+        "company" => "Muster-Company",
+        "first_name" => "Max",
+        "last_name" => "Mustermann",
+        "street" => "Musterstraße",
+        "street_no" => "42",
+        "zip_code" => "54321",
+        "city" => "Musterstadt",
+        "country" => "DE",
+        "phone" => "555-555"
+      )
+    end
+
+    it "use the affiliate ID provided for the request" do
+      expect(Shipcloud).to receive(:request).
+        with(
+          :post,
+          "pickup_requests",
+          valid_attributes,
+          api_key: nil,
+          affiliate_id: "affiliate_id",
+        ).and_return("data" => {})
+
+      Shipcloud::PickupRequest.create(valid_attributes, affiliate_id: "affiliate_id")
+    end
+  end
+end

data/spec/shipcloud/request/base_spec.rb

@@ -3,25 +3,63 @@ require "spec_helper"
 describe Shipcloud::Request::Base do
   context "#perform" do
     it "checks for an api key" do
-      Shipcloud.stub(:api_key).and_return(nil)
+      info = Shipcloud::Request::Info.new(:get, "shipments", nil, {}, "affiliate_id")
 
       expect{
-        Shipcloud::Request::Base.new(nil).perform
+        Shipcloud::Request::Base.new(info).perform
       }.to raise_error Shipcloud::AuthenticationError
     end
 
-    it "performs an https request" do
-      Shipcloud.stub(:api_key).and_return("some key")
-      connection = stub
-      validator = stub
-      Shipcloud::Request::Connection.stub(:new).and_return(connection)
-      Shipcloud::Request::Validator.stub(:new).and_return(validator)
+    it "performs an https request and returns a response hash" do
+      connection = double
+      expect(Shipcloud::Request::Connection).to receive(:new).and_return(connection)
+      expect(connection).to receive(:setup_https)
+      response = double(code: "200", body: { id: 1 }.to_json)
+      expect(connection).to receive(:request).and_return(response)
+      info = Shipcloud::Request::Info.new(:get, "shipments", "api_key", {}, "affiliate_id")
 
-      connection.should_receive(:setup_https)
-      connection.should_receive(:request)
-      validator.should_receive(:validated_data_for)
+      data = Shipcloud::Request::Base.new(info).perform
 
-      Shipcloud::Request::Base.new(nil).perform
+      expect(data).to eq("id" => 1)
+    end
+
+    it "performs an https request and raises an Shipcloud::ClientError if the response "\
+       "has a 400 status code" do
+      connection = double
+      expect(Shipcloud::Request::Connection).to receive(:new).and_return(connection)
+      expect(connection).to receive(:setup_https)
+      response = double(code: "400", body: { id: 1 }.to_json)
+      expect(connection).to receive(:request).and_return(response)
+      info = Shipcloud::Request::Info.new(:get, "shipments", "api_key", {}, "affiliate_id")
+
+      expect { Shipcloud::Request::Base.new(info).perform }.
+        to raise_error(Shipcloud::ClientError)
+    end
+
+    it "performs an https request and raises an Shipcloud::ServerError if the response "\
+       "has a 500 status code" do
+      connection = double
+      expect(Shipcloud::Request::Connection).to receive(:new).and_return(connection)
+      expect(connection).to receive(:setup_https)
+      response = double(code: "500", body: { id: 1 }.to_json)
+      expect(connection).to receive(:request).and_return(response)
+      info = Shipcloud::Request::Info.new(:get, "shipments", "api_key", {}, "affiliate_id")
+
+      expect { Shipcloud::Request::Base.new(info).perform }.
+        to raise_error(Shipcloud::ServerError)
+    end
+
+    it "performs an https request and raises an Shipcloud::ShipcloudError if the body of the "\
+       "response is not in JSON" do
+      connection = double
+      expect(Shipcloud::Request::Connection).to receive(:new).and_return(connection)
+      expect(connection).to receive(:setup_https)
+      response = double(code: "200", body: "no json")
+      expect(connection).to receive(:request).and_return(response)
+      info = Shipcloud::Request::Info.new(:get, "shipments", "api_key", {}, "affiliate_id")
+
+      expect { Shipcloud::Request::Base.new(info).perform }.
+        to raise_error(Shipcloud::ShipcloudError)
     end
   end
-end
+end

data/spec/shipcloud/request/connection_spec.rb

@@ -7,7 +7,7 @@ describe Shipcloud::Request::Connection do
 
       connection.setup_https
 
-      connection.https.should_not be_nil
+      expect(connection.https).to_not be_nil
     end
   end
 
@@ -15,9 +15,9 @@ describe Shipcloud::Request::Connection do
     it "performs the actual request" do
       connection = Shipcloud::Request::Connection.new(nil)
       connection.setup_https
-      connection.stub(:https_request)
+      allow(connection).to receive(:https_request)
 
-      connection.https.should_receive(:request)
+      expect(connection.https).to receive(:request)
 
       connection.request
     end

data/spec/shipcloud/request/info_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe Shipcloud::Request::Info do
+  describe "#url" do
+    it "returns the correct url" do
+      info = Shipcloud::Request::Info.new(:get, "shipments", "api_key", {}, "affiliate_id")
+
+      expect(info.url).to eq "/v1/shipments"
+    end
+  end
+
+  describe "#path_with_params" do
+    it "returns just the path if there aren't any params" do
+      info = Shipcloud::Request::Info.new(:get, "shipments", "api_key", {}, "affiliate_id")
+      path = info.path_with_params(info.url, info.data)
+
+      expect(path).to eq "/v1/shipments"
+    end
+
+    it "returns the path and given params" do
+      info = Shipcloud::Request::Info.new(
+        :get,
+        "shipments",
+        "api_key",
+        { foo: "bar" },
+        "affiliate_id",
+      )
+      path = info.path_with_params(info.url, info.data)
+
+      expect(path).to eq "/v1/shipments?foo=bar"
+    end
+  end
+end

data/spec/shipcloud/shipcloud_error_spec.rb

@@ -0,0 +1,125 @@
+require "spec_helper"
+
+describe Shipcloud::ShipcloudError do
+  describe ".from_response" do
+    context "with a response with status code 400" do
+      it "returns a Shipcloud::InvalidRequestError" do
+        expect(Shipcloud::ShipcloudError.from_response(build_response(status_code: 400))).to be_a(
+          Shipcloud::InvalidRequestError
+        )
+      end
+    end
+
+    context "with a response with status code 422" do
+      it "returns a Shipcloud::InvalidRequestError" do
+        expect(Shipcloud::ShipcloudError.from_response(build_response(status_code: 422))).to be_a(
+          Shipcloud::InvalidRequestError
+        )
+      end
+    end
+
+    context "with a response with status code 401" do
+      it "returns a Shipcloud::AuthenticationError" do
+        expect(Shipcloud::ShipcloudError.from_response(build_response(status_code: 401))).to be_a(
+          Shipcloud::AuthenticationError
+        )
+      end
+    end
+
+    context "with a response with status code 402" do
+      it "returns a Shipcloud::TooManyRequests" do
+        expect(Shipcloud::ShipcloudError.from_response(build_response(status_code: 402))).to be_a(
+          Shipcloud::TooManyRequests
+        )
+      end
+    end
+
+    context "with a response with status code 404" do
+      it "returns a Shipcloud::NotFoundError" do
+        expect(Shipcloud::ShipcloudError.from_response(build_response(status_code: 404))).to be_a(
+          Shipcloud::NotFoundError
+        )
+      end
+    end
+
+    context "with a response with a 4xx status code" do
+      it "returns a Shipcloud::ClientError" do
+        expect(Shipcloud::ShipcloudError.from_response(build_response(status_code: 400))).to be_a(
+          Shipcloud::ClientError
+        )
+      end
+    end
+
+    context "with a response with a 5xx status code" do
+      it "returns a Shipcloud::ClientError" do
+        expect(Shipcloud::ShipcloudError.from_response(build_response(status_code: 500))).to be_a(
+          Shipcloud::ServerError
+        )
+      end
+    end
+
+    context "with a 200 response" do
+      it "returns nil" do
+        expect(Shipcloud::ShipcloudError.from_response(build_response(status_code: 200))).to be_nil
+      end
+    end
+  end
+
+  describe "#message" do
+    context "with an errors node in the response body" do
+      it "returns the errors formated as one string" do
+        errors = ["error 1", "error 2"]
+        response = build_response(body: { errors: errors }.to_json)
+        error = Shipcloud::ShipcloudError.new(response)
+
+        expect(error.message).to eq '["error 1", "error 2"]'
+      end
+    end
+    context "without an errors node in the response body" do
+      it "returns the body of the response" do
+        error = Shipcloud::ShipcloudError.new(build_response(body: "test"))
+
+        expect(error.message).to eq "test"
+      end
+    end
+  end
+
+  describe "#errors" do
+    it "returns the errors node of the response" do
+      errors = ["error 1", "error 2"]
+      response = build_response(body: { errors: errors }.to_json)
+      error = Shipcloud::ShipcloudError.new(response)
+
+      expect(error.errors).to eq errors
+    end
+    context "with a response that has no errors node" do
+      it "returns an empty list" do
+        response = build_response(body: {}.to_json)
+        error = Shipcloud::ShipcloudError.new(response)
+
+        expect(error.errors).to eq []
+      end
+    end
+    context "with a response that has no JSON formated body" do
+      it "returns an empty list" do
+        response = build_response(body: "error")
+        error = Shipcloud::ShipcloudError.new(response)
+
+        expect(error.errors).to eq []
+      end
+    end
+  end
+
+  describe "#response" do
+    it "returns the response" do
+      response = build_response
+      error = Shipcloud::ShipcloudError.new(response)
+
+      expect(error.response).to eq response
+    end
+  end
+
+  def build_response(status_code: 400, body: nil)
+    double(code: status_code.to_s, body: body)
+  end
+end

data/spec/shipcloud/shipment_quote_spec.rb

@@ -52,7 +52,7 @@ describe Shipcloud::ShipmentQuote do
   describe ".create" do
     it "makes a new POST request using the correct API endpoint" do
       expect(Shipcloud).to receive(:request).
-        with(:post, "shipment_quotes", valid_attributes).
+        with(:post, "shipment_quotes", valid_attributes, api_key: nil, affiliate_id: nil).
         and_return("data" => {})
 
       Shipcloud::ShipmentQuote.create(valid_attributes)
@@ -70,5 +70,18 @@ describe Shipcloud::ShipmentQuote do
 
       expect(shipment_quote.price).to eq 42.12
     end
+
+    it "use the affiliate ID provided for the request" do
+      expect(Shipcloud).to receive(:request).
+        with(
+          :post,
+          "shipment_quotes",
+          valid_attributes,
+          api_key: nil,
+          affiliate_id: "affiliate_id",
+        ).and_return("data" => {})
+
+      Shipcloud::ShipmentQuote.create(valid_attributes, affiliate_id: "affiliate_id")
+    end
   end
 end