Merge branch 'master' of gitlab.stud.idi.ntnu.no:andreksv/idatt-1002-2023-9

src/main/java/no/ntnu/idatt1002/demo/data/recipes/FoodItem.java

+package no.ntnu.idatt1002.demo.data.recipes;
+
+public enum FoodItem {
+
+    ONION("onion"),
+    MINCED_MEAT("minced meat"),
+    POTATO("potatoes"),
+    YELLOW_CHEESE("yellow cheese"),
+    WHEAT_FLOUR("wheat flour"),
+    MILK("milk"),
+    TOMATO("tomato"),
+    ORANGE("orange"),
+    LEMON("lemon"),
+    SALSA_SAUCE("salsa sauce")
+    ;
+
+    public final String label;
+
+    FoodItem(String label) {
+        this.label = label;
+    }
+}

src/main/java/no/ntnu/idatt1002/demo/data/recipes/Ingredient.java

+package no.ntnu.idatt1002.demo.data.recipes;
+
+import java.util.Objects;
+
+/**
+ * The Ingredient class represents an ingredient that can be part of a recipe in real life and/or
+ * be available to the user in real life. When the ingredient is part of a recipe, the subclass called
+ * RecipeIngredient is used. An ingredient belongs to a food type among the values of the FoodItem enum class.
+ * Examples are onion, tomato, spaghetti, chicken etc. The ingredient is provided in a specific amount and unit
+ * of measure.
+ *
+ * @author hannesofie
+ */
+public class Ingredient {
+
+    private FoodItem foodType;
+    private double amount;
+    private MeasuringUnit unit;
+
+    /**
+     * The constructor of a new Ingredient object takes in three mandatory fields; ingredient type as defined in
+     * the enum class FoodItem, an amount and a unit of measure defined in the enum class MeasuringUnit. The amount
+     * must be a positive number.
+     * @param ingredient What type of food the ingredient is.
+     * @param amount The amount of the ingredient.
+     * @param unit The unit of measure of the given amount of the ingredient.
+     */
+    public Ingredient(FoodItem ingredient, double amount, MeasuringUnit unit) {
+        if(ingredient == null | amount <= 0.0f | unit == null) {
+            throw new IllegalArgumentException("The ingredient must have a type, amount and measuring unit.");
+        }
+        this.foodType = ingredient;
+        this.amount = amount;
+        this.unit = unit;
+    }
+
+    /**
+     * The method returns the food type that the ingredient belongs to among the valid types in the FoodItem enum class.
+     * @return What type of food the ingredient is.
+     */
+    public FoodItem getFoodType() {
+        return foodType;
+    }
+
+    public void setFoodType(FoodItem foodType) {
+        if(foodType == null) {
+            throw new IllegalArgumentException("The food type must be set to a valid value of FoodItem.");
+        }
+        this.foodType = foodType;
+    }
+
+    /**
+     * The method returns the amount of an ingredient as the datatype double.
+     * @return The amount of an ingredient as double.
+     */
+    public double getAmount() {
+        return amount;
+    }
+
+    /**
+     * The method takes in a new amount as a double and sets the ingredient's amount field equal to this value.
+     * If the provided value is not a positive double, an IllegalArgumentException is thrown.
+     * @param amount The amount of an ingredient as double.
+     */
+    public void setAmount(double amount) {
+        if(amount <= 0.0f) {
+            throw new IllegalArgumentException("The amount of an ingredient cannot be zero or negative.");
+        }
+        this.amount = amount;
+    }
+
+    /**
+     * The method returns the unit of measure of the ingredient as a value of the MeasuringUnit enum class.
+     * @return The unit of measure of the given amount of the ingredient.
+     */
+    public MeasuringUnit getUnit() {
+        return unit;
+    }
+
+    /**
+     * The method takes in a value of the MeasuringUnit enum class and sets the ingredient's unit equal to this
+     * value.
+     * @param unit The unit of measure of the given amount of the ingredient.
+     */
+    public void setUnit(MeasuringUnit unit) {
+        if(unit == null) {
+            throw new IllegalArgumentException("The food's measuring unit must be set to a valid value of MeasuringUnit.");
+        }
+        this.unit = unit;
+    }
+
+    /**
+     * The method returns a String representation of an Ingredient object, listing its type, amount and unit.
+     * @return A String representation of the ingredient object.
+     */
+    @Override
+    public String toString() {
+        return "Ingredient{" +
+                "foodType=" + foodType.label +
+                ", amount=" + amount +
+                ", unit=" + unit.label +
+                '}';
+    }
+
+    /**
+     * The method checks if a given object is equal to the ingredient object.
+     * If the object is of the same class as well as having the same value for each class field,
+     * the object is equal to the Ingredient.
+     * @param o An Object to which the Ingredient should be compared.
+     * @return True if the object is equivalent to the Ingredient, false otherwise.
+     */
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof Ingredient that)) return false;
+        return Double.compare(that.amount, amount) == 0 && foodType == that.foodType && unit == that.unit;
+    }
+
+/*    @Override
+    public int hashCode() {
+        return Objects.hash(foodType, amount, unit);
+    }*/
+}

