zillion 0.0.8 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6ce05db824e474efb57c076724e898b942e9d1e7
-  data.tar.gz: 4b9cd7809dfe54aebde95a44e20c367d5fecdd1e
+  metadata.gz: 91b941a168263933e9486bb2e3ba9dacf45b3d65
+  data.tar.gz: 6eafd20870092fa550a2f44e816d9776660c5e51
 SHA512:
-  metadata.gz: 5474bb4ab5fbec4aa0dfdb1d8d6739086760b76737534e934b8b8149e45a046acc3b9ae48d2262fdb9a90e1522f91da0fb016b48baa7f35c49765f9d23360df6
-  data.tar.gz: 8034f57e84d372f1209fc6f074c39661ee21a810860cf2c250d6f968c280ffd5a69ec5d5bf9d3c4944c8b1f3b5c5792fec183591475a321ca5f22aa58c1c5a91
+  metadata.gz: 0e4be1ce406af366e61cfe47433d3a0f33637bf548bd1ac7706d9359397b062a7effa77909cd4b89a381452bbb6a86849481f083b45f1781f7a2a9327521a31e
+  data.tar.gz: 95e9d521a36ec5f21d4c921fc6693b39f379076eeb7f33f3a7c8a9c8414619a1a8fdc154eaffeaaccd4a5ade8670761ec99753c236e5a36d82a8d15cf41d9d71

data/lib/zillion/plan.rb

@@ -128,16 +128,16 @@ class TieredPlan < Plan
   def amounts_for(counts)
     tier = matching_tier_for(counts)
     obj = {}
-    obj[tier.last.to_sym] = tier[1]
+    obj[tier.last.to_sym] = tier[1] # tier[1] is monthly cost
     obj
   end
 
   def matching_tier_for(counts)
     if tiers = matching_tiers_for(counts) and tiers.any?
-      # raise "More than one tier matches for #{counts}" if tiers.count > 1
-      tiers.first
+      # sort by monthly cost and return highest (first) one
+      tiers.sort { |a, b| a[1] <=> b[1] }.last
     else
-      raise "No matching tiers found for #{counts.inspect} in #{name} plan."
+      raise TierNotFoundError.new("No matching tiers found for #{counts.inspect} in #{name} plan.")
     end
   end
 
@@ -148,11 +148,6 @@ class TieredPlan < Plan
 
   private
 
-  def matching_tiers_for(counts)
-    # sort by amount (format is [range, monthly_cost, index, type])
-    get_matching_tiers(counts).sort { |a, b| b[1] <=> a[1] }
-  end
-
   def find_tier_for(tiers, units)
     # raise "Units not set!" unless units
     arr = tiers.select { |t| t[0].include?(units) }
@@ -168,10 +163,10 @@ class TieredPlan < Plan
 
   def tier_groups
     spec[:tiers].each_with_object({}) do |(key, list), obj|
-      obj[key] = list.map do |t|
+      obj[key.to_sym] = list.map do |t|
         h = symbolize_keys(t)
         [ h[:from]..h[:to], h[tier_cost_key] ]
-      end
+      end.sort { |a, b| a[0].last <=> b[0].last } # sort by last/highest item in range
     end
   end
 
@@ -179,10 +174,22 @@ class TieredPlan < Plan
     :monthly_cost
   end
 
-  def get_matching_tiers(counts)
+  # returns the last/highest existing tiers for the given keys
+  def last_existing_tier_for(key)
+    if found = tier_groups[key.to_sym]
+      found.last + [key]
+    end
+  end
+
+  def matching_tiers_for(counts, fallback_to_highest_tier = false)
     tier_groups.map do |key, tiers|
-      units = counts[key] or raise "Unit count required for #{key}"
-      find_tier_for(tiers, units.to_i) + [key]
+      units = counts[key] or raise MissingCountError.new("Unit count required for #{key}")
+      begin
+        find_tier_for(tiers, units.to_i) + [key]
+      rescue TierNotFoundError
+        raise unless fallback_to_highest_tier
+        last_existing_tier_for(key)
+      end
     end.compact
   end
 
@@ -194,11 +201,11 @@ end
 
 class MeteredPlan < TieredPlan
 
-  def amounts_for(counts)
+  def amounts_for(counts, fallback_to_highest_tier = false)
     obj = {}
