Resolve "Test database operations"

development/database/src/main/java/de/uniwue/swp/sshtool/database/DBConnection.java

@@ -12,6 +12,8 @@ import java.util.List;
 public interface DBConnection {
     public void login(String username, String password, String url);
 
+    public void logout();
+
     public Transaction insertTransaction(Transaction transaction) throws SQLException;
 
     public Session insertSession(Session session) throws SQLException;

development/database/src/main/java/de/uniwue/swp/sshtool/database/File.java

@@ -2,6 +2,8 @@ package de.uniwue.swp.sshtool.database;
 
 import de.uniwue.swp.sshtool.database.utils.FileStatus;
 
+import java.util.Objects;
+
 /**
  * class for the database table files
  */
@@ -57,4 +59,32 @@ public class File {
     public void setFileStatus(FileStatus fileStatus) {
         this.fileStatus = fileStatus;
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        File file = (File) o;
+        return Objects.equals(fileId, file.fileId) &&
+                Objects.equals(localPath, file.localPath) &&
+                Objects.equals(remotePath, file.remotePath) &&
+                fileStatus == file.fileStatus &&
+                Objects.equals(transactionId, file.transactionId);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(fileId, localPath, remotePath, fileStatus, transactionId);
+    }
+
+    @Override
+    public String toString() {
+        return "File{" +
+                "fileId=" + fileId +
+                ", localPath='" + localPath + '\'' +
+                ", remotePath='" + remotePath + '\'' +
+                ", fileStatus=" + fileStatus +
+                ", transactionId=" + transactionId +
+                '}';
+    }
 }

development/database/src/main/java/de/uniwue/swp/sshtool/database/Session.java

@@ -3,6 +3,7 @@ package de.uniwue.swp.sshtool.database;
 import de.uniwue.swp.sshtool.database.utils.SessionStatus;
 
 import java.time.LocalDateTime;
+import java.util.Objects;
 
 /**
  * class for the database table sessions
@@ -18,7 +19,7 @@ public class Session {
 
     public Session(String username, String sshHostname, int ssh_port) {
         this.username = username;
-        this.startingTime = LocalDateTime.now();
+        this.startingTime = LocalDateTime.now().withNano(0);
         this.sshHostname = sshHostname;
         this.sshPort = ssh_port;
         this.sessionStatus=SessionStatus.STARTED;
@@ -74,6 +75,38 @@ public class Session {
     public SessionStatus getSessionStatus() {
         return sessionStatus;
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Session session = (Session) o;
+        return sshPort == session.sshPort &&
+                Objects.equals(sessionId, session.sessionId) &&
+                Objects.equals(startingTime, session.startingTime) &&
+                Objects.equals(finishingTime, session.finishingTime) &&
+                Objects.equals(username, session.username) &&
+                Objects.equals(sshHostname, session.sshHostname) &&
+                sessionStatus == session.sessionStatus;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(sessionId, startingTime, finishingTime, username, sshHostname, sshPort, sessionStatus);
+    }
+
+    @Override
+    public String toString() {
+        return "Session{" +
+                "sessionId=" + sessionId +
+                ", startingTime=" + startingTime +
+                ", finishingTime=" + finishingTime +
+                ", username='" + username + '\'' +
+                ", sshHostname='" + sshHostname + '\'' +
+                ", sshPort=" + sshPort +
+                ", sessionStatus=" + sessionStatus +
+                '}';
+    }
 }
 
 

development/database/src/main/java/de/uniwue/swp/sshtool/database/Transaction.java

@@ -2,8 +2,13 @@ package de.uniwue.swp.sshtool.database;
 
 import de.uniwue.swp.sshtool.database.utils.TransactionType;
 
+import java.sql.Timestamp;
 import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Collections;
+import java.util.Comparator;
 import java.util.List;
+import java.util.Objects;
 
 /**
  * class for the database table transactions
@@ -15,10 +20,10 @@ public class Transaction {
     private LocalDateTime finishingTime = null;
     private final TransactionType transactionType;
     private final String username;
-    private List<File> files;
+    private final List<File> files;
 
     public Transaction(String username, TransactionType type, List<File> files) {
-        this.startingTime = LocalDateTime.now();
+        this.startingTime = LocalDateTime.now().withNano(0);
         this.username = username;
         this.transactionType = type;
         this.files = files;
@@ -69,6 +74,46 @@ public class Transaction {
         return transactionType;
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Transaction that = (Transaction) o;
+        this.files.sort(new Comparator<File>() {
+            @Override
+            public int compare(File o1, File o2) {
+                return Integer.compare(o1.getFileId(), o2.getFileId());
+            }
+        });
+        that.files.sort(new Comparator<File>() {
+            @Override
+            public int compare(File o1, File o2) {
+                return Integer.compare(o1.getFileId(), o2.getFileId());
+            }
+        });
+        return Objects.equals(transactionId, that.transactionId) &&
+                startingTime.isEqual(that.startingTime) &&
+                Objects.equals(finishingTime, that.finishingTime) &&
+                transactionType.equals(that.transactionType) &&
+                Objects.equals(username, that.username) &&
+                Objects.equals(files, that.files);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(transactionId, startingTime, finishingTime, transactionType, username, files);
+    }
 
+    @Override
+    public String toString() {
+        return "Transaction{" +
+                "transactionId=" + transactionId +
+                ", startingTime=" + startingTime +
+                ", finishingTime=" + finishingTime +
+                ", transactionType=" + transactionType +
+                ", username='" + username + '\'' +
+                ", files=" + files.toString() +
+                '}';
+    }
 }
 

development/database/src/test/java/de/uniwue/swp/sshtool/database/tests/ConnectionTest.java

+package de.uniwue.swp.sshtool.database.tests;
+
+import de.uniwue.swp.sshtool.database.DBConnectionImpl;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.SQLException;
+
+
+public class ConnectionTest {
+
+    @Test
+    public void createAndCloseConnectionTest() throws SQLException{
+        DBConnectionImpl dbConnection = new DBConnectionImpl();
+        String password = "example";
+        String username = "root";
+        String url = "jdbc:mysql://localhost:3306/sshTool";
+        dbConnection.login(username, password, url);
+        DataSource dataSource = dbConnection.getDataSource();
+        Connection connection = dataSource.getConnection();
+        Assertions.assertNotNull(connection);
+        dbConnection.logout();
+    }
+
+}

development/database/src/test/java/de/uniwue/swp/sshtool/database/tests/Datasets.java

+package de.uniwue.swp.sshtool.database.tests;
+
+import de.uniwue.swp.sshtool.database.File;
+import de.uniwue.swp.sshtool.database.Session;
+import de.uniwue.swp.sshtool.database.Transaction;
+import de.uniwue.swp.sshtool.database.utils.TransactionType;
+
+import java.util.ArrayList;
+
+public abstract class Datasets {
+    public static File file1;
+    public static File file2;
+    public static File file3;
+    public static File file4;
+    public static File file5;
+
+    public static Transaction uploadTransaction;
+    public static Transaction deletionTransaction;
+    public static Transaction downloadTransaction;
+
+    public static Session session1;
+    public static Session session2;
+
+    public static void setup(){
+        file1 = new File("localPath1", "remotePath1");
+        file2 = new File(null, "remotePath2");
+        file3 = new File("localPath3", "remotePath3");
+        file4 = new File("localPath4", "remotePath3");
+        file5 = new File("localPath5", "remotePath3");
+        session1 = new Session("user1","host1",90);
+        session2 = new Session("user2","host2", 100);
+        ArrayList<File> uploadFiles = new ArrayList<>();
+        uploadFiles.add(file1);
+        uploadFiles.add(file3);
+        uploadTransaction = new Transaction("name", TransactionType.UPLOAD,uploadFiles);
+        ArrayList<File> deletionFiles = new ArrayList<>();
+        deletionFiles.add(file2);
+        deletionTransaction = new Transaction("name", TransactionType.DELETION, deletionFiles);
+        ArrayList<File> downloadFiles = new ArrayList<>();
+        downloadFiles.add(file4);
+        downloadFiles.add(file5);
+        downloadTransaction = new Transaction("name", TransactionType.DOWNLOAD, downloadFiles);
+
+    }
+}

development/database/src/test/java/de/uniwue/swp/sshtool/database/tests/InsertTest.java

-package de.uniwue.swp.sshtool.database.tests;
-
-import de.uniwue.swp.sshtool.database.DBConnectionImpl;
-import de.uniwue.swp.sshtool.database.File;
-import de.uniwue.swp.sshtool.database.Transaction;
-import de.uniwue.swp.sshtool.database.utils.FileStatus;
-import de.uniwue.swp.sshtool.database.utils.TransactionType;
-
-import java.sql.SQLException;
-import java.time.LocalDateTime;
-import java.util.ArrayList;
-
-public class InsertTest {
-    public static void main(String[] args) {
-        /*DBConnectionImpl dbConnection=DBConnectionImpl.login("root","example","jdbc:mysql://localhost:8080/databaseName=sshTool_db;");
-
-        //insertTransaction
-        File file= new File("localPath","remotePath", FileStatus.STARTED);
-        ArrayList<File> list=new ArrayList<>();
-        list.add(file);
-        Transaction transaction=new Transaction(LocalDateTime.now(),LocalDateTime.now(),"Ellen", TransactionType.UPLOAD,list);
-        try{dbConnection.insertTransaction(transaction);}
-        catch (SQLException e){e.printStackTrace();}*/
-
-    }
-
-}

