billing_logic 0.0.3

data/lib/billing_logic/strategies/independent_payment_strategy.rb

@@ -0,0 +1,322 @@
+require 'forwardable'
+
+module BillingLogic::Strategies
+  # Because this is no longer the behavior in Ruby 2(.3?)
+  class ToStringArray < Array
+    def to_s
+      "[#{map { |child| child.to_s }.join(', ')}]"
+    end
+  end
+  # The BaseStrategy defines generic functions used by various BillingLogic::Strategies.
+  class IndependentPaymentStrategy
+
+    attr_accessor :desired_state, :current_state, :payment_command_builder_class, :default_command_builder
+
+    def initialize(opts = {})
+      @current_state = opts.delete(:current_state) || []
+      @desired_state = opts.delete(:desired_state) || []
+      @command_list = ToStringArray.new
+      @payment_command_builder_class = opts.delete(:payment_command_builder_class) || default_command_builder
+    end
+
+    # Returns a string representing the commands the Strategy generates
+    #
+    # @return [String] the string representation of the commands the Strategy generates
+    def command_list
+      calculate_list
+      @command_list.flatten
+    end
+
+    # Returns BillingEngine::Client::Products to be added, grouped by date
+    #
+    def products_to_be_added_grouped_by_date
+      group_by_date(products_to_be_added)
+    end
+
+    # Returns an array of BillingEngine::Client::Products to be added because they're desired but not active
+    # 
+    # @return [Array<BillingEngine::Client::Product>] array of desired but inactive BillingEngine::Client::Products scheduled to be added
+    def products_to_be_added
+      desired_state.reject do |product|
+        ProductComparator.new(product).in_like?(active_products)
+      end
+    end
+
+    # Returns an array of BillingEngine::Client::Products to be removed because they're active but not desired
+    # 
+    # @return [Array<BillingEngine::Client::Product>] array of active but no longer desired BillingEngine::Client::Products scheduled for removal
+    def products_to_be_removed
+      active_products.reject do |product|
+        ProductComparator.new(product).included?(desired_state)
+      end
+    end
+
+    # Returns an array of inactive BillingEngine::Client::Products in the CurrentState
+    #
+    # @return [Array<BillingEngine::Client::Product>] array of inactive BillingEngine::Client::Products in the CurrentState
+    def inactive_products
+      neither_active_nor_pending_profiles.map { |profile| profile.products }.flatten
+    end
+
+    # Returns an array of PaymentProfiles with profile_status 'ActiveProfile' or 'PendingProfile'
+    #
+    # @return [Array<PaymentProfile>] array of PaymentProfiles in the CurrentState with profile_status 'ActiveProfile' or 'PendingProfile'
+    def active_profiles
+      active_or_pending_profiles
+    end
+
+    # Returns an array of active BillingEngine::Client::Products from the CurrentState
+    #
+    # @return [Array<BillingEngine::Client::Product>] array of active BillingEngine::Client::Products in the CurrentState
+    def active_products
+      current_state.active_products
+    end
+
+    # CurrentState PaymentProfiles with payment_profile of 'ActiveProfile' or 'PendingProfile'
+    #
+    # @return [Array<PaymentProfile>] array of all 'ActiveProfile' or 'PendingProfile' PaymentProfiles
+    #   for the CurrentState
+    def active_or_pending_profiles
+      current_state.reject { |profile| !profile.active_or_pending? }
+    end
+
+    # CurrentState PaymentProfiles with payment_profile of neither 'ActiveProfile' nor 'PendingProfile' (i.e., either
+    # 'CancelledProfile' or 'ComplimentaryProfile')
+    #
+    # @return [Array<PaymentProfile>] array of all PaymentProfiles for the CurrentState with payment_profile of neither 
+    # 'ActiveProfile' nor 'PendingProfile'
+    def neither_active_nor_pending_profiles
+      current_state.reject { |profile| profile.active_or_pending? }
+    end
+
+    # @deprecated Too confusing. Please directly call #active_or_pending_profiles or #neither_active_nor_pending_profiles
+    def profiles_by_status(active_or_pending = nil)
+      active_or_pending ? active_or_pending_profiles : neither_active_nor_pending_profiles
+    end
+
+    protected
+
+    # Declares IndependentPaymentStrategy's #default_command_builder to be
+    #   BillingLogic::CommandBuilders::WordBuilder
+    # @return [BillingLogic::CommandBuilders::WordBuilder]
+    def default_command_builder
+      BillingLogic::CommandBuilders::WordBuilder
+    end
+
+    def removed_obsolete_subscriptions(subscriptions)
+      [subscriptions.select{ |sub| sub.active_or_pending? } + subscriptions.reject { |sub| !sub.paid_until_date || sub.paid_until_date < today } ].flatten.compact.uniq
+    end
+
+    def calculate_list
+      reset_command_list!
+      add_commands_for_products_to_be_removed!
+      add_commands_for_products_to_be_added!
+    end
+
+    # adds recurring payment command (strings) to @command_list for the 
+    #   group_of_products and date passed as block parameters
+    def add_commands_for_products_to_be_added!
+      with_products_to_be_added do |group_of_products, date|
+        group_of_products.each do |products|
+          @command_list << create_recurring_payment_command([products], :paid_until_date => date)
+        end
+      end
+    end
+
+    # this doesn't feel like it should be here
+    def group_by_date(new_products)
+      group = {}
+      new_products.each do |product|
+        date = nil
+        if previously_cancelled_product?(product)
+          date = next_payment_date_from_profile_with_product(product, :active => false)
+        elsif (previous_product = changed_product_subscription?(product))
+          unless previous_product_was_disabled?(product, previous_product)
+            update_product_billing_cycle_and_payment!(product, previous_product)
+            date = next_payment_date_from_product(product, previous_product)
+          end
+        end
+        date = (date.nil? || date < today) ? today : date
+        group[date] ||= []
+        group[date] << product
+      end
+      group.map { |k, v| [v, k] }
+    end
+
+    def previously_cancelled_product?(product)
+      inactive_products.detect do |inactive_product|
+        ProductComparator.new(inactive_product).same_class?(product)
+      end
+    end
+
+    def changed_product_subscription?(product)
+      products_to_be_removed.detect do |removed_product|
+        ProductComparator.new(removed_product).same_class?(product)
+      end
+    end
+
+    def next_payment_date_from_profile_with_product(product, opts = {:active => false})
+      (opts[:active] ? active_or_pending_profiles : neither_active_nor_pending_profiles).map do |profile|
+        profile.paid_until_date if ProductComparator.new(product).in_class_of?(profile.products)
+      end.compact.max
+    end
+
+    def update_product_billing_cycle_and_payment!(product, previous_product)
+      if product.billing_cycle.periodicity > previous_product.billing_cycle.periodicity
+        product.billing_cycle.anniversary = previous_product.billing_cycle.anniversary
+      end
+    end
+
+    def next_payment_date_from_product(product, previous_product)
+      if product.billing_cycle.periodicity > previous_product.billing_cycle.periodicity
+        product.billing_cycle.anniversary
+      else
+        product.billing_cycle.anniversary = next_payment_date_from_profile_with_product(product, :active => true)
+      end
+    end
+
+    def previous_product_was_disabled?(product, previous_product)
+      @command_list.compact.detect do |command|
+        command.products.any? {|product| product.identifier == previous_product.identifier } && command.disable
+      end
+    end
+
+    # for easy stubbing/subclassing/replacement
+    def today
+      Date.current
+    end
+
+    public
+    # this should be part of a separate strategy object
+    def add_commands_for_products_to_be_removed!
+      active_profiles.each do |profile|
+
+        # We need to issue refunds before cancelling profiles
+        refund_options = issue_refunds_if_necessary(profile)
+        remaining_products = remaining_products_after_product_removal_from_profile(profile)
+
+        if remaining_products.empty? # all products in payment profile needs to be removed
+
+          @command_list << cancel_recurring_payment_command(profile, refund_options)
+
+        elsif remaining_products.size == profile.products.size # nothing has changed
+        #
+        # do nothing
+        #
+        else  # only some products are being removed and the profile needs to be updated
+
+          if remaining_products.size >= 1
+
+            @command_list << remove_product_from_payment_profile(profile.identifier,
+                                                                 removed_products_from_profile(profile),
+                                                                 refund_options)
+          else
+
+            @command_list << cancel_recurring_payment_command(profile, refund_options)
+            @command_list << create_recurring_payment_command(remaining_products,
+                                                              :paid_until_date => profile.paid_until_date,
+                                                              :period => extract_period_from_product_list(remaining_products))
+          end
+        end
+      end
+    end
+
+    def extract_period_from_product_list(products)
+      products.first.billing_cycle.period
+    end
+
+    def remaining_products_after_product_removal_from_profile(profile)
+      profile.active_products.reject { |product| products_to_be_removed.include?(product) }
+    end
+
+    def removed_products_from_profile(profile)
+      profile.products.select { |product| products_to_be_removed.include?(product) }
+    end
+
+    def issue_refunds_if_necessary(profile)
+      ret = {}
+      if !profile.refundable_payment_amount(removed_products_from_profile(profile)).zero?
+        ret.merge!(refund_recurring_payments_command(profile.identifier, profile.refundable_payment_amount(removed_products_from_profile(profile))))
+        ret.merge!(disable_subscription(profile.identifier))
+      elsif ((Date.current - 1) <= profile.billing_start_date) # && (Date.current >= profile.billing_start_date)
+        ret.merge!(disable_subscription(profile.identifier))
+      end
+      ret
+    end
+
+    def refund_recurring_payments_command(profile_id, amount)
+      { :refund => amount, :profile_id => profile_id }
+    end
+
+    def disable_subscription(profile_id)
+      { :disable => true }
+    end
+
+    # these messages seems like they should be pluggable
+    def cancel_recurring_payment_command(profile, opts = {})
+      payment_command_builder_class.cancel_recurring_payment_commands(profile, opts)
+    end
+
+    def remove_product_from_payment_profile(profile_id, removed_products, opts = {})
+      payment_command_builder_class.remove_product_from_payment_profile(profile_id, removed_products, opts)
+    end
+
+    def create_recurring_payment_command(products, opts = {:paid_until_date => Date.current})
+      payment_command_builder_class.create_recurring_payment_commands(products, opts)
+    end
+
+    def with_products_to_be_added(&block)
+      unless (products_to_be_added = products_to_be_added_grouped_by_date).empty?
+        products_to_be_added.each do |group_of_products, date|
+          yield(group_of_products, date)
+        end
+      end
+    end
+
+    class ProductComparator
+      extend Forwardable
+      def_delegators :@product, :name, :price, :billing_cycle
+      def initialize(product)
+        @product = product
+      end
+
+      def included?(product_list)
+        product_list.any? { |product| ProductComparator.new(product).similar?(self) }
+      end
+
+      def in_class_of?(product_list)
+        product_list.any? { |product| ProductComparator.new(product).same_class?(self) }
+      end
+
+      def in_like?(product_list)
+        product_list.any? { |product| ProductComparator.new(product).like?(self) }
+      end
+
+      def like?(other_product)
+        similar?(other_product) && same_periodicity?(other_product)
+      end
+
+      def similar?(other_product)
+        same_class?(other_product) &&  same_price?(other_product)
+      end
+
+      def same_periodicity?(other_product)
+        @product.billing_cycle.periodicity == other_product.billing_cycle.periodicity
+      end
+
+      def same_class?(other_product)
+        @product.name == other_product.name
+      end
+
+      def same_price?(other_product)
+        BigDecimal(@product.price.to_s) == BigDecimal(other_product.price.to_s)
+      end
+
+    end
+
+    def reset_command_list!
+      @command_list.clear
+    end
+
+  end
+end