-    matching_tiers_for(counts).map do |tier|
+    matching_tiers_for(counts, fallback_to_highest_tier).map do |tier|
       units = units_for(tier.last, counts)
-      obj[tier.last.to_sym] = units * tier[1]
+      obj[tier.last.to_sym] = units * tier[1] # tier[1] is monthly unit cost
     end
     obj
   end
@@ -207,6 +214,8 @@ class MeteredPlan < TieredPlan
     counts[type]
   end
 
+  private
+
   def tier_cost_key
     :monthly_unit_cost
   end
@@ -219,7 +228,7 @@ class FixedMeteredPlan < MeteredPlan
     spec[:monthly_fee] ? spec[:monthly_fee].to_f : 0
   end
 
-  def amounts_for(counts)
+  def amounts_for(counts, fallback_to_highest_tier = false)
     obj = super
     obj[:base_fee] = base_fee
     obj
@@ -256,6 +265,9 @@ class FixedMeteredPlan < MeteredPlan
     # so we should reduce the count of actual units
     units -= limits[type] if limits[type]
 
+    # but ensure we never go below zero
+    units = 0 if units < 0
+
     units
   end
 
@@ -263,12 +275,17 @@ class FixedMeteredPlan < MeteredPlan
     :monthly_unit_cost
   end
 
-  def get_matching_tiers(counts)
+  def matching_tiers_for(counts, fallback_to_highest_tier = false)
     tier_groups.map do |key, tiers|
-      units = counts[key] or raise "Unit count required for #{key}"
+      units = counts[key] or raise MissingCountError.new("Unit count required for #{key}")
       next if limits[key] and limits[key] >= units.to_i
 
-      find_tier_for(tiers, units.to_i) + [key]
+      begin
+        find_tier_for(tiers, units.to_i) + [key]
+      rescue TierNotFoundError
+        raise unless fallback_to_highest_tier
+        last_existing_tier_for(key)
+      end
     end.compact
   end
 

data/spec/plans_spec.rb

@@ -39,48 +39,48 @@ describe 'FreePlan' do
 
   end
 
-  describe '#monthly_fee_for(counts)' do
+  describe '#available_for?(counts)' do
 
-    it 'returns 0 if no limits' do
-      expect(plan.monthly_fee_for({ apples: 10 })).to eql(0)
+    it 'returns true if no limits' do
+      expect(plan.available_for?({ bananas: 100 }) ).to eql(true)
     end
 
-    it 'returns 0 if within limits' do
+    it 'raises if not all units for limits are fed' do
       other = FreePlan.new(limits: { bananas: 10 })
-      expect(other.monthly_fee_for({ bananas: 10 })).to eql(0)
+      expect { other.available_for?({ apples: 10 }) }.to raise_error(Zillion::Plan::MissingCountError)
     end
 
-    it 'raises if not within limits' do
+    it 'returns false if limits/units match, but over the limit' do
       other = FreePlan.new(limits: { bananas: 10 })
-      expect { other.monthly_fee_for({ bananas: 11 }) }.to raise_error
+      expect(other.available_for?({ bananas: 20 })).to eql(false)
     end
 
-    it 'raises if not all counts present' do
+    it 'returns true if limits/units match, and within the limit' do
       other = FreePlan.new(limits: { bananas: 10, apples: 10 })
-      expect { other.monthly_fee_for({ apples: 5 }) }.to raise_error
+      expect(other.available_for?({ bananas: 5, apples: 2 })).to eql(true)
     end
 
   end
 
-  describe '#available_for?(counts)' do
+  describe '#monthly_fee_for(counts)' do
 
-    it 'returns true if no limits' do
-      expect(plan.available_for?({ bananas: 100 }) ).to eql(true)
+    it 'returns 0 if no limits' do
+      expect(plan.monthly_fee_for({ apples: 10 })).to eql(0)
     end
 
-    it 'raises if not all units for limits are fed' do
+    it 'returns 0 if within limits' do
       other = FreePlan.new(limits: { bananas: 10 })
-      expect { other.available_for?({ apples: 10 }) }.to raise_error
+      expect(other.monthly_fee_for({ bananas: 10 })).to eql(0)
     end
 
-    it 'returns false if limits/units match, but over the limit' do
+    it 'raises if not within limits' do
       other = FreePlan.new(limits: { bananas: 10 })
