getForName(String name) {
+ for (DBType dbType : DBType.values()) {
+ if (dbType.getName().equalsIgnoreCase(name)) {
+ return Optional.of(dbType);
+ }
+ }
+
+ return Optional.empty();
+ }
+
+ /**
+ * Checks if the name of a {@code DBType} corresponds to {@code name}.
+ * This method is case-insensitive.
+ *
+ * @param name the name of the {@code DBType}
+ * @return if the {@code DBType} exists
+ * @see DBType#getForName(String)
+ */
+ public static boolean exists(String name) {
+ for (DBType dbType : DBType.values()) {
+ if (dbType.getName().equalsIgnoreCase(name)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+}
diff --git a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/Database.java b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/Database.java
index 541fa2731..40bcae431 100644
--- a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/Database.java
+++ b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/Database.java
@@ -47,18 +47,13 @@ public abstract class Database {
public abstract SaveOperations save();
- public abstract String getName();
-
/**
- * Used to get the config name of the database type.
- *
- * Thread safe.
+ * Used to get the {@code DBType} of the Database
*
- * @return sqlite/mysql
+ * @return the {@code DBType}
+ * @see DBType
*/
- public String getConfigName() {
- return getName().toLowerCase().trim();
- }
+ public abstract DBType getType();
public abstract void close() throws DBException;
diff --git a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/H2DB.java b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/H2DB.java
new file mode 100644
index 000000000..13121e89f
--- /dev/null
+++ b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/H2DB.java
@@ -0,0 +1,240 @@
+/*
+ * This file is part of Player Analytics (Plan).
+ *
+ * Plan is free software: you can redistribute it and/or modify
+ * it under the terms of the LGNU Lesser General Public License v3 as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Plan is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * LGNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Plan. If not, see .
+ */
+package com.djrapitops.plan.system.database.databases.sql;
+
+import com.djrapitops.plan.api.exceptions.database.DBInitException;
+import com.djrapitops.plan.data.store.containers.NetworkContainer;
+import com.djrapitops.plan.system.database.databases.DBType;
+import com.djrapitops.plan.system.file.PlanFiles;
+import com.djrapitops.plan.system.info.server.ServerInfo;
+import com.djrapitops.plan.system.locale.Locale;
+import com.djrapitops.plan.system.settings.Settings;
+import com.djrapitops.plan.system.settings.config.PlanConfig;
+import com.djrapitops.plan.utilities.MiscUtils;
+import com.djrapitops.plugin.benchmarking.Timings;
+import com.djrapitops.plugin.logging.L;
+import com.djrapitops.plugin.logging.console.PluginLogger;
+import com.djrapitops.plugin.logging.error.ErrorHandler;
+import com.djrapitops.plugin.task.PluginTask;
+import com.djrapitops.plugin.task.RunnableFactory;
+import dagger.Lazy;
+import org.h2.jdbcx.JdbcDataSource;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import java.io.File;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.Objects;
+
+/**
+ * Implementation of the H2 database
+ *
+ * @author Fuzzlemann
+ * @since 4.5.1
+ */
+public class H2DB extends SQLDB {
+
+ private final File databaseFile;
+ private final String dbName;
+ private Connection connection;
+ private PluginTask connectionPingTask;
+
+ private H2DB(
+ File databaseFile,
+ Locale locale,
+ PlanConfig config,
+ Lazy serverInfo,
+ NetworkContainer.Factory networkContainerFactory,
+ RunnableFactory runnableFactory,
+ PluginLogger logger,
+ Timings timings,
+ ErrorHandler errorHandler
+ ) {
+ super(() -> serverInfo.get().getServerUUID(), locale, config, networkContainerFactory, runnableFactory, logger, timings, errorHandler);
+ dbName = databaseFile.getName();
+ this.databaseFile = databaseFile;
+ }
+
+ @Override
+ public void setupDataSource() throws DBInitException {
+ try {
+ Class.forName("org.h2.Driver");
+ } catch (ClassNotFoundException e) {
+ errorHandler.log(L.CRITICAL, this.getClass(), e);
+ }
+
+ try {
+ connection = getNewConnection(databaseFile);
+ } catch (SQLException e) {
+ throw new DBInitException(e);
+ }
+
+ execute("SET REFERENTIAL_INTEGRITY FALSE");
+ startConnectionPingTask();
+ }
+
+ public Connection getNewConnection(File dbFile) throws SQLException {
+ String dbFilePath = dbFile.getAbsolutePath();
+
+ Connection newConnection = getConnectionFor(dbFilePath);
+ logger.debug("H2 " + dbName + ": Opened a new Connection");
+ newConnection.setAutoCommit(false);
+ return newConnection;
+ }
+
+ private Connection getConnectionFor(String dbFilePath) throws SQLException {
+ String username = config.getString(Settings.DB_USER);
+ String password = config.getString(Settings.DB_PASS);
+
+ JdbcDataSource jdbcDataSource = new JdbcDataSource();
+ jdbcDataSource.setURL("jdbc:h2:file:" + dbFilePath + ";mode=MySQL");
+ jdbcDataSource.setUser(username);
+ jdbcDataSource.setPassword(password);
+
+ return jdbcDataSource.getConnection();
+ }
+
+ private void startConnectionPingTask() {
+ stopConnectionPingTask();
+ try {
+ // Maintains Connection.
+ connectionPingTask = runnableFactory.create("DBConnectionPingTask " + getType().getName(),
+ new KeepAliveTask(connection, () -> getNewConnection(databaseFile), logger, errorHandler)
+ ).runTaskTimerAsynchronously(60L * 20L, 60L * 20L);
+ } catch (Exception ignored) {
+ }
+ }
+
+ private void stopConnectionPingTask() {
+ if (connectionPingTask != null) {
+ try {
+ connectionPingTask.cancel();
+ } catch (Exception ignored) {
+ }
+ }
+ }
+
+ @Override
+ public DBType getType() {
+ return DBType.H2;
+ }
+
+ @Override
+ public Connection getConnection() throws SQLException {
+ if (connection == null) {
+ connection = getNewConnection(databaseFile);
+ }
+
+ return connection;
+ }
+
+ @Override
+ public void close() {
+ stopConnectionPingTask();
+ if (connection != null) {
+ logger.debug("H2DB " + dbName + ": Closed Connection");
+ MiscUtils.close(connection);
+ }
+
+ super.close();
+ }
+
+ @Override
+ public void commit(Connection connection) {
+ try {
+ connection.commit();
+ } catch (SQLException e) {
+ if (!e.getMessage().contains("cannot commit")) {
+ errorHandler.log(L.ERROR, this.getClass(), e);
+ }
+ }
+ }
+
+ @Override
+ public void returnToPool(Connection connection) {
+ // Connection pool not in use, no action required.
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null || getClass() != o.getClass()) return false;
+ if (!super.equals(o)) return false;
+ H2DB h2DB = (H2DB) o;
+ return Objects.equals(dbName, h2DB.dbName);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(super.hashCode(), dbName);
+ }
+
+ @Singleton
+ public static class Factory {
+
+ private final Locale locale;
+ private final PlanConfig config;
+ private final Lazy serverInfo;
+ private final NetworkContainer.Factory networkContainerFactory;
+ private final RunnableFactory runnableFactory;
+ private final PluginLogger logger;
+ private final Timings timings;
+ private final ErrorHandler errorHandler;
+ private PlanFiles files;
+
+ @Inject
+ public Factory(
+ Locale locale,
+ PlanConfig config,
+ PlanFiles files,
+ Lazy serverInfo,
+ NetworkContainer.Factory networkContainerFactory,
+ RunnableFactory runnableFactory,
+ PluginLogger logger,
+ Timings timings,
+ ErrorHandler errorHandler
+ ) {
+ this.locale = locale;
+ this.config = config;
+ this.files = files;
+ this.serverInfo = serverInfo;
+ this.networkContainerFactory = networkContainerFactory;
+ this.runnableFactory = runnableFactory;
+ this.logger = logger;
+ this.timings = timings;
+ this.errorHandler = errorHandler;
+ }
+
+ public H2DB usingDefaultFile() {
+ return usingFileCalled("h2database");
+ }
+
+ public H2DB usingFileCalled(String fileName) {
+ return usingFile(files.getFileFromPluginFolder(fileName));
+ }
+
+ public H2DB usingFile(File databaseFile) {
+ return new H2DB(databaseFile,
+ locale, config, serverInfo,
+ networkContainerFactory,
+ runnableFactory, logger, timings, errorHandler
+ );
+ }
+
+ }
+}
diff --git a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/KeepAliveTask.java b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/KeepAliveTask.java
new file mode 100644
index 000000000..fd74885bc
--- /dev/null
+++ b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/KeepAliveTask.java
@@ -0,0 +1,59 @@
+package com.djrapitops.plan.system.database.databases.sql;
+
+import com.djrapitops.plan.utilities.MiscUtils;
+import com.djrapitops.plugin.logging.L;
+import com.djrapitops.plugin.logging.console.PluginLogger;
+import com.djrapitops.plugin.logging.error.ErrorHandler;
+import com.djrapitops.plugin.task.AbsRunnable;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+/**
+ * The task which handles the upkeep of the {@code Connection}
+ *
+ * @author Fuzzlemann
+ * @since 4.5.1
+ */
+public class KeepAliveTask extends AbsRunnable {
+ private Connection connection;
+ private final IReconnect iReconnect;
+ private final PluginLogger logger;
+ private final ErrorHandler errorHandler;
+
+ public KeepAliveTask(Connection connection, IReconnect iReconnect, PluginLogger logger, ErrorHandler errorHandler) {
+ this.connection = connection;
+ this.iReconnect = iReconnect;
+ this.logger = logger;
+ this.errorHandler = errorHandler;
+ }
+
+ @Override
+ public void run() {
+ Statement statement = null;
+ ResultSet resultSet = null;
+ try {
+ if (connection != null && !connection.isClosed()) {
+ statement = connection.createStatement();
+ resultSet = statement.executeQuery("/* ping */ SELECT 1");
+ }
+ } catch (SQLException e) {
+ logger.debug("Something went wrong during SQL Connection upkeep task.");
+ try {
+ connection = iReconnect.reconnect();
+ } catch (SQLException e1) {
+ errorHandler.log(L.ERROR, this.getClass(), e1);
+ logger.error("SQL connection maintaining task had to be closed due to exception.");
+ this.cancel();
+ }
+ } finally {
+ MiscUtils.close(statement, resultSet);
+ }
+ }
+
+ public interface IReconnect {
+ Connection reconnect() throws SQLException;
+ }
+}
diff --git a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/MySQLDB.java b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/MySQLDB.java
index 4447f6f02..739e4f3e3 100644
--- a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/MySQLDB.java
+++ b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/MySQLDB.java
@@ -19,6 +19,7 @@ package com.djrapitops.plan.system.database.databases.sql;
import com.djrapitops.plan.api.exceptions.database.DBInitException;
import com.djrapitops.plan.api.exceptions.database.DBOpException;
import com.djrapitops.plan.data.store.containers.NetworkContainer;
+import com.djrapitops.plan.system.database.databases.DBType;
import com.djrapitops.plan.system.info.server.ServerInfo;
import com.djrapitops.plan.system.locale.Locale;
import com.djrapitops.plan.system.locale.lang.PluginLang;
@@ -67,12 +68,9 @@ public class MySQLDB extends SQLDB {
increment++;
}
- /**
- * @return the name of the Database
- */
@Override
- public String getName() {
- return "MySQL";
+ public DBType getType() {
+ return DBType.MySQL;
}
/**
@@ -158,11 +156,6 @@ public class MySQLDB extends SQLDB {
returnToPool(connection);
}
- @Override
- public boolean isUsingMySQL() {
- return true;
- }
-
@Override
public boolean equals(Object o) {
if (this == o) return true;
diff --git a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/SQLDB.java b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/SQLDB.java
index b326913e2..b275e937b 100644
--- a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/SQLDB.java
+++ b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/SQLDB.java
@@ -419,10 +419,6 @@ public abstract class SQLDB extends Database {
return pingTable;
}
- public boolean isUsingMySQL() {
- return false;
- }
-
@Override
public BackupOperations backup() {
return backupOps;
@@ -468,12 +464,12 @@ public abstract class SQLDB extends Database {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
SQLDB sqldb = (SQLDB) o;
- return getName().equals(sqldb.getName());
+ return getType() == sqldb.getType();
}
@Override
public int hashCode() {
- return Objects.hash(getName());
+ return Objects.hash(getType().getName());
}
public Supplier getServerUUIDSupplier() {
diff --git a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/SQLiteDB.java b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/SQLiteDB.java
index 640afedd3..c5d678771 100644
--- a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/SQLiteDB.java
+++ b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/SQLiteDB.java
@@ -18,6 +18,7 @@ package com.djrapitops.plan.system.database.databases.sql;
import com.djrapitops.plan.api.exceptions.database.DBInitException;
import com.djrapitops.plan.data.store.containers.NetworkContainer;
+import com.djrapitops.plan.system.database.databases.DBType;
import com.djrapitops.plan.system.file.PlanFiles;
import com.djrapitops.plan.system.info.server.ServerInfo;
import com.djrapitops.plan.system.locale.Locale;
@@ -28,7 +29,6 @@ import com.djrapitops.plugin.benchmarking.Timings;
import com.djrapitops.plugin.logging.L;
import com.djrapitops.plugin.logging.console.PluginLogger;
import com.djrapitops.plugin.logging.error.ErrorHandler;
-import com.djrapitops.plugin.task.AbsRunnable;
import com.djrapitops.plugin.task.PluginTask;
import com.djrapitops.plugin.task.RunnableFactory;
import dagger.Lazy;
@@ -36,7 +36,9 @@ import dagger.Lazy;
import javax.inject.Inject;
import javax.inject.Singleton;
import java.io.File;
-import java.sql.*;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
import java.util.Objects;
/**
@@ -104,30 +106,9 @@ public class SQLiteDB extends SQLDB {
stopConnectionPingTask();
try {
// Maintains Connection.
- connectionPingTask = runnableFactory.create("DBConnectionPingTask " + getName(), new AbsRunnable() {
- @Override
- public void run() {
- Statement statement = null;
- ResultSet resultSet = null;
- try {
- if (connection != null && !connection.isClosed()) {
- statement = connection.createStatement();
- resultSet = statement.executeQuery("/* ping */ SELECT 1");
- }
- } catch (SQLException e) {
- logger.debug("Something went wrong during SQLite Connection upkeep task.");
- try {
- connection = getNewConnection(databaseFile);
- } catch (SQLException e1) {
- errorHandler.log(L.ERROR, this.getClass(), e1);
- logger.error("SQLite connection maintaining task had to be closed due to exception.");
- this.cancel();
- }
- } finally {
- MiscUtils.close(statement, resultSet);
- }
- }
- }).runTaskTimerAsynchronously(60L * 20L, 60L * 20L);
+ connectionPingTask = runnableFactory.create("DBConnectionPingTask " + getType().getName(),
+ new KeepAliveTask(connection, () -> getNewConnection(databaseFile), logger, errorHandler)
+ ).runTaskTimerAsynchronously(60L * 20L, 60L * 20L);
} catch (Exception ignored) {
}
}
@@ -141,12 +122,9 @@ public class SQLiteDB extends SQLDB {
}
}
- /**
- * @return the name of the Database
- */
@Override
- public String getName() {
- return "SQLite";
+ public DBType getType() {
+ return DBType.SQLite;
}
@Override
@@ -250,4 +228,5 @@ public class SQLiteDB extends SQLDB {
}
}
+
}
diff --git a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/patches/Patch.java b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/patches/Patch.java
index 70ef3d07b..35cfa9fcf 100644
--- a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/patches/Patch.java
+++ b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/patches/Patch.java
@@ -16,6 +16,7 @@
*/
package com.djrapitops.plan.system.database.databases.sql.patches;
+import com.djrapitops.plan.system.database.databases.DBType;
import com.djrapitops.plan.system.database.databases.sql.SQLDB;
import com.djrapitops.plan.system.database.databases.sql.processing.QueryAllStatement;
import com.djrapitops.plan.system.database.databases.sql.processing.QueryStatement;
@@ -30,11 +31,11 @@ import java.util.UUID;
public abstract class Patch {
protected final SQLDB db;
- protected final boolean usingMySQL;
+ protected final DBType dbType;
public Patch(SQLDB db) {
this.db = db;
- usingMySQL = db.isUsingMySQL();
+ this.dbType = db.getType();
}
public abstract boolean hasBeenApplied();
@@ -46,15 +47,25 @@ public abstract class Patch {
}
public boolean hasTable(String tableName) {
- String sql = usingMySQL ?
- "SELECT * FROM information_schema.TABLES WHERE table_name=? AND TABLE_SCHEMA=? LIMIT 1" :
- "SELECT tbl_name FROM sqlite_master WHERE tbl_name=?";
+ boolean secondParameter;
+
+ String sql;
+ if (dbType == DBType.H2) {
+ sql = "SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME=?";
+ secondParameter = false;
+ } else if (dbType.supportsMySQLQueries()) {
+ sql = "SELECT * FROM information_schema.TABLES WHERE table_name=? AND TABLE_SCHEMA=? LIMIT 1";
+ secondParameter = true;
+ } else {
+ sql = "SELECT tbl_name FROM sqlite_master WHERE tbl_name=?";
+ secondParameter = false;
+ }
return query(new QueryStatement(sql) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
statement.setString(1, tableName);
- if (usingMySQL) {
+ if (secondParameter) {
statement.setString(2, db.getConfig().getString(Settings.DB_DATABASE));
}
}
@@ -67,36 +78,49 @@ public abstract class Patch {
}
protected boolean hasColumn(String tableName, String columnName) {
- return usingMySQL ?
- query(new QueryStatement("SELECT * FROM information_schema.COLUMNS" +
- " WHERE TABLE_NAME=? AND COLUMN_NAME=? AND TABLE_SCHEMA=?") {
- @Override
- public void prepare(PreparedStatement statement) throws SQLException {
- statement.setString(1, tableName);
- statement.setString(2, columnName);
+ if (dbType.supportsMySQLQueries()) {
+ String query;
+
+ if (dbType == DBType.H2) {
+ query = "SELECT * FROM INFORMATION_SCHEMA.COLUMNS" +
+ " WHERE TABLE_NAME=? AND COLUMN_NAME=?";
+ } else {
+ query = "SELECT * FROM information_schema.COLUMNS" +
+ " WHERE TABLE_NAME=? AND COLUMN_NAME=? AND TABLE_SCHEMA=?";
+ }
+
+ return query(new QueryStatement(query) {
+ @Override
+ public void prepare(PreparedStatement statement) throws SQLException {
+ statement.setString(1, tableName);
+ statement.setString(2, columnName);
+ if (dbType != DBType.H2) {
statement.setString(3, db.getConfig().getString(Settings.DB_DATABASE));
}
+ }
- @Override
- public Boolean processResults(ResultSet set) throws SQLException {
- return set.next();
- }
- }) :
- query(new QueryAllStatement("PRAGMA table_info(" + tableName + ")") {
- @Override
- public Boolean processResults(ResultSet set) throws SQLException {
- while (set.next()) {
- if (columnName.equals(set.getString("name"))) {
- return true;
- }
+ @Override
+ public Boolean processResults(ResultSet set) throws SQLException {
+ return set.next();
+ }
+ });
+ } else {
+ return query(new QueryAllStatement("PRAGMA table_info(" + tableName + ")") {
+ @Override
+ public Boolean processResults(ResultSet set) throws SQLException {
+ while (set.next()) {
+ if (columnName.equals(set.getString("name"))) {
+ return true;
}
- return false;
}
- });
+ return false;
+ }
+ });
+ }
}
protected void addColumn(String tableName, String columnInfo) {
- db.executeUnsafe("ALTER TABLE " + tableName + " ADD " + (usingMySQL ? "" : "COLUMN ") + columnInfo);
+ db.executeUnsafe("ALTER TABLE " + tableName + " ADD " + (dbType.supportsMySQLQueries() ? "" : "COLUMN ") + columnInfo);
}
protected void dropTable(String name) {
@@ -104,7 +128,7 @@ public abstract class Patch {
}
protected void renameTable(String from, String to) {
- String sql = usingMySQL ?
+ String sql = dbType.supportsMySQLQueries() ?
"RENAME TABLE " + from + " TO " + to :
"ALTER TABLE " + from + " RENAME TO " + to;
db.execute(sql);
diff --git a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/patches/Version10Patch.java b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/patches/Version10Patch.java
index 95b7bcf85..c62e86dc9 100644
--- a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/patches/Version10Patch.java
+++ b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/patches/Version10Patch.java
@@ -109,7 +109,7 @@ public class Version10Patch extends Patch {
" FROM " + tempNickTableName;
db.execute(statement);
try {
- if (usingMySQL) {
+ if (dbType.supportsMySQLQueries()) {
db.execute("SET foreign_key_checks = 0");
}
statement = "INSERT INTO plan_kills " +
@@ -118,7 +118,7 @@ public class Version10Patch extends Patch {
" FROM " + tempKillsTableName;
db.execute(statement);
} finally {
- if (usingMySQL) {
+ if (dbType.supportsMySQLQueries()) {
db.execute("SET foreign_key_checks = 1");
}
}
diff --git a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/CommandUseTable.java b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/CommandUseTable.java
index d84f3f734..6089e880f 100644
--- a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/CommandUseTable.java
+++ b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/CommandUseTable.java
@@ -62,11 +62,11 @@ public class CommandUseTable extends Table {
public void createTable() throws DBInitException {
ServerTable serverTable = db.getServerTable();
createTable(TableSqlParser.createTable(tableName)
- .primaryKeyIDColumn(usingMySQL, Col.COMMAND_ID)
+ .primaryKeyIDColumn(supportsMySQLQueries, Col.COMMAND_ID)
.column(Col.COMMAND, Sql.varchar(20)).notNull()
.column(Col.TIMES_USED, Sql.INT).notNull()
.column(Col.SERVER_ID, Sql.INT).notNull()
- .primaryKey(usingMySQL, Col.COMMAND_ID)
+ .primaryKey(supportsMySQLQueries, Col.COMMAND_ID)
.foreignKey(Col.SERVER_ID, serverTable.toString(), ServerTable.Col.SERVER_ID)
.toString()
);
diff --git a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/NicknamesTable.java b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/NicknamesTable.java
index 33fcd2f0d..fd18df308 100644
--- a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/NicknamesTable.java
+++ b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/NicknamesTable.java
@@ -81,8 +81,6 @@ public class NicknamesTable extends UserIDTable {
/**
* Get nicknames of the user on a server.
- *
- * Get's nicknames from other servers as well.
*
* @param uuid UUID of the Player
* @param serverUUID UUID of the server
@@ -119,8 +117,6 @@ public class NicknamesTable extends UserIDTable {
/**
* Get nicknames of the user on THIS server.
- *
- * Get's nicknames from other servers as well.
*
* @param uuid UUID of the Player
* @return The nicknames of the User
diff --git a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/PingTable.java b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/PingTable.java
index 884df6cc2..1cd30549c 100644
--- a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/PingTable.java
+++ b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/PingTable.java
@@ -56,14 +56,14 @@ public class PingTable extends UserIDTable {
@Override
public void createTable() throws DBInitException {
createTable(TableSqlParser.createTable(TABLE_NAME)
- .primaryKeyIDColumn(usingMySQL, Col.ID)
+ .primaryKeyIDColumn(supportsMySQLQueries, Col.ID)
.column(Col.USER_ID, Sql.INT).notNull()
.column(Col.SERVER_ID, Sql.INT).notNull()
.column(Col.DATE, Sql.LONG).notNull()
.column(Col.MAX_PING, Sql.INT).notNull()
.column(Col.MIN_PING, Sql.INT).notNull()
.column(Col.AVG_PING, Sql.DOUBLE).notNull()
- .primaryKey(usingMySQL, Col.ID)
+ .primaryKey(supportsMySQLQueries, Col.ID)
.foreignKey(Col.USER_ID, usersTable.getTableName(), UsersTable.Col.ID)
.foreignKey(Col.SERVER_ID, ServerTable.TABLE_NAME, ServerTable.Col.SERVER_ID)
.toString());
diff --git a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/ServerTable.java b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/ServerTable.java
index f16266bf1..41ab951e3 100644
--- a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/ServerTable.java
+++ b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/ServerTable.java
@@ -63,13 +63,13 @@ public class ServerTable extends Table {
@Override
public void createTable() throws DBInitException {
createTable(TableSqlParser.createTable(tableName)
- .primaryKeyIDColumn(usingMySQL, Col.SERVER_ID)
+ .primaryKeyIDColumn(supportsMySQLQueries, Col.SERVER_ID)
.column(Col.SERVER_UUID, Sql.varchar(36)).notNull().unique()
.column(Col.NAME, Sql.varchar(100))
.column(Col.WEBSERVER_ADDRESS, Sql.varchar(100))
.column(Col.INSTALLED, Sql.BOOL).notNull().defaultValue(true)
.column(Col.MAX_PLAYERS, Sql.INT).notNull().defaultValue("-1")
- .primaryKey(usingMySQL, Col.SERVER_ID)
+ .primaryKey(supportsMySQLQueries, Col.SERVER_ID)
.toString()
);
}
diff --git a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/SessionsTable.java b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/SessionsTable.java
index f54825a5f..0fb3092fc 100644
--- a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/SessionsTable.java
+++ b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/SessionsTable.java
@@ -66,7 +66,7 @@ public class SessionsTable extends UserIDTable {
@Override
public void createTable() throws DBInitException {
createTable(TableSqlParser.createTable(this.tableName)
- .primaryKeyIDColumn(usingMySQL, Col.ID)
+ .primaryKeyIDColumn(supportsMySQLQueries, Col.ID)
.column(Col.USER_ID, Sql.INT).notNull()
.column(Col.SERVER_ID, Sql.INT).notNull()
.column(Col.SESSION_START, Sql.LONG).notNull()
@@ -76,7 +76,7 @@ public class SessionsTable extends UserIDTable {
.column(Col.AFK_TIME, Sql.LONG).notNull()
.foreignKey(Col.USER_ID, usersTable.getTableName(), UsersTable.Col.ID)
.foreignKey(Col.SERVER_ID, serverTable.getTableName(), ServerTable.Col.SERVER_ID)
- .primaryKey(usingMySQL, Col.ID)
+ .primaryKey(supportsMySQLQueries, Col.ID)
.toString()
);
}
diff --git a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/Table.java b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/Table.java
index 1c81944a2..3e70f739b 100644
--- a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/Table.java
+++ b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/Table.java
@@ -37,7 +37,7 @@ public abstract class Table {
protected final String tableName;
protected final SQLDB db;
- protected final boolean usingMySQL;
+ protected final boolean supportsMySQLQueries;
/**
* Constructor.
@@ -48,7 +48,7 @@ public abstract class Table {
public Table(String name, SQLDB db) {
this.tableName = name;
this.db = db;
- this.usingMySQL = db != null && db.isUsingMySQL();
+ this.supportsMySQLQueries = db != null && db.getType().supportsMySQLQueries();
}
public abstract void createTable() throws DBInitException;
@@ -118,13 +118,13 @@ public abstract class Table {
protected void addColumns(String... columnInfo) {
for (int i = 0; i < columnInfo.length; i++) {
- columnInfo[i] = "ALTER TABLE " + tableName + " ADD " + (usingMySQL ? "" : "COLUMN ") + columnInfo[i];
+ columnInfo[i] = "ALTER TABLE " + tableName + " ADD " + (supportsMySQLQueries ? "" : "COLUMN ") + columnInfo[i];
}
executeUnsafe(columnInfo);
}
protected void removeColumns(String... columnNames) {
- if (usingMySQL) {
+ if (supportsMySQLQueries) {
StringBuilder sqlBuild = new StringBuilder();
sqlBuild.append("ALTER TABLE ").append(tableName);
for (int i = 0; i < columnNames.length; i++) {
@@ -147,7 +147,7 @@ public abstract class Table {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Table table = (Table) o;
- return usingMySQL == table.usingMySQL &&
+ return supportsMySQLQueries == table.supportsMySQLQueries &&
Objects.equal(tableName, table.tableName) &&
Objects.equal(db, table.db);
}
@@ -162,7 +162,7 @@ public abstract class Table {
@Override
public int hashCode() {
- return Objects.hashCode(tableName, db, usingMySQL);
+ return Objects.hashCode(tableName, db, supportsMySQLQueries);
}
protected boolean execute(ExecStatement statement) {
diff --git a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/TransferTable.java b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/TransferTable.java
index 8215b95d8..83ac9fa27 100644
--- a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/TransferTable.java
+++ b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/TransferTable.java
@@ -17,6 +17,7 @@
package com.djrapitops.plan.system.database.databases.sql.tables;
import com.djrapitops.plan.api.exceptions.database.DBInitException;
+import com.djrapitops.plan.system.database.databases.DBType;
import com.djrapitops.plan.system.database.databases.sql.SQLDB;
import com.djrapitops.plan.system.database.databases.sql.processing.ExecStatement;
import com.djrapitops.plan.system.database.databases.sql.processing.QueryStatement;
@@ -51,15 +52,33 @@ public class TransferTable extends Table {
super(TABLE_NAME, db);
serverTable = db.getServerTable();
- insertStatementNoParts = "REPLACE INTO " + tableName + " (" +
- Col.SENDER_ID + ", " +
- Col.EXPIRY + ", " +
- Col.INFO_TYPE + ", " +
- Col.EXTRA_VARIABLES + ", " +
- Col.CONTENT +
- ") VALUES (" +
- serverTable.statementSelectServerID + ", " +
- "?, ?, ?, ?)";
+
+ if (db.getType() == DBType.H2) {
+ insertStatementNoParts = "INSERT INTO " + tableName + " (" +
+ Col.SENDER_ID + ", " +
+ Col.EXPIRY + ", " +
+ Col.INFO_TYPE + ", " +
+ Col.EXTRA_VARIABLES + ", " +
+ Col.CONTENT +
+ ") VALUES (" +
+ serverTable.statementSelectServerID + ", " +
+ "?, ?, ?, ?)" +
+ " ON DUPLICATE KEY UPDATE" +
+ " " + Col.EXPIRY + "=?," +
+ " " + Col.INFO_TYPE + "=?," +
+ " " + Col.EXTRA_VARIABLES + "=?," +
+ " " + Col.CONTENT + "=?";
+ } else {
+ insertStatementNoParts = "REPLACE INTO " + tableName + " (" +
+ Col.SENDER_ID + ", " +
+ Col.EXPIRY + ", " +
+ Col.INFO_TYPE + ", " +
+ Col.EXTRA_VARIABLES + ", " +
+ Col.CONTENT +
+ ") VALUES (" +
+ serverTable.statementSelectServerID + ", " +
+ "?, ?, ?, ?)";
+ }
selectStatement = "SELECT * FROM " + tableName +
" WHERE " + Col.INFO_TYPE + "= ?" +
@@ -75,7 +94,7 @@ public class TransferTable extends Table {
.column(Col.EXPIRY, Sql.LONG).notNull().defaultValue("0")
.column(Col.INFO_TYPE, Sql.varchar(100)).notNull()
.column(Col.EXTRA_VARIABLES, Sql.varchar(255)).defaultValue("''")
- .column(Col.CONTENT, usingMySQL ? "MEDIUMTEXT" : Sql.varchar(1)) // SQLite does not enforce varchar limits.
+ .column(Col.CONTENT, supportsMySQLQueries ? "MEDIUMTEXT" : Sql.varchar(1)) // SQLite does not enforce varchar limits.
.column(Col.PART, Sql.LONG).notNull().defaultValue("0")
.foreignKey(Col.SENDER_ID, serverTable.toString(), ServerTable.Col.SERVER_ID)
.toString()
@@ -111,11 +130,21 @@ public class TransferTable extends Table {
execute(new ExecStatement(insertStatementNoParts) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
+ long expiration = System.currentTimeMillis() + TimeUnit.HOURS.toMillis(1L);
+
statement.setString(1, getServerUUID().toString());
- statement.setLong(2, System.currentTimeMillis() + TimeUnit.HOURS.toMillis(1L));
+ statement.setLong(2, expiration);
statement.setString(3, "configSettings");
statement.setString(4, null);
statement.setString(5, encodedSettingString);
+
+ if (db.getType() == DBType.H2) {
+ statement.setLong(6, expiration);
+ statement.setString(7, "configSettings");
+ statement.setString(8, null);
+ statement.setString(9, encodedSettingString);
+
+ }
}
});
}
diff --git a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/UserInfoTable.java b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/UserInfoTable.java
index 723a4aa04..f3c861c07 100644
--- a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/UserInfoTable.java
+++ b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/UserInfoTable.java
@@ -64,7 +64,7 @@ public class UserInfoTable extends UserIDTable {
public void registerUserInfo(UUID uuid, long registered) {
if (!usersTable.isRegistered(uuid)) {
- usersTable.registerUser(uuid, registered, "Waiting for Update..");
+ usersTable.registerUser(uuid, registered, "waitingForUpdate");
}
String sql = "INSERT INTO " + tableName + " (" +
diff --git a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/UsersTable.java b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/UsersTable.java
index 479bf72c9..26a7d15b4 100644
--- a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/UsersTable.java
+++ b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/UsersTable.java
@@ -59,12 +59,12 @@ public class UsersTable extends UserIDTable {
@Override
public void createTable() throws DBInitException {
createTable(TableSqlParser.createTable(tableName)
- .primaryKeyIDColumn(usingMySQL, Col.ID)
+ .primaryKeyIDColumn(supportsMySQLQueries, Col.ID)
.column(Col.UUID, Sql.varchar(36)).notNull().unique()
.column(Col.REGISTERED, Sql.LONG).notNull()
.column(Col.USER_NAME, Sql.varchar(16)).notNull()
.column(Col.TIMES_KICKED, Sql.INT).notNull().defaultValue("0")
- .primaryKey(usingMySQL, Col.ID)
+ .primaryKey(supportsMySQLQueries, Col.ID)
.toString()
);
}
@@ -261,13 +261,13 @@ public class UsersTable extends UserIDTable {
* @return a list of distinct names.
*/
public List getMatchingNames(String name) {
- String searchString = "%" + name.toLowerCase() + "%";
+ String searchString = "%" + name + "%";
NicknamesTable nicknamesTable = db.getNicknamesTable();
String sql = "SELECT DISTINCT " + Col.USER_NAME + " FROM " + tableName +
- " WHERE " + Col.USER_NAME + " LIKE ?" +
+ " WHERE LOWER(" + Col.USER_NAME + ") LIKE LOWER(?)" +
" UNION SELECT DISTINCT " + Col.USER_NAME + " FROM " + tableName +
" INNER JOIN " + nicknamesTable + " on " + Col.ID + "=" + nicknamesTable + "." + NicknamesTable.Col.USER_ID +
- " WHERE " + NicknamesTable.Col.NICKNAME + " LIKE ?";
+ " WHERE LOWER(" + NicknamesTable.Col.NICKNAME + ") LIKE LOWER(?)";
return query(new QueryStatement>(sql, 5000) {
@Override
diff --git a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/WorldTable.java b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/WorldTable.java
index e0c8ecc0c..24c0817e3 100644
--- a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/WorldTable.java
+++ b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/WorldTable.java
@@ -57,10 +57,10 @@ public class WorldTable extends Table {
@Override
public void createTable() throws DBInitException {
createTable(TableSqlParser.createTable(tableName)
- .primaryKeyIDColumn(usingMySQL, Col.ID)
+ .primaryKeyIDColumn(supportsMySQLQueries, Col.ID)
.column(Col.NAME, Sql.varchar(100)).notNull()
.column(Col.SERVER_ID, Sql.INT).notNull()
- .primaryKey(usingMySQL, Col.ID)
+ .primaryKey(supportsMySQLQueries, Col.ID)
.foreignKey(Col.SERVER_ID, ServerTable.TABLE_NAME, ServerTable.Col.SERVER_ID)
.toString()
);
diff --git a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/move/TransferTable.java b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/move/TransferTable.java
index ac197a1d7..7a9b8279d 100644
--- a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/move/TransferTable.java
+++ b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/move/TransferTable.java
@@ -37,7 +37,7 @@ public class TransferTable extends Table {
}
protected void renameTable(String from, String to) {
- String sql = usingMySQL ?
+ String sql = supportsMySQLQueries ?
"RENAME TABLE " + from + " TO " + to :
"ALTER TABLE " + from + " RENAME TO " + to;
execute(sql);
diff --git a/Plan/src/main/java/com/djrapitops/plan/system/webserver/response/pages/PageResponse.java b/Plan/src/main/java/com/djrapitops/plan/system/webserver/response/pages/PageResponse.java
index fb1a54016..3666c815e 100644
--- a/Plan/src/main/java/com/djrapitops/plan/system/webserver/response/pages/PageResponse.java
+++ b/Plan/src/main/java/com/djrapitops/plan/system/webserver/response/pages/PageResponse.java
@@ -27,6 +27,12 @@ import com.googlecode.htmlcompressor.compressor.HtmlCompressor;
*/
public class PageResponse extends Response {
+ private static final HtmlCompressor HTML_COMPRESSOR = new HtmlCompressor();
+
+ static {
+ HTML_COMPRESSOR.setRemoveIntertagSpaces(true);
+ }
+
public PageResponse(ResponseType type) {
super(type);
}
@@ -36,8 +42,6 @@ public class PageResponse extends Response {
@Override
public void setContent(String content) {
- HtmlCompressor compressor = new HtmlCompressor();
- compressor.setRemoveIntertagSpaces(true);
- super.setContent(compressor.compress(content));
+ super.setContent(HTML_COMPRESSOR.compress(content));
}
}
\ No newline at end of file
diff --git a/Plan/src/main/java/com/djrapitops/plan/utilities/html/pages/DebugPage.java b/Plan/src/main/java/com/djrapitops/plan/utilities/html/pages/DebugPage.java
index af011080a..c9a4efd9e 100644
--- a/Plan/src/main/java/com/djrapitops/plan/utilities/html/pages/DebugPage.java
+++ b/Plan/src/main/java/com/djrapitops/plan/utilities/html/pages/DebugPage.java
@@ -227,7 +227,7 @@ public class DebugPage implements Page {
.append(" (").append(serverProperties.getVersion());
content.append(")
");
- content.append("**Database:** ").append(database.getName());
+ content.append("**Database:** ").append(database.getType().getName());
content.append("
");
Properties properties = System.getProperties();
diff --git a/Plan/src/main/java/com/djrapitops/plan/utilities/metrics/BStatsBukkit.java b/Plan/src/main/java/com/djrapitops/plan/utilities/metrics/BStatsBukkit.java
index da84858f1..ddc99f063 100644
--- a/Plan/src/main/java/com/djrapitops/plan/utilities/metrics/BStatsBukkit.java
+++ b/Plan/src/main/java/com/djrapitops/plan/utilities/metrics/BStatsBukkit.java
@@ -41,7 +41,7 @@ public class BStatsBukkit {
if ("CraftBukkit".equals(serverType) && Check.isSpigotAvailable()) {
serverType = "Spigot";
}
- String databaseType = plugin.getSystem().getDatabaseSystem().getDatabase().getName();
+ String databaseType = plugin.getSystem().getDatabaseSystem().getDatabase().getType().getName();
addStringSettingPie("server_type", serverType);
addStringSettingPie("database_type", databaseType);
diff --git a/Plan/src/main/java/com/djrapitops/plan/utilities/metrics/BStatsBungee.java b/Plan/src/main/java/com/djrapitops/plan/utilities/metrics/BStatsBungee.java
index bece703b7..a6e719c09 100644
--- a/Plan/src/main/java/com/djrapitops/plan/utilities/metrics/BStatsBungee.java
+++ b/Plan/src/main/java/com/djrapitops/plan/utilities/metrics/BStatsBungee.java
@@ -46,7 +46,7 @@ public class BStatsBungee {
private void registerConfigSettingGraphs() {
String serverType = plugin.getProxy().getName();
- String databaseType = database.getName();
+ String databaseType = database.getType().getName();
addStringSettingPie("server_type", serverType);
addStringSettingPie("database_type", databaseType);
diff --git a/Plan/src/main/java/com/djrapitops/plan/utilities/metrics/BStatsSponge.java b/Plan/src/main/java/com/djrapitops/plan/utilities/metrics/BStatsSponge.java
index 911330b03..0a5b795b6 100644
--- a/Plan/src/main/java/com/djrapitops/plan/utilities/metrics/BStatsSponge.java
+++ b/Plan/src/main/java/com/djrapitops/plan/utilities/metrics/BStatsSponge.java
@@ -39,7 +39,7 @@ public class BStatsSponge {
private void registerConfigSettingGraphs() {
String serverType = "Sponge";
- String databaseType = database.getName();
+ String databaseType = database.getType().getName();
addStringSettingPie("server_type", serverType);
addStringSettingPie("database_type", databaseType);
diff --git a/Plan/src/test/java/com/djrapitops/plan/data/PlayerKillTest.java b/Plan/src/test/java/com/djrapitops/plan/data/PlayerKillTest.java
index d1d252fa2..a676f02f1 100644
--- a/Plan/src/test/java/com/djrapitops/plan/data/PlayerKillTest.java
+++ b/Plan/src/test/java/com/djrapitops/plan/data/PlayerKillTest.java
@@ -1,7 +1,18 @@
/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
+ * This file is part of Player Analytics (Plan).
+ *
+ * Plan is free software: you can redistribute it and/or modify
+ * it under the terms of the LGNU Lesser General Public License v3 as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Plan is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * LGNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Plan. If not, see .
*/
package com.djrapitops.plan.data;
diff --git a/Plan/src/test/java/com/djrapitops/plan/system/database/databases/CommonDBTest.java b/Plan/src/test/java/com/djrapitops/plan/system/database/databases/CommonDBTest.java
new file mode 100644
index 000000000..8334cc45a
--- /dev/null
+++ b/Plan/src/test/java/com/djrapitops/plan/system/database/databases/CommonDBTest.java
@@ -0,0 +1,1058 @@
+/*
+ * This file is part of Player Analytics (Plan).
+ *
+ * Plan is free software: you can redistribute it and/or modify
+ * it under the terms of the LGNU Lesser General Public License v3 as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Plan is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * LGNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Plan. If not, see .
+ */
+package com.djrapitops.plan.system.database.databases;
+
+import com.djrapitops.plan.DaggerPlanBukkitComponent;
+import com.djrapitops.plan.PlanBukkitComponent;
+import com.djrapitops.plan.api.exceptions.database.DBInitException;
+import com.djrapitops.plan.data.WebUser;
+import com.djrapitops.plan.data.container.*;
+import com.djrapitops.plan.data.store.Key;
+import com.djrapitops.plan.data.store.containers.AnalysisContainer;
+import com.djrapitops.plan.data.store.containers.NetworkContainer;
+import com.djrapitops.plan.data.store.containers.PlayerContainer;
+import com.djrapitops.plan.data.store.containers.ServerContainer;
+import com.djrapitops.plan.data.store.keys.*;
+import com.djrapitops.plan.data.store.objects.Nickname;
+import com.djrapitops.plan.data.time.GMTimes;
+import com.djrapitops.plan.data.time.WorldTimes;
+import com.djrapitops.plan.system.PlanSystem;
+import com.djrapitops.plan.system.database.DBSystem;
+import com.djrapitops.plan.system.database.databases.sql.H2DB;
+import com.djrapitops.plan.system.database.databases.sql.SQLDB;
+import com.djrapitops.plan.system.database.databases.sql.tables.*;
+import com.djrapitops.plan.system.info.server.Server;
+import com.djrapitops.plan.system.settings.Settings;
+import com.djrapitops.plan.utilities.Base64Util;
+import com.djrapitops.plan.utilities.SHA256Hash;
+import org.junit.*;
+import org.junit.rules.TemporaryFolder;
+import org.junit.rules.Timeout;
+import utilities.OptionalAssert;
+import utilities.RandomData;
+import utilities.TestConstants;
+import utilities.mocks.PlanBukkitMocker;
+
+import java.io.File;
+import java.lang.management.ManagementFactory;
+import java.lang.management.OperatingSystemMXBean;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.security.NoSuchAlgorithmException;
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.Assert.*;
+
+/**
+ * Contains all common Database Tests for all Database Types
+ *
+ * @author Fuzzlemann
+ * @since 4.5.1
+ */
+public abstract class CommonDBTest {
+
+ @ClassRule
+ public static TemporaryFolder temporaryFolder = new TemporaryFolder();
+ public static DBSystem dbSystem;
+ public static SQLDB db;
+ public static PlanSystem system;
+
+ public final List worlds = Arrays.asList("TestWorld", "TestWorld2");
+ public final UUID playerUUID = TestConstants.PLAYER_ONE_UUID;
+ public final UUID player2UUID = TestConstants.PLAYER_TWO_UUID;
+ public final UUID serverUUID = TestConstants.SERVER_UUID;
+
+ @Rule
+ public Timeout globalTimeout = Timeout.seconds(5);
+
+ public static void handleSetup(String dbName) throws Exception {
+ System.out.println("--- Test Class Setup ---");
+ PlanBukkitMocker mockUtil = PlanBukkitMocker.setUp()
+ .withDataFolder(temporaryFolder.newFolder())
+ .withPluginDescription()
+ .withResourceFetchingFromJar()
+ .withServer();
+ PlanBukkitComponent component = DaggerPlanBukkitComponent.builder().plan(mockUtil.getPlanMock()).build();
+ system = component.system();
+ system.getConfigSystem().getConfig().set(Settings.WEBSERVER_PORT, 9005);
+ system.enable();
+
+ dbSystem = system.getDatabaseSystem();
+ db = (SQLDB) dbSystem.getActiveDatabaseByName(dbName);
+
+ db.init();
+ System.out.println("--- Class Setup Complete ---\n");
+ }
+
+ @AfterClass
+ public static void tearDownClass() {
+ system.disable();
+ }
+
+ @Before
+ public void setUp() {
+ System.out.println("\n-- Clearing Test Database --");
+ db.remove().everything();
+ ServerTable serverTable = db.getServerTable();
+ serverTable.saveCurrentServerInfo(new Server(-1, TestConstants.SERVER_UUID, "ServerName", "", 20));
+ assertEquals(db.getServerUUIDSupplier().get(), TestConstants.SERVER_UUID);
+ System.out.println("-- Clear Complete --\n");
+ }
+
+ public void commitTest() throws DBInitException {
+ db.close();
+ db.init();
+ }
+
+ @Test
+ public void testNoExceptionWhenCommitEmpty() throws Exception {
+ db.commit(db.getConnection());
+ db.commit(db.getConnection());
+ db.commit(db.getConnection());
+ }
+
+ @Test(timeout = 3000)
+ public void testSaveCommandUse() throws DBInitException {
+ CommandUseTable commandUseTable = db.getCommandUseTable();
+ Map expected = new HashMap<>();
+
+ expected.put("plan", 1);
+ expected.put("tp", 4);
+ expected.put("pla", 7);
+ expected.put("help", 21);
+
+ commandUseTable.commandUsed("plan");
+
+ for (int i = 0; i < 4; i++) {
+ commandUseTable.commandUsed("tp");
+ }
+
+ for (int i = 0; i < 7; i++) {
+ commandUseTable.commandUsed("pla");
+ }
+
+ for (int i = 0; i < 21; i++) {
+ commandUseTable.commandUsed("help");
+ }
+
+ for (int i = 0; i < 3; i++) {
+ commandUseTable.commandUsed("roiergbnougbierubieugbeigubeigubgierbgeugeg");
+ }
+
+ commitTest();
+
+ Map commandUse = db.getCommandUseTable().getCommandUse();
+ assertEquals(expected, commandUse);
+
+ for (int i = 0; i < 3; i++) {
+ commandUseTable.commandUsed("test");
+ }
+
+ for (int i = 0; i < 2; i++) {
+ commandUseTable.commandUsed("tp");
+ }
+
+ expected.put("test", 3);
+ expected.put("tp", 6);
+
+ commandUse = db.getCommandUseTable().getCommandUse();
+
+ assertEquals(expected, commandUse);
+ }
+
+ @Test
+ public void testCommandUseTableIDSystem() {
+ CommandUseTable commandUseTable = db.getCommandUseTable();
+ commandUseTable.commandUsed("plan");
+
+ for (int i = 0; i < 4; i++) {
+ commandUseTable.commandUsed("tp");
+ }
+
+ for (int i = 0; i < 7; i++) {
+ commandUseTable.commandUsed("pla");
+ }
+
+ for (int i = 0; i < 21; i++) {
+ commandUseTable.commandUsed("help");
+ }
+
+ for (int i = 0; i < 3; i++) {
+ commandUseTable.commandUsed("roiergbnougbierubieugbeigubeigubgierbgeugeg");
+ }
+
+ Optional id = commandUseTable.getCommandID("plan");
+
+ assertTrue(id.isPresent());
+
+ Optional commandByID = commandUseTable.getCommandByID(id.get());
+
+ assertTrue(commandByID.isPresent());
+ assertEquals("plan", commandByID.get());
+ assertFalse(commandUseTable.getCommandID("roiergbnougbierubieugbeigubeigubgierbgeugeg").isPresent());
+ }
+
+ @Test
+ public void testTPSSaving() throws Exception {
+ TPSTable tpsTable = db.getTpsTable();
+ Random r = new Random();
+
+ List expected = new ArrayList<>();
+
+ for (int i = 0; i < RandomData.randomInt(1, 5); i++) {
+ expected.add(new TPS(r.nextLong(), r.nextDouble(), r.nextInt(100000000), r.nextDouble(), r.nextLong(), r.nextInt(), r.nextInt(), r.nextLong()));
+ }
+
+ for (TPS tps : expected) {
+ tpsTable.insertTPS(tps);
+ }
+
+ commitTest();
+
+ assertEquals(expected, tpsTable.getTPSData());
+ }
+
+ private void saveUserOne() {
+ saveUserOne(db);
+ }
+
+ private void saveUserOne(SQLDB database) {
+ database.getUsersTable().registerUser(playerUUID, 123456789L, "Test");
+ database.getUsersTable().kicked(playerUUID);
+ }
+
+ private void saveUserTwo() {
+ saveUserTwo(db);
+ }
+
+ private void saveUserTwo(SQLDB database) {
+ database.getUsersTable().registerUser(player2UUID, 123456789L, "Test");
+ }
+
+ @Test
+ public void testIPTable() throws DBInitException {
+ saveUserOne();
+ GeoInfoTable geoInfoTable = db.getGeoInfoTable();
+
+ String expectedIP = "1.2.3.4";
+ String expectedGeoLoc = "TestLocation";
+ long time = System.currentTimeMillis();
+
+ GeoInfo expected = new GeoInfo(expectedIP, expectedGeoLoc, time, "3");
+ geoInfoTable.saveGeoInfo(playerUUID, expected);
+ geoInfoTable.saveGeoInfo(playerUUID, expected);
+ commitTest();
+
+ List getInfo = geoInfoTable.getGeoInfo(playerUUID);
+ assertEquals(1, getInfo.size());
+ GeoInfo actual = getInfo.get(0);
+ assertEquals(expected, actual);
+ assertEquals(time, actual.getDate());
+
+ Optional result = geoInfoTable.getGeolocation(expectedIP);
+ assertTrue(result.isPresent());
+ assertEquals(expectedGeoLoc, result.get());
+ }
+
+ @Test
+ public void testNicknamesTable() throws DBInitException {
+ saveUserOne();
+ NicknamesTable nickTable = db.getNicknamesTable();
+
+ Nickname expected = new Nickname("TestNickname", System.currentTimeMillis(), TestConstants.SERVER_UUID);
+ nickTable.saveUserName(playerUUID, expected);
+ nickTable.saveUserName(playerUUID, expected);
+ commitTest();
+
+ List nicknames = nickTable.getNicknameInformation(playerUUID);
+ assertEquals(1, nicknames.size());
+ assertEquals(expected, nicknames.get(0));
+ }
+
+ @Test
+ public void testSecurityTable() throws DBInitException {
+ SecurityTable securityTable = db.getSecurityTable();
+ WebUser expected = new WebUser("Test", "RandomGarbageBlah", 0);
+ securityTable.addNewUser(expected);
+ commitTest();
+
+ assertTrue(securityTable.userExists("Test"));
+ WebUser test = securityTable.getWebUser("Test");
+ assertEquals(expected, test);
+
+ assertFalse(securityTable.userExists("NotExist"));
+ assertNull(securityTable.getWebUser("NotExist"));
+
+ assertEquals(1, securityTable.getUsers().size());
+
+ securityTable.removeUser("Test");
+ assertFalse(securityTable.userExists("Test"));
+ assertNull(securityTable.getWebUser("Test"));
+
+ assertEquals(0, securityTable.getUsers().size());
+ }
+
+ @Test
+ public void testWorldTable() throws DBInitException {
+ WorldTable worldTable = db.getWorldTable();
+ List worlds = Arrays.asList("Test", "Test2", "Test3");
+ worldTable.saveWorlds(worlds);
+
+ commitTest();
+
+ List saved = worldTable.getAllWorlds();
+ assertEquals(new HashSet<>(worlds), new HashSet<>(saved));
+ }
+
+ private void saveTwoWorlds() {
+ saveTwoWorlds(db);
+ }
+
+ private void saveTwoWorlds(SQLDB database) {
+ database.getWorldTable().saveWorlds(worlds);
+ }
+
+ private WorldTimes createWorldTimes() {
+ Map times = new HashMap<>();
+ Map gm = new HashMap<>();
+ String[] gms = GMTimes.getGMKeyArray();
+ gm.put(gms[0], 1000L);
+ gm.put(gms[1], 2000L);
+ gm.put(gms[2], 3000L);
+ gm.put(gms[3], 4000L);
+ times.put(worlds.get(0), new GMTimes(gm));
+
+ return new WorldTimes(times);
+ }
+
+ private List createKills() {
+ List kills = new ArrayList<>();
+ kills.add(new PlayerKill(TestConstants.PLAYER_TWO_UUID, "Iron Sword", 4321L));
+ kills.add(new PlayerKill(TestConstants.PLAYER_TWO_UUID, "Gold Sword", 5321L));
+ return kills;
+ }
+
+ @Test
+ public void testSessionPlaytimeSaving() throws DBInitException {
+ saveTwoWorlds();
+ saveUserOne();
+ saveUserTwo();
+ Session session = new Session(TestConstants.PLAYER_ONE_UUID, serverUUID, 12345L, "", "");
+ session.endSession(22345L);
+ session.setWorldTimes(createWorldTimes());
+ session.setPlayerKills(createKills());
+
+ long expectedLength = 10000L;
+ assertEquals(expectedLength, session.getLength());
+ assertEquals(expectedLength, session.getUnsafe(SessionKeys.WORLD_TIMES).getTotal());
+
+ SessionsTable sessionsTable = db.getSessionsTable();
+ sessionsTable.saveSession(playerUUID, session);
+
+ commitTest();
+
+ assertEquals(expectedLength, sessionsTable.getPlaytime(playerUUID));
+ assertEquals(0L, sessionsTable.getPlaytime(playerUUID, 30000L));
+
+ UUID serverUUID = TestConstants.SERVER_UUID;
+ long playtimeOfServer = sessionsTable.getPlaytimeOfServer(serverUUID);
+ assertEquals(expectedLength, playtimeOfServer);
+ assertEquals(0L, sessionsTable.getPlaytimeOfServer(serverUUID, 30000L));
+
+ assertEquals(1, sessionsTable.getSessionCount(playerUUID));
+ assertEquals(0, sessionsTable.getSessionCount(playerUUID, 30000L));
+ }
+
+ @Test
+ public void testSessionSaving() throws DBInitException {
+ saveUserOne();
+ saveUserTwo();
+
+ Session session = new Session(TestConstants.PLAYER_ONE_UUID, serverUUID, 12345L, "", "");
+ session.endSession(22345L);
+ session.setWorldTimes(createWorldTimes());
+ session.setPlayerKills(createKills());
+
+ SessionsTable sessionsTable = db.getSessionsTable();
+ sessionsTable.saveSession(playerUUID, session);
+
+ commitTest();
+
+ Map> sessions = sessionsTable.getSessions(playerUUID);
+
+ for (Map.Entry> entry : sessions.entrySet()) {
+ UUID key = entry.getKey();
+ if (key == null) {
+ System.out.print("null");
+ } else {
+ System.out.print(key);
+ }
+ System.out.println(" " + entry.getValue());
+ }
+
+ List savedSessions = sessions.get(serverUUID);
+
+ assertNotNull(savedSessions);
+ assertEquals(1, savedSessions.size());
+ assertNull(sessions.get(UUID.randomUUID()));
+
+ assertEquals(session, savedSessions.get(0));
+
+ Map lastSeen = sessionsTable.getLastSeenForAllPlayers();
+ assertTrue(lastSeen.containsKey(playerUUID));
+ assertFalse(lastSeen.containsKey(TestConstants.PLAYER_TWO_UUID));
+ assertEquals(22345L, (long) lastSeen.get(playerUUID));
+ }
+
+ @Test
+ public void testUserInfoTableRegisterUnRegistered() throws DBInitException {
+ UserInfoTable userInfoTable = db.getUserInfoTable();
+ assertFalse(userInfoTable.isRegistered(playerUUID));
+ UsersTable usersTable = db.getUsersTable();
+ assertFalse(usersTable.isRegistered(playerUUID));
+
+ userInfoTable.registerUserInfo(playerUUID, 123456789L);
+
+ commitTest();
+
+ assertTrue(usersTable.isRegistered(playerUUID));
+ assertTrue(userInfoTable.isRegistered(playerUUID));
+
+ UserInfo userInfo = userInfoTable.getUserInfo(playerUUID);
+ assertEquals(playerUUID, userInfo.getUuid());
+ assertEquals(123456789L, (long) usersTable.getRegisterDates().get(0));
+ assertEquals(123456789L, userInfo.getRegistered());
+ assertEquals(1, userInfoTable.getServerUserCount(serverUUID));
+ assertEquals("waitingForUpdate", userInfo.getName());
+ assertFalse(userInfo.isBanned());
+ assertFalse(userInfo.isOperator());
+ }
+
+ @Test
+ public void testUserInfoTableRegisterRegistered() throws DBInitException {
+ saveUserOne();
+ UsersTable usersTable = db.getUsersTable();
+ assertTrue(usersTable.isRegistered(playerUUID));
+
+ UserInfoTable userInfoTable = db.getUserInfoTable();
+ assertFalse(userInfoTable.isRegistered(playerUUID));
+
+ userInfoTable.registerUserInfo(playerUUID, 223456789L);
+ commitTest();
+
+ assertTrue(usersTable.isRegistered(playerUUID));
+ assertTrue(userInfoTable.isRegistered(playerUUID));
+
+ UserInfo userInfo = userInfoTable.getUserInfo(playerUUID);
+ assertEquals(playerUUID, userInfo.getUuid());
+ assertEquals(123456789L, (long) usersTable.getRegisterDates().get(0));
+ assertEquals(223456789L, userInfo.getRegistered());
+ assertEquals("Test", userInfo.getName());
+ assertFalse(userInfo.isBanned());
+ assertFalse(userInfo.isOperator());
+
+ assertEquals(userInfo, userInfoTable.getServerUserInfo().get(0));
+ }
+
+ @Test
+ public void testUserInfoTableUpdateBannedOpped() throws DBInitException {
+ UserInfoTable userInfoTable = db.getUserInfoTable();
+ userInfoTable.registerUserInfo(playerUUID, 223456789L);
+ assertTrue(userInfoTable.isRegistered(playerUUID));
+
+ userInfoTable.updateOpStatus(playerUUID, true);
+ userInfoTable.updateBanStatus(playerUUID, true);
+ commitTest();
+
+ UserInfo userInfo = userInfoTable.getUserInfo(playerUUID);
+ assertTrue(userInfo.isBanned());
+ assertTrue(userInfo.isOperator());
+
+ userInfoTable.updateOpStatus(playerUUID, false);
+ userInfoTable.updateBanStatus(playerUUID, true);
+ commitTest();
+
+ userInfo = userInfoTable.getUserInfo(playerUUID);
+
+ assertTrue(userInfo.isBanned());
+ assertFalse(userInfo.isOperator());
+
+ userInfoTable.updateOpStatus(playerUUID, true);
+ userInfoTable.updateBanStatus(playerUUID, false);
+ commitTest();
+
+ userInfo = userInfoTable.getUserInfo(playerUUID);
+
+ assertFalse(userInfo.isBanned());
+ assertTrue(userInfo.isOperator());
+ }
+
+ @Test
+ public void testUsersTableUpdateName() throws DBInitException {
+ saveUserOne();
+
+ UsersTable usersTable = db.getUsersTable();
+
+ assertEquals(playerUUID, usersTable.getUuidOf("Test"));
+ usersTable.updateName(playerUUID, "NewName");
+
+ commitTest();
+
+ assertNull(usersTable.getUuidOf("Test"));
+
+ assertEquals("NewName", usersTable.getPlayerName(playerUUID));
+ assertEquals(playerUUID, usersTable.getUuidOf("NewName"));
+ }
+
+ @Test
+ public void testUsersTableKickSaving() throws DBInitException {
+ saveUserOne();
+ UsersTable usersTable = db.getUsersTable();
+ assertEquals(1, usersTable.getTimesKicked(playerUUID));
+
+ int random = new Random().nextInt(20);
+
+ for (int i = 0; i < random + 1; i++) {
+ usersTable.kicked(playerUUID);
+ }
+ commitTest();
+ assertEquals(random + 2, usersTable.getTimesKicked(playerUUID));
+ }
+
+ @Test
+ public void testRemovalSingleUser() {
+ saveUserTwo();
+
+ UserInfoTable userInfoTable = db.getUserInfoTable();
+ UsersTable usersTable = db.getUsersTable();
+ SessionsTable sessionsTable = db.getSessionsTable();
+ NicknamesTable nicknamesTable = db.getNicknamesTable();
+ GeoInfoTable geoInfoTable = db.getGeoInfoTable();
+
+ userInfoTable.registerUserInfo(playerUUID, 223456789L);
+ saveTwoWorlds();
+
+ Session session = new Session(TestConstants.PLAYER_ONE_UUID, serverUUID, 12345L, "", "");
+ session.endSession(22345L);
+ session.setWorldTimes(createWorldTimes());
+ session.setPlayerKills(createKills());
+
+ sessionsTable.saveSession(playerUUID, session);
+ nicknamesTable.saveUserName(playerUUID, new Nickname("TestNick", System.currentTimeMillis(), TestConstants.SERVER_UUID));
+ geoInfoTable.saveGeoInfo(playerUUID, new GeoInfo("1.2.3.4", "TestLoc", 223456789L, "3"));
+
+ assertTrue(usersTable.isRegistered(playerUUID));
+
+ db.remove().player(playerUUID);
+
+ assertFalse(usersTable.isRegistered(playerUUID));
+ assertFalse(userInfoTable.isRegistered(playerUUID));
+ assertTrue(nicknamesTable.getNicknames(playerUUID).isEmpty());
+ assertTrue(geoInfoTable.getGeoInfo(playerUUID).isEmpty());
+ assertTrue(sessionsTable.getSessions(playerUUID).isEmpty());
+ }
+
+ @Test
+ public void testRemovalEverything() throws NoSuchAlgorithmException {
+ UserInfoTable userInfoTable = db.getUserInfoTable();
+ UsersTable usersTable = db.getUsersTable();
+ SessionsTable sessionsTable = db.getSessionsTable();
+ NicknamesTable nicknamesTable = db.getNicknamesTable();
+ GeoInfoTable geoInfoTable = db.getGeoInfoTable();
+ TPSTable tpsTable = db.getTpsTable();
+ SecurityTable securityTable = db.getSecurityTable();
+
+ saveAllData(db);
+
+ db.remove().everything();
+
+ assertFalse(usersTable.isRegistered(playerUUID));
+ assertFalse(usersTable.isRegistered(TestConstants.PLAYER_TWO_UUID));
+ assertFalse(userInfoTable.isRegistered(playerUUID));
+
+ assertTrue(nicknamesTable.getNicknames(playerUUID).isEmpty());
+ assertTrue(geoInfoTable.getGeoInfo(playerUUID).isEmpty());
+ assertTrue(sessionsTable.getSessions(playerUUID).isEmpty());
+ assertTrue(db.getCommandUseTable().getCommandUse().isEmpty());
+ assertTrue(db.getWorldTable().getAllWorlds().isEmpty());
+ assertTrue(tpsTable.getTPSData().isEmpty());
+ assertTrue(db.getServerTable().getBukkitServers().isEmpty());
+ assertTrue(db.getPingTable().getAllPings().isEmpty());
+ assertTrue(securityTable.getUsers().isEmpty());
+ }
+
+ private void saveAllData(SQLDB database) throws NoSuchAlgorithmException {
+ System.out.println("Saving all possible data to the Database..");
+ UserInfoTable userInfoTable = database.getUserInfoTable();
+ UsersTable usersTable = database.getUsersTable();
+ SessionsTable sessionsTable = database.getSessionsTable();
+ NicknamesTable nicknamesTable = database.getNicknamesTable();
+ GeoInfoTable geoInfoTable = database.getGeoInfoTable();
+ TPSTable tpsTable = database.getTpsTable();
+ SecurityTable securityTable = database.getSecurityTable();
+ PingTable pingTable = database.getPingTable();
+
+ saveUserOne(database);
+ saveUserTwo(database);
+
+ userInfoTable.registerUserInfo(playerUUID, 223456789L);
+ saveTwoWorlds(database);
+
+ Session session = new Session(TestConstants.PLAYER_ONE_UUID, serverUUID, 12345L, "", "");
+ session.endSession(22345L);
+ session.setWorldTimes(createWorldTimes());
+ session.setPlayerKills(createKills());
+
+ sessionsTable.saveSession(playerUUID, session);
+ nicknamesTable.saveUserName(playerUUID, new Nickname("TestNick", System.currentTimeMillis(), TestConstants.SERVER_UUID));
+ geoInfoTable.saveGeoInfo(playerUUID, new GeoInfo("1.2.3.4", "TestLoc", 223456789L,
+ new SHA256Hash("1.2.3.4").create()));
+
+ assertTrue(usersTable.isRegistered(playerUUID));
+
+ CommandUseTable commandUseTable = database.getCommandUseTable();
+ commandUseTable.commandUsed("plan");
+ commandUseTable.commandUsed("plan");
+ commandUseTable.commandUsed("tp");
+ commandUseTable.commandUsed("help");
+ commandUseTable.commandUsed("help");
+ commandUseTable.commandUsed("help");
+
+ List expected = new ArrayList<>();
+ Random r = new Random();
+ OperatingSystemMXBean operatingSystemMXBean = ManagementFactory.getOperatingSystemMXBean();
+ int availableProcessors = ManagementFactory.getOperatingSystemMXBean().getAvailableProcessors();
+ double averageCPUUsage = operatingSystemMXBean.getSystemLoadAverage() / availableProcessors * 100.0;
+ long usedMemory = 51231251254L;
+ int entityCount = 6123;
+ int chunksLoaded = 2134;
+ long freeDiskSpace = new File("").getUsableSpace();
+ expected.add(new TPS(r.nextLong(), r.nextDouble(), r.nextInt(100000000), averageCPUUsage, usedMemory, entityCount, chunksLoaded, freeDiskSpace));
+ expected.add(new TPS(r.nextLong(), r.nextDouble(), r.nextInt(100000000), averageCPUUsage, usedMemory, entityCount, chunksLoaded, freeDiskSpace));
+ expected.add(new TPS(r.nextLong(), r.nextDouble(), r.nextInt(100000000), averageCPUUsage, usedMemory, entityCount, chunksLoaded, freeDiskSpace));
+ expected.add(new TPS(r.nextLong(), r.nextDouble(), r.nextInt(100000000), averageCPUUsage, usedMemory, entityCount, chunksLoaded, freeDiskSpace));
+ for (TPS tps : expected) {
+ tpsTable.insertTPS(tps);
+ }
+
+ pingTable.insertPing(playerUUID, new Ping(
+ System.currentTimeMillis(), TestConstants.SERVER_UUID,
+ r.nextInt(), r.nextInt(), r.nextDouble()
+ ));
+
+ securityTable.addNewUser(new WebUser("Test", "RandomGarbageBlah", 0));
+ System.out.println("Done!\n");
+ }
+
+ @Test
+ public void testSessionTableNPEWhenNoPlayers() {
+ Map lastSeen = db.getSessionsTable().getLastSeenForAllPlayers();
+ assertTrue(lastSeen.isEmpty());
+ }
+
+ @Test
+ public void testSessionTableGetInfoOfServer() throws DBInitException {
+ saveUserOne();
+ saveUserTwo();
+
+ Session session = new Session(TestConstants.PLAYER_ONE_UUID, serverUUID, 12345L, "", "");
+ session.endSession(22345L);
+ session.setWorldTimes(createWorldTimes());
+ session.setPlayerKills(createKills());
+
+ SessionsTable sessionsTable = db.getSessionsTable();
+ sessionsTable.saveSession(playerUUID, session);
+
+ commitTest();
+
+ Map> sessions = sessionsTable.getSessionInfoOfServer();
+
+ session.setPlayerKills(new ArrayList<>());
+ session.setWorldTimes(new WorldTimes(new HashMap<>()));
+
+ List sSessions = sessions.get(playerUUID);
+ assertFalse(sessions.isEmpty());
+ assertNotNull(sSessions);
+ assertFalse(sSessions.isEmpty());
+ assertEquals(session, sSessions.get(0));
+ }
+
+ @Test
+ public void testKillTableGetKillsOfServer() throws DBInitException {
+ saveUserOne();
+ saveUserTwo();
+
+ KillsTable killsTable = db.getKillsTable();
+ List expected = createKills();
+ killsTable.savePlayerKills(playerUUID, 1, expected);
+
+ commitTest();
+
+ Map> playerKills = killsTable.getPlayerKills();
+ List kills = playerKills.get(playerUUID);
+ assertFalse(playerKills.isEmpty());
+ assertNotNull(kills);
+ assertFalse(kills.isEmpty());
+ assertEquals(expected, kills);
+ }
+
+ @Test
+ public void testBackupAndRestore() throws Exception {
+ System.out.println("- Creating Backup Database -");
+ H2DB backup = dbSystem.getH2Factory().usingFile(temporaryFolder.newFile("backup.db"));
+ backup.init();
+ System.out.println("- Backup Database Created -");
+
+ saveAllData(db);
+
+ System.out.println("Running backup..");
+ db.backup().backup(backup);
+ System.out.println("Backup Complete!");
+
+ UserInfoTable userInfoTable = backup.getUserInfoTable();
+ UsersTable usersTable = backup.getUsersTable();
+ SessionsTable sessionsTable = backup.getSessionsTable();
+ NicknamesTable nicknamesTable = backup.getNicknamesTable();
+ GeoInfoTable ipsTable = backup.getGeoInfoTable();
+ TPSTable tpsTable = backup.getTpsTable();
+ SecurityTable securityTable = backup.getSecurityTable();
+
+ assertTrue(usersTable.isRegistered(playerUUID));
+ assertTrue(usersTable.isRegistered(TestConstants.PLAYER_TWO_UUID));
+ assertTrue(userInfoTable.isRegistered(playerUUID));
+
+ assertFalse(nicknamesTable.getNicknames(playerUUID).isEmpty());
+ assertFalse(ipsTable.getGeoInfo(playerUUID).isEmpty());
+ assertFalse(sessionsTable.getSessions(playerUUID).isEmpty());
+ assertFalse(backup.getCommandUseTable().getCommandUse().isEmpty());
+ assertFalse(backup.getWorldTable().getAllWorlds().isEmpty());
+ assertFalse(tpsTable.getTPSData().isEmpty());
+ assertFalse(backup.getServerTable().getBukkitServers().isEmpty());
+ assertFalse(securityTable.getUsers().isEmpty());
+ }
+
+ @Test
+ public void testSaveWorldTimes() {
+ saveUserOne();
+ WorldTimes worldTimes = createWorldTimes();
+ WorldTimesTable worldTimesTable = db.getWorldTimesTable();
+ worldTimesTable.saveWorldTimes(playerUUID, 1, worldTimes);
+
+ Session session = new Session(1, playerUUID, TestConstants.SERVER_UUID, 12345L, 23456L, 0, 0, 0);
+ Map sessions = new HashMap<>();
+ sessions.put(1, session);
+ worldTimesTable.addWorldTimesToSessions(playerUUID, sessions);
+
+ assertEquals(worldTimes, session.getUnsafe(SessionKeys.WORLD_TIMES));
+ }
+
+ @Test
+ public void testSaveAllWorldTimes() {
+ saveUserOne();
+ WorldTimes worldTimes = createWorldTimes();
+ System.out.println(worldTimes);
+ WorldTimesTable worldTimesTable = db.getWorldTimesTable();
+ Session session = new Session(1, playerUUID, TestConstants.SERVER_UUID, 12345L, 23456L, 0, 0, 0);
+ session.setWorldTimes(worldTimes);
+
+ Map>> map = new HashMap<>();
+ Map> sessionMap = new HashMap<>();
+ List sessions = new ArrayList<>();
+ sessions.add(session);
+ sessionMap.put(playerUUID, sessions);
+ map.put(serverUUID, sessionMap);
+
+ worldTimesTable.saveWorldTimes(map);
+
+ Map worldTimesBySessionID = worldTimesTable.getAllWorldTimesBySessionID();
+ assertEquals(worldTimes, worldTimesBySessionID.get(1));
+ }
+
+ @Test
+ public void testSaveSessionsWorldTimes() {
+ SessionsTable sessionsTable = db.getSessionsTable();
+
+ saveUserOne();
+ WorldTimes worldTimes = createWorldTimes();
+ System.out.println(worldTimes);
+ Session session = new Session(1, playerUUID, TestConstants.SERVER_UUID, 12345L, 23456L, 0, 0, 0);
+ session.setWorldTimes(worldTimes);
+
+ Map>> map = new HashMap<>();
+ Map> sessionMap = new HashMap<>();
+ List sessions = new ArrayList<>();
+ sessions.add(session);
+ sessionMap.put(playerUUID, sessions);
+ map.put(serverUUID, sessionMap);
+
+ sessionsTable.insertSessions(map, true);
+
+ Map>> allSessions = sessionsTable.getAllSessions(true);
+
+ assertEquals(worldTimes, allSessions.get(serverUUID).get(playerUUID).get(0).getUnsafe(SessionKeys.WORLD_TIMES));
+ }
+
+ @Test
+ public void testGetUserWorldTimes() {
+ testSaveSessionsWorldTimes();
+ WorldTimes worldTimesOfUser = db.getWorldTimesTable().getWorldTimesOfUser(playerUUID);
+ assertEquals(createWorldTimes(), worldTimesOfUser);
+ }
+
+ @Test
+ public void testGetServerWorldTimes() {
+ testSaveSessionsWorldTimes();
+ WorldTimes worldTimesOfServer = db.getWorldTimesTable().getWorldTimesOfServer(TestConstants.SERVER_UUID);
+ assertEquals(createWorldTimes(), worldTimesOfServer);
+ }
+
+ @Test
+ public void testRegister() {
+ assertFalse(db.check().isPlayerRegistered(playerUUID));
+ assertFalse(db.check().isPlayerRegisteredOnThisServer(playerUUID));
+ db.save().registerNewUser(playerUUID, 1000L, "name");
+ db.save().registerNewUserOnThisServer(playerUUID, 500L);
+ assertTrue(db.check().isPlayerRegistered(playerUUID));
+ assertTrue(db.check().isPlayerRegisteredOnThisServer(playerUUID));
+ }
+
+ @Test
+ public void testWorldTableGetWorldNamesNoException() throws NoSuchAlgorithmException {
+ saveAllData(db);
+ Set worldNames = db.getWorldTable().getWorldNames(TestConstants.SERVER_UUID);
+ assertEquals(new HashSet<>(worlds), worldNames);
+ }
+
+ @Test
+ public void testSettingTransfer() {
+ String testString = RandomData.randomString(100);
+
+ TransferTable transferTable = db.getTransferTable();
+ transferTable.storeConfigSettings(Base64Util.encode(testString));
+ Optional configSettings = transferTable.getConfigSettings();
+
+ assertTrue(configSettings.isPresent());
+ assertEquals(testString, Base64Util.decode(configSettings.get()));
+ }
+
+ @Test
+ public void testGetNetworkGeolocations() {
+ GeoInfoTable geoInfoTable = db.getGeoInfoTable();
+ UUID firstUuid = UUID.randomUUID();
+ UUID secondUuid = UUID.randomUUID();
+ UUID thirdUuid = UUID.randomUUID();
+
+ UsersTable usersTable = db.getUsersTable();
+ usersTable.registerUser(firstUuid, 0, "");
+ usersTable.registerUser(secondUuid, 0, "");
+ usersTable.registerUser(thirdUuid, 0, "");
+
+ geoInfoTable.saveGeoInfo(firstUuid, new GeoInfo("-", "Test1", 0, "3"));
+ GeoInfo secondInfo = new GeoInfo("-", "Test2", 5, "3");
+ geoInfoTable.saveGeoInfo(firstUuid, secondInfo);
+ geoInfoTable.saveGeoInfo(secondUuid, new GeoInfo("-", "Test3", 0, "3"));
+ geoInfoTable.saveGeoInfo(thirdUuid, new GeoInfo("-", "Test4", 0, "3"));
+
+ List geolocations = geoInfoTable.getNetworkGeolocations();
+ System.out.println(geolocations);
+
+ assertNotNull(geolocations);
+ assertFalse(geolocations.isEmpty());
+ assertEquals(3, geolocations.size());
+ assertTrue(geolocations.contains(secondInfo.getGeolocation()));
+ }
+
+ @Test
+ public void testNewContainerForPlayer() throws NoSuchAlgorithmException {
+ saveAllData(db);
+
+ long start = System.nanoTime();
+
+ PlayerContainer container = db.fetch().getPlayerContainer(playerUUID);
+
+ assertTrue(container.supports(PlayerKeys.UUID));
+ assertTrue(container.supports(PlayerKeys.REGISTERED));
+ assertTrue(container.supports(PlayerKeys.NAME));
+ assertTrue(container.supports(PlayerKeys.KICK_COUNT));
+
+ assertTrue(container.supports(PlayerKeys.GEO_INFO));
+ assertTrue(container.supports(PlayerKeys.NICKNAMES));
+
+ assertTrue(container.supports(PlayerKeys.PER_SERVER));
+
+ assertTrue(container.supports(PlayerKeys.OPERATOR));
+ assertTrue(container.supports(PlayerKeys.BANNED));
+
+ assertTrue(container.supports(PlayerKeys.SESSIONS));
+ assertTrue(container.supports(PlayerKeys.WORLD_TIMES));
+ assertTrue(container.supports(PlayerKeys.LAST_SEEN));
+ assertTrue(container.supports(PlayerKeys.DEATH_COUNT));
+ assertTrue(container.supports(PlayerKeys.MOB_KILL_COUNT));
+ assertTrue(container.supports(PlayerKeys.PLAYER_KILLS));
+ assertTrue(container.supports(PlayerKeys.PLAYER_KILL_COUNT));
+
+ assertFalse(container.supports(PlayerKeys.ACTIVE_SESSION));
+ container.putRawData(PlayerKeys.ACTIVE_SESSION, new Session(TestConstants.PLAYER_ONE_UUID, serverUUID, System.currentTimeMillis(), "TestWorld", "SURVIVAL"));
+ assertTrue(container.supports(PlayerKeys.ACTIVE_SESSION));
+
+ long end = System.nanoTime();
+
+ assertFalse("Took too long: " + ((end - start) / 1000000.0) + "ms", end - start > TimeUnit.SECONDS.toNanos(1L));
+
+ OptionalAssert.equals(playerUUID, container.getValue(PlayerKeys.UUID));
+ OptionalAssert.equals(123456789L, container.getValue(PlayerKeys.REGISTERED));
+ OptionalAssert.equals("Test", container.getValue(PlayerKeys.NAME));
+ OptionalAssert.equals(1, container.getValue(PlayerKeys.KICK_COUNT));
+
+ List expectedGeoInfo =
+ Collections.singletonList(new GeoInfo("1.2.3.4", "TestLoc", 223456789, "ZpT4PJ9HbaMfXfa8xSADTn5X1CHSR7nTT0ntv8hKdkw="));
+ OptionalAssert.equals(expectedGeoInfo, container.getValue(PlayerKeys.GEO_INFO));
+
+ List expectedNicknames = Collections.singletonList(new Nickname("TestNick", -1, TestConstants.SERVER_UUID));
+ OptionalAssert.equals(expectedNicknames, container.getValue(PlayerKeys.NICKNAMES));
+
+ OptionalAssert.equals(false, container.getValue(PlayerKeys.OPERATOR));
+ OptionalAssert.equals(false, container.getValue(PlayerKeys.BANNED));
+
+ // TODO Test rest
+ }
+
+ @Test
+ public void playerContainerSupportsAllPlayerKeys() throws NoSuchAlgorithmException, IllegalAccessException {
+ saveAllData(db);
+
+ PlayerContainer playerContainer = db.fetch().getPlayerContainer(TestConstants.PLAYER_ONE_UUID);
+ // Active sessions are added after fetching
+ playerContainer.putRawData(PlayerKeys.ACTIVE_SESSION, RandomData.randomSession());
+
+ List unsupported = new ArrayList<>();
+ for (Field field : PlayerKeys.class.getDeclaredFields()) {
+ if (!Modifier.isPublic(field.getModifiers())) {
+ continue;
+ }
+ Key key = (Key) field.get(null);
+ if (!playerContainer.supports(key)) {
+ unsupported.add(field.getName());
+ }
+ }
+
+ assertTrue("Some keys are not supported by PlayerContainer: PlayerKeys." + unsupported.toString(), unsupported.isEmpty());
+ }
+
+ @Test
+ public void serverContainerSupportsAllServerKeys() throws NoSuchAlgorithmException, IllegalAccessException {
+ saveAllData(db);
+
+ ServerContainer serverContainer = db.fetch().getServerContainer(TestConstants.SERVER_UUID);
+
+ List unsupported = new ArrayList<>();
+ for (Field field : ServerKeys.class.getDeclaredFields()) {
+ if (!Modifier.isPublic(field.getModifiers())) {
+ continue;
+ }
+ Key key = (Key) field.get(null);
+ if (!serverContainer.supports(key)) {
+ unsupported.add(field.getName());
+ }
+ }
+
+ assertTrue("Some keys are not supported by ServerContainer: ServerKeys." + unsupported.toString(), unsupported.isEmpty());
+ }
+
+ @Test
+ @Ignore
+ public void analysisContainerSupportsAllAnalysisKeys() throws IllegalAccessException, NoSuchAlgorithmException {
+ serverContainerSupportsAllServerKeys();
+ AnalysisContainer.Factory factory = null;
+ AnalysisContainer analysisContainer = factory.forServerContainer(
+ db.fetch().getServerContainer(TestConstants.SERVER_UUID)
+ );
+ List unsupported = new ArrayList<>();
+ for (Field field : AnalysisKeys.class.getDeclaredFields()) {
+ if (!Modifier.isPublic(field.getModifiers())) {
+ continue;
+ }
+ Key key = (Key) field.get(null);
+ if (!analysisContainer.supports(key)) {
+ unsupported.add(field.getName());
+ }
+ }
+
+ assertTrue("Some keys are not supported by AnalysisContainer: AnalysisKeys." + unsupported.toString(), unsupported.isEmpty());
+ }
+
+ @Test
+ public void networkContainerSupportsAllNetworkKeys() throws IllegalAccessException, NoSuchAlgorithmException {
+ serverContainerSupportsAllServerKeys();
+ NetworkContainer networkContainer = db.fetch().getNetworkContainer();
+
+ List unsupported = new ArrayList<>();
+ for (Field field : NetworkKeys.class.getDeclaredFields()) {
+ if (!Modifier.isPublic(field.getModifiers())) {
+ continue;
+ }
+ Key key = (Key) field.get(null);
+ if (!networkContainer.supports(key)) {
+ unsupported.add(field.getName());
+ }
+ }
+
+ assertTrue("Some keys are not supported by NetworkContainer: NetworkKeys." + unsupported.toString(), unsupported.isEmpty());
+ }
+
+ @Test
+ public void testGetMatchingNames() {
+ String exp1 = "TestName";
+ String exp2 = "TestName2";
+
+ UsersTable usersTable = db.getUsersTable();
+ UUID uuid1 = UUID.randomUUID();
+ usersTable.registerUser(uuid1, 0L, exp1);
+ usersTable.registerUser(UUID.randomUUID(), 0L, exp2);
+
+ String search = "testname";
+
+ List result = db.search().matchingPlayers(search);
+
+ assertNotNull(result);
+ assertEquals(2, result.size());
+ assertEquals(exp1, result.get(0));
+ assertEquals(exp2, result.get(1));
+ }
+
+ @Test
+ public void testGetMatchingNickNames() {
+ UUID uuid = UUID.randomUUID();
+ String userName = RandomData.randomString(10);
+ db.getUsersTable().registerUser(uuid, 0L, userName);
+ db.getUsersTable().registerUser(TestConstants.PLAYER_ONE_UUID, 1L, "Not random");
+
+ String nickname = "2" + RandomData.randomString(10);
+ db.getNicknamesTable().saveUserName(uuid, new Nickname(nickname, System.currentTimeMillis(), TestConstants.SERVER_UUID));
+ db.getNicknamesTable().saveUserName(TestConstants.PLAYER_ONE_UUID, new Nickname("No nick", System.currentTimeMillis(), TestConstants.SERVER_UUID));
+
+ String search = "2";
+
+ List result = db.search().matchingPlayers(search);
+
+ assertNotNull(result);
+ assertEquals(1, result.size());
+ assertEquals(userName, result.get(0));
+ }
+
+}
diff --git a/Plan/src/test/java/com/djrapitops/plan/system/database/databases/H2Test.java b/Plan/src/test/java/com/djrapitops/plan/system/database/databases/H2Test.java
new file mode 100644
index 000000000..011af7c91
--- /dev/null
+++ b/Plan/src/test/java/com/djrapitops/plan/system/database/databases/H2Test.java
@@ -0,0 +1,56 @@
+/*
+ * This file is part of Player Analytics (Plan).
+ *
+ * Plan is free software: you can redistribute it and/or modify
+ * it under the terms of the LGNU Lesser General Public License v3 as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Plan is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * LGNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Plan. If not, see .
+ */
+package com.djrapitops.plan.system.database.databases;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Test for the H2 database
+ *
+ * @author Rsl1122, Fuzzlemann
+ * @see SQLiteTest
+ * @since 4.5.1
+ */
+@RunWith(MockitoJUnitRunner.Silent.class)
+public class H2Test extends CommonDBTest {
+
+ @BeforeClass
+ public static void setUpClass() throws Exception {
+ handleSetup("H2");
+ }
+
+ @AfterClass
+ public static void tearDownClass() {
+ system.disable();
+ }
+
+ @Test
+ public void testH2GetConfigName() {
+ assertEquals("h2", db.getType().getConfigName());
+ }
+
+ @Test
+ public void testH2GetName() {
+ assertEquals("H2", db.getType().getName());
+ }
+}
diff --git a/Plan/src/test/java/com/djrapitops/plan/system/database/databases/SQLiteTest.java b/Plan/src/test/java/com/djrapitops/plan/system/database/databases/SQLiteTest.java
index ed866437c..5ce09e60f 100644
--- a/Plan/src/test/java/com/djrapitops/plan/system/database/databases/SQLiteTest.java
+++ b/Plan/src/test/java/com/djrapitops/plan/system/database/databases/SQLiteTest.java
@@ -1,51 +1,32 @@
/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
+ * This file is part of Player Analytics (Plan).
+ *
+ * Plan is free software: you can redistribute it and/or modify
+ * it under the terms of the LGNU Lesser General Public License v3 as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Plan is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * LGNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Plan. If not, see .
*/
package com.djrapitops.plan.system.database.databases;
-import com.djrapitops.plan.DaggerPlanBukkitComponent;
-import com.djrapitops.plan.PlanBukkitComponent;
import com.djrapitops.plan.api.exceptions.database.DBInitException;
-import com.djrapitops.plan.data.WebUser;
-import com.djrapitops.plan.data.container.*;
-import com.djrapitops.plan.data.store.Key;
-import com.djrapitops.plan.data.store.containers.AnalysisContainer;
-import com.djrapitops.plan.data.store.containers.NetworkContainer;
-import com.djrapitops.plan.data.store.containers.PlayerContainer;
-import com.djrapitops.plan.data.store.containers.ServerContainer;
-import com.djrapitops.plan.data.store.keys.*;
-import com.djrapitops.plan.data.store.objects.Nickname;
-import com.djrapitops.plan.data.time.GMTimes;
-import com.djrapitops.plan.data.time.WorldTimes;
-import com.djrapitops.plan.system.PlanSystem;
-import com.djrapitops.plan.system.database.DBSystem;
-import com.djrapitops.plan.system.database.databases.sql.SQLDB;
-import com.djrapitops.plan.system.database.databases.sql.SQLiteDB;
-import com.djrapitops.plan.system.database.databases.sql.tables.*;
+import com.djrapitops.plan.system.database.databases.sql.tables.ServerTable;
import com.djrapitops.plan.system.info.server.Server;
-import com.djrapitops.plan.system.settings.Settings;
-import com.djrapitops.plan.utilities.Base64Util;
-import com.djrapitops.plan.utilities.SHA256Hash;
-import org.junit.*;
-import org.junit.rules.TemporaryFolder;
-import org.junit.rules.Timeout;
+import org.junit.BeforeClass;
+import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.junit.MockitoJUnitRunner;
-import utilities.OptionalAssert;
-import utilities.RandomData;
-import utilities.TestConstants;
-import utilities.mocks.PlanBukkitMocker;
-import java.io.File;
-import java.lang.management.ManagementFactory;
-import java.lang.management.OperatingSystemMXBean;
-import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
-import java.security.NoSuchAlgorithmException;
-import java.util.*;
-import java.util.concurrent.TimeUnit;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
import static org.junit.Assert.*;
@@ -53,607 +34,21 @@ import static org.junit.Assert.*;
* @author Rsl1122
*/
@RunWith(MockitoJUnitRunner.Silent.class)
-public class SQLiteTest {
-
- @ClassRule
- public static TemporaryFolder temporaryFolder = new TemporaryFolder();
- private static DBSystem dbSystem;
- private static SQLDB db;
- private static PlanSystem system;
-
- private final List worlds = Arrays.asList("TestWorld", "TestWorld2");
- private final UUID playerUUID = TestConstants.PLAYER_ONE_UUID;
- private final UUID player2UUID = TestConstants.PLAYER_TWO_UUID;
- private final UUID serverUUID = TestConstants.SERVER_UUID;
- @Rule
- public Timeout globalTimeout = Timeout.seconds(5);
+public class SQLiteTest extends CommonDBTest {
@BeforeClass
public static void setUpClass() throws Exception {
- System.out.println("--- Test Class Setup ---");
- PlanBukkitMocker mockUtil = PlanBukkitMocker.setUp()
- .withDataFolder(temporaryFolder.newFolder())
- .withPluginDescription()
- .withResourceFetchingFromJar()
- .withServer();
- PlanBukkitComponent component = DaggerPlanBukkitComponent.builder().plan(mockUtil.getPlanMock()).build();
- system = component.system();
- system.getConfigSystem().getConfig().set(Settings.WEBSERVER_PORT, 9005);
- system.enable();
-
- dbSystem = system.getDatabaseSystem();
- db = (SQLDB) dbSystem.getDatabase();
- System.out.println("--- Class Setup Complete ---\n");
- }
-
- @AfterClass
- public static void tearDownClass() {
- system.disable();
- }
-
- @Before
- public void setUp() {
- System.out.println("\n-- Clearing Test Database --");
- db.remove().everything();
- ServerTable serverTable = db.getServerTable();
- serverTable.saveCurrentServerInfo(new Server(-1, TestConstants.SERVER_UUID, "ServerName", "", 20));
- assertEquals(db.getServerUUIDSupplier().get(), TestConstants.SERVER_UUID);
- System.out.println("-- Clear Complete --\n");
+ handleSetup("SQLite");
}
@Test
- public void testInit() throws DBInitException {
- db.init();
+ public void testH2GetConfigName() {
+ assertEquals("sqlite", db.getType().getConfigName());
}
@Test
- public void testNoExceptionWhenCommitEmpty() throws Exception {
- db.commit(db.getConnection());
- db.commit(db.getConnection());
- db.commit(db.getConnection());
- }
-
- @Test
- public void testSQLiteGetConfigName() {
- assertEquals("sqlite", db.getConfigName());
- }
-
- @Test
- public void testSQLiteGetName() {
- assertEquals("SQLite", db.getName());
- }
-
- @Test(timeout = 3000)
- public void testSaveCommandUse() throws DBInitException {
- CommandUseTable commandUseTable = db.getCommandUseTable();
- Map expected = new HashMap<>();
-
- expected.put("plan", 1);
- expected.put("tp", 4);
- expected.put("pla", 7);
- expected.put("help", 21);
-
- commandUseTable.commandUsed("plan");
-
- for (int i = 0; i < 4; i++) {
- commandUseTable.commandUsed("tp");
- }
-
- for (int i = 0; i < 7; i++) {
- commandUseTable.commandUsed("pla");
- }
-
- for (int i = 0; i < 21; i++) {
- commandUseTable.commandUsed("help");
- }
-
- for (int i = 0; i < 3; i++) {
- commandUseTable.commandUsed("roiergbnougbierubieugbeigubeigubgierbgeugeg");
- }
-
- commitTest();
-
- Map commandUse = db.getCommandUseTable().getCommandUse();
- assertEquals(expected, commandUse);
-
- for (int i = 0; i < 3; i++) {
- commandUseTable.commandUsed("test");
- }
-
- for (int i = 0; i < 2; i++) {
- commandUseTable.commandUsed("tp");
- }
-
- expected.put("test", 3);
- expected.put("tp", 6);
-
- commandUse = db.getCommandUseTable().getCommandUse();
-
- assertEquals(expected, commandUse);
- }
-
- @Test
- public void testCommandUseTableIDSystem() {
- CommandUseTable commandUseTable = db.getCommandUseTable();
- commandUseTable.commandUsed("plan");
-
- for (int i = 0; i < 4; i++) {
- commandUseTable.commandUsed("tp");
- }
-
- for (int i = 0; i < 7; i++) {
- commandUseTable.commandUsed("pla");
- }
-
- for (int i = 0; i < 21; i++) {
- commandUseTable.commandUsed("help");
- }
-
- for (int i = 0; i < 3; i++) {
- commandUseTable.commandUsed("roiergbnougbierubieugbeigubeigubgierbgeugeg");
- }
-
- Optional id = commandUseTable.getCommandID("plan");
-
- assertTrue(id.isPresent());
-
- Optional commandByID = commandUseTable.getCommandByID(id.get());
-
- assertTrue(commandByID.isPresent());
- assertEquals("plan", commandByID.get());
- assertFalse(commandUseTable.getCommandID("roiergbnougbierubieugbeigubeigubgierbgeugeg").isPresent());
- }
-
- @Test
- public void testTPSSaving() throws Exception {
- TPSTable tpsTable = db.getTpsTable();
- Random r = new Random();
-
- List expected = new ArrayList<>();
-
- for (int i = 0; i < RandomData.randomInt(1, 5); i++) {
- expected.add(new TPS(r.nextLong(), r.nextDouble(), r.nextInt(100000000), r.nextDouble(), r.nextLong(), r.nextInt(), r.nextInt(), r.nextLong()));
- }
-
- for (TPS tps : expected) {
- tpsTable.insertTPS(tps);
- }
-
- commitTest();
-
- assertEquals(expected, tpsTable.getTPSData());
- }
-
- private void saveUserOne() {
- saveUserOne(db);
- }
-
- private void saveUserOne(SQLDB database) {
- database.getUsersTable().registerUser(playerUUID, 123456789L, "Test");
- database.getUsersTable().kicked(playerUUID);
- }
-
- private void saveUserTwo() {
- saveUserTwo(db);
- }
-
- private void saveUserTwo(SQLDB database) {
- database.getUsersTable().registerUser(player2UUID, 123456789L, "Test");
- }
-
- @Test
- public void testIPTable() throws DBInitException {
- saveUserOne();
- GeoInfoTable geoInfoTable = db.getGeoInfoTable();
-
- String expectedIP = "1.2.3.4";
- String expectedGeoLoc = "TestLocation";
- long time = System.currentTimeMillis();
-
- GeoInfo expected = new GeoInfo(expectedIP, expectedGeoLoc, time, "3");
- geoInfoTable.saveGeoInfo(playerUUID, expected);
- geoInfoTable.saveGeoInfo(playerUUID, expected);
- commitTest();
-
- List getInfo = geoInfoTable.getGeoInfo(playerUUID);
- assertEquals(1, getInfo.size());
- GeoInfo actual = getInfo.get(0);
- assertEquals(expected, actual);
- assertEquals(time, actual.getDate());
-
- Optional result = geoInfoTable.getGeolocation(expectedIP);
- assertTrue(result.isPresent());
- assertEquals(expectedGeoLoc, result.get());
- }
-
- @Test
- public void testNicknamesTable() throws DBInitException {
- saveUserOne();
- NicknamesTable nickTable = db.getNicknamesTable();
-
- Nickname expected = new Nickname("TestNickname", System.currentTimeMillis(), TestConstants.SERVER_UUID);
- nickTable.saveUserName(playerUUID, expected);
- nickTable.saveUserName(playerUUID, expected);
- commitTest();
-
- List nicknames = nickTable.getNicknameInformation(playerUUID);
- assertEquals(1, nicknames.size());
- assertEquals(expected, nicknames.get(0));
- }
-
- @Test
- public void testSecurityTable() throws DBInitException {
- SecurityTable securityTable = db.getSecurityTable();
- WebUser expected = new WebUser("Test", "RandomGarbageBlah", 0);
- securityTable.addNewUser(expected);
- commitTest();
-
- assertTrue(securityTable.userExists("Test"));
- WebUser test = securityTable.getWebUser("Test");
- assertEquals(expected, test);
-
- assertFalse(securityTable.userExists("NotExist"));
- assertNull(securityTable.getWebUser("NotExist"));
-
- assertEquals(1, securityTable.getUsers().size());
-
- securityTable.removeUser("Test");
- assertFalse(securityTable.userExists("Test"));
- assertNull(securityTable.getWebUser("Test"));
-
- assertEquals(0, securityTable.getUsers().size());
- }
-
- @Test
- public void testWorldTable() throws DBInitException {
- WorldTable worldTable = db.getWorldTable();
- List worlds = Arrays.asList("Test", "Test2", "Test3");
- worldTable.saveWorlds(worlds);
-
- commitTest();
-
- List saved = worldTable.getAllWorlds();
- assertEquals(new HashSet<>(worlds), new HashSet<>(saved));
- }
-
- private void saveTwoWorlds() {
- saveTwoWorlds(db);
- }
-
- private void saveTwoWorlds(SQLDB database) {
- database.getWorldTable().saveWorlds(worlds);
- }
-
- private WorldTimes createWorldTimes() {
- Map times = new HashMap<>();
- Map gm = new HashMap<>();
- String[] gms = GMTimes.getGMKeyArray();
- gm.put(gms[0], 1000L);
- gm.put(gms[1], 2000L);
- gm.put(gms[2], 3000L);
- gm.put(gms[3], 4000L);
- times.put(worlds.get(0), new GMTimes(gm));
-
- return new WorldTimes(times);
- }
-
- private List createKills() {
- List kills = new ArrayList<>();
- kills.add(new PlayerKill(TestConstants.PLAYER_TWO_UUID, "Iron Sword", 4321L));
- kills.add(new PlayerKill(TestConstants.PLAYER_TWO_UUID, "Gold Sword", 5321L));
- return kills;
- }
-
- @Test
- public void testSessionPlaytimeSaving() throws DBInitException {
- saveTwoWorlds();
- saveUserOne();
- saveUserTwo();
- Session session = new Session(TestConstants.PLAYER_ONE_UUID, serverUUID, 12345L, "", "");
- session.endSession(22345L);
- session.setWorldTimes(createWorldTimes());
- session.setPlayerKills(createKills());
-
- long expectedLength = 10000L;
- assertEquals(expectedLength, session.getLength());
- assertEquals(expectedLength, session.getUnsafe(SessionKeys.WORLD_TIMES).getTotal());
-
- SessionsTable sessionsTable = db.getSessionsTable();
- sessionsTable.saveSession(playerUUID, session);
-
- commitTest();
-
- assertEquals(expectedLength, sessionsTable.getPlaytime(playerUUID));
- assertEquals(0L, sessionsTable.getPlaytime(playerUUID, 30000L));
-
- UUID serverUUID = TestConstants.SERVER_UUID;
- long playtimeOfServer = sessionsTable.getPlaytimeOfServer(serverUUID);
- assertEquals(expectedLength, playtimeOfServer);
- assertEquals(0L, sessionsTable.getPlaytimeOfServer(serverUUID, 30000L));
-
- assertEquals(1, sessionsTable.getSessionCount(playerUUID));
- assertEquals(0, sessionsTable.getSessionCount(playerUUID, 30000L));
- }
-
- @Test
- public void testSessionSaving() throws DBInitException {
- saveUserOne();
- saveUserTwo();
-
- Session session = new Session(TestConstants.PLAYER_ONE_UUID, serverUUID, 12345L, "", "");
- session.endSession(22345L);
- session.setWorldTimes(createWorldTimes());
- session.setPlayerKills(createKills());
-
- SessionsTable sessionsTable = db.getSessionsTable();
- sessionsTable.saveSession(playerUUID, session);
-
- commitTest();
-
- Map> sessions = sessionsTable.getSessions(playerUUID);
-
- for (Map.Entry> entry : sessions.entrySet()) {
- UUID key = entry.getKey();
- if (key == null) {
- System.out.print("null");
- } else {
- System.out.print(key);
- }
- System.out.println(" " + entry.getValue());
- }
-
- List savedSessions = sessions.get(serverUUID);
-
- assertNotNull(savedSessions);
- assertEquals(1, savedSessions.size());
- assertNull(sessions.get(UUID.randomUUID()));
-
- assertEquals(session, savedSessions.get(0));
-
- Map lastSeen = sessionsTable.getLastSeenForAllPlayers();
- assertTrue(lastSeen.containsKey(playerUUID));
- assertFalse(lastSeen.containsKey(TestConstants.PLAYER_TWO_UUID));
- assertEquals(22345L, (long) lastSeen.get(playerUUID));
- }
-
- @Test
- public void testUserInfoTableRegisterUnRegistered() throws DBInitException {
- UserInfoTable userInfoTable = db.getUserInfoTable();
- assertFalse(userInfoTable.isRegistered(playerUUID));
- UsersTable usersTable = db.getUsersTable();
- assertFalse(usersTable.isRegistered(playerUUID));
-
- userInfoTable.registerUserInfo(playerUUID, 123456789L);
-
- commitTest();
-
- assertTrue(usersTable.isRegistered(playerUUID));
- assertTrue(userInfoTable.isRegistered(playerUUID));
-
- UserInfo userInfo = userInfoTable.getUserInfo(playerUUID);
- assertEquals(playerUUID, userInfo.getUuid());
- assertEquals(123456789L, (long) usersTable.getRegisterDates().get(0));
- assertEquals(123456789L, userInfo.getRegistered());
- assertEquals(1, userInfoTable.getServerUserCount(serverUUID));
- assertEquals("Waiting for Update..", userInfo.getName());
- assertFalse(userInfo.isBanned());
- assertFalse(userInfo.isOperator());
- }
-
- @Test
- public void testUserInfoTableRegisterRegistered() throws DBInitException {
- saveUserOne();
- UsersTable usersTable = db.getUsersTable();
- assertTrue(usersTable.isRegistered(playerUUID));
-
- UserInfoTable userInfoTable = db.getUserInfoTable();
- assertFalse(userInfoTable.isRegistered(playerUUID));
-
- userInfoTable.registerUserInfo(playerUUID, 223456789L);
- commitTest();
-
- assertTrue(usersTable.isRegistered(playerUUID));
- assertTrue(userInfoTable.isRegistered(playerUUID));
-
- UserInfo userInfo = userInfoTable.getUserInfo(playerUUID);
- assertEquals(playerUUID, userInfo.getUuid());
- assertEquals(123456789L, (long) usersTable.getRegisterDates().get(0));
- assertEquals(223456789L, userInfo.getRegistered());
- assertEquals("Test", userInfo.getName());
- assertFalse(userInfo.isBanned());
- assertFalse(userInfo.isOperator());
-
- assertEquals(userInfo, userInfoTable.getServerUserInfo().get(0));
- }
-
- @Test
- public void testUserInfoTableUpdateBannedOpped() throws DBInitException {
- UserInfoTable userInfoTable = db.getUserInfoTable();
- userInfoTable.registerUserInfo(playerUUID, 223456789L);
- assertTrue(userInfoTable.isRegistered(playerUUID));
-
- userInfoTable.updateOpStatus(playerUUID, true);
- userInfoTable.updateBanStatus(playerUUID, true);
- commitTest();
-
- UserInfo userInfo = userInfoTable.getUserInfo(playerUUID);
- assertTrue(userInfo.isBanned());
- assertTrue(userInfo.isOperator());
-
- userInfoTable.updateOpStatus(playerUUID, false);
- userInfoTable.updateBanStatus(playerUUID, true);
- commitTest();
-
- userInfo = userInfoTable.getUserInfo(playerUUID);
-
- assertTrue(userInfo.isBanned());
- assertFalse(userInfo.isOperator());
-
- userInfoTable.updateOpStatus(playerUUID, true);
- userInfoTable.updateBanStatus(playerUUID, false);
- commitTest();
-
- userInfo = userInfoTable.getUserInfo(playerUUID);
-
- assertFalse(userInfo.isBanned());
- assertTrue(userInfo.isOperator());
- }
-
- @Test
- public void testUsersTableUpdateName() throws DBInitException {
- saveUserOne();
-
- UsersTable usersTable = db.getUsersTable();
-
- assertEquals(playerUUID, usersTable.getUuidOf("Test"));
- usersTable.updateName(playerUUID, "NewName");
-
- commitTest();
-
- assertNull(usersTable.getUuidOf("Test"));
-
- assertEquals("NewName", usersTable.getPlayerName(playerUUID));
- assertEquals(playerUUID, usersTable.getUuidOf("NewName"));
- }
-
- @Test
- public void testUsersTableKickSaving() throws DBInitException {
- saveUserOne();
- UsersTable usersTable = db.getUsersTable();
- assertEquals(1, usersTable.getTimesKicked(playerUUID));
-
- int random = new Random().nextInt(20);
-
- for (int i = 0; i < random + 1; i++) {
- usersTable.kicked(playerUUID);
- }
- commitTest();
- assertEquals(random + 2, usersTable.getTimesKicked(playerUUID));
- }
-
- @Test
- public void testRemovalSingleUser() {
- saveUserTwo();
-
- UserInfoTable userInfoTable = db.getUserInfoTable();
- UsersTable usersTable = db.getUsersTable();
- SessionsTable sessionsTable = db.getSessionsTable();
- NicknamesTable nicknamesTable = db.getNicknamesTable();
- GeoInfoTable geoInfoTable = db.getGeoInfoTable();
-
- userInfoTable.registerUserInfo(playerUUID, 223456789L);
- saveTwoWorlds();
-
- Session session = new Session(TestConstants.PLAYER_ONE_UUID, serverUUID, 12345L, "", "");
- session.endSession(22345L);
- session.setWorldTimes(createWorldTimes());
- session.setPlayerKills(createKills());
-
- sessionsTable.saveSession(playerUUID, session);
- nicknamesTable.saveUserName(playerUUID, new Nickname("TestNick", System.currentTimeMillis(), TestConstants.SERVER_UUID));
- geoInfoTable.saveGeoInfo(playerUUID, new GeoInfo("1.2.3.4", "TestLoc", 223456789L, "3"));
-
- assertTrue(usersTable.isRegistered(playerUUID));
-
- db.remove().player(playerUUID);
-
- assertFalse(usersTable.isRegistered(playerUUID));
- assertFalse(userInfoTable.isRegistered(playerUUID));
- assertTrue(nicknamesTable.getNicknames(playerUUID).isEmpty());
- assertTrue(geoInfoTable.getGeoInfo(playerUUID).isEmpty());
- assertTrue(sessionsTable.getSessions(playerUUID).isEmpty());
- }
-
- @Test
- public void testRemovalEverything() throws NoSuchAlgorithmException {
- UserInfoTable userInfoTable = db.getUserInfoTable();
- UsersTable usersTable = db.getUsersTable();
- SessionsTable sessionsTable = db.getSessionsTable();
- NicknamesTable nicknamesTable = db.getNicknamesTable();
- GeoInfoTable geoInfoTable = db.getGeoInfoTable();
- TPSTable tpsTable = db.getTpsTable();
- SecurityTable securityTable = db.getSecurityTable();
-
- saveAllData(db);
-
- db.remove().everything();
-
- assertFalse(usersTable.isRegistered(playerUUID));
- assertFalse(usersTable.isRegistered(TestConstants.PLAYER_TWO_UUID));
- assertFalse(userInfoTable.isRegistered(playerUUID));
-
- assertTrue(nicknamesTable.getNicknames(playerUUID).isEmpty());
- assertTrue(geoInfoTable.getGeoInfo(playerUUID).isEmpty());
- assertTrue(sessionsTable.getSessions(playerUUID).isEmpty());
- assertTrue(db.getCommandUseTable().getCommandUse().isEmpty());
- assertTrue(db.getWorldTable().getAllWorlds().isEmpty());
- assertTrue(tpsTable.getTPSData().isEmpty());
- assertTrue(db.getServerTable().getBukkitServers().isEmpty());
- assertTrue(db.getPingTable().getAllPings().isEmpty());
- assertTrue(securityTable.getUsers().isEmpty());
- }
-
- private void saveAllData(SQLDB database) throws NoSuchAlgorithmException {
- System.out.println("Saving all possible data to the Database..");
- UserInfoTable userInfoTable = database.getUserInfoTable();
- UsersTable usersTable = database.getUsersTable();
- SessionsTable sessionsTable = database.getSessionsTable();
- NicknamesTable nicknamesTable = database.getNicknamesTable();
- GeoInfoTable geoInfoTable = database.getGeoInfoTable();
- TPSTable tpsTable = database.getTpsTable();
- SecurityTable securityTable = database.getSecurityTable();
- PingTable pingTable = database.getPingTable();
-
- saveUserOne(database);
- saveUserTwo(database);
-
- userInfoTable.registerUserInfo(playerUUID, 223456789L);
- saveTwoWorlds(database);
-
- Session session = new Session(TestConstants.PLAYER_ONE_UUID, serverUUID, 12345L, "", "");
- session.endSession(22345L);
- session.setWorldTimes(createWorldTimes());
- session.setPlayerKills(createKills());
-
- sessionsTable.saveSession(playerUUID, session);
- nicknamesTable.saveUserName(playerUUID, new Nickname("TestNick", System.currentTimeMillis(), TestConstants.SERVER_UUID));
- geoInfoTable.saveGeoInfo(playerUUID, new GeoInfo("1.2.3.4", "TestLoc", 223456789L,
- new SHA256Hash("1.2.3.4").create()));
-
- assertTrue(usersTable.isRegistered(playerUUID));
-
- CommandUseTable commandUseTable = database.getCommandUseTable();
- commandUseTable.commandUsed("plan");
- commandUseTable.commandUsed("plan");
- commandUseTable.commandUsed("tp");
- commandUseTable.commandUsed("help");
- commandUseTable.commandUsed("help");
- commandUseTable.commandUsed("help");
-
- List expected = new ArrayList<>();
- Random r = new Random();
- OperatingSystemMXBean operatingSystemMXBean = ManagementFactory.getOperatingSystemMXBean();
- int availableProcessors = ManagementFactory.getOperatingSystemMXBean().getAvailableProcessors();
- double averageCPUUsage = operatingSystemMXBean.getSystemLoadAverage() / availableProcessors * 100.0;
- long usedMemory = 51231251254L;
- int entityCount = 6123;
- int chunksLoaded = 2134;
- long freeDiskSpace = new File("").getUsableSpace();
- expected.add(new TPS(r.nextLong(), r.nextDouble(), r.nextInt(100000000), averageCPUUsage, usedMemory, entityCount, chunksLoaded, freeDiskSpace));
- expected.add(new TPS(r.nextLong(), r.nextDouble(), r.nextInt(100000000), averageCPUUsage, usedMemory, entityCount, chunksLoaded, freeDiskSpace));
- expected.add(new TPS(r.nextLong(), r.nextDouble(), r.nextInt(100000000), averageCPUUsage, usedMemory, entityCount, chunksLoaded, freeDiskSpace));
- expected.add(new TPS(r.nextLong(), r.nextDouble(), r.nextInt(100000000), averageCPUUsage, usedMemory, entityCount, chunksLoaded, freeDiskSpace));
- for (TPS tps : expected) {
- tpsTable.insertTPS(tps);
- }
-
- pingTable.insertPing(playerUUID, new Ping(
- System.currentTimeMillis(), TestConstants.SERVER_UUID,
- r.nextInt(), r.nextInt(), r.nextDouble()
- ));
-
- securityTable.addNewUser(new WebUser("Test", "RandomGarbageBlah", 0));
- System.out.println("Done!\n");
+ public void testH2GetName() {
+ assertEquals("SQLite", db.getType().getName());
}
@Test
@@ -688,405 +83,4 @@ public class SQLiteTest {
Map bukkitServers = serverTable.getBukkitServers();
assertEquals(1, bukkitServers.size());
}
-
- @Test
- public void testSessionTableNPEWhenNoPlayers() {
- Map lastSeen = db.getSessionsTable().getLastSeenForAllPlayers();
- assertTrue(lastSeen.isEmpty());
- }
-
- private void commitTest() throws DBInitException {
- db.close();
- db.init();
- }
-
- @Test
- public void testSessionTableGetInfoOfServer() throws DBInitException {
- saveUserOne();
- saveUserTwo();
-
- Session session = new Session(TestConstants.PLAYER_ONE_UUID, serverUUID, 12345L, "", "");
- session.endSession(22345L);
- session.setWorldTimes(createWorldTimes());
- session.setPlayerKills(createKills());
-
- SessionsTable sessionsTable = db.getSessionsTable();
- sessionsTable.saveSession(playerUUID, session);
-
- commitTest();
-
- Map> sessions = sessionsTable.getSessionInfoOfServer();
-
- session.setPlayerKills(new ArrayList<>());
- session.setWorldTimes(new WorldTimes(new HashMap<>()));
-
- List sSessions = sessions.get(playerUUID);
- assertFalse(sessions.isEmpty());
- assertNotNull(sSessions);
- assertFalse(sSessions.isEmpty());
- assertEquals(session, sSessions.get(0));
- }
-
- @Test
- public void testKillTableGetKillsOfServer() throws DBInitException {
- saveUserOne();
- saveUserTwo();
-
- KillsTable killsTable = db.getKillsTable();
- List expected = createKills();
- killsTable.savePlayerKills(playerUUID, 1, expected);
-
- commitTest();
-
- Map> playerKills = killsTable.getPlayerKills();
- List kills = playerKills.get(playerUUID);
- assertFalse(playerKills.isEmpty());
- assertNotNull(kills);
- assertFalse(kills.isEmpty());
- assertEquals(expected, kills);
- }
-
- @Test
- public void testBackupAndRestore() throws Exception {
- System.out.println("- Creating Backup Database -");
- SQLiteDB backup = dbSystem.getSqLiteFactory().usingFile(temporaryFolder.newFile("backup.db"));
- backup.init();
- System.out.println("- Backup Database Created -");
-
- saveAllData(db);
-
- System.out.println("Running backup..");
- db.backup().backup(backup);
- System.out.println("Backup Complete!");
-
- UserInfoTable userInfoTable = backup.getUserInfoTable();
- UsersTable usersTable = backup.getUsersTable();
- SessionsTable sessionsTable = backup.getSessionsTable();
- NicknamesTable nicknamesTable = backup.getNicknamesTable();
- GeoInfoTable ipsTable = backup.getGeoInfoTable();
- TPSTable tpsTable = backup.getTpsTable();
- SecurityTable securityTable = backup.getSecurityTable();
-
- assertTrue(usersTable.isRegistered(playerUUID));
- assertTrue(usersTable.isRegistered(TestConstants.PLAYER_TWO_UUID));
- assertTrue(userInfoTable.isRegistered(playerUUID));
-
- assertFalse(nicknamesTable.getNicknames(playerUUID).isEmpty());
- assertFalse(ipsTable.getGeoInfo(playerUUID).isEmpty());
- assertFalse(sessionsTable.getSessions(playerUUID).isEmpty());
- assertFalse(backup.getCommandUseTable().getCommandUse().isEmpty());
- assertFalse(backup.getWorldTable().getAllWorlds().isEmpty());
- assertFalse(tpsTable.getTPSData().isEmpty());
- assertFalse(backup.getServerTable().getBukkitServers().isEmpty());
- assertFalse(securityTable.getUsers().isEmpty());
- }
-
- @Test
- public void testSaveWorldTimes() {
- saveUserOne();
- WorldTimes worldTimes = createWorldTimes();
- WorldTimesTable worldTimesTable = db.getWorldTimesTable();
- worldTimesTable.saveWorldTimes(playerUUID, 1, worldTimes);
-
- Session session = new Session(1, playerUUID, TestConstants.SERVER_UUID, 12345L, 23456L, 0, 0, 0);
- Map sessions = new HashMap<>();
- sessions.put(1, session);
- worldTimesTable.addWorldTimesToSessions(playerUUID, sessions);
-
- assertEquals(worldTimes, session.getUnsafe(SessionKeys.WORLD_TIMES));
- }
-
- @Test
- public void testSaveAllWorldTimes() {
- saveUserOne();
- WorldTimes worldTimes = createWorldTimes();
- System.out.println(worldTimes);
- WorldTimesTable worldTimesTable = db.getWorldTimesTable();
- Session session = new Session(1, playerUUID, TestConstants.SERVER_UUID, 12345L, 23456L, 0, 0, 0);
- session.setWorldTimes(worldTimes);
-
- Map>> map = new HashMap<>();
- Map> sessionMap = new HashMap<>();
- List sessions = new ArrayList<>();
- sessions.add(session);
- sessionMap.put(playerUUID, sessions);
- map.put(serverUUID, sessionMap);
-
- worldTimesTable.saveWorldTimes(map);
-
- Map worldTimesBySessionID = worldTimesTable.getAllWorldTimesBySessionID();
- assertEquals(worldTimes, worldTimesBySessionID.get(1));
- }
-
- @Test
- public void testSaveSessionsWorldTimes() {
- SessionsTable sessionsTable = db.getSessionsTable();
-
- saveUserOne();
- WorldTimes worldTimes = createWorldTimes();
- System.out.println(worldTimes);
- Session session = new Session(1, playerUUID, TestConstants.SERVER_UUID, 12345L, 23456L, 0, 0, 0);
- session.setWorldTimes(worldTimes);
-
- Map>> map = new HashMap<>();
- Map> sessionMap = new HashMap<>();
- List sessions = new ArrayList<>();
- sessions.add(session);
- sessionMap.put(playerUUID, sessions);
- map.put(serverUUID, sessionMap);
-
- sessionsTable.insertSessions(map, true);
-
- Map>> allSessions = sessionsTable.getAllSessions(true);
-
- assertEquals(worldTimes, allSessions.get(serverUUID).get(playerUUID).get(0).getUnsafe(SessionKeys.WORLD_TIMES));
- }
-
- @Test
- public void testGetUserWorldTimes() {
- testSaveSessionsWorldTimes();
- WorldTimes worldTimesOfUser = db.getWorldTimesTable().getWorldTimesOfUser(playerUUID);
- assertEquals(createWorldTimes(), worldTimesOfUser);
- }
-
- @Test
- public void testGetServerWorldTimes() {
- testSaveSessionsWorldTimes();
- WorldTimes worldTimesOfServer = db.getWorldTimesTable().getWorldTimesOfServer(TestConstants.SERVER_UUID);
- assertEquals(createWorldTimes(), worldTimesOfServer);
- }
-
- @Test
- public void testRegister() {
- assertFalse(db.check().isPlayerRegistered(playerUUID));
- assertFalse(db.check().isPlayerRegisteredOnThisServer(playerUUID));
- db.save().registerNewUser(playerUUID, 1000L, "name");
- db.save().registerNewUserOnThisServer(playerUUID, 500L);
- assertTrue(db.check().isPlayerRegistered(playerUUID));
- assertTrue(db.check().isPlayerRegisteredOnThisServer(playerUUID));
- }
-
- @Test
- public void testWorldTableGetWorldNamesNoException() throws NoSuchAlgorithmException {
- saveAllData(db);
- Set worldNames = db.getWorldTable().getWorldNames(TestConstants.SERVER_UUID);
- assertEquals(new HashSet<>(worlds), worldNames);
- }
-
- @Test
- public void testSettingTransfer() {
- String testString = RandomData.randomString(100);
-
- TransferTable transferTable = db.getTransferTable();
- transferTable.storeConfigSettings(Base64Util.encode(testString));
- Optional configSettings = transferTable.getConfigSettings();
-
- assertTrue(configSettings.isPresent());
- assertEquals(testString, Base64Util.decode(configSettings.get()));
- }
-
- @Test
- public void testGetNetworkGeolocations() {
- GeoInfoTable geoInfoTable = db.getGeoInfoTable();
- UUID firstUuid = UUID.randomUUID();
- UUID secondUuid = UUID.randomUUID();
- UUID thirdUuid = UUID.randomUUID();
-
- UsersTable usersTable = db.getUsersTable();
- usersTable.registerUser(firstUuid, 0, "");
- usersTable.registerUser(secondUuid, 0, "");
- usersTable.registerUser(thirdUuid, 0, "");
-
- geoInfoTable.saveGeoInfo(firstUuid, new GeoInfo("-", "Test1", 0, "3"));
- GeoInfo secondInfo = new GeoInfo("-", "Test2", 5, "3");
- geoInfoTable.saveGeoInfo(firstUuid, secondInfo);
- geoInfoTable.saveGeoInfo(secondUuid, new GeoInfo("-", "Test3", 0, "3"));
- geoInfoTable.saveGeoInfo(thirdUuid, new GeoInfo("-", "Test4", 0, "3"));
-
- List geolocations = geoInfoTable.getNetworkGeolocations();
- System.out.println(geolocations);
-
- assertNotNull(geolocations);
- assertFalse(geolocations.isEmpty());
- assertEquals(3, geolocations.size());
- assertTrue(geolocations.contains(secondInfo.getGeolocation()));
- }
-
- @Test
- public void testNewContainerForPlayer() throws NoSuchAlgorithmException {
- saveAllData(db);
-
- long start = System.nanoTime();
-
- PlayerContainer container = db.fetch().getPlayerContainer(playerUUID);
-
- assertTrue(container.supports(PlayerKeys.UUID));
- assertTrue(container.supports(PlayerKeys.REGISTERED));
- assertTrue(container.supports(PlayerKeys.NAME));
- assertTrue(container.supports(PlayerKeys.KICK_COUNT));
-
- assertTrue(container.supports(PlayerKeys.GEO_INFO));
- assertTrue(container.supports(PlayerKeys.NICKNAMES));
-
- assertTrue(container.supports(PlayerKeys.PER_SERVER));
-
- assertTrue(container.supports(PlayerKeys.OPERATOR));
- assertTrue(container.supports(PlayerKeys.BANNED));
-
- assertTrue(container.supports(PlayerKeys.SESSIONS));
- assertTrue(container.supports(PlayerKeys.WORLD_TIMES));
- assertTrue(container.supports(PlayerKeys.LAST_SEEN));
- assertTrue(container.supports(PlayerKeys.DEATH_COUNT));
- assertTrue(container.supports(PlayerKeys.MOB_KILL_COUNT));
- assertTrue(container.supports(PlayerKeys.PLAYER_KILLS));
- assertTrue(container.supports(PlayerKeys.PLAYER_KILL_COUNT));
-
- assertFalse(container.supports(PlayerKeys.ACTIVE_SESSION));
- container.putRawData(PlayerKeys.ACTIVE_SESSION, new Session(TestConstants.PLAYER_ONE_UUID, serverUUID, System.currentTimeMillis(), "TestWorld", "SURVIVAL"));
- assertTrue(container.supports(PlayerKeys.ACTIVE_SESSION));
-
- long end = System.nanoTime();
-
- assertFalse("Took too long: " + ((end - start) / 1000000.0) + "ms", end - start > TimeUnit.SECONDS.toNanos(1L));
-
- OptionalAssert.equals(playerUUID, container.getValue(PlayerKeys.UUID));
- OptionalAssert.equals(123456789L, container.getValue(PlayerKeys.REGISTERED));
- OptionalAssert.equals("Test", container.getValue(PlayerKeys.NAME));
- OptionalAssert.equals(1, container.getValue(PlayerKeys.KICK_COUNT));
-
- List expectedGeoInfo =
- Collections.singletonList(new GeoInfo("1.2.3.4", "TestLoc", 223456789, "ZpT4PJ9HbaMfXfa8xSADTn5X1CHSR7nTT0ntv8hKdkw="));
- OptionalAssert.equals(expectedGeoInfo, container.getValue(PlayerKeys.GEO_INFO));
-
- List expectedNicknames = Collections.singletonList(new Nickname("TestNick", -1, TestConstants.SERVER_UUID));
- OptionalAssert.equals(expectedNicknames, container.getValue(PlayerKeys.NICKNAMES));
-
- OptionalAssert.equals(false, container.getValue(PlayerKeys.OPERATOR));
- OptionalAssert.equals(false, container.getValue(PlayerKeys.BANNED));
-
- // TODO Test rest
- }
-
- @Test
- public void playerContainerSupportsAllPlayerKeys() throws NoSuchAlgorithmException, IllegalAccessException {
- saveAllData(db);
-
- PlayerContainer playerContainer = db.fetch().getPlayerContainer(TestConstants.PLAYER_ONE_UUID);
- // Active sessions are added after fetching
- playerContainer.putRawData(PlayerKeys.ACTIVE_SESSION, RandomData.randomSession());
-
- List unsupported = new ArrayList<>();
- for (Field field : PlayerKeys.class.getDeclaredFields()) {
- if (!Modifier.isPublic(field.getModifiers())) {
- continue;
- }
- Key key = (Key) field.get(null);
- if (!playerContainer.supports(key)) {
- unsupported.add(field.getName());
- }
- }
-
- assertTrue("Some keys are not supported by PlayerContainer: PlayerKeys." + unsupported.toString(), unsupported.isEmpty());
- }
-
- @Test
- public void serverContainerSupportsAllServerKeys() throws NoSuchAlgorithmException, IllegalAccessException {
- saveAllData(db);
-
- ServerContainer serverContainer = db.fetch().getServerContainer(TestConstants.SERVER_UUID);
-
- List unsupported = new ArrayList<>();
- for (Field field : ServerKeys.class.getDeclaredFields()) {
- if (!Modifier.isPublic(field.getModifiers())) {
- continue;
- }
- Key key = (Key) field.get(null);
- if (!serverContainer.supports(key)) {
- unsupported.add(field.getName());
- }
- }
-
- assertTrue("Some keys are not supported by ServerContainer: ServerKeys." + unsupported.toString(), unsupported.isEmpty());
- }
-
- @Test
- @Ignore
- public void analysisContainerSupportsAllAnalysisKeys() throws IllegalAccessException, NoSuchAlgorithmException {
- serverContainerSupportsAllServerKeys();
- AnalysisContainer.Factory factory = null;
- AnalysisContainer analysisContainer = factory.forServerContainer(
- db.fetch().getServerContainer(TestConstants.SERVER_UUID)
- );
- List unsupported = new ArrayList<>();
- for (Field field : AnalysisKeys.class.getDeclaredFields()) {
- if (!Modifier.isPublic(field.getModifiers())) {
- continue;
- }
- Key key = (Key) field.get(null);
- if (!analysisContainer.supports(key)) {
- unsupported.add(field.getName());
- }
- }
-
- assertTrue("Some keys are not supported by AnalysisContainer: AnalysisKeys." + unsupported.toString(), unsupported.isEmpty());
- }
-
- @Test
- public void networkContainerSupportsAllNetworkKeys() throws IllegalAccessException, NoSuchAlgorithmException {
- serverContainerSupportsAllServerKeys();
- NetworkContainer networkContainer = db.fetch().getNetworkContainer();
-
- List unsupported = new ArrayList<>();
- for (Field field : NetworkKeys.class.getDeclaredFields()) {
- if (!Modifier.isPublic(field.getModifiers())) {
- continue;
- }
- Key key = (Key) field.get(null);
- if (!networkContainer.supports(key)) {
- unsupported.add(field.getName());
- }
- }
-
- assertTrue("Some keys are not supported by NetworkContainer: NetworkKeys." + unsupported.toString(), unsupported.isEmpty());
- }
-
- @Test
- public void testGetMatchingNames() {
- String exp1 = "TestName";
- String exp2 = "TestName2";
-
- UsersTable usersTable = db.getUsersTable();
- UUID uuid1 = UUID.randomUUID();
- usersTable.registerUser(uuid1, 0L, exp1);
- usersTable.registerUser(UUID.randomUUID(), 0L, exp2);
-
- String search = "testname";
-
- List result = db.search().matchingPlayers(search);
-
- assertNotNull(result);
- assertEquals(2, result.size());
- assertEquals(exp1, result.get(0));
- assertEquals(exp2, result.get(1));
- }
-
- @Test
- public void testGetMatchingNickNames() {
- UUID uuid = UUID.randomUUID();
- String userName = RandomData.randomString(10);
- db.getUsersTable().registerUser(uuid, 0L, userName);
- db.getUsersTable().registerUser(TestConstants.PLAYER_ONE_UUID, 1L, "Not random");
-
- String nickname = "2" + RandomData.randomString(10);
- db.getNicknamesTable().saveUserName(uuid, new Nickname(nickname, System.currentTimeMillis(), TestConstants.SERVER_UUID));
- db.getNicknamesTable().saveUserName(TestConstants.PLAYER_ONE_UUID, new Nickname("No nick", System.currentTimeMillis(), TestConstants.SERVER_UUID));
-
- String search = "2";
-
- List result = db.search().matchingPlayers(search);
-
- assertNotNull(result);
- assertEquals(1, result.size());
- assertEquals(userName, result.get(0));
- }
}
diff --git a/Plan/src/test/java/com/djrapitops/plan/utilities/MiscUtilsTest.java b/Plan/src/test/java/com/djrapitops/plan/utilities/MiscUtilsTest.java
index 310fcae12..f61dc5007 100644
--- a/Plan/src/test/java/com/djrapitops/plan/utilities/MiscUtilsTest.java
+++ b/Plan/src/test/java/com/djrapitops/plan/utilities/MiscUtilsTest.java
@@ -1,7 +1,18 @@
/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
+ * This file is part of Player Analytics (Plan).
+ *
+ * Plan is free software: you can redistribute it and/or modify
+ * it under the terms of the LGNU Lesser General Public License v3 as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Plan is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * LGNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Plan. If not, see .
*/
package com.djrapitops.plan.utilities;
diff --git a/Plan/src/test/java/com/djrapitops/plan/utilities/html/HtmlTest.java b/Plan/src/test/java/com/djrapitops/plan/utilities/html/HtmlTest.java
index 0901c9a4b..95702fc4c 100644
--- a/Plan/src/test/java/com/djrapitops/plan/utilities/html/HtmlTest.java
+++ b/Plan/src/test/java/com/djrapitops/plan/utilities/html/HtmlTest.java
@@ -1,7 +1,18 @@
/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
+ * This file is part of Player Analytics (Plan).
+ *
+ * Plan is free software: you can redistribute it and/or modify
+ * it under the terms of the LGNU Lesser General Public License v3 as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Plan is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * LGNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Plan. If not, see .
*/
package com.djrapitops.plan.utilities.html;
diff --git a/Plan/src/test/java/com/djrapitops/plan/utilities/html/HtmlUtilsTest.java b/Plan/src/test/java/com/djrapitops/plan/utilities/html/HtmlUtilsTest.java
index b6de66e37..6178fa74f 100644
--- a/Plan/src/test/java/com/djrapitops/plan/utilities/html/HtmlUtilsTest.java
+++ b/Plan/src/test/java/com/djrapitops/plan/utilities/html/HtmlUtilsTest.java
@@ -1,7 +1,18 @@
/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
+ * This file is part of Player Analytics (Plan).
+ *
+ * Plan is free software: you can redistribute it and/or modify
+ * it under the terms of the LGNU Lesser General Public License v3 as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Plan is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * LGNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Plan. If not, see .
*/
package com.djrapitops.plan.utilities.html;
diff --git a/README.md b/README.md
index 13694aa3b..fc45cdf54 100644
--- a/README.md
+++ b/README.md
@@ -27,3 +27,4 @@ Documentation can be found [On the Wiki](https://github.com/Rsl1122/Plan-PlayerA
- **[jQuery Datatables](https://datatables.net/)** | [MIT License](https://datatables.net/license/mit)
- **[Font Awesome Icons](http://fontawesome.io/icons/)** | [SIL Open Font License](http://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&id=OFL)
- **[MaxMind GeoIP2](https://www.maxmind.com/en/geoip-demo)** | [Creative Commons Attribution-ShareAlike 4.0 International License](https://creativecommons.org/licenses/by-sa/4.0/)
+- **[H2 Database](http://www.h2database.com)** | [MPL 2.0](http://www.h2database.com/html/license.html#mpl2) or [EPL 1.0](http://www.h2database.com/html/license.html#eclipse_license)