Checkout system giving strange result - ruby

Question

So I'm making a checkout system similar to this. However, I have 3 items (A, B and C priced at $3.11, $5.00 and $11.23, respectively).
The conditions are such that item A has a buy-one-get-one-free offer and item B reduces to $4.50 if 3 or more units are bought. The problem comes when testing the code.
I've written the following code to solve the exercise:
class PriceDiscount # Applies price discounts for a specific number of items
# Initial method with item price and item quantity parameters
def initialize(itemprice, quantity)
#itemprice = itemprice
#quantity = quantity
end
# "calculate_for" method which calculates the discount for the specific number of items
def calculate_for(quantity)
(quantity / #quantity).floor * #itemprice
end
end
class PricePolicy # Calculates the price for a certain quantity of items after discounts
# Initial method with the original price and discounts as the paremeters
def initialize(orgprice, *discounts)
#orgprice = orgprice
#discounts = discounts
end
# Calculates the discounted price of a number of items
def price_for(quantity)
quantity * #orgprice - discount_for(quantity)
end
# Calculates the discount which is given for a number of items
def discount_for(quantity)
#discounts.inject(0) do |mem, discount|
mem + discount.calculate_for(quantity)
end
end
end
# Rule list set up for great flexibility as each rule is specified in one line
RULES = {
'A' => PricePolicy.new(3.11, PriceDiscount.new(3.11, 2)),
'B' => PricePolicy.new(5.00, PriceDiscount.new(4.50, 2)),
'C' => PricePolicy.new(11.23),
}
class Checkout # Checkout class which applies the rules to each item that is scanned
# Initial method which has the rules and items as its parameters
def initialize(rules)
#rules = rules
#items = Hash.new
end
# Method to set up the array in which scanned items are stored
def scan(item)
#items[item] ||= 0
#items[item] += 1
end
# Method which totals the price of the scanned items
def total
#items.inject(0) do |mem, (item, quantity)|
mem + price_for(item, quantity)
end
end
private
def price_for(item, quantity)
if rule_for(item)
rule_for(item).price_for(quantity)
else
raise "Invalid item '#{item}'"
end
end
def rule_for(item)
#rules[item]
end
end
And this is the tester:
require 'test/unit'
require_relative './CheckoutSystem.rb'
class TestPrice < Test::Unit::TestCase
def price(goods)
co = Checkout.new(RULES)
goods.split(//).each { |item| co.scan(item) }
co.total
end
def test_totals
# Scenario 1 with basket: A, B, A, A, C
assert_equal(22.45, price("ABAAC").round(2))
# Scenario 2 with basket: A, A
assert_equal(3.11, price("AA").round(2))
# Scenario 3 with basket: B, B, A, B
assert_equal(16.61, price("BBAB").round(2))
end
end
Scenario 1 and 2 give the correct values. However, scenario 3 gives the value of $13.11 when it should in fact be $16.61.
Does anyone have any idea where I've made a mistake? I've been going over it for ages and can't fix it. Any help would be greatly appreciated!

Answer 1

In order to change your program to pass the test cases, you have to change:
'B' => PricePolicy.new(5.00, PriceDiscount.new(4.50, 2)),
To
'B' => PricePolicy.new(5.00, PriceDiscount.new(1.50, 3)),
This way, when the user purchases 3 'B' items, they will receive a discount of 1.5, meaning that the total price of the 3 items will change from 15 to 13.5 (4.50 each.)
Note that in this case, if the user buys 4 'B' items, they will receive a discount on the first 3, but NO discount on the fourth item.
To solve the problem to work properly when '3 or more items' are purchased, the discount.calculate_for method will have to be changed. This is because 'A' and 'B' items will calculate their discounts differently:
A straightforward implementation would be to define a 'type' for each of the situations. In the example below, an empty type simply represents the 'x or more items' situation, and a bogo type represents a 'buy x and get a flat discount' situation.
class PriceDiscount
def initialize(itemprice, quantity, type = nil)
#itemprice = itemprice
#quantity = quantity
#type = type
raise "Invalid type '#{type}'" if #type != 'bogo' && #type != nil
end
def calculate_for(quantity)
if (#type == 'bogo')
(quantity / #quantity) * #itemprice
elsif quantity >= #quantity
(quantity.to_f / #quantity) * #itemprice
else
0
end
end
end
And the rules would be updated as follows:
RULES = {
'A' => PricePolicy.new(3.11, PriceDiscount.new(3.11, 2, 'bogo')),
'B' => PricePolicy.new(5.00, PriceDiscount.new(1.50, 3)),
'C' => PricePolicy.new(11.23),
}
The bogo items would use the same calculation as you had before, meaning that AA has 1 discount, AAA has 1 discount, and AAAA has 2 discounts.
The 'x or more items' will first check if the number of items meets the threshold, and if so, it will apply the discounted rate to every single one of those items. (In this case, BBB will apply the specified discount of 1.50. BBBB will apply a modified version of the discount --> 2.00, to match the 4 items.)
As well, you can drop the '.floor' method for ints --> it will automatically floor when converting. To get non-integer results, you can see that I've converted one of the values in the second calculation to a float.
Try running these changes with these change-specific tests:
assert_equal(13.11, price("BBA").round(2))
assert_equal(21.11, price("BBBBA").round(2))
assert_equal(22.45, price("AAAABC").round(2))
assert_equal(25.56, price("AAAAABC").round(2))