data/lib/billing_logic/version.rb

@@ -0,0 +1,3 @@
+module BillingLogic
+  VERSION = "0.0.3"
+end

data/lib/billing_logic.rb

@@ -0,0 +1,23 @@
+require 'bigdecimal'
+require "billing_logic/version"
+require 'billing_logic/current_state'
+require 'billing_logic/billing_cycle'
+require 'billing_logic/proration_calculator'
+require 'billing_logic/payment_command_builder'
+require 'billing_logic/command_builders/command_builders'
+require 'active_support/core_ext/date/calculations'
+module BillingLogic
+  module CommandBuilders
+    autoload :BuilderHelpers, 'billing_logic/command_builders/command_builders'
+    autoload :BasicBuilder, 'billing_logic/command_builders/command_builders'
+    autoload :WordBuilder , 'billing_logic/command_builders/command_builders'
+    autoload :AggregateWordBuilder, 'billing_logic/command_builders/command_builders'
+    autoload :ActionObject,         'billing_logic/command_builders/command_builders'
+    autoload :SINGLE_PRODUCT_REGEX, 'billing_logic/command_builders/command_builders'
+    autoload :CurrentState,         'billing_logic/current_state'
+
+  end
+  module Strategies
+    autoload :IndependentPaymentStrategy, 'billing_logic/strategies/independent_payment_strategy'
+  end
+end

