authorize-net 1.5.2

data/lib/generators/authorize_net/sim_generator.rb

@@ -0,0 +1,47 @@
+require 'rails/generators'
+require 'rails/generators/named_base'
+
+module AuthorizeNet
+  module Generators
+    class SimGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("../../../../generators/authorize_net_sim/templates", __FILE__)
+      argument :api_login_id, :type => :string, :desc => 'Your Authorize.Net API login ID.', :optional => true
+      argument :api_transaction_key, :type => :string, :desc => 'Your Authorize.Net API transaction key.', :optional => true
+      argument :merchant_hash_value, :type => :string, :desc => 'Your Authorize.Net merchant hash value.', :optional => true
+      desc <<-DESC
+Description
+    Generates a simple implementation of Authorize.Net's SIM integration method.
+
+Example:
+    rails generate authorize_net:sim payments API_LOGIN_ID API_TRANSACTION_KEY MERCHANT_HASH_VALUE
+    
+    This will create:
+      create  README-AuthorizeNet
+      create  app/views/payments
+      create  app/views/payments/payment.erb
+      create  app/views/payments/thank_you.erb
+      create  app/views/layouts/authorize_net.erb
+      create  config/authorize_net.yml
+      create  config/initializers/authorize_net.rb
+      create  app/controllers/payments_controller.rb
+       route  match '/payments/thank_you', :to => 'payments#thank_you', :as => 'payments_thank_you', :via => [:get]
+       route  match '/payments/payment', :to => 'payments#payment', :as => 'paymentspayment', :via => [:get]
+
+DESC
+      
+      def manifest
+        copy_file "README-AuthorizeNet", "README-AuthorizeNet"
+        empty_directory "app/views/#{file_name}"
+        copy_file "payment.rails3.erb", "app/views/#{file_name}/payment.erb"
+        copy_file "thank_you.erb", "app/views/#{file_name}/thank_you.erb"
+        copy_file "layout.erb", "app/views/layouts/authorize_net.erb"
+        template "config.yml.rails3.erb", "config/authorize_net.yml"
+        copy_file "initializer.rb", "config/initializers/authorize_net.rb"
+        template "controller.rb.erb", "app/controllers/#{file_name}_controller.rb"
+        route "match '/#{plural_name}/thank_you', :to => '#{file_name}#thank_you', :as => '#{singular_name}_thank_you', :via => [:get]"
+        route "match '/#{plural_name}/payment', :to => '#{file_name}#payment', :as => '#{singular_name}payment', :via => [:get]"
+      end
+      
+    end
+  end
+end

data/spec/aim_spec.rb

