paytureman 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ecfb2af79747d781ab577d9424ec75fa87b0aed5
-  data.tar.gz: 3cacba04b75c0ee01b23ea637011c4d76985aa3a
+  metadata.gz: cab53a95a5cb505acc786ae18db994f36b2b5f2b
+  data.tar.gz: 6195ca545af50b0edbb0ee007704991494bf617b
 SHA512:
-  metadata.gz: 4dc7562f7b30eedfae776d7e1f5d3227134972b7cd18278b35e6fe2d91023de33ba412d47820c650280da0a34ec5101c84db296ae7c942d02728b034a043877c
-  data.tar.gz: dc4fa2ff9f82487982cdeccd3d9a11a3204cbd4d53259badc409b8416d76a796b984d7056a158c15bf9e389d4de4d18afa9f5b551b0b4d5e0f335240608915ca
+  metadata.gz: aa7323cddc4e9a62fad4a86f5f44b0002bc3cbccfc9b9b93eab0594135554846f69104ed04f6173fa32747f6473edb589b5bac5975c34ae75f6f2f5227ed2fbb
+  data.tar.gz: 2f6c25408ebecb50ee21d0ecafc1700c6ba9bd85440f43d39ee26010654b76563dfbc8da8e78614260412e909b14005e06913c581fe7334a8b86de1666e060aa

data/README.md

