cloud_payments 0.0.2

data/spec/cloud_payments/namespaces/base_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+class TestNamespace < CloudPayments::Namespaces::Base
+end
+
+describe CloudPayments::Namespaces::Base do
+  let(:headers){ { 'Content-Type' => 'application/json' } }
+  let(:successful_body){ '{"Model":{},"Success":true}' }
+  let(:failed_body){ '{"Success":false,"Message":"Error message"}' }
+  let(:failed_transaction_body){ '{"Model":{"ReasonCode":5041,"CardHolderMessage":"Contact your bank"},"Success":false}' }
+  let(:request_body){ '{"Amount":120,"CurrencyCode":"RUB"}' }
+  let(:request_params){ { amount: 120, currency_code: 'RUB' } }
+
+  subject{ TestNamespace.new(CloudPayments.client) }
+
+  def stub_api(path, body = '')
+    url = "http://user:pass@localhost:9292#{path}"
+    stub_request(:post, url).with(body: body, headers: headers)
+  end
+
+  describe '#request' do
+    context do
+      before{ stub_api('/testnamespace', request_body).to_return(body: successful_body, headers: headers) }
+      specify{ expect(subject.request(nil, request_params)) }
+    end
+
+    context 'with path' do
+      before{ stub_api('/testnamespace/path', request_body).to_return(body: successful_body, headers: headers) }
+
+      specify{ expect(subject.request(:path, request_params)) }
+    end
+
+    context 'with path and parent path' do
+      subject{ TestNamespace.new(CloudPayments.client, 'parent') }
+
+      before{ stub_api('/parent/testnamespace/path', request_body).to_return(body: successful_body, headers: headers) }
+
+      specify{ expect(subject.request(:path, request_params)) }
+    end
+
+    context 'when status is greater than 300' do
+      before{ stub_api('/testnamespace/path', request_body).to_return(status: 404, headers: headers) }
+
+      specify{ expect{ subject.request(:path, request_params) }.to raise_error(CloudPayments::Client::Errors::NotFound) }
+    end
+
+    context 'when failed request' do
+      before{ stub_api('/testnamespace/path', request_body).to_return(body: failed_body, headers: headers) }
+
+      context 'config.raise_banking_errors = true' do
+        before { CloudPayments.config.raise_banking_errors = true }
+        specify{ expect{ subject.request(:path, request_params) }.to raise_error(CloudPayments::Client::GatewayError, 'Error message') }
+      end
+
+      context 'config.raise_banking_errors = false' do
+        before { CloudPayments.config.raise_banking_errors = false }
+        specify{ expect{ subject.request(:path, request_params) }.to raise_error(CloudPayments::Client::GatewayError, 'Error message') }
+      end
+    end
+
+    context 'when failed transaction' do
+      before{ stub_api('/testnamespace/path', request_body).to_return(body: failed_transaction_body, headers: headers) }
+
+      context 'config.raise_banking_errors = true' do
+        before { CloudPayments.config.raise_banking_errors = true }
+        specify{ expect{ subject.request(:path, request_params) }.to raise_error(CloudPayments::Client::GatewayErrors::LostCard) }
+      end
+
+      context 'config.raise_banking_errors = false' do
+        before { CloudPayments.config.raise_banking_errors = false }
+        specify{ expect{ subject.request(:path, request_params) }.not_to raise_error }
+      end
+    end
+  end
+end

