scalingo 3.3.0 → 3.5.0

data/spec/scalingo/billing/profile_spec.rb

@@ -1,55 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Scalingo::Billing::Profile do
-  describe_method "show" do
-    context "existing" do
-      let(:stub_pattern) { "show-200" }
-
-      it_behaves_like "a singular object response"
-    end
-
-    context "not yet created" do
-      let(:stub_pattern) { "show-404" }
-
-      it_behaves_like "a not found response"
-    end
-  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 "already existing" do
-      let(:stub_pattern) { "create-400" }
-
-      it_behaves_like "a client error"
-    end
-
-    context "unprocessable" do
-      let(:arguments) { meta[:create][:invalid] }
-      let(:stub_pattern) { "create-422" }
-
-      it_behaves_like "an unprocessable request"
-    end
-  end
-
-  describe_method "update" do
-    context "success" do
-      let(:arguments) { [meta[:id], meta[:update][:valid]] }
-      let(:stub_pattern) { "update-200" }
-
-      it_behaves_like "a singular object response"
-    end
-
-    context "unprocessable" do
-      let(:arguments) { [meta[:id], meta[:update][:invalid]] }
-      let(:stub_pattern) { "update-422" }
-
-      it_behaves_like "an unprocessable request"
-    end
-  end
-end

data/spec/scalingo/billing_spec.rb

@@ -1,11 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Scalingo::Billing do
-  subject { described_class.new("url") }
-
-  %w[profile].each do |section|
-    it "handles requests for #{section}" do
-      expect(subject.respond_to?(section)).to be true
-    end
-  end
-end

data/spec/scalingo/client_spec.rb

@@ -1,93 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Scalingo::Client do
-  subject { described_class.new }
-
-  describe "token" do
-    it "wraps the token in a BearerToken" do
-      expect(subject.token).to eq nil
-
-      subject.token = "my-token"
-      expect(subject.token).to be_a(Scalingo::BearerToken)
-      expect(subject.token.value).to eq "my-token"
-
-      subject.token = Scalingo::BearerToken.new("other-token")
-      expect(subject.token).to be_a(Scalingo::BearerToken)
-      expect(subject.token.value).to eq "other-token"
-    end
-
-    it "can query the authentication status" do
-      expect(subject).not_to be_authenticated
-
-      subject.token = "my-token"
-      expect(subject).to be_authenticated
-
-      subject.token = Scalingo::BearerToken.new("other-token")
-      allow(subject.token).to receive(:expired?).and_return(false)
-      expect(subject).to be_authenticated
-
-      allow(subject.token).to receive(:expired?).and_return(true)
-      expect(subject).not_to be_authenticated
-    end
-  end
-
-  describe "authenticate_with" do
-    it "raises without arguments" do
-      expect { subject.authenticate_with }.to raise_error(ArgumentError)
-    end
-
-    it "raises with both more than one authentication type" do
-      expect {
-        subject.authenticate_with(access_token: :a, bearer_token: :b)
-      }.to raise_error(ArgumentError)
-    end
-
-    it "raises if expires_at is supplied for an access_token" do
-      expect {
-        subject.authenticate_with(access_token: :a, expires_at: :b)
-      }.to raise_error(ArgumentError)
-    end
-
-    context "with access token" do
-      it "is successful with valid token" do
-        fake_response = OpenStruct.new(
-          successful?: true,
-          data: {token: "response token"},
-        )
-
-        expect(subject.auth.tokens).to receive(:exchange).and_return(fake_response)
-
-        expect(subject.authenticate_with(access_token: "access token")).to be true
-        expect(subject.token.value).to eq "response token"
-        expect(subject.token.expires_at).to be_within(1.second).of(Time.current + Scalingo.config.exchanged_token_validity)
-      end
-
-      it "fails with invalid token" do
-        fake_response = OpenStruct.new(
-          successful?: false,
-        )
-
-        expect(subject.auth.tokens).to receive(:exchange).and_return(fake_response)
-
-        expect(subject.authenticate_with(access_token: "access token")).to be false
-        expect(subject.token).to be nil
-      end
-    end
-
-    context "with bearer token" do
-      it "only sets the bearer token according to the arguments" do
-        expect(subject.authenticate_with(bearer_token: "my token")).to be true
-        expect(subject.token.value).to eq "my token"
-        expect(subject.token.expires_at).to eq nil
-
-        expect(subject.authenticate_with(bearer_token: Scalingo::BearerToken.new("my token"))).to be true
-        expect(subject.token.value).to eq "my token"
-        expect(subject.token.expires_at).to eq nil
-
-        expect(subject.authenticate_with(bearer_token: "my token", expires_at: Time.now + 1.hour)).to be true
-        expect(subject.token.value).to eq "my token"
-        expect(subject.token.expires_at).not_to eq nil
-      end
-    end
-  end
-end

