nmi_direct_post 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d376bc5d9401a3274444f713f3ef40f04a4a41e3
-  data.tar.gz: 383d6fb624a33d30f1121904b76c5b77eb0af761
+  metadata.gz: 8a7f96e99aff57d1745c1e1b1cd90619eca8d45b
+  data.tar.gz: 7b5faf05b492e67293278a702f1f8832e1ba617a
 SHA512:
-  metadata.gz: d40ddf52eceb8174336a6b9675d8a3a0e7161135cbdaed6effd7c1a361c54ebcb84432e08391a9b8829ffed9dd366401123cd750ecbe488e5b9cccf13b77e8a4
-  data.tar.gz: 9ac20fafa098b00e4069d05b994f0d15175033cd6b7408c617c10cd32e0318f1c6984039db20d95606fdb7375803c5413bef446914629ef29d74120cd3a53229
+  metadata.gz: a5584f91061e4ebf5d372a96efc7f2ca061134fc79b9e5c6c130e9220573c7bd978416e88f769038fbab0f7f391cea24cea9e0bf752d49032b9f0a3a4c2f6701
+  data.tar.gz: b5c1bb5556057f1df9acae2bf22b2b1ed462275e81c52ea811150cc365e1425b0f650746b7a35a044624e14071f0439add3b0a406184bba4455996ddec6d7084

data/README.md

@@ -22,17 +22,21 @@ Or install it yourself as:
 
 ## Usage
 
-1) Before you can query or post, establish the connection:
+1) Before you query or post, you probably want to set a default username and password:
 
     NmiDirectPost::Base.establish_connection("MY_NMI_USERNAME", "MY_NMI_PASSWORD")
 
+If you don't set a default, you'll need to include the username and password in the hash passed to the initializer when instantiating a new Transaction or CustomerVault.
+
 Theoretically, you can use a different connection for NmiDirectPost::Transaction or NmiDirectPost::CustomerVault by calling establish_connection on either of those derived classes, instead of on Base.
 However, it's hard to imagine a case where this would be useful; the option is only present to mimic the syntax of ActiveRecord.
 
 2) Query the API:
 
-    NmiDirectPost::Transaction.find_by_transaction_id(123456789)
-    NmiDirectPost::CustomerVault.find_by_customer_vault_id(123123123)
+    NmiDirectPost::Transaction.find_by_transaction_id(123456789, "MyUsername", "MyPassword")
+    NmiDirectPost::Transaction.find_by_transaction_id(123456789) # If you've already called establish_connection
+
+    NmiDirectPost::CustomerVault.find_by_customer_vault_id(123123123) # Note that there is no way to pass a username and password to this method.  You must call establish_connection beforehand.
 
 3) Create a CustomerVault:
 
@@ -69,6 +73,8 @@ However, it's hard to imagine a case where this would be useful; the option is o
     NmiDirectPost::CustomerVault.last
     NmiDirectPost::CustomerVault.all # Returns very, very big array.  This method had very poor performance and could be optimized significantly in a future version of this gem.
 
+    Note that there is no way to pass a username and password to these methods.  You must call establish_connection beforehand.
+
 8) Create a Transaction:
 
     parking_ticket = NmiDirectPost::Transaction(:type => :sale, :amount => 150.01, :customer_vault_id => george.customer_vault_id)

data/lib/nmi_direct_post/base.rb

@@ -28,8 +28,9 @@ module NmiDirectPost
     include ActiveModel::Conversion
     validates_presence_of :username, :password
 
-    def initialize
-      @username, @password = self.class.username, self.class.password
+    def initialize(attributes)
+      @username = attributes[:username] || attributes["username"] || self.class.username
+      @password = attributes[:password] || attributes["password"] || self.class.password
     end
 
     def persisted?
@@ -80,7 +81,7 @@ module NmiDirectPost
           url = URI.parse(uri)
           http = Net::HTTP.new(url.host, url.port)
           http.use_ssl = true
-          http.ssl_version = :TLSv1
+          http.ssl_version = :TLSv1_2
           http.verify_mode = OpenSSL::SSL::VERIFY_PEER
           http.request(request)
         end

data/lib/nmi_direct_post/customer_vault.rb

@@ -39,7 +39,7 @@ module NmiDirectPost
         :if => Proc.new { |record| :add_customer == record.customer_vault }
 
     def initialize(attributes)
-      super()
+      super
       if attributes[:customer_vault_id].blank?
         set_attributes(attributes.dup) unless attributes.empty?
       else
@@ -84,7 +84,7 @@ module NmiDirectPost
       begin
         safe_params = customer_vault_instance_params
         logger.debug { "Loading NMI customer vault from customer_vault_id(#{customer_vault_id}) using query: #{safe_params}" }
-        response = self.class.get(self.class.all_params(safe_params))["customer_vault"]
+        response = self.class.get(self.class.all_params(safe_params, self))["customer_vault"]
         raise CustomerVaultNotFoundError, "No record found for customer vault ID #{self.customer_vault_id}" if response.nil?
         attributes = response["customer"].with_indifferent_access
         READ_ONLY_ATTRIBUTES.each do |a|
