scalingo 3.0.0.beta.1 → 3.0.0.beta.2

data/samples/billing/profile/show-200.json

@@ -0,0 +1,41 @@
+{
+  "path": "/profile",
+  "method": "get",
+  "request": {
+    "headers": {
+      "Authorization": "Bearer the-bearer-token"
+    }
+  },
+  "response": {
+    "status": 200,
+    "headers": {
+      "Date": "Fri, 12 Jun 2020 15:46:10 GMT",
+      "Etag": "W/\"d1a1d2eed6a6fc5fb399b497a4572e89\"",
+      "Content-Type": "application/json; charset=utf-8",
+      "Transfer-Encoding": "chunked",
+      "Connection": "keep-alive",
+      "Cache-Control": "max-age=0, private, must-revalidate"
+    },
+    "json_body": {
+      "profile": {
+        "id": "882d7733-923b-40dc-88e6-f1324e48c42a",
+        "name": "Billing",
+        "email": null,
+        "address_line1": "Somewhere",
+        "address_line2": null,
+        "address_city": "Somecity",
+        "balance": 0,
+        "address_zip": "12345",
+        "address_state": null,
+        "address_country": "FR",
+        "vat_number": null,
+        "company": null,
+        "payment_method": "sepa",
+        "created_at": "2020-05-29T13:01:46.217Z",
+        "updated_at": "2020-06-12T15:45:43.535Z",
+        "credit": 0,
+        "stripe_payment_method": null
+      }
+    }
+  }
+}

data/samples/billing/profile/show-404.json

@@ -0,0 +1,22 @@
+{
+  "path": "/profile",
+  "method": "get",
+  "request": {
+    "headers": {
+      "Authorization": "Bearer the-bearer-token"
+    }
+  },
+  "response": {
+    "status": 404,
+    "headers": {
+      "Date": "Fri, 12 Jun 2020 15:46:10 GMT",
+      "Content-Type": "application/json; charset=utf-8",
+      "Transfer-Encoding": "chunked",
+      "Connection": "keep-alive",
+      "Cache-Control": "no-cache"
+    },
+    "json_body": {
+      "error": "no billing profile"
+    }
+  }
+}

data/samples/billing/profile/update-200.json

@@ -0,0 +1,47 @@
+{
+  "path": "/profiles/882d7733-923b-40dc-88e6-f1324e48c42a",
+  "method": "put",
+  "request": {
+    "headers": {
+      "Authorization": "Bearer the-bearer-token",
+      "Content-Type": "application/json"
+    },
+    "json_body": {
+      "profile": {
+        "address_city": "New Somecity"
+      }
+    }
+  },
+  "response": {
+    "status": 200,
+    "headers": {
+      "Date": "Fri, 12 Jun 2020 15:46:11 GMT",
+      "Etag": "W/\"885ba0ce422a076feb961e3bed89db0c\"",
+      "Content-Type": "application/json; charset=utf-8",
+      "Transfer-Encoding": "chunked",
+      "Connection": "keep-alive",
+      "Cache-Control": "max-age=0, private, must-revalidate"
+    },
+    "json_body": {
+      "profile": {
+        "id": "882d7733-923b-40dc-88e6-f1324e48c42a",
+        "name": "Billing",
+        "email": null,
+        "address_line1": "Somewhere",
+        "address_line2": null,
+        "address_city": "New Somecity",
+        "balance": 0,
+        "address_zip": "12345",
+        "address_state": null,
+        "address_country": "FR",
+        "vat_number": null,
+        "company": null,
+        "payment_method": "sepa",
+        "created_at": "2020-05-29T13:01:46.217Z",
+        "updated_at": "2020-06-12T15:46:11.559Z",
+        "credit": 0,
+        "stripe_payment_method": null
+      }
+    }
+  }
+}

data/samples/billing/profile/update-422.json