data/spec/scalingo/configuration_spec.rb

@@ -1,57 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Scalingo::Configuration do
-  subject { described_class.default }
-
-  describe "inheritance" do
-    it "can inherit configuration from a parent" do
-      object = described_class.new({}, subject)
-
-      described_class::ATTRIBUTES.each do |attr|
-        expect(object.public_send(attr)).to eq subject.public_send(attr)
-      end
-    end
-
-    it "can uses local configuration when supplied, the parent other wise" do
-      object = described_class.new({user_agent: "Agent"}, subject)
-
-      (described_class::ATTRIBUTES - [:user_agent]).each do |attr|
-        expect(object.public_send(attr)).to eq subject.public_send(attr)
-      end
-
-      expect(object.user_agent).to eq "Agent"
-    end
-  end
-
-  describe "faraday adapter" do
-    let(:scalingo) { Scalingo::Client.new(config).tap { |s| s.authenticate_with(bearer_token: "some-token") } }
-    let(:client) { Scalingo::API::Client.new("http://example.test", scalingo: scalingo) }
-
-    context "when unspecified" do
-      let(:config) { {} }
-
-      it "uses the default one when unspecificied" do
-        expect(client.authenticated_connection.adapter).to eq Faraday::Adapter::NetHttp
-        expect(client.unauthenticated_connection.adapter).to eq Faraday::Adapter::NetHttp
-      end
-    end
-
-    context "when set to an unkown adapter" do
-      let(:config) { {faraday_adapter: :yo} }
-
-      it "uses the default one when unspecificied" do
-        expect { client.authenticated_connection.adapter }.to raise_error(Faraday::Error)
-        expect { client.unauthenticated_connection.adapter }.to raise_error(Faraday::Error)
-      end
-    end
-
-    context "when set to a valid adapter" do
-      let(:config) { {faraday_adapter: :test} }
-
-      it "uses the default one when unspecificied" do
-        expect(client.authenticated_connection.adapter).to eq Faraday::Adapter::Test
-        expect(client.unauthenticated_connection.adapter).to eq Faraday::Adapter::Test
-      end
-    end
-  end
-end

data/spec/scalingo/core_client_spec.rb

@@ -1,23 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Scalingo::CoreClient do
-  subject { described_class.new }
-
-  describe "#database_region" do
-    it "forwards call to the specified region" do
-      allow(subject).to receive("db_api_osc_secnum_fr1")
-
-      subject.database_region("db_api_osc_secnum_fr1")
-
-      expect(subject).to have_received("db_api_osc_secnum_fr1")
-    end
-
-    it "forwards call to default db_api region" do
-      allow(subject).to receive("db_api_#{subject.config.default_region}")
-
-      subject.database_region
-
-      expect(subject).to have_received("db_api_#{subject.config.default_region}")
-    end
-  end
-end

data/spec/scalingo/regional/addons_spec.rb

