diff --git a/pom.xml b/pom.xml index 8171c1a..acbb56a 100644 --- a/pom.xml +++ b/pom.xml @@ -24,6 +24,21 @@ 4.13 test + + net.serenity-bdd + serenity-core + 2.2.9 + + + net.serenity-bdd + serenity-junit + 2.2.9 + + + org.assertj + assertj-core + 3.16.1 + @@ -70,5 +85,16 @@ + + + org.apache.maven.plugins + maven-compiler-plugin + + 14 + 14 + --enable-preview + + + diff --git a/src/main/java/com/serenitydojo/Cat.java b/src/main/java/com/serenitydojo/Cat.java new file mode 100644 index 0000000..84af9eb --- /dev/null +++ b/src/main/java/com/serenitydojo/Cat.java @@ -0,0 +1,68 @@ +package com.serenitydojo; + +/** + * A feline creature. + */ +public class Cat extends Pet { + + private String favoriteFood; + private int age; + + // A very useful field + public static final String CAT_NOISE = "Meow"; + + public static String usualFood() { + return "Tuna"; + } + + public Cat(String name, int age) { + super(name); + this.age = age; + this.favoriteFood = usualFood(); + } + + public Cat(String name, String favoriteFood, int age) { + super(name); + this.favoriteFood = favoriteFood; + this.age = age; + } + + public void setFavoriteFood(String favoriteFood) { + this.favoriteFood = favoriteFood; + } + + public String getFavoriteFood() { + return favoriteFood; + } + + public int getAge() { + return age; + } + + @Override + public String makeNoise() { + return CAT_NOISE; + } + + @Override + public String play() { + return "plays with string"; + } + + public void feed(String food) { + System.out.println(getName() + " eats some " + food); + } + + public void groom() { + lickPaws(); + cleanFur(); + } + + private void cleanFur() { + System.out.println(getName() + " cleans his fur"); + } + + private void lickPaws() { + System.out.println(getName() + " licks his paws"); + } +} diff --git a/src/main/java/com/serenitydojo/Dog.java b/src/main/java/com/serenitydojo/Dog.java new file mode 100644 index 0000000..a12fc6f --- /dev/null +++ b/src/main/java/com/serenitydojo/Dog.java @@ -0,0 +1,29 @@ +package com.serenitydojo; + +public class Dog extends Pet { + private String favoriteToy; + private int age; + + public Dog(String name, String favoriteToy, int age) { + super(name); + this.favoriteToy = favoriteToy; + this.age = age; + } + + @Override + public String play() { + return "plays with bone"; + } + + public String getFavoriteToy() { + return favoriteToy; + } + + public int getAge() { + return age; + } + + public String makeNoise() { + return "Woof"; + } +} diff --git a/src/main/java/com/serenitydojo/Hampster.java b/src/main/java/com/serenitydojo/Hampster.java new file mode 100644 index 0000000..445d15a --- /dev/null +++ b/src/main/java/com/serenitydojo/Hampster.java @@ -0,0 +1,30 @@ +package com.serenitydojo; + +public class Hampster extends Pet { + private String favoriteGame; + private int age; + + public Hampster(String name, String favoriteGame, int age) { + super(name); + this.favoriteGame = favoriteGame; + this.age = age; + } + + public String getFavoriteGame() { + return favoriteGame; + } + + public int getAge() { + return age; + } + + @Override + public String play() { + return "runs in wheel"; + } + + @Override + public String makeNoise() { + return "Squeak"; + } +} diff --git a/src/main/java/com/serenitydojo/Pet.java b/src/main/java/com/serenitydojo/Pet.java new file mode 100644 index 0000000..eb6c450 --- /dev/null +++ b/src/main/java/com/serenitydojo/Pet.java @@ -0,0 +1,18 @@ +package com.serenitydojo; + +public abstract class Pet { + private String name; + private int age; + + + public Pet(String name) { + this.name = name; + } + public String getName() { + return name; + } + + public String goForWalks() { return "walk walk walk"; } + public abstract String makeNoise(); + public abstract String play(); +} diff --git a/src/main/java/com/serenitydojo/calculator/Calculator.java b/src/main/java/com/serenitydojo/calculator/Calculator.java new file mode 100644 index 0000000..ba543fc --- /dev/null +++ b/src/main/java/com/serenitydojo/calculator/Calculator.java @@ -0,0 +1,39 @@ +package com.serenitydojo.calculator; + +import java.util.ArrayList; +import java.util.List; + +public class Calculator { + public int evaluate(String expression) + { + if(!expression.isEmpty()) { + String[] inputString = expression.split(" "); + int i = 1; + int total = Integer.parseInt(inputString[0]); + while (i < inputString.length) { + switch (inputString[i]) { + case "+": + total = total + Integer.parseInt(inputString[i + 1]); + i = i + 2; + break; + case "-": + total = total - Integer.parseInt(inputString[i + 1]); + i = i + 2; + break; + case "*": + total = total * Integer.parseInt(inputString[i + 1]); + i = i + 2; + break; + default: + throw new IllegalMathsOperatorException("Operator Not Found "+inputString[i]); + } + } + return total; + } + else + { + return 0; + } + + } +} diff --git a/src/main/java/com/serenitydojo/calculator/IllegalMathsOperatorException.java b/src/main/java/com/serenitydojo/calculator/IllegalMathsOperatorException.java new file mode 100644 index 0000000..e6fa13f --- /dev/null +++ b/src/main/java/com/serenitydojo/calculator/IllegalMathsOperatorException.java @@ -0,0 +1,7 @@ +package com.serenitydojo.calculator; + +public class IllegalMathsOperatorException extends RuntimeException { + public IllegalMathsOperatorException(String s) { + super(s); + } +} diff --git a/src/main/java/com/serenitydojo/exceptions/FileLoader.java b/src/main/java/com/serenitydojo/exceptions/FileLoader.java new file mode 100644 index 0000000..86ee236 --- /dev/null +++ b/src/main/java/com/serenitydojo/exceptions/FileLoader.java @@ -0,0 +1,43 @@ +package com.serenitydojo.exceptions; + +import org.apache.commons.io.filefilter.IOFileFilter; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.NoSuchFileException; +import java.nio.file.Paths; + +public class FileLoader { + public String readHelloWorld() throws IOException { + return Files.readString(Paths.get("src/main/resources/hello.txt")); + } + + public Boolean fileContainsText(String filename, String expectedText) { + try + { + String path = "src/main/resources/" + filename; + return Files.readString(Paths.get(path)).contains(expectedText); + } + catch(NoSuchFileException fileDoesNotExist) + { + return false; + } catch (IOException e) { + e.printStackTrace(); + return false; + } + + } + + public Boolean fileHasText(String filename, String expectedText) throws IOException,MissingWelcomeFileException { + try + { + String path = "src/main/resources/" + filename; + return Files.readString(Paths.get(path)).contains(expectedText); + } + catch (NoSuchFileException missingFile) + { + throw new MissingWelcomeFileException("Unable to find the file " + filename,missingFile); + } + + } +} diff --git a/src/main/java/com/serenitydojo/exceptions/MissingWelcomeFileException.java b/src/main/java/com/serenitydojo/exceptions/MissingWelcomeFileException.java new file mode 100644 index 0000000..883700b --- /dev/null +++ b/src/main/java/com/serenitydojo/exceptions/MissingWelcomeFileException.java @@ -0,0 +1,7 @@ +package com.serenitydojo.exceptions; + +public class MissingWelcomeFileException extends RuntimeException { + public MissingWelcomeFileException(String message, Throwable e) { + super(message, e); + } +} diff --git a/src/main/java/com/serenitydojo/exceptions/StringProcessor.java b/src/main/java/com/serenitydojo/exceptions/StringProcessor.java new file mode 100644 index 0000000..13e702a --- /dev/null +++ b/src/main/java/com/serenitydojo/exceptions/StringProcessor.java @@ -0,0 +1,26 @@ +package com.serenitydojo.exceptions; + +import java.io.File; +import java.net.MalformedURLException; +import java.net.URI; +import java.net.URL; +import java.nio.file.Path; +import java.nio.file.Paths; + +public class StringProcessor { + + public String showLengthOf(String input) { + int length = (input == null) ? 0 : input.length(); + return input + " has a length of " + length; + } + + + public int getPortOf(String urlAsAString) { + try { + URL url = new URL(urlAsAString); + return url.getDefaultPort(); + } catch(MalformedURLException badlyWrittenException) { + throw new TestEnvironmentUnavailableException(); + } + } +} diff --git a/src/main/java/com/serenitydojo/exceptions/TestEnvironmentUnavailableException.java b/src/main/java/com/serenitydojo/exceptions/TestEnvironmentUnavailableException.java new file mode 100644 index 0000000..567710c --- /dev/null +++ b/src/main/java/com/serenitydojo/exceptions/TestEnvironmentUnavailableException.java @@ -0,0 +1,5 @@ +package com.serenitydojo.exceptions; + +public class TestEnvironmentUnavailableException extends RuntimeException { + +} diff --git a/src/main/java/com/serenitydojo/fruitmarket/Catalog.java b/src/main/java/com/serenitydojo/fruitmarket/Catalog.java new file mode 100644 index 0000000..ee003ba --- /dev/null +++ b/src/main/java/com/serenitydojo/fruitmarket/Catalog.java @@ -0,0 +1,48 @@ +package com.serenitydojo.fruitmarket; + +import java.util.*; + +public class Catalog { + + private Map pricePerKilo = new HashMap<>(); + + public PriceSetter setPriceOf(Fruit fruit) { + return new PriceSetter(this, fruit); + } + + public Double getPriceOf(Fruit fruit) throws FruitUnavailableException { + try + { + return pricePerKilo.get(fruit); + } + catch (NullPointerException fruitNotFound) + { + throw new FruitUnavailableException("Unable to find the fruit ",fruitNotFound); + } + } + + public static class PriceSetter { + private final Catalog catalog; + private final Fruit fruit; + + public PriceSetter(Catalog catalog, Fruit fruit) { + this.catalog = catalog; + this.fruit = fruit; + } + + public Catalog to(Double price) { + catalog.pricePerKilo.put(fruit, price); + return catalog; + } + } + public List returnCurrentlyAvailableFruit() + { + List availableFruits = new ArrayList<>(); + for (Map.Entry entry:pricePerKilo.entrySet()) + { + availableFruits.add(entry.getKey().toString()); + } + Collections.sort(availableFruits); + return availableFruits; + } +} diff --git a/src/main/java/com/serenitydojo/fruitmarket/Fruit.java b/src/main/java/com/serenitydojo/fruitmarket/Fruit.java new file mode 100644 index 0000000..25ab5a2 --- /dev/null +++ b/src/main/java/com/serenitydojo/fruitmarket/Fruit.java @@ -0,0 +1,5 @@ +package com.serenitydojo.fruitmarket; + +public enum Fruit { + Apple, Orange, Banana, Pear, Peach, Strawberries, Mulberries +} diff --git a/src/main/java/com/serenitydojo/fruitmarket/FruitUnavailableException.java b/src/main/java/com/serenitydojo/fruitmarket/FruitUnavailableException.java new file mode 100644 index 0000000..2fa9f45 --- /dev/null +++ b/src/main/java/com/serenitydojo/fruitmarket/FruitUnavailableException.java @@ -0,0 +1,7 @@ +package com.serenitydojo.fruitmarket; + +public class FruitUnavailableException extends RuntimeException { + public FruitUnavailableException(String message, Throwable e) { + super(message, e); + } +} diff --git a/src/main/java/com/serenitydojo/fruitmarket/ShoppingCart.java b/src/main/java/com/serenitydojo/fruitmarket/ShoppingCart.java new file mode 100644 index 0000000..06435db --- /dev/null +++ b/src/main/java/com/serenitydojo/fruitmarket/ShoppingCart.java @@ -0,0 +1,35 @@ +package com.serenitydojo.fruitmarket; + +import java.util.ArrayList; +import java.util.List; + +public class ShoppingCart { + private final Catalog catalog; + private final List items; + + public ShoppingCart(Catalog catalog) { + this.catalog = catalog; + this.items = new ArrayList<>(); + } + + public void setItems(ShoppingCartItem item) + { + this.items.add(item); + } + + public List getItems() + { + return this.items; + } + + + public double calculateTotalCost() + { + double totalCost=0.0; + for (ShoppingCartItem item : this.items) { + totalCost = totalCost + item.getTotalCost(); + } + + return totalCost; + } +} diff --git a/src/main/java/com/serenitydojo/fruitmarket/ShoppingCartItem.java b/src/main/java/com/serenitydojo/fruitmarket/ShoppingCartItem.java new file mode 100644 index 0000000..37b7cd4 --- /dev/null +++ b/src/main/java/com/serenitydojo/fruitmarket/ShoppingCartItem.java @@ -0,0 +1,31 @@ +package com.serenitydojo.fruitmarket; + +public class ShoppingCartItem { + private Fruit fruit; + private Double quantity; + private Double totalCost; + + public ShoppingCartItem(Fruit fruit, Double quantity, Double totalCost) { + this.fruit = fruit; + this.quantity = quantity; + this.totalCost = totalCost; + } + + + public Fruit getFruit() { + return fruit; + } + + public Double getQuantity() { + return quantity; + } + + public Double getTotalCost() + { + if(this.getQuantity() > 5.00 || this.getQuantity() == 5) + { + totalCost=this.totalCost - (this.totalCost*0.1); + } + return totalCost; + } +} diff --git a/src/main/java/com/serenitydojo/model/AnimalType.java b/src/main/java/com/serenitydojo/model/AnimalType.java new file mode 100644 index 0000000..792bfc3 --- /dev/null +++ b/src/main/java/com/serenitydojo/model/AnimalType.java @@ -0,0 +1,5 @@ +package com.serenitydojo.model; + +public enum AnimalType { + CAT, DOG, HAMSTER, FISH, LLAMA +} diff --git a/src/main/java/com/serenitydojo/model/Feeder.java b/src/main/java/com/serenitydojo/model/Feeder.java new file mode 100644 index 0000000..d037ff4 --- /dev/null +++ b/src/main/java/com/serenitydojo/model/Feeder.java @@ -0,0 +1,17 @@ +package com.serenitydojo.model; + +public class Feeder { + public FoodType feeds(AnimalType animal, boolean isPremium) { + + switch (animal) { + case CAT: + return (isPremium) ? FoodType.SALMON : FoodType.TUNA; + case DOG: + return (isPremium) ? FoodType.DELUXE_DOG_FOOD : FoodType.DOG_FOOD; + case HAMSTER: + return (isPremium) ? FoodType.LETTUCE : FoodType.CABBAGE; + default: + return FoodType.UNKNOWN; + } + } +} diff --git a/src/main/java/com/serenitydojo/model/FoodType.java b/src/main/java/com/serenitydojo/model/FoodType.java new file mode 100644 index 0000000..c1e4501 --- /dev/null +++ b/src/main/java/com/serenitydojo/model/FoodType.java @@ -0,0 +1,5 @@ +package com.serenitydojo.model; + +public enum FoodType { + TUNA, CABBAGE, LETTUCE, SALMON, DOG_FOOD, DELUXE_DOG_FOOD, UNKNOWN +} diff --git a/src/main/java/com/serenitydojo/readme.md b/src/main/java/com/serenitydojo/readme.md deleted file mode 100644 index 6caadce..0000000 --- a/src/main/java/com/serenitydojo/readme.md +++ /dev/null @@ -1 +0,0 @@ -Application classes go here \ No newline at end of file diff --git a/src/main/resources/hello.txt b/src/main/resources/hello.txt new file mode 100644 index 0000000..5e1c309 --- /dev/null +++ b/src/main/resources/hello.txt @@ -0,0 +1 @@ +Hello World \ No newline at end of file diff --git a/src/test/java/com/serenitydojo/assertions/WhenWritingReadableAssertions.java b/src/test/java/com/serenitydojo/assertions/WhenWritingReadableAssertions.java new file mode 100644 index 0000000..b81d41f --- /dev/null +++ b/src/test/java/com/serenitydojo/assertions/WhenWritingReadableAssertions.java @@ -0,0 +1,123 @@ +package com.serenitydojo.assertions; + +import org.assertj.core.data.Percentage; +import org.junit.Test; + +import java.util.Arrays; +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; + +public class WhenWritingReadableAssertions { + + @Test + public void whenTwoNumbersAreEqual() { + int a = 5; + int b = 10; + int c = 20; + int sum = a + b + c; + + // Check that the sum is 35 + } + + @Test + public void whenANumberIsGreaterThanAnother() { + int a = 5; + int b = 10; + int c = 20; + int sum = a + b + c; + + // Check that the sum is greater than 30 + } + + @Test + public void whenANumberIsInACertainInterval() { + int a = 5; + int b = 10; + int sum = a + b; + + // Check that the sum is between 10 and 20 + } + + @Test + public void whenANumberIsCloseToAnotherValue() { + double roughlyOneHundred = 99; + + // Check that the sum is within 10% of 100 + } + + @Test + public void whenAStringIsEqualToAnother() { + String color = "red"; + + // Check that the string has a value of 'red' + } + + @Test + public void whenAStringIsEqualIgnoringCase() { + String color = "RED"; + + // Check that the string has a value of 'red' (ignoring case) + } + + @Test + public void whenAStringContainsOnlyDigits() { + String licenseNumber = "12345"; + + // Check that the value contains only digits + } + + @Test + public void whenAStringStartsWithAValue() { + String colors = "red,green,blue"; + + // Check that the value starts with 'red' + } + + @Test + public void whenAStringEndsWithAValue() { + String colors = "red,green,blue"; + + // Check that the value ends with 'blue' + } + + + @Test + public void whenAListContainsAValue() { + List colors = Arrays.asList("red","green","blue"); + + // Check that the list contains "red" + } + + @Test + public void whenAListContainsASetOfValues() { + List colors = Arrays.asList("red","green","blue"); + + // Check that the list contains "red" and "blue + } + + @Test + public void whenAListHasASpecificSize() { + List colors = Arrays.asList("red","green","blue"); + + // Check that the list contains 3 elements + } + + @Test + public void whenAListContainsExactlyASetOfValues() { + List colors = Arrays.asList("red","green","blue"); + + // Check that the list contains "red","green" and "blue" in any order + } + + @Test + public void whenAListContainsExactlyASetOfValuesInAnyOrder() { + List colors = Arrays.asList("red","green","blue"); + + // Check that the list contains "red","blue" and "green" in any order + } + + + + +} diff --git a/src/test/java/com/serenitydojo/calculator/WhenDoingMaths.java b/src/test/java/com/serenitydojo/calculator/WhenDoingMaths.java new file mode 100644 index 0000000..c8897fe --- /dev/null +++ b/src/test/java/com/serenitydojo/calculator/WhenDoingMaths.java @@ -0,0 +1,50 @@ +package com.serenitydojo.calculator; + +import org.apache.commons.lang3.StringUtils; +import org.junit.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +public class WhenDoingMaths { + Calculator calculator = new Calculator(); + + @Test + public void shouldReturnZeroForAnEmptyString() { + assertThat(calculator.evaluate("")).isEqualTo(0); + } + + @Test(expected = IllegalMathsOperatorException.class) + public void shouldReportNonSupportedOperations() { + calculator.evaluate("1 ^ 2"); + } + + @Test + public void shouldReturnTheValueOfASingleNumber() { + assertThat(calculator.evaluate("1")).isEqualTo(1); + } + + @Test + public void shouldAddTwoNumbers() { + assertThat(calculator.evaluate("1 + 1")).isEqualTo(2); + } + + @Test + public void shouldAddThreeNumbers() { + assertThat(calculator.evaluate("1 + 2 + 3")).isEqualTo(6); + } + + @Test + public void shouldAlsoSubtract() { + assertThat(calculator.evaluate("10 - 6")).isEqualTo(4); + } + + @Test + public void shouldAddAndSubtract() { + assertThat(calculator.evaluate("10 + 5 - 6")).isEqualTo(9); + } + + @Test + public void shouldMultiplyNumbers() { + assertThat(calculator.evaluate("10 * 5")).isEqualTo(50); + } +} diff --git a/src/test/java/com/serenitydojo/exceptions/ExceptionHandlingExercises.java b/src/test/java/com/serenitydojo/exceptions/ExceptionHandlingExercises.java new file mode 100644 index 0000000..d9f7c2f --- /dev/null +++ b/src/test/java/com/serenitydojo/exceptions/ExceptionHandlingExercises.java @@ -0,0 +1,55 @@ +package com.serenitydojo.exceptions; + +import org.junit.Test; + +import java.io.IOException; + +import static org.assertj.core.api.Assertions.assertThat; + +public class ExceptionHandlingExercises { + + // - Handle a declared exception + // - Catch a declared exception and return a value + // - Catch a declared exception and throw a custom exception + // - Custom logic that throws a custom exception when no result is found + // - Using the Finally block to clean up + + /** + * Exercise 1 - Handling exceptions + * Uncomment the code in this test and make it work. + * You will need to modify the FileLoader class so that it correctly handles an IOException + */ + @Test + public void workingWithDeclaredExceptions() throws IOException { + FileLoader fileLoader = new FileLoader(); + assertThat(fileLoader.readHelloWorld()).isEqualTo("Hello World"); + } + + /** + * Exercise 2 - Catching exceptions + * Update the fileContainsText() method in the FileLoader class so that it returns false if the file + * does not contain the excepted text, or if the file does not exist. + */ + @Test + public void catchingExceptions() { + FileLoader fileLoader = new FileLoader(); + assertThat(fileLoader.fileContainsText("hello.txt","Hello World")).isTrue(); + } + + @Test + public void catchingExceptionsWhenTheFileDoesNotExist() { + FileLoader fileLoader = new FileLoader(); + assertThat(fileLoader.fileContainsText("does-not-exist.txt","Hello World")).isFalse(); + } + + /** + * Exercise 3 - Throwing custom exceptions + * Create a custom runtime exception called MissingWelcomeFileException, + * and update the fileHasText() method to throw this exception if no matching file is found. + */ + @Test(expected = MissingWelcomeFileException.class) + public void catchingCustomExceptionsWhenTheFileDoesNotExist() { + FileLoader fileLoader = new FileLoader(); + //assertThat(fileLoader.fileHasText("does-not-exist.txt","Hello World")).isFalse(); + } +} diff --git a/src/test/java/com/serenitydojo/exceptions/WhenWorkingWithExceptions.java b/src/test/java/com/serenitydojo/exceptions/WhenWorkingWithExceptions.java new file mode 100644 index 0000000..4395705 --- /dev/null +++ b/src/test/java/com/serenitydojo/exceptions/WhenWorkingWithExceptions.java @@ -0,0 +1,34 @@ +package com.serenitydojo.exceptions; + +import org.junit.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +public class WhenWorkingWithExceptions { + + @Test + public void shouldShowTheLengthOfAString() { + StringProcessor stringProcessor = new StringProcessor(); + + String result = stringProcessor.showLengthOf("some string"); + + assertThat(result).isEqualTo("some string has a length of 11"); + } + + @Test + public void shouldShowZeroForNullStrings() { + + StringProcessor stringProcessor = new StringProcessor(); + + String result = stringProcessor.showLengthOf(null); + + assertThat(result).isEqualTo("null has a length of 0"); + } + + @Test(expected = TestEnvironmentUnavailableException.class) + public void shouldFindThePort() { + StringProcessor stringProcessor = new StringProcessor(); + + stringProcessor.getPortOf("A:https://www.google.com"); + } +} diff --git a/src/test/java/com/serenitydojo/fruitmarket/TheCatalog.java b/src/test/java/com/serenitydojo/fruitmarket/TheCatalog.java new file mode 100644 index 0000000..f2be814 --- /dev/null +++ b/src/test/java/com/serenitydojo/fruitmarket/TheCatalog.java @@ -0,0 +1,107 @@ +package com.serenitydojo.fruitmarket; + +import org.junit.Before; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.List; + +import static com.serenitydojo.fruitmarket.Fruit.*; +import static org.assertj.core.api.Assertions.assertThat; + +public class TheCatalog { + + Catalog catalog; + + @Before + public void createANewCatalog() { + catalog = new Catalog(); + catalog.setPriceOf(Apple).to(4.00) + .setPriceOf(Orange).to(5.50) + .setPriceOf(Banana).to(4.50) + .setPriceOf(Pear).to(4.50); + } + + @Test + public void shouldBeAbleToUpdateTheCurrentPriceOfAFruit() { + catalog.setPriceOf(Apple).to(5.00); + assertThat(catalog.getPriceOf(Apple)).isEqualTo(5.00); + } + + @Test + public void shouldListTheAvailableFruitInAlphabeticalOrder() { + assertThat(catalog.returnCurrentlyAvailableFruit()).containsExactly("Apple", "Banana", "Orange", "Pear"); + } + + @Test + public void shouldReturnTheCorrectPricesOfEachFruitInSeason() { + assertThat(catalog.getPriceOf(Apple)).isEqualTo(4.00); + assertThat(catalog.getPriceOf(Orange)).isEqualTo(5.50); + } + + @Test + public void shouldReportAnExceptionIfAFruitIsNotAvailable() throws FruitUnavailableException { + catalog.getPriceOf(Strawberries); + } + + @Test + public void shouldBeAbleToAddItemsToCart() + { + ShoppingCart cart=new ShoppingCart(catalog); + cart.setItems(new ShoppingCartItem(Apple,2.00,catalog.getPriceOf(Apple)*2)); + cart.setItems(new ShoppingCartItem(Banana,4.00,catalog.getPriceOf(Banana)*4)); + for(int i=0;i< cart.getItems().size();i++) + { + switch (cart.getItems().get(i).getFruit()) + { + case Apple: + assertThat(cart.getItems().get(i).getQuantity()).isEqualTo(2.00); + assertThat(cart.getItems().get(i).getTotalCost()).isEqualTo(8.00); + break; + case Banana: + assertThat(cart.getItems().get(i).getQuantity()).isEqualTo(4.00); + assertThat(cart.getItems().get(i).getTotalCost()).isEqualTo(18.00); + break; + default: + System.out.println("Unable to find the items in the cart"); + } + } + } + + @Test + public void shouldBeAbleToGetTotalCostOfTheItemsOnTheCart() + { + ShoppingCart cart=new ShoppingCart(catalog); + cart.setItems(new ShoppingCartItem(Apple,2.00,catalog.getPriceOf(Apple)*2)); + cart.setItems(new ShoppingCartItem(Banana,4.00,catalog.getPriceOf(Banana)*4)); + assertThat(cart.calculateTotalCost()).isEqualTo(26.00); + } + + //When you buy 5 kilos or more of any fruit, you get a 10% discount + @Test + public void shouldBeAbleToGetDiscountedPriceWhenQuantityIsEqualToFive() + { + ShoppingCart cart=new ShoppingCart(catalog); + cart.setItems(new ShoppingCartItem(Apple,5.00,catalog.getPriceOf(Apple)*5)); + assertThat(cart.calculateTotalCost()).isEqualTo(18.00); + } + + @Test + public void shouldBeAbleToGetDiscountedPriceWhenQuantityIsGreaterThanFive() + { + ShoppingCart cart=new ShoppingCart(catalog); + cart.setItems(new ShoppingCartItem(Banana,5.50,catalog.getPriceOf(Banana)* 5.50)); + assertThat(cart.calculateTotalCost()).isEqualTo(22.275); + } + + @Test + public void shouldBeAbleToGetDiscountedPriceWhenDifferentTypesOfFruitsExistAndOnlyTwoOfThemEligibleForDiscount() + { + ShoppingCart cart=new ShoppingCart(catalog); + cart.setItems(new ShoppingCartItem(Banana,5.50,catalog.getPriceOf(Banana)* 5.50)); + cart.setItems(new ShoppingCartItem(Pear,6.00,catalog.getPriceOf(Pear)* 6)); + cart.setItems(new ShoppingCartItem(Orange,3.00,catalog.getPriceOf(Orange)* 3)); + assertThat(cart.calculateTotalCost()).isEqualTo(63.075); + } + +} diff --git a/src/test/java/com/serenitydojo/readme.md b/src/test/java/com/serenitydojo/readme.md deleted file mode 100644 index 44f08e7..0000000 --- a/src/test/java/com/serenitydojo/readme.md +++ /dev/null @@ -1 +0,0 @@ -Unit tests go here \ No newline at end of file