susply 0.0.1

data/spec/services/susply/change_subscription_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+module Susply
+  describe ChangeSubscription do
+    let(:owner_class) { Susply.subscription_owner_class.constantize } 
+    let(:time) {Time.zone.today}
+
+    context "when owner has an active subscription" do
+      it "closes the active subscription when present" do
+        owner = owner_class.create()
+        plan = create(:susply_plan)
+        subscription = create(:susply_subscription, :active, owner: owner)
+
+        new_subscription = Susply::ChangeSubscription.call(owner, plan)
+        subscription.reload
+
+        expect(subscription).not_to be_active
+        expect(new_subscription).to be_active
+      end
+
+      it "creates a plan_changed prorate payment" do
+        owner = owner_class.create()
+        plan = create(:susply_plan, interval: 'monthly', price: 100)
+        subscription = create(:susply_subscription, :active,owner: owner,
+                              current_period_start: time - 15.days)
+
+        Susply::ChangeSubscription.call(owner, plan)
+
+        payment = owner.payments.last
+        expect(payment.generated_type).to eq 'plan_change'
+      end
+
+      it "creates a new subscription" do
+        owner = owner_class.create()
+        plan = create(:susply_plan)
+        subscription = create(:susply_subscription, :active, owner: owner)
+        new_subscription = Susply::ChangeSubscription.call(owner, plan)
+
+        expect(new_subscription.owner).to eq owner
+        expect(new_subscription.plan).to eq plan
+        expect(new_subscription).to be_active
+        expect(owner.subscriptions.count).to eq 2
+      end
+    end
+
+    context "when owner does not have active subscription" do
+      it "does not creates a payment" do
+        owner = owner_class.create()
+        plan = create(:susply_plan)
+
+        new_subscription = Susply::ChangeSubscription.call(owner, plan)
+
+        expect(owner.payments.count).to eq 0
+      end
+
+      it "creates a new subscription" do
+        owner = owner_class.create()
+        plan = create(:susply_plan)
+
+        new_subscription = Susply::ChangeSubscription.call(owner, plan)
+
+        expect(new_subscription.owner).to eq owner
+        expect(new_subscription.plan).to eq plan
+        expect(new_subscription).to be_active
+      end
+    end
+  end
+end

data/spec/services/susply/close_subscription_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module Susply
+  describe CloseSubscription do
+    let(:owner_class) { Susply.subscription_owner_class.constantize } 
+    let(:time) {Time.zone.today}
+
+    context "when owner has an active subscription" do
+      it "closes the active subscription when present" do
+        owner = owner_class.create()
+        plan = create(:susply_plan)
+        subscription = create(:susply_subscription, :active, owner: owner)
+
+        expect(owner.has_active_subscription?).to be true
+        Susply::CloseSubscription.call(owner)
+        subscription.reload
+
+        expect(subscription).not_to be_active
+        expect(owner.has_active_subscription?).to be false
+      end
+
+      it "creates a plan_close prorate payment" do
+        owner = owner_class.create()
+        plan = create(:susply_plan, interval: 'monthly', price: 100)
+        subscription = create(:susply_subscription, :active,owner: owner,
+                              current_period_start: time - 15.days)
+
+        Susply::CloseSubscription.call(owner)
+
+        payment = owner.payments.last
+        expect(payment.generated_type).to eq 'plan_close'
+        expect(owner.has_active_subscription?).to be false
+      end
+    end
+  end
+end