@@ -115,7 +115,7 @@ module NmiDirectPost
         @report_type = :customer_vault
         safe_params = generate_query_string(MERCHANT_DEFINED_FIELDS + [:last_name, :email, :report_type]) # These are the only fields you can use when looking up without a customer_vault_id
         logger.info { "Querying NMI customer vault: #{safe_params}" }
-        @customer_vault_id = self.class.get(self.class.all_params(safe_params))['customer_vault'][0]['customer_vault_id'] # This assumes there is only 1 result.
+        @customer_vault_id = self.class.get(self.class.all_params(safe_params, self))['customer_vault'][0]['customer_vault_id'] # This assumes there is only 1 result.
         # TODO: When there are multiple results, we don't know which one you want.  Maybe raise an error in that case?
         reload
       ensure
@@ -126,10 +126,10 @@ module NmiDirectPost
     class << self
       attr_reader :report_type
 
-      def find_by_customer_vault_id(customer_vault_id)
+      def find_by_customer_vault_id(customer_vault_id, username=nil, password=nil)
         raise StandardError, "CustomerVaultID cannot be blank" if customer_vault_id.blank?
         begin
-          new(:customer_vault_id => customer_vault_id)
+          new(customer_vault_id: customer_vault_id, username: username, password: password)
         rescue CustomerVaultNotFoundError
           return nil
         end
@@ -161,8 +161,8 @@ module NmiDirectPost
         limit
       end
 
-      def all_params(safe_params)
-        [safe_params, generate_query_string(Base::AUTH_PARAMS)].join('&')
+      def all_params(safe_params, target=self)
+        [safe_params, generate_query_string(Base::AUTH_PARAMS, target)].join('&')
       end
 
       private
@@ -178,7 +178,7 @@ module NmiDirectPost
 
       def post(safe_params)
         logger.info { "Sending Direct Post to NMI: #{safe_params}" }
-        response = self.class.post(self.class.all_params(safe_params))
+        response = self.class.post(self.class.all_params(safe_params, self))
         @response, @response_text, @response_code = response["response"].to_i, response["responsetext"], response["response_code"].to_i
         @customer_vault_id = response["customer_vault_id"].to_i if :add_customer == self.customer_vault
       end

data/lib/nmi_direct_post/transaction.rb

@@ -25,7 +25,7 @@ module NmiDirectPost
     validate :save_successful?, :unless => 'response_text.blank?'
 
     def initialize(attributes)
-      super()
+      super
       @type, @amount = attributes[:type].to_s, attributes[:amount].to_f
       @transaction_id = attributes[:transaction_id].to_i if attributes[:transaction_id]
       @customer_vault_id = attributes[:customer_vault_id].to_i if attributes[:customer_vault_id]
@@ -34,8 +34,13 @@ module NmiDirectPost
     end
 
     def save
-      void! if ('void' == type && condition.blank?)
-      return false if self.invalid?
+      return false if invalid?
+      if condition.blank?
+        if 'void' == type
+          reload
+          @type = 'void'
+        end
+      end
       _safe_params = safe_params
       logger.info { "Sending Direct Post Transaction to NMI: #{_safe_params}" }
       post([_safe_params, transaction_params].join('&'))
@@ -74,11 +79,6 @@ module NmiDirectPost
 
     def void!
       @type='void'
-      if condition.blank?
-        return false if invalid?
-        reload
-        @type = 'void'
-      end
       save
     end
 

data/lib/nmi_direct_post/version.rb

@@ -1,3 +1,3 @@
 module NmiDirectPost
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/nmi_direct_post.gemspec

@@ -25,6 +25,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "simplecov"
 
   spec.add_dependency 'addressable'
-  spec.add_dependency 'activemodel'
-  spec.add_dependency 'activesupport', ' >= 3.0'
+  spec.add_dependency 'activemodel', '>= 4.0'
 end

data/spec/base_spec.rb

@@ -34,4 +34,8 @@ describe NmiDirectPost::Base do
     NmiDirectPost::CustomerVault.establish_connection(credentials.nmi_username, credentials.nmi_password)
     expect{a_query}.to_not raise_error
   end
+  it "should allow the record to set its own username/password" do
+    a_query = ->{ NmiDirectPost::CustomerVault.find_by_customer_vault_id(a_cc_customer_vault_id, "ABC", "DEF") }
+    expect(a_query).not_to raise_error
+  end
 end

data/spec/transaction_spec.rb

@@ -4,153 +4,151 @@ require_relative 'spec_helper'
 describe NmiDirectPost::Transaction do
   let(:a_cc_customer_vault_id) { TestCredentials::INSTANCE.cc_customer }
   let(:a_checking_account_customer_vault_id) { TestCredentials::INSTANCE.ach_customer }
-  let(:amount) { lambda { @amount_generator.rand(50..500) } }
+  let(:amount) { Random.rand(50.0..500.0).round(2) }
+  let(:credentials) { TestCredentials::INSTANCE }
+  let(:cc_implicit_sale) { NmiDirectPost::Transaction.new(customer_vault_id: a_cc_customer_vault_id, amount: amount) }
+  let(:ach_implicit_sale) { NmiDirectPost::Transaction.new(customer_vault_id: a_checking_account_customer_vault_id, amount: amount) }
+  let(:cc_validation) { NmiDirectPost::Transaction.new(customer_vault_id: a_cc_customer_vault_id, amount: 0, type: :validate) }
 
