diff --git a/pom.xml b/pom.xml index 8171c1a..2ed543a 100644 --- a/pom.xml +++ b/pom.xml @@ -16,7 +16,6 @@ 1.8 1.8 - junit @@ -24,8 +23,65 @@ 4.13 test + + org.assertj + assertj-core + 3.15.0 + + + org.assertj + assertj-core + 3.19.0 + + + com.serenitydojo + java-for-testers + 1.0.0-SNAPSHOT + test + + + orgit g.assertj + assertj-core + 3.15.0 + + + org.assertj + assertj-core + 3.19.0 + + + com.serenitydojo + java-for-testers + 1.0.0-SNAPSHOT + test + + + junit + junit + 4.13 + compile + + + junit + junit + 4.13 + compile + + + org.junit.jupiter + junit-jupiter + RELEASE + compile + + + org.junit.jupiter + junit-jupiter + RELEASE + compile + + @@ -70,5 +126,23 @@ + + + org.apache.maven.plugins + maven-compiler-plugin + + 9 + 9 + + + + org.apache.maven.plugins + maven-compiler-plugin + + 11 + 11 + + + 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/exceptions/FileHasNoWordException.java b/src/main/java/com/serenitydojo/exceptions/FileHasNoWordException.java new file mode 100644 index 0000000..321bc23 --- /dev/null +++ b/src/main/java/com/serenitydojo/exceptions/FileHasNoWordException.java @@ -0,0 +1,12 @@ +package com.serenitydojo.exceptions; + +public class FileHasNoWordException extends RuntimeException{ + public FileHasNoWordException(String message){ + super(message); + } + public FileHasNoWordException(String message, Throwable cause){ + super(message,cause); + } + + +} diff --git a/src/main/java/com/serenitydojo/exceptions/WhenWorkingWithExceptions.java b/src/main/java/com/serenitydojo/exceptions/WhenWorkingWithExceptions.java new file mode 100644 index 0000000..7221a46 --- /dev/null +++ b/src/main/java/com/serenitydojo/exceptions/WhenWorkingWithExceptions.java @@ -0,0 +1,39 @@ +package com.serenitydojo.exceptions; +import org.assertj.core.api.Assertions; +import org.junit.Assert; +import org.junit.Test; + +import java.io.IOException; +import java.nio.file.NoSuchFileException; + +public class WhenWorkingWithExceptions { + WordCounter wordCounter = new WordCounter(); + @Test + public void shouldCountWordsInAString(){ + int numberOfWords = wordCounter.numberOfWordsIn("some string"); + Assertions.assertThat(numberOfWords).isEqualTo(2); + + + } + @Test + public void shouldReturnZeroForANullString(){ + Assertions.assertThat(wordCounter.numberOfWordsIn(null)).isEqualTo(0); + + } + @Test + public void shouldCountWordsInAFile() throws Exception { + int numberOfWords = wordCounter.numberOfWordsInAfile("src/main/resources/hello.txt"); + } + @Test(expected = FileHasNoWordException.class) + public void shoulReportAnErrowIfThatFileDoesNotExist()throws Exception{ + int numberOfWords = wordCounter.numberOfWordsInAfile("file-that-does-not-exist.txt"); + } + @Test(expected = FileHasNoWordException.class) + public void shouldThrowMeaningfullExceptionIfThereAreNoWordsInAFile()throws Exception{ + int numberOfWords = wordCounter.numberOfWordsInAfile("src/main/resources/no_words.txt"); + Assertions.assertThat(numberOfWords).isEqualTo(0); + + + } + +} diff --git a/src/main/java/com/serenitydojo/exceptions/WordCounter.java b/src/main/java/com/serenitydojo/exceptions/WordCounter.java new file mode 100644 index 0000000..1569055 --- /dev/null +++ b/src/main/java/com/serenitydojo/exceptions/WordCounter.java @@ -0,0 +1,33 @@ +package com.serenitydojo.exceptions; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.NoSuchFileException; +import java.nio.file.Paths; + +public class WordCounter { + public int numberOfWordsIn(String value){ + if(value==null){ + return 0; + } + return value.split("\\W").length; + + + } + + public int numberOfWordsInAfile(String fileName) throws IOException { + try { + String fileContents = Files.readString(Paths.get(fileName)); + int wordCount = numberOfWordsIn(fileContents); + if(wordCount==0){ + throw new FileHasNoWordException("no words found in a file " + fileName); + } + return wordCount; + } + catch(NoSuchFileException noSuchFile){ + throw new FileHasNoWordException("no words found in a non existing file " + fileName); + + } + + } +} 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..3648413 --- /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, Hamster, Dog, Cat, 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..c79d6a7 --- /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, Tuna, Cabbage, Dogs_Food, Salmon, Deluxe_Dog_Food, Lettuce, UNKNOWN +} diff --git a/src/main/resources/hello.txt b/src/main/resources/hello.txt new file mode 100644 index 0000000..95d09f2 --- /dev/null +++ b/src/main/resources/hello.txt @@ -0,0 +1 @@ +hello world \ No newline at end of file diff --git a/src/main/resources/no_words.txt b/src/main/resources/no_words.txt new file mode 100644 index 0000000..e69de29 diff --git a/src/test/java/com/serenitydojo/WhenCreatingObjects.java b/src/test/java/com/serenitydojo/WhenCreatingObjects.java new file mode 100644 index 0000000..e3c2076 --- /dev/null +++ b/src/test/java/com/serenitydojo/WhenCreatingObjects.java @@ -0,0 +1,79 @@ +package com.serenitydojo; + +import org.junit.Assert; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public class WhenCreatingObjects { + + @Test + public void creating_a_cat() { + + Cat felix = new Cat("Felix","Tuna", 4); + + assertEquals(felix.getName(), "Felix"); + assertEquals(felix.getFavoriteFood(), "Tuna"); + assertEquals(felix.getAge(), 4); + } + + @Test + public void creating_a_dog() { + + Dog fido = new Dog("Fido","Bone", 5); + assertEquals(fido.getName(), "Fido"); + assertEquals(fido.getFavoriteToy(), "Bone"); + assertEquals(fido.getAge(), 5); + + } + + @Test + public void creating_a_hampster() { + + Hampster rusty = new Hampster("Rusty","Wheel",1); + + assertEquals(rusty.getName(),"Rusty"); + assertEquals(rusty.getFavoriteGame(),"Wheel"); + assertEquals(rusty.getAge(),1); + } + + + @Test + public void cat_makes_noise() { + Cat felix = new Cat("Felix", 4); + + System.out.println("Felix goes " + felix.makeNoise()); + } + + @Test + public void dog_makes_noise() { + Dog fido = new Dog("Fido","bone", 5); + + System.out.println("Fido goes " + fido.makeNoise()); + } + + @Test + public void pets_make_noise() { + Pet felix = new Cat("Felix",4); + Pet fido = new Dog("Fido", "bone", 5); + Pet rusty = new Hampster("Rusty", "wheels", 1); + + System.out.println("Felix goes " + felix.makeNoise()); + System.out.println("Fido goes " + fido.makeNoise()); + System.out.println("Rusty goes " + rusty.makeNoise()); + } + + @Test + public void pets_can_play() { + + Pet felix = new Cat("Felix",4); + Pet fido = new Dog("Fido", "bone", 5); + Pet rusty = new Hampster("Rusty", "wheels", 1); + + assertEquals(felix.play(), "plays with string"); + assertEquals(fido.play(), "plays with bone"); + assertEquals(rusty.play(), "runs in wheel"); + + } + +} diff --git a/src/test/java/com/serenitydojo/WhenFeedingTheAnimals.java b/src/test/java/com/serenitydojo/WhenFeedingTheAnimals.java new file mode 100644 index 0000000..d5f437a --- /dev/null +++ b/src/test/java/com/serenitydojo/WhenFeedingTheAnimals.java @@ -0,0 +1,54 @@ +package com.serenitydojo; +import com.serenitydojo.model.AnimalType; +import com.serenitydojo.model.Feeder; +import com.serenitydojo.model.FoodType; +import org.junit.Assert; +import org.junit.Test; +import static com.serenitydojo.model.AnimalType.*; +import static com.serenitydojo.model.FoodType.*; + +public class WhenFeedingTheAnimals { + + @Test + public void shouldFeedCatsTuna(){ + Feeder feeder = new Feeder(); + FoodType food = feeder.feeds(Cat,false); + Assert.assertEquals(Tuna, food); + + } + @Test + public void shouldFeedHamsterCabbage(){ + Feeder feeder = new Feeder(); + FoodType food = feeder.feeds(Hamster,false); + Assert.assertEquals(Cabbage, food); + + } + + @Test + public void shouldFeedDogsDogFood(){ + Feeder feeder = new Feeder(); + FoodType food = feeder.feeds(Dog, false); + Assert.assertEquals(Dogs_Food, food); + + } + @Test + public void shouldFeedPremiumCatsPremiumFood(){ + Feeder feeder = new Feeder(); + FoodType food = feeder.feeds(Cat,true); + Assert.assertEquals(Salmon, food); + + } + @Test + public void shouldFeedPremiumDogsPremiumFood() { + Feeder feeder = new Feeder(); + FoodType food = feeder.feeds(Dog, true); + Assert.assertEquals(Deluxe_Dog_Food, food); + } + @Test + public void shouldFeedPremiumHamsterPremiumFood() { + Feeder feeder = new Feeder(); + FoodType food = feeder.feeds(Hamster, true); + Assert.assertEquals(Lettuce, food); + } +} + diff --git a/src/test/java/com/serenitydojo/WhenWOrkingWithMaps.java b/src/test/java/com/serenitydojo/WhenWOrkingWithMaps.java new file mode 100644 index 0000000..3df5e37 --- /dev/null +++ b/src/test/java/com/serenitydojo/WhenWOrkingWithMaps.java @@ -0,0 +1,56 @@ +package com.serenitydojo; +import org.junit.Test; +import java.util.HashMap; +import java.util.Map; + +public class WhenWOrkingWithMaps { + @Test + public void workingwithMaps(){ + Map numberOfBallsWithColors = new HashMap<>(); + numberOfBallsWithColors.put("red",3); + numberOfBallsWithColors.put("green",6); + numberOfBallsWithColors.put("blue",10); + + Integer numberOfRedBalls = numberOfBallsWithColors.get("red"); + System.out.println("number of red balls is " + numberOfRedBalls); + } + @Test + public void creatingAMapConcisely(){ + Map numberOfBallsWithColors = Map.of("red",3,"green",6,"blue",5); + + Map moreColors = new HashMap<>(); + moreColors.put("yellow",10); + moreColors.putAll(numberOfBallsWithColors); + + moreColors.put("yellow",20); + moreColors.replace("pink",15); + System.out.println("number of pink balls is " + moreColors.getOrDefault("pink",0)); + + //System.out.println("purple colors are presents :" + moreColors.containsKey("purple")); + + + } + @Test + public void iteratingOverMapKeys(){ + Map numberOfBallsByColors = Map.of("red",3,"green",6,"blue",5); + //System.out.println(numberOfBallsByColors.keySet()); + + for(String Key : numberOfBallsByColors.keySet()){ + Integer numberOfTennisBalls = numberOfBallsByColors.get(Key); + System.out.println(numberOfTennisBalls); + } + for(Map.Entry entry : numberOfBallsByColors.entrySet()){ + System.out.println(entry); + } + Map moreBalls = new HashMap<>(); + moreBalls.putAll(numberOfBallsByColors); + moreBalls.remove("red"); + System.out.println(moreBalls); + + } + + + + + +} diff --git a/src/test/java/com/serenitydojo/WhenWorkingWithJavaLists.java b/src/test/java/com/serenitydojo/WhenWorkingWithJavaLists.java new file mode 100644 index 0000000..acfff05 --- /dev/null +++ b/src/test/java/com/serenitydojo/WhenWorkingWithJavaLists.java @@ -0,0 +1,112 @@ +package com.serenitydojo; +import org.assertj.core.api.Assertions; +import org.junit.Assert; +import org.junit.Test; +import java.util.*; +import static org.assertj.core.api.Assertions.assertThat; + + +public class WhenWorkingWithJavaLists { + @Test + public void creatingASimpleList(){ + List simpleList = new ArrayList(); + simpleList.add("this is a simple list"); + simpleList.add(123); + assertThat(simpleList).contains("this is a simple list",123); + + } + @Test + public void creatATypedList(){ + List names = Arrays.asList("joe","sally","pete"); + List ages = Arrays.asList(10,20,20); + assertThat(names).contains("joe","sally","pete"); + + List favoriteNumbers = Arrays.asList(10,20,30,10000000l,4.4); + assertThat(favoriteNumbers).contains(10,20,30,10000000l,4.4); + } + @Test + public void removingStuff(){ + List names = new ArrayList<>(); + names.add("joe"); + names.add("mike"); + names.add("tim"); + + names.remove("joe"); + assertThat(names).contains("mike","tim"); + names.clear(); + assertThat(names).isEmpty(); + } + @Test + public void combiningLists(){ + List names = new ArrayList<>(); + names.add("joe"); + names.add("sally"); + names.add("pete"); + + ListmoreNames = new ArrayList<>(); + names.add("paul"); + names.add("petra"); + + names.addAll(moreNames); + assertThat(names).contains("joe","sally","pete","paul","petra"); + + names.removeAll(moreNames); + + + + + names.remove("joe"); + assertThat(names).contains("mike","tim"); + names.clear(); + assertThat(names).isEmpty(); + } + @Test + public void immutableList(){ + List names = Arrays.asList("joe","mike","tim");// these are fixed lists, can not add or remove + names.remove("joe"); + names.add("paul"); + + } + @Test + public void findElementInAList(){ + List names = Arrays.asList("joe","Sally","Pete","Sally","Paul"); + int indexOfSally = names.indexOf("Sally"); + int lastIndexOfSally = names.lastIndexOf("Sally"); + + assertThat(indexOfSally).isEqualTo(1); + assertThat(lastIndexOfSally).isEqualTo(3); + } + @Test + public void findingASubList(){ + List names = Arrays.asList("joe","sally","paul"); + ListmiddleNames = names.subList(1,2); + assertThat(names).contains("joe","sally","paul"); + } + @Test + public void findingTheSize(){ + List names = Arrays.asList("joe","sally","paul"); + assertThat(names.size()).isEqualTo(3); + } + @Test + public void convertingAListToAset(){ + Listnames = Arrays.asList("joe","sally","pete","sally","paul"); + Set uniqueNames = new HashSet<>(names); + assertThat(uniqueNames).containsExactlyInAnyOrder("joe,sally","pete","paul"); + } + @Test + public void sortingAList(){ + Listnames = Arrays.asList("joe","sally","pete","sally","paul"); + Collections.sort(names); + assertThat(names).containsExactly("joe","paul","pete","sally","sally"); + + } + @Test + public void findingMaxAndMin(){ + List ages = Arrays.asList(15,10,50,30,20); + assertThat(Collections.max(ages)).isEqualTo(50); + assertThat(Collections.min(ages)).isEqualTo(10); + + } + + +} diff --git a/src/test/java/com/serenitydojo/assertiondemo/WhenAddingNumbers.java b/src/test/java/com/serenitydojo/assertiondemo/WhenAddingNumbers.java new file mode 100644 index 0000000..cff1af1 --- /dev/null +++ b/src/test/java/com/serenitydojo/assertiondemo/WhenAddingNumbers.java @@ -0,0 +1,34 @@ +package com.serenitydojo.assertiondemo; + +import org.junit.Test; + +import java.util.Arrays; +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; + +public class WhenAddingNumbers { + @Test + public void shouldAddTwoIntegersCorrectly(){ +// int a =1; +// int b =2; +// +// int sum = a+b; +// assertThat(sum).isEqualTo(4); + + String color = "red"; + String anotherColor = "Red"; + + assertThat(color).isEqualToIgnoringCase(anotherColor); + + List colors = Arrays.asList("red","green","blue"); + assertThat(colors).hasSize(3); + assertThat(colors).contains("green"); + assertThat(colors).containsExactly("red","green","blue"); + assertThat(colors).containsExactlyInAnyOrder("blue","green","red"); + + + + } + +} 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..0b65ccf --- /dev/null +++ b/src/test/java/com/serenitydojo/assertions/WhenWritingReadableAssertions.java @@ -0,0 +1,111 @@ +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; +import static org.assertj.core.data.Percentage.*; + +public class WhenWritingReadableAssertions { + + @Test + public void whenTwoNumbersAreEqual() { + int a = 5; + int b = 10; + int c = 20; + + int sum = a + b + c; + assertThat(sum).isEqualTo(35); + } + + @Test + public void whenANumberIsGreaterThanAnother() { + int a = 5; + int b = 10; + int c = 20; + int sum = a + b + c; + assertThat(sum).isGreaterThan(30); + } + + @Test + public void whenANumberIsInACertainInterval() { + int a = 5; + int b = 10; + int sum = a + b; + assertThat(sum).isBetween(10,20); + } + + @Test + public void whenANumberIsCloseToAnotherValue() { + double roughlyOneHundred = 99; + assertThat(roughlyOneHundred).isCloseTo(100, withPercentage(10)); + } + + @Test + public void whenAStringIsEqualToAnother() { + String color = "red"; + assertThat(color).contains("red"); + } + + @Test + public void whenAStringIsEqualIgnoringCase() { + String color = "RED"; + assertThat(color).containsIgnoringCase("red"); + } + + @Test + public void whenAStringContainsOnlyDigits() { + String licenseNumber = "12345"; + assertThat(licenseNumber).containsOnlyDigits(); + } + + @Test + public void whenAStringStartsWithAValue() { + String colors = "red,green,blue"; + assertThat(colors).startsWith("red"); + } + + @Test + public void whenAStringEndsWithAValue() { + String colors = "red,green,blue"; + assertThat(colors).endsWith("blue"); + } + + + @Test + public void whenAListContainsAValue() { + List colors = Arrays.asList("red","green","blue"); + assertThat(colors).contains("red"); + } + + @Test + public void whenAListContainsASetOfValues() { + List colors = Arrays.asList("red","green","blue"); + assertThat(colors).contains("red","blue"); + } + + @Test + public void whenAListHasASpecificSize() { + List colors = Arrays.asList("red","green","blue"); + assertThat(colors).hasSize(3); + } + + @Test + public void whenAListContainsExactlyASetOfValues() { + List colors = Arrays.asList("red","green","blue"); + assertThat(colors).containsExactlyInAnyOrder("red","green","blue"); + } + + @Test + public void whenAListContainsExactlyASetOfValuesInAnyOrder() { + List colors = Arrays.asList("red","green","blue"); + assertThat(colors).containsExactlyInAnyOrder("red","blue","green"); + } + + + + +} diff --git a/src/test/java/com/serenitydojo/banking/BankAccount.java b/src/test/java/com/serenitydojo/banking/BankAccount.java new file mode 100644 index 0000000..8355800 --- /dev/null +++ b/src/test/java/com/serenitydojo/banking/BankAccount.java @@ -0,0 +1,12 @@ +package com.serenitydojo.banking; + +public class BankAccount { + private double balance; + + public double getBalance(){ + return balance; + } + public void setBalance(double balance){ + this.balance = balance; + } +} diff --git a/src/test/java/com/serenitydojo/banking/CurrentAccount.java b/src/test/java/com/serenitydojo/banking/CurrentAccount.java new file mode 100644 index 0000000..2e2d85e --- /dev/null +++ b/src/test/java/com/serenitydojo/banking/CurrentAccount.java @@ -0,0 +1,12 @@ +package com.serenitydojo.banking; + +public class CurrentAccount { + private double overdraft; + + public double getOverdraft(){ + return overdraft; + } + public void setOverdraft(double overdraft){ + this.overdraft = overdraft; + } +} diff --git a/src/test/java/com/serenitydojo/banking/InterestYieldingBonds.java b/src/test/java/com/serenitydojo/banking/InterestYieldingBonds.java new file mode 100644 index 0000000..88e64c0 --- /dev/null +++ b/src/test/java/com/serenitydojo/banking/InterestYieldingBonds.java @@ -0,0 +1,16 @@ +package com.serenitydojo.banking; + +public class InterestYieldingBonds { + private double value; + private double interestRate; + + public InterestYieldingBonds(double value,double interestRate){ + this.value = value; + this.interestRate = interestRate; + } + + public double calculateMonthlyInterest(){ + return value * interestRate/12; + + } +} diff --git a/src/test/java/com/serenitydojo/banking/SavingsAccount.java b/src/test/java/com/serenitydojo/banking/SavingsAccount.java new file mode 100644 index 0000000..ba5b5f7 --- /dev/null +++ b/src/test/java/com/serenitydojo/banking/SavingsAccount.java @@ -0,0 +1,15 @@ +package com.serenitydojo.banking; + +public class SavingsAccount extends BankAccount { + private double interestRate; + + public double getInterestRate(){ + return interestRate; + } + public void setInterestRate(double interestRate){ + this.interestRate = interestRate; + } + public double calculateMonthlyInterest(){ + return interestRate * getBalance()/12; + } +} diff --git a/src/test/java/com/serenitydojo/banking/WhenCalculatingMonthlyInterest.java b/src/test/java/com/serenitydojo/banking/WhenCalculatingMonthlyInterest.java new file mode 100644 index 0000000..157945f --- /dev/null +++ b/src/test/java/com/serenitydojo/banking/WhenCalculatingMonthlyInterest.java @@ -0,0 +1,37 @@ +package com.serenitydojo.banking; + +import org.assertj.core.api.Assertions; +import org.junit.Assert; +import org.junit.Test; + +public class WhenCalculatingMonthlyInterest { + @Test + public void shouldCalculateInterestForSavingsAccount(){ + //Given + SavingsAccount savingsAccount = new SavingsAccount(); + savingsAccount.setBalance(1200); + savingsAccount.setInterestRate(0.01); + + //When + + double earnedInterest = savingsAccount.calculateMonthlyInterest(); + + //Then + Assertions.assertThat(earnedInterest).isEqualTo(1); + + + } + @Test + public void shouldCalculateInterestForBonds(){ + //Given + InterestYieldingBonds bonds = new InterestYieldingBonds(1200,0.01); + + //When + double earnedInterest = bonds.calculateMonthlyInterest(); + + //Then + Assertions.assertThat(earnedInterest).isEqualTo(1); + + + } +}