-      expect(other.available_for?({ bananas: 20 })).to eql(false)
+      expect { other.monthly_fee_for({ bananas: 11 }) }.to raise_error(Zillion::Plan::OverLimitsError)
     end
 
-    it 'returns true if limits/units match, and within the limit' do
+    it 'raises if not all counts present' do
       other = FreePlan.new(limits: { bananas: 10, apples: 10 })
-      expect(other.available_for?({ bananas: 5, apples: 2 })).to eql(true)
+      expect { other.monthly_fee_for({ apples: 5 }) }.to raise_error(Zillion::Plan::MissingCountError)
     end
 
   end
@@ -95,7 +95,7 @@ describe 'FixedPlan' do
 
     it 'raises if monthly_fee not set' do
       other = FixedPlan.new(limits: { bananas: 10 })
-      expect { other.monthly_fee }.to raise_error
+      expect { other.monthly_fee }.to raise_error(Zillion::Plan::InvalidFeeError)
     end
 
     it 'returns monthly_fee, if present' do
@@ -104,48 +104,48 @@ describe 'FixedPlan' do
 
   end
 
-  describe '#monthly_fee_for(counts)' do
+  describe '#available_for?(counts)' do
 
-    it 'returns monthly_fee if no limits' do
-      expect(plan.monthly_fee_for({ apples: 10 })).to eql(10.0)
+    it 'returns true if no limits' do
+      expect(plan.available_for?({ bananas: 100 }) ).to eql(true)
     end
 
-    it 'returns monthly_fee if within limits' do
+    it 'raises not all units for limits are fed' do
       other = FixedPlan.new(monthly_fee: 10, limits: { bananas: 10 })
-      expect(other.monthly_fee_for({ bananas: 10 })).to eql(10.0)
+      expect { other.available_for?({ apples: 10 }) }.to raise_error
     end
 
-    it 'raises if not within limits' do
+    it 'returns false if limits/units match, but over the limit' do
       other = FixedPlan.new(monthly_fee: 10, limits: { bananas: 10 })
-      expect { other.monthly_fee_for({ bananas: 11 }) }.to raise_error
+      expect(other.available_for?({ bananas: 20 })).to eql(false)
     end
 
-    it 'raises if not all counts present' do
+    it 'returns true if limits/units match, and within the limit' do
       other = FixedPlan.new(monthly_fee: 10, limits: { bananas: 10, apples: 10 })
-      expect { other.monthly_fee_for({ apples: 5 }) }.to raise_error
+      expect(other.available_for?({ bananas: 5, apples: 2 })).to eql(true)
     end
 
   end
 
-  describe '#available_for?(counts)' do
+  describe '#monthly_fee_for(counts)' do
 
-    it 'returns true if no limits' do
-      expect(plan.available_for?({ bananas: 100 }) ).to eql(true)
+    it 'returns monthly_fee if no limits' do
+      expect(plan.monthly_fee_for({ apples: 10 })).to eql(10.0)
     end
 
-    it 'raises not all units for limits are fed' do
+    it 'returns monthly_fee if within limits' do
       other = FixedPlan.new(monthly_fee: 10, limits: { bananas: 10 })
-      expect { other.available_for?({ apples: 10 }) }.to raise_error
+      expect(other.monthly_fee_for({ bananas: 10 })).to eql(10.0)
     end
 
-    it 'returns false if limits/units match, but over the limit' do
+    it 'raises if not within limits' do
       other = FixedPlan.new(monthly_fee: 10, limits: { bananas: 10 })
-      expect(other.available_for?({ bananas: 20 })).to eql(false)
+      expect { other.monthly_fee_for({ bananas: 11 }) }.to raise_error(Zillion::Plan::OverLimitsError)
     end
 
-    it 'returns true if limits/units match, and within the limit' do
+    it 'raises if not all counts present' do
       other = FixedPlan.new(monthly_fee: 10, limits: { bananas: 10, apples: 10 })
-      expect(other.available_for?({ bananas: 5, apples: 2 })).to eql(true)
+      expect { other.monthly_fee_for({ apples: 5 }) }.to raise_error(Zillion::Plan::MissingCountError)
     end
 
   end