development/database/src/test/java/de/uniwue/swp/sshtool/database/tests/InsertionTest.java

+package de.uniwue.swp.sshtool.database.tests;
+
+import de.uniwue.swp.sshtool.database.DBConnectionImpl;
+import de.uniwue.swp.sshtool.database.Session;
+import de.uniwue.swp.sshtool.database.Transaction;
+import org.junit.jupiter.api.*;
+
+import java.sql.SQLException;
+import java.util.List;
+
+public class InsertionTest {
+
+    static DBConnectionImpl dbConnection;
+    static Session session1;
+    static Session session2;
+
+
+    @BeforeEach
+    public void setup() throws SQLException {
+        dbConnection = new DBConnectionImpl();
+        dbConnection.login("root", "example", "jdbc:mysql://localhost:3306/sshTool");
+        Datasets.setup();
+
+    }
+
+    @AfterEach
+    public void shutdownPool() {
+        dbConnection.getDataSource().close();
+    }
+
+    @Test
+    public void testInsertAndGetTransactions() throws SQLException {
+        Transaction deletionTransaction = dbConnection.insertTransaction(Datasets.deletionTransaction);
+        Transaction uploadTransaction = dbConnection.insertTransaction(Datasets.uploadTransaction);
+        Transaction downloadTransaction = dbConnection.insertTransaction(Datasets.downloadTransaction);
+        Assertions.assertEquals(deletionTransaction, dbConnection.getTransaction(deletionTransaction.getTransactionId()));
+        Assertions.assertEquals(uploadTransaction, dbConnection.getTransaction(uploadTransaction.getTransactionId()));
+        Assertions.assertEquals(downloadTransaction, dbConnection.getTransaction(downloadTransaction.getTransactionId()));
+        List<Transaction> txs = dbConnection.getTransactions();
+        Assertions.assertTrue(txs.contains(deletionTransaction));
+        Assertions.assertTrue(txs.contains(uploadTransaction));
+        Assertions.assertTrue(txs.contains(downloadTransaction));
+
+    }
+
+    @Test
+    public void testInsertAndGetSessions() throws SQLException {
+        session1 = dbConnection.insertSession(Datasets.session1);
+        session2 = dbConnection.insertSession(Datasets.session2);
+        Assertions.assertEquals(session1, dbConnection.getSession(session1.getSessionId()));
+        Assertions.assertEquals(session2, dbConnection.getSession(session2.getSessionId()));
+        List<Session> sessions = dbConnection.getSessions();
+        Assertions.assertTrue(sessions.contains(session1));
+        Assertions.assertTrue(sessions.contains(session2));
+
+    }
+
+    @Test
+    public void testInsertTransactionSessionConn() throws SQLException {
+        session1 = dbConnection.insertSession(Datasets.session1);
+        session2 = dbConnection.insertSession(Datasets.session2);
+        Transaction deletionTransaction = dbConnection.insertTransaction(Datasets.deletionTransaction);
+        Transaction uploadTransaction = dbConnection.insertTransaction(Datasets.uploadTransaction);
+        Transaction downloadTransaction = dbConnection.insertTransaction(Datasets.downloadTransaction);
+        dbConnection.insertTransactionSessionConn(session1, deletionTransaction);
+        dbConnection.insertTransactionSessionConn(session1, uploadTransaction);
+        dbConnection.insertTransactionSessionConn(session2, uploadTransaction);
+        dbConnection.insertTransactionSessionConn(session2, downloadTransaction);
+
+        List<Transaction> transactionsInSession1 = dbConnection.getTransactionsInSession(session1);
+        List<Transaction> transactionsInSession2 = dbConnection.getTransactionsInSession(session2);
+
+        Assertions.assertTrue(transactionsInSession1.contains(deletionTransaction));
+        Assertions.assertTrue(transactionsInSession1.contains(uploadTransaction));
+        Assertions.assertTrue(transactionsInSession2.contains(uploadTransaction));
+        Assertions.assertTrue(transactionsInSession2.contains(downloadTransaction));
+
+    }
+
+
+}