@@ -21,6 +21,19 @@ Or install it yourself as:
 ```ruby
 require 'paytureman'
 
+Paytureman::Configuration.setup do |config|
+  config.host = "sandbox"
+  config.key = "MerchantKey"
+  config.password = "123"
+end
+
+# or you can use several configs
+Paytureman::Configuration.setup :production do |config|
+  config.host = "secure"
+  config.key = "Merchant12345"
+  config.password = "password"
+end
+
 order_id = SecureRandom.uuid # generate an order ID
 amount = 123.15 # amount to be charged
 customer_ip = "123.45.67.89" # customer's IP address
@@ -28,8 +41,15 @@ customer_ip = "123.45.67.89" # customer's IP address
 # create initial payment
 payment = Paytureman::PaymentNew.new(order_id, amount, customer_ip)
 
+# in case with several configs
+payment = Paytureman::PaymentNew.new(order_id, amount, customer_ip, :production)
+
 # prepare it
-payment = payment.prepare
+description = Paytureman::PaymentDescription.new
+description.product = 'Paytureman demo payment'
+description.total = amount
+
+payment = payment.prepare(description)
 # ... assert(payment.kind_of?(Paytureman::PaymentPrepared))
 
 puts "Please, visit #{payment.url} to proceed with the payment. Then press Enter."
@@ -51,4 +71,4 @@ payment = payment.charge
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+5. Create new Pull Request

data/lib/payments/payment.rb

@@ -2,18 +2,24 @@ module Paytureman
 
   class Payment
 
+    attr_accessor :gateway
     attr_reader :order_id
+    attr_writer :configuration
 
-    def initialize(order_id, amount, ip)
-      @order_id, @amount, @ip = order_id, amount, ip
+    def initialize(order_id, amount, gateway = nil)
+      @order_id = order_id
+      @amount = amount
+      @gateway = gateway
     end
 
     def save_to_memento(memento)
-      memento.order_id, memento.amount, memento.ip = order_id, amount, ip
+      memento.order_id = order_id
+      memento.amount = amount
+      memento.gateway = gateway
     end
 
     def self.new_from_memento(memento)
-      new(memento.order_id, memento.amount, memento.ip)
+      new(memento.order_id, memento.amount, memento.gateway)
     end
 
     def self.new_from_payment(donor)
@@ -34,17 +40,23 @@ module Paytureman
       current_payment_type.new_from_payment(self)
     end
 
-    attr_accessor :payture
-
   protected
 
-    attr_accessor :amount, :ip
+    attr_accessor :amount
     attr_writer   :order_id
 
+    def amount_in_cents
+      (amount * 100).round
+    end
+
+    def configuration
+      @configuration ||= Configuration.instance
+    end
+
     def payture
-      @payture ||= Api.instance
+      @payture ||= configuration.api_for(gateway)
     end
 
   end
 
-end
+end

data/lib/payments/payment_blocked.rb

@@ -3,16 +3,16 @@ module Paytureman
   class PaymentBlocked < PaymentWithSession
 
     def unblock
-      if payture.unblock(order_id, (self.amount*100).round)
-        PaymentCancelled.new(order_id, amount, ip, session_id)
+      if payture.unblock(order_id, amount_in_cents)
+        PaymentCancelled.new(order_id, amount, session_id, gateway)
       else
         self
       end
     end
 
     def charge
-      if payture.charge(order_id, session_id)
-        PaymentCharged.new(order_id, amount, ip, session_id)
+      if payture.charge(order_id)
+        PaymentCharged.new(order_id, amount, session_id, gateway)
       else
         self
       end

data/lib/payments/payment_charged.rb

@@ -2,12 +2,12 @@ module Paytureman
 
   class PaymentCharged < PaymentWithSession
     def refund
-      if payture.refund(order_id, (self.amount*100).round)
-        PaymentRefunded.new(order_id, amount, ip, session_id)
+      if payture.refund(order_id, amount_in_cents)
+        PaymentRefunded.new(order_id, amount, session_id, gateway)
       else
         self
       end
     end
   end
 
-end
+end

data/lib/payments/payment_new.rb

@@ -10,15 +10,33 @@ module Paytureman
 
   class PaymentNew < Payment
 
+    def initialize(order_id, amount, ip, gateway = nil)
+      super(order_id, amount, gateway)
+      @ip = ip
+    end
+
+    def save_to_memento(memento)
+      super
+      memento.ip = ip
+    end
+
+    def self.new_from_memento(memento)
+      new(memento.order_id, memento.amount, memento.ip, memento.gateway)
+    end
+
     def prepare(description = PaymentDescription.new)
-      session_id = payture.init(self.order_id, (self.amount*100).round, self.ip, description.to_h)
+      session_id = payture.init(order_id, amount_in_cents, ip, description.to_h)
       if session_id
-        PaymentPrepared.new(self.order_id, self.amount, self.ip, session_id)
+        PaymentPrepared.new(order_id, amount, session_id, gateway)
       else
         self
       end
     end
 
+  protected
+
+    attr_reader :ip
+
   end
 
-end
+end

data/lib/payments/payment_prepared.rb

@@ -3,13 +3,13 @@ module Paytureman
   class PaymentPrepared < PaymentWithSession
 
     def url
-      "https://sandbox.payture.com/apim/Pay?SessionId=#{session_id}"
+      payture.pay_url(session_id)
     end
 
     def block
-      PaymentBlocked.new(order_id, amount, ip, session_id)
+      PaymentBlocked.new(order_id, amount, session_id, gateway)
     end
 
   end
 
-end
+end

data/lib/payments/payment_with_session.rb

@@ -2,9 +2,9 @@ module Paytureman
 
   class PaymentWithSession < Payment
 
-    def initialize(order_id, amount, ip, session_id)
+    def initialize(order_id, amount, session_id, gateway = nil)
+      super(order_id, amount, gateway)
       @session_id = session_id
-      super(order_id, amount, ip)
     end
 
     def save_to_memento(memento)
@@ -13,7 +13,7 @@ module Paytureman
     end
 
     def self.new_from_memento(memento)
-      new(memento.order_id, memento.amount, memento.ip, memento.session_id)
+      new(memento.order_id, memento.amount, memento.session_id, memento.gateway)
     end
 
   protected
@@ -22,4 +22,4 @@ module Paytureman
 
   end
 
-end
+end

data/lib/payture/api.rb

@@ -1,9 +1,13 @@
 module Paytureman
   class Api
-    include Singleton
-
     attr_accessor :rest_client
 
+    def initialize(host, key, password)
+      @host = host
+      @key = key
+      @password = password
+    end
+
     def init(order_id, amount, ip, description = {})
 
       data = { SessionType: :Block, OrderId: order_id, Amount: amount, IP: ip }
@@ -17,18 +21,22 @@ module Paytureman
       response[:success] && response[:session_id]
     end
 
-    def charge(order_id, session_id)
-      response = make_request(:charge, order_id: order_id, password: '123')
+    def pay_url(session_id)
+      "#{url_for(:pay)}?SessionId=#{session_id}"
+    end
+
+    def charge(order_id)
+      response = make_request(:charge, order_id: order_id, password: @password)
       response[:success]
     end
 
     def refund(order_id, amount)
-      response = make_request(:refund, order_id: order_id, amount: amount, password: '123')
+      response = make_request(:refund, order_id: order_id, amount: amount, password: @password)
       response[:success]
     end
 
     def unblock(order_id, amount)
-      response = make_request(:unblock, order_id: order_id, amount: amount, password: '123')
+      response = make_request(:unblock, order_id: order_id, amount: amount, password: @password)
       response[:success]
     end
 
@@ -46,10 +54,10 @@ module Paytureman
 
     def make_request(method, params)
       params = Hash[
-          params.merge(key: 'MerchantRutravel').
+          params.merge(key: @key).
               map { |k, v| [ k.to_s.camelize, v ] }
       ]
-      response = rest_client.post "https://sandbox.payture.com/apim/#{method.to_s.camelize}", params
+      response = rest_client.post url_for(method), params
       puts response.body
       return nil if response.body.empty?
       doc = REXML::Document.new(response.body)
@@ -69,6 +77,10 @@ module Paytureman
       return result
     end
 
+    def url_for(method)
+      "https://#@host.payture.com/apim/#{method.to_s.camelize}"
+    end
+
   end
 end
 

data/lib/paytureman.rb

@@ -17,4 +17,5 @@ require_relative 'payments/payment_refunded'
 require_relative 'payments/payment_cancelled'
 require_relative 'payments/payment_unknown'
 
-require_relative 'service/payment_persistence'
+require_relative 'service/payment_persistence'
+require_relative 'service/configuration'

data/lib/service/configuration.rb

@@ -0,0 +1,56 @@
+module Paytureman
+  class Configuration
+    include Singleton
+
+    class << self
+      def setup(namespace = nil)
+        settings = Settings.new
+        yield settings
+        instance.add_settings(namespace, settings)
+      end
+    end
+
+    attr_accessor :configurations
+
+    def initialize
+      @configurations = {}
+      add_settings(nil, Settings.new)
+    end
+
+    def add_settings(namespace, settings)
+      configurations[gateway_name(namespace)] = settings
+    end
+  
+    def settings(namespace)
+      configurations[gateway_name(namespace)]
+    end
+
+    def api_for(namespace)
+      config = settings(namespace) or raise GatewayNotFoundException.new(namespace)
+      Paytureman::Api.new(config.host, config.key, config.password)
+    end
+
+  private
+
+    def gateway_name(key)
+      key.to_s.to_sym
+    end
+  end
+
+  class Settings
+    attr_accessor :host, :key, :password
+
+    def initialize
+      @host = 'sandbox'
+      @key = 'MerchantRutravel'
+      @password = '123'
+    end
+  end
+
+  class GatewayNotFoundException < Exception
+    def initialize(name)
+      super("Gateway #{name} has not been defined in the configuration")
+    end
+  end
+
+end

data/paytureman.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "paytureman"
-  spec.version       = "0.5.0"
+  spec.version       = "0.7.0"
   spec.authors       = ["Ivan Kasatenko", "Nickolay Sverchkov", "Alexander Fomin"]
   spec.email         = ["contact@uniqsystems.ru"]
   spec.summary       = %q{Payture API implementation}

data/spec/requests/payment_process_spec.rb

@@ -8,16 +8,14 @@ describe "Payment" do
   let(:session_id) { SecureRandom.uuid }
 
   let(:payture_mock) {
-    double("Payture").tap do |mock|
-      expect(mock).to receive(:init).with(order_id, amount*100, ip, {}).and_return(session_id)
-    end
+    Api.any_instance
   }
 
   it "should charge successfully" do
-    expect(payture_mock).to receive(:charge).with(order_id, session_id).and_return(true)
+    payture_mock.stub(:init).with(order_id, amount*100, ip, {}).and_return(session_id)
+    payture_mock.stub(:charge).with(order_id).and_return(true)
 
     payment = PaymentNew.new(order_id, amount, ip)
-    payment.payture = payture_mock
 
     payment = payment.prepare
 
@@ -26,16 +24,16 @@ describe "Payment" do
     payment = payment.block
     expect(payment).to be_kind_of(PaymentBlocked)
 
-    payment.payture = payture_mock
+
     payment = payment.charge
     expect(payment).to be_kind_of(PaymentCharged)
   end
 
   it "should unblock successfully" do
-    expect(payture_mock).to receive(:unblock).with(order_id, amount*100).and_return(true)
+    payture_mock.stub(:init).with(order_id, amount*100, ip, {}).and_return(session_id)
+    payture_mock.stub(:unblock).with(order_id, amount*100).and_return(true)
 
     payment = PaymentNew.new(order_id, amount, ip)
-    payment.payture = payture_mock
 
     payment = payment.prepare
     expect(payment).to be_kind_of(PaymentPrepared)
@@ -43,17 +41,16 @@ describe "Payment" do
     payment = payment.block
     expect(payment).to be_kind_of(PaymentBlocked)
 
-    payment.payture = payture_mock
     payment = payment.unblock
     expect(payment).to be_kind_of(PaymentCancelled)
   end
 
   it "should refund successfully" do
-    expect(payture_mock).to receive(:charge).with(order_id, session_id).and_return(true)
-    expect(payture_mock).to receive(:refund).with(order_id, amount*100).and_return(true)
+    payture_mock.stub(:init).with(order_id, amount*100, ip, {}).and_return(session_id)
+    payture_mock.stub(:charge).with(order_id).and_return(true)
+    payture_mock.stub(:refund).with(order_id, amount*100).and_return(true)
 
     payment = PaymentNew.new(order_id, amount, ip)
-    payment.payture = payture_mock
 
     payment = payment.prepare
     expect(payment).to be_kind_of(PaymentPrepared)
@@ -61,11 +58,9 @@ describe "Payment" do
     payment = payment.block
     expect(payment).to be_kind_of(PaymentBlocked)
 
-    payment.payture = payture_mock
     payment = payment.charge
     expect(payment).to be_kind_of(PaymentCharged)
 
-    payment.payture = payture_mock
     payment = payment.refund
     expect(payment).to be_kind_of(PaymentRefunded)
   end
@@ -99,22 +94,92 @@ describe "Payment" do
     ).and_return(empty_response)
 
     payment = PaymentNew.new(order_id, amount, ip)
+
     payment.prepare(PaymentDescription.new(nil, nil, nil, nil))
   end
 
+  let(:real_configuration) {
+    double('configuration').tap do |config|
+      allow(config).to receive(:api_for).with(:real).and_return(Api.new('secure', 'MERCHANT100100', 'password'))
+    end
+  }
+
   it "should send valid params" do
     expect(RestClient).to receive(:post).with(
-        "https://sandbox.payture.com/apim/Charge",
-        {
-            "OrderId" => order_id,
-            "Password" => "123",
-            "Key" => "MerchantRutravel"
-        }
+      "https://secure.payture.com/apim/Charge",
+      {
+          "OrderId" => order_id,
+          "Password" => "password",
+          "Key" => "MERCHANT100100"
+      }
     ).and_return(empty_response)
 
-    payment = PaymentBlocked.new(order_id, amount, ip, 'session')
+    payment = PaymentBlocked.new(order_id, amount, 'session', :real)
+    payment.configuration = real_configuration
 
     payment.charge
   end
 
+  describe 'using same gateway when status changing' do
+    before do
+      Configuration.setup :settings do |config|
+        config.host = 'host'
+        config.key = 'key'
+        config.password = 'password'
+      end
+    end
+
+    it 'when charged' do
+      payture_mock.stub(:init).with(order_id, amount*100, ip, {}).and_return(session_id)
+      payture_mock.stub(:charge).with(order_id).and_return(true)
+
+      payment = PaymentNew.new(order_id, amount, ip, :settings)
+
+      payment = payment.prepare
+      expect(payment.gateway).to eq :settings
+
+      payment = payment.block
+      expect(payment.gateway).to eq :settings
+
+      payment = payment.charge
+      expect(payment.gateway).to eq :settings
+    end
+
+    it "when unblocked" do
+      payture_mock.stub(:init).with(order_id, amount*100, ip, {}).and_return(session_id)
+      payture_mock.stub(:unblock).with(order_id, amount*100).and_return(true)
+
+      payment = PaymentNew.new(order_id, amount, ip, :settings)
+
+      payment = payment.prepare
+      expect(payment.gateway).to eq :settings
+
+      payment = payment.block
+      expect(payment.gateway).to eq :settings
+
+      payment = payment.unblock
+      expect(payment.gateway).to eq :settings
+    end
+
+    it "when refunded" do
+      payture_mock.stub(:init).with(order_id, amount*100, ip, {}).and_return(session_id)
+      payture_mock.stub(:charge).with(order_id).and_return(true)
+      payture_mock.stub(:refund).with(order_id, amount*100).and_return(true)
+
+      payment = PaymentNew.new(order_id, amount, ip, :settings)
+
+      payment = payment.prepare
+      expect(payment.gateway).to eq :settings
+
+      payment = payment.block
+      expect(payment.gateway).to eq :settings
+
+      payment = payment.charge
+      expect(payment.gateway).to eq :settings
+
+      payment = payment.refund
+      expect(payment.gateway).to eq :settings
+    end
+  end
+
 end

data/spec/requests/payture/api_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Api do
+
+  let(:empty_response) { double('Request', body: '<xml />') }
+  let(:host) { 'secure' }
+  let(:key) { 'merchant' }
+  let(:password) { 'password' }
+
+  describe 'send request with defined host and key' do
+    subject { Api.new(host, key, password) }
+
+    it 'should send request with settings' do
+      expect(RestClient).to receive(:post).with(
+          "https://#{host}.payture.com/apim/Charge",
+          {
+              "OrderId" => 1,
+              "Password" => password,
+              "Key" => key
+          }
+      ).and_return(empty_response)
+
+      subject.charge(1)
+    end
+  end
+
+
+end

data/spec/requests/service/configuration_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Configuration do
+  context 'with default configuration' do
+    describe 'settings' do
+      subject { Configuration.instance.settings(nil) }
+
+      its(:host) { should eq 'sandbox' }
+      its(:key) { should eq 'MerchantRutravel' }
+      its(:password) { should eq '123' }
+
+      it 'should build api' do
+        allow(Api.any_instance).to receive(:new).with('sandbox', 'MerchantRutravel', '123')
+        Configuration.instance.api_for(nil)
+      end
+    end
+  end
+
+  context 'set up' do
+    context 'host' do
+      before do
+        Configuration.setup :settings do |config|
+          config.host = 'host'
+          config.key = 'key'
+          config.password = 'password'
+        end
+      end
+
+      subject { Configuration.instance.settings(:settings) }
+
+      its(:host) { should eq 'host' }
+      its(:key) { should eq 'key' }
+      its(:password) { should eq 'password' }
+
+
+      it 'should build api' do
+        allow(Api.any_instance).to receive(:new).with('host', 'key', 'password')
+        Configuration.instance.api_for(nil)
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: paytureman
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Ivan Kasatenko
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-28 00:00:00.000000000 Z
+date: 2014-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest_client
@@ -134,9 +134,12 @@ files:
 - lib/payments/payment_with_session.rb
 - lib/payture/api.rb
 - lib/paytureman.rb
+- lib/service/configuration.rb
 - lib/service/payment_persistence.rb
 - paytureman.gemspec
 - spec/requests/payment_process_spec.rb
+- spec/requests/payture/api_spec.rb
+- spec/requests/service/configuration_spec.rb
 - spec/spec_helper.rb
 homepage: ''
 licenses:
@@ -164,4 +167,6 @@ specification_version: 4
 summary: Payture API implementation
 test_files:
 - spec/requests/payment_process_spec.rb
+- spec/requests/payture/api_spec.rb
+- spec/requests/service/configuration_spec.rb
 - spec/spec_helper.rb