billing_logic 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9ab8672513eb575ef74c8f93f5b298a1c9909f5d24b360a485a1e17b558cab0b
+  data.tar.gz: 554055cc3b17ffbdc4c177c9cbff00bac1d7fe18b006cea3d25332796e7d652b
+SHA512:
+  metadata.gz: f61efaecc6290eb8dacc78a4f67fc40405e585a3a2788e176c07e97f204cc0bb03938e650de886122a0622274d088baf1f241470265959c50d84a683c49afc9f
+  data.tar.gz: 35cfbfaf963692a9115597d87a4c1c513d0d0172af061903cfbb80ef84c387fbcb90ab1f66b051ef2c3ba36305da6894e217970e8ca34b979886b57ec2ec5658

data/README.rdoc

@@ -0,0 +1,89 @@
+= Billing Logic
+
+== Major Players
+* *BillingCycle* has a period, frequency, anniversary, time_unit_measure, periodicity, next_payment_date, etc.
+* *CurrentState* holds a set of profiles and can iterate through them or return current_products or active_products
+* *PaymentCommandBuilder*, initialized with an array of products, generates commands for creating recurring payments for those products; also takes a set of profile_ids and generates commands for canceling their recurring payments
+* [*Base*|*IndependentPayment*|*SinglePaymentStrategy*], initialized with a current state, desired state and builder class, calculates how to achieve the desired state
+* *ProrationCalculator*, initialized with a hash of billing_cycle, price and date, calculates a prorated price
+* *BillingEngine*::*Client*::*Product*, arrays of these are manipulated via Billing Logic. "Product" in Billing Logic generally refers to BillingEngine::Client::Products
+
+== Structure
+
+    module BillingLogic
+        class BillingCycle
+        module CommandBuilders
+            module BuilderHelpers
+            class ProductList
+            class ProductStub
+            class ActionObject
+            class BasicBuilder
+            class WordBuilder < BasicBuilder
+            class AggregateWordBuilder < BasicBuilder
+        class CurrentState
+        module CurrentStateMixin
+        class PaymentCommandBuilder
+        class ProrationCalculator
+        module Strategies
+            class BaseStrategy
+            class IndependentPaymentStrategy
+            class SinglePaymentStrategy
+
+
+== BillingLogic::Strategies
+
+You create a BillingLogic::Strategy by passing in a hash with your current state, desired state and builder class:
+
+    strategy = <strategy class>.new(:payment_command_builder_class => <your builder class>,
+    				:current_state => <an array of payment profiles>
+    				:desired_state => <an array of products>)
+
+You then ask the strategy to return you an array of commands:
+
+    strategy.command_list => An Array of commands provided by the command builder class
+
+There are three strategies available:
+
+- BaseStrategy:
+  - Contains most of the methods
+- IndependentPaymentStrategy:
+  - Each product gets its own PaymentProfile
+  - Default payment_command_builder_class: BillingLogic::CommandBuilders::WordBuilder
+- SinglePaymentStrategy:
+  - All products share a single PaymentProfile
+  - Default payment_command_builder_class: BillingLogic::CommandBuilders::AggregateWordBuilder
+
+BaseStrategy also has these public methods:
+    #command_list
+    #products_to_be_added
+    #products_to_be_added_grouped_by_date
+    #products_to_be_removed
+    #inactive_products
+    #active_products
+    #active_profiles
+    #profiles_by_status(active_or_pending)
+
+== BillingLogic::BillingCycle
+
+constants:
+    TIME_UNITS = { :day => 1, :week => 7, :month => 365/12.0, :semimonth=> 365/24, :year => 365 }
+
+fields:
+    :frequency (e.g., 1 or 45)
+    :period (e.g., :day, :week, :semimonth, :month, :year)
+    :anniversary (a date)
+
+methods include:
+    #days_in_billing_cycle_including(date)
+    #next_payment_date
+    #closest_anniversary_date_including(date)
+    #periodicity ( TIME_UNITS[self.period] * frequency )
+
+== BillingLogic::PaymentCommandBuilder
+
+instance methods:
+    #group_products_by_billing_cycle
+
+class methods:
+    .create_recurring_payment_commands(products, next_payment_date = Date.current)
+    .cancel_recurring_payment_commands(*profile_ids)