@@ -1,169 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Scalingo::Regional::Addons do
-  describe_method "categories" do
-    context "guest" do
-      subject { guest_endpoint }
-
-      let(:expected_count) { 2 }
-      let(:stub_pattern) { "categories-guest" }
-
-      it_behaves_like "a collection response"
-      it_behaves_like "a non-paginated collection"
-    end
-
-    context "logged" do
-      let(:expected_count) { 2 }
-      let(:stub_pattern) { "categories-logged" }
-
-      it_behaves_like "a collection response"
-      it_behaves_like "a non-paginated collection"
-    end
-  end
-
-  describe_method "providers" do
-    context "guest" do
-      subject { guest_endpoint }
-
-      let(:expected_count) { 9 }
-      let(:stub_pattern) { "providers-guest" }
-
-      it_behaves_like "a collection response"
-      it_behaves_like "a non-paginated collection"
-    end
-
-    context "logged" do
-      let(:expected_count) { 11 }
-      let(:stub_pattern) { "providers-logged" }
-
-      it_behaves_like "a collection response"
-      it_behaves_like "a non-paginated collection"
-    end
-  end
-
-  describe_method "provision" do
-    context "success" do
-      let(:arguments) { [meta[:app_id], meta[:provision][:valid]] }
-      let(:stub_pattern) { "provision-201" }
-
-      it_behaves_like "a singular object response", 201
-    end
-
-    context "failure" do
-      let(:arguments) { [meta[:app_id], meta[:provision][:invalid]] }
-      let(:stub_pattern) { "provision-400" }
-
-      it_behaves_like "a client error"
-    end
-  end
-
-  describe_method "for" do
-    context "success" do
-      let(:arguments) { meta[:app_id] }
-      let(:stub_pattern) { "for-200" }
-
-      it_behaves_like "a collection response"
-      it_behaves_like "a non-paginated collection"
-    end
-  end
-
-  describe_method "find" do
-    context "success" do
-      let(:arguments) { [meta[:app_id], meta[:id]] }
-      let(:stub_pattern) { "find-200" }
-
-      it_behaves_like "a singular object response"
-    end
-
-    context "not found" do
-      let(:arguments) { [meta[:app_id], meta[:not_found_id]] }
-      let(:stub_pattern) { "find-404" }
-
-      it_behaves_like "a not found response"
-    end
-  end
-
-  describe_method "sso" do
-    context "success" do
-      let(:arguments) { [meta[:app_id], meta[:id]] }
-      let(:stub_pattern) { "sso-200" }
-
-      it_behaves_like "a singular object response"
-    end
-
-    context "not found" do
-      let(:arguments) { [meta[:app_id], meta[:not_found_id]] }
-      let(:stub_pattern) { "sso-404" }
-
-      it_behaves_like "a not found response"
-    end
-  end
-
-  describe_method "token" do
-    context "success" do
-      let(:arguments) { [meta[:app_id], meta[:id]] }
-      let(:stub_pattern) { "token-200" }
-
-      it_behaves_like "a singular object response"
-    end
-
-    context "not found" do
-      let(:arguments) { [meta[:app_id], meta[:not_found_id]] }
-      let(:stub_pattern) { "token-404" }
-
-      it_behaves_like "a not found response"
-    end
-  end
-
-  describe_method "authenticate!" do
-    context "success" do
-      let(:arguments) { [meta[:app_id], meta[:id]] }
-      let(:stub_pattern) { "token-200" }
-
-      it_behaves_like "a singular object response"
-      it "authenticates" do
-        response
-        expect(scalingo.authenticated_for_database?(meta[:id])).to be true
-      end
-    end
-
-    context "not found" do
-      let(:arguments) { [meta[:app_id], meta[:not_found_id]] }
-      let(:stub_pattern) { "token-404" }
-
-      it_behaves_like "a not found response"
-    end
-  end
-
-  describe_method "update" do
-    context "success" do
-      let(:arguments) { [meta[:app_id], meta[:id], meta[:update][:valid]] }
-      let(:stub_pattern) { "update-200" }
-
-      it_behaves_like "a singular object response"
-    end
-
-    context "failure" do
-      let(:arguments) { [meta[:app_id], meta[:id], meta[:update][:invalid]] }
-      let(:stub_pattern) { "update-404" }
-
-      it_behaves_like "a not found response"
-    end
-  end
-
-  describe_method "destroy" do
-    context "success" do
-      let(:arguments) { [meta[:app_id], meta[:id]] }
-      let(:stub_pattern) { "destroy-204" }
-
-      it_behaves_like "an empty response"
-    end
-
-    context "not found" do
-      let(:arguments) { [meta[:app_id], meta[:not_found_id]] }
-      let(:stub_pattern) { "destroy-404" }
-
-      it_behaves_like "a not found response"
-    end
-  end
-end