@@ -0,0 +1,310 @@
+require "spec_helper"
+
+describe AuthorizeNet::AIM::Transaction do
+  
+  before :all do
+    begin
+      creds = YAML.load_file(File.dirname(__FILE__) + "/credentials.yml")
+      @api_key = creds['api_transaction_key']
+      @api_login = creds['api_login_id']
+      @cp_api_key = creds['cp_api_transaction_key']
+      @cp_api_login = creds['cp_api_login_id']
+      @md5_value = creds['md5_value']
+      @cp_md5_value = creds['cp_md5_value']
+    rescue Errno::ENOENT => e
+      @api_key = "TEST"
+      @api_login = "TEST"
+      @cp_api_key = "TEST"
+      @cp_api_login = "TEST"
+      @md5_value = "TEST"
+      @cp_md5_value = "TEST"
+      warn "WARNING: Running w/o valid AuthorizeNet sandbox credentials. Create spec/credentials.yml."
+    end
+  end
+  
+  before do
+    @type = AuthorizeNet::AIM::Transaction::Type::AUTHORIZE_AND_CAPTURE
+    @test_mode = false
+    @gateway = :sandbox
+    @amount = (rand(10000) + 100) / 100.0
+    @credit_card = AuthorizeNet::CreditCard.new('4111111111111111', '01' + (Time.now + (3600 * 24 * 365)).strftime('%y'))
+    @response = '1,1,1,(TESTMODE) This transaction has been approved.,000000,P,0,,,10.00,CC,auth_capture,,,,,,,,,,,,,,,,,,,,,,,,,,7A3C09A367FED29C9902038440CD8A52,,,,,,,,,,,,,XXXX0027,Visa,,,,,,,,,,,,,,,,'
+    @echeck = AuthorizeNet::ECheck.new('322271627', '123456789', 'JPMorgan Chase Bank', 'John Doe')
+  end
+  
+  it "should support instantiation" do
+    AuthorizeNet::AIM::Transaction.new(@api_login, @api_key).should be_instance_of(AuthorizeNet::AIM::Transaction)
+  end
+  
+  it "should know if its in test mode" do
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => AuthorizeNet::AIM::Transaction::Gateway::TEST, :test => true)
+    transaction.test?.should be_true
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => AuthorizeNet::AIM::Transaction::Gateway::TEST, :test => false)
+    transaction.test?.should be_true
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => AuthorizeNet::AIM::Transaction::Gateway::LIVE, :test => true)
+    transaction.test?.should be_true
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => AuthorizeNet::AIM::Transaction::Gateway::LIVE, :test => false)
+    transaction.test?.should be_false
+  end
+  
+  it "should not have a response if the transaciton hasn't been run" do
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => @gateway, :test => @test_mode)
+    transaction.has_response?.should be_false
+  end
+  
+  it "should support the addition of fields to the transaction body" do
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => @gateway, :test => @test_mode)
+    transaction.should respond_to(:set_fields)
+    transaction.set_fields({:test => 123}).should == {:test => 123}
+  end
+  
+  it "should support the addition of mulitple line_item fields" do
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => @gateway, :test => @test_mode)
+    transaction.set_fields({:line_item => [123, 123]}).should == {:line_item => [123, 123]}
+    transaction.set_fields({:line_item => "abc"}).should == {:line_item => "abc"}
+  end
+  
+  it "should not support the addition of mulitple fields for non-line-item fields" do
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => @gateway, :test => @test_mode)
+    transaction.set_fields({:test => 123}).should == {:test => 123}
+    transaction.set_fields({:test => 123}).should == {:test => 123}
+  end
+  
+  it "should support custom fields" do
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => @gateway, :test => @test_mode)
+    transaction.should respond_to(:set_custom_fields)
+    transaction.set_custom_fields(:test => 123).should == {:test => 123}
+    transaction.fields.should == {}
+    transaction.custom_fields.should == {:test => 123}
+  end
+  
+  it "should support the returning its response object" do
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => @gateway, :test => @test_mode)
+    transaction.should respond_to(:response)
+  end
+  
+  it "should parse the response properly" do
+    Net::HTTP.stub!(:start).and_return(@response)
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => @gateway, :test => @test_mode)
+    response = transaction.purchase(@amount, @credit_card)
+    response.should be_kind_of(AuthorizeNet::AIM::Response)
+    response.transaction_id.length.should >= 3
+    response.success?.should be_true
+    response.avs_response.should  == AuthorizeNet::AIM::Response::AVSResponseCode::ADDRESS_AND_ZIP5_MATCH
+    response.card_type.should == AuthorizeNet::AIM::Response::CardType::VISA
+    response.card_type.should_not == AuthorizeNet::AIM::Response::CardType::MASTER_CARD
+  end
+  
+  it "should support different transaction types" do
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => @gateway, :test => @test_mode)
+    transaction.should respond_to(:type)
+    transaction.type.should == AuthorizeNet::AIM::Transaction::Type::AUTHORIZE_AND_CAPTURE
+    transaction.type = AuthorizeNet::AIM::Transaction::Type::VOID
+    transaction.type.should == AuthorizeNet::AIM::Transaction::Type::VOID
+    transaction.type = AuthorizeNet::AIM::Transaction::Type::AUTHORIZE_ONLY
+    transaction.type.should == AuthorizeNet::AIM::Transaction::Type::AUTHORIZE_ONLY
+    transaction.type = AuthorizeNet::AIM::Transaction::Type::CAPTURE_ONLY
+    transaction.type.should == AuthorizeNet::AIM::Transaction::Type::CAPTURE_ONLY
+    transaction.type = AuthorizeNet::AIM::Transaction::Type::CREDIT
+    transaction.type.should == AuthorizeNet::AIM::Transaction::Type::CREDIT
+    transaction.type = AuthorizeNet::AIM::Transaction::Type::PRIOR_AUTHORIZATION_AND_CAPTURE
+    transaction.type.should == AuthorizeNet::AIM::Transaction::Type::PRIOR_AUTHORIZATION_AND_CAPTURE
+  end
+  
+  it "should be able to run a transaction" do
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => @gateway, :test => @test_mode)
+    transaction.run.should be_kind_of(AuthorizeNet::AIM::Response)
+  end
+  
+  it "should not be able to run a transaction a second time" do
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => @gateway, :test => @test_mode)
+    transaction.run.should be_kind_of(AuthorizeNet::AIM::Response)
+    transaction.run.should be_nil
+  end
+  
+  it "should be able to make a purchase" do
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => @gateway, :test => @test_mode)
+    transaction.purchase(@amount, @credit_card).should be_kind_of(AuthorizeNet::AIM::Response)
+    transaction.response.fields[:amount].should == @amount
+    transaction.response.success?.should be_true
+  end
+  
+  it "should support custom fields in the response" do
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => @gateway, :test => @test_mode)
+    transaction.set_custom_fields(:funkey => '123')
+    transaction.set_custom_fields(:winker => 'ABC')
+    transaction.set_custom_fields(:bean => '!!!')
+    transaction.purchase(@amount, @credit_card).should be_kind_of(AuthorizeNet::AIM::Response)
+    fields = transaction.response.custom_fields
+    fields.should have_key(:funkey)
+    fields[:funkey].should == '123'
+    fields.should have_key(:winker)
+    fields[:winker].should == 'ABC'
+    fields.should have_key(:bean)
+    fields[:bean].should == '!!!'
+  end
+  
+  it "should support an encapsulation character in the response" do
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => @gateway, :test => @test_mode, :encapsulation_character => '"')
+    transaction.set_custom_fields(:funkey => '12,3')
+    transaction.purchase(@amount, @credit_card).should be_kind_of(AuthorizeNet::AIM::Response)
+    fields = transaction.response.custom_fields
+    fields.should have_key(:funkey)
+    fields[:funkey].should == '12,3'
+  end
+  
+  it "should accept an ECheck for a purchase" do
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => @gateway, :test => @test_mode)
+    transaction.purchase(@amount, @echeck).should be_kind_of(AuthorizeNet::AIM::Response)
+    transaction.response.success?.should be_true
+  end
+  
+  it "should support adding line items" do
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => @gateway, :test => @test_mode)
+    transaction.add_line_item("item1", "Foo", "Bar", "5", "5.00", "TRUE")
+    transaction.purchase(@amount, @credit_card).should be_kind_of(AuthorizeNet::AIM::Response)
+    transaction.response.success?.should be_true
+    transaction.fields[:line_item].should == ["item1<|>Foo<|>Bar<|>5<|>5.00<|>TRUE"]
+  end
+  
+  it "should support setting a customer" do
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => @gateway, :test => @test_mode)
+    customer = AuthorizeNet::Customer.new(:ip => '127.0.0.1')
+    transaction.set_customer(customer)
+    transaction.purchase(@amount, @credit_card).should be_kind_of(AuthorizeNet::AIM::Response)
+    transaction.response.success?.should be_true
+  end
+  
+  it "should support setting an address" do
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => @gateway, :test => @test_mode)
+    address = AuthorizeNet::Address.new(:city => 'San Francisco', :state => 'NY')
+    transaction.set_address(address)
+    transaction.purchase(@amount, @credit_card).should be_kind_of(AuthorizeNet::AIM::Response)
+    transaction.response.success?.should be_true
+  end
+  
+  it "should support setting a shipping address" do
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => @gateway, :test => @test_mode)
+    address = AuthorizeNet::ShippingAddress.new(:city => 'San Francisco', :state => 'NY', :tax => 10.00)
+    transaction.set_shipping_address(address)
+    transaction.purchase(@amount, @credit_card).should be_kind_of(AuthorizeNet::AIM::Response)
+    transaction.response.success?.should be_true
+  end
+  
+  it "should support adding an email receipt" do
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => @gateway, :test => @test_mode)
+    email = AuthorizeNet::EmailReceipt.new(:header => 'TEST!')
+    transaction.set_email_receipt(email)
+    transaction.purchase(@amount, @credit_card).should be_kind_of(AuthorizeNet::AIM::Response)
+    transaction.response.success?.should be_true
+  end
+  
+  it "should be able to void a purchase" do
+    purchase = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => @gateway, :test => false)
+    purchase.purchase(@amount, @credit_card).should be_kind_of(AuthorizeNet::AIM::Response)
+    purchase.response.fields[:amount].should == @amount
+    purchase.response.success?.should be_true
+    void = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :gateway => @gateway, :test => false)
+    void.void(purchase.response.transaction_id)
+    void.response.success?.should be_true
+  end
+  
+  it "should be able to capture a prior authorization" do
+    auth = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => @gateway, :test => false)
+    auth.authorize(@amount, @credit_card).should be_kind_of(AuthorizeNet::AIM::Response)
+    auth.response.fields[:amount].should == @amount
+    auth.response.success?.should be_true
+    capture = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :gateway => @gateway, :test => false)
+    capture.prior_auth_capture(auth.response.transaction_id)
+    capture.response.success?.should be_true
+  end
+  
+  it "should be able to run a card present purchase with track 1 data" do
+    @credit_card = AuthorizeNet::CreditCard.new(nil, nil, :track_1 => '%B4111111111111111^DOE/JOHN^1803101000000000020000831000000?')
+    purchase = AuthorizeNet::AIM::Transaction.new(@cp_api_login, @cp_api_key, :gateway => :card_present_test, :test => false)
+    response = purchase.purchase(@amount, @credit_card)
+    response.success?.should be_true
+  end
+  
+  it "should be able to run a card present purchase with LRC codes in the track 1 data" do
+    @credit_card = AuthorizeNet::CreditCard.new(nil, nil, :track_1 => "%B4111111111111111^DOE/JOHN^1803101000000000020000831000000?\xAA")
+    purchase = AuthorizeNet::AIM::Transaction.new(@cp_api_login, @cp_api_key, :gateway => :card_present_test, :test => false)
+    response = purchase.purchase(@amount, @credit_card)
+    response.success?.should be_true
+  end
+  
+  it "should be able to run a card present purchase with no LRC or Start/End Sentinels in track 1 data" do
+    @credit_card = AuthorizeNet::CreditCard.new(nil, nil, :track_1 => "B4111111111111111^DOE/JOHN^1803101000000000020000831000000")
+    purchase = AuthorizeNet::AIM::Transaction.new(@cp_api_login, @cp_api_key, :gateway => :card_present_test, :test => false)
+    response = purchase.purchase(@amount, @credit_card)
+    response.success?.should be_true
+  end
+  
+  it "should be able to run a card present purchase with track 2 data" do
+     @credit_card = AuthorizeNet::CreditCard.new(nil, nil, :track_2 => ';4111111111111111=1803101000020000831?')
+     purchase = AuthorizeNet::AIM::Transaction.new(@cp_api_login, @cp_api_key, :gateway => :card_present_test, :test => false)
+     response = purchase.purchase(@amount, @credit_card)
+     response.success?.should be_true
+   end
+
+   it "should be able to run a card present purchase with LRC codes in the track 2 data" do
+     @credit_card = AuthorizeNet::CreditCard.new(nil, nil, :track_2 => ";4111111111111111=1803101000020000831?\x33")
+     purchase = AuthorizeNet::AIM::Transaction.new(@cp_api_login, @cp_api_key, :gateway => :card_present_test, :test => false)
+     response = purchase.purchase(@amount, @credit_card)
+     response.success?.should be_true
+   end
+   
+   it "should be able to run a card present purchase with no LRC or Start/End Sentinels in track 2 data" do
+      @credit_card = AuthorizeNet::CreditCard.new(nil, nil, :track_2 => "4111111111111111=1803101000020000831")
+      purchase = AuthorizeNet::AIM::Transaction.new(@cp_api_login, @cp_api_key, :gateway => :card_present_test, :test => false)
+      response = purchase.purchase(@amount, @credit_card)
+      response.success?.should be_true
+    end
+  
+  it "should be able to validate the passed MD5 hash" do
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :transaction_type => @type, :gateway => @gateway, :test => @test_mode)
+    transaction.purchase(@amount, @credit_card).should be_kind_of(AuthorizeNet::AIM::Response)
+    transaction.response.success?.should be_true
+    transaction.response.valid_md5?(@api_login, @md5_value).should be_true
+  end
+  
+  it "should be able to validate the passed MD5 hash for card present transactions" do
+    @credit_card = AuthorizeNet::CreditCard.new(nil, nil, :track_1 => '%B4111111111111111^DOE/JOHN^1803101000000000020000831000000?')
+    purchase = AuthorizeNet::AIM::Transaction.new(@cp_api_login, @cp_api_key, :gateway => :card_present_test, :test => false)
+    response = purchase.purchase(@amount, @credit_card)
+    response.success?.should be_true
+    response.valid_md5?(@cp_api_login, @cp_md5_value).should be_true
+  end
+end
+
+
+describe AuthorizeNet::AIM::Response do
+  
+  before :all do
+    begin
+      creds = YAML.load_file(File.dirname(__FILE__) + "/credentials.yml")
+      @api_key = creds['api_transaction_key']
+      @api_login = creds['api_login_id']
+    rescue Errno::ENOENT => e
+      @api_key = "TEST"
+      @api_login = "TEST"
+      warn "WARNING: Running w/o valid AuthorizeNet sandbox credentials. Create spec/credentials.yml."
+    end
+  end
+  
+  before do
+    @cim_response = '1,1,1,This transaction has been approved.,000000,Y,2000000000,none,Test transaction for ValidateCustomerPaymentProfile.,0.01,CC,auth_only,custId123,John,Doe,,123 Main St.,Bellevue,WA,98004,USA,000-000-0000,,mark@example.com,,,,,,,,,0.00,0.00,0.00,,none,D18EB6B211FE0BBF556B271FDA6F92EE,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,'
+  end
+  
+  it "should support a Nokogiri based raw_response" do
+    builder = Nokogiri::XML::Builder.new(:encoding => 'utf-8') do |x|
+      x.directResponse(@cim_response)
+    end
+    @element = builder.doc.children[0]
+    @element.should be_kind_of(Nokogiri::XML::Element)
+    transaction = AuthorizeNet::AIM::Transaction.new(@api_login, @api_key, :test => false)
+    response = AuthorizeNet::AIM::Response.new(@element, transaction)
+    response.success?.should be_true
+    response.response_reason_text.should == 'This transaction has been approved.'
+  end
+end