development/database/src/test/java/de/uniwue/swp/sshtool/database/tests/SelectionTest.java

+package de.uniwue.swp.sshtool.database.tests;
+
+import de.uniwue.swp.sshtool.database.DBConnectionImpl;
+import de.uniwue.swp.sshtool.database.File;
+import de.uniwue.swp.sshtool.database.Session;
+import de.uniwue.swp.sshtool.database.Transaction;
+import de.uniwue.swp.sshtool.database.utils.FileStatus;
+import org.junit.jupiter.api.*;
+
+import java.sql.SQLException;
+import java.util.List;
+
+public class SelectionTest {
+    static DBConnectionImpl dbConnection;
+    static Session session1;
+    static Session session2;
+    static Transaction uploadTransaction;
+    static Transaction downloadTransaction;
+    static Transaction deletionTransaction;
+
+    @BeforeEach
+    public void setup() throws SQLException {
+        dbConnection = new DBConnectionImpl();
+        dbConnection.login("root", "example", "jdbc:mysql://localhost:3306/sshTool");
+        Datasets.setup();
+        session1 = dbConnection.insertSession(Datasets.session1);
+        session2 = dbConnection.insertSession(Datasets.session2);
+        for (File file : Datasets.uploadTransaction.getFiles()) {
+            file.setFileStatus(FileStatus.FINISHED);
+        }
+        uploadTransaction = dbConnection.insertTransaction(Datasets.uploadTransaction);
+        downloadTransaction = dbConnection.insertTransaction(Datasets.downloadTransaction);
+        deletionTransaction = dbConnection.insertTransaction(Datasets.deletionTransaction);
+        dbConnection.insertTransactionSessionConn(session1, downloadTransaction);
+        dbConnection.insertTransactionSessionConn(session1, uploadTransaction);
+        dbConnection.insertTransactionSessionConn(session2, deletionTransaction);
+        dbConnection.insertTransactionSessionConn(session1, deletionTransaction);
+
+
+    }
+
+    @AfterEach
+    public void shutdownPool() {
+        dbConnection.getDataSource().close();
+    }
+
+
+    @Test
+    public void testGetIncompleteTransactions() throws SQLException {
+        Transaction uploadTrans = Datasets.uploadTransaction;
+        for (File file : uploadTrans.getFiles()) {
+            file.setFileStatus(FileStatus.FINISHED);
+        }
+        dbConnection.updateTransaction(uploadTrans);
+        List<Transaction> transactions = dbConnection.getIncompleteTransactions("name");
+        Assertions.assertTrue(transactions.contains(deletionTransaction));
+        Assertions.assertTrue(transactions.contains(downloadTransaction));
+        Assertions.assertFalse(transactions.contains(uploadTrans));
+
+    }
+
+    @Test
+    public void testGetTransactionsInSession() throws SQLException {
+        List<Transaction> txs = dbConnection.getTransactionsInSession(session1);
+        Assertions.assertTrue(txs.contains(deletionTransaction));
+        Assertions.assertTrue(txs.contains(uploadTransaction));
+        Assertions.assertTrue(txs.contains(downloadTransaction));
+
+    }
+
+    @Test
+    public void testGetSessionsInTransaction() throws SQLException {
+        List<Session> txs = dbConnection.getSessionsInTransaction(deletionTransaction);
+        Assertions.assertTrue(txs.contains(session1));
+        Assertions.assertTrue(txs.contains(session2));
+        txs = dbConnection.getSessionsInTransaction(uploadTransaction);
+        Assertions.assertTrue(txs.contains(session1));
+        Assertions.assertFalse(txs.contains(session2));
+
+
+    }
+}

