Pebble text processing engine

src/test/java/sh/okx/rankup/RankupBasicsTest.java

@@ -0,0 +1,67 @@
+package sh.okx.rankup;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import be.seeseemelk.mockbukkit.entity.PlayerMock;
+import org.junit.Test;
+import sh.okx.rankup.messages.Message;
+import sh.okx.rankup.ranks.Rank;
+import sh.okx.rankup.ranks.RankElement;
+
+public class RankupBasicsTest extends RankupTest {
+  @Test
+  public void testAutoRankup() {
+    PlayerMock player = server.addPlayer();
+
+    // requirement of $1000
+    plugin.getEconomy().setPlayer(player, 1000);
+    // give them group A
+    groupProvider.addGroup(player.getUniqueId(), "A");
+    // give the permission to auto rankup
+    player.addAttachment(plugin, "rankup.auto", true);
+
+    plugin.autoRankup.run();
+    assertTrue(groupProvider.inGroup(player.getUniqueId(), "B"));
+    assertEquals(0, plugin.getEconomy().getBalance(player), 0);
+  }
+
+  @Test
+  public void testNotInLadder() {
+    PlayerMock player = server.addPlayer();
+
+    plugin.getHelper().rankup(player);
+
+    player.assertSaid(plugin.getMessage(Message.NOT_IN_LADDER).replacePlayer(player).toString());
+    player.assertNoMoreSaid();
+  }
+
+  @Test
+  public void testLastRank() {
+    PlayerMock player = server.addPlayer();
+
+    groupProvider.addGroup(player.getUniqueId(), "D");
+
+    plugin.getHelper().rankup(player);
+
+    player.assertSaid(plugin.getMessage(Message.NO_RANKUP).replacePlayer(player)
+        .replaceRank(plugin.getRankups().getTree().last().getRank()).toString());
+    player.assertNoMoreSaid();
+  }
+
+  @Test
+  public void testMoneyRequirement() {
+    PlayerMock player = server.addPlayer();
+
+    plugin.getEconomy().setPlayer(player, 500);
+
+    groupProvider.addGroup(player.getUniqueId(), "A");
+    plugin.getHelper().rankup(player);
+
+    RankElement<Rank> element = plugin.getRankups().getTree().getFirst();
+    Rank rank = element.getRank();
+
+    player.assertSaid(plugin.getMessage(rank, Message.REQUIREMENTS_NOT_MET).replacePlayer(player).replaceOldRank(rank).replaceRank(element.getNext().getRank()).toString(player));
+    player.assertNoMoreSaid();
+  }
+}

src/test/java/sh/okx/rankup/RankupTest.java

@@ -1,101 +1,85 @@
 package sh.okx.rankup;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
 import be.seeseemelk.mockbukkit.MockBukkit;
 import be.seeseemelk.mockbukkit.ServerMock;
-import be.seeseemelk.mockbukkit.entity.PlayerMock;
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
 import org.junit.After;
 import org.junit.Before;
-import org.junit.Test;
 import sh.okx.rankup.economy.TestEconomyProvider;
 import sh.okx.rankup.hook.GroupProvider;
 import sh.okx.rankup.hook.TestGroupProvider;
 import sh.okx.rankup.hook.TestPermissionManager;
-import sh.okx.rankup.messages.Message;
-import sh.okx.rankup.messages.Variable;
-import sh.okx.rankup.ranks.Rank;
-import sh.okx.rankup.ranks.RankElement;
 
