nitro_pay 0.1.0 → 1.0.0

data/spec/nitro_pay/conversions_spec.rb

@@ -0,0 +1,36 @@
+=begin
+  require 'spec_helper'
+
+  describe 'Numeric conversions' do
+    describe 'BigDecimalBackup conversions' do
+      # setup it vars to have the conversion tested, value: 1999 (nineteen ninety nine)
+      pt_br = '1.999,00'
+      en_us = '1,999.00'
+
+      # Value like the card operator uses
+      operator_expected_value = '199900'
+      operator_value = '199900'
+      decimal_expected_value = BigDecimal.new '1999.00'
+
+      # it is the Rails conversion form the Form for Decimal input
+      decimal_obj_pt_br = BigDecimal.new(pt_br)
+      decimal_obj_en_us = BigDecimal.new(en_us.remove('.').remove(','))
+
+      # Conversions
+      pt_br_converted = Currency.to_operator_str decimal_obj_pt_br
+      en_us_converted = Currency.to_operator_str decimal_obj_en_us
+      decimal_converted = Currency.to_decimal operator_value
+
+      context 'Operator Format value' do
+
+      end
+
+      it 'should be running correctly' do
+        status = NitroPay::Status.new
+        expect(status.http_code).to equal(200)
+        expect(status.api_code).to equal(200)
+        expect(status.message).not_to be nil
+      end
+    end
+  end
+=end