@@ -160,8 +160,8 @@ describe 'TieredPlan', 'Single tier' do
       limits: { bananas: 10 },
       tiers: {
         products: [
-          { from: 0, to: 100, monthly_cost: 20 },
           { from: 101, to: 200, monthly_cost: 30 },
+          { from: 0, to: 100, monthly_cost: 20 },
         ]
       })
   }
@@ -174,42 +174,42 @@ describe 'TieredPlan', 'Single tier' do
 
   end
 
-  describe '#monthly_fee_for(counts)' do
+  describe '#available_for?(counts)' do
 
     it 'raises if missing unit for tier' do
-      expect { plan.monthly_fee_for({ bananas: 5 }) }.to raise_error
+      expect { plan.available_for?({ bananas: 5 }) }.to raise_error(Zillion::Plan::MissingCountError)
     end
 
     it 'raises if missing unit for fixed limit' do
-      expect { plan.monthly_fee_for({ products: 25 }) }.to raise_error
+      expect { plan.available_for?({ products: 25 }) }.to raise_error(Zillion::Plan::MissingCountError)
     end
 
     it 'raises if not within limits' do
-      expect { plan.monthly_fee_for({ bananas: 5, products: -5 }) }.to raise_error
+      expect { plan.available_for?({ bananas: 5, products: -5 }) }.to raise_error(Zillion::Plan::TierNotFoundError)
     end
 
     it 'returns monthly fee for tier if within its limit' do
-      expect(plan.monthly_fee_for({ bananas: 5, products: 25 })).to eql(20)
+      expect(plan.available_for?({ bananas: 5, products: 25 })).to eql(true)
     end
 
   end
 
-  describe '#available_for?(counts)' do
+  describe '#monthly_fee_for(counts)' do
 
     it 'raises if missing unit for tier' do
-      expect { plan.available_for?({ bananas: 5 }) }.to raise_error
+      expect { plan.monthly_fee_for({ bananas: 5 }) }.to raise_error(Zillion::Plan::MissingCountError)
     end
 
     it 'raises if missing unit for fixed limit' do
-      expect { plan.available_for?({ products: 25 }) }.to raise_error
+      expect { plan.monthly_fee_for({ products: 25 }) }.to raise_error(Zillion::Plan::MissingCountError)
     end
 
     it 'raises if not within limits' do
-      expect { plan.available_for?({ bananas: 5, products: -5 }) }.to raise_error
+      expect { plan.monthly_fee_for({ bananas: 5, products: -5 }) }.to raise_error(Zillion::Plan::TierNotFoundError)
     end
 
     it 'returns monthly fee for tier if within its limit' do
-      expect(plan.available_for?({ bananas: 5, products: 25 })).to eql(true)
+      expect(plan.monthly_fee_for({ bananas: 5, products: 25 })).to eql(20)
     end
 
   end