@@ -0,0 +1,32 @@
+{
+  "path": "/profiles/882d7733-923b-40dc-88e6-f1324e48c42a",
+  "method": "put",
+  "request": {
+    "headers": {
+      "Authorization": "Bearer the-bearer-token",
+      "Content-Type": "application/json"
+    },
+    "json_body": {
+      "profile": {
+        "address_country": "not a country"
+      }
+    }
+  },
+  "response": {
+    "status": 422,
+    "headers": {
+      "Date": "Fri, 12 Jun 2020 15:46:11 GMT",
+      "Content-Type": "application/json; charset=utf-8",
+      "Transfer-Encoding": "chunked",
+      "Connection": "keep-alive",
+      "Cache-Control": "no-cache"
+    },
+    "json_body": {
+      "errors": {
+        "address_country": [
+          "is not a valid country"
+        ]
+      }
+    }
+  }
+}

data/scalingo.gemspec

@@ -35,14 +35,12 @@ Gem::Specification.new do |s|
   s.test_files = Dir["spec/**/*_spec.rb"]
 
   s.add_dependency "activesupport", [">= 5", "< 7"]
-  s.add_dependency "activemodel", [">= 5", "< 7"]
-  s.add_dependency "dry-configurable", "~> 0.11"
   s.add_dependency "faraday", "~> 1.0.1"
   s.add_dependency "faraday_middleware", "~> 1.0.0"
   s.add_dependency "multi_json", ">= 1.0.3", "~> 1.0"
 
   s.add_development_dependency "bundler", "~> 2.0"
-  s.add_development_dependency "rake", "~> 10.0"
+  s.add_development_dependency "rake", "~> 13.0"
   s.add_development_dependency "rspec", "~> 3.0"
   s.add_development_dependency "rubocop", "~> 0.83.0"
   s.add_development_dependency "standard", "~> 0.4.2"

data/spec/scalingo/api/client_spec.rb

@@ -0,0 +1,168 @@
+require "spec_helper"
+
+RSpec.describe Scalingo::API::Client do
+  let(:url) { "http://localhost" }
+
+  subject { described_class.new(scalingo, url) }
+
+  describe "initialize" do
+    it "stores the scalingo client and the url" do
+      instance = described_class.new(:scalingo, :url)
+
+      expect(instance.scalingo).to eq(:scalingo)
+      expect(instance.url).to eq(:url)
+    end
+  end
+
+  describe "self.register_handler(s)!" do
+    it "is called for each key/value pair" do
+      expect(described_class).to receive(:register_handler!).with(:a, :b).once
+      expect(described_class).to receive(:register_handler!).with(:c, :d).once
+
+      described_class.register_handlers!(a: :b, c: :d)
+    end
+
+    it "defines a lazy-loaded memoized getter, returning an instance of the class supplied" do
+      mock = double
+
+      described_class.register_handler!(:handler, mock)
+      instance = described_class.new(:scalingo, :url)
+
+      # Only 1 instanciation should be done, no matter how many calls are done below
+      expect(mock).to receive(:new).with(instance).and_return("1st").once
+
+      # Not yet loaded...
+      expect(instance.instance_variable_get(:"@handler")).to eq(nil)
+      instance.handler
+
+      # Memoized...
+      expect(instance.instance_variable_get(:"@handler")).not_to eq(nil)
+
+      # More calls won't try to perform more instanciations
+      instance.handler
+      instance.handler
+    end
+  end
+
+  describe "headers" do
+    before do
+      expect(scalingo.config).to receive(:user_agent).and_return(user_agent).once
+    end
+
+    let(:user_agent) { "user agent" }
+    let(:extra_hash) { {"X-Other" => "other"} }
+    let(:extra_block) {
+      proc { {"X-Another" => "another"} }
+    }
+
+    it "only returns the user agent if nothing else is configured" do
+      expect(subject.headers).to eq("User-Agent" => user_agent)
+    end
+
+    it "allows additional headers to be globally configured" do
+      expect(scalingo.config).to receive(:additional_headers).and_return(extra_hash)
+
+      expect(subject.headers).to eq("User-Agent" => user_agent, "X-Other" => "other")
+    end
+
+    it "additional headers can be a block" do
+      expect(scalingo.config).to receive(:additional_headers).and_return(extra_block)
+
+      expect(subject.headers).to eq("User-Agent" => user_agent, "X-Another" => "another")
+    end
+  end
+
+  describe "connection_options" do
+    it "returns the url and headers" do
+      expect(subject).to receive(:url).and_return("url").once
+      expect(subject).to receive(:headers).and_return("headers").once
+
+      expect(subject.connection_options).to eq(url: "url", headers: "headers")
+    end
+  end
+
+  describe "unauthenticated_connection" do
+    it "returns a memoized object" do
+      expect(Faraday).to receive(:new).with(subject.connection_options).and_return("faraday").once
+
+      expect(subject.unauthenticated_connection).to eq "faraday"
+
+      subject.unauthenticated_connection
+      subject.unauthenticated_connection
+    end
+
+    it "has no authentication header set" do
+      expect(subject.unauthenticated_connection.headers.key?("Authorization")).not_to be true
+    end
+  end
+
+  describe "authenticated_connection" do
+    context "without bearer token" do
+      let(:scalingo) { scalingo_guest }
+
+      it "raises if configured to" do
+        expect(scalingo.config).to receive(:raise_on_missing_authentication).and_return(true).once
+
+        expect {
+          subject.authenticated_connection
+        }.to raise_error(Scalingo::Error::Unauthenticated)
+      end
+
+      it "returns an unauthenticated connection if configured to not raise" do
+        expect(scalingo.config).to receive(:raise_on_missing_authentication).and_return(false).once
+
+        expect(subject).to receive(:unauthenticated_connection).and_return(:object).once
+        expect(subject.authenticated_connection).to eq(:object)
+      end
+    end
+
+    context "with bearer token" do
+      it "has an authentication header set with a bearer scheme" do
+        expect(subject.connection.headers["Authorization"]).to eq "Bearer #{subject.scalingo.token.value}"
+      end
+    end
+  end
+
+  describe "connection" do
+    context "logged" do
+      context "no fallback to guest" do
+        it "calls and return the authenticated_connection" do
+          expect(subject).to receive(:authenticated_connection).and_return(:conn)
+          expect(subject.connection).to eq(:conn)
+        end
+      end
+
+      context "with fallback to guest" do
+        it "calls and return the authenticated_connection" do
+          expect(subject).to receive(:authenticated_connection).and_return(:conn)
+          expect(subject.connection(fallback_to_guest: true)).to eq(:conn)
+        end
+      end
+    end
+
+    context "not logged" do
+      let(:scalingo) { scalingo_guest }
+
+      context "no fallback to guest" do
+        it "raises when set to raise" do
+          expect(scalingo.config).to receive(:raise_on_missing_authentication).and_return(true).once
+
+          expect { subject.connection }.to raise_error(Scalingo::Error::Unauthenticated)
+        end
+
+        it "calls and return the unauthenticated_connection when set not to raise" do
+          expect(scalingo.config).to receive(:raise_on_missing_authentication).and_return(false).once
+          expect(subject).to receive(:unauthenticated_connection).and_return(:conn)
+          expect(subject.connection(fallback_to_guest: true)).to eq(:conn)
+        end
+      end
+
+      context "with fallback to guest" do
+        it "calls and return the unauthenticated_connection" do
+          expect(subject).to receive(:unauthenticated_connection).and_return(:conn)
+          expect(subject.connection(fallback_to_guest: true)).to eq(:conn)
+        end
+      end
+    end
+  end
+end

