mysql tests

2025-12-18 09:17:23 +01:00
parent facb0556a0
commit 7f96f50fb7
73 changed files with 1013 additions and 902 deletions
--- a/test/project/BadCaseTaskTest.java
+++ b/test/project/BadCaseTaskTest.java
@@ -3,15 +3,16 @@ import hhn.temp.project.Main;
 import hhn.temp.project.Task;
 import hhn.temp.project.TaskManager;
 import hhn.temp.project.TaskStatus;
-import hhn.temp.project.expections.SQLNoConectionException;
-import hhn.temp.project.expections.SQLStatmentException;
-import hhn.temp.project.expections.TaskAlreadyExistsException;
-import hhn.temp.project.expections.TaskHasNoWorkerException;
+import hhn.temp.project.expections.*;
+import hhn.temp.project.provider.MySql;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;

-import java.util.List;
+import java.lang.reflect.Field;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;

 import static org.junit.jupiter.api.Assertions.*;

@@ -21,7 +22,8 @@ public class BadCaseTaskTest {
  private String user = "hhn";
  private String password = "!9oSmhsiwYO.m)_x";
  private String db = "hhn";
-  private String host = "0.0.0.0";
+  private String host = "home.luithardt.cloud";
+  private String port = "3555";

  @BeforeEach
  public void setup() {
@@ -32,13 +34,20 @@ public class BadCaseTaskTest {
  @Test
  @DisplayName("Create a new TaskManager and test Connecton")
  public void assertCreateNewTaskManager() {
-    assertThrows(SQLNoConectionException.class,() -> taskManager = new TaskManager("deep", "deep", db, host));
+    assertThrows(SQLNoConectionException.class,() -> taskManager = new TaskManager("deep", "deep", db, host, port));
+    assertThrows(NullPointerException.class,() -> taskManager = new TaskManager(null, "deep", db, host, port));
+    assertThrows(NullPointerException.class,() -> taskManager = new TaskManager(user, null, db, host, port));
+    assertThrows(NullPointerException.class,() -> taskManager = new TaskManager(user, password, null, host, port));
+    assertThrows(NullPointerException.class,() -> taskManager = new TaskManager(user, password, db, null, port));
+    assertThrows(NullPointerException.class,() -> taskManager = new TaskManager(user, password, db, host, null));
+
+
  }

  @Test
  @DisplayName("Assert an IllegalArgumentException when you create a new Task with no or wrong Name, Description")
  public void assertExceptionOnCreateNewTask() {
-    taskManager = new TaskManager(user, password, db, host);
+    taskManager = new TaskManager(user, password, db, host, port);
    assertThrows(IllegalArgumentException.class,() -> taskManager.createTask("", null));
    assertThrows(IllegalArgumentException.class,() -> taskManager.createTask(null, ""));
    assertThrows(IllegalArgumentException.class,() -> taskManager.createTask(null, null));
@@ -53,7 +62,7 @@ public class BadCaseTaskTest {
  @Test
  @DisplayName("Assert an IllegalArgumentException when you create a new Task with the same Name of a exits Task")
  public void assertExceptionOnCreateNewTaskWithExitsName() {
-    taskManager = new TaskManager(user, password, db, host);
+    taskManager = new TaskManager(user, password, db, host, port);
    String name = "Name";
    String description = "Description";
    assertDoesNotThrow(() -> taskManager.createTask(name, description));
@@ -66,7 +75,7 @@ public class BadCaseTaskTest {
  @Test
  @DisplayName("Assert an IllegalArgumentException when you edit a exits Task")
  public void assertExceptionOnEditATask() {
-    taskManager = new TaskManager(user, password, db, host);
+    taskManager = new TaskManager(user, password, db, host, port);
    String name = "Name";
    String description = "Description";
    Task task = taskManager.createTask(name, description);
@@ -82,7 +91,7 @@ public class BadCaseTaskTest {
    @Test
    @DisplayName("Assert an IllegalArgumentException when calling a non-Existing Task")
    public void assertExceptionOnCallingANonextistingTask (){
-      taskManager = new TaskManager(user, password, db, host);
+      taskManager = new TaskManager(user, password, db, host, port);
      String wrongName = "Manager";
      String name = "Name";
      String description = "Description";
@@ -98,7 +107,7 @@ public class BadCaseTaskTest {
  @Test
  @DisplayName("Assert an IllegalArgumentException when delete a existing Task with wrong arguments")
  public void assertExceptionOnDeletingTask (){
-    taskManager = new TaskManager(user, password, db, host);
+    taskManager = new TaskManager(user, password, db, host, port);
    String wrongName = "Manager";
    String name = "Name";
    String description = "Description";
@@ -115,7 +124,7 @@ public class BadCaseTaskTest {
  @Test
  @DisplayName("Get a Exeption by setWorker and getWorker")
  public void assertExeptionBySetAndGetAuthorOfATask() {
-    taskManager = new TaskManager(user, password, db, host);
+    taskManager = new TaskManager(user, password, db, host, port);
    String name = "Name";
    String description = "Description";
    String workerName = "worker";
@@ -130,4 +139,274 @@ public class BadCaseTaskTest {

  }

+
+  // MYSQL FILE TESTS
+
+
+  @Test
+  @DisplayName("Assert SQLNoConectionException when connect fails")
+  public void assertSQLNoConectionExceptionOnConnect() {
+    MySql mySql = new MySql("wrongUser", "wrongPassword", "wrongDb", host, port);
+    assertThrows(SQLNoConectionException.class, mySql::connect);
+  }
+
+  @Test
+  @DisplayName("Assert NullPointerException when reset without connect")
+  public void assertNullPointerExceptionOnReset() {
+    MySql mySql = new MySql(user, password, db, host, port);
+    assertThrows(NullPointerException.class, mySql::reset);
+  }
+
+  @Test
+  @DisplayName("Assert NullPointerException when createTask without connect")
+  public void assertNullPointerExceptionOnCreateTask() {
+    MySql mySql = new MySql(user, password, db, host, port);
+    assertThrows(NullPointerException.class, () -> mySql.createTask("Task", "Description"));
+  }
+
+  @Test
+  @DisplayName("Assert NullPointerException when existTask(name) without connect")
+  public void assertNullPointerExceptionOnExistTaskByName() {
+    MySql mySql = new MySql(user, password, db, host, port);
+    assertThrows(NullPointerException.class, () -> mySql.existTask("Task"));
+  }
+
+  @Test
+  @DisplayName("Assert NullPointerException when existTask(id) without connect")
+  public void assertNullPointerExceptionOnExistTaskById() {
+    MySql mySql = new MySql(user, password, db, host, port);
+    assertThrows(NullPointerException.class, () -> mySql.existTask(1));
+  }
+
+  @Test
+  @DisplayName("Assert NullPointerException when deleteTask without connect")
+  public void assertNullPointerExceptionOnDeleteTask() {
+    MySql mySql = new MySql(user, password, db, host, port);
+    assertThrows(NullPointerException.class, () -> mySql.deleteTask("Task"));
+  }
+
+  @Test
+  @DisplayName("Assert NullPointerException when updateDescription without connect")
+  public void assertNullPointerExceptionOnUpdateDescription() {
+    MySql mySql = new MySql(user, password, db, host, port);
+    assertThrows(NullPointerException.class, () -> mySql.updateDescription(1, "Desc"));
+  }
+
+  @Test
+  @DisplayName("Assert NullPointerException when updateStatus without connect")
+  public void assertNullPointerExceptionOnUpdateStatus() {
+    MySql mySql = new MySql(user, password, db, host, port);
+    assertThrows(NullPointerException.class, () -> mySql.updateStatus(1, TaskStatus.OPEN));
+  }
+
+  @Test
+  @DisplayName("Assert NullPointerException when updateWorker without connect")
+  public void assertNullPointerExceptionOnUpdateWorker() {
+    MySql mySql = new MySql(user, password, db, host, port);
+    assertThrows(NullPointerException.class, () -> mySql.updateWorker(1, "Worker"));
+  }
+
+  @Test
+  @DisplayName("Assert NullPointerException when getTask(id) without connect")
+  public void assertNullPointerExceptionOnGetTaskById() {
+    MySql mySql = new MySql(user, password, db, host, port);
+    assertThrows(NullPointerException.class, () -> mySql.getTask(1));
+  }
+
+  @Test
+  @DisplayName("Assert NullPointerException when getTask(name) without connect")
+  public void assertNullPointerExceptionOnGetTaskByName() {
+    MySql mySql = new MySql(user, password, db, host, port);
+    assertThrows(NullPointerException.class, () -> mySql.getTask("Task"));
+  }
+
+  @Test
+  @DisplayName("Assert NullPointerException when getTaskList without connect")
+  public void assertNullPointerExceptionOnGetTaskList() {
+    MySql mySql = new MySql(user, password, db, host, port);
+    assertThrows(NullPointerException.class, mySql::getTaskList);
+  }
+
+  @Test
+  @DisplayName("Assert TaskNotExistsException when getTask(id) finds no task")
+  public void assertTaskNotExistsExceptionOnGetTaskById() {
+    MySql mySql = new MySql(user, password, db, host, port);
+    mySql.connect();
+    mySql.reset();
+
+    assertThrows(
+            TaskNotExistsException.class,
+            () -> mySql.getTask(9999)
+    );
+  }
+
+  @Test
+  @DisplayName("Assert TaskNotExistsException when getTask(name) finds no task")
+  public void assertTaskNotExistsExceptionOnGetTaskByName() {
+    MySql mySql = new MySql(user, password, db, host, port);
+    mySql.connect();
+    mySql.reset();
+
+    assertThrows(
+            TaskNotExistsException.class,
+            () -> mySql.getTask("does-not-exist")
+    );
+  }
+
+  @Test
+  @DisplayName("Assert SQLStatmentException when getTask(id) causes SQLException")
+  public void assertSQLStatmentExceptionOnGetTaskById()  {
+    MySql mySql = new MySql(user, password, db, host, port);
+    mySql.connect();
+
+    assertDoesNotThrow(() ->closeConnectionViaReflection(mySql));
+
+    assertThrows(
+            SQLStatmentException.class,
+            () -> mySql.getTask(1)
+    );
+  }
+
+  @Test
+  @DisplayName("Assert SQLStatmentException when getTask(name) causes SQLException")
+  public void assertSQLStatmentExceptionOnGetTaskByName()  {
+    MySql mySql = new MySql(user, password, db, host, port);
+    mySql.connect();
+
+    assertDoesNotThrow(() ->closeConnectionViaReflection(mySql));
+    assertThrows(
+            SQLStatmentException.class,
+            () -> mySql.getTask("Task")
+    );
+  }
+
+  @Test
+  @DisplayName("Assert SQLStatmentException when getTaskList causes SQLException")
+  public void assertSQLStatmentExceptionOnGetTaskList()  {
+    MySql mySql = new MySql(user, password, db, host, port);
+    mySql.connect();
+
+    assertDoesNotThrow(() ->closeConnectionViaReflection(mySql));
+
+    assertThrows(
+            SQLStatmentException.class,
+            mySql::getTaskList
+    );
+  }
+
+  @Test
+  @DisplayName("Assert SQLStatmentException when existTask causes SQLException")
+  public void assertSQLStatmentExceptionOnExistTask() {
+    MySql mySql = new MySql(user, password, db, host, port);
+    mySql.connect();
+
+    assertDoesNotThrow(() ->closeConnectionViaReflection(mySql));
+
+    assertThrows(
+            SQLStatmentException.class,
+            () -> mySql.existTask(1)
+    );
+  }
+  @Test
+  @DisplayName("Assert SQLStatmentException when existTask causes SQLException")
+  public void assertSQLStatmentExceptionOnExistTaskWithString() {
+    MySql mySql = new MySql(user, password, db, host, port);
+    mySql.connect();
+
+    assertDoesNotThrow(() ->closeConnectionViaReflection(mySql));
+
+    assertThrows(
+            SQLStatmentException.class,
+            () -> mySql.existTask("adada")
+    );
+  }
+
+  @Test
+  @DisplayName("Assert SQLStatmentException when updateDescription causes SQLException")
+  public void assertSQLStatmentExceptionOnUpdateDescription() {
+    MySql mySql = new MySql(user, password, db, host, port);
+    mySql.connect();
+
+    assertDoesNotThrow(() ->closeConnectionViaReflection(mySql));
+
+    assertThrows(
+            SQLStatmentException.class,
+            () -> mySql.updateDescription(1, "desc")
+    );
+  }
+
+  @Test
+  @DisplayName("Assert SQLStatmentException when updateStatus causes SQLException")
+  public void assertSQLStatmentExceptionOnUpdateStatus() {
+    MySql mySql = new MySql(user, password, db, host, port);
+    mySql.connect();
+
+    assertDoesNotThrow(() ->closeConnectionViaReflection(mySql));
+
+    assertThrows(
+            SQLStatmentException.class,
+            () -> mySql.updateStatus(1, TaskStatus.OPEN)
+    );
+  }
+
+  @Test
+  @DisplayName("Assert SQLStatmentException when updateWorker causes SQLException")
+  public void assertSQLStatmentExceptionOnUpdateWorker() {
+    MySql mySql = new MySql(user, password, db, host, port);
+    mySql.connect();
+
+    assertDoesNotThrow(() ->closeConnectionViaReflection(mySql));
+
+    assertThrows(
+            SQLStatmentException.class,
+            () -> mySql.updateWorker(1, "worker")
+    );
+  }
+
+  @Test
+  @DisplayName("Assert SQLStatmentException when deleteTask causes SQLException")
+  public void assertSQLStatmentExceptionOnDeleteTask()  {
+    MySql mySql = new MySql(user, password, db, host, port);
+    mySql.connect();
+
+    assertDoesNotThrow(() ->closeConnectionViaReflection(mySql));
+
+    assertThrows(
+            SQLStatmentException.class,
+            () -> mySql.deleteTask("task")
+    );
+  }
+
+  @Test
+  @DisplayName("Assert SQLStatmentException when createTask causes SQLException")
+  public void assertSQLStatmentExceptionOnCreateTask() {
+    MySql mySql = new MySql(user, password, db, host, port);
+    mySql.connect();
+
+    assertDoesNotThrow(() ->closeConnectionViaReflection(mySql));
+
+    assertThrows(
+            SQLStatmentException.class,
+            () -> mySql.createTask("Task", "Description")
+    );
+  }
+  @Test
+  @DisplayName("Assert SQLStatmentException when reset causes SQLException")
+  void assertSQLStatmentExceptionOnReset() {
+    MySql mySql = new MySql(user, password, db, host, port);
+    mySql.connect();
+    assertDoesNotThrow(() ->closeConnectionViaReflection(mySql));
+
+    assertThrows(SQLStatmentException.class, mySql::reset);
+  }
+
+  private void closeConnectionViaReflection(MySql mySql) throws Exception {
+    Field connectionField = MySql.class.getDeclaredField("connection");
+    connectionField.setAccessible(true);
+    Connection connection = (Connection) connectionField.get(mySql);
+    connection.close();
+  }
+
+
+
 }