data/spec/billing_info/billing_cycle_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe BillingLogic::BillingCycle do
+  context "a billing cycle" do
+    before do 
+      @cycle_45_days      = BillingLogic::BillingCycle.new(:period => :day,       :frequency => 45)
+      @one_day_cycle      = BillingLogic::BillingCycle.new(:period => :day,       :frequency => 1)
+      @one_week_cycle     = BillingLogic::BillingCycle.new(:period => :week,      :frequency => 1)
+      @semimonth_cycle    = BillingLogic::BillingCycle.new(:period => :semimonth, :frequency => 1)
+      @one_month_cycle    = BillingLogic::BillingCycle.new(:period => :month,     :frequency => 1)
+      @one_year_cycle     = BillingLogic::BillingCycle.new(:period => :year,      :frequency => 1)
+    end
+
+    it "should know about its period type" do
+      @cycle_45_days.period.should == :day
+    end
+
+    it "should know about its frequency" do
+      @cycle_45_days.frequency.should == 45
+    end
+
+    it "should be able to calculate its periodicity" do
+      @cycle_45_days.periodicity.should == 45
+      @one_year_cycle.periodicity.should == 365
+    end
+
+    it "should know how to compare itself" do
+      @one_day_cycle.should   < @one_week_cycle
+      @one_week_cycle.should  < @semimonth_cycle
+      @semimonth_cycle.should < @one_month_cycle
+      @one_month_cycle.should < @cycle_45_days
+      @cycle_45_days.should   < @one_year_cycle 
+    end
+  end
+end