data/spec/scalingo/regional/apps_spec.rb

@@ -1,137 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Scalingo::Regional::Apps do
-  describe_method "all" do
-    let(:expected_count) { 2 }
-    let(:stub_pattern) { "all" }
-
-    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 "failure" do
-      let(:arguments) { meta[:create][:invalid] }
-      let(:stub_pattern) { "create-422" }
-
-      it_behaves_like "an unprocessable request"
-    end
-  end
-
-  describe_method "find" do
-    context "success" do
-      let(:arguments) { meta[:id] }
-      let(:stub_pattern) { "find-200" }
-
-      it_behaves_like "a singular object response"
-    end
-
-    context "not found" do
-      let(:arguments) { meta[:not_found_id] }
-      let(:stub_pattern) { "find-404" }
-
-      it_behaves_like "a not found response"
-    end
-  end
-
-  describe_method "update" do
-    context "success" do
-      let(:arguments) { [meta[:id], meta[:update][:valid]] }
-      let(:stub_pattern) { "update-200" }
-
-      it_behaves_like "a singular object response"
-    end
-
-    context "invalid stack" do
-      let(:arguments) { [meta[:id], meta[:update][:invalid]] }
-      let(:stub_pattern) { "update-stack-404" }
-
-      it_behaves_like "a not found response"
-    end
-  end
-
-  describe_method "logs_url" do
-    context "success" do
-      let(:arguments) { meta[:id] }
-      let(:stub_pattern) { "logs_url" }
-
-      it_behaves_like "a singular object response"
-    end
-  end
-
-  describe_method "destroy" do
-    context "success" do
-      let(:arguments) { [meta[:id], meta[:destroy][:valid]] }
-      let(:stub_pattern) { "destroy-204" }
-
-      it_behaves_like "an empty response"
-    end
-
-    context "not found" do
-      let(:arguments) { [meta[:not_found_id], meta[:destroy][:valid]] }
-      let(:stub_pattern) { "destroy-404" }
-
-      it_behaves_like "a not found response"
-    end
-
-    context "unprocessable" do
-      let(:arguments) { [meta[:id], meta[:destroy][:invalid]] }
-      let(:stub_pattern) { "destroy-422" }
-
-      it_behaves_like "an unprocessable request"
-    end
-  end
-
-  describe_method "rename" do
-    context "success" do
-      let(:arguments) { [meta[:id], meta[:rename][:valid]] }
-      let(:stub_pattern) { "rename-200" }
-
-      it_behaves_like "a singular object response"
-    end
-
-    context "not found" do
-      let(:arguments) { [meta[:not_found_id], meta[:rename][:valid]] }
-      let(:stub_pattern) { "rename-404" }
-
-      it_behaves_like "a not found response"
-    end
-
-    context "unprocessable" do
-      let(:arguments) { [meta[:id], meta[:rename][:invalid]] }
-      let(:stub_pattern) { "rename-422" }
-
-      it_behaves_like "an unprocessable request"
-    end
-  end
-
-  describe_method "transfer" do
-    context "success" do
-      let(:arguments) { [meta[:id], meta[:transfer][:valid]] }
-      let(:stub_pattern) { "transfer-200" }
-
-      it_behaves_like "a singular object response"
-    end
-
-    context "not found" do
-      let(:arguments) { [meta[:not_found_id], meta[:transfer][:valid]] }
-      let(:stub_pattern) { "transfer-404" }
-
-      it_behaves_like "a not found response"
-    end
-
-    context "unprocessable" do
-      let(:arguments) { [meta[:id], meta[:transfer][:invalid]] }
-      let(:stub_pattern) { "transfer-422" }
-
-      it_behaves_like "an unprocessable request"
-    end
-  end
-end

data/spec/scalingo/regional/autoscalers_spec.rb