-public class RankupTest {
+public abstract class RankupTest {
+    private final File testResourceFolder;
+
+    public RankupTest() {
+        this("default");
+    }
+
+    public RankupTest(String testResourceFolder) {
+        URL resource = this.getClass().getResource("/" + testResourceFolder);
+        if (resource != null) {
+            this.testResourceFolder = new File(resource.getPath());
+        } else {
+            this.testResourceFolder = null;
+        }
+    }
+
     protected GroupProvider groupProvider;
     protected ServerMock server;
     protected RankupPlugin plugin;
 
     @Before
     public void setup() {
-        System.setProperty("TEST", "true");
+        System.setProperty("RANKUP_TEST", "true");
 
         try {
             groupProvider = new TestGroupProvider();
 
             server = MockBukkit.mock();
-            plugin = MockBukkit.load(RankupPlugin.class, new TestPermissionManager(groupProvider), new TestEconomyProvider());
+            plugin = (RankupPlugin) server.getPluginManager()
+                .loadPlugin(RankupPlugin.class, new Object[]{
+                    new TestPermissionManager(groupProvider),
+                    new TestEconomyProvider()
+                });
+
+            if (this.testResourceFolder != null) {
+                Path testPath = this.testResourceFolder.toPath();
+                Path pluginPath = plugin.getDataFolder().toPath();
+                Files.walkFileTree(testPath, new SimpleFileVisitor<Path>() {
+                    @Override
+                    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
+                        throws IOException {
+                        Path out = pluginPath.resolve(testPath.relativize(file));
+                        System.out.println("Copy " + file + " to " + out);
+                        out.getParent().toFile().mkdirs();
+                        Files.copy(file, out);
+                        return super.visitFile(file, attrs);
+                    }
+                });
+            }
+
+            server.getPluginManager().enablePlugin(plugin);
+
             // let rankup finish setting up
             server.getScheduler().performTicks(1);
+
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 
-    @Test
-    public void testAutoRankup() {
-        PlayerMock player = server.addPlayer();
-
-        // requirement of $1000
-        plugin.getEconomy().setPlayer(player, 1000);
-        // give them group A
-        groupProvider.addGroup(player.getUniqueId(), "A");
-        // give the permission to auto rankup
-        player.addAttachment(plugin, "rankup.auto", true);
-
-        plugin.autoRankup.run();
-        assertTrue(groupProvider.inGroup(player.getUniqueId(), "B"));
-        assertEquals(0, plugin.getEconomy().getBalance(player), 0);
-    }
-
-    @Test
-    public void testNotInLadder() {
-        PlayerMock player = server.addPlayer();
-
-        plugin.getHelper().rankup(player);
-
-        player.assertSaid(plugin.getMessage(Message.NOT_IN_LADDER).replace(Variable.PLAYER, player.getName()).toString());
-        player.assertNoMoreSaid();
-    }
-
-    @Test
-    public void testLastRank() {
-        PlayerMock player = server.addPlayer();
-
-        groupProvider.addGroup(player.getUniqueId(), "D");
-
-        plugin.getHelper().rankup(player);
-
-        player.assertSaid(plugin.getMessage(Message.NO_RANKUP).replaceRanks(player, plugin.getRankups().getTree().last().getRank()).toString());
-        player.assertNoMoreSaid();
-    }
-
-    @Test
-    public void testMoneyRequirement() {
-        PlayerMock player = server.addPlayer();
-
-        plugin.getEconomy().setPlayer(player, 500);
-
-        groupProvider.addGroup(player.getUniqueId(), "A");
-        plugin.getHelper().rankup(player);
-
-        RankElement<Rank> element = plugin.getRankups().getTree().getFirst();
-        Rank rank = element.getRank();
-
-        player.assertSaid(plugin.replaceMoneyRequirements(plugin.getMessage(rank, Message.REQUIREMENTS_NOT_MET).replaceRanks(player, rank, element.getNext().getRank()), player, rank).toString());
-        player.assertNoMoreSaid();
-    }
-
     @After
     public void tearDown() {
         MockBukkit.unmock();
-        System.clearProperty("TEST");
+        System.clearProperty("RANKUP_TEST");
     }
 }

src/test/java/sh/okx/rankup/legacy/LegacyPlaceholderTest.java

@@ -0,0 +1,24 @@
+package sh.okx.rankup.legacy;
+
+import be.seeseemelk.mockbukkit.entity.PlayerMock;
+import org.junit.Test;
+import sh.okx.rankup.RankupTest;
+
+public class LegacyPlaceholderTest extends RankupTest {
+  public LegacyPlaceholderTest() {
+    super("legacy");
+  }
+
+  @Test
+  public void testLegacy() {
+    PlayerMock player = server.addPlayer("testPlayer");
+
+    plugin.getEconomy().setPlayer(player, 100);
+    player.setLevel(1);
+
+    groupProvider.addGroup(player.getUniqueId(), "A");
+    plugin.getHelper().rankup(player);
+
+    player.assertSaid("testPlayer A B A-display last rank 1,000 900 4 1 3 25 75");
+  }
+}

src/test/java/sh/okx/rankup/messages/MessageBuilderTest.java

@@ -8,6 +8,6 @@ import static org.junit.Assert.assertThat;
 public class MessageBuilderTest {
   @Test
   public void testFailIfEmpty() {
-    assertThat(new MessageBuilder("").failIfEmpty(), instanceOf(NullMessageBuilder.class));
+    assertThat(new StringMessageBuilder("").failIfEmpty(), instanceOf(NullMessageBuilder.class));
   }
 }

src/test/java/sh/okx/rankup/messages/RankupPlaceholderTest.java

@@ -0,0 +1,24 @@
+package sh.okx.rankup.messages;
+
+import be.seeseemelk.mockbukkit.entity.PlayerMock;
+import org.junit.Test;
+import sh.okx.rankup.RankupTest;
+
+public class RankupPlaceholderTest extends RankupTest {
+  @Test
+  public void testSuccessPublicIsSame() {
+    PlayerMock player = server.addPlayer();
+    PlayerMock receiver = server.addPlayer();
+
+    plugin.getEconomy().setPlayer(player, 1000);
+
+    groupProvider.addGroup(player.getUniqueId(), "A");
+    plugin.getHelper().rankup(player);
+
+    // success-public message must be the same for both players
+    player.assertSaid(receiver.nextMessage());
+
+    // receiver does not receive success-private
+    receiver.assertNoMoreSaid();
+  }
+}

src/test/java/sh/okx/rankup/pebble/PebbleTest.java

@@ -0,0 +1,26 @@
+package sh.okx.rankup.pebble;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.Test;
+import sh.okx.rankup.text.pebble.PebbleTextProcessor;
+
+public class PebbleTest {
+  @Test
+  public void testIndex() {
+    Map<String, Object> ctx = new HashMap<>();
+    ctx.put("one", "2");
+    List<String> list = new ArrayList<>();
+    list.add("L0");
+    list.add("L1");
+    list.add("L2");
+    list.add("L3");
+    ctx.put("list", list);
+    PebbleTextProcessor processor = new PebbleTextProcessor(ctx, null);
+    assertEquals("L2", processor.process("{{ list[one] }}"));
+  }
+}