data/spec/cloud_payments/namespaces/cards_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+describe CloudPayments::Namespaces::Cards do
+  subject{ CloudPayments::Namespaces::Cards.new(CloudPayments.client, '/payments') }
+
+  let(:attributes){ {
+    amount: 10,
+    currency: 'RUB',
+    invoice_id: '1234567',
+    description: 'Payment for goods on example.com',
+    account_id: 'user_x',
+    name: 'CARDHOLDER NAME',
+    card_cryptogram_packet: '01492500008719030128SM'
+  } }
+
+  context do
+    context 'config.raise_banking_errors = false' do
+      before { CloudPayments.config.raise_banking_errors = false }
+
+      describe '#charge' do
+        before{ stub_api_request('cards/charge/successful').perform }
+        specify{ expect(subject.charge(attributes)).to be_instance_of(CloudPayments::Transaction) }
+        specify{ expect(subject.charge(attributes)).not_to be_required_secure3d }
+        specify{ expect(subject.charge(attributes)).to be_completed }
+        specify{ expect(subject.charge(attributes).id).to eq(12345) }
+      end
+
+      context do
+        before{ stub_api_request('cards/charge/secure3d').perform }
+        specify{ expect(subject.charge(attributes)).to be_instance_of(CloudPayments::Secure3D) }
+        specify{ expect(subject.charge(attributes)).to be_required_secure3d }
+        specify{ expect(subject.charge(attributes).id).to eq(12345) }
+        specify{ expect(subject.charge(attributes).transaction_id).to eq(12345) }
+        specify{ expect(subject.charge(attributes).pa_req).to eq('eJxVUdtugkAQ') }
+        specify{ expect(subject.charge(attributes).acs_url).to eq('https://test.paymentgate.ru/acs/auth/start.do') }
+      end
+
+      context do
+        before{ stub_api_request('cards/charge/failed').perform }
+        specify{ expect(subject.charge(attributes)).to be_instance_of(CloudPayments::Transaction) }
+        specify{ expect(subject.charge(attributes)).not_to be_required_secure3d }
+        specify{ expect(subject.charge(attributes)).to be_declined }
+        specify{ expect(subject.charge(attributes).id).to eq(12345) }
+        specify{ expect(subject.charge(attributes).reason).to eq('InsufficientFunds') }
+      end
+    end
+
+    context 'config.raise_banking_errors = true' do
+      before { CloudPayments.config.raise_banking_errors = true }
+
+      context do
+        before{ stub_api_request('cards/charge/successful').perform }
+        specify{ expect{ subject.charge(attributes) }.not_to raise_error }
+      end
+
+      context do
+        before{ stub_api_request('cards/charge/secure3d').perform }
+        specify{ expect{ subject.charge(attributes) }.not_to raise_error }
+      end
+
+      context do
+        before{ stub_api_request('cards/charge/failed').perform }
+        specify{ expect{ subject.charge(attributes) }.to raise_error(CloudPayments::Client::GatewayErrors::InsufficientFunds) }
+      end
+    end
+  end
+
+  describe '#auth' do
+    context 'config.raise_banking_errors = false' do
+      before { CloudPayments.config.raise_banking_errors = false }
+
+      context do
+        before{ stub_api_request('cards/auth/successful').perform }
+        specify{ expect(subject.auth(attributes)).to be_instance_of(CloudPayments::Transaction) }
+        specify{ expect(subject.auth(attributes)).not_to be_required_secure3d }
+        specify{ expect(subject.auth(attributes)).to be_authorized }
+        specify{ expect(subject.auth(attributes).id).to eq(12345) }
+      end
+
+      context do
+        before{ stub_api_request('cards/auth/secure3d').perform }
+        specify{ expect(subject.auth(attributes)).to be_instance_of(CloudPayments::Secure3D) }
+        specify{ expect(subject.auth(attributes)).to be_required_secure3d }
+        specify{ expect(subject.auth(attributes).id).to eq(12345) }
+        specify{ expect(subject.auth(attributes).transaction_id).to eq(12345) }
+        specify{ expect(subject.auth(attributes).pa_req).to eq('eJxVUdtugkAQ') }
+        specify{ expect(subject.auth(attributes).acs_url).to eq('https://test.paymentgate.ru/acs/auth/start.do') }
+      end
+
+      context do
+        before{ stub_api_request('cards/auth/failed').perform }
+        specify{ expect(subject.auth(attributes)).to be_instance_of(CloudPayments::Transaction) }
+        specify{ expect(subject.auth(attributes)).not_to be_required_secure3d }
+        specify{ expect(subject.auth(attributes)).to be_declined }
+        specify{ expect(subject.auth(attributes).id).to eq(12345) }
+        specify{ expect(subject.auth(attributes).reason).to eq('InsufficientFunds') }
+      end
+    end
+
+    context 'config.raise_banking_errors = true' do
+      before { CloudPayments.config.raise_banking_errors = true }
+
+      context do
+        before{ stub_api_request('cards/auth/successful').perform }
+        specify{ expect{ subject.auth(attributes) }.not_to raise_error }
+      end
+
+      context do
+        before{ stub_api_request('cards/auth/secure3d').perform }
+        specify{ expect{ subject.auth(attributes) }.not_to raise_error }
+      end
+
+      context do
+        before{ stub_api_request('cards/auth/failed').perform }
+        specify{ expect{ subject.auth(attributes) }.to raise_error(CloudPayments::Client::GatewayErrors::InsufficientFunds) }
+      end
+    end
+  end
+end