data/spec/services/susply/create_payment_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+module Susply
+  describe CreatePayment do
+    let(:owner_class) { Susply.subscription_owner_class.constantize } 
+    it "returns nil when its passes a closed subscription" do
+      s = create(:susply_subscription, :inactive)
+      payment = Susply::CreatePayment.call(s, 'my_type')
+
+      expect(payment).to be_nil
+    end
+
+    context "when passes an active subscription" do
+      let(:owner) {owner_class.create(name: 'iokero')}
+      it "sets the payment owner to the subscription owner" do
+        s = create(:susply_subscription, :active, owner: owner)
+        payment = Susply::CreatePayment.call(s, 'plan_change')
+
+        expect(payment.owner).to be owner
+      end
+
+      it "sets the payment plan to the subscription plan" do
+        plan = create(:susply_plan, sku: 'awea')
+        s = create(:susply_subscription, :active, owner: owner, plan: plan)
+        payment = Susply::CreatePayment.call(s, 'plan_change')
+
+        expect(payment.plan).to be plan
+      end
+
+      it "sets the payment subscription to the passed subscription" do
+        s = create(:susply_subscription, :active, owner: owner)
+        payment = Susply::CreatePayment.call(s, 'plan_change')
+
+        expect(payment.subscription).to be s
+      end
+
+      it "sets the payment amount proratated for no renovation type" do
+        allow(Susply::Prorate).to receive(:call) {5}
+        s = create(:susply_subscription, :active, owner: owner)
+        payment = Susply::CreatePayment.call(s, 'plan_change')
+
+        expect(payment.amount).to be 5
+      end
+
+      it "sets the payment mount as full plan price for renovation type" do
+        plan = create(:susply_plan, price: 25)
+        s = create(:susply_subscription, :active, owner: owner, plan: plan)
+        payment = Susply::CreatePayment.call(s, 'plan_renovation')
+
+        expect(payment.amount).to be 25
+      end
+
+      it "sets the payment type to the passed generated type" do
+        s = create(:susply_subscription, :active, owner: owner)
+        payment = Susply::CreatePayment.call(s, 'plan_change')
+
+        expect(payment.generated_type).to eq 'plan_change'
+      end
+
+      it "sets the payment period start" do
+        s = create(:susply_subscription, :active, owner: owner,
+                  current_period_start: Time.zone.now - 3.hours)
+        payment = Susply::CreatePayment.call(s, 'plan_change')
+
+        expect(payment.period_start).to eq s.current_period_start
+      end
+
+      it "sets the payment period end" do
+        s = create(:susply_subscription, :active, owner: owner,
+                  current_period_end: Time.zone.now + 3.hours)
+        payment = Susply::CreatePayment.call(s, 'plan_change')
+
+        expect(payment.period_end).to eq s.current_period_end
+      end
+
+      it "sets the status to generated" do
+        s = create(:susply_subscription, :active, owner: owner)
+        payment = Susply::CreatePayment.call(s, 'plan_change')
+
+        expect(payment.status).to eq 'generated'
+      end
+    end
+  end
+end

data/spec/services/susply/create_subscription_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module Susply
+  describe CreateSubscription do
+    it "creates the subscription" do
+      owner = Organization.create(name: "Iokero", subdomain: 'iokero')
+      plan = create(:susply_plan, interval: 'monthly')
+
+      subscription = Susply::CreateSubscription.call(owner, plan)
+
+      expect(subscription.id).not_to be_nil
+      expect(subscription.owner).to eq owner
+      expect(subscription.plan).to eq plan
+      expect(subscription.quantity).to eq 1
+      expect(subscription.start).to be_within(1.second).of(Time.zone.now)
+      expect(subscription.current_period_start).
+        to be_within(2.second).of(Time.zone.now)
+      expect(subscription.current_period_end).
+        to be_within(2.second).of(Time.zone.now + 1.month)
+    end
+  end
+end