-  before :all do
-    credentials = TestCredentials::INSTANCE
+  before(:each) do
     NmiDirectPost::Base.establish_connection(credentials.nmi_username, credentials.nmi_password)
-    @amount_generator = Random.new
-  end
-
-  def given_a_sale_for_customer_vault_id customer_vault_id
-    @transaction = NmiDirectPost::Transaction.new(:customer_vault_id => customer_vault_id, :amount => amount.call)
-    expect(@transaction.save).to eq(true), "Transaction failed to save for the following reasons: #{@transaction.errors.messages.inspect}"
-  end
-
-  def expect_response_to_be response, response_code
-    expect(@transaction.response).to eq(response), @transaction.inspect
-    expect(@transaction.response_code).to eq(response_code), @transaction.inspect
-  end
-
-  def if_the_transaction_succeeds
-    expect(@transaction.response).to eq(1), @transaction.inspect
-  end
-
-  def it_should_find_the_transaction
-    @queried_transaction = NmiDirectPost::Transaction.find_by_transaction_id(@transaction.transaction_id)
-    expect(@queried_transaction).not_to be_nil
-    expect(@queried_transaction.amount).to eq @transaction.amount
-    expect(@queried_transaction.customer_vault_id).to eq @transaction.customer_vault_id
-    expect(@queried_transaction.customer_vault).not_to be_nil
-    expect(@queried_transaction.customer_vault.first_name).to eq(@transaction.customer_vault.first_name)
   end
 
   it "should allow saving with a bang" do
-    @transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_cc_customer_vault_id, :amount => amount.call)
-    expect{@transaction.save!}.not_to raise_error
+    expect{cc_implicit_sale.save!}.not_to raise_error
   end
 
   it "should fail validation when no customer_vault_id and no transaction_id are given" do
-    @transaction = NmiDirectPost::Transaction.new(:amount => amount.call)
-    expect{@transaction.save!}.to raise_error(NmiDirectPost::TransactionNotSavedError)
+    transaction = NmiDirectPost::Transaction.new(amount: amount)
+    expect{transaction.save!}.to raise_error(NmiDirectPost::TransactionNotSavedError)
   end
 
   it "should respond with a success code when given a valid customer_vault_id" do
-    given_a_sale_for_customer_vault_id a_cc_customer_vault_id
-    expect_response_to_be 1, 100
-    expect(@transaction.response_text).to eq("SUCCESS"), @transaction.inspect
-    expect(@transaction).to be_success, @transaction.inspect
+    expect(cc_implicit_sale.save).to eq(true), "Transaction failed to save for the following reasons: #{cc_implicit_sale.errors.messages.inspect}"
+    expect(cc_implicit_sale.response).to eq(1), cc_implicit_sale.inspect
+    expect(cc_implicit_sale.response_code).to eq(100), cc_implicit_sale.inspect
+    expect(cc_implicit_sale.response_text).to eq("SUCCESS"), cc_implicit_sale.inspect
+    expect(cc_implicit_sale).to be_success, cc_implicit_sale.inspect
   end
 
   it "should fail validation when given an invalid customer_vault_id" do
-    @transaction = NmiDirectPost::Transaction.new(:customer_vault_id => 1000, :amount => amount.call)
-    expect(@transaction.save).to eq(false)
-    expect(@transaction.errors.size).to eq(1)
-    expect(@transaction.errors[:customer_vault].size).to eq(1)
-    expect(@transaction.errors[:customer_vault]).to include("Customer vault with the given customer_vault could not be found")
+    transaction = NmiDirectPost::Transaction.new(customer_vault_id: 1000, amount: amount)
+    expect(transaction.save).to eq(false)
+    expect(transaction.errors.size).to eq(1)
+    expect(transaction.errors[:customer_vault].size).to eq(1)
+    expect(transaction.errors[:customer_vault]).to include("Customer vault with the given customer_vault could not be found")
   end
 
-  it "should find a sale" do
-    given_a_sale_for_customer_vault_id a_cc_customer_vault_id
-    if_the_transaction_succeeds
-    it_should_find_the_transaction
-    expect(@queried_transaction.type).to eq "sale"
-  end
+  describe "finding an existing transaction" do
+    let(:queried_transaction) { NmiDirectPost::Transaction.find_by_transaction_id(transaction.transaction_id) }
 
-  it "should find a validate" do
-    @transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_cc_customer_vault_id, :amount => 0, :type => :validate)
-    @transaction.save
-    if_the_transaction_succeeds
-    it_should_find_the_transaction
-    expect(@queried_transaction.type).to eq @transaction.type
-  end
+    def it_should_find_the_transaction
+      expect(queried_transaction).not_to be_nil
+      expect(queried_transaction.amount).to eq transaction.amount
+      expect(queried_transaction.customer_vault_id).to eq transaction.customer_vault_id
+      expect(queried_transaction.customer_vault).not_to be_nil
+      expect(queried_transaction.customer_vault.first_name).to eq(transaction.customer_vault.first_name)
+    end
 