data/config/cruise/run_cruise

@@ -0,0 +1,10 @@
+#!/bin/bash -li
+set -o errexit
+echo The path to the Hedgeye Utilities is $HEDGEYE_UTILITIES_PATH
+source $HEDGEYE_UTILITIES_PATH/set_up_rvm
+mkdir -p temp/pids
+git checkout master
+git pull origin master
+bundle install
+bundle exec rake ci
+# /bin/bash --login -- ~/work/yard_use/generate_ruby19_docs.shecho '*** starting Billing-Logic build ***' &>/dev/stderr

data/features/change_periodicity_on_anniversary_day.feature

@@ -0,0 +1,34 @@
+Feature: Change of periodicity Policy on anniversary
+  As a service provider
+  In order to provide a fair experience to the customers and not overcharging them when making multiple changes on the same day.
+  I want to offer a grace period for for cancellation, during which I'll issue a refund even in case of change of periodicity
+
+  Scenario Outline: User subscribes to a product, then changes periodicity to within the grace period
+    Given I support <strategy>
+    And   The cancellation grace period is of <grace period>
+    And   Today is 3/15/12
+    And   I have the following subscriptions:
+     #| product names | status | comments                                                 | next billing date |
+      | A @ $30/mo | active | and the next billing date is on | 4/15/12 | 2/15/12 |
+      | B @ $99/yr | active | and the next billing date is on | 3/15/13 | 3/15/11 |
+    And   I made the following payment: <payment made>
+    When  I change to having: <desired state>
+    Then  I expect the following action: <actions>
+    Examples: A customer that have made a payment of $30 the same day of cancellation
+      | strategy                     | grace period | payment made                                                            | desired state | actions                    |
+      | Independent Payment Strategy | 24 hours     | paid $30 for A @ $30/mo on 3/15/12                                      | A @ $99/yr, B @ $99/yr       | cancel [A @ $30/mo] now, add (A @ $99/yr) on 04/15/12 |
+      | Independent Payment Strategy | 24 hours     | paid $30 for A @ $30/mo on 3/15/12                                      | A @ $30/mo, B @ $30/mo       | cancel [B @ $99/yr] now, add (B @ $30/mo) on 03/15/13 |
+      | Independent Payment Strategy | 24 hours     | paid $30 for A @ $30/mo on 3/15/12                                      | A @ $99/yr, B @ $30/mo       | cancel [B @ $99/yr] now, cancel [A @ $30/mo] now, add (A @ $99/yr) on 04/15/12, add (B @ $30/mo) on 03/15/13 |
+
+      | Independent Payment Strategy | 24 hours     | paid $99 for B @ $99/yr on 3/15/12                                      | A @ $99/yr, B @ $99/yr    | cancel [A @ $30/mo] now, add (A @ $99/yr) on 04/15/12 |
+      | Independent Payment Strategy | 24 hours     | paid $99 for B @ $99/yr on 3/15/12                                      | A @ $30/mo, B @ $30/mo    | cancel [B @ $99/yr] now, add (B @ $30/mo) on 03/15/13 |
+      | Independent Payment Strategy | 24 hours     | paid $99 for B @ $99/yr on 3/15/12                                      | A @ $99/yr, B @ $30/mo    | cancel [B @ $99/yr] now, cancel [A @ $30/mo] now, add (A @ $99/yr) on 04/15/12, add (B @ $30/mo) on 03/15/13 |
+
+      | Independent Payment Strategy | 24 hours     | paid $30 for A @ $30/mo on 3/15/12, paid $99 for B @ $99/yr on 3/15/12  | A @ $99/yr, B @ $99/yr    | cancel [A @ $30/mo] now, add (A @ $99/yr) on 04/15/12 |
+      | Independent Payment Strategy | 24 hours     | paid $30 for A @ $30/mo on 3/15/12, paid $99 for B @ $99/yr on 3/15/12  | A @ $30/mo, B @ $30/mo    | cancel [B @ $99/yr] now, add (B @ $30/mo) on 03/15/13 |
+      | Independent Payment Strategy | 24 hours     | paid $30 for A @ $30/mo on 3/15/12, paid $99 for B @ $99/yr on 3/15/12  | A @ $99/yr, B @ $30/mo    | cancel [B @ $99/yr] now, cancel [A @ $30/mo]  now, add (A @ $99/yr) on 04/15/12, add (B @ $30/mo) on 03/15/13 |
+
+      | Independent Payment Strategy | 24 hours     | none                                                                    | A @ $99/yr, B @ $99/yr    | cancel [A @ $30/mo] now, add (A @ $99/yr) on 04/15/12 |
+      | Independent Payment Strategy | 24 hours     | none                                                                    | A @ $30/mo, B @ $30/mo    | cancel [B @ $99/yr] now, add (B @ $30/mo) on 03/15/13 |
+      | Independent Payment Strategy | 24 hours     | none                                                                    | A @ $99/yr, B @ $30/mo    | cancel [B @ $99/yr] now, cancel [A @ $30/mo] now, add (A @ $99/yr) on 04/15/12, add (B @ $30/mo) on 03/15/13 |
+

