harleytt-simplepay 0.2.2

data/test/simplepay/services/test_subscription.rb

@@ -0,0 +1,109 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+require 'simplepay/services/subscription'
+
+class Simplepay::Services::TestSubscription < Test::Unit::TestCase
+  
+  def self.model_class; Simplepay::Services::Subscription; end
+  
+  context 'Simplepay::Services::Subscription' do
+    
+    should_have_service_field :immediate_return,
+                              :class    => Simplepay::Support::Boolean, 
+                              :as       => 'immediateReturn',
+                              :required => false
+    
+    should_have_service_field :number_of_promotion_transactions,  
+                              :as       => 'noOfPromotionTransactions',
+                              :required => false
+    
+    should_have_service_field :start_date,
+                              :class    => Simplepay::Support::Epoch, 
+                              :as       => 'recurringStartDate',
+                              :required => false
+    
+    should_have_service_field :collect_shipping_address,
+                              :as       => 'collectShippingAddress', 
+                              :required => false,
+                              :class    => Simplepay::Support::Boolean
+    
+    should_have_service_field :promotion_amount,
+                              :as       => 'promotionAmount', 
+                              :required => false,
+                              :class    => Simplepay::Support::Amount
+    
+    should_have_service_field :access_key,
+                              :as       => 'accessKey', 
+                              :required => true
+    
+    should_have_service_field :subscription_period,
+                              :as       => 'subscriptionPeriod', 
+                              :required => false,
+                              :class    => Simplepay::Support::SubscriptionPeriod
+
+    should_have_service_field :reference_id,
+                              :as       => 'referenceId', 
+                              :required => false
+
+    should_have_service_field :recurring_frequency,
+                              :as       => 'recurringFrequency', 
+                              :required => true,
+                              :class    => Simplepay::Support::BillingFrequency
+
+    should_have_service_field :amount,
+                              :as       => 'amount', 
+                              :required => true,
+                              :class    => Simplepay::Support::Amount
+
+    should_have_service_field :variable_marketplace_fee,
+                              :as       => 'variableMarketplaceFee', 
+                              :required => false
+
+    should_have_service_field :signature,
+                              :as       => 'signature', 
+                              :required => true
+
+    should_have_service_field :donation_widget,
+                              :as       => 'isDonationWidget', 
+                              :required => false
+
+    should_have_service_field :fixed_marketplace_fee,
+                              :as       => 'fixedMarketplaceFee', 
+                              :required => false
+
+    should_have_service_field :auto_renew,
+                              :as       => 'isAutoRenewal', 
+                              :required => false,
+                              :class    => Simplepay::Support::Boolean
+
+    should_have_service_field :description,
+                              :as       => 'description', 
+                              :required => true
+
+    should_have_service_field :account_id,
+                              :as       => 'amazonPaymentsAccountId', 
+                              :required => true
+
+    should_have_service_field :ipn_url,
+                              :as       => 'ipnUrl', 
+                              :required => false
+
+    should_have_service_field :return_url,
+                              :as       => 'returnUrl', 
+                              :required => false
+
+    should_have_service_field :process_immediately,
+                              :as       => 'processImmediate', 
+                              :required => false,
+                              :class    => Simplepay::Support::Boolean
+
+    should_have_service_field :cobranding_style,
+                              :as       => 'cobrandingStyle', 
+                              :required => true
+
+    should_have_service_field :abandon_url,
+                              :as       => 'abandonUrl', 
+                              :required => false
+    
+  end
+  
+end

data/test/simplepay/support/test_amount.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+require 'simplepay/support/amount'
+
+class Simplepay::Support::TestAmount < Test::Unit::TestCase
+  
+  context 'Simplepay::Support::Amount' do
+    
+    should 'convert to Amazon formatted string' do
+      assert_equal 'USD 5.00', new_amount(5).to_s
+      assert_equal 'USD 6.10', new_amount(6.1).to_s
+      assert_equal 'USD 5.25', new_amount(5.25).to_s
+    end
+    
+    should 'raise an error for negative amounts' do
+      assert_raise(ArgumentError) { new_amount(-1) }
+    end
+    
+    should 'be able to set your desired currency by code' do
+      amount = new_amount(1, 'USD')
+      assert_equal 'USD', amount.currency.to_s
+    end
+    
+    should 'raise an error when using an unrecognized currency code' do
+      assert_raise(ArgumentError) { new_amount(1, 'BADCURRENCYCODE') }
+    end
+    
+    should 'be able to use a custom currency by object' do
+      custom = Simplepay::Support::Currency.new('Test Currency', 'TEST', "%d")
+      amount = new_amount(1, custom)
+      assert_equal custom, amount.currency
+      assert_equal "TEST 1", amount.to_s
+    end
+    
+  end
+  
+  
+  private
+  
+  
+  def new_amount(amount, currency = nil)
+    currency ? 
+      Simplepay::Support::Amount.new(amount, currency) :
+      Simplepay::Support::Amount.new(amount)
+  end
+  
+end