-  it "should raise an error when transaction_id is blank" do
-    expect{ NmiDirectPost::Transaction.find_by_transaction_id("") }.to raise_error(StandardError, "TransactionID cannot be blank")
-  end
+    describe "a sale" do
+      let(:transaction) { cc_implicit_sale }
 
-  it "should raise an error when transaction is not found using instance" do
-    expect{ NmiDirectPost::Transaction.new(:transaction_id => 12345) }.to raise_error(NmiDirectPost::TransactionNotFoundError, "No transaction found for TransactionID 12345")
-  end
+      it "should be found" do
+        expect(cc_implicit_sale.save).to eq(true), "Transaction failed to save for the following reasons: #{cc_implicit_sale.errors.messages.inspect}"
+        expect(cc_implicit_sale.response).to eq(1), cc_implicit_sale.inspect
+        it_should_find_the_transaction
+        expect(queried_transaction.type).to eq "sale"
+      end
+    end
 
-  it "should return nil when transaction is not found using class method" do
-    expect(NmiDirectPost::Transaction.find_by_transaction_id(12345)).to be_nil
+    describe "a validate" do
+      let(:transaction) { cc_validation }
+
+      it "should be found" do
+        cc_validation.save
+        expect(cc_validation.response).to eq(1), cc_validation.inspect
+        it_should_find_the_transaction
+        expect(queried_transaction.type).to eq cc_validation.type
+      end
+    end
+
+    it "should raise an error when transaction_id is blank" do
+      expect{ NmiDirectPost::Transaction.find_by_transaction_id("") }.to raise_error(StandardError, "TransactionID cannot be blank")
+    end
+
+    it "should raise an error when transaction is not found using instance" do
+      expect{ NmiDirectPost::Transaction.new(transaction_id: 12345) }.to raise_error(NmiDirectPost::TransactionNotFoundError, "No transaction found for TransactionID 12345")
+    end
+
+    it "should return nil when transaction is not found using class method" do
+      expect(NmiDirectPost::Transaction.find_by_transaction_id(12345)).to be_nil
+    end
   end
 
   it "should add response, response_code and response to errors when charge cannot be saved" do
-    transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_cc_customer_vault_id, :amount => 0, :type => :validate)
-    transaction.instance_variable_set("@password", '12345')
-    expect(transaction.save).to eq(false)
-    expect(transaction.errors.size).to eq(3), transaction.errors.inspect
-    expect(transaction.errors[:response].size).to eq(1), transaction.errors[:response].inspect
-    expect(transaction.errors[:response]).to include('3'), transaction.errors.inspect
-    expect(transaction.errors[:response_code].size).to eq(1), transaction.errors[:response_code].inspect
-    expect(transaction.errors[:response_code]).to include('300'), transaction.errors.inspect
-    expect(transaction.errors[:response_text].size).to eq(1), transaction.errors[:response_text].inspect
-    expect(transaction.errors[:response_text]).to include('Authentication Failed'), transaction.errors.inspect
+    cc_validation.instance_variable_set("@password", '12345')
+    expect(cc_validation.save).to eq(false)
+    expect(cc_validation.errors.size).to eq(3), cc_validation.errors.inspect
+    expect(cc_validation.errors[:response].size).to eq(1), cc_validation.errors[:response].inspect
+    expect(cc_validation.errors[:response]).to include('3'), cc_validation.errors.inspect
+    expect(cc_validation.errors[:response_code].size).to eq(1), cc_validation.errors[:response_code].inspect
+    expect(cc_validation.errors[:response_code]).to include('300'), cc_validation.errors.inspect
+    expect(cc_validation.errors[:response_text].size).to eq(1), cc_validation.errors[:response_text].inspect
+    expect(cc_validation.errors[:response_text]).to include('Authentication Failed'), cc_validation.errors.inspect
   end
 
   describe "customer_vault" do
     it "should find when it exists" do
-      @transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_cc_customer_vault_id, :amount => amount.call)
-      expect(@transaction.customer_vault).to have_same_attributes_as(NmiDirectPost::CustomerVault.find_by_customer_vault_id(a_cc_customer_vault_id))
+      expect(cc_implicit_sale.customer_vault).to have_same_attributes_as(NmiDirectPost::CustomerVault.find_by_customer_vault_id(a_cc_customer_vault_id))
     end
 
     it "should be nil when it doesn't exist" do
-      @transaction = NmiDirectPost::Transaction.new(:customer_vault_id => '123456', :amount => amount.call)
-      expect(@transaction.customer_vault).to be_nil
+      transaction = NmiDirectPost::Transaction.new(customer_vault_id: '123456', amount: amount)
+      expect(transaction.customer_vault).to be_nil
     end
   end
 
   describe "type" do
+    let(:cc_transaction) { NmiDirectPost::Transaction.new(customer_vault_id: a_cc_customer_vault_id, amount: amount, type: transaction_type) }
+    let(:cc_transaction_amount_0) { NmiDirectPost::Transaction.new(customer_vault_id: a_cc_customer_vault_id, amount: 0, type: transaction_type) }
+    let(:ach_transaction) { NmiDirectPost::Transaction.new(customer_vault_id: a_checking_account_customer_vault_id, amount: amount, type: transaction_type) }
+    let(:ach_transaction_amount_0) { NmiDirectPost::Transaction.new(customer_vault_id: a_checking_account_customer_vault_id, amount: 0, type: transaction_type) }
+
     describe "sale" do