data/features/change_periodicity_on_signup_day.feature

@@ -0,0 +1,34 @@
+Feature: Change of periodicity Policy on signup day
+  As a service provider
+  In order to provide a fair experience to the customers and not overcharging them when making multiple changes on the same day.
+  I want to offer a grace period for for cancellation, during which I'll issue a refund even in case of change of periodicity
+
+  Scenario Outline: User subscribes to a product, then changes periodicity to within the grace period
+    Given I support <strategy>
+    And   The cancellation grace period is of <grace period>
+    And   Today is 3/15/12
+    And   I have the following subscriptions:
+     #| product names | status | comments                                                 | next billing date |
+      | A @ $30/mo | active | and the next billing date is on | 4/15/12 | 3/15/12 |
+      | B @ $99/yr | active | and the next billing date is on | 3/15/13 | 3/15/12 |
+    And   I made the following payment: <payment made>
+    When  I change to having: <desired state>
+    Then  I expect the following action: <actions>
+    Examples: A customer that have made a payment of $30 the same day of cancellation
+      | strategy                     | grace period | payment made                                                            | desired state | actions                    |
+      | Independent Payment Strategy | 24 hours     | paid $30 for A @ $30/mo on 3/15/12                                      | A @ $99/yr, B @ $99/yr       | cancel and disable [A @ $30/mo] with refund $30.00 now, add (A @ $99/yr) on 03/15/12 |
+      | Independent Payment Strategy | 24 hours     | paid $30 for A @ $30/mo on 3/15/12                                      | A @ $30/mo, B @ $30/mo       | cancel and disable [B @ $99/yr] now, add (B @ $30/mo) on 03/15/12 |
+      | Independent Payment Strategy | 24 hours     | paid $30 for A @ $30/mo on 3/15/12                                      | A @ $99/yr, B @ $30/mo       | cancel and disable [B @ $99/yr] now, cancel and disable [A @ $30/mo] with refund $30.00 now, add (A @ $99/yr) on 03/15/12, add (B @ $30/mo) on 03/15/12 |
+
+      | Independent Payment Strategy | 24 hours     | paid $99 for B @ $99/yr on 3/15/12                                      | A @ $99/yr, B @ $99/yr    | cancel and disable [A @ $30/mo] now, add (A @ $99/yr) on 03/15/12 |
+      | Independent Payment Strategy | 24 hours     | paid $99 for B @ $99/yr on 3/15/12                                      | A @ $30/mo, B @ $30/mo    | cancel and disable [B @ $99/yr] with refund $99.00 now, add (B @ $30/mo) on 03/15/12 |
+      | Independent Payment Strategy | 24 hours     | paid $99 for B @ $99/yr on 3/15/12                                      | A @ $99/yr, B @ $30/mo    | cancel and disable [B @ $99/yr] with refund $99.00 now, cancel and disable [A @ $30/mo] now, add (A @ $99/yr) on 03/15/12, add (B @ $30/mo) on 03/15/12 |
+
+      | Independent Payment Strategy | 24 hours     | paid $30 for A @ $30/mo on 3/15/12, paid $99 for B @ $99/yr on 3/15/12  | A @ $99/yr, B @ $99/yr    | cancel and disable [A @ $30/mo] with refund $30.00 now, add (A @ $99/yr) on 03/15/12 |
+      | Independent Payment Strategy | 24 hours     | paid $30 for A @ $30/mo on 3/15/12, paid $99 for B @ $99/yr on 3/15/12  | A @ $30/mo, B @ $30/mo    | cancel and disable [B @ $99/yr] with refund $99.00 now, add (B @ $30/mo) on 03/15/12 |
+      | Independent Payment Strategy | 24 hours     | paid $30 for A @ $30/mo on 3/15/12, paid $99 for B @ $99/yr on 3/15/12  | A @ $99/yr, B @ $30/mo    | cancel and disable [B @ $99/yr] with refund $99.00 now, cancel and disable [A @ $30/mo] with refund $30.00 now, add (A @ $99/yr) on 03/15/12, add (B @ $30/mo) on 03/15/12 |
+
+      | Independent Payment Strategy | 24 hours     | none                                                                    | A @ $99/yr, B @ $99/yr    | cancel and disable [A @ $30/mo] now, add (A @ $99/yr) on 03/15/12 |
+      | Independent Payment Strategy | 24 hours     | none                                                                    | A @ $30/mo, B @ $30/mo    | cancel and disable [B @ $99/yr] now, add (B @ $30/mo) on 03/15/12 |
+      | Independent Payment Strategy | 24 hours     | none                                                                    | A @ $99/yr, B @ $30/mo    | cancel and disable [B @ $99/yr] now, cancel and disable [A @ $30/mo] now, add (A @ $99/yr) on 03/15/12, add (B @ $30/mo) on 03/15/12 |
+