@@ -223,8 +223,8 @@ describe 'TieredPlan', 'Multiple tiers' do
       limits: { bananas: 10 },
       tiers: {
         orders: [
+          { from: 11, to: 20, monthly_cost: 35 },
           { from: 0, to: 10, monthly_cost: 15 },
-          { from: 11, to: 20, monthly_cost: 35 }
         ],
         products: [
           { from: 0, to: 100, monthly_cost: 20 },
@@ -241,42 +241,42 @@ describe 'TieredPlan', 'Multiple tiers' do
 
   end
 
-  describe '#monthly_fee_for(counts)' do
+  describe '#available_for?(counts)' do
 
     it 'raises if missing unit for tier' do
-      expect { plan.monthly_fee_for({ bananas: 5, products: 25 }) }.to raise_error
+      expect { plan.available_for?({ bananas: 5 }) }.to raise_error(Zillion::Plan::MissingCountError)
     end
 
     it 'raises if missing unit for fixed limit' do
-      expect { plan.monthly_fee_for({ products: 25 }) }.to raise_error
+      expect { plan.available_for?({ products: 25 }) }.to raise_error(Zillion::Plan::MissingCountError)
     end
 
     it 'raises if not within limits' do
-      expect { plan.monthly_fee_for({ bananas: 5, products: -5 }) }.to raise_error
+      expect { plan.available_for?({ bananas: 5, products: -5, orders: -1 }) }.to raise_error(Zillion::Plan::TierNotFoundError)
     end
 
-    it 'returns monthly fee for tier if within its limit' do
-      expect(plan.monthly_fee_for({ bananas: 1, orders: 5, products: 25 })).to eql(20)
+    it 'returns true if within tier limits' do
+      expect(plan.available_for?({ bananas: 5, orders: 5, products: 25 })).to eql(true)
     end
 
   end
 
-  describe '#available_for?(counts)' do
+  describe '#monthly_fee_for(counts)' do
 
     it 'raises if missing unit for tier' do
-      expect { plan.available_for?({ bananas: 5 }) }.to raise_error
+      expect { plan.monthly_fee_for({ bananas: 5, products: 25 }) }.to raise_error(Zillion::Plan::MissingCountError)
     end
 
     it 'raises if missing unit for fixed limit' do
-      expect { plan.available_for?({ products: 25 }) }.to raise_error
+      expect { plan.monthly_fee_for({ products: 25 }) }.to raise_error(Zillion::Plan::MissingCountError)
     end
 
     it 'raises if not within limits' do
-      expect { plan.available_for?({ bananas: 5, products: -5 }) }.to raise_error
+      expect { plan.monthly_fee_for({ bananas: 5, products: -5, orders: 0 }) }.to raise_error(Zillion::Plan::TierNotFoundError)
     end
 
-    it 'returns true if within tier limits' do
-      expect(plan.available_for?({ bananas: 5, orders: 5, products: 25 })).to eql(true)
+    it 'returns monthly fee for tier if within its limit' do
+      expect(plan.monthly_fee_for({ bananas: 1, orders: 5, products: 25 })).to eql(20)
     end
 
   end
@@ -290,8 +290,8 @@ describe 'MeteredPlan', 'Single tier' do
       limits: { bananas: 10 },
       tiers: {
         products: [
+          { from: 101, to: 200, monthly_unit_cost: 1.5 },
           { from: 0, to: 100, monthly_unit_cost: 2 },
-          { from: 101, to: 200, monthly_unit_cost: 1.5 }
         ]
       })
   }
@@ -304,18 +304,38 @@ describe 'MeteredPlan', 'Single tier' do
 
   end
 
+  describe '#available_for?(counts)' do
+
+    it 'raises if missing unit for tier' do
+      expect { plan.available_for?({ bananas: 5 }) }.to raise_error(Zillion::Plan::MissingCountError)
+    end
+
+    it 'raises if missing unit for fixed limit' do
+      expect { plan.available_for?({ products: 25 }) }.to raise_error(Zillion::Plan::MissingCountError)
+    end
+
+    it 'raises if not within limits' do
+      expect { plan.available_for?({ bananas: 5, products: -5 }) }.to raise_error(Zillion::Plan::TierNotFoundError)
+    end
+
+    it 'returns true if within its limit' do
+      expect(plan.available_for?({ bananas: 5, products: 25 })).to eql(true)
+    end
+
+  end
+
   describe '#monthly_fee_for(counts)' do
 
     it 'raises if missing unit for tier' do
-      expect { plan.monthly_fee_for({ bananas: 5 }) }.to raise_error
+      expect { plan.monthly_fee_for({ bananas: 5 }) }.to raise_error(Zillion::Plan::MissingCountError)
     end
 
     it 'raises if missing unit for fixed limit' do
-      expect { plan.monthly_fee_for({ products: 25 }) }.to raise_error
+      expect { plan.monthly_fee_for({ products: 25 }) }.to raise_error(Zillion::Plan::MissingCountError)
     end
 
     it 'raises if not within limits' do
-      expect { plan.monthly_fee_for({ bananas: 5, products: -5 }) }.to raise_error
+      expect { plan.monthly_fee_for({ bananas: 5, products: -5 }) }.to raise_error(Zillion::Plan::TierNotFoundError)
     end
 
     it 'returns monthly fee for tier if within its limit' do
@@ -324,26 +344,34 @@ describe 'MeteredPlan', 'Single tier' do
 
   end
 
-  describe '#available_for?(counts)' do
+  describe '#amounts_for(counts)' do
 
     it 'raises if missing unit for tier' do
-      expect { plan.available_for?({ bananas: 5 }) }.to raise_error
+      expect { plan.amounts_for({ bananas: 5 }) }.to raise_error(Zillion::Plan::MissingCountError)
     end
 