@@ -1,84 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Scalingo::Regional::Autoscalers do
-  describe_method "create" do
-    context "success" do
-      let(:arguments) { [meta[:app_id], meta[:create][:valid]] }
-      let(:stub_pattern) { "create-201" }
-
-      it_behaves_like "a singular object response", 201
-    end
-
-    context "failure" do
-      let(:arguments) { [meta[:app_id], meta[:create][:invalid]] }
-      let(:stub_pattern) { "create-500" }
-
-      it_behaves_like "a server error"
-    end
-  end
-
-  describe_method "for" do
-    context "success" do
-      let(:arguments) { meta[:app_id] }
-      let(:stub_pattern) { "for-200" }
-
-      it_behaves_like "a collection response"
-      it_behaves_like "a non-paginated collection"
-    end
-  end
-
-  describe_method "find" do
-    context "success" do
-      let(:arguments) { [meta[:app_id], meta[:id]] }
-      let(:stub_pattern) { "find-200" }
-
-      it_behaves_like "a singular object response"
-    end
-
-    context "not found" do
-      let(:arguments) { [meta[:app_id], meta[:not_found_id]] }
-      let(:stub_pattern) { "find-404" }
-
-      it_behaves_like "a not found response"
-    end
-  end
-
-  describe_method "update" do
-    context "success" do
-      let(:arguments) { [meta[:app_id], meta[:id], meta[:update][:valid]] }
-      let(:stub_pattern) { "update-200" }
-
-      it_behaves_like "a singular object response"
-    end
-
-    context "failure" do
-      let(:arguments) { [meta[:app_id], meta[:id], meta[:update][:invalid]] }
-      let(:stub_pattern) { "update-500" }
-
-      it_behaves_like "a server error"
-    end
-
-    context "not found" do
-      let(:arguments) { [meta[:app_id], meta[:not_found_id], meta[:update][:valid]] }
-      let(:stub_pattern) { "update-404" }
-
-      it_behaves_like "a not found response"
-    end
-  end
-
-  describe_method "destroy" do
-    context "success" do
-      let(:arguments) { [meta[:app_id], meta[:id]] }
-      let(:stub_pattern) { "destroy-204" }
-
-      it_behaves_like "an empty response"
-    end
-
-    context "not found" do
-      let(:arguments) { [meta[:app_id], meta[:not_found_id]] }
-      let(:stub_pattern) { "destroy-404" }
-
-      it_behaves_like "a not found response"
-    end
-  end
-end

data/spec/scalingo/regional/collaborators_spec.rb

@@ -1,69 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Scalingo::Regional::Collaborators do
-  describe_method "for" do
-    context "success" do
-      let(:arguments) { meta[:app_id] }
-      let(:stub_pattern) { "for-200" }
-
-      it_behaves_like "a collection response"
-      it_behaves_like "a non-paginated collection"
-    end
-  end
-
-  describe_method "invite" do
-    context "success" do
-      let(:arguments) { [meta[:app_id], meta[:invite][:valid]] }
-      let(:stub_pattern) { "invite-201" }
-
-      it_behaves_like "a singular object response", 201
-    end
-
-    context "failure" do
-      let(:arguments) { [meta[:app_id], meta[:invite][:invalid]] }
-      let(:stub_pattern) { "invite-422" }
-
-      it_behaves_like "an unprocessable request"
-    end
-  end
-
-  describe_method "accept" do
-    context "success" do
-      let(:arguments) { meta[:accept][:valid] }
-      let(:stub_pattern) { "accept-200" }
-      let(:expected_keys) { %i[app] }
-
-      it_behaves_like "a singular object response"
-    end
-
-    context "already collaborating" do
-      let(:arguments) { meta[:accept][:valid] }
-      let(:stub_pattern) { "accept-400" }
-
-      it_behaves_like "a client error"
-    end
-
-    context "not found" do
-      let(:arguments) { meta[:accept][:invalid] }
-      let(:stub_pattern) { "accept-404" }
-
-      it_behaves_like "a not found response"
-    end
-  end
-
-  describe_method "destroy" do
-    context "success" do
-      let(:arguments) { [meta[:app_id], meta[:id]] }
-      let(:stub_pattern) { "destroy-204" }
-
-      it_behaves_like "an empty response"
-    end
-
-    context "not found" do
-      let(:arguments) { [meta[:app_id], meta[:not_found_id]] }
-      let(:stub_pattern) { "destroy-404" }
-
-      it_behaves_like "a not found response"
-    end
-  end
-end