data/test/simplepay/support/test_billing_frequency.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+require 'simplepay/support/billing_frequency'
+
+class Simplepay::Support::TestBillingFrequency < Test::Unit::TestCase
+  
+  context 'Simplepay::Support::BillingFrequency' do
+    
+    setup do
+      @interval = Simplepay::Support::BillingFrequency.new
+    end
+    
+    should 'not set default values' do
+      assert_nil @interval.interval
+      assert_nil @interval.quantity
+    end
+    
+    should 'only allow defined intervals' do
+      intervals = ['day', 'week', 'month', 'year']
+      added     = @interval.class.allowed_intervals - intervals
+      missed    = intervals - @interval.class.allowed_intervals
+      assert added.empty?,  "#{@interval.class.name} defines unexpected intervals: #{added.inspect}"
+      assert missed.empty?, "#{@interval.class.name} failed to define expected intervals: #{missed.inspect}"
+    end
+    
+    should 'limit quantities to two digits' do
+      assert_raise(ArgumentError) { @interval.quantity = 100 }
+    end
+    
+    should 'disallow 0 quantity' do
+      assert_raise(ArgumentError) { @interval.quantity = 0 }
+    end
+    
+    should 'disallow negative quantities' do
+      assert_raise(ArgumentError) { @interval.quantity = -1 }
+    end
+    
+    should 'convert to String' do
+      assert_equal '5 year', @interval.class.new(5, 'year').to_s
+    end
+    
+  end
+  
+end

data/test/simplepay/support/test_boolean.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+class Simplepay::Support::BooleanTest < Test::Unit::TestCase
+  
+  context 'Simplepay::Support::Boolean' do
+    
+    should 'use "1" for true' do
+      assert_equal '1', Simplepay::Support::Boolean.new(true).to_s
+    end
+    
+    should 'use "0" for false' do
+      assert_equal '0', Simplepay::Support::Boolean.new(false).to_s
+    end
+    
+  end
+  
+end

data/test/simplepay/support/test_epoch.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+require 'simplepay/support/epoch'
+
+class Simplepay::Support::TestEpoch < Test::Unit::TestCase
+  
+  context "Simplepay::Support::Epoch" do
+    
+    should 'return time as an integer' do
+      time = Time.now
+      assert_equal time.to_i.to_s, new_epoch(time).to_s
+    end
+    
+    should 'parse a given string for Time' do
+      assert_equal "1199150625", new_epoch("2008-01-01 01:23:45Z").to_s
+    end
+    
+    should 'represent seconds since January 1, 1970' do
+      time    = Time.parse("1970-01-01 00:00:00Z")
+      now     = Time.now
+      seconds = (now - time).to_i
+      assert_equal seconds.to_s, new_epoch(now).to_s
+    end
+    
+  end
+  
+  
+  private
+  
+  
+  def new_epoch(value)
+    Simplepay::Support::Epoch.new(value)
+  end
+  
+end

data/test/simplepay/support/test_field.rb

