mymoip 0.6.1 → 0.6.2

data/test/lib/test_payer.rb

@@ -0,0 +1,249 @@
+require_relative '../test_helper'
+
+class TestPayer < Test::Unit::TestCase
+  def test_getters_for_attributes
+    payer = MyMoip::Payer.new(
+      id: "some id",
+      name: "some name",
+      email: "some email",
+      address_street: "some address_street",
+      address_street_number: "some address_street_number",
+      address_street_extra: "some address_street_extra",
+      address_neighbourhood: "some address_neighbourhood",
+      address_city: "some address_city",
+      address_state: "RS",
+      address_country: "BRA",
+      address_cep: "92123456",
+      address_phone: "5130405060"
+    )
+
+    assert_equal "some id", payer.id
+    assert_equal "some name", payer.name
+    assert_equal "some email", payer.email
+    assert_equal "some address_street", payer.address_street
+    assert_equal "some address_street_number", payer.address_street_number
+    assert_equal "some address_street_extra", payer.address_street_extra
+    assert_equal "some address_neighbourhood", payer.address_neighbourhood
+    assert_equal "some address_city", payer.address_city
+    assert_equal "RS", payer.address_state
+    assert_equal "BRA", payer.address_country
+    assert_equal "92123456", payer.address_cep
+    assert_equal "5130405060", payer.address_phone
+  end
+
+  def test_initialization_and_setters_with_string_keys
+    payer = MyMoip::Payer.new(
+      'id'                    => 'some id',
+      'name'                  => 'some name',
+      'email'                 => 'some email',
+      'address_street'        => 'some address_street',
+      'address_street_number' => 'some address_street_number',
+      'address_street_extra'  => 'some address_street_extra',
+      'address_neighbourhood' => 'some address_neighbourhood',
+      'address_city'          => 'some address_city',
+      'address_state'         => 'RS',
+      'address_country'       => 'BRA',
+      'address_cep'           => '92123456',
+      'address_phone'         => '5130405060'
+    )
+
+    assert_equal "some id", payer.id
+    assert_equal "some name", payer.name
+    assert_equal "some email", payer.email
+    assert_equal "some address_street", payer.address_street
+    assert_equal "some address_street_number", payer.address_street_number
+    assert_equal "some address_street_extra", payer.address_street_extra
+    assert_equal "some address_neighbourhood", payer.address_neighbourhood
+    assert_equal "some address_city", payer.address_city
+    assert_equal "RS", payer.address_state
+    assert_equal "BRA", payer.address_country
+    assert_equal "92123456", payer.address_cep
+    assert_equal "5130405060", payer.address_phone
+  end
+
+  def test_validate_presence_of_id_attribute
+    subject = Fixture.payer
+    subject.id = nil
+    assert subject.invalid?, 'should be invalid without an id'
+    subject.id = ''
+    assert subject.invalid?, 'should be invalid without an id'
+  end
+
+  def test_validate_presence_of_name_attribute
+    subject = Fixture.payer
+    subject.name = nil
+    assert subject.invalid?, 'should be invalid without an name'
+    subject.name = ''
+    assert subject.invalid?, 'should be invalid without an name'
+  end
+
+  def test_validate_presence_of_email_attribute
+    subject = Fixture.payer
+    subject.email = nil
+    assert subject.invalid?, 'should be invalid without an email'
+    subject.email = ''
+    assert subject.invalid?, 'should be invalid without an email'
+  end
+
+  def test_validate_presence_of_address_street_attribute
+    subject = Fixture.payer
+    subject.address_street = nil
+    assert subject.invalid?, 'should be invalid without an address_street'
+    subject.address_street = ''
+    assert subject.invalid?, 'should be invalid without an address_street'
+  end
+
+  def test_validate_presence_of_address_street_number_attribute
+    subject = Fixture.payer
+    subject.address_street_number = nil
+    assert subject.invalid?, 'should be invalid without an address_street_number'
+    subject.address_street_number = ''
+    assert subject.invalid?, 'should be invalid without an address_street_number'
+  end
+
+  def test_validate_presence_of_address_neighbourhood_attribute
+    subject = Fixture.payer
+    subject.address_neighbourhood = nil
+    assert subject.invalid?, 'should be invalid without an address_neighbourhood'
+    subject.address_neighbourhood = ''
+    assert subject.invalid?, 'should be invalid without an address_neighbourhood'
+  end
+
+  def test_validate_presence_of_address_city_attribute
+    subject = Fixture.payer
+    subject.address_city = nil
+    assert subject.invalid?, 'should be invalid without an address_city'
+    subject.address_city = ''
+    assert subject.invalid?, 'should be invalid without an address_city'
+  end
+
+  def test_validate_presence_of_address_state_attribute
+    subject = Fixture.payer
+    subject.address_state = nil
+    assert subject.invalid?, 'should be invalid without an address_state'
+    subject.address_state = ''
+    assert subject.invalid?, 'should be invalid without an address_state'
+  end
+
+  def test_validate_length_of_address_state_attribute_in_2_chars
+    subject = Fixture.payer
+    subject.address_state = 'RS'
+    assert subject.valid?, 'should accept 2 chars'
+    subject.address_state = 'RSS'
+    assert subject.invalid? && subject.errors[:address_state].present?,
+      'should not accept strings with other than 2 chars'
+  end
+
+  def test_upcase_assigned_address_state
+    subject = Fixture.payer
+    subject.address_state = 'rs'
+    assert_equal 'RS', subject.address_state
+  end
+
+  def test_validate_presence_of_address_country_attribute
+    subject = Fixture.payer
+    subject.address_country = nil
+    assert subject.invalid?, 'should be invalid without an address_country'
+    subject.address_country = ''
+    assert subject.invalid?, 'should be invalid without an address_country'
+  end
+
+  def test_validate_length_of_address_country_attribute_in_3_chars
+    subject = Fixture.payer
+    subject.address_country = 'BRA'
+    assert subject.valid?, 'should accept 3 chars'
+    subject.address_country = 'BR'
+    assert subject.invalid? && subject.errors[:address_country].present?,
+      'should not accept strings with other than 3 chars'
+  end
+
+  def test_upcase_assigned_address_country
+    subject = Fixture.payer
+    subject.address_country = 'bra'
+    assert_equal 'BRA', subject.address_country
+  end
+
+  def test_validate_presence_of_address_cep_attribute
+    subject = Fixture.payer
+    subject.address_cep = nil
+    assert subject.invalid?, 'should be invalid without an address_cep'
+    subject.address_cep = ''
+    assert subject.invalid?, 'should be invalid without an address_cep'
+  end
+
+  def test_validate_length_of_address_cep_attribute_in_2_chars
+    subject = Fixture.payer
+    subject.address_cep = '92123456'
+    assert subject.valid?, 'should accept 8 chars'
+    subject.address_cep = '921234560000'
+    assert subject.invalid? && subject.errors[:address_cep].present?,
+      'should not accept strings with other than 8 chars'
+  end
+
+  def test_dont_count_dashes_in_the_address_cep_length_validation
+    subject = Fixture.payer
+    subject.address_cep = '92123-456'
+    assert subject.valid?
+  end
+
+  def test_remove_dashes_from_address_cep
+    subject = Fixture.payer
+    subject.address_cep = '92123-456'
+    assert_equal '92123456', subject.address_cep
+  end
+
+  def test_validate_presence_of_address_phone_attribute
+    subject = Fixture.payer
+    subject.address_phone = nil
+    assert subject.invalid?, 'should be invalid without an address_phone'
+    subject.address_phone = ''
+    assert subject.invalid?, 'should be invalid without an address_phone'
+  end
+
+  def test_validate_length_of_address_phone_attribute_in_10_or_11_chars
+    subject = Fixture.payer
+    subject.address_phone = '5130405060'
+    assert subject.valid?, 'should accept 10 chars'
+    subject.address_phone = '51930405060'
+    assert subject.valid?, 'should accept 11 chars'
+    subject.address_phone = '215130405060'
+    assert subject.invalid? && subject.errors[:address_phone].present?,
+      'should not accept strings with other than 10 or 11 chars'
+  end
+
+  def test_remove_left_zeros_from_address_phone
+    subject = Fixture.payer
+    subject.address_phone = '05130405060'
+    assert_equal '5130405060', subject.address_phone
+  end
+
+  def test_remove_dashes_from_address_phone
+    subject = Fixture.payer
+    subject.address_phone = '513040-5060'
+    assert_equal '5130405060', subject.address_phone
+    subject.address_phone = '5193040-5060'
+    assert_equal '51930405060', subject.address_phone
+  end
+
+  def test_remove_parenthesis_from_address_phone
+    subject = Fixture.payer
+    subject.address_phone = '(51)30405060'
+    assert_equal '5130405060', subject.address_phone
+    subject.address_phone = '(51)930405060'
+    assert_equal '51930405060', subject.address_phone
+  end
+
+  def test_to_xml_method_uses_the_formatted_version_of_the_address_cep
+    subject = Fixture.payer(address_cep: '92000123')
+    formatter = stub_everything('formatter')
+    formatter.expects(:cep).with('92000123')
+    subject.to_xml(nil, formatter)
+  end
+
+  def test_to_xml_method_uses_the_formatted_version_of_the_address_phone
+    subject = Fixture.payer(address_phone: '5130405060')
+    formatter = stub_everything('formatter')
+    formatter.expects(:phone).with('5130405060')
+    subject.to_xml(nil, formatter)
+  end
+end