data/spec/services/susply/owner_methods_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+require 'byebug'
+
+module Susply
+  describe OwnerMethods do
+    let(:owner_class) { Susply.subscription_owner_class.constantize } 
+
+    describe "sets the has many relationship for subscriptions" do
+      it "has many subscriptions" do
+        a = owner_class.reflect_on_association(:subscriptions)
+        expect(a.macro).to eq :has_many
+      end
+
+      it "sets subscriptions class" do
+        a = owner_class.reflect_on_association(:subscriptions)
+        expect(a.options[:class_name]).to eq 'Susply::Subscription'
+      end
+
+      it "sets subscriptions foreign key" do
+        a = owner_class.reflect_on_association(:subscriptions)
+        expect(a.options[:foreign_key]).to eq 'owner_id'
+      end
+    end
+
+    describe "sets the has many relationship for payments" do
+      it "has many payments" do
+        a = owner_class.reflect_on_association(:payments)
+        expect(a.macro).to eq :has_many
+      end
+
+      it "sets payments class" do
+        a = owner_class.reflect_on_association(:payments)
+        expect(a.options[:class_name]).to eq 'Susply::Payment'
+      end
+
+      it "sets payments foreign key" do
+        a = owner_class.reflect_on_association(:payments)
+        expect(a.options[:foreign_key]).to eq 'owner_id'
+      end
+    end
+
+
+    describe "#active_subscription" do
+      it "returns nil when the is no subscrition" do
+        o = owner_class.create
+
+        expect(o.active_subscription).to be_nil
+      end
+
+      it "returns nil when the is no active subscription" do
+        o = owner_class.create
+        s = create(:susply_subscription, :inactive, owner: o)
+
+        expect(o.active_subscription).to be_nil
+      end
+
+      it "returns the active subscription when presente" do
+        o = owner_class.create
+        s = create(:susply_subscription, :active, owner: o)
+
+        expect(o.active_subscription).to eq s
+      end
+    end
+
+    describe "#has_active_subscription?" do
+      it "returns true when there is an active subscription" do
+        o = owner_class.create
+        s = create(:susply_subscription, :active, owner: o)
+
+        expect(o.has_active_subscription?).to eq true
+      end
+
+      it "returns false when there is not an active subscription" do
+        o = owner_class.create
+        s = create(:susply_subscription, :inactive, owner: o)
+
+        expect(o.has_active_subscription?).to eq false
+      end
+    end
+
+    describe "#most_recentry_deactivated_subscription" do
+      it "returns nil when there is no inactive subscription" do
+        o = owner_class.create
+        s = create(:susply_subscription, :active, owner: o)
+
+        expect(o.most_recently_deactivated_subscription).to be_nil
+      end
+
+      it "returns the most recently deactivated usbscription"  do
+        o = owner_class.create
+        mr = create(:susply_subscription, :inactive, owner: o)
+        nr = create(:susply_subscription, :inactive, owner: o, 
+                    deactivated_at: Time.zone.now - 5.days)
+
+        expect(o.most_recently_deactivated_subscription).to eq mr
+      end
+    end
+  end
+end

data/spec/services/susply/prorate_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+module Susply
+  describe Prorate do
+    let(:time) {Time.zone.now}
+
+    describe ".call" do
+      it "returns 0 when subscription is not active" do
+        time = Time.zone.now - 3.days
+        subscription = create(:susply_subscription, deactivated_at: time)
+
+        expect(Susply::Prorate.call(subscription)).to be 0
+      end
+
+      it "returns the calculated amount for montly" do
+        plan = build(:susply_plan, price: 100, interval: 'monthly')
+        s = build(:susply_subscription, current_period_start: time - 7.days,
+                  plan: plan )
+
+        expect(Susply::Prorate.call(s)).to be 24
+      end
+
+      it "returns the calculated amount for yearly" do
+        plan = build(:susply_plan, price: 1000, interval: 'yearly')
+        s = build(:susply_subscription, current_period_start: time - 304.days,
+                  plan: plan )
+
+        expect(Susply::Prorate.call(s)).to be 1000
+      end
+    end
+
+    describe ".used_days" do
+      it "returns the number of days in a month" do
+        s = build(:susply_subscription, current_period_start: time - 7.days )
+
+        expect(Susply::Prorate.used_days(s)).to be 7
+      end
+
+      it "returns the number of days in a year" do
+        s = build(:susply_subscription, current_period_start: time - 102.days )
+
+        expect(Susply::Prorate.used_days(s)).to be 102
+      end
+    end
+
+    describe ".calculate_used_amount" do
+      context "when plan interval is yearly" do
+        it "returns the prorate amount with price + 2 months" do
+          plan = build(:susply_plan, price: 40, interval: 'yearly')
+          used_days = 182
+          amount = Susply::Prorate.calculate_used_amount(plan, used_days)
+
+          expect(amount).to be 24
+        end
+
+        it "always return an integer value" do
+          plan = build(:susply_plan, price: 100, interval: 'yearly')
+          used_days = 91
+          amount = Susply::Prorate.calculate_used_amount(plan, used_days)
+
+          expect(amount).to be 30
+        end
+      end
+
+      context "when plan interval is monthly" do
+        it "returns the prorate amount based on 30 days use" do
+          plan = build(:susply_plan, price: 100, interval: 'monthly')
+          used_days = 91
+          amount = Susply::Prorate.calculate_used_amount(plan, used_days)
+
+          expect(amount).to be 304
+        end
+
+        it "returns the prorate amount based on 30 days use" do
+          plan = build(:susply_plan, price: 49, interval: 'monthly')
+          used_days = 15
+          amount = Susply::Prorate.calculate_used_amount(plan, used_days)
+
+          expect(amount).to be 25
+        end
+
+        it "returns the exact amount used" do
+          plan = build(:susply_plan, price: 99, interval: 'monthly')
+          used_days = 10
+          amount = Susply::Prorate.calculate_used_amount(plan, used_days)
+
+          expect(amount).to be 33
+        end
+      end
+    end
+  end
+end