-    it 'raises if missing unit for fixed limit' do
-      expect { plan.available_for?({ products: 25 }) }.to raise_error
+    it 'raises if not within limits' do
+      expect { plan.amounts_for({ bananas: 5, products: -5 }) }.to raise_error(Zillion::Plan::TierNotFoundError)
+    end
+
+    it 'returns amounts if within limits' do
+      expect(plan.amounts_for({ products: 25 })).to eql({ products: 50 })
     end
 
     it 'raises if not within limits' do
-      expect { plan.available_for?({ bananas: 5, products: -5 }) }.to raise_error
+      expect { plan.amounts_for({ products: 250 }) }.to raise_error(Zillion::Plan::TierNotFoundError)
     end
 
-    it 'returns true if within its limit' do
-      expect(plan.available_for?({ bananas: 5, products: 25 })).to eql(true)
+    it 'doesnt raise if not within limits but second arg is true' do
+      expect { plan.amounts_for({ products: 250 }, true) }.not_to raise_error(Zillion::Plan::TierNotFoundError)
+      expect(plan.amounts_for({ products: 250 }, true)).to eql({ products: 375.0 })
     end
 
-  end
+    it 'returns amounts if within limits' do
+      expect(plan.amounts_for({ bananas: 5, products: 25 })).to eql({ products: 50 })
+    end
 
+  end
 
 end
 
@@ -372,18 +400,43 @@ describe 'MeteredPlan', 'Multiple tiers' do
 
   end
 
-  describe '#monthly_fee_for(counts)' do
+
+  describe '#available_for?(counts)' do
 
     it 'raises if missing unit for tier' do
-      expect { plan.monthly_fee_for({ bananas: 5 }) }.to raise_error
+      expect { plan.available_for?({ bananas: 5 }) }.to raise_error(Zillion::Plan::MissingCountError)
     end
 
     it 'raises if missing unit for fixed limit' do
-      expect { plan.monthly_fee_for({ products: 25 }) }.to raise_error
+      expect { plan.available_for?({ products: 25 }) }.to raise_error(Zillion::Plan::MissingCountError)
     end
 
     it 'raises if not within limits' do
-      expect { plan.monthly_fee_for({ bananas: 5, products: -5 }) }.to raise_error
+      expect { plan.available_for?({ bananas: 5, products: -5, orders: 1 }) }.to raise_error(Zillion::Plan::TierNotFoundError)
+    end
+
+    it 'returns true if within its limit' do
+      expect(plan.available_for?({ bananas: 5, orders: 5, products: 25 })).to eql(true)
+    end
+
+  end
+
+  describe '#monthly_fee_for(counts)' do
+
+    it 'raises if missing unit for tier' do
+      expect { plan.monthly_fee_for({ bananas: 5 }) }.to raise_error(Zillion::Plan::MissingCountError)
+    end
+
+    it 'raises if missing unit for fixed limit' do
+      expect { plan.monthly_fee_for({ products: 25 }) }.to raise_error(Zillion::Plan::MissingCountError)
+    end
+
+    it 'raises if below limits' do
+      expect { plan.monthly_fee_for({ bananas: 5, products: -5, orders: 10 }) }.to raise_error(Zillion::Plan::TierNotFoundError)
+    end
+
+    it 'raises if over limits' do
+      expect { plan.monthly_fee_for({ bananas: 5, products: 250, orders: 10 }) }.to raise_error(Zillion::Plan::TierNotFoundError)
     end
 
     it 'returns monthly fee for tier if within its limit' do
@@ -392,22 +445,31 @@ describe 'MeteredPlan', 'Multiple tiers' do
 
   end
 
-  describe '#available_for?(counts)' do
+  describe '#amounts_for(counts)' do
 
     it 'raises if missing unit for tier' do
-      expect { plan.available_for?({ bananas: 5 }) }.to raise_error
+      expect { plan.amounts_for({ bananas: 5 }) }.to raise_error(Zillion::Plan::MissingCountError)
     end
 
-    it 'raises if missing unit for fixed limit' do
-      expect { plan.available_for?({ products: 25 }) }.to raise_error
+    it 'raises if not within limits' do
+      expect { plan.amounts_for({ bananas: 5, products: -5, orders: 1 }) }.to raise_error(Zillion::Plan::TierNotFoundError)
     end
 
     it 'raises if not within limits' do