data/test/lib/test_payment_request.rb

@@ -0,0 +1,96 @@
+# encoding: UTF-8
+require_relative '../test_helper'
+
+class TestPaymentRequest < Test::Unit::TestCase
+  def test_http_method_as_get
+    assert_equal :get, MyMoip::PaymentRequest::HTTP_METHOD
+  end
+
+  def test_path
+    assert_equal  "/rest/pagamento?callback=?", MyMoip::PaymentRequest::PATH
+  end
+
+  def test_non_auth_requirement
+    assert_equal false, MyMoip::PaymentRequest::REQUIRES_AUTH
+  end
+
+  def test_generate_json
+    HTTParty.stubs(:send).returns("<html>some_result</html>")
+    request = MyMoip::PaymentRequest.new("id")
+
+    JSON.expects(:generate).with(
+      pagamentoWidget: {
+        referer: "http://localhost",
+        token:   "big_transparent_token",
+        dadosPagamento: {payment: "attributes"}
+      }
+    )
+    request_data = stub(to_json: {payment: "attributes"})
+    request.api_call(request_data, token: "big_transparent_token", referer_url: "http://localhost")
+  end
+
+  def test_gets_default_referer_if_another_isnt_passed
+    MyMoip.default_referer_url = "http://localhost/default"
+    HTTParty.stubs(:send).returns("<html>some_result</html>")
+    request = MyMoip::PaymentRequest.new("id")
+
+    JSON.expects(:generate).with(
+      pagamentoWidget: {
+        referer:        MyMoip.default_referer_url,
+        token:          "big_transparent_token",
+        dadosPagamento: {payment: "attributes"}
+      }
+    )
+    request_data = stub(to_json: {payment: "attributes"})
+    request.api_call(request_data, token: "big_transparent_token")
+  end
+
+  def test_successful_status
+    MyMoip.default_referer_url = "http://localhost/default"
+    HTTParty.stubs(:send).returns(
+      JSON.parse '{"Status":"EmAnalise","Codigo":0,"CodigoRetorno":"","TaxaMoIP":"7.79","StatusPagamento":"Sucesso","Classificacao":{"Codigo":999,"Descricao":"Não suportado no ambiente Sandbox"},"CodigoMoIP":77316,"Mensagem":"Requisição processada com sucesso","TotalPago":"100.00"}'
+    )
+    request = MyMoip::PaymentRequest.new("id")
+
+    request_data = stub(to_json: {payment: "attributes"})
+    request.api_call(request_data, token: "big_transparent_token")
+    assert request.success?
+  end
+
+  def test_success_method_returns_false_in_payments_already_made
+    MyMoip.default_referer_url = "http://localhost/default"
+    HTTParty.stubs(:send).returns(
+      JSON.parse '{"Codigo":236,"StatusPagamento":"Falha","Mensagem":"Pagamento já foi realizado"}'
+    )
+    request = MyMoip::PaymentRequest.new("id")
+
+    request_data = stub(to_json: {payment: "attributes"})
+    request.api_call(request_data, token: "big_transparent_token")
+    assert !request.success?
+  end
+
+  def test_method_to_get_moip_code
+    instruction = Fixture.instruction(payer: Fixture.payer)
+    transparent_request = MyMoip::TransparentRequest.new("your_own_id")
+    VCR.use_cassette('transparent_request') do
+      transparent_request.api_call(instruction)
+    end
+    credit_card_payment = MyMoip::CreditCardPayment.new(Fixture.credit_card, 1)
+    payment_request = MyMoip::PaymentRequest.new("your_own_id")
+    VCR.use_cassette('payment_request') do
+      payment_request.api_call(credit_card_payment, token: transparent_request.token)
+    end
+    assert_equal 102596, payment_request.code
+  end
+
+  def test_code_method_should_return_nil_with_blank_response
+    instruction = Fixture.instruction(payer: Fixture.payer)
+    transparent_request = MyMoip::TransparentRequest.new("your_own_id")
+    VCR.use_cassette('transparent_request') do
+      transparent_request.api_call(instruction)
+    end
+    credit_card_payment = MyMoip::CreditCardPayment.new(Fixture.credit_card, 1)
+    payment_request = MyMoip::PaymentRequest.new("your_own_id")
+    assert_nil payment_request.code
+  end
+end