data/features/independent_payment_strategy.feature

@@ -0,0 +1,93 @@
+Feature: Independent Payment Strategy
+  As a service provider
+  in order to provide an a-la-carte menu of products and consistent charges
+  I want to offer independent payments & subscriptions for each product
+
+  Scenario Outline: Adding a product
+    Given I support Independent Payment Strategy
+    And   Today is 3/15/12
+    And   I don't have any subscriptions
+    When  I change to having: <added products>
+    Then  I expect the following action: <action>
+    Examples:
+      | added products          | action                                                 |
+      | A @ $30/mo              | add (A @ $30/mo) on 03/15/12                             |
+      | A @ $30/mo, B @ $40/mo  | add (A @ $30/mo) on 03/15/12, add (B @ $40/mo) on 03/15/12 |
+
+    Scenario Outline: Transitioning a subscription to independent payments
+      Given I support Independent Payment Strategy
+      And   Today is 3/15/12
+      And   I have the following subscriptions:
+        | (A @ $30/mo & B @ $40/mo & C @ $25/mo) @ $95/mo | active | and the next billing date is on | 4/1/12 | 3/1/12 |
+     When  I change to having: <desired state>
+     Then  I expect the following action: <action>
+     Examples: Removing all products
+       | desired state | action               |
+       | nothing       | cancel [(A @ $30/mo & B @ $40/mo & C @ $25/mo) @ $95/mo] now |
+
+     Examples: Removing partial products
+       | desired state                | action                  |
+       | A @ $30/mo                   | remove (B @ $40/mo & C @ $25/mo) from [(A @ $30/mo & B @ $40/mo & C @ $25/mo) @ $95/mo] now   |
+       | B @ $40/mo & C @ $25/mo      | remove (A @ $30/mo) from [(A @ $30/mo & B @ $40/mo & C @ $25/mo) @ $95/mo] now   |
+
+   Scenario Outline: Removing a product
+     Given I support Independent Payment Strategy
+     And   Today is 3/15/12
+     And   I have the following subscriptions:
+     # | product names | billing cycle        | status    | #comments                      | next billing date   |
+       | A @ $30/mo | active    | with current permissions and the next billing date is on | 4/1/12              | 3/1/12 |
+       | B @ $20/mo | active    | with current permissions and the next billing date is on | 3/20/12             | 2/20/12 |
+       | C @ $50/yr | cancelled | with permissions expiring in the future on               | 4/25/12             | 4/25/11 |
+       | F @ $10/mo | cancelled | with permissions expiring today                          | 3/15/12             | 2/15/12 |
+       | G @ $15/mo | cancelled | with permissions expired in the past on                  | 3/13/12             | 2/13/12 |
+     When  I change to having: <desired state>
+     Then  I expect the following action: <action>
+     Examples: Removing all products
+       | desired state | action                                           |
+       | nothing       | cancel [A @ $30/mo] now, cancel [B @ $20/mo] now |
+
+     Examples: Removing partial products
+       | desired state                | action                    |
+       | A @ $30/mo                   | cancel [B @ $20/mo] now   |
+       | B @ $20/mo                   | cancel [A @ $30/mo] now   |
+
+     Examples: Re-adding a cancelled product C that expires in the future
+       | desired state                      | action                       |
+       | A @ $30/mo, B @ $20/mo, C @ $50/mo | add (C @ $50/mo) on 04/25/12 |
+
+     Examples: Re-adding a cancelled product that expires today
+       | desired state                        | action                       |
+       | A @ $30/mo, B @ $20/mo, F @ $10/mo   | add (F @ $10/mo) on 03/15/12 |
+       
+     Examples: Re-adding a cancelled product that expired in the past
+       | desired state                        | action                       |
+       | A @ $30/mo, B @ $20/mo, G @ $15/mo   | add (G @ $15/mo) on 03/15/12 |
+
+     Examples: Re-adding & removing product
+       | desired state           | action                                                |
+       | A @ $30/mo, C @ $50/mo  | cancel [B @ $20/mo] now, add (C @ $50/mo) on 04/25/12 |
+
+     Examples: Adding, Re-adding & removing product
+       | desired state                        | action                                                                              |
+       | A @ $30/mo, C @ $50/mo, D @ $40/mo   | cancel [B @ $20/mo] now, add (C @ $50/mo) on 04/25/12, add (D @ $40/mo) on 03/15/12 |
+
+     Examples: changing the periodicity of product A from monthly to yearly
+       | desired state            | action                                                                                   |
+       | A @ $99/yr, B @ $20/mo   | cancel [A @ $30/mo] now, add (A @ $99/yr) on 04/01/12 |
+
+     Examples: 
+      Adding a new product D, 
+      Re-adding a cancelled product C, 
+      Changing the periodicity of A product, 
+      Removing product B
+       | desired state                      | action                                                                                                                                                           |
+       | A @ $60/yr, C @ $50/yr, D @ $40/yr | cancel [A @ $30/mo] now, add (A @ $60/yr) on 04/01/12, cancel [B @ $20/mo] now, add (C @ $50/yr) on 04/25/12, add (D @ $40/yr) on 03/15/12 |
+
+       #  """
+       #                                                                         cancel A @ $30 now, 
+       #                                                                         add A @ $60 on 04/01/12 renewing every 1 year, 
+       #                                                                         cancel B @ $20 now, 
+       #                                                                         add C @ $50 on 04/25/12 renewing every 1 year, 
+       #                                                                         add D @ $40 on 03/15/12 renewing every 1 year 
+       #                                                                         """                       |
+

