commit d22f155fb3a7fb3b2d0bdd2afa42f41d593d209f Author: Michael Ziluck Date: Tue May 28 19:59:48 2019 -0500 Initial commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ec10551 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +target/ +.idea/ +*.iml diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..5c3662e --- /dev/null +++ b/pom.xml @@ -0,0 +1,48 @@ + + + 4.0.0 + + com.alttd + AltitudeTag + 0.0.1 + + UTF-8 + + + + + com.destroystokyo.paper + paper + 1.14.1-R0.1-SNAPSHOT + + + com.alttd + AltitudeAPI + LATEST + + + + org.mariadb.jdbc + mariadb-java-client + 2.4.1 + + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.8.1 + + 1.8 + 1.8 + + + + + + \ No newline at end of file diff --git a/src/main/java/com/alttd/altitudetag/AltitudeTag.java b/src/main/java/com/alttd/altitudetag/AltitudeTag.java new file mode 100644 index 0000000..6900e61 --- /dev/null +++ b/src/main/java/com/alttd/altitudetag/AltitudeTag.java @@ -0,0 +1,70 @@ +package com.alttd.altitudetag; + +import java.util.UUID; +import java.util.function.Consumer; + +import org.bukkit.plugin.java.JavaPlugin; + +public class AltitudeTag extends JavaPlugin +{ + private static AltitudeTag instance; + + private UUID tagger; + + /** + * Enable the plugin + */ + public void onEnable() + { + instance = this; + } + + /** + * Set the current tagger. + * + * @param tagger the new tagger. + * + * @return the previous tagger. + */ + public static UUID setTagger(UUID tagger) + { + UUID prev = instance.tagger; + instance.tagger = tagger; + return prev; + } + + /** + * Returns the current tagger. + * + * @return the current tagger. + */ + public static UUID getTagger() + { + return instance.tagger; + } + + /** + * Adds a tag for the given player. + * + * @param uuid the player to add a tag for. + */ + public static void addTag(UUID uuid, Runnable runnable) + { + Leaderboard.addTag(uuid, runnable); + } + + public static void getTags(UUID uuid, Consumer consumer) + { + Leaderboard.getTags(uuid, consumer); + } + + /** + * Returns the singleton instance of this plugin. + * + * @return the singleton instance of this plugin. + */ + public static AltitudeTag getInstance() + { + return instance; + } +} diff --git a/src/main/java/com/alttd/altitudetag/Leaderboard.java b/src/main/java/com/alttd/altitudetag/Leaderboard.java new file mode 100644 index 0000000..4406223 --- /dev/null +++ b/src/main/java/com/alttd/altitudetag/Leaderboard.java @@ -0,0 +1,131 @@ +package com.alttd.altitudetag; + +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Statement; +import java.util.UUID; +import java.util.function.Consumer; + +import org.bukkit.Bukkit; + +public class Leaderboard +{ + public static void initialize() + { + //language=SQL + String sql = "CREATE TABLE IF NOT EXISTS Players (" + + " PlayerId INT NOT NULL AUTO_INCREMENT," + + " PlayerUuidMost BIGINT NOT NULL," + + " PlayerUuidLeast BIGINT NOT NULL," + + " PlayerTags INT NOT NULL DEFAULT(1)," + + " PRIMARY KEY (PlayerId)" + + ");"; + + try + { + Statement statement = TagConnection.getConnection().createStatement(); + statement.execute(sql); + } + catch (SQLException ex) + { + ex.printStackTrace(); + } + } + + /** + * Adds a tag for the given player. + * + * @param uuid the player to add a tag for. + */ + public static void addTag(UUID uuid, Runnable runnable) + { + // call the database action asynchronously + Bukkit.getScheduler().runTaskAsynchronously(AltitudeTag.getInstance(), () -> + { + String sql; + // if they've tagged before we want to update rather than insert + if (hasTagged(uuid)) + { + sql = "UPDATE Players SET PlayerTags = PlayerTags + 1 WHERE PlayerUuidMost = ? AND PlayerUuidLeast = ?;"; + } + else + { + sql = "INSERT INTO Players (PlayerUuidMost, PlayerUuidLeast) VALUES (?, ?);"; + } + // prepare the statement + try (PreparedStatement ps = TagConnection.getConnection().prepareStatement(sql)) + { + // set the parameters + ps.setLong(1, uuid.getMostSignificantBits()); + ps.setLong(2, uuid.getLeastSignificantBits()); + + // execute the code + ps.execute(); + + // run the runnable if it's not null + if (runnable != null) + { + runnable.run(); + } + } + catch (SQLException ex) + { + ex.printStackTrace(); + } + }); + } + + /** + * Returns the number of tags the given player has. + * + * @param uuid the player's uuid. + */ + public static void getTags(UUID uuid, Consumer consumer) + { + Bukkit.getScheduler().runTaskAsynchronously(AltitudeTag.getInstance(), () -> + { + String sql = "SELECT PlayerTags FROM Players WHERE PlayerUuidMost = ? AND PlayerUuidLeast = ?;"; + + try (PreparedStatement ps = TagConnection.getConnection().prepareStatement(sql)) + { + ps.setLong(1, uuid.getMostSignificantBits()); + ps.setLong(2, uuid.getLeastSignificantBits()); + + ResultSet rs = ps.getResultSet(); + + if (rs.next()) + { + // call the consumer when the query returns back + consumer.accept(rs.getInt(1)); + } + + } + catch (SQLException ex) + { + ex.printStackTrace(); + } + }); + } + + public static boolean hasTagged(UUID uuid) + { + String sql = "SELECT COUNT(*) FROM Players WHERE PlayerUuidMost = ? AND PlayerUuidLeast = ?;"; + + try (PreparedStatement ps = TagConnection.getConnection().prepareStatement(sql)) + { + ps.setLong(1, uuid.getMostSignificantBits()); + ps.setLong(2, uuid.getLeastSignificantBits()); + + ResultSet rs = ps.getResultSet(); + + return rs.next() && rs.getInt(1) > 0; + } + catch (SQLException ex) + { + ex.printStackTrace(); + } + + return false; + } +} diff --git a/src/main/java/com/alttd/altitudetag/Permission.java b/src/main/java/com/alttd/altitudetag/Permission.java new file mode 100644 index 0000000..64eb2e6 --- /dev/null +++ b/src/main/java/com/alttd/altitudetag/Permission.java @@ -0,0 +1,21 @@ +package com.alttd.altitudetag; + +public enum Permission +{ + PRIORITY_QUEUE("altiqueue.priority-queue"), + SKIP_QUEUE("altiqueue.skip-queue"), + QUEUE_COMMAND("altiqueue.queue-command"); + + private String permission; + + private Permission(String permission) + { + this.permission = permission; + } + + public String getPermission() + { + return permission; + } + +} diff --git a/src/main/java/com/alttd/altitudetag/TagConnection.java b/src/main/java/com/alttd/altitudetag/TagConnection.java new file mode 100644 index 0000000..5c4fa64 --- /dev/null +++ b/src/main/java/com/alttd/altitudetag/TagConnection.java @@ -0,0 +1,75 @@ +package com.alttd.altitudetag; + +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; + +import com.alttd.altitudetag.configuration.Config; + +public class TagConnection +{ + private static TagConnection instance; + + private Connection connection; + + private String host; + private String database; + private String username; + private String password; + private int port; + + private TagConnection() + { + this.host = Config.DATABASE_HOSTNAME.getValue(); + this.database = Config.DATABASE_DATABASE.getValue(); + this.username = Config.DATABASE_USERNAME.getValue(); + this.password = Config.DATABASE_PASSWORD.getValue(); + this.port = Config.DATABASE_PORT.getValue(); + + try + { + instance.openConnection(); + } + catch (SQLException | ClassNotFoundException ex) + { + ex.printStackTrace(); + } + } + + private void openConnection() throws SQLException, ClassNotFoundException + { + if (connection != null && !connection.isClosed()) + { + return; + } + + synchronized (this) + { + if (connection != null && !connection.isClosed()) + { + return; + } + Class.forName("org.mariadb.jdbc.Driver"); + connection = DriverManager.getConnection("jdbc:mariadb://" + this.host + ":" + this.port + "/" + this.database, this.username, this.password); + } + } + + public static Connection getConnection() + { + try + { + instance.openConnection(); + } + catch (SQLException | ClassNotFoundException ex) + { + ex.printStackTrace(); + } + + return instance.connection; + } + + public static void initialize() + { + instance = new TagConnection(); + } +} diff --git a/src/main/java/com/alttd/altitudetag/configuration/Config.java b/src/main/java/com/alttd/altitudetag/configuration/Config.java new file mode 100644 index 0000000..c61ee1e --- /dev/null +++ b/src/main/java/com/alttd/altitudetag/configuration/Config.java @@ -0,0 +1,167 @@ +package com.alttd.altitudetag.configuration; + +import java.util.Objects; + +import com.alttd.altitudeapi.utils.MutableValue; +import com.alttd.altitudetag.AltitudeTag; +import org.bukkit.configuration.file.FileConfiguration; + +public final class Config +{ + /** + * The plugin's version + */ + public static final MutableValue VERSION = new MutableValue<>("1.1.2"); + + /** + * The hostname of the database if one is used. + */ + public static final MutableValue DATABASE_HOSTNAME = new MutableValue<>("localhost"); + + /** + * The port of the database if one is used. + */ + public static final MutableValue DATABASE_PORT = new MutableValue<>(27017); + + /** + * The username of the user for the database if one is used. + */ + public static final MutableValue DATABASE_USERNAME = new MutableValue<>("root"); + + /** + * The password of the database user if one is used. + */ + public static final MutableValue DATABASE_PASSWORD = new MutableValue<>("password"); + + /** + * The database to use in the database if one is used. + */ + public static final MutableValue DATABASE_DATABASE = new MutableValue<>("factions"); + + /** + * How long the system should wait when trying to connect to a database. + */ + public static final MutableValue DATABASE_TIMEOUT = new MutableValue<>(100); + + /** + * The description given to a connection if the DBMS supports that feature. + */ + public static final MutableValue DATABASE_CONNECTION_DESCRIPTION = new MutableValue<>("Altitude Connection"); + + /** + * Update the values from the config file. + */ + public static void update() + { + FileConfiguration config = AltitudeTag.getInstance().getConfig(); + + MutableValue save = new MutableValue<>(false); + + // how to optimize operations + updateValue(config, save, "version", VERSION); + + // database connection information + updateValue(config, save, "database.hostname", DATABASE_HOSTNAME); + updateValue(config, save, "database.port", DATABASE_PORT); + updateValue(config, save, "database.username", DATABASE_USERNAME); + updateValue(config, save, "database.password", DATABASE_PASSWORD); + updateValue(config, save, "database.database", DATABASE_DATABASE); + updateValue(config, save, "database.timeout", DATABASE_TIMEOUT); + updateValue(config, save, "database.description", DATABASE_CONNECTION_DESCRIPTION); + + if (save.getValue()) + { + AltitudeTag.getInstance().saveConfig(); + } + } + + /** + * Updates the configuration with the given information. If the value fails to load from the config because it does + * not exist or it is in an invalid format, the system will notify the console. + * + * @param config the config file to load/update. + * @param location the location in the config. + * @param mutable the mutable value to update. + */ + private static void updateValue(FileConfiguration config, MutableValue save, String location, MutableValue mutable) + { + if (!config.isSet(location) || !successful(() -> mutable.setValue(loadValue(config, mutable.getType(), location)))) + { + error(location); + config.set(location, mutable.getValue().toString()); + if (!save.getValue()) + { + save.setValue(true); + } + } + } + + /** + * Used to check if an operation throws an exception with ease. + * + * @param runnable the operation to run. + * + * @return {@code true} if the operation does NOT throw an exception.
+ * {@code false} if the operation DOES throw an exception. + */ + protected static boolean successful(Runnable runnable) + { + try + { + runnable.run(); + } + catch (Exception ex) + { + ex.printStackTrace(); + return false; + } + return true; + } + + /** + * Alerts the console that there was an error loading a config value. + * + * @param location the location that caused an error. + */ + private static void error(String location) + { + AltitudeTag.getInstance().getLogger().severe("Error loading the config value '" + location + "'. Reverted it to default."); + } + + @SuppressWarnings("unchecked") + public static T loadValue(FileConfiguration config, Class clazz, String location) + { + if (config == null) + { + throw new IllegalArgumentException("Config parameter can't be null."); + } + if (clazz == null) + { + throw new IllegalArgumentException("Class parameter can't be null."); + } + + if (clazz == Integer.class) + { + return (T) Integer.valueOf(config.getInt(location)); + } + else if (clazz == String.class) + { + return (T) config.getString(location); + } + else if (clazz == Boolean.class) + { + return (T) Boolean.valueOf(config.getBoolean(location)); + } + else if (clazz == Double.class) + { + return (T) Double.valueOf(config.getDouble(location)); + } + else if (Enum.class.isAssignableFrom(clazz)) + { + return (T) Enum.valueOf((Class) clazz, Objects.requireNonNull(config.getString(location))); + } + + // TODO throw exception since the type is weird + return null; + } +} diff --git a/src/main/java/com/alttd/altitudetag/configuration/Lang.java b/src/main/java/com/alttd/altitudetag/configuration/Lang.java new file mode 100644 index 0000000..6b302db --- /dev/null +++ b/src/main/java/com/alttd/altitudetag/configuration/Lang.java @@ -0,0 +1,245 @@ +package com.alttd.altitudetag.configuration; + +import java.io.File; +import java.util.Arrays; + +import com.alttd.altitudeapi.utils.CollectionUtils; +import com.alttd.altitudeapi.utils.StringUtils; +import com.alttd.altitudetag.AltitudeTag; +import org.apache.commons.lang.mutable.MutableBoolean; +import org.bukkit.command.CommandSender; +import org.bukkit.configuration.file.FileConfiguration; +import org.bukkit.configuration.file.YamlConfiguration; + +/** + * The system for processing and sending messages to players. + * + * @author Michael Ziluck + */ +public enum Lang +{ + /** + * The prefix before most of the lang messages. + */ + PREFIX("prefix", "&3[&bAltitudeTag&3] &f{message}"), + /** + * When a player misuses a command. + */ + USAGE("usage_message", "&6&lUSAGE &e» &f{usage}"), + /** + * The prefix to an error message. + */ + ERROR("error_message", "&4&lERROR &c» &7{message}"), + /** + * The prefix to a success message. + */ + SUCCESS("success_message", "&2&lSUCCESS &a» &f{message}"), + /** + * When players do not have permission to do something. + */ + NO_PERMS("no_permissions", "You don't have permission to do that."), + /** + * When a player does not have access to any sub-commands. + */ + NO_SUBS("no_sub_access", "You don't have access to any sub-commands."), + /** + * When the configuration files were successfully reloaded. + */ + RELOAD("reload", "Reloaded the config and lang files."), + /** + * The header and footer for all commands. + */ + HEADER_FOOTER("header_footer", "&7&m-----------------------------------"), + /** + * When the console tries to run a player-only command. + */ + ONLY_PLAYERS("only_players", "Only players can run that command."), + YOURE_IT("youre-it", "You're it! Try to tag someone!"), + TAGGED("tagged", "Nice tag! You're up to {tags} tags!"); + + private String[] message; + + private String path; + + Lang(String path, String... message) + { + this.path = path; + this.message = message; + } + + /** + * Retrieves the message for this Lang object. This can be changed by editing the language configuration files, so + * they should NOT be treated as constants. Additionally their Strings should NOT be stored to reference anything. + * + * @return the message for this Lang object. + */ + public String[] getRawMessage() + { + return message; + } + + /** + * Sets the message for this Lang object. This should not be done after startup to ensure data security. + * + * @param message the new message. + */ + public void setRawMessage(String... message) + { + this.message = message; + } + + /** + * Retrieves the message for this Lang object. This can be changed by editing the language configuration files, so + * they should NOT be treated as constants. Additionally, their Strings should NOT be stored to reference anything. + * Lastly, this returns the combined version of the message in the case that there are multiple. + * + * @return the message for this Lang object. + */ + public String getRawMessageCompiled() + { + return StringUtils.compile(message); + } + + /** + * @return the path of option in the lang.yml file. + */ + public String getPath() + { + return path; + } + + /** + * Sends this Lang object to the CommandSender target. The parameters replace all placeholders that exist in the + * String as well. + * + * @param sender the CommandSender receiving the message. + * @param parameters all additional arguments to fill placeholders. + */ + public void send(CommandSender sender, Object... parameters) + { + sender.sendMessage(getMessage(parameters)); + } + + /** + * Sends this Lang object but prepended with the ERROR value as well. + * + * @param sender the CommandSender receiving the message. + * @param parameters all additional arguments to fill placeholders. + */ + public void sendError(CommandSender sender, Object... parameters) + { + for (String line : getMessage(parameters)) + { + ERROR.send(sender, "{message}", line); + } + } + + /** + * Sends this Lang object but prepended with the SUCCESS value as well. + * + * @param sender the CommandSender receiving the message. + * @param parameters all additional arguments to fill placeholders. + */ + public void sendSuccess(CommandSender sender, Object... parameters) + { + for (String line : getMessage(parameters)) + { + SUCCESS.send(sender, "{message}", line); + } + } + + /** + * Sends this Lang object but prepended with the PREFIX value as well. + * + * @param sender the CommandSender receiving the message. + * @param parameters all additional arguments to fill placeholders. + */ + public void sendInfo(CommandSender sender, Object... parameters) + { + for (String line : getMessage(parameters)) + { + PREFIX.send(sender, "{message}", line); + } + } + + /** + * Renders this message and returns it. Similar behavior to {@link #send(CommandSender, Object...)}, but instead of sending the message, it simply returns it. + * + * @param parameters all additional arguments to fill placeholders. + * + * @return the compiled message. + */ + public String[] getMessage(Object... parameters) + { + String[] args = Arrays.copyOf(message, message.length); + for (int i = 0; i < args.length; i++) + { + args[i] = renderString(args[i], parameters); + } + return args; + } + + /** + * Render a string with the proper parameters. + * + * @param string the rendered string. + * @param args the placeholders and proper content. + * + * @return the rendered string. + */ + protected String renderString(String string, Object... args) + { + if (args.length % 2 != 0) + { + throw new IllegalArgumentException("Message rendering requires arguments of an even number. " + Arrays.toString(args) + " given."); + } + + for (int i = 0; i < args.length; i += 2) + { + string = string.replace(args[i].toString(), CollectionUtils.firstNonNull(args[i + 1], "").toString()); + } + + return string; + } + + public static void update() + { + File langFile = new File(AltitudeTag.getInstance().getDataFolder(), "lang.yml"); + FileConfiguration config = YamlConfiguration.loadConfiguration(langFile); + + final MutableBoolean save = new MutableBoolean(false); + + for (Lang lang : values()) + { + if (!config.isSet(lang.getPath()) || !Config.successful(() -> lang.setRawMessage(config.getString(lang.getPath())))) + { + config.set(lang.getPath(), lang.getRawMessage()); + error(lang.getPath()); + if (!save.booleanValue()) + { + save.setValue(true); + } + } + } + } + + /** + * Alerts the console that there was an error loading a config value. + * + * @param location the location that caused an error. + */ + private static void error(String location) + { + AltitudeTag.getInstance().getLogger().severe("Error loading the lang value '" + location + "'. Reverted it to default."); + } + + public static void sendUsageMessage(CommandSender sender, String[] label, String[] parameters) + { + StringBuilder args = new StringBuilder("/" + StringUtils.compile(label)); + for (String str : parameters) + { + args.append(" [").append(str).append("]"); + } + USAGE.send(sender, "{usage}", args.toString()); + } +} diff --git a/src/main/java/com/alttd/altitudetag/listeners/ConnectionListener.java b/src/main/java/com/alttd/altitudetag/listeners/ConnectionListener.java new file mode 100644 index 0000000..30482a1 --- /dev/null +++ b/src/main/java/com/alttd/altitudetag/listeners/ConnectionListener.java @@ -0,0 +1,35 @@ +package com.alttd.altitudetag.listeners; + +import com.alttd.altitudeapi.utils.CollectionUtils; +import com.alttd.altitudetag.AltitudeTag; +import com.alttd.altitudetag.configuration.Lang; +import org.bukkit.Bukkit; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerJoinEvent; +import org.bukkit.event.player.PlayerQuitEvent; + +public class ConnectionListener implements Listener +{ + @EventHandler + public void onJoin(PlayerJoinEvent event) + { + if (AltitudeTag.getTagger() == null) + { + AltitudeTag.setTagger(event.getPlayer().getUniqueId()); + Lang.YOURE_IT.send(event.getPlayer()); + } + } + + @EventHandler + public void onLeave(PlayerQuitEvent event) + { + if (event.getPlayer().getUniqueId().equals(AltitudeTag.getTagger())) + { + AltitudeTag.setTagger(CollectionUtils.randomValue(Bukkit.getOnlinePlayers()).getUniqueId()); + Lang.YOURE_IT.send(event.getPlayer()); + } + } + + +} diff --git a/src/main/java/com/alttd/altitudetag/listeners/InteractListener.java b/src/main/java/com/alttd/altitudetag/listeners/InteractListener.java new file mode 100644 index 0000000..4d9966c --- /dev/null +++ b/src/main/java/com/alttd/altitudetag/listeners/InteractListener.java @@ -0,0 +1,44 @@ +package com.alttd.altitudetag.listeners; + +import com.alttd.altitudetag.AltitudeTag; +import com.alttd.altitudetag.configuration.Lang; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.entity.EntityDamageByEntityEvent; + +public class InteractListener implements Listener +{ + @EventHandler + public void onHit(EntityDamageByEntityEvent event) + { + if (event.getDamager() instanceof Player && event.getEntity() instanceof Player) + { + Player tagger = (Player) event.getDamager(); + Player tagged = (Player) event.getEntity(); + + // add the new tag + AltitudeTag.addTag(tagger.getUniqueId(), () -> + { + // if they're still online... + if (tagger.isOnline()) + { + // get their tags... + AltitudeTag.getTags(tagger.getUniqueId(), (tags) -> + { + // if they're still online... + if (tagger.isOnline()) + { + // let em know how they're doing! + Lang.TAGGED.send(tagger, "{tags}", tags); + } + }); + } + }); + + AltitudeTag.setTagger(tagged.getUniqueId()); + + Lang.YOURE_IT.send(tagged); + } + } +} diff --git a/src/main/resources/config.yml b/src/main/resources/config.yml new file mode 100644 index 0000000..352197a --- /dev/null +++ b/src/main/resources/config.yml @@ -0,0 +1,8 @@ +database: + hostname: localhost + port: 3306 + username: root + password: password + database: AltitudeTag + timeout: 100 + description: 'Altitude Connection' \ No newline at end of file diff --git a/src/main/resources/lang.yml b/src/main/resources/lang.yml new file mode 100644 index 0000000..ba33006 --- /dev/null +++ b/src/main/resources/lang.yml @@ -0,0 +1,9 @@ +prefix: "§3[§bFortuneBlocks§3] §f{message}" +usage_message: "§6§lUSAGE §e» §f{usage}" +error_message: "§4§lERROR §c» §7{message}" +success_message: "§2§lSUCCESS §a» §f{message}" +no_permissions: "You don't have permission to do that." +no_sub_access: "You don't have access to any sub-commands." +reload: "Reloaded the config and lang files." +header_footer: "&7&m-----------------------------------" +only_players: "Only players can run that command." \ No newline at end of file diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml new file mode 100644 index 0000000..cce10fd --- /dev/null +++ b/src/main/resources/plugin.yml @@ -0,0 +1,4 @@ +main: com.alttd.altitudetag.AltitudeTag +name: AltitudeTag +version: ${project.version} +author: Michael Ziluck \ No newline at end of file diff --git a/src/test/java/com/alttd/altiqueue/configuration/LangTest.java b/src/test/java/com/alttd/altiqueue/configuration/LangTest.java new file mode 100644 index 0000000..42e2017 --- /dev/null +++ b/src/test/java/com/alttd/altiqueue/configuration/LangTest.java @@ -0,0 +1,51 @@ +package com.alttd.altiqueue.configuration; + +import java.io.File; + +import com.alttd.altitudetag.configuration.Lang; +import org.bukkit.configuration.file.FileConfiguration; +import org.bukkit.configuration.file.YamlConfiguration; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +public class LangTest +{ + private FileConfiguration config; + + @Before + public void setup() + { + File file = new File("src/main/resources/lang.yml"); + + config = YamlConfiguration.loadConfiguration(file); + } + + @Test + public void test_file_contains_options() + { + for (Lang lang : Lang.values()) + { + System.out.println(lang.getPath() + ": \"" + lang.getRawMessageCompiled() + "\""); + } + for (Lang lang : Lang.values()) + { + if (!config.contains(lang.getPath())) + { + Assert.fail("Value missing from lang.yml: " + lang.name()); + } + } + } + + @Test + public void test_defaults_match() + { + for (Lang lang : Lang.values()) + { + if (!config.getString(lang.getPath()).equals(lang.getRawMessageCompiled())) + { + Assert.fail("Lang values don't match: " + lang.name()); + } + } + } +}