@@ -0,0 +1,99 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+require 'simplepay/support/field'
+
+class DelegateTest
+  def initialize(v); end
+  def to_s; end
+end
+
+class Simplepay::Support::TestField < Test::Unit::TestCase
+  
+  context 'Simplepay::Support::Field' do
+    
+    should 'raise error for invalid options' do
+      assert_raise(Simplepay::InvalidOptions) { new_field(:bad, {:bad_field => 'foo'}) }
+    end
+    
+    should 'set the value via options' do
+      assert_equal 'set value', new_field(:test, :value => 'set value').value
+    end
+    
+    should 'camelize the service name when given a symbol' do
+      assert_equal 'testField', new_field(:test_field).service_name
+    end
+    
+    should 'use the given string name as service name' do
+      assert_equal 'TestField', new_field('TestField').service_name
+      assert_equal 'test_field', new_field('test_field').service_name
+    end
+    
+    should 'use the :as option to override the service name' do
+      assert_equal 'Overridden', new_field(:original, :as => 'Overridden').service_name
+    end
+    
+    should 'use the service name when converted to String' do
+      field = new_field(:test_field)
+      assert_equal field.service_name, field.to_s
+    end
+    
+    should 'not be required by default' do
+      assert !new_field(:optional_field).required?
+    end
+    
+    should 'be required' do
+      assert new_field(:required_field, :required => true).required?
+    end
+    
+    should 'change the service parent for cloned objects' do
+      field1 = new_field(:clone)
+      field2 = field1.clone_for(new_service)
+      assert_equal      field1.name,    field2.name
+      assert_equal      field1.value,   field2.value
+      assert_not_equal  field1.service, field2.service
+    end
+    
+    should 'be equivalent' do
+      field1 = new_field(:equal, {})
+      field2 = new_field(:equal, {}, field1.service)
+      assert_equal field1, field2
+    end
+    
+    should 'not be equivalent' do
+      field1 = new_field(:equal, {}, new_service)
+      field2 = new_field(:equal, {}, new_service)
+      assert_not_equal field1, field2
+    end
+    
+    should 'correctly sort' do
+      fielda, fieldb, fieldc = new_field(:a), new_field(:b), new_field(:c)
+      assert_equal [fielda, fieldb, fieldc], [fieldc, fielda, fieldb].sort
+    end
+    
+    should 'pass itself as a proc parameter if value is a proc' do
+      field   = new_field(:test, {:value => Proc.new { |f| f}})
+      assert_equal field, field.value
+    end
+    
+    should 'be able to delegate value handling to another class' do
+      delegate = DelegateTest.new('foo')
+      DelegateTest.expects(:new).with('foo').once.returns(delegate)
+      delegate.expects(:to_s).times(2).returns('mocked')
+      field = new_field(:delegated, {:class => DelegateTest, :value => 'foo'})
+      assert_equal delegate.to_s, field.value
+    end
+    
+  end
+  
+  
+  private
+  
+  
+  def new_field(name, options = {}, service = new_service)
+    Simplepay::Support::Field.new(service, name, options)
+  end
+  
+  def new_service
+    Simplepay::Service.new
+  end
+  
+end

data/test/simplepay/support/test_interval.rb

@@ -0,0 +1,92 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+require 'simplepay/support/interval'
+
+class TestInterval < Simplepay::Support::Interval
+  ALLOWED_QUANTITY_RANGE  = (1..200)
+  ALLOWED_INTERVALS       = ['testinterval', 'testinterval2']
+  DEFAULT_QUANTITY        = 3
+  DEFAULT_INTERVAL        = 'testinterval'
+end
+
+class Simplepay::Support::TestInterval < Test::Unit::TestCase
+  
+  context 'Simplepay::Support::Interval' do
+    
+    setup do
+      @interval = TestInterval.new
+    end
+    
+    should 'set the default quantity' do
+      assert_equal 3, @interval.quantity
+    end
+    
+    should 'set the default interval' do
+      assert_equal 'testinterval', @interval.interval
+    end
+    
+    should 'properly convert to string' do
+      assert_equal '3 testinterval', @interval.to_s
+    end
+    
+    should 'return nil with converted to a string with no interval set' do
+      @interval.interval = nil
+      assert_nil @interval.to_s
+    end
+    
+    should 'raise an error for quantities outside of the allowed range' do
+      assert_raises(ArgumentError) {
+        @interval.quantity = @interval.class.allowed_quantity_range.last + 1
+      }
+    end
+    
+    should 'accept valid quantities' do
+      assert_nothing_raised(Exception) {
+        @interval.quantity = @interval.class.allowed_quantity_range.first
+        @interval.quantity = @interval.class.allowed_quantity_range.first + 1
+        @interval.quantity = @interval.class.allowed_quantity_range.last - 1
+        @interval.quantity = @interval.class.allowed_quantity_range.last
+      }
+      assert_equal @interval.class.allowed_quantity_range.last, @interval.quantity
+    end
+    
+    should 'raise an error for intervals which are not allowed' do
+      assert_raises(ArgumentError) {
+        @interval.interval = 'badtestinterval'
+      }
+    end
+    
+    should 'accept valid intervals' do
+      assert_nothing_raised(Exception) {
+        @interval.interval = @interval.class.allowed_intervals.first
+        @interval.interval = @interval.class.allowed_intervals.last
+      }
+      assert_equal @interval.class.allowed_intervals.last, @interval.interval
+    end
+    
+    should 'be definable by string' do
+      interval = TestInterval.new("5 testinterval2")
+      assert_equal 5, interval.quantity
+      assert_equal 'testinterval2', interval.interval
+    end
+    
+    should 'raise an error for an improperly formatted string' do
+      assert_raise(ArgumentError) {
+        TestInterval.new("Bad String")
+      }
+    end
+    
+    should 'be definable by parameter' do
+      interval = TestInterval.new(5, 'testinterval2')
+      assert_equal 5, interval.quantity
+      assert_equal 'testinterval2', interval.interval
+    end
+    
+    should 'be definable by a hash' do
+      interval = TestInterval.new({:quantity => 5, :interval => 'testinterval2'})
+      assert_equal 5, interval.quantity
+      assert_equal 'testinterval2', interval.interval
+    end
+    
+  end
+  
+end