data/spec/arb_spec.rb

@@ -0,0 +1,191 @@
+require "spec_helper"
+
+describe AuthorizeNet::ARB::Transaction do
+  
+  before :all do
+    begin
+      creds = YAML.load_file(File.dirname(__FILE__) + "/credentials.yml")
+      @api_key = creds['api_transaction_key']
+      @api_login = creds['api_login_id']
+    rescue Errno::ENOENT => e
+      @api_key = "TEST"
+      @api_login = "TEST"
+      warn "WARNING: Running w/o valid AuthorizeNet sandbox credentials. Create spec/credentials.yml."
+    end
+  end
+  
+  before do
+    @gateway = :sandbox
+    @subscription = AuthorizeNet::ARB::Subscription.new(
+      :name => "monthly foo",
+      :length => 1,
+      :unit => AuthorizeNet::ARB::Subscription::IntervalUnits::MONTH,
+      :start_date => Date.today,
+      :total_occurrences => 1,
+      :trial_occurrences => nil,
+      :amount => 10.00,
+      :trial_amount => nil, 
+      :invoice_number => rand(),
+      :description => "a test subscription",
+      :subscription_id => nil,
+      :credit_card => AuthorizeNet::CreditCard.new('4111111111111111', '01' + (Time.now + (3600 * 24 * 365)).strftime('%y')),
+      :billing_address => AuthorizeNet::Address.new(:first_name => 'John', :last_name => 'Doe')
+    )
+  end
+  
+  it "should support instantiation" do
+    AuthorizeNet::ARB::Transaction.new(@api_login, @api_key).should be_instance_of(AuthorizeNet::ARB::Transaction)
+  end
+  
+  it "should not have a response if the transaction hasn't been run" do
+    transaction = AuthorizeNet::ARB::Transaction.new(@api_login, @api_key, :gateway => @gateway)
+    transaction.has_response?.should be_false
+  end
+  
+  it "should support the returning its response object" do
+    transaction = AuthorizeNet::ARB::Transaction.new(@api_login, @api_key, :gateway => @gateway)
+    transaction.should respond_to(:response)
+  end
+  
+  it "should know if its running against the sandbox or not" do
+    transaction = AuthorizeNet::ARB::Transaction.new(@api_login, @api_key, :gateway => :sandbox)
+    transaction.test?.should be_true
+    transaction = AuthorizeNet::ARB::Transaction.new(@api_login, @api_key, :gateway => :live)
+    transaction.test?.should be_false
+    transaction = AuthorizeNet::ARB::Transaction.new(@api_login, @api_key, :gateway => 'moose')
+    transaction.test?.should be_true
+  end
+  
+  it "should have a response after running a transaction" do
+    transaction = AuthorizeNet::ARB::Transaction.new(@api_login, @api_key, :gateway => :sandbox)
+    response = transaction.create({})
+    response.should be_instance_of(AuthorizeNet::ARB::Response)
+  end
+  
+  it "should support creating a subscription" do
+    transaction = AuthorizeNet::ARB::Transaction.new(@api_login, @api_key, :gateway => :sandbox)
+    response = transaction.create(@subscription)
+    response.success?.should be_true
+  end
+  
+  it "should support canceling a subscription" do
+    transaction = AuthorizeNet::ARB::Transaction.new(@api_login, @api_key, :gateway => :sandbox)
+    response = transaction.create(@subscription)
+    response.success?.should be_true
+    cancel = AuthorizeNet::ARB::Transaction.new(@api_login, @api_key, :gateway => :sandbox)
+    response = cancel.cancel(response.subscription_id)
+    response.success?.should be_true
+  end
+  
+  it "should support getting the status of a subscription" do
+    create = AuthorizeNet::ARB::Transaction.new(@api_login, @api_key, :gateway => :sandbox)
+    response = create.create(@subscription)
+    response.success?.should be_true
+    status = AuthorizeNet::ARB::Transaction.new(@api_login, @api_key, :gateway => :sandbox)
+    response = status.get_status(response.subscription_id)
+    response.success?.should be_true
+    response.subscription_status.should == AuthorizeNet::ARB::Subscription::Status::ACTIVE
+  end
+  
+  it "should support updating a subscription" do
+    create = AuthorizeNet::ARB::Transaction.new(@api_login, @api_key, :gateway => :sandbox)
+    response = create.create(@subscription)
+    response.success?.should be_true
+    update = AuthorizeNet::ARB::Transaction.new(@api_login, @api_key, :gateway => :sandbox)
+    subscription = AuthorizeNet::ARB::Subscription.new(:subscription_id => response.subscription_id, :billing_address => AuthorizeNet::Address.new(:first_name => 'Jane', :last_name => 'Doe'))
+    response = update.update(subscription)
+    response.success?.should be_true
+  end
+end
+
+describe AuthorizeNet::ARB::Response do
+  
+  before :all do
+    begin
+      creds = YAML.load_file(File.dirname(__FILE__) + "/credentials.yml")
+      @api_key = creds['api_transaction_key']
+      @api_login = creds['api_login_id']
+    rescue Errno::ENOENT => e
+      @api_key = "TEST"
+      @api_login = "TEST"
+      warn "WARNING: Running w/o valid AuthorizeNet sandbox credentials. Create spec/credentials.yml."
+    end
+  end
+  
+  before do
+    
+  end
+  
+  it "should support instantiation" do
+    AuthorizeNet::ARB::Response.new('', nil).should be_instance_of(AuthorizeNet::ARB::Response)
+  end
+end
+
+describe AuthorizeNet::ARB::Subscription do
+  
+  before do
+    @attributes = [:name, :length, :unit, :start_date, :total_occurrences, :trial_occurrences, :amount, :trial_amount, :invoice_number, :description, :subscription_id]
+    @attribute_values = {
+      :name => "daily foo",
+      :length => 1,
+      :unit => AuthorizeNet::ARB::Subscription::IntervalUnits::DAY,
+      :start_date => Date.today,
+      :total_occurrences => 1,
+      :trial_occurrences => nil,
+      :amount => 10.00,
+      :trial_amount => nil, 
+      :invoice_number => '123456',
+      :description => "a test subscription",
+      :subscription_id => nil,
+      :credit_card => AuthorizeNet::CreditCard.new('4111111111111111', '01' + (Time.now + (3600 * 24 * 365)).strftime('%y')),
+      :billing_address => AuthorizeNet::Address.new(:first_name => 'John', :last_name => 'Doe')
+    }
+  end
+  
+  it "should support instantiation" do
+    AuthorizeNet::ARB::Subscription.new().should be_instance_of(AuthorizeNet::ARB::Subscription)
+  end
+  
+  it "should support access to its attributes" do
+    subscription = AuthorizeNet::ARB::Subscription.new(@attribute_values)
+    @attribute_values.each do |k, v|
+      subscription.send(k).should == v
+    end
+  end
+  
+  it "should support connivence values for unlimited subscription length" do
+    subscription = AuthorizeNet::ARB::Subscription.new(:length => :unlimited)
+    subscription.length.should == AuthorizeNet::ARB::Subscription::UNLIMITED_OCCURRENCES
+    subscription = AuthorizeNet::ARB::Subscription.new()
+    subscription.length = :unlimited
+    subscription.length.should == AuthorizeNet::ARB::Subscription::UNLIMITED_OCCURRENCES
+  end
+  
+  it "should support connivence values for day interval units" do
+    subscription = AuthorizeNet::ARB::Subscription.new(:unit => :day)
+    subscription.unit.should == AuthorizeNet::ARB::Subscription::IntervalUnits::DAY
+    subscription = AuthorizeNet::ARB::Subscription.new(:unit => :days)
+    subscription.unit.should == AuthorizeNet::ARB::Subscription::IntervalUnits::DAY
+    subscription = AuthorizeNet::ARB::Subscription.new()
+    subscription.unit = :day
+    subscription.unit.should == AuthorizeNet::ARB::Subscription::IntervalUnits::DAY
+    subscription = AuthorizeNet::ARB::Subscription.new()
+    subscription.unit = :days
+    subscription.unit.should == AuthorizeNet::ARB::Subscription::IntervalUnits::DAY
+  end
+  
+  it "should support connivence values for month interval units" do
+    subscription = AuthorizeNet::ARB::Subscription.new(:unit => :month)
+    subscription.unit.should == AuthorizeNet::ARB::Subscription::IntervalUnits::MONTH
+    subscription = AuthorizeNet::ARB::Subscription.new(:unit => :months)
+    subscription.unit.should == AuthorizeNet::ARB::Subscription::IntervalUnits::MONTH
+    subscription = AuthorizeNet::ARB::Subscription.new()
+    subscription.unit = :month
+    subscription.unit.should == AuthorizeNet::ARB::Subscription::IntervalUnits::MONTH
+    subscription = AuthorizeNet::ARB::Subscription.new()
+    subscription.unit = :months
+    subscription.unit.should == AuthorizeNet::ARB::Subscription::IntervalUnits::MONTH
+  end
+end
+
+