Welcome to your third unit for this course dedicated to practicing Test Driven Development (TDD) utilizing Ruby and RSpec. In this lesson, we will explore the process of building a ShoppingCart class with multiple features using TDD.

The aim is to provide you with an understanding of how requirements are translated into tests, which are tackled one at a time. You'll observe how tests are written and code is implemented to pass each test, simulating a real-world TDD environment. Previously, tests were provided, but this time, the focus will be on creating them independently.

Remember to use the core concepts of the Red-Green-Refactor cycle while practicing these exercises. I'm still here to help! Just ask if you encounter any questions or issues.

In this section, you will learn how to build the ShoppingCart class by implementing the following features:

1. Starting with an Empty Cart
2. Adding a Single Item
3. Adding Multiple Items
4. Handling Multiple Quantities of the Same Item
5. Removing an Item

• Description: When a new shopping cart is created, it should start without any items, and the total price should be zero.
• Details:
  • Initialize a new shopping cart using the ShoppingCart constructor.
  • Ensure the item_count method returns 0 for an empty cart.
  • Verify the total method returns 0 for the initial state.
• Examples: A newly created cart should have a count of 0 and a total of 0.

• Description: Verify that when a single item is added to the cart, the cart's item count increases, and the total price reflects the added item's price.
• Details:
  • Use the add_item(item) method to add an item to the cart.
  • Confirm that the item_count method returns the correct number of items after an item is added.
  • Ensure the total method accurately calculates and returns the total price of items in the cart.
• Examples: Adding an item {'id' => '1', 'name' => 'Book', 'price' => 10} should result in an item count of 1 and a total cost of 10.

• Description: When multiple different items are added to the cart, the item count should reflect the total number of unique items, and the total price should be the sum of all individual item prices.
• Details:
  • Accommodate adding different items using the add_item() method.
  • Ensure the item_count method accurately reflects the number of items added.
  • Verify that the total method correctly calculates the sum of all item prices.
• Examples: Adding {'id' => '1', 'name' => 'Book', 'price' => 10} and {'id' => '2', 'name' => 'Pen', 'price' => 5} should result in a count of 2 and a total of 15.

• Description: When multiple quantities of the same item are added to the cart, the item count should reflect the total quantity added, and the total price should be the item's unit price multiplied by the quantity.
• Details:
  • Allow items to be added with a specified quantity using an add_item(item, quantity) method.
  • Ensure the item_count method returns the sum of all quantities added for an item.
  • Update the total method to calculate the total price using the unit price multiplied by the total quantity.
• Examples: Adding {'id' => '1', 'name' => 'Book', 'price' => 10} with a quantity of 3 should have a count of 3 and a total of 30.

• Description: When an item is removed from the cart, the item count should decrease accordingly, and the total price should adjust to reflect the removal.
• Details:
  • Provide a remove_item(id) method to handle the removal of items from the cart.
  • Ensure the item_count method accurately reflects the new count after removal.
  • Update the total method to return the correct total price after an item has been removed.
• Examples: Adding {'id' => '1', 'name' => 'Book', 'price' => 10} in a quantity of 2 and then removing one should result in a count of 1 and a total of 10.

Looking ahead to the practice exercises, you will have the opportunity to write tests and ensure they pass while practicing the Red-Green-Refactor cycle. Your implementation may differ from the provided solutions as we move forward, and that’s perfectly acceptable. Each practice session will begin from a solution foundation, allowing you to compare your approach with the guided solution and develop your features to ensure test success.

As you undertake these exercises, remember to engage in the Red-Green-Refactor cycle. Be sure to practice writing tests first and do not write implementation code unless the test asks for it.

Red! Green! Refactor!