+      let(:transaction_type) { :sale }
       it "should allow non-zero amounts for credit card customer vaults" do
-        transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_cc_customer_vault_id, :amount => amount.call, :type => :sale)
-        expect(transaction.save).to eq(true), transaction.errors.inspect
+        expect(cc_transaction.save).to eq(true), cc_transaction.errors.inspect
       end
       it "should not allow amount to be 0 for credit card customer vaults" do
-        transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_cc_customer_vault_id, :amount => 0, :type => :sale)
-        expect(transaction.save).to eq(false)
-        expect(transaction.errors.size).to eq(1)
-        expect(transaction.errors[:amount].size).to eq(1)
-        expect(transaction.errors[:amount]).to include('Amount cannot be 0 for a sale')
+        expect(cc_transaction_amount_0.save).to eq(false)
+        expect(cc_transaction_amount_0.errors.size).to eq(1)
+        expect(cc_transaction_amount_0.errors[:amount].size).to eq(1)
+        expect(cc_transaction_amount_0.errors[:amount]).to include('Amount cannot be 0 for a sale')
       end
       it "should allow non-zero amounts for checking account customer vaults" do
-        expect(NmiDirectPost::Transaction.new(:customer_vault_id => a_checking_account_customer_vault_id, :amount => amount.call, :type => :sale).save).to eq(true)
+        expect(ach_transaction.save).to eq(true)
       end
       it "should not allow amount to be 0 for checking account customer vaults" do
-        transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_checking_account_customer_vault_id, :amount => 0, :type => :sale)
-        expect(transaction.save).to eq(false)
-        expect(transaction.errors.size).to eq(1)
-        expect(transaction.errors[:amount].size).to eq(1)
-        expect(transaction.errors[:amount]).to include('Amount cannot be 0 for a sale')
+        expect(ach_transaction_amount_0.save).to eq(false)
+        expect(ach_transaction_amount_0.errors.size).to eq(1)
+        expect(ach_transaction_amount_0.errors[:amount].size).to eq(1)
+        expect(ach_transaction_amount_0.errors[:amount]).to include('Amount cannot be 0 for a sale')
       end
       it "should allow non-zero amounts for credit card customer vaults when sale is implied" do
-        transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_cc_customer_vault_id, :amount => amount.call)
-        expect(transaction.save).to eq(true), transaction.errors.inspect
+        expect(cc_implicit_sale.save).to eq(true), cc_implicit_sale.errors.inspect
       end
       it "should not allow amount to be 0 for credit card customer vaults when sale is implied" do
-        transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_cc_customer_vault_id, :amount => 0)
+        transaction = NmiDirectPost::Transaction.new(customer_vault_id: a_cc_customer_vault_id, amount: 0)
         expect(transaction.save).to eq(false)
         expect(transaction.errors.size).to eq(1)
         expect(transaction.errors[:amount].size).to eq(1)
         expect(transaction.errors[:amount]).to include('Amount cannot be 0 for a sale')
       end
       it "should allow non-zero amounts for checking account customer vaults when sale is implied" do
-        expect(NmiDirectPost::Transaction.new(:customer_vault_id => a_checking_account_customer_vault_id, :amount => amount.call).save).to eq(true)
+        expect(ach_implicit_sale.save).to eq(true)
       end
       it "should not allow amount to be 0 for checking account customer vaults when sale is implied" do
-        transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_checking_account_customer_vault_id, :amount => 0)
+        transaction = NmiDirectPost::Transaction.new(customer_vault_id: a_checking_account_customer_vault_id, amount: 0)
         expect(transaction.save).to eq(false)
         expect(transaction.errors.size).to eq(1)
         expect(transaction.errors[:amount].size).to eq(1)
@@ -159,134 +157,124 @@ describe NmiDirectPost::Transaction do
     end
 
     describe "validate" do
+      let(:transaction_type) { :validate }
       it "should not allow non-zero amounts" do
-        transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_cc_customer_vault_id, :amount => amount.call, :type => :validate)
-        expect(transaction.save).to eq(false)
-        expect(transaction.errors.size).to eq(1)
-        expect(transaction.errors[:amount].size).to eq(1)
-        expect(transaction.errors[:amount]).to include('Amount must be 0 when validating a credit card')
+        expect(cc_transaction.save).to eq(false)
+        expect(cc_transaction.errors.size).to eq(1)
+        expect(cc_transaction.errors[:amount].size).to eq(1)
+        expect(cc_transaction.errors[:amount]).to include('Amount must be 0 when validating a credit card')
       end
       it "should allow amount to be 0" do
-        expect(NmiDirectPost::Transaction.new(:customer_vault_id => a_cc_customer_vault_id, :amount => 0, :type => :validate).save).to eq(true)
+        expect(cc_transaction_amount_0.save).to eq(true)
       end
       it "should not be allowed for checking account customer vaults" do