data/features/same_day_cancellation_policy.feature

@@ -0,0 +1,57 @@
+Feature: Same Day Cancellation Policy
+  As a service provider
+  In order to provide a fair experience to the customers and not overcharging them when making multiple changes on the same day.
+  I want to offer a grace period for for cancellation, during which I'll issue a refund
+
+  Scenario Outline: User subscribes, then cancels within the grace period
+    Given I support <strategy>
+    And   The cancellation grace period is of <grace period>
+    And   Today is 3/15/12
+    And   I have the following subscriptions:
+     #| product names | status | comments                                                 | next billing date |
+      | A @ $30/mo    | active | with current permissions and the next billing date is on | 4/15/12           |
+    And   I made the following payment: <payment made>
+    When  I change to having: <desired state>
+    Then  I expect the following action: <actions>
+    Examples: A customer that have made a payment of $30 the same day of cancellation
+      | strategy                     | grace period | payment made                    | desired state | actions                    |
+      | Independent Payment Strategy | 24 hours     | paid $30 for A @ $30/mo on 3/15/12 | nothing       | cancel and disable [A @ $30/mo] with refund $30.00 now |
+
+    Examples: A customer that made a refundable payment greater than the monthly payment because of a startup fee
+      | strategy                     | grace period | payment made                    | desired state | actions                   |
+      | Independent Payment Strategy | 24 hours     | paid $40 for A @ $30/mo on 3/15/12 | nothing       | cancel and disable [A @ $30/mo] with refund $40.00 now |
+
+    Examples: A customer that made a refundable payment lesser than the monthly payment because of an initial discount
+      | strategy                     | grace period              | payment made                    | desired state | actions                   |
+      | Independent Payment Strategy | 24 hours                  | paid $20 for A @ $30/mo on 3/15/12 | nothing       | cancel and disable [A @ $30/mo] with refund $20.00 now |
+
+  Scenario Outline: User subscribes to multiple, then cancels within the grace period
+    Given I support <strategy>
+    And   The cancellation grace period is of <grace period>
+    And   Today is 3/15/12
+    And   I have the following subscriptions:
+     #| product names | status | comments                                                 | next billing date |
+      | (A @ $30/mo & B @ $40/mo & C @ $25/mo) @ $95/mo | active | and the next billing date is on | 4/14/12 |
+    And   I made the following payment: <payment made>
+    When  I change to having: <desired state>
+    Then  I expect the following action: <actions>
+    Examples: A customer that have made a payment of $30 the same day of cancellation
+      | strategy                     | grace period | payment made                    | desired state | actions                    |
+      | Independent Payment Strategy | 24 hours     | paid $30 for A @ $30/mo on 3/15/12 | nothing       | cancel and disable [(A @ $30/mo & B @ $40/mo & C @ $25/mo) @ $95/mo] with refund $30.00 now |
+      | Independent Payment Strategy | 24 hours     | paid $30 for A @ $30/mo on 3/15/12 | B @ $40/mo    | remove (A @ $30/mo & C @ $25/mo) from [(A @ $30/mo & B @ $40/mo & C @ $25/mo) @ $95/mo] with refund $30.00 now |
+
+  Scenario Outline: User subscribes, then cancels not within the grace period
+    Given I support <strategy>
+    And   The cancellation grace period is of <grace period>
+    And   Today is 3/15/12
+    And   I have the following subscriptions:
+     #| product names | status | comments                                                 | next billing date |
+      | A @ $30/mo    | active | with current permissions and the next billing date is on | 4/13/12           |
+    And   I made the following payment: <payment made>
+    When  I change to having: <desired state>
+    Then  I expect the following action: <action>
+    And   I do not expect the following action: <inaction>
+    Examples: A customer that have made a payment just outside of the grace period by 1 second
+      | strategy                     | grace period | payment made                    | desired state | action                    | inaction |
+      | Independent Payment Strategy | 24 hours     | paid $30 for A @ $30/mo on 3/14/12 | nothing       | cancel [A @ $30/mo] now        | refund $30 to [A @ $30/mo] now |
+

