scalingo 3.4.0 → 3.6.0

data/spec/scalingo/auth/scm_integrations_spec.rb

@@ -1,58 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Scalingo::Auth::ScmIntegrations 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 "failure" 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

data/spec/scalingo/auth/tokens_spec.rb

@@ -1,74 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Scalingo::Auth::Tokens do
-  describe_method "exchange" do
-    subject { auth_guest.tokens }
-
-    context "with a valid token" do
-      let(:arguments) { meta[:exchange][:valid] }
-      let(:stub_pattern) { "exchange-200" }
-
-      it "should be successful" do
-        expect(response).to be_successful
-        expect(response.data[:token]).to be_present
-      end
-    end
-
-    context "with an invalid token" do
-      let(:arguments) { meta[:exchange][:invalid] }
-      let(:stub_pattern) { "exchange-401" }
-
-      it "should be rejected with an valid token" do
-        expect(response.status).to eq 401
-      end
-    end
-  end
-
-  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
-  end
-
-  describe_method "renew" do
-    context "success" do
-      let(:arguments) { meta[:id] }
-      let(:stub_pattern) { "renew-200" }
-
-      it_behaves_like "a singular object response"
-    end
-
-    context "not found" do
-      let(:arguments) { meta[:not_found_id] }
-      let(:stub_pattern) { "renew-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

data/spec/scalingo/auth/two_factor_auth_spec.rb

@@ -1,69 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Scalingo::Auth::TwoFactorAuth do
-  describe_method "status" do
-    let(:stub_pattern) { "status" }
-
-    it_behaves_like "a singular object response"
-  end
-
-  describe_method "initiate" do
-    context "success" do
-      let(:arguments) { Scalingo::Auth::TwoFactorAuth::DEFAULT_PROVIDER }
-      let(:stub_pattern) { "initiate-success" }
-
-      it_behaves_like "a singular object response", 201
-    end
-
-    context "wrong provider" do
-      let(:arguments) { meta[:initiate][:invalid] }
-      let(:stub_pattern) { "initiate-wrong-provider" }
-
-      it_behaves_like "a client error"
-    end
-
-    context "already enabled" do
-      let(:stub_pattern) { "initiate-already-enabled" }
-
-      it_behaves_like "a client error"
-    end
-  end
-
-  describe_method "validate" do
-    context "success" do
-      let(:arguments) { meta[:validate][:valid] }
-      let(:stub_pattern) { "validate-success" }
-      let(:expected_keys) { %i[codes user] }
-
-      it_behaves_like "a singular object response", 201
-    end
-
-    context "wrong provider" do
-      let(:arguments) { meta[:validate][:invalid] }
-      let(:stub_pattern) { "validate-wrong" }
-
-      it_behaves_like "a client error"
-    end
-
-    context "already enabled" do
-      let(:arguments) { meta[:validate][:invalid] }
-      let(:stub_pattern) { "validate-not-initiated" }
-
-      it_behaves_like "a client error"
-    end
-  end
-
-  describe_method "disable" do
-    context "success" do
-      let(:stub_pattern) { "disable-success" }
-
-      it_behaves_like "a singular object response"
-    end
-
-    context "not enabled" do
-      let(:stub_pattern) { "disable-not-initiated" }
-
-      it_behaves_like "a client error"
-    end
-  end
-end

data/spec/scalingo/auth/user_spec.rb

@@ -1,31 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Scalingo::Auth::User do
-  describe_method "self" do
-    let(:stub_pattern) { "self" }
-
-    it_behaves_like "a singular object response"
-  end
-
-  describe_method "update" do
-    context "success" do
-      let(:arguments) { meta[:update][:valid] }
-      let(:stub_pattern) { "update-200" }
-
-      it_behaves_like "a singular object response"
-    end
-
-    context "unprocessable" do
-      let(:arguments) { meta[:update][:invalid] }
-      let(:stub_pattern) { "update-422" }
-
-      it_behaves_like "an unprocessable request"
-    end
-  end
-
-  describe_method "stop_free_trial" do
-    let(:stub_pattern) { "stop-free-trial" }
-
-    it_behaves_like "a successful response"
-  end
-end

data/spec/scalingo/auth_spec.rb

@@ -1,15 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Scalingo::Auth do
-  subject { described_class.new("url") }
-
-  %w[keys scm_integrations tokens two_factor_auth user].each do |section|
-    it "handles requests for #{section}" do
-      expect(subject.respond_to?(section)).to be true
-    end
-  end
-
-  it "aliases tfa" do
-    expect(subject.tfa).to eq(subject.two_factor_auth)
-  end
-end

data/spec/scalingo/bearer_token_spec.rb

@@ -1,72 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Scalingo::BearerToken do
-  let(:value) { "my-token" }
-  let(:expires_at) { nil }
-  let(:raise_on_expired) { false }
-
-  subject { described_class.new(value, expires_at: expires_at, raise_on_expired: raise_on_expired) }
-
-  describe "initialize" do
-    it "stores the value" do
-      instance = described_class.new(:value)
-
-      expect(instance.value).to eq(:value)
-      expect(instance.expires_at).to eq nil
-    end
-
-    it "stores the expiration" do
-      expiration = Time.now + 1.hour
-      instance = described_class.new(:value, expires_at: expiration)
-
-      expect(instance.value).to eq(:value)
-      expect(instance.expires_at).to eq expiration
-    end
-  end
-
-  describe "expired?" do
-    context "without expiration" do
-      it { expect(subject).not_to be_expired }
-    end
-
-    context "with the expiration in the future" do
-      let(:expires_at) { Time.current + 1.hour }
-      it { expect(subject).not_to be_expired }
-    end
-
-    context "with the expiration in the past" do
-      let(:expires_at) { Time.current - 1.minute }
-      it { expect(subject).to be_expired }
-    end
-  end
-
-  describe "value" do
-    context "when raising on expired token" do
-      let(:raise_on_expired) { true }
-
-      it "raises when expired" do
-        expect(subject).to receive(:expired?).and_return(true)
-        expect { subject.value }.to raise_error(Scalingo::Error::ExpiredToken)
-      end
-
-      it "returns the value when not expired" do
-        expect(subject).to receive(:expired?).and_return(false)
-        expect(subject.value).to eq(value)
-      end
-    end
-
-    context "when not raising on expired token" do
-      let(:raise_on_expired) { false }
-
-      it "returns the value when expired" do
-        expect(subject).to receive(:expired?).and_return(true)
-        expect(subject.value).to eq(value)
-      end
-
-      it "returns the value when not expired" do
-        expect(subject).to receive(:expired?).and_return(false)
-        expect(subject.value).to eq(value)
-      end
-    end
-  end
-end

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