-        transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_checking_account_customer_vault_id, :amount => 0, :type => :validate)
-        expect(transaction.save).to eq(false)
-        expect(transaction.errors.size).to eq(1)
-        expect(transaction.errors[:type].size).to eq(1)
-        expect(transaction.errors[:type]).to include('validate is not a valid action for a customer vault that uses a checking account')
+        expect(ach_transaction_amount_0.save).to eq(false)
+        expect(ach_transaction_amount_0.errors.size).to eq(1)
+        expect(ach_transaction_amount_0.errors[:type].size).to eq(1)
+        expect(ach_transaction_amount_0.errors[:type]).to include('validate is not a valid action for a customer vault that uses a checking account')
       end
     end
 
     describe "auth" do
+      let(:transaction_type) { :auth }
       it "should allow non-zero amounts for credit card customer vaults" do
-        transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_cc_customer_vault_id, :amount => amount.call, :type => :auth)
-        expect(transaction.save).to eq(true), transaction.errors.inspect
+        expect(cc_transaction.save).to eq(true), cc_transaction.errors.inspect
       end
       it "should not allow amount to be 0 for credit card customer vaults" do
-        transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_cc_customer_vault_id, :amount => 0, :type => :auth)
-        expect(transaction.save).to eq(false)
-        expect(transaction.errors.size).to eq(1)
-        expect(transaction.errors[:amount].size).to eq(1)
-        expect(transaction.errors[:amount]).to include('Amount cannot be 0 for an authorization')
+        expect(cc_transaction_amount_0.save).to eq(false)
+        expect(cc_transaction_amount_0.errors.size).to eq(1)
+        expect(cc_transaction_amount_0.errors[:amount].size).to eq(1)
+        expect(cc_transaction_amount_0.errors[:amount]).to include('Amount cannot be 0 for an authorization')
       end
       it "should not be allowed for checking account customer vaults" do
-        transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_checking_account_customer_vault_id, :amount => amount.call, :type => :auth)
-        expect(transaction.save).to eq(false)
-        expect(transaction.errors.size).to eq(1)
-        expect(transaction.errors[:type].size).to eq(1)
-        expect(transaction.errors[:type]).to include('auth is not a valid action for a customer vault that uses a checking account')
+        expect(ach_transaction.save).to eq(false)
+        expect(ach_transaction.errors.size).to eq(1)
+        expect(ach_transaction.errors[:type].size).to eq(1)
+        expect(ach_transaction.errors[:type]).to include('auth is not a valid action for a customer vault that uses a checking account')
       end
     end
 
     describe "void" do
+      let(:cc_auth) { NmiDirectPost::Transaction.new(customer_vault_id: a_cc_customer_vault_id, amount: amount, type: :auth) }
       it "should be allowed for a pending sale" do
-        transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_cc_customer_vault_id, :amount => amount.call)
-        transaction.save!
-        expect(transaction.void!).to eq(true)
+        cc_implicit_sale.save!
+        expect(cc_implicit_sale.void!).to eq(true)
       end
       it "should not be allowed for validates" do
-        transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_cc_customer_vault_id, :amount => 0, :type => :validate)
-        transaction.save!
-        expect(transaction.void!).to eq(false)
-        expect(transaction.errors.size).to eq(1), transaction.errors.inspect
-        expect(transaction.errors[:type].size).to eq(1), transaction.errors.inspect
-        expect(transaction.errors[:type]).to include('Void is only a valid action for a pending or unsettled authorization, or an unsettled sale')
+        cc_validation.save!
+        expect(cc_validation.void!).to eq(false)
+        expect(cc_validation.errors.size).to eq(1), cc_validation.errors.inspect
+        expect(cc_validation.errors[:type].size).to eq(1), cc_validation.errors.inspect
+        expect(cc_validation.errors[:type]).to include('Void is only a valid action for a pending or unsettled authorization, or an unsettled sale')
       end
       it "should be allowed for authorizations when saved and voided on same instantiation" do
-        transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_cc_customer_vault_id, :amount => amount.call, :type => :auth)
-        expect(transaction.save).to eq(true), transaction.inspect
-        expect(transaction.void!).to eq(true), transaction.inspect
-        expect(transaction.errors).to be_empty, transaction.errors.inspect
+        expect(cc_auth.save).to eq(true), cc_auth.inspect
+        expect(cc_auth.void!).to eq(true), cc_auth.inspect
+        expect(cc_auth.errors).to be_empty, cc_auth.errors.inspect
       end
       it "should be allowed for authorizations when found by transaction ID" do
-        transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_cc_customer_vault_id, :amount => amount.call, :type => :auth)
-        transaction.save!
-        transaction = NmiDirectPost::Transaction.find_by_transaction_id(transaction.transaction_id)
-        expect(transaction.void!).to eq(true), transaction.inspect
-        expect(transaction.errors).to be_empty, transaction.errors.inspect
+        cc_auth.save!
+        void = NmiDirectPost::Transaction.find_by_transaction_id(cc_auth.transaction_id)
+        expect(void.void!).to eq(true), void.inspect
+        expect(void.errors).to be_empty, void.errors.inspect
       end
       it "should be allowed for authorizations when instantiated as a void" do