data/spec/services/susply/renews_subscription_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+module Susply
+  describe RenewsSubscription do
+    let(:owner_class) { Susply.subscription_owner_class.constantize } 
+    let(:time) {Time.zone.today}
+
+    context "when owner does not has an active subscription" do
+      it "returns nil" do
+        owner = owner_class.create()
+        plan = create(:susply_plan)
+        subscription = create(:susply_subscription, :inactive, owner: owner)
+
+        s = Susply::RenewsSubscription.call(owner)
+
+        expect(s).to be_nil
+      end
+    end
+
+    context "when owner has an active subscription" do
+      it "creates a payment of renovation type" do
+        owner = owner_class.create()
+        plan = create(:susply_plan, interval: 'monthly', price: 101)
+        subscription = create(:susply_subscription, :active,
+                              owner: owner, plan: plan)
+
+        s = Susply::RenewsSubscription.call(owner)
+        payment = owner.payments.last
+
+        expect(payment.generated_type).to eq 'plan_renovation'
+        expect(payment.amount).to eq 101
+      end
+
+      it "does not creates an extra subscription" do
+        owner = owner_class.create()
+        subscription = create(:susply_subscription, :active, owner: owner)
+
+        Susply::RenewsSubscription.call(owner)
+
+        expect(owner.subscriptions.count).to be 1
+      end
+
+      it "return a subscription with updated attributes" do
+        owner = owner_class.create()
+        subscription = create(:susply_subscription, :active, owner: owner, 
+                             current_period_start: time - 5.days)
+        s = Susply::RenewsSubscription.call(owner)
+        
+        expect(s.quantity).not_to eq subscription.quantity
+        expect(s.current_period_start).
+          not_to eq subscription.current_period_start
+        expect(s.current_period_end).
+          not_to eq subscription.current_period_end
+      end
+
+      it "returns updates by one the subscriptions" do
+        owner = owner_class.create()
+        subscription = create(:susply_subscription, :active, owner: owner, 
+                             current_period_start: time - 5.days,
+                             quantity: 5)
+        s = Susply::RenewsSubscription.call(owner)
+
+        expect(s.quantity).to eq 6
+      end
+
+      it "sets the subscription initial date o past end" do
+        owner = owner_class.create()
+        end_time = time + 6.hours
+        subscription = create(:susply_subscription, :active, owner: owner, 
+                             current_period_start: time - 5.days,
+                             current_period_end: end_time)
+        s = Susply::RenewsSubscription.call(owner)
+
+        expect(s.current_period_start).to eq end_time
+      end
+
+      it "sets the end period to the given month calculation" do
+        owner = owner_class.create()
+        end_time = time + 6.hours
+        plan = create(:susply_plan, interval: 'monthly')
+        subscription = create(:susply_subscription, :active, owner: owner, 
+                             plan: plan, current_period_end: end_time)
+        s = Susply::RenewsSubscription.call(owner)
+        expect(s.current_period_end).to eq(end_time + 1.month)
+      end
+
+      it "sets the end period to the given yearly calculation" do
+        owner = owner_class.create()
+        end_time = time + 2.hours
+        plan = create(:susply_plan, interval: 'yearly')
+        subscription = create(:susply_subscription, :active, owner: owner, 
+                             plan: plan, current_period_end: end_time)
+        s = Susply::RenewsSubscription.call(owner)
+        expect(s.current_period_end).to eq(end_time + 1.year)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+ENV["RAILS_ENV"] ||= 'test'
+require File.expand_path("../dummy/config/environment", __FILE__)
+require 'rspec/rails'
+require 'factory_girl_rails'
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+Rails.backtrace_cleaner.remove_silencers!
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+  config.use_transactional_fixtures = true
+  config.infer_base_class_for_anonymous_controllers = false
+  config.order = "random"
+  config.include FactoryGirl::Syntax::Methods
+end