Merge pull request #626 from exercism/433-book-store-difficulty

book-store: cleanup, estimate difficulty

config.json

@@ -276,6 +276,11 @@
       "topics": []
     },
     {
+      "slug": "book-store",
+      "difficulty": 8,
+      "topics": []
+    },
+    {
       "slug": "simple-cipher",
       "difficulty": 8,
       "topics": []
@@ -316,11 +321,6 @@
       "topics": []
     },
     {
-      "slug": "book-store",
-      "difficulty": 1,
-      "topics": []
-    },
-    {
       "slug": "saddle-points",
       "difficulty": 1,
       "topics": []

exercises/book-store/src/example/java/Bookstore.java → exercises/book-store/src/example/java/BookStore.java

@@ -2,23 +2,17 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.stream.Collectors;
 
-class Bookstore {
+class BookStore {
 
   private static final int BOOK_PRICE = 8, MAX_GROUP_SIZE = 5;
 
   private static double[] DISCOUNT_TIERS = {0, 5, 10, 20, 25};
 
-  private List<Integer> books;
-
-  Bookstore(List<Integer> books) {
-    this.books = books;
-  }
-
-  double calculateTotalCost() {
-    return calculateTotalCost(this.books, 0);
+  double calculateBasketCost(final List<Integer> books) {
+    return calculateBasketCost(books, 0);
   }
 
-  private double calculateTotalCost(List<Integer> books, double priceSoFar) {
+  private double calculateBasketCost(final List<Integer> books, final double priceSoFar) {
     if (books.size() == 0) {
       return priceSoFar;
     }
@@ -38,8 +32,7 @@ class Bookstore {
         remainingBooks.remove(newGroupBook);
       }
 
-      double price = calculateTotalCost(remainingBooks, priceSoFar + costOfGroupSize(newGroupBooks.size()));
-
+      double price = calculateBasketCost(remainingBooks, priceSoFar + costOfGroupSize(newGroupBooks.size()));
       minPrice = Math.min(minPrice, price);
     }
 

exercises/book-store/src/test/java/BookStoreTest.java

@@ -0,0 +1,113 @@
+import static org.junit.Assert.assertEquals;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Arrays;
+
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+public class BookStoreTest {
+
+  // This is sufficient accuracy since we're handling currency values, which should be equal to within 2 decimal places.
+  private static final double EQUALITY_TOLERANCE = 0.001;
+
+  private BookStore bookStore;
+
+  @Before
+  public void setUp() {
+    bookStore = new BookStore();
+  }
+
+  @Test
+  public void onlyASingleBook() {
+    List<Integer> books = Collections.singletonList(1);
+    assertEquals(8, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+  @Ignore("Remove to run test")
+  @Test
+  public void twoOfSameBook() {
+    List<Integer> books = Arrays.asList(1, 1);
+    assertEquals(16, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+  @Ignore("Remove to run test")
+  @Test
+  public void emptyBasket() {
+    List<Integer> books = Collections.emptyList();
+    assertEquals(0, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+  @Ignore("Remove to run test")
+  @Test
+  public void twoDifferentBooks() {
+    List<Integer> books = Arrays.asList(1, 2);
+    assertEquals(15.20, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+  @Ignore("Remove to run test")
+  @Test
+  public void threeDifferentBooks() {
+    List<Integer> books = Arrays.asList(1, 2, 3);
+    assertEquals(21.6, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+  @Ignore("Remove to run test")
+  @Test
+  public void fourDifferentBooks() {
+    List<Integer> books = Arrays.asList(1, 2, 3, 4);
+    assertEquals(25.6, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+  @Ignore("Remove to run test")
+  @Test
+  public void fiveDifferentBooks() {
+    List<Integer> books = Arrays.asList(1, 2, 3, 4, 5);
+    assertEquals(30, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+  @Ignore("Remove to run test")
+  @Test
+  public void twoGroupsOfFourIsCheaperThanGroupOfFivePlusGroupOfThree() {
+    List<Integer> books = Arrays.asList(1, 1, 2, 2, 3, 3, 4, 5);
+    assertEquals(51.20, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+  @Ignore("Remove to run test")
+  @Test
+  public void groupOfFourPlusGroupOfTwoIsCheaperThanTwoGroupsOfThree() {
+    List<Integer> books = Arrays.asList(1, 1, 2, 2, 3, 4);
+    assertEquals(40.8, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+  @Ignore("Remove to run test")
+  @Test
+  public void twoEachOfFirst4BooksAnd1CopyEachOfRest() {
+    List<Integer> books = Arrays.asList(1, 1, 2, 2, 3, 3, 4, 4, 5);
+    assertEquals(55.60, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+  @Ignore("Remove to run test")
+  @Test
+  public void twoCopiesOfEachBook() {
+    List<Integer> books = Arrays.asList(1, 1, 2, 2, 3, 3, 4, 4, 5, 5);
+    assertEquals(60.00, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+  @Ignore("Remove to run test")
+  @Test
+  public void threeCopiesOfFirstBookAnd2EachOfRemaining() {
+    List<Integer> books = Arrays.asList(1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1);
+    assertEquals(68.00, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+  @Ignore("Remove to run test")
+  @Test
+  public void threeEachOFirst2BooksAnd2EachOfRemainingBooks() {
+    List<Integer> books = Arrays.asList(1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1, 2);
+    assertEquals(75.20, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+}

exercises/book-store/src/test/java/BookstoreTest.java

@@ -1,119 +0,0 @@
-import static org.junit.Assert.assertEquals;
-
-import java.util.Collections;
-import java.util.List;
-import java.util.ArrayList;
-import java.util.Arrays;
-
-import org.junit.Ignore;
-import org.junit.Test;
-
-public class BookstoreTest {
-
-  // This is sufficient accuracy since we're handling currency values, which should be equal to within 2 decimal places.
-  private static final double EQUALITY_TOLERANCE = 0.001;
-
-  @Test
-  public void onlyASingleBook() {
-    List<Integer> books = new ArrayList<>(Collections.singletonList(1));
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(8, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-  @Ignore("Remove to run test")
-  @Test
-  public void twoOfSameBook() {
-    List<Integer> books = new ArrayList<>(Arrays.asList(1, 1));
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(16, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-  @Ignore("Remove to run test")
-  @Test
-  public void emptyBasket() {
-    List<Integer> books = new ArrayList<>();
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(0, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-  @Ignore("Remove to run test")
-  @Test
-  public void twoDifferentBooks() {
-    List<Integer> books = new ArrayList<>(Arrays.asList(1, 2));
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(15.20, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-  @Ignore("Remove to run test")
-  @Test
-  public void threeDifferentBooks() {
-    List<Integer> books = new ArrayList<>(Arrays.asList(1, 2, 3));
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(21.6, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-  @Ignore("Remove to run test")
-  @Test
-  public void fourDifferentBooks() {
-    List<Integer> books = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(25.6, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-  @Ignore("Remove to run test")
-  @Test
-  public void fiveDifferentBooks() {
-    List<Integer> books = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(30, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-  @Ignore("Remove to run test")
-  @Test
-  public void twoGroupsOfFourIsCheaperThanGroupOfFivePlusGroupOfThree() {
-    List<Integer> books = new ArrayList<>(Arrays.asList(1, 1, 2, 2, 3, 3, 4, 5));
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(51.20, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-  @Ignore("Remove to run test")
-  @Test
-  public void groupOfFourPlusGroupOfTwoIsCheaperThanTwoGroupsOfThree() {
-    List<Integer> books = new ArrayList<>(Arrays.asList(1, 1, 2, 2, 3, 4));
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(40.8, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-  @Ignore("Remove to run test")
-  @Test
-  public void twoEachOfFirst4BooksAnd1CopyEachOfRest() {
-    List<Integer> books = new ArrayList<>(Arrays.asList(1, 1, 2, 2, 3, 3, 4, 4, 5));
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(55.60, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-  @Ignore("Remove to run test")
-  @Test
-  public void twoCopiesOfEachBook() {
-    List<Integer> books = new ArrayList<>(Arrays.asList(1, 1, 2, 2, 3, 3, 4, 4, 5, 5));
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(60.00, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-  @Ignore("Remove to run test")
-  @Test
-  public void threeCopiesOfFirstBookAnd2EachOfRemaining() {
-    List<Integer> books = new ArrayList<>(Arrays.asList(1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1));
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(68.00, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-  @Ignore("Remove to run test")
-  @Test
-  public void threeEachOFirst2BooksAnd2EachOfRemainingBooks() {
-    List<Integer> books = new ArrayList<>(Arrays.asList(1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1, 2));
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(75.20, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-}