-        transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_cc_customer_vault_id, :amount => amount.call, :type => :auth)
-        transaction.save!
-        transaction = NmiDirectPost::Transaction.new(:transaction_id => transaction.transaction_id, :type => :void)
-        expect(transaction.save).to eq(true), transaction.errors.inspect
-        expect(transaction.errors).to be_empty, transaction.errors.inspect
+        cc_auth.save!
+        void = NmiDirectPost::Transaction.new(transaction_id: cc_auth.transaction_id, type: :void)
+        expect(void.save).to eq(true), cc_auth.errors.inspect
+        expect(void.errors).to be_empty, cc_auth.errors.inspect
       end
       it "should not be allowed for an unpersisted transaction" do
-        transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_cc_customer_vault_id, :amount => amount.call, :type => :auth)
-        expect(transaction.void!).to eq(false), transaction.inspect
-        expect(transaction.errors.size).to eq(1), transaction.errors.inspect
-        expect(transaction.errors[:type].size).to eq(1), transaction.errors.inspect
-        expect(transaction.errors[:type]).to include('Void is only a valid action for a transaction that has already been sent to NMI')
+        expect(cc_auth.void!).to eq(false), cc_auth.inspect
+        expect(cc_auth.errors.size).to eq(1), cc_auth.errors.inspect
+        expect(cc_auth.errors[:type].size).to eq(1), cc_auth.errors.inspect
+        expect(cc_auth.errors[:type]).to include('Void is only a valid action for a transaction that has already been sent to NMI')
       end
-      it "should not be allowed for a voided sale" do
-        transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_cc_customer_vault_id, :amount => amount.call)
-        transaction.save!
-        expect(transaction.void!).to eq(true)
-        expect(transaction.void!).to eq(false)
+
+      def expect_error_on_void_for(transaction)
         expect(transaction.errors.size).to eq(1), transaction.errors.inspect
         expect(transaction.errors[:type].size).to eq(1), transaction.errors.inspect
         expect(transaction.errors[:type]).to include('Void is only a valid action for a pending or unsettled authorization, or an unsettled sale')
       end
+
+      it "should not be allowed for a voided sale" do
+        cc_implicit_sale.save!
+        expect(cc_implicit_sale.void!).to eq(true)
+        expect(cc_implicit_sale.void!).to eq(false)
+        expect_error_on_void_for(cc_implicit_sale)
+        void = NmiDirectPost::Transaction.new(transaction_id: cc_implicit_sale.transaction_id, type: :void)
+        expect(void.save).to eq(false)
+        expect_error_on_void_for(void)
+      end
       it "should not be allowed for a voided auth" do
-        transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_cc_customer_vault_id, :amount => amount.call, :type => :auth)
-        transaction.save!
-        expect(transaction.void!).to eq(true)
-        expect(transaction.void!).to eq(false)
-        expect(transaction.errors.size).to eq(1), transaction.errors.inspect
-        expect(transaction.errors[:type].size).to eq(1), transaction.errors.inspect
-        expect(transaction.errors[:type]).to include('Void is only a valid action for a pending or unsettled authorization, or an unsettled sale')
+        cc_auth.save!
+        expect(cc_auth.void!).to eq(true)
+        expect(cc_auth.void!).to eq(false)
+        expect_error_on_void_for(cc_auth)
+
+        void = NmiDirectPost::Transaction.new(transaction_id: cc_auth.transaction_id, type: :void)
+        expect(void.save).to eq(false)
+        expect_error_on_void_for(void)
       end
     end
   end
 
   describe "condition" do
-    def given_a_check_transaction
-      transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_checking_account_customer_vault_id, :amount => amount.call)
-      transaction.save!
-      @amount = transaction.amount
-      @transaction = NmiDirectPost::Transaction.find_by_transaction_id(transaction.transaction_id)
-    end
-    def given_a_cc_transaction
-      transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_cc_customer_vault_id, :amount => amount.call)
-      transaction.save!
-      @amount = transaction.amount
-      @transaction = NmiDirectPost::Transaction.find_by_transaction_id(transaction.transaction_id)
-    end
     it "should be pendingsettlement on a new check" do
-      given_a_check_transaction
-      expect(@transaction.condition).to eq("pendingsettlement")
-      expect(@transaction).to be_pending
-      expect(@transaction).not_to be_cleared
-      expect(@transaction.amount).to eq(@amount)
+      ach_implicit_sale.save!
+      transaction = NmiDirectPost::Transaction.find_by_transaction_id(ach_implicit_sale.transaction_id)
+      expect(transaction.condition).to eq("pendingsettlement")
+      expect(transaction).to be_pending
+      expect(transaction).not_to be_cleared
+      expect(transaction.amount).to eq(amount)
     end
     it "should be pending on a new CC charge" do