data/features/step_definitions/cancellation_steps.rb

@@ -0,0 +1,52 @@
+And 'I made the following payment: paid {money} for {product_formatting} on {date}' do |amount, profile_object, payment_date|
+  strategy.current_state.each do |profile|
+    profile.products.each do |product|
+      profile_object.each do |obj|
+        if product.name == obj.name
+          create_payment_for_profile_at_date(profile, amount, payment_date)
+        end
+      end
+    end
+  end
+end
+
+And /^I made the following payment: (.*,.*)$/ do |payment_strings|
+  payment_strings.split(',').each do |payment_string|
+    step "I made the following payment: #{payment_string.strip}"
+  end
+end
+
+Given(/^I made the following payment: (none|nothing)?$/) do |throwaway|
+  # Nothing to be done here
+end
+
+Given /^The cancellation grace period is of (\d+) (hour|day|month|week|year)s?$/ do |amount, length|
+  grace_period(amount.to_i * 60 * 60)
+end
+
+
+# NOTE: this one might be replaced by the inline version above
+# keeping this method around for the moment. Diego
+# And /^I made the following payments:$/ do |table|
+#   # table is a Cucumber::Ast::Table
+#   table.raw.map do |row|
+#     strategy.current_state.each do |profile|
+#       profile.products.each do |product| 
+#         if product.name == str_to_product_formatting(row[0]).name
+#           profile.last_payment = OpenStruct.new(:amount => row[1],
+#                                                 :payment_date => str_to_date(row[2]),
+#                                                 :refundable? => (Date.current - str_to_date(row[2])).to_i <= grace_period)
+#           def profile.last_payment_refundable?
+#             last_payment.refundable?
+#           end
+#           
+#           def profile.last_payment_amount
+#             last_payment.amount
+#           end
+#         end
+#       end
+#     end
+#   end
+# end
+
+

data/features/step_definitions/implementation_specific_steps.rb

@@ -0,0 +1,41 @@
+Given /^I have the following subscriptions:$/ do |table|
+  # table is a Cucumber::Ast::Table
+  profiles =  table.raw.map do |row|
+    paid_until_date = str_to_date(row[3])
+
+    products = str_to_product_formatting(row[0])
+    products.each { |product| product.billing_cycle.anniversary = paid_until_date }
+    billing_cycle = str_to_billing_cycle(row[0], paid_until_date)
+    if row[4]
+      billing_start_date = str_to_date(row[4])
+    else
+      billing_start_date = billing_cycle.advance_date_by_period(billing_cycle.anniversary, true)
+    end
+
+    active_or_pending = row[1] =~ /active/
+    ostruct = OpenStruct.new(
+               :identifier => row[0],
+               :products =>  products,
+               :current_products => (paid_until_date >= Date.current) ? products : [],
+               :active_products => active_or_pending ? products : [],
+               :billing_start_date => billing_start_date,
+               :paid_until_date =>  paid_until_date,
+               :billing_cycle => billing_cycle,
+               :active_or_pending? => active_or_pending ,
+              )
+    def ostruct.refundable_payment_amount(foo)
+      @refundable_payment_amount || 0.0
+    end
+    ostruct
+  end
+  strategy.current_state = BillingLogic::CurrentState.new(profiles)
+end
+
+When /^I change to having: nothing$/ do
+  strategy.desired_state = []
+end
+
+When "I change to having: {product_formatting}" do |products|
+  expect(products).to be_a(Array) # Optional test
+  strategy.desired_state = products
+end

data/features/step_definitions/independent_payment_strategy_steps.rb

@@ -0,0 +1,4 @@
+Given /^I support Independent Payment Strategy$/ do
+  set_current_strategy(BillingLogic::Strategies::IndependentPaymentStrategy)
+end
+

data/features/step_definitions/steps.rb

@@ -0,0 +1,15 @@
+Then /^(?:|I )(|don't |do not |)expect the following action: ((?:remove|add|cancel|disable|refund \$\d+ to) .*)$/ do |assertion, commands|
+  assertion = !(assertion =~ /(don't |do not |ain't )/)
+  commands.split(/, /).each do |command|
+    command_list_should_include(command, assertion)
+  end
+end
+
+Given /^I don't have any subscriptions$/ do
+  strategy.current_state = BillingLogic::CurrentState.new([])
+end
+
+Given /^Today is (\d+\/\d+\/\d+)$/ do |date|
+  Timecop.travel(Date.strptime(date, '%m/%d/%y'))
+end
+

data/features/support/env.rb

@@ -0,0 +1,13 @@
+require 'cucumber/rspec/doubles'
+require 'timecop'
+require 'ostruct'
+require 'rspec/matchers'
+
+require_relative './helpers.rb'
+require_relative '../../lib/billing_logic.rb'
+
+World(RSpec::Matchers)
+World(CancellationPolicyHelpers)
+World(ProductPaymentHelpers)
+World(StringParsers)
+World(StrategyHelper)

data/features/support/helpers.rb

@@ -0,0 +1,73 @@
+module CancellationPolicyHelpers
+  def grace_period(val = nil)
+    @grace_period ||= val
+  end
+end
+
+module ProductPaymentHelpers
+  def create_payment_for_profile_at_date(profile, amount, payment_date)
+    refundable = (Time.now - payment_date.to_time).to_i < grace_period && ((Date.current - 1) <= profile.billing_start_date)
+    profile.last_payment = OpenStruct.new(:amount => amount.to_i,
+                                          :payment_date => payment_date,
+                                          :refundable? => refundable)
+
+    def profile.refundable_payment_amount(foo)
+      last_payment.refundable? ? last_payment.amount : 0.0
+    end
+  end
+end
+
+module StrategyHelper
+  def set_current_strategy(strategy, opts = {:command_builder => BillingLogic::CommandBuilders::WordBuilder})
+    @strategy = strategy.new(:payment_command_builder_class => opts[:command_builder])
+  end
+
+  def strategy
+    @strategy
+  end
+end
+
+module StringParsers
+
+  def str_to_billing_cycle(string, anniversary = Date.current)
+    billing_cycle = BillingLogic::BillingCycle.new
+    case string
+    when /every (\d+)\s(\w+)$/
+      billing_cycle.frequency    = $1.to_i
+      billing_cycle.period = $2.to_sym
+    when /\/mo/
+      billing_cycle.frequency    = 1
+      billing_cycle.period = :month
+    when /\/yr/
+      billing_cycle.frequency    = 1
+      billing_cycle.period = :year
+    end
+    billing_cycle.anniversary = anniversary
+    billing_cycle
+  end
+  
+  def str_to_date(string)
+     Date.strptime(string, '%m/%d/%y')
+  end
+
+  def str_to_product_formatting(str)
+    str.split(/ & /).map do |string|
+      BillingLogic::CommandBuilders::ProductStub.parse(string)
+    end
+  end
+
+  def str_to_anniversary(string)
+    string =~ ANNIVERSARY
+  end
+
+  def command_list_should_include(command, bool = true)
+    command_list = strategy.command_list.map { |obj| obj.to_s }
+    if bool
+      command_list.should include(BillingLogic::CommandBuilders::ActionObject.from_string(command).to_s)
+    else
+      command_list.should_not include(BillingLogic::CommandBuilders::ActionObject.from_string(command).to_s)
+    end
+  end
+
+end
+

data/features/support/parameter_types.rb

@@ -0,0 +1,42 @@
+DATE = ParameterType(
+  name: 'date',
+  regexp: /#{BillingLogic::CommandBuilders::DATE_REGEX}/,
+  transformer: ->(date) { str_to_date(date) },
+  type: Date
+)
+
+ANNIVERSARY = ParameterType(
+  name: 'anniversary',
+  regexp: /(?:| on | starting on )#{DATE}?/,
+  transformer: ->(date) { date }
+)
+
+BILLING_CYCLE = ParameterType(
+  name: 'billing_cycle',
+  regexp: /\/mo|\/yr|every \d+ (?:day|month|year)/,
+  transformer: ->(string) { str_to_billing_cycle(string) },
+  type: BillingLogic::BillingCycle
+)
+
+MONEY = ParameterType(
+  name: 'money',
+  regexp: /#{BillingLogic::CommandBuilders::MONEY_REGEX}/,
+  transformer: ->(money) { money }
+)
+
+PRODUCT_FORMATTING = ParameterType(
+  name: 'product_formatting',
+  regexp: /(?:\w+ @ #{MONEY[0].tr('()', '')}(?:\/mo|\/yr|)(?:, | & )?)+/, # Remove capture group from MONEY regexp
+  transformer: ->(products) {
+    products.split(/, /).map do |string|
+      str_to_product_formatting(string)
+    end.flatten
+  },
+  type: Array
+)
+
+DESIRED_STATE = ParameterType(
+  name: 'desired_state',
+  regexp: /((?:\w+) @ (?:#{MONEY}) (?:#{BILLING_CYCLE}))/,
+  transformer: ->(string) { string }
+)