scalingo 3.3.0 → 3.5.0

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

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