data/spec/nitro_pay/currency_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+describe NitroPay::Currency do
+  describe 'Operator Format value' do
+    # setup it vars to have the conversion tested, value: 1999 (nineteen ninety nine)
+    pt_br = '1.999,00'
+    en_us = '1,999.00'
+    non_formatted = '199900'
+    non_formatted_with_cents = '199933'
+
+    # Values expected
+    cents_expected = '55'
+    non_cents_expected = '00'
+    operator_value = non_formatted
+    integer_value = non_formatted.to_i
+    operator_expected_value = '199900'
+    decimal_value = BigDecimal.new '1999.00'
+    operator_with_cents = '300055' # R$ 3.000,55
+    decimal_expected_value = BigDecimal.new '1999.00'
+    expected_float_unit_cents = '100005'
+    expected_float_decimal_cents = '100050'
+    expected_float_without_cents = '100000'
+
+    # Float values
+    float_with_cents = 1000.55
+    float_without_cents = 1000.00
+
+    float_unit_cents = 1000.05
+    float_decimal_cents = 1000.50
+
+    # Values Converted to operator format
+    non_cents_received = NitroPay::Currency.get_cents operator_value
+    decimal_converted = NitroPay::Currency.to_decimal operator_value
+    cents_received = NitroPay::Currency.get_cents operator_with_cents
+    pt_br_operator_converted = NitroPay::Currency.to_operator_str pt_br
+    en_us_operator_converted = NitroPay::Currency.to_operator_str en_us
+    integer_converted = NitroPay::Currency.to_operator_str integer_value
+    big_decimal_converted = NitroPay::Currency.to_operator_str decimal_value
+    non_formatted_converted = NitroPay::Currency.to_operator_str non_formatted
+    non_formatted_with_cents_converted = NitroPay::Currency.to_operator_str non_formatted_with_cents
+    float_unit_cents_conv = NitroPay::Currency.to_operator_str float_unit_cents
+    float_decimal_cents_conv = NitroPay::Currency.to_operator_str float_decimal_cents
+    float_without_cents_conv = NitroPay::Currency.to_operator_str float_without_cents
+
+    context 'Decimal to Operator' do
+      # Convert PT_BR
+      it 'PT_BR should be convertible' do
+        expect(pt_br_operator_converted).to be_a String
+        expect(pt_br_operator_converted.index('.')).to be_nil
+        expect(pt_br_operator_converted.index(',')).to be_nil
+        expect(pt_br_operator_converted).to be_integer
+        expect(pt_br_operator_converted).to be_equals operator_expected_value
+      end
+
+      # Convert EN_US
+      it 'EN_US should be convertible' do
+        expect(en_us_operator_converted).to be_a String
+        expect(en_us_operator_converted.index('.')).to be_nil
+        expect(en_us_operator_converted.index(',')).to be_nil
+        expect(en_us_operator_converted).to be_integer
+        expect(en_us_operator_converted).to be_equals operator_expected_value
+      end
+
+      # To operator passing a BigDecimal instance
+      it 'should have a Operator format based on BigDecimal instance' do
+        expect(big_decimal_converted).to be_a String
+        expect(big_decimal_converted.index('.')).to be_nil
+        expect(big_decimal_converted.index(',')).to be_nil
+        expect(big_decimal_converted).to be_integer
+        expect(big_decimal_converted).to be_equals operator_expected_value
+      end
+    end
+
+    context 'Integer to Operator' do
+      it 'should have a Operator format based on Integer instance' do
+        expect(integer_converted).to be_a String
+        expect(integer_converted.index('.')).to be_nil
+        expect(integer_converted.index(',')).to be_nil
+        expect(integer_converted).to be_integer
+        expect(integer_converted).to be_equals operator_expected_value
+      end
+    end
+
+    context 'Float to Operator' do
+      it 'unit cents con must be on Operator format' do
+        expect(float_unit_cents_conv).to be == expected_float_unit_cents
+      end
+
+      it 'decimal cents con must be on Operator format' do
+        expect(float_decimal_cents_conv).to be == expected_float_decimal_cents
+      end
+
+      it 'no cents must be an Operator format' do
+        expect(float_without_cents_conv).to be == expected_float_without_cents
+      end
+    end
+
+    context 'Operator to Decimal' do
+      # Convert from the operator to BigDecimal instance, like rails does/need
+      it 'should be the BigDecimal expected' do
+        expect(decimal_converted).to be_a BigDecimal
+        expect(decimal_converted).to be == decimal_expected_value.to_i
+      end
+    end
+
+    context 'Non-formatted value to operator' do
+      context 'without cents' do
+        it 'must be the same as received' do
+          expect(non_formatted_converted).to be == non_formatted
+        end
+
+        it 'cents must be the same' do
+          expect(NitroPay::Currency.get_cents(non_formatted_converted)).to be == NitroPay::Currency.get_cents(non_formatted)
+        end
+      end
+
+      context 'with cents' do
+        it 'must be the same as received' do
+          expect(non_formatted_with_cents_converted).to be == non_formatted_with_cents
+        end
+
+        it 'cents must be the same' do
+          expect(NitroPay::Currency.get_cents(non_formatted_with_cents_converted)).to be == NitroPay::Currency.get_cents(non_formatted_with_cents)
+        end
+      end
+    end
+
+    context 'Methods to work in operator format' do
+      it 'should retrieve existent cents' do
+        expect(cents_received).to be_equals cents_expected
+      end
+
+      it 'should retrieve the non existent cents' do
+        expect(non_cents_received).to be_equals non_cents_expected
+      end
+
+      it 'should have cents' do
+        expect(NitroPay::Currency.have_cents?(operator_with_cents)).to be_truthy
+      end
+
+      it 'should not have cents' do
+        expect(NitroPay::Currency.have_cents?(operator_value)).to_not be_truthy
+      end
+
+      it '(RECEIVING FLOAT) should have cents' do
+        expect(NitroPay::Currency.have_cents?(float_with_cents)).to be_truthy
+      end
+
+      it '(RECEIVING FLOAT) should not have cents' do
+        expect(NitroPay::Currency.have_cents?(float_without_cents)).to_not be_truthy
+      end
+    end
+  end
+end

data/spec/nitro_pay/status_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe NitroPay::Status do
+  describe 'API' do
+    it 'should be running correctly' do
+      NitroPay.debug=true
+      NitroPay.test_env=true
+
+      status = NitroPay::Status.new
+      expect(status.http_code).to equal(200)
+      expect(status.api_code).to equal(200)
+      expect(status.message).not_to be nil
+    end
+  end
+end