-      expect { plan.available_for?({ bananas: 5, products: -5 }) }.to raise_error
+      expect { plan.amounts_for({ products: 250, orders: 5, orders: 1 }) }.to raise_error(Zillion::Plan::TierNotFoundError)
     end
 
-    it 'returns true if within its limit' do
-      expect(plan.available_for?({ bananas: 5, orders: 5, products: 25 })).to eql(true)
+    it 'doesnt raise if not within limits but second arg is true' do
+      expect { plan.amounts_for({ products: 250, orders: 5 }, true) }.not_to raise_error(Zillion::Plan::TierNotFoundError)
+      expect(plan.amounts_for({ products: 250, orders: 5 }, true)).to eql({ orders: 15, products: 375.0 })
+    end
+
+    it 'returns amounts if within limits' do
+      expect(plan.amounts_for({ bananas: 5, products: 25, orders: 5 })).to eql({ orders: 15, products: 50 })
+    end
+
+    it 'returns amounts if within limits' do
+      expect(plan.amounts_for({ bananas: 5, products: 25, orders: 1 })).to eql({ orders: 3, products: 50 })
     end
 
   end
@@ -422,8 +484,8 @@ describe 'FixedMeteredPlan' do
       limits: { bananas: 10, orders: 10, products: 10 },
       tiers: {
         orders: [
+          { from: 16, to: 20, monthly_unit_cost: 1 },
           { from: 11, to: 15, monthly_unit_cost: 3 },
-          { from: 16, to: 20, monthly_unit_cost: 1 }
         ],
         products: [
           { from: 5, to: 100, monthly_unit_cost: 2 },
@@ -443,14 +505,53 @@ describe 'FixedMeteredPlan' do
 
   end
 
+
+  describe '#available_for?(counts)' do
+
+    it 'raises if missing units for tier' do
+      expect { plan.available_for?({ bananas: 5 }) }.to raise_error(Zillion::Plan::MissingCountError)
+    end
+
+    it 'raises if missing unit for fixed limit' do
+      expect { plan.available_for?({ products: 25 }) }.to raise_error(Zillion::Plan::MissingCountError)
+    end
+
+    it 'doent explode if negative key for limit with tier' do
+      expect(plan.available_for?({ bananas: 5, orders: 5, products: -5 })).to eql(true)
+    end
+
+    it 'returns true if below fixed limits' do
+      expect(plan.available_for?({ bananas: 5, orders: 5, products: 5 })).to eql(true)
+    end
+
+    it 'returns true if below fixed limits, even if no matching tier exists' do
+      plan_opts[:tiers].delete(:products)
+      expect(plan.available_for?({ bananas: 5, orders: 5, products: 5 })).to eql(true)
+    end
+
+    it 'returns false if above fixed limit and no tier found' do
+      plan_opts[:tiers].delete(:products)
+      expect(plan.available_for?({ bananas: 5, orders: 5, products: 15 })).to eql(false)
+    end
+
+    it 'returns true if above fixed limit but within tier limit' do
+      expect(plan.available_for?({ bananas: 5, orders: 5, products: 15 })).to eql(true)
+    end
+
+    it 'returns true if above fixed limit but within tier limit' do
+      expect(plan.available_for?({ bananas: 5, orders: 15, products: 25 })).to eql(true)
+    end
+
+  end
+
   describe '#monthly_fee_for(counts)' do
 
     it 'raises if missing unit for tier' do
-      expect { plan.monthly_fee_for({ bananas: 5 }) }.to raise_error
+      expect { plan.monthly_fee_for({ bananas: 5 }) }.to raise_error(Zillion::Plan::MissingCountError)
     end
 
     it 'raises if missing unit for fixed limit' do
-      expect { plan.monthly_fee_for({ products: 5 }) }.to raise_error
+      expect { plan.monthly_fee_for({ products: 5 }) }.to raise_error(Zillion::Plan::MissingCountError)
     end
 
     it 'doent explode if negative key for tiered count, but under fixed limit' do
@@ -461,7 +562,7 @@ describe 'FixedMeteredPlan' do
       expect(plan.monthly_fee_for({ bananas: 5, orders: 5, products: 5 })).to eql(10.0)
     end
 
-    it 'returns monthly fee for if just within limit limits' do
+    it 'returns monthly fee if just within limit limits' do
       expect(plan.monthly_fee_for({ bananas: 10, orders: 10, products: 10 })).to eql(10.0)
     end
 
@@ -475,40 +576,44 @@ describe 'FixedMeteredPlan' do
 
   end
 
-  describe '#available_for?(counts)' do
 
-    it 'raises if missing units for tier' do
-      expect { plan.available_for?({ bananas: 5 }) }.to raise_error
+  describe '#amounts_for(counts)' do
+
+    it 'raises if missing unit for tier' do
+      expect { plan.amounts_for({ bananas: 5 }) }.to raise_error(Zillion::Plan::MissingCountError)
     end
 
     it 'raises if missing unit for fixed limit' do
-      expect { plan.available_for?({ products: 25 }) }.to raise_error
+      expect { plan.amounts_for({ products: 5 }) }.to raise_error(Zillion::Plan::MissingCountError)
     end
 
-    it 'doent explode if negative key for limit with tier' do
-      expect(plan.available_for?({ bananas: 5, orders: 5, products: -5 })).to eql(true)
+    it 'raises if over limits' do
+      expect { plan.amounts_for({ orders: 1000, products: 5 }) }.to raise_error(Zillion::Plan::TierNotFoundError)
     end
 
-    it 'returns true if below fixed limits' do
-      expect(plan.available_for?({ bananas: 5, orders: 5, products: 5 })).to eql(true)
+    it 'doest raises if over limits but second arg is true' do
+      expect { plan.amounts_for({ orders: 1000, products: 5 }, true) }.not_to raise_error(Zillion::Plan::TierNotFoundError)
+      expect(plan.amounts_for({ orders: 1000, products: 5 }, true)).to eql({ orders: 990, base_fee: 10.0 })
     end
 
-    it 'returns true if below fixed limits, even if no matching tier exists' do
-      plan_opts[:tiers].delete(:products)
-      expect(plan.available_for?({ bananas: 5, orders: 5, products: 5 })).to eql(true)
+    it 'doesnt explode if negative key for tiered count, but under fixed limit' do
+      expect(plan.amounts_for({ bananas: 5, orders: 5, products: -5 })).to eql({ base_fee: 10.0 })
     end
 
-    it 'returns false if above fixed limit and no tier found' do
-      plan_opts[:tiers].delete(:products)
-      expect(plan.available_for?({ bananas: 5, orders: 5, products: 15 })).to eql(false)
+    it 'returns amounts for tier if below fixed limits' do
+      expect(plan.amounts_for({ bananas: 5, orders: 5, products: 5 })).to eql({ base_fee: 10.0 })
     end
 
-    it 'returns true if above fixed limit but within tier limit' do
-      expect(plan.available_for?({ bananas: 5, orders: 5, products: 15 })).to eql(true)
+    it 'returns amounts if just within limit limits' do
+      expect(plan.amounts_for({ bananas: 10, orders: 10, products: 10 })).to eql({ base_fee: 10.0 })
     end
 
-    it 'returns true e if above fixed limit but within tier limit' do
-      expect(plan.available_for?({ bananas: 5, orders: 15, products: 25 })).to eql(true)
+    it 'returns amounts for tier if within its limit' do
+      expect(plan.amounts_for({ bananas: 5, orders: 5, products: 25 })).to eql({:products=>30, :base_fee=>10.0})
+    end
+
+    it 'returns amounts for tier if within its limit' do
+      expect(plan.amounts_for({ bananas: 5, orders: 15, products: 25 })).to eql({:orders=>15, :products=>30, :base_fee=>10.0})
     end
 
   end

data/zillion.gemspec

@@ -3,7 +3,7 @@
 
 Gem::Specification.new do |s|
   s.name        = "zillion"
-  s.version     = '0.0.8'
+  s.version     = '0.1.0'
   s.platform    = Gem::Platform::RUBY
   s.authors     = ['Tomás Pollak']
   s.email       = ['tomas@forkhq.com']

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zillion
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.1.0
 platform: ruby
 authors:
 - Tomás Pollak
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-18 00:00:00.000000000 Z
+date: 2018-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -78,9 +78,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: A model for SaaS plans with fixed, tiered and metered pricing.
 test_files: []
-has_rdoc: