scalingo 3.4.0 → 3.6.0

data/spec/scalingo/api/client_spec.rb

@@ -1,256 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Scalingo::API::Client do
-  let(:url) { "http://localhost" }
-
-  subject { described_class.new(url, scalingo: scalingo) }
-
-  describe "initialize" do
-    let(:config) { {default_region: :test} }
-
-    describe "with only url" do
-      subject { described_class.new(:url) }
-
-      it "stores the url" do
-        expect(subject.url).to eq(:url)
-      end
-
-      it "uses itself as token holder" do
-        expect(subject.token_holder).to eq(subject)
-      end
-
-      it "configuration is the global one" do
-        expect(Scalingo::Configuration).to receive(:new).with({}, Scalingo.config).and_return(:config).once
-
-        expect(subject.config).to eq(:config)
-      end
-    end
-
-    describe "with scalingo client supplied" do
-      subject { described_class.new(:url, scalingo: scalingo) }
-
-      it "uses the scalingo client as token holder" do
-        expect(subject.token_holder).to eq(scalingo)
-      end
-
-      it "configuration is herited from the scalingo client" do
-        expect(Scalingo::Configuration).to receive(:new).with({}, scalingo.config).once
-
-        subject
-      end
-    end
-
-    describe "with config supplied" do
-      subject { described_class.new(:url, config: config) }
-
-      it "configuration is herited from the global one" do
-        expect(Scalingo::Configuration).to receive(:new).with(config, Scalingo.config).and_return(:config).once
-
-        expect(subject.config).to eq(:config)
-      end
-    end
-
-    describe "with both supplied" do
-      subject { described_class.new(:url, scalingo: scalingo, config: config) }
-
-      it "configuration is herited from the scalingo one" do
-        expect(Scalingo::Configuration).to receive(:new).with(config, scalingo.config).once
-
-        subject
-      end
-    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(:url, scalingo: scalingo)
-
-      # 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 and accept if nothing else is configured" do
-      expect(subject.headers).to eq("Accept" => "application/json", "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("Accept" => "application/json", "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("Accept" => "application/json", "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.token_holder.token.value}"
-      end
-    end
-  end
-
-  describe "database_connection" do
-    let(:database_id) { "db-id-1234" }
-
-    context "without bearer token" do
-      let(:scalingo) { scalingo_guest }
-
-      it "raises" do
-        expect {
-          subject.database_connection(database_id)
-        }.to raise_error(Scalingo::Error::Unauthenticated)
-      end
-    end
-
-    context "with bearer token" do
-      it "has an authentication header set with a bearer scheme" do
-        scalingo.authenticate_database_with_bearer_token(
-          database_id,
-          "1234",
-          expires_at: Time.now + 1.hour,
-          raise_on_expired_token: false,
-        )
-        expect(subject.database_connection(database_id).headers["Authorization"]).to eq "Bearer #{subject.token_holder.database_tokens[database_id].value}"
-      end
-    end
-
-    context "with wrong bearer token" do
-      it "raises" do
-        database_id_2 = "db-id-5678"
-        scalingo.authenticate_database_with_bearer_token(
-          database_id_2,
-          "1234",
-          expires_at: Time.now + 1.hour,
-          raise_on_expired_token: false,
-        )
-        expect {
-          subject.database_connection(database_id)
-        }.to raise_error(Scalingo::Error::Unauthenticated)
-      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

@@ -1,45 +0,0 @@
-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 without keys" do
-      mock = proc { 1 }
-
-      expect(Scalingo::API::Response).to receive(:unpack).with(client, keys: [], &mock).and_return(:d).once
-      expect(subject.send(:unpack, &mock)).to eq :d
-    end
-
-    it "forwards unpack to Response with a single key" do
-      mock = proc { 1 }
-
-      expect(Scalingo::API::Response).to receive(:unpack).with(client, keys: [:a], &mock).and_return(:d).once
-      expect(subject.send(:unpack, :a, &mock)).to eq :d
-    end
-
-    it "forwards unpack to Response with many keys" do
-      mock = proc { 1 }
-
-      expect(Scalingo::API::Response).to receive(:unpack).with(client, keys: [:a, :b], &mock).and_return(:d).once
-      expect(subject.send(:unpack, :a, :b, &mock)).to eq :d
-    end
-  end
-end

data/spec/scalingo/api/response_spec.rb

@@ -1,301 +0,0 @@
-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, key: :key) { response }
-
-        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, key: :key) { response }
-
-        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, key: :key) { response }
-
-        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, key: :root) { response }
-
-        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, key: :root) { response }
-
-        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, key: :other) { response }
-
-        expect(object.data).to eq nil
-        expect(object.full_body).to eq body
-        expect(object.meta).to eq nil
-      end
-
-      it "with valid keys" do
-        object = described_class.unpack(client, keys: [:root, :key]) { response }
-
-        expect(object.data).to eq(:value)
-        expect(object.full_body).to eq body
-        expect(object.meta).to eq nil
-      end
-
-      it "with invalid keys" do
-        object = described_class.unpack(client, keys: [:root, :other]) { response }
-
-        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, key: :root) { response }
-
-        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

data/spec/scalingo/auth/keys_spec.rb

@@ -1,58 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Scalingo::Auth::Keys do
-  describe_method "all" do
-    let(:stub_pattern) { "all-200" }
-
-    it_behaves_like "a collection response"
-    it_behaves_like "a non-paginated collection"
-  end
-
-  describe_method "create" do
-    context "success" do
-      let(:arguments) { meta[:create][:valid] }
-      let(:stub_pattern) { "create-201" }
-
-      it_behaves_like "a singular object response", 201
-    end
-
-    context "unprocessable" do
-      let(:arguments) { meta[:create][:invalid] }
-      let(:stub_pattern) { "create-422" }
-
-      it_behaves_like "an unprocessable request"
-    end
-  end
-
-  describe_method "show" do
-    context "success" do
-      let(:arguments) { meta[:id] }
-      let(:stub_pattern) { "show-200" }
-
-      it_behaves_like "a singular object response"
-    end
-
-    context "not found" do
-      let(:arguments) { meta[:not_found_id] }
-      let(:stub_pattern) { "show-404" }
-
-      it_behaves_like "a not found response"
-    end
-  end
-
-  describe_method "destroy" do
-    context "success" do
-      let(:arguments) { meta[:id] }
-      let(:stub_pattern) { "destroy-204" }
-
-      it_behaves_like "an empty response"
-    end
-
-    context "not found" do
-      let(:arguments) { meta[:not_found_id] }
-      let(:stub_pattern) { "destroy-404" }
-
-      it_behaves_like "a not found response"
-    end
-  end
-end