data/spec/cloud_payments/namespaces/payments_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe CloudPayments::Namespaces::Payments do
+  subject{ CloudPayments::Namespaces::Payments.new(CloudPayments.client) }
+
+  describe '#cards' do
+    specify{ expect(subject.cards).to be_instance_of(CloudPayments::Namespaces::Cards) }
+    specify{ expect(subject.cards.parent_path).to eq('payments') }
+  end
+
+  describe '#tokens' do
+    specify{ expect(subject.tokens).to be_instance_of(CloudPayments::Namespaces::Tokens) }
+    specify{ expect(subject.tokens.parent_path).to eq('payments') }
+  end
+
+  describe '#confirm' do
+    context do
+      before{ stub_api_request('payments/confirm/successful').perform }
+      specify{ expect(subject.confirm(12345, 120)).to be_truthy }
+    end
+
+    context do
+      before{ stub_api_request('payments/confirm/failed').perform }
+      specify{ expect(subject.confirm(12345, 120)).to be_falsy }
+    end
+
+    context do
+      before{ stub_api_request('payments/confirm/failed_with_message').perform }
+      specify{ expect{ subject.confirm(12345, 120) }.to raise_error(CloudPayments::Client::GatewayError, 'Error message') }
+    end
+  end
+
+  describe '#void' do
+    context do
+      before{ stub_api_request('payments/void/successful').perform }
+      specify{ expect(subject.void(12345)).to be_truthy }
+    end
+
+    context do
+      before{ stub_api_request('payments/void/failed').perform }
+      specify{ expect(subject.void(12345)).to be_falsy }
+    end
+
+    context do
+      before{ stub_api_request('payments/void/failed_with_message').perform }
+      specify{ expect{ subject.void(12345) }.to raise_error(CloudPayments::Client::GatewayError, 'Error message') }
+    end
+  end
+
+  describe '#refund' do
+    context do
+      before{ stub_api_request('payments/refund/successful').perform }
+      specify{ expect(subject.refund(12345, 120)).to be_truthy }
+    end
+
+    context do
+      before{ stub_api_request('payments/refund/failed').perform }
+      specify{ expect(subject.refund(12345, 120)).to be_falsy }
+    end
+
+    context do
+      before{ stub_api_request('payments/refund/failed_with_message').perform }
+      specify{ expect{ subject.refund(12345, 120) }.to raise_error(CloudPayments::Client::GatewayError, 'Error message') }
+    end
+  end
+
+  describe '#post3ds' do
+    context 'config.raise_banking_errors = false' do
+      before { CloudPayments.config.raise_banking_errors = false }
+
+      context do
+        before{ stub_api_request('payments/post3ds/successful').perform }
+        specify{ expect(subject.post3ds(12345, 'eJxVUdtugkAQ')).to be_instance_of(CloudPayments::Transaction) }
+      end
+
+      context do
+        before{ stub_api_request('payments/post3ds/failed').perform }
+        specify{ expect{ subject.post3ds(12345, 'eJxVUdtugkAQ') }.not_to raise_error }
+      end
+    end
+
+    context 'config.raise_banking_errors = true' do
+      before { CloudPayments.config.raise_banking_errors = true }
+
+      context do
+        before{ stub_api_request('payments/post3ds/successful').perform }
+        specify{ expect{ subject.post3ds(12345, 'eJxVUdtugkAQ') }.not_to raise_error }
+      end
+
+      context do
+        before{ stub_api_request('payments/post3ds/failed').perform }
+        specify{ expect{ subject.post3ds(12345, 'eJxVUdtugkAQ') }.to raise_error(CloudPayments::Client::GatewayErrors::InsufficientFunds)  }
+      end
+    end
+  end
+end