development/database/src/test/java/de/uniwue/swp/sshtool/database/tests/UpdateTest.java

+package de.uniwue.swp.sshtool.database.tests;
+
+import de.uniwue.swp.sshtool.database.DBConnectionImpl;
+import de.uniwue.swp.sshtool.database.File;
+import de.uniwue.swp.sshtool.database.Session;
+import de.uniwue.swp.sshtool.database.Transaction;
+import de.uniwue.swp.sshtool.database.utils.FileStatus;
+import de.uniwue.swp.sshtool.database.utils.SessionStatus;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.sql.SQLException;
+import java.time.LocalDateTime;
+
+public class UpdateTest {
+
+    static DBConnectionImpl dbConnection;
+
+    @BeforeEach
+    public void setup() throws SQLException {
+        dbConnection = new DBConnectionImpl();
+        dbConnection.login("root", "example", "jdbc:mysql://localhost:3306/sshTool");
+        Datasets.setup();
+        dbConnection.insertTransaction(Datasets.deletionTransaction);
+        dbConnection.insertTransaction(Datasets.downloadTransaction);
+        dbConnection.insertTransaction(Datasets.uploadTransaction);
+        dbConnection.insertSession(Datasets.session1);
+        dbConnection.insertSession(Datasets.session2);
+
+    }
+
+    @AfterEach
+    public void shutdownPool() {
+        dbConnection.getDataSource().close();
+    }
+
+    @Test
+    public void updateTransactionStatusToCancelled() throws SQLException{
+        Transaction deletionTransaction = Datasets.deletionTransaction;
+        for (File file : deletionTransaction.getFiles()) {
+            file.setFileStatus(FileStatus.CANCELLED);
+        }
+        dbConnection.updateTransaction(deletionTransaction);
+        Assertions.assertEquals(deletionTransaction, dbConnection.getTransaction(deletionTransaction.getTransactionId()));
+    }
+
+    @Test
+    public void updateFileStatusToFinished() throws SQLException{
+        Transaction uploadTransaction = Datasets.uploadTransaction;
+        for (File file : uploadTransaction.getFiles()) {
+            file.setFileStatus(FileStatus.FINISHED);
+        }
+        dbConnection.updateTransaction(uploadTransaction);
+        Assertions.assertEquals(uploadTransaction, dbConnection.getTransaction(uploadTransaction.getTransactionId()));
+    }
+    @Test
+    public void updateTransactionFinishingTime() throws SQLException {
+        Transaction downloadTransaction = Datasets.downloadTransaction;
+        downloadTransaction.setFinishingTime(LocalDateTime.now().withNano(0));
+        dbConnection.updateTransaction(downloadTransaction);
+        Assertions.assertEquals(downloadTransaction, dbConnection.getTransaction(downloadTransaction.getTransactionId()));
+    }
+
+    @Test
+    public void updateSessionFinishingTime() throws SQLException {
+        Session session1 = Datasets.session1;
+        session1.setFinishingTime(LocalDateTime.now().withNano(0));
+        dbConnection.updateSession(session1);
+        Assertions.assertEquals(session1, dbConnection.getSession(session1.getSessionId()));
+
+    }
+
+    @Test
+    public void updateSessionStatusToFinished() throws SQLException{
+        Session session2 = Datasets.session2;
+        session2.setSessionStatus(SessionStatus.FINISHED);
+        dbConnection.updateSession(session2);
+        Assertions.assertEquals(session2, dbConnection.getSession(session2.getSessionId()));
+    }
+}
+