data/spec/billing_info/command_builders/command_builder_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe BillingLogic::CommandBuilders::ActionObject do
+
+  before do
+    Time.zone = "Eastern Time (US & Canada)"
+  end
+
+  it "removes two products from a bundle with one payment profile" do
+    command = "remove (B @ $20/mo & C @ $20/mo) from [(A @ $30/mo & B @ $20/mo & C @ $20/mo) @ $70/mo] now"
+    BillingLogic::CommandBuilders::ActionObject.from_string(command).to_s.should == command
+  end
+
+  it "adds two new products" do
+    command = "add (B @ $20/mo & C @ $20/mo) @ $40.00/mo now"
+    translated_command = command.gsub("now", "on ") + Time.zone.now.strftime('%m/%d/%y')
+    BillingLogic::CommandBuilders::ActionObject.from_string(command).to_s.should == translated_command
+  end
+
+  it "cancels a product" do
+    command = "cancel [A @ $30/mo] now"
+    BillingLogic::CommandBuilders::ActionObject.from_string(command).to_s.should == command
+  end
+
+  it "cancels a product that is also a bundle (indicated by parentheses)" do
+    command = "cancel [(A @ $30/mo) @ $30/mo] now"
+    BillingLogic::CommandBuilders::ActionObject.from_string(command).to_s.should == command
+  end
+
+  it "adds a product on a future date" do
+    command = "add (B @ $300/yr) @ $300.00/yr on 03/10/12"
+    BillingLogic::CommandBuilders::ActionObject.from_string(command).to_s.should == command
+  end
+
+  it "cancels and disables a product" do
+    command = "cancel and disable [(A @ $30/mo & B @ $40/mo & C @ $25/mo) @ $95/mo] with refund $30.00 now"
+    BillingLogic::CommandBuilders::ActionObject.from_string(command).to_s.should == command
+  end
+
+  it "expects you to pass in 'from [...]' when removing a product" do
+    command = "remove (B @ $20/mo & C @ $20/mo) now"
+    translated_command = command.sub("now","from [] now")
+    BillingLogic::CommandBuilders::ActionObject.from_string(command).to_s.should == translated_command
+  end
+
+end
+

data/spec/billing_info/independent_payment_strategy_spec.rb