data/test/lib/test_purchase.rb

@@ -0,0 +1,109 @@
+require_relative '../test_helper'
+
+def cc_attrs(attrs = {})
+  {
+    logo:            :visa,
+    card_number:     '4916654211627608',
+    expiration_date: '06/15',
+    security_code:   '000',
+    owner_name:      'Juquinha da Rocha',
+    owner_birthday:  '03/11/1980',
+    owner_phone:     '5130405060',
+    owner_cpf:       '52211670695'
+  }.merge(attrs)
+end
+
+def payer_attrs(attrs = {})
+  {
+    id:                    rand,
+    name:                  'Juquinha da Rocha',
+    email:                 'juquinha@rocha.com',
+    address_street:        'Felipe Neri',
+    address_street_number: '406',
+    address_street_extra:  'Sala 501',
+    address_neighbourhood: 'Auxiliadora',
+    address_city:          'Porto Alegre',
+    address_state:         'RS',
+    address_country:       'BRA',
+    address_cep:           '90440150',
+    address_phone:         '5130405060'
+  }.merge(attrs)
+end
+
+class TestPurchase < Test::Unit::TestCase
+  def setup
+    MyMoip::Request.any_instance.stubs(:api_call)
+    MyMoip::PaymentRequest.any_instance.stubs(:api_call)
+    MyMoip::TransparentRequest.any_instance.stubs(:api_call)
+  end
+
+  def subject
+    MyMoip::Purchase.new(id:          '42',
+                         price:       400,
+                         reason:      'Payment of my product',
+                         credit_card: cc_attrs,
+                         payer:       payer_attrs)
+  end
+
+  def test_new_objects_stores_already_initialized_instance_of_credit_ard
+    assert subject.credit_card.kind_of?(MyMoip::CreditCard)
+  end
+
+  def test_new_objects_stores_already_initialized_instance_of_payer
+    assert subject.payer.kind_of?(MyMoip::Payer)
+  end
+
+  def test_checkout_uses_initialized_id_for_logging
+    MyMoip::PaymentRequest.expects(:new).
+                           with('42').
+                           returns(stub_everything)
+    subject.checkout!
+  end
+
+  def test_checkout_instruction_uses_a_generated_id_for_instruction
+    MyMoip::Instruction.expects(:new).
+                        with(has_entry(id: subject.id)).
+                        returns(stub_everything)
+    subject.checkout!
+  end
+
+  def test_checkout_instruction_uses_initialized_reason
+    MyMoip::Instruction.expects(:new).
+                        with(has_entry(payment_reason: 'Payment of my product')).
+                        returns(stub_everything)
+    subject.checkout!
+  end
+
+  def test_checkout_instruction_uses_initialized_price
+    MyMoip::Instruction.expects(:new).
+                        with(has_entry(values: [400.0])).
+                        returns(stub_everything)
+    subject.checkout!
+  end
+
+  def test_checkouts_transparent_request_uses_initialized_id_for_payment_request_logging
+    MyMoip::TransparentRequest.expects(:new).
+                               with('42').
+                               returns(stub_everything)
+    subject.checkout!
+  end
+
+  def test_checkouts_transparent_request_confirm_request_with_authorized_token
+    MyMoip::Purchase.any_instance.stubs(:get_authorization!).
+                          returns(stub('MyMoip request', token: 'abc'))
+
+    MyMoip::PaymentRequest.any_instance.expects(:api_call).
+                               with(anything, has_entry(token: 'abc')).
+                               returns(stub_everything)
+    subject.checkout!
+  end
+
+  def test_checkouts_transparent_request_assigns_its_code
+    MyMoip::PaymentRequest.any_instance.stubs(:success?).returns(true)
+    MyMoip::PaymentRequest.any_instance.stubs(:code).returns('foo_bar')
+    purchase = subject
+    purchase.checkout!
+
+    assert_equal 'foo_bar', purchase.code
+  end
+end