-      given_a_cc_transaction
-      expect(@transaction.condition).to eq("pendingsettlement")
-      expect(@transaction).to be_pending
-      expect(@transaction).not_to be_cleared
-      expect(@transaction.amount).to eq(@amount)
+      cc_implicit_sale.save!
+      transaction = NmiDirectPost::Transaction.find_by_transaction_id(cc_implicit_sale.transaction_id)
+      expect(transaction.condition).to eq("pendingsettlement")
+      expect(transaction).to be_pending
+      expect(transaction).not_to be_cleared
+      expect(transaction.amount).to eq(amount)
     end
     it "should be approved on an existing CC charge" do
       transaction = NmiDirectPost::Transaction.find_by_transaction_id(TestCredentials::INSTANCE.cc_transaction)
@@ -297,7 +285,6 @@ describe NmiDirectPost::Transaction do
   end
 
   it "should not reload when transaction_id is missing" do
-    transaction = NmiDirectPost::Transaction.new(:customer_vault_id => a_cc_customer_vault_id, :amount => amount.call)
-    expect{transaction.reload}.not_to raise_error
+    expect{cc_implicit_sale.reload}.not_to raise_error
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nmi_direct_post
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Isaac Betesh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-19 00:00:00.000000000 Z
+date: 2015-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -100,28 +100,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.0'
 description: Gem that encapsulates the NMI Direct Post API in an ActiveRecord-like
   syntax
 email:
@@ -171,7 +157,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: '# NmiDirectPost  NmiDirectPost is a gem that encapsulates the NMI Direct
@@ -181,14 +167,20 @@ summary: '# NmiDirectPost  NmiDirectPost is a gem that encapsulates the NMI Dire
   the boundary between NMI''s Direct Post API and its Query API.  This fuzziness is
   part of the encapsulation.  ## Installation  Add this line to your application''s
   Gemfile:  gem ''nmi_direct_post''  And then execute:  $ bundle  Or install it yourself
-  as:  $ gem install nmi_direct_post  ## Usage  1) Before you can query or post, establish
-  the connection:  NmiDirectPost::Base.establish_connection("MY_NMI_USERNAME", "MY_NMI_PASSWORD")  Theoretically,
-  you can use a different connection for NmiDirectPost::Transaction or NmiDirectPost::CustomerVault
-  by calling establish_connection on either of those derived classes, instead of on
-  Base. However, it''s hard to imagine a case where this would be useful; the option
-  is only present to mimic the syntax of ActiveRecord.  2) Query the API:  NmiDirectPost::Transaction.find_by_transaction_id(123456789)
-  NmiDirectPost::CustomerVault.find_by_customer_vault_id(123123123)  3) Create a CustomerVault:  george
-  = NmiDirectPostCustomerVault.new(:first_name => ''George'', :last_name => ''Washington'',
+  as:  $ gem install nmi_direct_post  ## Usage  1) Before you query or post, you probably
+  want to set a default username and password:  NmiDirectPost::Base.establish_connection("MY_NMI_USERNAME",
+  "MY_NMI_PASSWORD")  If you don''t set a default, you''ll need to include the username
+  and password in the hash passed to the initializer when instantiating a new Transaction
+  or CustomerVault.  Theoretically, you can use a different connection for NmiDirectPost::Transaction
+  or NmiDirectPost::CustomerVault by calling establish_connection on either of those
+  derived classes, instead of on Base. However, it''s hard to imagine a case where
+  this would be useful; the option is only present to mimic the syntax of ActiveRecord.  2)
+  Query the API:  NmiDirectPost::Transaction.find_by_transaction_id(123456789, "MyUsername",
+  "MyPassword") NmiDirectPost::Transaction.find_by_transaction_id(123456789) # If
+  you''ve already called establish_connection  NmiDirectPost::CustomerVault.find_by_customer_vault_id(123123123)
+  # Note that there is no way to pass a username and password to this method.  You
+  must call establish_connection beforehand.  3) Create a CustomerVault:  george =
+  NmiDirectPostCustomerVault.new(:first_name => ''George'', :last_name => ''Washington'',
   :cc_number => ''4111111111111111'', :cc_exp => ''03/17'') george.create  4) Update
   a CustomerVault:  george.update!(:email => ''el_primero_presidente@whitehouse.gov'',
   :address_1 => ''1600 Pennsylvania Ave NW'', :city => ''Washington'', :state => ''DC'',
@@ -201,12 +193,13 @@ summary: '# NmiDirectPost  NmiDirectPost is a gem that encapsulates the NMI Dire
   # Returns array of `customer_vault_id`s NmiDirectPost::CustomerVault.first NmiDirectPost::CustomerVault.last
   NmiDirectPost::CustomerVault.all # Returns very, very big array.  This method had
   very poor performance and could be optimized significantly in a future version of
-  this gem.  8) Create a Transaction:  parking_ticket = NmiDirectPost::Transaction(:type
-  => :sale, :amount => 150.01, :customer_vault_id => george.customer_vault_id) parking_ticket.save!
-  # Returns true  ## Contributing  1. Fork it 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'
+  this gem.  Note that there is no way to pass a username and password to these methods.  You
+  must call establish_connection beforehand.  8) Create a Transaction:  parking_ticket
+  = NmiDirectPost::Transaction(:type => :sale, :amount => 150.01, :customer_vault_id
+  => george.customer_vault_id) parking_ticket.save! # Returns true  ## Contributing  1.
+  Fork it 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'
 test_files:
 - spec/base_spec.rb
 - spec/customer_vault_spec.rb