@@ -0,0 +1,234 @@
+require 'spec_helper'
+
+module BillingLogic
+
+  # an IndependentPaymentStrategy gives each product its own payment_profile
+  describe Strategies::IndependentPaymentStrategy do
+    module With0RefundablePayment
+      def refundable_payment_amount(foo)
+        0.0
+      end
+    end
+    let(:monthly_cycle) do
+      BillingCycle.new(:period => :month,
+                       :frequency => 1,
+                       :anniversary => Date.current - 7)
+    end
+
+    let(:yearly_cycle) do
+      BillingCycle.new(:period => :year,
+                       :frequency => 1,
+                       :anniversary => Date.current - 7)
+    end
+
+    let(:product_a) { MockProduct.new(:identifier => 1, :name => 'A', :price => 10, :billing_cycle => monthly_cycle, :initial_payment => 0.0) }
+    let(:product_a_yearly) { MockProduct.new(:identifier => 1, :name => 'A', :price => 90, :billing_cycle => yearly_cycle, :initial_payment => 0.0) }
+    let(:product_b) { MockProduct.new(:identifier => 2, :name => 'B', :price => 20, :billing_cycle => monthly_cycle, :initial_payment => 0.0) }
+    let(:product_c) { MockProduct.new(:identifier => 3, :name => 'C', :price => 30, :billing_cycle => monthly_cycle, :initial_payment => 0.0) }
+    let(:product_d) { MockProduct.new(:identifier => 4, :name => 'D', :price => 40, :billing_cycle => monthly_cycle, :initial_payment => 0.0) }
+    let(:strategy)  { Strategies::IndependentPaymentStrategy.new(:current_state => ::BillingLogic::CurrentState.new([])) }
+
+
+    let(:profile_a) do
+      MockProfile.new(
+            :products =>          [product_a, product_b],
+            :current_products =>  [product_a, product_b],
+            :active_products =>   [product_a, product_b],
+            :price => 30,
+            :identifier => 'i-1',
+            :billing_start_date => monthly_cycle.anniversary,
+            :paid_until_date => monthly_cycle.next_payment_date,
+            :active_or_pending => true
+           )
+    end
+
+    let(:canceled_profile_d) do
+      MockProfile.new(
+                     :products => [product_d],
+                     :current_products => [product_d],
+                     :active_products => [],
+                     :price => 40,
+                     :identifier => 'i-4',
+                     :billing_start_date => monthly_cycle.anniversary,
+                     :paid_until_date => monthly_cycle.next_payment_date,
+                     :active_or_pending => false,
+                    )
+    end
+
+    let(:strategy_with_3_active_products) do
+      profile = MockProfile.new(
+                     :products => [product_c],
+                     :current_products => [product_c],
+                     :active_products => [product_c],
+                     :price => 30,
+                     :identifier => 'i-2',
+                     :billing_start_date => monthly_cycle.anniversary,
+                     :paid_until_date => monthly_cycle.next_payment_date,
+                     :active_or_pending => true,
+                     )
+      Strategies::IndependentPaymentStrategy.new(:current_state => ::BillingLogic::CurrentState.new([profile_a, profile]))
+    end
+
+    describe "#active_products" do
+      it "should return an array" do
+        strategy.active_products.should be_kind_of(Array)
+      end
+
+      it "should return the products in the current state" do
+        strategy_with_3_active_products.active_products.should == [product_a, product_b, product_c]
+      end
+    end
+
+    describe "#products_to_be_added" do
+      it "should not return products that are already in the current state" do
+        strategy.current_state = ::BillingLogic::CurrentState.new([])
+        strategy.desired_state = []
+        strategy.products_to_be_added.should be_empty
+      end
+
+      it "should return products that are not in the current state" do
+        strategy.current_state = ::BillingLogic::CurrentState.new([])
+        strategy.desired_state = [product_a]
+        strategy.products_to_be_added.should == [product_a]
+      end
+    end
+
+    describe "#products_to_be_added_grouped_by_date" do
+      it "should return products that are not in the current state" do
+        strategy.current_state = ::BillingLogic::CurrentState.new([])
+        strategy.desired_state = [product_a]
+        strategy.products_to_be_added_grouped_by_date.should == [[[product_a], Date.current]]
+      end
+    end
+
+    context 'with empty current state' do
+      let(:strategy) { Strategies::IndependentPaymentStrategy.new(:current_state => ::BillingLogic::CurrentState.new([])) }
+
+      context 'with an empty desired state' do
+        it 'should return an empty command list' do
+          strategy.command_list.should == []
+        end
+      end
+
+      context 'with 1 new subscription in the desired state' do
+        before do
+          strategy.desired_state = [product_a]
+        end
+
+        it "should call create_recurring_payment_command with 1 product on the command builder object" do
+          strategy.payment_command_builder_class.should_receive(:create_recurring_payment_commands).with([product_a], :paid_until_date => Date.current).once
+          strategy.command_list
+        end
+
+        it 'should return 1 command in the command list' do
+          strategy.command_list.size.should == 1
+        end
+
+      end
+
+    end
+
+    context 'with 2 current profile with 3 products' do
+      context "when going towards a desired state of no products" do
+        before do
+          strategy_with_3_active_products.desired_state = []
+        end
+
+        # NOTE: this should be moved to a separate class
+        it 'should know which product should be removed' do
+          strategy_with_3_active_products.products_to_be_removed.should == [product_a, product_b, product_c]
+        end
+
+        it "should call :cancel_recurring_payment_command twice" do
+          strategy_with_3_active_products.should_receive(:cancel_recurring_payment_command).twice
+          strategy_with_3_active_products.command_list
+        end
+      end
+
+      context "when removing a partial product from a profile" do
+        before do
+          strategy_with_3_active_products.desired_state = [product_b, product_c]
+        end
+
+        it "should remove the product from the profile with the partial match" do
+          strategy_with_3_active_products.should_receive(:remove_product_from_payment_profile).with('i-1', [product_a], {}).once
+          strategy_with_3_active_products.command_list
+        end
+
+      end
+
+      context "with a yearly subscription" do
+        before do
+          profile_a.products          = [product_a_yearly]
+          profile_a.active_products   = profile_a.products
+          profile_a.current_products  = profile_a.products
+          profile_a.paid_until_date   = product_a_yearly.billing_cycle.next_payment_date
+          profile_a.billing_cycle     = yearly_cycle
+          strategy.current_state      = ::BillingLogic::CurrentState.new([profile_a])
+        end
+
+        it "should add monthly plan at the end of the year when switching to monthly cycle" do
+          strategy.desired_state = [product_a]
+          strategy.should_receive(:create_recurring_payment_command).with([product_a], hash_including(:paid_until_date => profile_a.paid_until_date)).once
+          strategy.should_receive(:cancel_recurring_payment_command).with(profile_a, {}).once
+          strategy.command_list
+          # Note: I used the following for debugging, but leaving it inside
+          # would couple the tests for the strategy with the command builder as
+          # well, which would be bad.
+          # .should == ["add 1 @ $10/mo on #{profile_a.next_payment_date.strftime('%m/%d/%y')}", "cancel i-1 now"]
+        end
+
+        context "that is cancelled and being re-added" do
+          before do
+            profile_a.active_or_pending = false
+            profile_a.active_products = []
+            profile_a.current_products = []
+            strategy.desired_state = [product_a]
+          end
+
+          it "shouldn't try to cancel the yearly subscription if already cancelled" do
+            strategy.should_not_receive(:cancel_recurring_payment_command)
+            strategy.command_list
+          end
+
+          it "should re-add the cancelled product at the end of the year" do
+            strategy.should_receive(:create_recurring_payment_command).with([product_a], :paid_until_date => profile_a.paid_until_date).once
+            strategy.command_list
+          end
+        end
+      end
+
+      context "with one of them cancelled" do
+        before do
+          state = ::BillingLogic::CurrentState.new([canceled_profile_d])
+          strategy.current_state = state
+        end
+        context "when re-adding the cancelled product" do
+          it "should add it to the end of the cancelled period" do
+            strategy.desired_state = [product_d]
+            strategy.should_receive(:create_recurring_payment_command).with([product_d], :paid_until_date => canceled_profile_d.paid_until_date).once
+            strategy.command_list
+          end
+        end
+
+      end
+
+      context "with one of them cancelled twice" do
+        before do
+          state = ::BillingLogic::CurrentState.new([canceled_profile_d, canceled_profile_d.clone])
+          strategy.current_state = state
+        end
+
+        context "when re-adding the cancelled product" do
+          it "should add it to the end of the cancelled period" do
+            strategy.desired_state = [product_d]
+            strategy.should_receive(:create_recurring_payment_command).with([product_d], :paid_until_date => canceled_profile_d.paid_until_date).once
+            strategy.command_list
+          end
+        end
+
+      end
+
+    end
+  end
+end