data/test/lib/test_request.rb

@@ -0,0 +1,88 @@
+require_relative '../test_helper'
+
+class TestRequest < Test::Unit::TestCase
+  def setup
+    @default_environment = MyMoip.environment
+    @default_key         = MyMoip.key
+    @default_token       = MyMoip.token
+    @default_logger      = MyMoip.logger
+  end
+
+  def teardown
+    MyMoip.environment = @default_environment
+    MyMoip.key         = @default_key
+    MyMoip.token       = @default_token
+    MyMoip.logger      = @default_logger
+  end
+
+  def test_initializes_receiving_data_and_optional_id
+    request = MyMoip::Request.new("request_id")
+    assert_equal "request_id", request.id
+  end
+
+  def test_logs_api_call_method_in_info_level
+    logger = stub_everything
+    request = MyMoip::Request.new("request_id")
+    params = {
+      http_method: :post, body: "<pretty><xml></xml></pretty>", path: "/ws/alpha/EnviarInstrucao/Unica"
+    }
+
+    HTTParty.stubs(:send).returns("<html>some_result</html>")
+    logger.expects(:info).at_least_once.
+      with(regexp_matches(/being sent to MoIP/))
+
+    request.api_call(params, logger: logger)
+  end
+
+  def test_logs_api_call_method_parameters_in_debug_level
+    logger = stub_everything
+    request = MyMoip::Request.new("request_id")
+    params = {
+      http_method: :post, body: "<pretty><xml></xml></pretty>", path: "/ws/alpha/EnviarInstrucao/Unica"
+    }
+
+    HTTParty.stubs(:send).returns("<html>some_result</html>")
+    logger.expects(:debug).at_least_once.
+      with(regexp_matches(/request_id.+<pretty><xml><\/xml><\/pretty>/))
+
+    request.api_call(params, logger: logger)
+  end
+
+  def test_logs_api_call_response_in_debug_level
+    logger = stub_everything
+    request = MyMoip::Request.new("request_id")
+    params = {
+      http_method: :post, body: "<pretty><xml></xml></pretty>", path: "/ws/alpha/EnviarInstrucao/Unica"
+    }
+
+    HTTParty.stubs(:send).returns("<html>some_result</html>")
+    logger.expects(:debug).at_least_once.
+      with(regexp_matches(/request_id.+<html>some_result<\/html>/))
+
+    request.api_call(params, logger: logger)
+  end
+
+  def test_raises_error_before_api_calls_without_a_key_set
+    subject = MyMoip::Request.new('request_id')
+    MyMoip.sandbox_key = nil
+    assert_raises StandardError do
+      subject.api_call({})
+    end
+    MyMoip.sandbox_key = ''
+    assert_raises StandardError do
+      subject.api_call({})
+    end
+  end
+
+  def test_raises_error_before_api_calls_without_a_token_set
+    subject = MyMoip::Request.new('request_id')
+    MyMoip.sandbox_token = nil
+    assert_raises StandardError do
+      subject.api_call({})
+    end
+    MyMoip.sandbox_token = ''
+    assert_raises StandardError do
+      subject.api_call({})
+    end
+  end
+end