data/spec/cloud_payments/namespaces/subscriptions_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe CloudPayments::Namespaces::Subscriptions do
+  subject{ CloudPayments::Namespaces::Subscriptions.new(CloudPayments.client) }
+
+  describe '#find' do
+    context do
+      before{ stub_api_request('subscriptions/find/successful').perform }
+
+      specify{ expect(subject.find('sc_8cf8a9338fb')).to be_instance_of(CloudPayments::Subscription) }
+
+      context do
+        let(:sub){ subject.find('sc_8cf8a9338fb') }
+
+        specify{ expect(sub.id).to eq('sc_8cf8a9338fb') }
+        specify{ expect(sub.account_id).to eq('user@example.com') }
+        specify{ expect(sub.description).to eq('Monthly subscription') }
+        specify{ expect(sub.started_at).to eq(DateTime.parse('2014-08-09T11:49:41')) }
+        specify{ expect(sub).to be_active }
+      end
+    end
+  end
+
+  describe '#create' do
+    let(:attributes){ {
+      token: '477BBA133C182267F',
+      account_id: 'user@example.com',
+      description: 'Monthly subscription',
+      email: 'user@example.com',
+      amount: 1.02,
+      currency: 'RUB',
+      require_confirmation: false,
+      start_date: '2014-08-09T11:49:41',
+      interval: 'Month',
+      period: 1,
+      max_periods: 12
+    } }
+
+    context do
+      before{ stub_api_request('subscriptions/create/successful').perform }
+
+      specify{ expect(subject.create(attributes)).to be_instance_of(CloudPayments::Subscription) }
+
+      context do
+        let(:sub){ subject.create(attributes) }
+
+        specify{ expect(sub.id).to eq('sc_8cf8a9338fb') }
+        specify{ expect(sub.account_id).to eq('user@example.com') }
+        specify{ expect(sub.description).to eq('Monthly subscription') }
+        specify{ expect(sub.started_at).to eq(DateTime.parse('2014-08-09T11:49:41')) }
+        specify{ expect(sub).to be_active }
+      end
+    end
+  end
+
+  describe '#update' do
+    let(:attributes){ { account_id: 'user2@example.com', email: 'user2@example.com', max_periods: 6 } }
+
+    context do
+      before{ stub_api_request('subscriptions/update/successful').perform }
+
+      specify{ expect(subject.update('sc_8cf8a9338fb', attributes)).to be_instance_of(CloudPayments::Subscription) }
+
+      context do
+        let(:sub){ subject.update('sc_8cf8a9338fb', attributes) }
+
+        specify{ expect(sub.id).to eq('sc_8cf8a9338fb') }
+        specify{ expect(sub.account_id).to eq('user2@example.com') }
+        specify{ expect(sub.max_periods).to eq(6) }
+        specify{ expect(sub).to be_active }
+      end
+    end
+  end
+
+  describe '#cancel' do
+    context do
+      before{ stub_api_request('subscriptions/cancel/successful').perform }
+
+      specify{ expect(subject.cancel('sc_8cf8a9338fb')).to be_truthy }
+    end
+  end
+end