src/main/java/no/ntnu/idatt1002/demo/data/recipes/IngredientsAtHand.java

+package no.ntnu.idatt1002.demo.data.recipes;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * The IngredientsAtHand class contains a collection of Ingredient objects that are currently available to the user.
+ * Only one instance of each ingredient type may exist in the collection. If an ingredient is already present in the
+ * collection, the old will be replaced by the new.
+ *
+ * @author hannesofie
+ */
+public class IngredientsAtHand {
+
+    private final List<Ingredient> ingredientsAtHand = new ArrayList<>();
+
+    /**
+     * The method returns the collection of ingredients at hand as an arraylist of ingredient objects.
+     * @return The collection of ingredients at hand to the user.
+     */
+    public List<Ingredient> getIngredientsAtHand() {
+        return ingredientsAtHand;
+    }
+
+    /**
+     * The method takes in an ingredient object and adds it to the collection of ingredients at hand.
+     * @param ingredient The ingredient object to add to the collection of ingredients at hand.
+     */
+    public void addIngredient(Ingredient ingredient) {
+        this.ingredientsAtHand.add(ingredient);
+    }
+
+    /**
+     * Returns null if no ingredient of the requested type is found in the collection.
+     * @param ingredientType What type of food the ingredient is.
+     * @return The ingredient of the specified type found among the ingredients at hand, null otherwise.
+     */
+    public Ingredient getIngredient(FoodItem ingredientType) {
+        if(ingredientType == null) return null;
+        return this.getIngredientsAtHand().stream()
+                .filter((ingredient) -> ingredient.getFoodType() == ingredientType)
+                .findFirst().orElse(null);
+    }
+
+    /**
+     * The method takes in three parameters. The method first checks if the Ingredient is at hand in the first place.
+     * If it is, the old amount and unit of this ingredient are replaced by the provided amount and unit if they
+     * differ. If not, the ingredient is left as is. If the ingredient is not in the collection,
+     * @param ingredientType What type of food the ingredient is.
+     * @param amount The amount of the ingredient.
+     * @return True if Ingredient is successfully altered or added, false if not.
+     */
+    public boolean alterIngredient(FoodItem ingredientType, double amount, MeasuringUnit unit) {
+        //TODO: Consider handling exceptions differently.
+        if(ingredientsAtHand.stream().anyMatch((ingredient) -> ingredient.getFoodType() == ingredientType)) {
+            try {
+                getIngredient(ingredientType).setAmount(amount);
+                getIngredient(ingredientType).setUnit(unit);
+
+            } catch (IllegalArgumentException e) {
+                return false;
+            }
+        } else {
+            try {
+                addIngredient(new Ingredient(ingredientType, amount, unit));
+            } catch (IllegalArgumentException e) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * The method takes in a value of the FoodItem enum as a parameter and removes it from the collection of
+     * ingredients at hand if it exists and returns true. If no ingredient of the given type was found in the
+     * collection, false is returned.
+     * @param ingredientType What type of food the ingredient is.
+     * @return True if the ingredient was found among the ingredients at hand and removed, false otherwise.
+     */
+    public boolean removeIngredient(FoodItem ingredientType) {
+        return ingredientsAtHand.removeIf((ingredient) -> ingredient.getFoodType() == ingredientType);
+    }
+
+}

src/main/java/no/ntnu/idatt1002/demo/data/recipes/MeasuringUnit.java

+package no.ntnu.idatt1002.demo.data.recipes;
+
+public enum MeasuringUnit {
+
+    DL("dl."),
+    L("l."),
+    TSP("tsp."),
+    TBS("tbs."),
+    GR("gr."),
+    KG("kg."),
+    PC("pieces");
+
+    public final String label;
+
+    MeasuringUnit(String label) {
+        this.label = label;
+    }
+}

src/main/java/no/ntnu/idatt1002/demo/data/recipes/Recipe.java

+package no.ntnu.idatt1002.demo.data.recipes;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+// Method in case we want to check if also the amount is enough for the recipe.
+// Recipes without any ingredients can be showed among all ingredients, but not in suggestion based on ingredients
+// at hand.
+//TODO: Record?
+public class Recipe {
+
+    private String name = "";
+    private List<RecipeIngredient> ingredientList = new ArrayList<>();
+    private String instructions = "";
+
+    public Recipe(String name, String description ) {
+        if(name.isBlank() | description.isBlank()) {
+            throw new IllegalArgumentException("The recipe must have a name and a description.");
+        }
+        this.name = name;
+        this.instructions = description;
+    }
+
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        if(name.isBlank()) {
+            throw new IllegalArgumentException("The recipe name cannot be left blank.");
+        }
+        this.name = name;
+    }
+
+    public List<RecipeIngredient> getIngredientList() {
+        return ingredientList;
+    }
+
+    public String getInstructions() {
+        return instructions;
+    }
+
+    public void setInstructions(String instructions) {
+        if(instructions.isBlank()) {
+            throw new IllegalArgumentException("The recipe instructions cannot be left blank.");
+        }
+        this.instructions = instructions;
+    }
+
+
+ /*   public void addIngredients(ArrayList<RecipeIngredient> ingredients) {
+        ingredients.forEach((ingredient) -> this.ingredientList.add(ingredient));
+    }*/
+
+    //TODO: Make interface for "collects ingredients" and do deep copy.
+
+    public RecipeIngredient getIngredient(FoodItem ingredientType) {
+        if(ingredientType == null) return null;
+        return this.getIngredientList().stream()
+                .filter((ingredient) -> ingredient.getFoodType() == ingredientType)
+                .findFirst().orElse(null);
+    }
+
+
+    public boolean addIngredient(FoodItem ingredientType, double amount, MeasuringUnit unit) {
+        if(ingredientList.stream().anyMatch((ingredient) -> ingredient.getFoodType() == ingredientType)) {
+            try {
+                getIngredient(ingredientType).setAmount(amount);
+                getIngredient(ingredientType).setUnit(unit);
+
+            } catch (IllegalArgumentException e) {
+                return false;
+            }
+        } else {
+            try {
+                this.ingredientList.add(new RecipeIngredient(ingredientType, amount, unit));
+            } catch (IllegalArgumentException e) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * The functionality may be expanded upon in order to also check if the amount is sufficient for the current recipe.
+     * @param ingredientsAtHand
+     */
+    public void updateIngredientStatus(IngredientsAtHand ingredientsAtHand) {
+        // Will need a supporting class for converting between units to be accurate.
+       if(ingredientsAtHand == null) {
+           throw new NullPointerException("The ingredients at hand object must exist");
+       } else if (ingredientsAtHand.getIngredientsAtHand().size() < 1) {
+           throw new IllegalArgumentException("The collection of ingredients at hand is empty.");
+       } else {
+           ingredientList.forEach((inRecipe) -> {
+               ingredientsAtHand.getIngredientsAtHand().forEach((atHand) -> {
+                   if(inRecipe.getFoodType() == atHand.getFoodType()) {
+                       inRecipe.setAtHand(true);
+                   }
+               });
+           });
+       }
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Recipe recipe = (Recipe) o;
+        return Objects.equals(name, recipe.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, ingredientList, instructions);
+    }
+}

src/main/java/no/ntnu/idatt1002/demo/data/recipes/RecipeIngredient.java

+package no.ntnu.idatt1002.demo.data.recipes;
+
+/**
+ * The RecipeIngredient class is an extension of the Ingredient class  used as part of recipes
+ * that also stored the boolean value 'atHand'. This value can be set to true whenever the given ingredient,
+ * being part of a recipe, is also at hand to the user. Ingredients that the user has available are stored in
+ * the IngredientsAtHand class.
+ *
+ * @author hannesofie
+ */
+public class RecipeIngredient extends Ingredient{
+
+    private boolean atHand = false;
+
+    /**
+     * The constructor of a RecipeIngredient object inherits from the superclass Ingredient. The additional 'atHand'
+     * field is set to false ar default.
+     * @param ingredient What type of food the ingredient is.
+     * @param amount The amount of the ingredient.
+     * @param unit The unit of measure of the given amount of the ingredient.
+     */
+    public RecipeIngredient(FoodItem ingredient, double amount, MeasuringUnit unit) {
+        super(ingredient, amount, unit);
+    }
+
+    /**
+     * The method returns the boolean value of the atHand field for the ingredient. If the ingredient being part of
+     * a recipe is also contained in the collection of ingredients at hand to the user, true is returned, if not,
+     * false is returned.
+     * @return True of the current recipe ingredient is available to the user.
+     */
+    public boolean isAtHand() {
+        return atHand;
+    }
+
+    /**
+     * The method sets the value of the atHand field for the ingredient to either true or false.
+     * @param atHand
+     */
+    public void setAtHand(boolean atHand) {
+        this.atHand = atHand;
+    }
+
+}

src/main/java/no/ntnu/idatt1002/demo/data/recipes/RecipeRegister.java

+package no.ntnu.idatt1002.demo.data.recipes;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class RecipeRegister {
+
+    private final List<Recipe> recipes = new ArrayList<>();
+
+
+    //TODO: Copy-constructor
+
+    public List<Recipe> getRecipes() {
+        return recipes;
+    }
+
+    public void addRecipe (Recipe recipe) {
+        if(recipes.contains(recipe)) {
+            throw new IllegalArgumentException("The recipe already exists in the register."); // Or just replace?
+        } else if (recipe == null) {
+            throw new NullPointerException("The recipe cannot be null.");
+        }
+        this.recipes.add(recipe);
+    }
+
+    public Recipe getRecipe(String name) {
+        return recipes.stream().
+                filter((recipe) -> recipe.getName().equals(name))
+                        .findFirst().orElse(null);
+    }
+}

src/test/java/no/ntnu/idatt1002/demo/data/recipes/IngredientTest.java

+package no.ntnu.idatt1002.demo.data.recipes;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class IngredientTest {
+
+    Ingredient testIngredient;
+
+    @BeforeEach
+    void beforeEach() {
+        testIngredient = new Ingredient(FoodItem.ONION, 0.5f, MeasuringUnit.KG);
+    }
+
+    @Test
+    @DisplayName("The constructor creates an ingredient object successfully")
+    void constructValidIngredient() {
+        Ingredient validIngredient = new Ingredient(FoodItem.ONION, 1, MeasuringUnit.KG);
+        assertEquals(validIngredient, new Ingredient(FoodItem.ONION, 1, MeasuringUnit.KG));
+    }
+
+    @Test
+    @DisplayName("The constructor throws exceptions for illegal input.")
+    void constructorThrowsExceptionsWhenItShould() {
+        assertThrows(IllegalArgumentException.class, () -> new Ingredient(null, 2, MeasuringUnit.DL));
+        assertThrows(IllegalArgumentException.class, () -> new Ingredient(FoodItem.ONION, -5, MeasuringUnit.DL));
+        assertThrows(IllegalArgumentException.class, () -> new Ingredient(FoodItem.ONION, 0, MeasuringUnit.DL));
+        assertThrows(IllegalArgumentException.class, () -> new Ingredient(FoodItem.ONION, 2, null));
+    }
+
+    @Test
+    @DisplayName("Change of food type works for valid food type.")
+    void setFoodTypeWorksForValidType() {
+        testIngredient.setFoodType(FoodItem.LEMON);
+        assertEquals(new Ingredient(FoodItem.LEMON, 0.5f, MeasuringUnit.KG), testIngredient);
+    }
+
+    @Test
+    @DisplayName("Change of food type to invalid type throws exception.")
+    void setFoodTypeThrowsException() {
+        assertThrows(IllegalArgumentException.class, () -> testIngredient.setFoodType(null));
+    }
+
+    @Test
+    @DisplayName("Change of food amount works for valid amount.")
+    void setAmountWorksForValidAmount() {
+        testIngredient.setAmount(2.5);
+        assertEquals(new Ingredient(FoodItem.ONION, 2.5f, MeasuringUnit.KG), testIngredient);
+    }
+
+    @Test
+    @DisplayName("Change of food amount to invalid amount throws exception.")
+    void setAmountThrowsException() {
+        assertThrows(IllegalArgumentException.class, () -> testIngredient.setAmount(0));
+        assertThrows(IllegalArgumentException.class, () -> testIngredient.setAmount(-1));
+    }
+
+    @Test
+    @DisplayName("Change of measuring unit works for valid unit.")
+    void setUnitWorksForValidUnit() {
+        testIngredient.setUnit(MeasuringUnit.TBS);
+        assertEquals(new Ingredient(FoodItem.ONION, 0.5f, MeasuringUnit.TBS), testIngredient);
+    }
+
+    @Test
+    @DisplayName("Change of measuring to invalid unit throws exception.")
+    void setUnitThrowsException() {
+        assertThrows(IllegalArgumentException.class, () -> testIngredient.setUnit(null));
+    }
+
+//TODO: Test for equals method?
+
+}
\ No newline at end of file

src/test/java/no/ntnu/idatt1002/demo/data/recipes/IngredientsAtHandTest.java

+package no.ntnu.idatt1002.demo.data.recipes;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class IngredientsAtHandTest {
+
+    IngredientsAtHand ingredientsAtHand = new IngredientsAtHand();
+
+    @BeforeEach
+    void beforeEach() {
+        ingredientsAtHand.addIngredient(new Ingredient(FoodItem.LEMON, 3, MeasuringUnit.PC));
+        ingredientsAtHand.addIngredient(new Ingredient(FoodItem.MILK, 1.5f, MeasuringUnit.L));
+        ingredientsAtHand.addIngredient(new Ingredient(FoodItem.MINCED_MEAT, 400, MeasuringUnit.GR));
+
+    }
+
+    @Test
+    @DisplayName("The getIngredient method returns the correct ingredient.")
+    void getIngredientReturnsSuccessfully() {
+        assertEquals(new Ingredient(FoodItem.LEMON, 3, MeasuringUnit.PC),
+                ingredientsAtHand.getIngredient(FoodItem.LEMON));
+
+    }
+
+    @Test
+    @DisplayName("The getIngredient method returns null if the ingredient is not in the collection.")
+    void getIngredientReturnsNullWhenNotFoundOrNull(){
+        assertNull(ingredientsAtHand.getIngredient(FoodItem.ONION));
+        assertNull(ingredientsAtHand.getIngredient(null));
+    }
+
+
+    @Test
+    @DisplayName("Altering ingredient successfully and return true.")
+    void alterIngredientSuccessfully() {
+        assertNotEquals(new Ingredient(FoodItem.ONION, 500, MeasuringUnit.GR),
+                ingredientsAtHand.getIngredient(FoodItem.ONION));
+
+        assertTrue(ingredientsAtHand.alterIngredient(FoodItem.ONION, 500, MeasuringUnit.GR));
+
+        assertEquals(new Ingredient(FoodItem.ONION, 500, MeasuringUnit.GR),
+                ingredientsAtHand.getIngredient(FoodItem.ONION));
+
+    }
+
+    @Test
+    @DisplayName("Altering ingredient that does not yet exist in collection adds it and returns true.")
+    void alterNewIngredientAddsIt() {
+        int ingredientsAtStart = ingredientsAtHand.getIngredientsAtHand().size();
+        assertTrue(ingredientsAtHand.alterIngredient(FoodItem.ORANGE, 8, MeasuringUnit.PC));
+
+        assertEquals(ingredientsAtStart + 1, ingredientsAtHand.getIngredientsAtHand().size());
+    }
+
+    @Test
+    @DisplayName("Attempting to alter ingredient in illegal way does not alter the collection and returns false.")
+    void alterIngredientUnchangedForInvalidChange() {
+        assertFalse(ingredientsAtHand.alterIngredient(null, 350, MeasuringUnit.GR));
+        assertEquals(new Ingredient(FoodItem.LEMON, 3, MeasuringUnit.PC),
+                ingredientsAtHand.getIngredient(FoodItem.LEMON));
+    }
+
+    @Test
+    @DisplayName("Altering an ingredients without changing values, leaves no change on the collection and returns true.")
+    void alterNothingLeavesCollectionIntact() {
+        int ingredientsAtStart = ingredientsAtHand.getIngredientsAtHand().size();
+
+         assertTrue(ingredientsAtHand.alterIngredient(FoodItem.LEMON, 3, MeasuringUnit.PC));
+
+        assertEquals(ingredientsAtStart, ingredientsAtHand.getIngredientsAtHand().size());
+    }
+
+    @Test
+    @DisplayName("Ingredient is removed successfully and true is returned.")
+    void removeIngredientSuccessfully() {
+        int ingredientsAtStart = ingredientsAtHand.getIngredientsAtHand().size();
+        assertTrue(ingredientsAtHand.removeIngredient(FoodItem.LEMON));
+        assertEquals(ingredientsAtStart-1, ingredientsAtHand.getIngredientsAtHand().size());
+    }
+
+    @Test
+    @DisplayName("Removing ingredient that is not in the collection, leaves it unchanged and returns false.")
+    void removeIngredientNotInCollection() {
+
+        assertFalse(ingredientsAtHand.removeIngredient(FoodItem.SALSA_SAUCE));
+    }
+
+}
\ No newline at end of file

src/test/java/no/ntnu/idatt1002/demo/data/recipes/RecipeRegisterTest.java

+package no.ntnu.idatt1002.demo.data.recipes;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class RecipeRegisterTest {
+
+    RecipeRegister myRecipes;
+
+    @BeforeEach
+    void beforeEach() {
+        myRecipes = new RecipeRegister();
+        myRecipes.addRecipe(new Recipe("Pasta al Limone", "Instructions"));
+    }
+
+    @Test
+    @DisplayName("Adding recipe to register successfully.")
+    void addRecipeToRegister() {
+        int numberOfRecipes = myRecipes.getRecipes().size();
+        myRecipes.addRecipe(new Recipe("Carbonara", "Instructions"));
+        assertEquals(numberOfRecipes + 1, myRecipes.getRecipes().size());
+    }
+
+    @Test
+    @DisplayName("Throw exception when adding already registered recipe.")
+    void recipeAlreadyInRegister() {
+        assertThrows(IllegalArgumentException.class, () -> myRecipes.addRecipe( new Recipe("Pasta al Limone", "Instructions")));
+    }
+
+    @Test
+    @DisplayName("Throw exception when adding null recipe.")
+    void addNullRecipe() {
+        assertThrows(NullPointerException.class, () -> myRecipes.addRecipe(null));
+    }
+
+    @Test
+    @DisplayName("Returns correct recipe based on name.")
+    void getRecipeByName() {
+        assertEquals(new Recipe("Pasta al Limone", "Instructions"), myRecipes.getRecipe("Pasta al Limone"));
+    }
+
+}
\ No newline at end of file

src/test/java/no/ntnu/idatt1002/demo/data/recipes/RecipeTest.java

+package no.ntnu.idatt1002.demo.data.recipes;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class RecipeTest {
+
+    Recipe recipe;
+
+    @BeforeEach
+    void beforeEach() {
+        recipe = new Recipe("Meat, cheese and potatoes", "Instructions");
+
+        recipe.addIngredient(FoodItem.MINCED_MEAT, 500, MeasuringUnit.GR);
+        recipe.addIngredient(FoodItem.POTATO, 750, MeasuringUnit.GR);
+        recipe.addIngredient(FoodItem.YELLOW_CHEESE, 2, MeasuringUnit.DL);
+
+    }
+
+    @Test
+    @DisplayName("Constructor creates Recipe successfully.")
+    void constructorCreatesRecipe() {
+        assertEquals(recipe, new Recipe("Meat, cheese and potatoes", "Instructions"));
+        // Recipes are equal if name and Instructions are equal.
+    }
+
+    @Test
+    @DisplayName("Constructor throws exception for empty name or instruction.")
+    void constructorThrowsException() {
+        assertThrows(IllegalArgumentException.class, () -> new Recipe("", "Instructions"));
+        assertThrows(IllegalArgumentException.class, () -> new Recipe("Name", ""));
+
+    }
+
+    @Test
+    @DisplayName("Can change name of recipe successfully.")
+    void setNameSuccessfully() {
+        String newName = "Meat and cheese";
+        recipe.setName(newName);
+        assertEquals(newName, recipe.getName());
+    }
+
+    @Test
+    @DisplayName("Throws exception when name set to empty string.")
+    void setNameEmptyThrowsException() {
+        assertThrows(IllegalArgumentException.class, () -> recipe.setName(" "));
+    }
+
+    @Test
+    @DisplayName("Can change instructions of recipe successfully.")
+    void setInstructionsSuccessfully() {
+        String newInstruction = "New instructions";
+        recipe.setInstructions(newInstruction);
+        assertEquals(newInstruction, recipe.getInstructions());
+    }
+
+    @Test
+    @DisplayName("Throws exception when Instructions set to empty string.")
+    void setInstructionsEmptyThrowsException() {
+        assertThrows(IllegalArgumentException.class, () -> recipe.setInstructions(""));
+    }
+
+
+    @Test
+    @DisplayName("Ingredient is added to recipe successfully.")
+    void addNewIngredient() {
+        int ingredientsInRecipe = recipe.getIngredientList().size();
+        assertTrue(recipe.addIngredient(FoodItem.LEMON, 1, MeasuringUnit.PC));
+        assertEquals(ingredientsInRecipe + 1, recipe.getIngredientList().size());
+    }
+
+    @Test
+    @DisplayName("Ingredient already in recipe does not alter and returns true.")
+    void addAlreadyIncludedIngredient() {
+        int ingredientsInRecipe = recipe.getIngredientList().size();
+        assertTrue(recipe.addIngredient(FoodItem.MINCED_MEAT, 500, MeasuringUnit.GR));
+        assertEquals(ingredientsInRecipe, recipe.getIngredientList().size());
+    }
+
+    @Test
+    @DisplayName("Invalid ingredient change is not made and false is returned.")
+    void addInvalidIngredientReturnsFalse() {
+        int ingredientsInRecipe = recipe.getIngredientList().size();
+        assertFalse(recipe.addIngredient(null, 500, MeasuringUnit.GR));
+        assertEquals(ingredientsInRecipe, recipe.getIngredientList().size());
+    }
+
+
+    @Test
+    @DisplayName("Updating ingredient status works as expected.")
+    void updateIngredientStatus() {
+        IngredientsAtHand inFridge = new IngredientsAtHand();
+        inFridge.addIngredient(new Ingredient(FoodItem.MINCED_MEAT, 400, MeasuringUnit.GR));
+        inFridge.addIngredient(new Ingredient(FoodItem.YELLOW_CHEESE, 500, MeasuringUnit.GR));
+
+
+        recipe.getIngredientList().forEach((ingredient) -> assertFalse(ingredient.isAtHand()));
+        recipe.updateIngredientStatus(inFridge);
+
+        assertTrue(recipe.getIngredient(FoodItem.MINCED_MEAT).isAtHand());
+        assertTrue(recipe.getIngredient(FoodItem.YELLOW_CHEESE).isAtHand());
+        assertFalse(recipe.getIngredient(FoodItem.POTATO).isAtHand());
+    }
+
+    @Test
+    @DisplayName("Update of ingredient status based on empty or null ingredients at hand collection.")
+    void nullOrEmptyIngredientsAtHand() {
+        IngredientsAtHand emptyFridge = new IngredientsAtHand();
+
+        assertThrows(NullPointerException.class, () -> recipe.updateIngredientStatus(null));
+        assertThrows(IllegalArgumentException.class, () -> recipe.updateIngredientStatus(emptyFridge));
+    }
+
+}
\ No newline at end of file