data/spec/scalingo/api/endpoint_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+RSpec.describe Scalingo::API::Endpoint do
+  let(:client) { double }
+
+  subject { described_class.new(client) }
+
+  describe "initialize" do
+    it "stores the client" do
+      instance = described_class.new(:client)
+
+      expect(instance.client).to eq(:client)
+    end
+  end
+
+  describe "connection" do
+    it "delegates the connection to the client" do
+      expect(client).to receive(:connection).and_return(:value).once
+      expect(subject.connection).to eq :value
+    end
+  end
+
+  describe "unpack" do
+    it "forwards unpack to Response" do
+      expect(Scalingo::API::Response).to receive(:unpack).with(client, :a, :b, :c).and_return(:d).once
+
+      expect(subject.send(:unpack, :a, :b, :c)).to eq :d
+    end
+  end
+end

data/spec/scalingo/api/response_spec.rb

@@ -0,0 +1,285 @@
+require "spec_helper"
+
+RSpec.describe Scalingo::API::Response do
+  let(:client) { regional }
+  let(:status) { 200 }
+  let(:headers) { {} }
+  let(:data) { "" }
+  let(:full_body) { "" }
+  let(:meta_object) { nil }
+
+  subject {
+    described_class.new(
+      client: client,
+      status: status,
+      headers: headers,
+      data: data,
+      full_body: full_body,
+      meta: meta_object,
+    )
+  }
+
+  describe "self.unpack" do
+    let(:body) { "" }
+    let(:success) { true }
+
+    let(:response) {
+      OpenStruct.new(
+        body: body,
+        status: status,
+        headers: headers,
+        success?: success,
+      )
+    }
+
+    it "passes the client supplied" do
+      object = described_class.unpack(:some_client, response)
+
+      expect(object.client).to eq :some_client
+    end
+
+    it "passes the response status" do
+      object = described_class.unpack(:client, response)
+
+      expect(object.status).to eq status
+    end
+
+    it "passes the response headers" do
+      object = described_class.unpack(:client, response)
+
+      expect(object.headers).to eq headers
+    end
+
+    context "with an empty body" do
+      let(:body) { "" }
+
+      it "without key" do
+        object = described_class.unpack(client, response)
+
+        expect(object.data).to eq ""
+        expect(object.full_body).to eq ""
+        expect(object.meta).to eq nil
+      end
+
+      it "ignores key if supplied" do
+        object = described_class.unpack(client, response, key: :key)
+
+        expect(object.data).to eq ""
+        expect(object.full_body).to eq ""
+        expect(object.meta).to eq nil
+      end
+    end
+
+    context "with a nil body" do
+      let(:body) { nil }
+
+      it "without key" do
+        object = described_class.unpack(client, response)
+
+        expect(object.data).to eq nil
+        expect(object.full_body).to eq nil
+        expect(object.meta).to eq nil
+      end
+
+      it "ignores key if supplied" do
+        object = described_class.unpack(client, response, key: :key)
+
+        expect(object.data).to eq nil
+        expect(object.full_body).to eq nil
+        expect(object.meta).to eq nil
+      end
+    end
+
+    context "with a string body" do
+      let(:body) { "this is a string body, probably due to an error" }
+
+      it "without key" do
+        object = described_class.unpack(client, response)
+
+        expect(object.data).to eq body
+        expect(object.full_body).to eq body
+        expect(object.meta).to eq nil
+      end
+
+      it "ignores key if supplied" do
+        object = described_class.unpack(client, response, key: :key)
+
+        expect(object.data).to eq body
+        expect(object.full_body).to eq body
+        expect(object.meta).to eq nil
+      end
+    end
+
+    context "with an json (array) body" do
+      let(:body) {
+        [{key: :value}]
+      }
+
+      it "without key" do
+        object = described_class.unpack(client, response)
+
+        expect(object.data).to eq body
+        expect(object.full_body).to eq body
+        expect(object.meta).to eq nil
+      end
+
+      it "ignores key if supplied" do
+        object = described_class.unpack(client, response, key: :root)
+
+        expect(object.data).to eq body
+        expect(object.full_body).to eq body
+        expect(object.meta).to eq nil
+      end
+    end
+
+    context "with a json (hash) body" do
+      let(:body) {
+        {root: {key: :value}}
+      }
+
+      it "without key" do
+        object = described_class.unpack(client, response)
+
+        expect(object.data).to eq body
+        expect(object.full_body).to eq body
+        expect(object.meta).to eq nil
+      end
+
+      it "with valid key" do
+        object = described_class.unpack(client, response, key: :root)
+
+        expect(object.data).to eq({key: :value})
+        expect(object.full_body).to eq body
+        expect(object.meta).to eq nil
+      end
+
+      it "with invalid key" do
+        object = described_class.unpack(client, response, key: :other)
+
+        expect(object.data).to eq nil
+        expect(object.full_body).to eq body
+        expect(object.meta).to eq nil
+      end
+
+      context "with meta" do
+        let(:body) {
+          {root: {key: :value}, meta: {meta1: :value}}
+        }
+
+        it "extracts the meta object" do
+          object = described_class.unpack(client, response)
+
+          expect(object.meta).to eq({meta1: :value})
+        end
+      end
+    end
+
+    context "with an error response" do
+      let(:success) { false }
+      let(:body) { {root: {key: :value}} }
+
+      it "does not dig in the response hash, even with a valid key" do
+        object = described_class.unpack(client, response, key: :root)
+
+        expect(object.data).to eq body
+        expect(object.full_body).to eq body
+        expect(object.meta).to eq nil
+      end
+    end
+  end
+
+  describe "successful?" do
+    context "is true when 2XX" do
+      let(:status) { 200 }
+      it { expect(subject.successful?).to be true }
+    end
+
+    context "is false when 3XX" do
+      let(:status) { 300 }
+      it { expect(subject.successful?).to be false }
+    end
+
+    context "is false when 4XX" do
+      let(:status) { 400 }
+      it { expect(subject.successful?).to be false }
+    end
+
+    context "is false when 5XX" do
+      let(:status) { 500 }
+      it { expect(subject.successful?).to be false }
+    end
+  end
+
+  describe "paginated?" do
+    context "with pagination metadata" do
+      let(:meta_object) {
+        {pagination: {page: 1}}
+      }
+
+      it { expect(subject.paginated?).to be true }
+    end
+
+    context "without pagination metadata" do
+      let(:meta_object) {
+        {messages: []}
+      }
+
+      it { expect(subject.paginated?).to be false }
+    end
+  end
+
+  describe "operation" do
+    context "with an operation url" do
+      before do
+        load_meta!(api: :regional, folder: :operations)
+        register_stubs!("find-200", api: :regional, folder: :operations)
+      end
+
+      let(:url) {
+        path = "/apps/#{meta[:app_id]}/operations/#{meta[:id]}"
+        File.join(Scalingo::ENDPOINTS[:regional], path)
+      }
+
+      let(:headers) {
+        {location: url}
+      }
+
+      it { expect(subject.operation?).to be true }
+      it { expect(subject.operation_url).to eq url }
+
+      it "can request the operation" do
+        response = subject.operation
+
+        expect(response).to be_successful
+        expect(response.data[:id]).to be_present
+        expect(response.data[:status]).to be_present
+        expect(response.data[:type]).to be_present
+      end
+
+      it "delegates the operation to the given client" do
+        mock = double
+
+        expect(subject.client).to receive(:operations).and_return(mock)
+        expect(mock).to receive(:get).with(url).and_return(:response)
+
+        expect(subject.operation).to eq :response
+      end
+
+      context "when the client doesn't know about operations" do
+        let(:client) { auth }
+
+        it "fails silently" do
+          expect(subject.operation).to eq nil
+        end
+      end
+    end
+
+    context "without an operation url" do
+      let(:meta_object) { {} }
+
+      it { expect(subject.operation?).to be false }
+      it { expect(subject.operation_url).to eq nil }
+      it { expect(subject.operation).to eq nil }
+    end
+  end
+end