data/spec/nitro_pay/transaction_spec.rb

@@ -0,0 +1,584 @@
+require 'spec_helper'
+
+describe NitroPay::Transaction do
+  before(:all) do
+    @protocol = 'http://'
+    @domain = 'pay.dev:4000'
+    @base_url = "#{@protocol}#{@domain}"
+    @global_subscription_rid = get_json("#{@base_url}/api/v1/global_subscription")[:rid]
+  end
+
+  context 'Proxy' do
+    it 'should validate the proxy' do
+      uncomment_proxy_yml
+      expect(NitroPay.proxy).to_not be_nil
+      comment_proxy_yml
+    end
+  end
+
+  context 'BuyStorePage' do
+    # correct Request/Params
+    context 'SUCCESS' do
+      context 'Denied request' do
+        # Denying a subscription update
+        describe 'Update recurrent subscription DENIED' do
+          # ================    SetUp/Config    ================
+          before(:all) do
+            NitroPay.debug=true
+            NitroPay.test_env=false
+
+            NitroPay.app_id = 1
+            NitroPay.secret_key = '12312321312$2a$10$NmV9EysKVLe8ItBdl9CHN.LF05bOuDdoOkmfptdbJs7cuaDWksuUu'
+
+            # Force the amount to be random & to be exact
+            amount = Random.rand(99999).to_s
+            @amount = "#{amount}00" if amount[amount.length-2, amount.length] != '00'
+            @amount = @amount.to_i
+            @recurrence_period = NitroPay.enum[:recurrence_periods][:monthly]
+
+            # Test passing no RID & passing specific RID
+            transaction_params = {rid: 1, amount: @amount, recurrence_period: @recurrence_period}
+            @transaction = NitroPay::Transaction.new transaction_params
+
+            # Send subscription update
+            @subscription_update_resp = @transaction.update_subscription
+            @subscription_update_full_resp = @transaction.update_subscription nil, true
+          end
+
+          it 'should be Hash' do
+            expect(@subscription_update_resp).to be_a Hash
+          end
+
+          it 'should not have an error' do
+            expect(@subscription_update_resp).to include :error
+          end
+
+          it 'should resp with SUCCESS (200)' do
+            expect(@subscription_update_full_resp.code).to eq(http_success)
+          end
+        end
+
+        # Denying an unsubscribe
+        describe 'Unsubscribe denied' do
+          # ================    SetUp/Config    ================
+          before(:all) do
+            NitroPay.debug=true
+            NitroPay.test_env=false
+
+            NitroPay.app_id = 1
+            NitroPay.secret_key = '12312321312$2a$10$NmV9EysKVLe8ItBdl9CHN.LF05bOuDdoOkmfptdbJs7cuaDWksuUu'
+
+            # Test passing no RID & passing specific RID
+            @transaction_with_rid = NitroPay::Transaction.new rid: 1
+
+            # Send Unsubscribe
+            @rid_transaction_resp = @transaction_with_rid.unsubscribe
+            @transaction_full_resp = @transaction_with_rid.unsubscribe nil, true
+          end
+
+          it 'should be Hash' do
+            expect(@rid_transaction_resp).to be_a Hash
+          end
+
+          it 'should not have an error' do
+            expect(@rid_transaction_resp).to include :error
+          end
+
+          it 'should resp with SUCCESS (200)' do
+            expect(@transaction_full_resp.code).to eq(http_success)
+          end
+        end
+      end
+
+      context 'Permitted request' do
+        # OK StorePage tests
+        describe 'Transaction charged' do
+          # ================    SetUp/Config    ================
+          before(:all) do
+            NitroPay.debug=true
+            NitroPay.test_env=true
+
+            #  To test it as CAPTURED it mustn't have cents or invalid credit card number!?
+            amount = Random.rand(99999).to_s
+            amount = "#{amount}00" if amount[amount.length-2, amount.length] != '00'
+
+            # Forcing formatted amount to check if the GEM is sending it with Operator format
+            amount.insert amount.length-2, ','
+
+            @store_transaction = NitroPay::Transaction.new({
+              card:{
+                brand: 'visa',
+                cvv: '123',
+                expiration_month: '05',
+                expiration_year: '2018',
+                number: '4012001037141112',
+                holder: Faker::Name.name,
+              },
+
+              amount: amount
+            })
+
+            # Fake SoldItems added
+            @store_transaction.sold_items = fake_sold_items
+
+            # Send StoreCharge
+            @resp = @store_transaction.charge_store
+          end
+
+          # ================    Tests/Expects/Should   ================
+          it 'resp should not be null' do
+            expect(@resp).to_not be_nil
+          end
+
+          it 'resp should contain the RequestID' do
+            request_id = @resp[:request_id]
+            expect(request_id).to_not be_nil
+            expect(request_id).to be_a Integer
+          end
+
+          it 'resp should have a full SUCCESSFUL transaction status' do
+            status = @resp[:status]
+            expect(status[:name]).to eq('charged')
+            expect(status[:code]).to eq(6) # TODO change it to ENUM
+            expect(status[:msg].index('Capturada').nil?).to_not be_truthy
+          end
+
+          it 'resp should have a full CardObj which is allowed to be stored {:rid, :truncated, :brand}' do
+            card = @resp[:card]
+            expect(card[:rid]).to be_a Integer
+            expect(card[:rid] == 0).to_not be_truthy
+            expect(card[:brand]).to eq('visa')
+            expect(card[:truncated].index('***')).to_not be_nil
+          end
+
+          it 'resp should have the remote reference (TransactionRID)' do
+            rid = @resp[:rid]
+            expect(rid).to_not be_nil
+            expect(rid).to be_a Integer
+            expect(rid != 0).to be_truthy
+          end
+        end
+
+        # TRANSACTION DENIED example
+        describe 'Transaction denied' do
+          # ================    SetUp/Config    ================
+          before(:all) do
+            NitroPay.debug=true
+            NitroPay.test_env=true
+
+            #  To test it as DENIED it must have cents or invalid credit card number!?
+            amount = Random.rand(99999).to_s
+            amount = "#{amount}71" if amount[amount.length-2, amount.length] == '00'
+
+            @store_transaction = NitroPay::Transaction.new({
+              card:{
+                brand: 'visa',
+                cvv: '321',
+                expiration_month: '05',
+                expiration_year: '2018',
+                number: '9999999999999999',
+                holder: Faker::Name.name,
+              },
+              recurrence_period_id: NitroPay.enum[:recurrence_periods][:daily],
+              amount: amount
+            })
+
+            # Fake SoldItems added
+            @store_transaction.sold_items = fake_sold_items
+
+            # Send StoreCharge
+            @resp = @store_transaction.charge_store
+          end
+
+          # ================    Tests/Expects/Should   ================
+          it 'resp should not be null' do
+            expect(@resp).to_not be_nil
+          end
+
+          it 'resp should contain the RequestID' do
+            request_id = @resp[:request_id]
+            expect(request_id).to_not be_nil
+            expect(request_id).to be_a Integer
+          end
+
+          it 'resp should have a full SUCCESSFUL transaction status' do
+            status = @resp[:status]
+            expect(status[:name]).to eq('error')
+            expect(status[:code]).to eq(5) # TODO change it to ENUM
+            expect(status[:msg].index('não').nil?).to_not be_truthy
+          end
+
+          it 'resp should have a full CardObj which is allowed to be stored {:rid, :truncated, :brand}' do
+            card = @resp[:card]
+            expect(card[:rid]).to be_nil
+            expect(card[:brand]).to eq('visa')
+            expect(card[:truncated].index('***')).to_not be_nil
+          end
+
+          it 'resp should have the remote reference (TransactionRID)' do
+            rid = @resp[:rid]
+            expect(rid).to_not be_nil
+            expect(rid).to be_a Integer
+            expect(rid != 0).to be_truthy
+          end
+        end
+
+        # Create a Subscription (Recurrent charges)
+        describe 'Sign a recurrent subscription' do
+          # ================    SetUp/Config    ================
+          before(:all) do
+            NitroPay.debug=true
+            NitroPay.test_env=true
+
+            #  To test it as CAPTURED it mustn't have cents or invalid credit card number!?
+            amount = Random.rand(99999).to_s
+            amount = "#{amount}00" if amount[amount.length-2, amount.length] != '00'
+
+            @store_transaction = NitroPay::Transaction.new({
+              card:{
+                brand: 'visa',
+                cvv: '123',
+                expiration_month: '05',
+                expiration_year: '2018',
+                number: '4012001037141112',
+                holder: Faker::Name.name
+              },
+              recurrence_period_id: NitroPay.enum[:recurrence_periods][:daily],
+              amount: amount
+            })
+
+            # Fake SoldItems added
+            @store_transaction.sold_items = fake_sold_items
+
+            # Send StoreCharge
+            @resp = @store_transaction.charge_store
+          end
+
+          # ================    Tests/Expects/Should   ================
+          it 'resp should not be null' do
+            expect(@resp).to_not be_nil
+          end
+
+          it 'resp should contain the RequestID' do
+            request_id = @resp[:request_id]
+            expect(request_id).to_not be_nil
+            expect(request_id).to be_a Integer
+          end
+
+          it 'resp should have a full SUCCESSFUL transaction status' do
+            status = @resp[:status]
+            expect(status[:name]).to eq('charged')
+            expect(status[:code]).to eq(6) # TODO change it to ENUM
+            expect(status[:msg].index('Capturada').nil?).to_not be_truthy
+          end
+
+          it 'resp should have a full CardObj which is allowed to be stored {:rid, :truncated, :brand}' do
+            card = @resp[:card]
+            expect(card[:rid]).to be_a Integer
+            expect(card[:rid] == 0).to_not be_truthy
+            expect(card[:brand]).to eq('visa')
+            expect(card[:truncated].index('***')).to_not be_nil
+          end
+
+          it 'resp should have the remote reference (TransactionRID)' do
+            rid = @resp[:rid]
+            expect(rid).to_not be_nil
+            expect(rid).to be_a Integer
+            expect(rid != 0).to be_truthy
+          end
+        end
+
+        # Update a Subscription (Recurrent charges updated)
+        describe 'Update the recurrent subscription AMOUNT' do
+          # ================    SetUp/Config    ================
+          before(:all) do
+            NitroPay.debug=true
+            NitroPay.test_env=true
+
+            # Force the amount to be random & to be exact
+            amount = Random.rand(99999).to_s
+            @amount = "#{amount}00" if amount[amount.length-2, amount.length] != '00'
+            @amount = @amount.to_i
+            @recurrence_period = NitroPay.enum[:recurrence_periods][:monthly]
+
+            # Test passing no RID & passing specific RID
+            transaction_params = {amount: @amount, recurrence_period: @recurrence_period}
+            @empty_transaction = NitroPay::Transaction.new transaction_params
+            transaction_params[:rid] = @global_subscription_rid
+            @transaction_with_rid = NitroPay::Transaction.new transaction_params
+
+            # Send subscription update
+            @empty_transaction_resp = @empty_transaction.update_subscription
+            @rid_transaction_resp = @transaction_with_rid.update_subscription
+          end
+
+          it 'should be Hash' do
+            expect(@empty_transaction_resp).to be_a Hash
+            expect(@rid_transaction_resp).to be_a Hash
+          end
+
+          it 'should be performed the unsubscribe' do
+            # SetUpVars
+            empty_subscription_resp = @empty_transaction_resp[:subscription]
+            resp_amount = empty_subscription_resp[:amount]
+            resp_recurrence_period = empty_subscription_resp[:recurrence_period]
+
+            # test those attrs
+            expect(resp_amount).to eq(@amount)
+            expect(resp_recurrence_period).to eq(@recurrence_period)
+
+            # SetUpVars
+            rid_subscription_resp = @rid_transaction_resp[:subscription]
+            resp_amount = rid_subscription_resp[:amount]
+            resp_recurrence_period = rid_subscription_resp[:recurrence_period]
+
+            # test those attrs
+            expect(resp_amount).to eq(@amount)
+            expect(resp_recurrence_period).to eq(@recurrence_period)
+          end
+
+          it 'should not have any error' do
+            expect(@empty_transaction_resp).to_not include :error
+            expect(@rid_transaction_resp).to_not include :error
+          end
+        end
+
+        # Unsubscribe a recurrence payment / signature
+        describe 'Unsubscribe a recurrent subscription' do
+          # ================    SetUp/Config    ================
+          before(:all) do
+            NitroPay.debug=true
+            NitroPay.test_env=true
+
+            # Test passing no RID & passing specific RID
+            @empty_transaction = NitroPay::Transaction.new
+            @transaction_with_rid = NitroPay::Transaction.new rid: @global_subscription_rid
+
+            # Send Unsubscribe
+            @empty_transaction_resp = @empty_transaction.unsubscribe
+            @rid_transaction_resp = @transaction_with_rid.unsubscribe
+          end
+
+          it 'should be Hash' do
+            expect(@empty_transaction_resp).to be_a Hash
+            expect(@rid_transaction_resp).to be_a Hash
+          end
+
+          it 'should be performed the unsubscribe' do
+            expect(@empty_transaction_resp[:did_unsubscribe]).to be_truthy
+            expect(@rid_transaction_resp[:did_unsubscribe]).to be_truthy
+          end
+
+          it 'should not have any error' do
+            expect(@empty_transaction_resp).to_not include :error
+            expect(@rid_transaction_resp).to_not include :error
+          end
+        end
+
+        # Should return all the bank transaction payments done
+        describe 'Subscription payment history' do
+          # ================    SetUp/Config    ================
+          before(:all) do
+            NitroPay.debug=true
+            NitroPay.test_env=true
+
+            # Test passing no RID & passing specific RID
+            @transaction = NitroPay::Transaction.new
+
+            # Send Unsubscribe
+            @transaction_resp = @transaction.payment_history
+          end
+
+          it 'should be an array' do
+            expect(@transaction_resp).to be_a Array
+          end
+
+          it 'should not have any error' do
+            expect(@transaction_resp.first).to_not include :error
+          end
+
+          it 'should have the valid bank_transactions_payment format on it array' do
+            transaction = @transaction_resp.first
+            valid_keys = [
+                :amount, :active, :brand,
+                :currency_iso, :status_code, :status_message,
+                :next_transaction_at, :created_at, :updated_at
+            ]
+
+            valid_keys.each {|key| expect(transaction[key]).to_not be_nil}
+          end
+        end
+
+        # Should retrieve it only bank transaction done
+        describe 'Non-subscription payment history' do
+          # ================    SetUp/Config    ================
+          before(:all) do
+            NitroPay.debug=true
+            NitroPay.test_env=true
+
+            # Test passing no RID & passing specific RID
+            global_sample_transaction = get_json("#{@base_url}/api/v1/global_sample_transaction")
+            @transaction = NitroPay::Transaction.new rid: global_sample_transaction[:id]
+
+            # Send Unsubscribe
+            @transaction_resp = @transaction.payment_history
+          end
+
+          it 'should be a simple hash' do
+            expect(@transaction_resp).to be_a Hash
+          end
+
+          it 'should not have any error' do
+            expect(@transaction_resp).to_not include :error
+          end
+
+          it 'should have the valid bank_transactions_payment format' do
+            valid_keys = [
+                :amount, :active, :brand,
+                :currency_iso, :status_code, :status_message,
+                :created_at, :updated_at
+            ]
+
+            invalid_keys = [
+                :next_transaction_at, :recurrence_period_id
+            ]
+
+            valid_keys.each {|key| expect(@transaction_resp[key]).to_not be_nil}
+            invalid_keys.each {|key| expect(@transaction_resp[key]).to be_nil}
+          end
+        end
+
+        # Check if a subscription is up-to-date
+        describe 'Up-to-date subscription' do
+          # ================    SetUp/Config    ================
+          before(:all) do
+            NitroPay.debug=true
+            NitroPay.test_env=true
+
+            # Test passing no RID & passing specific RID
+
+            @transaction = NitroPay::Transaction.new
+
+            # Send Unsubscribe
+            @transaction_resp = @transaction.up_to_date
+          end
+
+          it 'should be Hash' do
+            expect(@transaction_resp).to be_a Hash
+          end
+
+          it 'should be up-to-date with success message' do
+            expect(@transaction_resp[:success]).to_not be_nil
+          end
+
+          it 'should not have any error' do
+            expect(@transaction_resp).to_not include :error
+          end
+        end
+
+        # Check if a subscription is up-to-date
+        describe 'Subscription PENDING payment, not up-to-date' do
+          # ================    SetUp/Config    ================
+          before(:all) do
+            NitroPay.debug=true
+            NitroPay.test_env=true
+
+            # Test pending subscription payment passing specific RID
+            @global_pending_subscription = get_json("#{@base_url}/api/v1/global_pending_subscription")
+            @transaction_with_rid = NitroPay::Transaction.new rid: @global_pending_subscription[:id]
+
+            # Send Unsubscribe
+            @rid_transaction_resp = @transaction_with_rid.up_to_date
+          end
+
+          it 'should be Hash' do
+            expect(@rid_transaction_resp).to be_a Hash
+          end
+
+          it 'should not have any error' do
+            expect(@rid_transaction_resp).to_not include :error
+          end
+
+          it 'should have the subscription' do
+            expect(@rid_transaction_resp[:subscription]).to_not be_nil
+          end
+        end
+      end
+    end
+
+    # incorrect Request/Params
+    context 'BAD REQUEST' do
+      # NOT_OK on the authentication Store Page tests
+      describe 'Authentication failing' do
+        # SetUp/Config
+        before(:all) do
+          NitroPay.debug = true
+          NitroPay.test_env = false
+          NitroPay.app_id = 1
+          NitroPay.secret_key = '12312321312$2a$10$NmV9EysKVLe8ItBdl9CHN.LF05bOuDdoOkmfptdbJs7cuaDWksuUu'
+
+          amount = Random.rand(99999).to_s
+          amount = "#{amount}00" if amount[amount.length-2, amount.length] != '00'
+
+          @store_transaction = NitroPay::Transaction.new({
+              card:{
+                brand: 'visa',
+                cvv: '321',
+                expiration_month: '05',
+                expiration_year: '2018',
+                number: '9999999999999999',
+                holder: Faker::Name.name,
+              },
+
+              amount: amount
+          })
+
+          # Fake SoldItems added
+          @store_transaction.sold_items = fake_sold_items
+
+          # Send StoreCharge
+          @resp = @store_transaction.charge_store
+        end
+
+        # ================    Tests/Expects/Should   ================
+        it 'resp should exist (do not be empty)' do
+          expect(@resp).to_not be_nil
+        end
+
+        it 'resp should contain the RequestID' do
+          request_id = @resp[:request_id]
+          expect(request_id).to_not be_nil
+          expect(request_id).to be_a Integer
+        end
+
+        it 'resp should contain auth error' do
+          error = @resp[:error].downcase
+          expect(error).to_not be_nil
+          expect(error.index('auth error').nil?).to_not be_truthy
+          expect(error.index('AppID'.downcase).nil?).to_not be_truthy
+          expect(error.index('SecretKey'.downcase).nil?).to_not be_truthy
+        end
+      end
+    end
+  end
+
+  context 'Remote sample connection test' do
+    before(:all) do
+      NitroPay.debug=false
+      NitroPay.test_env=false
+      @remote = NitroPay::Status.new
+    end
+
+    it 'must have a JSON response' do
+      expect(@remote.response).to be_a Hash
+    end
+
+    it 'must have a message' do
+      expect(@remote.message).to be_a String
+    end
+
+    it 'must have an API code' do
+      expect(@remote.api_code).to be_a Integer
+    end
+  end
+end