data/spec/cloud_payments/namespaces/tokens_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe CloudPayments::Namespaces::Tokens do
+  subject{ CloudPayments::Namespaces::Tokens.new(CloudPayments.client, '/payments') }
+
+  let(:attributes){ {
+    amount: 10,
+    currency: 'RUB',
+    invoice_id: '1234567',
+    description: 'Payment for goods on example.com',
+    account_id: 'user_x',
+    name: 'CARDHOLDER NAME',
+    token: 'a4e67841-abb0-42de-a364-d1d8f9f4b3c0'
+  } }
+
+  describe '#charge' do
+    context 'config.raise_banking_errors = true' do
+      before { CloudPayments.config.raise_banking_errors = true }
+      after { CloudPayments.config.raise_banking_errors = false }
+
+      context do
+        before { stub_api_request('tokens/charge/successful').perform }
+        specify{ expect{ subject.charge(attributes) }.not_to raise_error }
+      end
+
+      context do
+        before { stub_api_request('tokens/charge/failed').perform }
+        specify{ expect{ subject.charge(attributes) }.to raise_error(CloudPayments::Client::GatewayErrors::InsufficientFunds) }
+      end
+    end
+
+    context 'config.raise_banking_errors = false' do
+      before { CloudPayments.config.raise_banking_errors = false }
+
+      context do
+        before{ stub_api_request('tokens/charge/successful').perform }
+        specify{ expect(subject.charge(attributes)).to be_instance_of(CloudPayments::Transaction) }
+        specify{ expect(subject.charge(attributes)).not_to be_required_secure3d }
+        specify{ expect(subject.charge(attributes)).to be_completed }
+        specify{ expect(subject.charge(attributes).id).to eq(12345) }
+      end
+
+      context do
+        before{ stub_api_request('tokens/charge/failed').perform }
+        specify{ expect(subject.charge(attributes)).to be_instance_of(CloudPayments::Transaction) }
+        specify{ expect(subject.charge(attributes)).not_to be_required_secure3d }
+        specify{ expect(subject.charge(attributes)).to be_declined }
+        specify{ expect(subject.charge(attributes).id).to eq(12345) }
+        specify{ expect(subject.charge(attributes).reason).to eq('InsufficientFunds') }
+      end
+    end
+  end
+
+  describe '#auth' do
+    context 'config.raise_banking_errors = true' do
+      before { CloudPayments.config.raise_banking_errors = true }
+
+      context do
+        before { stub_api_request('tokens/auth/successful').perform }
+        specify{ expect{ subject.auth(attributes) }.not_to raise_error }
+      end
+
+      context do
+        before { stub_api_request('tokens/auth/failed').perform }
+        specify{ expect{ subject.auth(attributes) }.to raise_error(CloudPayments::Client::GatewayErrors::InsufficientFunds) }
+      end
+    end
+
+    context 'config.raise_banking_errors = false' do
+      before { CloudPayments.config.raise_banking_errors = false }
+
+      context do
+        before{ stub_api_request('tokens/auth/successful').perform }
+        specify{ expect(subject.auth(attributes)).to be_instance_of(CloudPayments::Transaction) }
+        specify{ expect(subject.auth(attributes)).not_to be_required_secure3d }
+        specify{ expect(subject.auth(attributes)).to be_authorized }
+        specify{ expect(subject.auth(attributes).id).to eq(12345) }
+      end
+
+      context do
+        before{ stub_api_request('tokens/auth/failed').perform }
+        specify{ expect(subject.auth(attributes)).to be_instance_of(CloudPayments::Transaction) }
+        specify{ expect(subject.auth(attributes)).not_to be_required_secure3d }
+        specify{ expect(subject.auth(attributes)).to be_declined }
+        specify{ expect(subject.auth(attributes).id).to eq(12345) }
+        specify{ expect(subject.auth(attributes).reason).to eq('InsufficientFunds') }
+      end
+    end
+  end
+end