data/test/lib/test_transparent_request.rb

@@ -0,0 +1,71 @@
+require_relative '../test_helper'
+
+class TestTransparentRequest < Test::Unit::TestCase
+  def test_http_method_as_post
+    assert_equal :post, MyMoip::TransparentRequest::HTTP_METHOD
+  end
+
+  def test_path
+    assert_equal "/ws/alpha/EnviarInstrucao/Unica", MyMoip::TransparentRequest::PATH
+  end
+
+  def test_auth_requirement
+    assert_equal true, MyMoip::TransparentRequest::REQUIRES_AUTH
+  end
+
+  def test_success_method_with_valid_json
+    HTTParty.stubs(:send).returns(
+      {"EnviarInstrucaoUnicaResponse"=>{"xmlns:ns1"=>"http://www.moip.com.br/ws/alpha/", "Resposta"=>{"ID"=>"201208081614306080000000928569", "Status"=>"Sucesso", "Token"=>"G290E1H230N8L0M8J1K6F1F4B3T0N610K8B0S0H0I0T0T0E029Y2R8H5Y6H9"}}}
+    )
+    request = MyMoip::TransparentRequest.new("some_id")
+    request_data = stub(to_xml: "<anydata></anydata>")
+    request.api_call request_data
+    assert request.success?
+  end
+
+  def test_success_method_with_failed_response
+    HTTParty.stubs(:send).returns(
+      {"EnviarInstrucaoUnicaResponse"=>{"xmlns:ns1"=>"http://www.moip.com.br/ws/alpha/", "Resposta"=>{"Status"=>"Falha"}}}
+    )
+    request = MyMoip::TransparentRequest.new("some_id")
+    request_data = stub(to_xml: "<anydata></anydata>")
+    request.api_call request_data
+    assert !request.success?
+  end
+
+  def test_success_method_with_requests_that_hasnt_be_made
+    request = MyMoip::TransparentRequest.new("some_id")
+    assert !request.success?
+  end
+
+  def test_provides_token_when_has_a_valid_response
+    HTTParty.stubs(:send).returns(
+      {"EnviarInstrucaoUnicaResponse"=>{"xmlns:ns1"=>"http://www.moip.com.br/ws/alpha/", "Resposta"=>{"ID"=>"201208081614306080000000928569", "Status"=>"Sucesso", "Token"=>"token"}}}
+    )
+    request = MyMoip::TransparentRequest.new("some_id")
+    request_data = stub(to_xml: "<anydata></anydata>")
+    request.api_call request_data
+    assert_equal "token", request.token
+  end
+
+  def test_provides_token_with_requests_that_hasnt_be_made
+    request = MyMoip::TransparentRequest.new("some_id")
+    assert_equal nil, request.token
+  end
+
+  def test_should_provide_the_transaction_id_get_by_the_request
+    request = MyMoip::TransparentRequest.new("some_id")
+    VCR.use_cassette('transparent_request') do
+      request.api_call(Fixture.instruction(payer: Fixture.payer))
+    end
+    assert_equal "201210171118501100000001102691", request.id
+  end
+
+  def test_should_provide_the_transaction_id_get_by_the_request_with_commissions_feature
+    request = MyMoip::TransparentRequest.new("some_id")
+    VCR.use_cassette('transparent_request_with_commissions') do
+      request.api_call Fixture.instruction(commissions: [Fixture.commission])
+    end
+    assert_equal "YOUR_REQUEST_ID", request.id
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,17 @@
+require 'test/unit'
+require 'mocha/setup'
+require 'vcr'
+
+VCR.configure do |c|
+  c.cassette_library_dir = 'test/fixtures/vcr_cassettes'
+  c.hook_into :webmock
+end
+
+require_relative 'live_test'
+require_relative 'fixtures/fixture'
+Dir[File.dirname(__FILE__) + "/lib/*.rb"].each { |file| require file }
+
+MyMoip.sandbox_key   = 'YOUR_MOIP_KEY'
+MyMoip.sandbox_token = 'YOUR_MOIP_TOKEN'
+MyMoip.logger = Logger.new('/dev/null')
+$VERBOSE = nil