mockDb = Mockito.mockStatic(DatabaseSetup.class);
+ DatabaseSetup dbSetup = mock(DatabaseSetup.class);
+ mockDb.when(DatabaseSetup::getDatabase).thenReturn(dbSetup);
+ when(dbSetup.getHandler(any())).thenReturn(h);
+ when(h.saveObject(any())).thenReturn(CompletableFuture.completedFuture(true));
+
+
+ // The database type has to be created one line before the thenReturn() to work!
+ DatabaseType value = DatabaseType.JSON;
+ when(plugin.getSettings()).thenReturn(settings);
+ when(settings.getDatabaseType()).thenReturn(value);
+
+ // Command manager
+ CommandsManager cm = mock(CommandsManager.class);
+ when(plugin.getCommandsManager()).thenReturn(cm);
+
+ // Player
+ when(user.isOp()).thenReturn(false);
+ UUID uuid = UUID.randomUUID();
+ when(user.getUniqueId()).thenReturn(uuid);
+ when(user.getPlayer()).thenReturn(mockPlayer);
+ when(user.getName()).thenReturn("tastybento");
+ User.setPlugin(plugin);
+
+ // Player has island to begin with
+ when(im.getIsland(any(), any(UUID.class))).thenReturn(island);
+
+ // Create an Addon
+ addon = new AOneBlock();
+ File jFile = new File("addon.jar");
+ try (JarOutputStream tempJarOutputStream = new JarOutputStream(new FileOutputStream(jFile))) {
+
+ // Copy over config file from src folder
+ Path fromPath = Paths.get("src/main/resources/config.yml");
+ Path path = Paths.get("config.yml");
+ Files.copy(fromPath, path);
+
+ // Add the new files to the jar.
+ add(path, tempJarOutputStream);
+
+ // Copy over panels file from src folder
+ fromPath = Paths.get("src/main/resources/panels/phases_panel.yml");
+ path = Paths.get("panels");
+ Files.createDirectory(path);
+ path = Paths.get("panels/phases_panel.yml");
+ Files.copy(fromPath, path);
+
+ // Add the new files to the jar.
+ add(path, tempJarOutputStream);
+ }
+
+ File dataFolder = new File("addons/AOneBlock");
+ addon.setDataFolder(dataFolder);
+ addon.setFile(jFile);
+ AddonDescription desc = new AddonDescription.Builder("bentobox", "aoneblock", "1.3").description("test")
+ .authors("tasty").build();
+ addon.setDescription(desc);
+ // Addons manager
+ AddonsManager am = mock(AddonsManager.class);
+ when(plugin.getAddonsManager()).thenReturn(am);
+
+ // Flags manager
+ when(plugin.getFlagsManager()).thenReturn(fm);
+ when(fm.getFlags()).thenReturn(Collections.emptyList());
+
+ }
+
+ private void add(Path path, JarOutputStream tempJarOutputStream) throws FileNotFoundException, IOException {
+ try (FileInputStream fis = new FileInputStream(path.toFile())) {
+ byte[] buffer = new byte[1024];
+ int bytesRead = 0;
+ JarEntry entry = new JarEntry(path.toString());
+ tempJarOutputStream.putNextEntry(entry);
+ while ((bytesRead = fis.read(buffer)) != -1) {
+ tempJarOutputStream.write(buffer, 0, bytesRead);
+ }
+ }
+
+ }
+
+ /**
+ * Test method for {@link world.bentobox.aoneblock.AOneBlock#onEnable()}.
+ */
+ @Test
+ public void testOnEnable() {
+ testOnLoad();
+ addon.setState(State.ENABLED);
+ addon.onEnable();
+ assertNotEquals(State.DISABLED, addon.getState());
+ assertNotNull(addon.getBlockListener());
+ assertNotNull(addon.getOneBlockManager());
+
+ }
+
+ /**
+ * Test method for {@link world.bentobox.aoneblock.AOneBlock#onLoad()}.
+ */
+ @Test
+ public void testOnLoad() {
+ addon.onLoad();
+ // Check that config.yml file has been saved
+ File check = new File("addons/AOneBlock", "config.yml");
+ assertTrue(check.exists());
+ assertTrue(addon.getPlayerCommand().isPresent());
+ assertTrue(addon.getAdminCommand().isPresent());
+
+ }
+
+ /**
+ * Test method for {@link world.bentobox.aoneblock.AOneBlock#onReload()}.
+ */
+ @Test
+ public void testOnReload() {
+ addon.onLoad();
+ addon.onEnable();
+ addon.onReload();
+ // Check that config.yml file has been saved
+ File check = new File("addons/AOneBlock", "config.yml");
+ assertTrue(check.exists());
+ }
+
+ /**
+ * Test method for {@link world.bentobox.aoneblock.AOneBlock#createWorlds()}.
+ */
+ @Test
+ public void testCreateWorlds() {
+ addon.onLoad();
+ addon.createWorlds();
+ verify(plugin).log("[aoneblock] Creating AOneBlock world ...");
+ verify(plugin).log("[aoneblock] Creating AOneBlock's Nether...");
+ verify(plugin).log("[aoneblock] Creating AOneBlock's End World...");
+
+ }
+
+ /**
+ * Test method for {@link world.bentobox.aoneblock.AOneBlock#getSettings()}.
+ */
+ @Test
+ public void testGetSettings() {
+ addon.onLoad();
+ assertNotNull(addon.getSettings());
+
+ }
+
+ /**
+ * Test method for
+ * {@link world.bentobox.aoneblock.AOneBlock#getWorldSettings()}.
+ */
+ @Test
+ public void testGetWorldSettings() {
+ addon.onLoad();
+ assertEquals(addon.getSettings(), addon.getWorldSettings());
+ }
+
+ /**
+ * Test method for
+ * {@link world.bentobox.aoneblock.AOneBlock#getOneBlocksIsland(world.bentobox.bentobox.database.objects.Island)}.
+ */
+ @Test
+ public void testGetOneBlocksIsland() {
+ addon.onLoad();
+ addon.onEnable();
+ @NonNull
+ OneBlockIslands i = addon.getOneBlocksIsland(island);
+ assertEquals(island.getUniqueId(), i.getUniqueId());
+ }
+
+ /**
+ * Test method for
+ * {@link world.bentobox.aoneblock.AOneBlock#getOneBlockManager()}.
+ */
+ @Test
+ public void testGetOneBlockManager() {
+ assertNull(addon.getOneBlockManager());
+ }
+
+ /**
+ * Test method for
+ * {@link world.bentobox.aoneblock.AOneBlock#getBlockListener()}.
+ */
+ @Test
+ public void testGetBlockListener() {
+ assertNull(addon.getBlockListener());
+ }
+
+ /**
+ * Test method for
+ * {@link world.bentobox.aoneblock.AOneBlock#getPlaceholdersManager()}.
+ */
+ @Test
+ public void testGetPlaceholdersManager() {
+ assertNull(addon.getPlaceholdersManager());
+ }
+
+ /**
+ * Test method for {@link world.bentobox.aoneblock.AOneBlock#getHoloListener()}.
+ */
+ @Test
+ public void testGetHoloListener() {
+ assertNull(addon.getHoloListener());
+ }
}
diff --git a/src/test/java/world/bentobox/aoneblock/CommonTestSetup.java b/src/test/java/world/bentobox/aoneblock/CommonTestSetup.java
new file mode 100644
index 00000000..b8281c1f
--- /dev/null
+++ b/src/test/java/world/bentobox/aoneblock/CommonTestSetup.java
@@ -0,0 +1,310 @@
+package world.bentobox.aoneblock;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Player.Spigot;
+import org.bukkit.event.entity.EntityExplodeEvent;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.inventory.ItemFactory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+import org.bukkit.metadata.FixedMetadataValue;
+import org.bukkit.metadata.MetadataValue;
+import org.bukkit.plugin.PluginManager;
+import org.bukkit.scheduler.BukkitScheduler;
+import org.bukkit.util.Vector;
+import org.eclipse.jdt.annotation.Nullable;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.mockbukkit.mockbukkit.MockBukkit;
+import org.mockbukkit.mockbukkit.ServerMock;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.stubbing.Answer;
+
+import com.google.common.collect.ImmutableSet;
+
+import net.md_5.bungee.api.chat.TextComponent;
+import world.bentobox.bentobox.BentoBox;
+import world.bentobox.bentobox.api.configuration.WorldSettings;
+import world.bentobox.bentobox.api.user.Notifier;
+import world.bentobox.bentobox.api.user.User;
+import world.bentobox.bentobox.database.objects.Island;
+import world.bentobox.bentobox.database.objects.Players;
+import world.bentobox.bentobox.managers.BlueprintsManager;
+import world.bentobox.bentobox.managers.FlagsManager;
+import world.bentobox.bentobox.managers.HooksManager;
+import world.bentobox.bentobox.managers.IslandWorldManager;
+import world.bentobox.bentobox.managers.IslandsManager;
+import world.bentobox.bentobox.managers.LocalesManager;
+import world.bentobox.bentobox.managers.PlaceholdersManager;
+import world.bentobox.bentobox.managers.PlayersManager;
+import world.bentobox.bentobox.util.Util;
+
+/**
+ * Common items for testing. Don't forget to use super.setUp()!
+ *
+ * Sets up BentoBox plugin, pluginManager and ItemFactory.
+ * Location, world, playersManager and player.
+ * IWM, Addon and WorldSettings. IslandManager with one
+ * island with protection and nothing allowed by default.
+ * Owner of island is player with same UUID.
+ * Locales, placeholders.
+ * @author tastybento
+ *
+ */
+public abstract class CommonTestSetup {
+
+ protected UUID uuid = UUID.randomUUID();
+
+ @Mock
+ protected Player mockPlayer;
+ @Mock
+ protected PluginManager pim;
+ @Mock
+ protected ItemFactory itemFactory;
+ @Mock
+ protected Location location;
+ @Mock
+ protected World world;
+ @Mock
+ protected IslandWorldManager iwm;
+ @Mock
+ protected IslandsManager im;
+ @Mock
+ protected Island island;
+ @Mock
+ protected BentoBox plugin;
+ @Mock
+ protected PlayerInventory inv;
+ @Mock
+ protected Notifier notifier;
+ @Mock
+ protected FlagsManager fm;
+ @Mock
+ protected Spigot spigot;
+ @Mock
+ protected HooksManager hooksManager;
+ @Mock
+ protected BlueprintsManager bm;
+
+ protected ServerMock server;
+
+ protected MockedStatic mockedBukkit;
+ protected MockedStatic mockedUtil;
+
+ protected AutoCloseable closeable;
+
+ @Mock
+ protected BukkitScheduler sch;
+ @Mock
+ protected LocalesManager lm;
+
+ @Mock
+ protected PlaceholdersManager phm;
+
+
+ @BeforeEach
+ public void setUp() throws Exception {
+ MockitoAnnotations.openMocks(this);
+ // Processes the @Mock annotations and initializes the field
+ closeable = MockitoAnnotations.openMocks(this);
+ server = MockBukkit.mock();
+ // Bukkit
+ // Set up plugin
+ WhiteBox.setInternalState(BentoBox.class, "instance", plugin);
+
+ // Register the static mock
+ mockedBukkit = Mockito.mockStatic(Bukkit.class, Mockito.RETURNS_DEEP_STUBS);
+ mockedBukkit.when(Bukkit::getMinecraftVersion).thenReturn("1.21.10");
+ mockedBukkit.when(Bukkit::getBukkitVersion).thenReturn("");
+ mockedBukkit.when(Bukkit::getPluginManager).thenReturn(pim);
+ mockedBukkit.when(Bukkit::getItemFactory).thenReturn(itemFactory);
+ mockedBukkit.when(Bukkit::getServer).thenReturn(server);
+ // Location
+ when(location.getWorld()).thenReturn(world);
+ when(location.getBlockX()).thenReturn(0);
+ when(location.getBlockY()).thenReturn(0);
+ when(location.getBlockZ()).thenReturn(0);
+ when(location.toVector()).thenReturn(new Vector(0,0,0));
+ when(location.clone()).thenReturn(location); // Paper
+
+ // Players Manager and meta data
+ PlayersManager pm = mock(PlayersManager.class);
+ when(plugin.getPlayers()).thenReturn(pm);
+ Players players = mock(Players.class);
+ when(players.getMetaData()).thenReturn(Optional.empty());
+ when(pm.getPlayer(any(UUID.class))).thenReturn(players);
+
+ // Player
+ when(mockPlayer.getUniqueId()).thenReturn(uuid);
+ when(mockPlayer.getLocation()).thenReturn(location);
+ when(mockPlayer.getWorld()).thenReturn(world);
+ when(mockPlayer.getName()).thenReturn("tastybento");
+ when(mockPlayer.getInventory()).thenReturn(inv);
+ when(mockPlayer.spigot()).thenReturn(spigot);
+ when(mockPlayer.getType()).thenReturn(EntityType.PLAYER);
+ when(mockPlayer.getWorld()).thenReturn(world);
+
+ User.setPlugin(plugin);
+ User.clearUsers();
+ User.getInstance(mockPlayer);
+
+ // IWM
+ when(plugin.getIWM()).thenReturn(iwm);
+ when(iwm.inWorld(any(Location.class))).thenReturn(true);
+ when(iwm.inWorld(any(World.class))).thenReturn(true);
+ when(iwm.getFriendlyName(any())).thenReturn("BSkyBlock");
+ // Addon
+ when(iwm.getAddon(any())).thenReturn(Optional.empty());
+
+ // World Settings
+ WorldSettings worldSet = new TestWorldSettings();
+ when(iwm.getWorldSettings(any())).thenReturn(worldSet);
+
+ // Island Manager
+ when(plugin.getIslands()).thenReturn(im);
+ Optional optionalIsland = Optional.of(island);
+ when(im.getProtectedIslandAt(any())).thenReturn(optionalIsland);
+
+ // Island - nothing is allowed by default
+ when(island.isAllowed(any())).thenReturn(false);
+ when(island.isAllowed(any(User.class), any())).thenReturn(false);
+ when(island.getOwner()).thenReturn(uuid);
+ when(island.getMemberSet()).thenReturn(ImmutableSet.of(uuid));
+
+ // Enable reporting from Flags class
+ MetadataValue mdv = new FixedMetadataValue(plugin, "_why_debug");
+ when(mockPlayer.getMetadata(anyString())).thenReturn(Collections.singletonList(mdv));
+
+ // Locales & Placeholders
+ when(lm.get(any(), any())).thenAnswer((Answer) invocation -> invocation.getArgument(1, String.class));
+ when(plugin.getPlaceholdersManager()).thenReturn(phm);
+ when(phm.replacePlaceholders(any(), any())).thenAnswer((Answer) invocation -> invocation.getArgument(1, String.class));
+ when(plugin.getLocalesManager()).thenReturn(lm);
+ // Notifier
+ when(plugin.getNotifier()).thenReturn(notifier);
+
+ // Fake players
+ world.bentobox.bentobox.Settings settings = new world.bentobox.bentobox.Settings();
+ when(plugin.getSettings()).thenReturn(settings);
+
+ //Util
+ mockedUtil = Mockito.mockStatic(Util.class, Mockito.CALLS_REAL_METHODS);
+ mockedUtil.when(() -> Util.getWorld(any())).thenReturn(mock(World.class));
+ Util.setPlugin(plugin);
+
+ // Util
+ mockedUtil.when(() -> Util.findFirstMatchingEnum(any(), any())).thenCallRealMethod();
+ // Util translate color codes (used in user translate methods)
+ //mockedUtil.when(() -> translateColorCodes(anyString())).thenAnswer((Answer) invocation -> invocation.getArgument(0, String.class));
+
+ // Server & Scheduler
+ mockedBukkit.when(Bukkit::getScheduler).thenReturn(sch);
+
+ // Hooks
+ when(hooksManager.getHook(anyString())).thenReturn(Optional.empty());
+ when(plugin.getHooks()).thenReturn(hooksManager);
+
+ // Blueprints Manager
+ when(plugin.getBlueprintsManager()).thenReturn(bm);
+ }
+
+ /**
+ * @throws Exception
+ */
+ @AfterEach
+ public void tearDown() throws Exception {
+ // IMPORTANT: Explicitly close the mock to prevent leakage
+ mockedBukkit.closeOnDemand();
+ mockedUtil.closeOnDemand();
+ closeable.close();
+ MockBukkit.unmock();
+ User.clearUsers();
+ Mockito.framework().clearInlineMocks();
+ deleteAll(new File("database"));
+ deleteAll(new File("database_backup"));
+ }
+
+ protected static void deleteAll(File file) throws IOException {
+ if (file.exists()) {
+ Files.walk(file.toPath()).sorted(Comparator.reverseOrder()).map(Path::toFile).forEach(File::delete);
+ }
+
+ }
+
+ /**
+ * Check that spigot sent the message
+ * @param message - message to check
+ */
+ public void checkSpigotMessage(String expectedMessage) {
+ checkSpigotMessage(expectedMessage, 1);
+ }
+
+ @SuppressWarnings("deprecation")
+ public void checkSpigotMessage(String expectedMessage, int expectedOccurrences) {
+ // Capture the argument passed to spigot().sendMessage(...) if messages are sent
+ ArgumentCaptor captor = ArgumentCaptor.forClass(TextComponent.class);
+
+ // Verify that sendMessage() was called at least 0 times (capture any sent messages)
+ verify(spigot, atLeast(0)).sendMessage(captor.capture());
+
+ // Get all captured TextComponents
+ List capturedMessages = captor.getAllValues();
+
+ // Count the number of occurrences of the expectedMessage in the captured messages
+ long actualOccurrences = capturedMessages.stream().map(component -> component.toLegacyText()) // Convert each TextComponent to plain text
+ .filter(messageText -> messageText.contains(expectedMessage)) // Check if the message contains the expected text
+ .count(); // Count how many times the expected message appears
+
+ // Assert that the number of occurrences matches the expectedOccurrences
+ assertEquals(expectedOccurrences,
+ actualOccurrences, "Expected message occurrence mismatch: " + expectedMessage);
+ }
+
+ /**
+ * Get the exploded event
+ * @param entity
+ * @param l
+ * @param list
+ * @return
+ */
+ public EntityExplodeEvent getExplodeEvent(Entity entity, Location l, List list) {
+ //return new EntityExplodeEvent(entity, l, list, 0, null);
+ return new EntityExplodeEvent(entity, l, list, 0, null);
+ }
+
+ public PlayerDeathEvent getPlayerDeathEvent(Player player, List drops, int droppedExp, int newExp,
+ int newTotalExp, int newLevel, @Nullable String deathMessage) {
+ //Technically this null is not allowed, but it works right now
+ return new PlayerDeathEvent(player, null, drops, droppedExp, newExp,
+ newTotalExp, newLevel, deathMessage);
+ }
+
+}
diff --git a/src/test/java/world/bentobox/aoneblock/PlaceholdersManagerTest.java b/src/test/java/world/bentobox/aoneblock/PlaceholdersManagerTest.java
index adf7e17e..c20a78d7 100644
--- a/src/test/java/world/bentobox/aoneblock/PlaceholdersManagerTest.java
+++ b/src/test/java/world/bentobox/aoneblock/PlaceholdersManagerTest.java
@@ -1,64 +1,42 @@
package world.bentobox.aoneblock;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
import java.util.List;
import java.util.Optional;
-import java.util.UUID;
-import org.bukkit.Location;
-import org.bukkit.World;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.mockito.Mock;
-import org.powermock.modules.junit4.PowerMockRunner;
import world.bentobox.aoneblock.dataobjects.OneBlockIslands;
import world.bentobox.aoneblock.oneblocks.OneBlocksManager;
import world.bentobox.bentobox.api.user.User;
-import world.bentobox.bentobox.database.objects.Island;
-import world.bentobox.bentobox.managers.IslandsManager;
-import world.bentobox.bentobox.managers.PlaceholdersManager;
/**
* @author tastybento
*
*/
-@RunWith(PowerMockRunner.class)
-public class PlaceholdersManagerTest {
+public class PlaceholdersManagerTest extends CommonTestSetup {
@Mock
private AOneBlock addon;
@Mock
private User user;
- private UUID uuid = UUID.randomUUID();
-
private AOneBlockPlaceholders pm;
@Mock
- private IslandsManager im;
- @Mock
- private Island island;
- @Mock
- private @Nullable Location location;
- private @NonNull OneBlockIslands obi;
- @Mock
- private World world;
- @Mock
private OneBlocksManager obm;
- private Settings settings;
- @Mock
- private PlaceholdersManager phm;
/**
* @throws java.lang.Exception
*/
- @Before
+ @Override
+ @BeforeEach
public void setUp() throws Exception {
+ super.setUp();
// User
when(user.getLocation()).thenReturn(location);
when(user.getTranslation("aoneblock.placeholders.infinite")).thenReturn("Infinite");
@@ -71,7 +49,7 @@ public void setUp() throws Exception {
when(im.getProtectedIslandAt(any())).thenReturn(Optional.of(island));
when(im.getIsland(world, user)).thenReturn(island);
when(im.getIslands(world, user)).thenReturn(List.of(island));
- obi = new OneBlockIslands("uniqueId");
+ @NonNull OneBlockIslands obi = new OneBlockIslands("uniqueId");
obi.setPhaseName("first");
obi.setBlockNumber(1000);
when(addon.getOneBlocksIsland(any())).thenReturn(obi);
@@ -80,7 +58,7 @@ public void setUp() throws Exception {
when(obm.getPercentageDone(any(OneBlockIslands.class))).thenReturn(70D);
when(obm.getNextPhaseBlocks(any(OneBlockIslands.class))).thenReturn(123);
// Settings
- settings = new Settings();
+ Settings settings = new Settings();
when(addon.getSettings()).thenReturn(settings);
// Island
when(island.getOwner()).thenReturn(uuid);
diff --git a/src/test/java/world/bentobox/aoneblock/SettingsTest.java b/src/test/java/world/bentobox/aoneblock/SettingsTest.java
index e8b8a9a4..bdac14d6 100644
--- a/src/test/java/world/bentobox/aoneblock/SettingsTest.java
+++ b/src/test/java/world/bentobox/aoneblock/SettingsTest.java
@@ -1,28 +1,20 @@
package world.bentobox.aoneblock;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Collections;
import java.util.List;
import java.util.Map;
-import org.bukkit.Bukkit;
import org.bukkit.Difficulty;
import org.bukkit.GameMode;
-import org.bukkit.Registry;
import org.bukkit.block.Biome;
import org.bukkit.entity.EntityType;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Ignore;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mockito;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import world.bentobox.aoneblock.listeners.BlockListener;
@@ -30,26 +22,27 @@
* @author tastybento
*
*/
-@RunWith(PowerMockRunner.class)
-@PrepareForTest({ Bukkit.class, Biome.class, Registry.class })
-public class SettingsTest {
+public class SettingsTest extends CommonTestSetup {
private Settings s;
/**
* @throws java.lang.Exception
*/
- @Before
+ @Override
+ @BeforeEach
public void setUp() throws Exception {
- PowerMockito.mockStatic(Bukkit.class, Mockito.RETURNS_MOCKS);
+ super.setUp();
s = new Settings();
}
/**
* @throws java.lang.Exception
*/
- @After
+ @Override
+ @AfterEach
public void tearDown() throws Exception {
+ super.tearDown();
}
/**
@@ -702,7 +695,7 @@ public void testSetWorldFlags() {
@Test
public void testSetDefaultIslandFlagNames() {
s.setDefaultIslandFlagNames(Map.of("TEST", 500));
- assertTrue(s.getDefaultIslandFlagNames().get("TEST") == 500);
+ assertEquals(500, (int) s.getDefaultIslandFlagNames().get("TEST"));
}
/**
@@ -711,7 +704,7 @@ public void testSetDefaultIslandFlagNames() {
@Test
public void testSetDefaultIslandSettingNames() {
s.setDefaultIslandSettingNames(Map.of("SETTING", 456));
- assertTrue(s.getDefaultIslandSettingNames().get("SETTING") == 456);
+ assertEquals(456, (int) s.getDefaultIslandSettingNames().get("SETTING"));
}
/**
@@ -1012,7 +1005,7 @@ public void testIsWaterUnsafe() {
* Test method for {@link world.bentobox.aoneblock.Settings#getDefaultBiome()}.
*/
@Test
- @Ignore("Need to solve Biome enum issue")
+ //@Ignore("Need to solve Biome enum issue")
public void testGetDefaultBiome() {
assertEquals(Biome.PLAINS, s.getDefaultBiome());
}
@@ -1021,7 +1014,7 @@ public void testGetDefaultBiome() {
* Test method for {@link world.bentobox.aoneblock.Settings#setDefaultBiome(org.bukkit.block.Biome)}.
*/
@Test
- @Ignore("Need to solve Biome enum issue")
+ //@Ignore("Need to solve Biome enum issue")
public void testSetDefaultBiome() {
assertEquals(Biome.PLAINS, s.getDefaultBiome());
s.setDefaultBiome(Biome.BAMBOO_JUNGLE);
@@ -1281,8 +1274,6 @@ public void testSetPasteMissingIslands() {
assertFalse(s.isPasteMissingIslands());
s.setPasteMissingIslands(true);
assertTrue(s.isPasteMissingIslands());
-
-
}
/**
@@ -1533,7 +1524,7 @@ public void testGetMobLimitSettings() {
@Test
public void testSetMobLimitSettings() {
s.setMobLimitSettings(List.of("test"));
- assertEquals("test", s.getMobLimitSettings().get(0));
+ assertEquals("test", s.getMobLimitSettings().getFirst());
}
/**
@@ -1559,7 +1550,6 @@ public void testSetDropOnTop() {
* Test method for {@link world.bentobox.aoneblock.Settings#getDefaultNetherBiome()}.
*/
@Test
- @Ignore("Biome enum conversion")
public void testGetDefaultNetherBiome() {
assertEquals(Biome.NETHER_WASTES, s.getDefaultNetherBiome());
}
@@ -1568,7 +1558,6 @@ public void testGetDefaultNetherBiome() {
* Test method for {@link world.bentobox.aoneblock.Settings#setDefaultNetherBiome(org.bukkit.block.Biome)}.
*/
@Test
- @Ignore("Biome enum conversion")
public void testSetDefaultNetherBiome() {
assertEquals(Biome.NETHER_WASTES, s.getDefaultNetherBiome());
s.setDefaultNetherBiome(Biome.BADLANDS);
@@ -1579,7 +1568,6 @@ public void testSetDefaultNetherBiome() {
* Test method for {@link world.bentobox.aoneblock.Settings#getDefaultEndBiome()}.
*/
@Test
- @Ignore("Biome enum conversion")
public void testGetDefaultEndBiome() {
assertEquals(Biome.THE_END, s.getDefaultEndBiome());
}
@@ -1588,7 +1576,6 @@ public void testGetDefaultEndBiome() {
* Test method for {@link world.bentobox.aoneblock.Settings#setDefaultEndBiome(org.bukkit.block.Biome)}.
*/
@Test
- @Ignore("Biome enum conversion")
public void testSetDefaultEndBiome() {
assertEquals(Biome.THE_END, s.getDefaultEndBiome());
s.setDefaultEndBiome(Biome.BADLANDS);
diff --git a/src/test/java/world/bentobox/aoneblock/TestWorldSettings.java b/src/test/java/world/bentobox/aoneblock/TestWorldSettings.java
new file mode 100644
index 00000000..b6b3a1ae
--- /dev/null
+++ b/src/test/java/world/bentobox/aoneblock/TestWorldSettings.java
@@ -0,0 +1,409 @@
+package world.bentobox.aoneblock;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.bukkit.Difficulty;
+import org.bukkit.GameMode;
+import org.bukkit.entity.EntityType;
+import org.eclipse.jdt.annotation.NonNull;
+
+import world.bentobox.bentobox.api.configuration.WorldSettings;
+import world.bentobox.bentobox.api.flags.Flag;
+
+/**
+ * Class for tests that require world settings
+ * @author tastybento
+ *
+ */
+public class TestWorldSettings implements WorldSettings {
+
+ private long epoch;
+
+ @Override
+ public GameMode getDefaultGameMode() {
+
+ return GameMode.SURVIVAL;
+ }
+
+ @Override
+ public Map getDefaultIslandFlags() {
+
+ return Collections.emptyMap();
+ }
+
+ @Override
+ public Map getDefaultIslandSettings() {
+
+ return Collections.emptyMap();
+ }
+
+ @Override
+ public Difficulty getDifficulty() {
+
+ return Difficulty.EASY;
+ }
+
+ @Override
+ public void setDifficulty(Difficulty difficulty) {
+
+
+ }
+
+ @Override
+ public String getFriendlyName() {
+
+ return "friendly_name";
+ }
+
+ @Override
+ public int getIslandDistance() {
+
+ return 0;
+ }
+
+ @Override
+ public int getIslandHeight() {
+
+ return 0;
+ }
+
+ @Override
+ public int getIslandProtectionRange() {
+
+ return 0;
+ }
+
+ @Override
+ public int getIslandStartX() {
+
+ return 0;
+ }
+
+ @Override
+ public int getIslandStartZ() {
+
+ return 0;
+ }
+
+ @Override
+ public int getIslandXOffset() {
+
+ return 0;
+ }
+
+ @Override
+ public int getIslandZOffset() {
+
+ return 0;
+ }
+
+ @Override
+ public List getIvSettings() {
+
+ return Collections.emptyList();
+ }
+
+ @Override
+ public int getMaxHomes() {
+
+ return 3;
+ }
+
+ @Override
+ public int getMaxIslands() {
+
+ return 0;
+ }
+
+ @Override
+ public int getMaxTeamSize() {
+
+ return 4;
+ }
+
+ @Override
+ public int getNetherSpawnRadius() {
+
+ return 10;
+ }
+
+ @Override
+ public String getPermissionPrefix() {
+
+ return "perm.";
+ }
+
+ @Override
+ public Set getRemoveMobsWhitelist() {
+
+ return Collections.emptySet();
+ }
+
+ @Override
+ public int getSeaHeight() {
+
+ return 0;
+ }
+
+ @Override
+ public List getHiddenFlags() {
+
+ return Collections.emptyList();
+ }
+
+ @Override
+ public List getVisitorBannedCommands() {
+
+ return Collections.emptyList();
+ }
+
+ @Override
+ public Map getWorldFlags() {
+
+ return Collections.emptyMap();
+ }
+
+ @Override
+ public String getWorldName() {
+
+ return "world_name";
+ }
+
+ @Override
+ public boolean isDragonSpawn() {
+
+ return false;
+ }
+
+ @Override
+ public boolean isEndGenerate() {
+
+ return true;
+ }
+
+ @Override
+ public boolean isEndIslands() {
+
+ return true;
+ }
+
+ @Override
+ public boolean isNetherGenerate() {
+
+ return true;
+ }
+
+ @Override
+ public boolean isNetherIslands() {
+
+ return true;
+ }
+
+ @Override
+ public boolean isOnJoinResetEnderChest() {
+
+ return false;
+ }
+
+ @Override
+ public boolean isOnJoinResetInventory() {
+
+ return false;
+ }
+
+ @Override
+ public boolean isOnJoinResetMoney() {
+
+ return false;
+ }
+
+ @Override
+ public boolean isOnJoinResetHealth() {
+
+ return false;
+ }
+
+ @Override
+ public boolean isOnJoinResetHunger() {
+
+ return false;
+ }
+
+ @Override
+ public boolean isOnJoinResetXP() {
+
+ return false;
+ }
+
+ @Override
+ public @NonNull List getOnJoinCommands() {
+
+ return Collections.emptyList();
+ }
+
+ @Override
+ public boolean isOnLeaveResetEnderChest() {
+
+ return false;
+ }
+
+ @Override
+ public boolean isOnLeaveResetInventory() {
+
+ return false;
+ }
+
+ @Override
+ public boolean isOnLeaveResetMoney() {
+
+ return false;
+ }
+
+ @Override
+ public boolean isOnLeaveResetHealth() {
+
+ return false;
+ }
+
+ @Override
+ public boolean isOnLeaveResetHunger() {
+
+ return false;
+ }
+
+ @Override
+ public boolean isOnLeaveResetXP() {
+
+ return false;
+ }
+
+ @Override
+ public @NonNull List getOnLeaveCommands() {
+
+ return Collections.emptyList();
+ }
+
+ @Override
+ public boolean isUseOwnGenerator() {
+
+ return false;
+ }
+
+ @Override
+ public boolean isWaterUnsafe() {
+
+ return false;
+ }
+
+ @Override
+ public List getGeoLimitSettings() {
+
+ return Collections.emptyList();
+ }
+
+ @Override
+ public int getResetLimit() {
+
+ return 0;
+ }
+
+ @Override
+ public long getResetEpoch() {
+
+ return epoch;
+ }
+
+ @Override
+ public void setResetEpoch(long timestamp) {
+ this.epoch = timestamp;
+
+ }
+
+ @Override
+ public boolean isTeamJoinDeathReset() {
+
+ return false;
+ }
+
+ @Override
+ public int getDeathsMax() {
+
+ return 0;
+ }
+
+ @Override
+ public boolean isDeathsCounted() {
+
+ return true;
+ }
+
+ @Override
+ public boolean isDeathsResetOnNewIsland() {
+
+ return true;
+ }
+
+ @Override
+ public boolean isAllowSetHomeInNether() {
+
+ return false;
+ }
+
+ @Override
+ public boolean isAllowSetHomeInTheEnd() {
+
+ return false;
+ }
+
+ @Override
+ public boolean isRequireConfirmationToSetHomeInNether() {
+
+ return false;
+ }
+
+ @Override
+ public boolean isRequireConfirmationToSetHomeInTheEnd() {
+
+ return false;
+ }
+
+ @Override
+ public int getBanLimit() {
+
+ return 10;
+ }
+
+ @Override
+ public boolean isLeaversLoseReset() {
+
+ return true;
+ }
+
+ @Override
+ public boolean isKickedKeepInventory() {
+
+ return true;
+ }
+
+ @Override
+ public boolean isCreateIslandOnFirstLoginEnabled() {
+
+ return false;
+ }
+
+ @Override
+ public int getCreateIslandOnFirstLoginDelay() {
+
+ return 0;
+ }
+
+ @Override
+ public boolean isCreateIslandOnFirstLoginAbortOnLogout() {
+
+ return false;
+ }
+
+}
diff --git a/src/test/java/world/bentobox/aoneblock/WhiteBox.java b/src/test/java/world/bentobox/aoneblock/WhiteBox.java
new file mode 100644
index 00000000..a65316cd
--- /dev/null
+++ b/src/test/java/world/bentobox/aoneblock/WhiteBox.java
@@ -0,0 +1,26 @@
+package world.bentobox.aoneblock;
+
+public class WhiteBox {
+ /**
+ * Sets the value of a private static field using Java Reflection.
+ * @param targetClass The class containing the static field.
+ * @param fieldName The name of the private static field.
+ * @param value The value to set the field to.
+ */
+ public static void setInternalState(Class targetClass, String fieldName, Object value) {
+ try {
+ // 1. Get the Field object from the class
+ java.lang.reflect.Field field = targetClass.getDeclaredField(fieldName);
+
+ // 2. Make the field accessible (required for private fields)
+ field.setAccessible(true);
+
+ // 3. Set the new value. The first argument is 'null' for static fields.
+ field.set(null, value);
+
+ } catch (NoSuchFieldException | IllegalAccessException e) {
+ // Wrap reflection exceptions in a runtime exception for clarity
+ throw new RuntimeException("Failed to set static field '" + fieldName + "' on class " + targetClass.getName(), e);
+ }
+ }
+}
diff --git a/src/test/java/world/bentobox/aoneblock/commands/island/IslandActionBarCommandTest.java b/src/test/java/world/bentobox/aoneblock/commands/island/IslandActionBarCommandTest.java
new file mode 100644
index 00000000..5cc35687
--- /dev/null
+++ b/src/test/java/world/bentobox/aoneblock/commands/island/IslandActionBarCommandTest.java
@@ -0,0 +1,94 @@
+package world.bentobox.aoneblock.commands.island;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.List;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+
+import world.bentobox.aoneblock.AOneBlock;
+import world.bentobox.aoneblock.CommonTestSetup;
+import world.bentobox.aoneblock.Settings;
+import world.bentobox.bentobox.api.commands.CompositeCommand;
+import world.bentobox.bentobox.api.user.User;
+
+/**
+ * Test class
+ */
+class IslandActionBarCommandTest extends CommonTestSetup {
+
+ @Mock
+ private CompositeCommand ac;
+
+ @Mock
+ private User user;
+ @Mock
+ private AOneBlock addon;
+
+ private IslandActionBarCommand abc;
+
+
+ /**
+ * @throws java.lang.Exception
+ */
+ @Override
+ @BeforeEach
+ public void setUp() throws Exception {
+ super.setUp();
+
+ // Settings
+ Settings settings = new Settings();
+ when(addon.getSettings()).thenReturn(settings);
+
+ abc = new IslandActionBarCommand(ac, settings.getActionBarCommand().split(" ")[0],
+ settings.getActionBarCommand().split(" "));
+ }
+
+ /**
+ * @throws java.lang.Exception
+ */
+ @Override
+ @AfterEach
+ public void tearDown() throws Exception {
+ super.tearDown();
+ }
+
+ /**
+ * Test method for {@link world.bentobox.aoneblock.commands.island.IslandActionBarCommand#IslandActionBarCommand(world.bentobox.bentobox.api.commands.CompositeCommand, java.lang.String, java.lang.String[])}.
+ */
+ @Test
+ void testIslandActionBarCommand() {
+ assertNotNull(abc);
+ }
+
+ /**
+ * Test method for {@link world.bentobox.aoneblock.commands.island.IslandActionBarCommand#setup()}.
+ */
+ @Test
+ void testSetup() {
+ assertEquals("island.actionbar", abc.getPermission());
+ assertEquals("aoneblock.commands.island.actionbar.description", abc.getDescription());
+ assertTrue(abc.isOnlyPlayer());
+ }
+
+ /**
+ * Test method for {@link world.bentobox.aoneblock.commands.island.IslandActionBarCommand#execute(world.bentobox.bentobox.api.user.User, java.lang.String, java.util.List)}.
+ */
+ @Test
+ void testExecuteUserStringListOfString() {
+ abc.execute(user, "", List.of());
+ verify(user).getMetaData("aoneblock.actionbar");
+ verify(user).putMetaData(eq("aoneblock.actionbar"), any());
+ verify(user).sendMessage("aoneblock.commands.island.actionbar.status_off");
+ }
+
+}
diff --git a/src/test/java/world/bentobox/aoneblock/commands/island/IslandBossBarCommandTest.java b/src/test/java/world/bentobox/aoneblock/commands/island/IslandBossBarCommandTest.java
new file mode 100644
index 00000000..e2378339
--- /dev/null
+++ b/src/test/java/world/bentobox/aoneblock/commands/island/IslandBossBarCommandTest.java
@@ -0,0 +1,104 @@
+package world.bentobox.aoneblock.commands.island;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.List;
+import java.util.Optional;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+
+import world.bentobox.aoneblock.AOneBlock;
+import world.bentobox.aoneblock.CommonTestSetup;
+import world.bentobox.aoneblock.Settings;
+import world.bentobox.aoneblock.listeners.BossBarListener;
+import world.bentobox.bentobox.api.commands.CompositeCommand;
+import world.bentobox.bentobox.api.user.User;
+
+/**
+ * Test class
+ */
+class IslandBossBarCommandTest extends CommonTestSetup {
+
+ @Mock
+ private CompositeCommand ac;
+
+ @Mock
+ private User user;
+ @Mock
+ private AOneBlock addon;
+
+ private IslandBossBarCommand bbc;
+
+ @Mock
+ private BossBarListener bb;
+
+
+ /**
+ * @throws java.lang.Exception
+ */
+ @Override
+ @BeforeEach
+ public void setUp() throws Exception {
+ super.setUp();
+
+ when(ac.getAddon()).thenReturn(addon);
+
+ when(addon.getBossBar()).thenReturn(bb);
+
+ when(user.getLocation()).thenReturn(location);
+
+ when(im.getIslandAt(location)).thenReturn(Optional.of(island));
+
+ // Settings
+ Settings settings = new Settings();
+ when(addon.getSettings()).thenReturn(settings);
+
+ bbc = new IslandBossBarCommand(ac, settings.getBossBarCommand().split(" ")[0],
+ settings.getBossBarCommand().split(" "));
+ }
+
+ /**
+ * @throws java.lang.Exception
+ */
+ @Override
+ @AfterEach
+ public void tearDown() throws Exception {
+ super.tearDown();
+ }
+
+ /**
+ * Test method for {@link world.bentobox.aoneblock.commands.island.IslandBossBarCommand#IslandBossBarCommand(world.bentobox.bentobox.api.commands.CompositeCommand, java.lang.String, java.lang.String[])}.
+ */
+ @Test
+ void testIslandBossBarCommand() {
+ assertNotNull(bbc);
+ }
+
+ /**
+ * Test method for {@link world.bentobox.aoneblock.commands.island.IslandBossBarCommand#setup()}.
+ */
+ @Test
+ void testSetup() {
+ assertEquals("island.bossbar", bbc.getPermission());
+ assertEquals("aoneblock.commands.island.bossbar.description", bbc.getDescription());
+ assertTrue(bbc.isOnlyPlayer());
+ }
+
+ /**
+ * Test method for {@link world.bentobox.aoneblock.commands.island.IslandBossBarCommand#execute(world.bentobox.bentobox.api.user.User, java.lang.String, java.util.List)}.
+ */
+ @Test
+ void testExecuteUserStringListOfString() {
+ bbc.execute(user, "", List.of());
+ verify(bb).toggleUser(user);
+ verify(user).sendMessage("aoneblock.bossbar.not-active");
+ }
+
+}
diff --git a/src/test/java/world/bentobox/aoneblock/commands/island/IslandPhasesCommandTest.java b/src/test/java/world/bentobox/aoneblock/commands/island/IslandPhasesCommandTest.java
new file mode 100644
index 00000000..c52c4d5c
--- /dev/null
+++ b/src/test/java/world/bentobox/aoneblock/commands/island/IslandPhasesCommandTest.java
@@ -0,0 +1,101 @@
+package world.bentobox.aoneblock.commands.island;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.List;
+import java.util.TreeMap;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+
+import world.bentobox.aoneblock.AOneBlock;
+import world.bentobox.aoneblock.CommonTestSetup;
+import world.bentobox.aoneblock.Settings;
+import world.bentobox.aoneblock.oneblocks.OneBlocksManager;
+import world.bentobox.bentobox.api.addons.AddonDescription;
+import world.bentobox.bentobox.api.commands.CompositeCommand;
+import world.bentobox.bentobox.api.localization.TextVariables;
+import world.bentobox.bentobox.api.user.User;
+
+/**
+ * Test class
+ */
+class IslandPhasesCommandTest extends CommonTestSetup {
+
+ @Mock
+ private CompositeCommand ac;
+ @Mock
+ private User user;
+ @Mock
+ private AOneBlock addon;
+ @Mock
+ private OneBlocksManager obm;
+
+ private IslandPhasesCommand ipc;
+
+ /**
+ * @throws java.lang.Exception
+ */
+ @Override
+ @BeforeEach
+ public void setUp() throws Exception {
+ super.setUp();
+ when(ac.getAddon()).thenReturn(addon);
+ when(obm.getBlockProbs()).thenReturn(new TreeMap<>());
+ when(addon.getOneBlockManager()).thenReturn(obm);
+ when(addon.getIslandsManager()).thenReturn(im);
+ AddonDescription desc = new AddonDescription.Builder("name", "", "").build();
+ when(addon.getDescription()).thenReturn(desc);
+
+ // Settings
+ Settings settings = new Settings();
+ when(addon.getSettings()).thenReturn(settings);
+ ipc = new IslandPhasesCommand(ac, settings.getPhasesCommand().split(" ")[0],
+ settings.getPhasesCommand().split(" "));
+ }
+
+ /**
+ * @throws java.lang.Exception
+ */
+ @Override
+ @AfterEach
+ public void tearDown() throws Exception {
+ super.tearDown();
+ }
+
+ /**
+ * Test method for {@link world.bentobox.aoneblock.commands.island.IslandPhasesCommand#IslandPhasesCommand(world.bentobox.bentobox.api.commands.CompositeCommand, java.lang.String, java.lang.String[])}.
+ */
+ @Test
+ void testIslandPhasesCommand() {
+ assertNotNull(ipc);
+ }
+
+ /**
+ * Test method for {@link world.bentobox.aoneblock.commands.island.IslandPhasesCommand#setup()}.
+ */
+ @Test
+ void testSetup() {
+ assertEquals("phases", ipc.getPermission());
+ assertEquals("aoneblock.commands.phases.description", ipc.getDescription());
+ assertTrue(ipc.isOnlyPlayer());
+ }
+
+ /**
+ * Test method for {@link world.bentobox.aoneblock.commands.island.IslandPhasesCommand#execute(world.bentobox.bentobox.api.user.User, java.lang.String, java.util.List)}.
+ */
+ @Test
+ void testExecuteUserStringListOfString() {
+ ipc.execute(user, "", List.of());
+ verify(addon).logError("There are no available phases for selection!");
+ verify(user).sendMessage("no-phases",
+ TextVariables.GAMEMODE, this.addon.getDescription().getName());
+ }
+
+}
diff --git a/src/test/java/world/bentobox/aoneblock/commands/island/IslandRespawnBlockCommandTest.java b/src/test/java/world/bentobox/aoneblock/commands/island/IslandRespawnBlockCommandTest.java
new file mode 100644
index 00000000..958164aa
--- /dev/null
+++ b/src/test/java/world/bentobox/aoneblock/commands/island/IslandRespawnBlockCommandTest.java
@@ -0,0 +1,160 @@
+package world.bentobox.aoneblock.commands.island;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.List;
+
+import org.bukkit.Material;
+import org.bukkit.Particle;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.util.Vector;
+import org.jetbrains.annotations.NotNull;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+
+import world.bentobox.aoneblock.AOneBlock;
+import world.bentobox.aoneblock.CommonTestSetup;
+import world.bentobox.aoneblock.Settings;
+import world.bentobox.bentobox.api.commands.CompositeCommand;
+import world.bentobox.bentobox.api.user.User;
+import world.bentobox.bentobox.util.Util;
+
+/**
+ * Test class
+ */
+class IslandRespawnBlockCommandTest extends CommonTestSetup {
+
+ @Mock
+ private CompositeCommand ac;
+ @Mock
+ private User user;
+ @Mock
+ private AOneBlock addon;
+ private IslandRespawnBlockCommand rbc;
+ @Mock
+ private @NotNull Block block;
+
+ /**
+ * @throws java.lang.Exception
+ */
+ @BeforeEach
+ public void setUp() throws Exception {
+ super.setUp();
+ when(ac.getAddon()).thenReturn(addon);
+ when(ac.getWorld()).thenReturn(world);
+ when(user.getWorld()).thenReturn(world);
+ mockedUtil.when(() -> Util.sameWorld(any(World.class), any(World.class))).thenReturn(true);
+ // User has island
+ when(im.getIsland(world, user)).thenReturn(island);
+ // Island center block
+ when(island.getWorld()).thenReturn(world);
+ when(island.getCenter()).thenReturn(location);
+ when(location.getBlock()).thenReturn(block);
+ when(block.getType()).thenReturn(Material.BEDROCK);
+ when(location.add(any(Vector.class))).thenReturn(location);
+
+ Settings settings = new Settings();
+ when(addon.getSettings()).thenReturn(settings);
+ rbc = new IslandRespawnBlockCommand(ac, settings.getRespawnBlockCommand().split(" ")[0],
+ settings.getRespawnBlockCommand().split(" "));
+ }
+
+ /**
+ * @throws java.lang.Exception
+ */
+ @AfterEach
+ public void tearDown() throws Exception {
+ super.tearDown();
+ }
+
+ /**
+ * Test method for {@link world.bentobox.aoneblock.commands.island.IslandRespawnBlockCommand#IslandRespawnBlockCommand(world.bentobox.bentobox.api.commands.CompositeCommand, java.lang.String, java.lang.String[])}.
+ */
+ @Test
+ void testIslandRespawnBlockCommand() {
+ assertNotNull(rbc);
+ }
+
+ /**
+ * Test method for {@link world.bentobox.aoneblock.commands.island.IslandRespawnBlockCommand#setup()}.
+ */
+ @Test
+ void testSetup() {
+ assertEquals("respawn-block", rbc.getPermission());
+ assertEquals("aoneblock.commands.respawn-block.description", rbc.getDescription());
+ assertTrue(rbc.isOnlyPlayer());
+ }
+
+ /**
+ * Test method for {@link world.bentobox.aoneblock.commands.island.IslandRespawnBlockCommand#canExecute(world.bentobox.bentobox.api.user.User, java.lang.String, java.util.List)}.
+ */
+ @Test
+ void testCanExecute() {
+ assertTrue(rbc.canExecute(user, "", List.of()));
+ verify(user, never()).sendMessage(anyString());
+ }
+ /**
+ * Test method for {@link world.bentobox.aoneblock.commands.island.IslandRespawnBlockCommand#canExecute(world.bentobox.bentobox.api.user.User, java.lang.String, java.util.List)}.
+ */
+ @Test
+ void testCanExecuteWrongWorld() {
+ mockedUtil.when(() -> Util.sameWorld(any(World.class), any(World.class))).thenReturn(false);
+ assertFalse(rbc.canExecute(user, "", List.of()));
+ verify(user).sendMessage("general.errors.wrong-world");
+ }
+
+ /**
+ * Test method for {@link world.bentobox.aoneblock.commands.island.IslandRespawnBlockCommand#canExecute(world.bentobox.bentobox.api.user.User, java.lang.String, java.util.List)}.
+ */
+ @Test
+ void testCanExecuteNoIsland() {
+ when(im.getIsland(world, user)).thenReturn(null);
+ assertFalse(rbc.canExecute(user, "", List.of()));
+ verify(user).sendMessage("general.errors.no-island");
+ }
+
+ /**
+ * Test method for {@link world.bentobox.aoneblock.commands.island.IslandRespawnBlockCommand#execute(world.bentobox.bentobox.api.user.User, java.lang.String, java.util.List)}.
+ */
+ @Test
+ void testExecuteUserStringListOfString() {
+ // when(block.getType()).thenReturn(Material.STONE);
+ rbc.execute(user, "", List.of());
+ verify(user).sendMessage("aoneblock.commands.respawn-block.block-respawned");
+ }
+
+ /**
+ * Test method for {@link world.bentobox.aoneblock.commands.island.IslandRespawnBlockCommand#execute(world.bentobox.bentobox.api.user.User, java.lang.String, java.util.List)}.
+ */
+ @Test
+ void testExecuteUserStringListOfStringAir() {
+ when(block.getType()).thenReturn(Material.AIR);
+ rbc.execute(user, "", List.of());
+ verify(user).sendMessage("aoneblock.commands.respawn-block.block-respawned");
+ }
+
+ /**
+ * Test method for {@link world.bentobox.aoneblock.commands.island.IslandRespawnBlockCommand#execute(world.bentobox.bentobox.api.user.User, java.lang.String, java.util.List)}.
+ */
+ @Test
+ void testExecuteUserStringListOfStringSomething() {
+ when(block.getType()).thenReturn(Material.STONE);
+ rbc.execute(user, "", List.of());
+ verify(user).sendMessage("aoneblock.commands.respawn-block.block-exist");
+ verify(world, times(18)).spawnParticle(eq(Particle.DUST), eq(location), eq(5), eq(0.1), eq(0.0d), eq(0.1), eq(1.0d), any());
+ }
+
+}
diff --git a/src/test/java/world/bentobox/aoneblock/commands/island/IslandSetCountCommandTest.java b/src/test/java/world/bentobox/aoneblock/commands/island/IslandSetCountCommandTest.java
index 58e50193..ff63e114 100644
--- a/src/test/java/world/bentobox/aoneblock/commands/island/IslandSetCountCommandTest.java
+++ b/src/test/java/world/bentobox/aoneblock/commands/island/IslandSetCountCommandTest.java
@@ -1,9 +1,9 @@
package world.bentobox.aoneblock.commands.island;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
@@ -11,212 +11,165 @@
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import java.beans.IntrospectionException;
import java.io.File;
-import java.io.IOException;
-import java.lang.reflect.InvocationTargetException;
-import java.nio.file.Files;
-import java.nio.file.Path;
import java.util.Collections;
-import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;
-import org.bukkit.Bukkit;
-import org.bukkit.World;
import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Player;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.mockito.Mock;
+import org.mockito.MockedStatic;
import org.mockito.Mockito;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
-import org.powermock.reflect.Whitebox;
import world.bentobox.aoneblock.AOneBlock;
+import world.bentobox.aoneblock.CommonTestSetup;
import world.bentobox.aoneblock.Settings;
+import world.bentobox.aoneblock.WhiteBox;
import world.bentobox.aoneblock.dataobjects.OneBlockIslands;
import world.bentobox.aoneblock.listeners.BlockListener;
import world.bentobox.aoneblock.oneblocks.OneBlockObject;
-import world.bentobox.bentobox.BentoBox;
import world.bentobox.bentobox.api.commands.CompositeCommand;
import world.bentobox.bentobox.api.localization.TextVariables;
import world.bentobox.bentobox.api.user.User;
import world.bentobox.bentobox.database.AbstractDatabaseHandler;
import world.bentobox.bentobox.database.DatabaseSetup;
-import world.bentobox.bentobox.database.objects.Island;
import world.bentobox.bentobox.managers.CommandsManager;
-import world.bentobox.bentobox.managers.IslandWorldManager;
-import world.bentobox.bentobox.managers.IslandsManager;
-import world.bentobox.bentobox.managers.LocalesManager;
import world.bentobox.bentobox.managers.RanksManager;
/**
* @author tastybento
*
*/
-@RunWith(PowerMockRunner.class)
-@PrepareForTest({ Bukkit.class, BentoBox.class, User.class, DatabaseSetup.class, RanksManager.class })
-public class IslandSetCountCommandTest {
- @Mock
- private BentoBox plugin;
- @Mock
- private CompositeCommand ac;
- @Mock
- private User user;
- @Mock
- private LocalesManager lm;
- @Mock
- private AOneBlock addon;
- private UUID uuid;
- @Mock
- private World world;
- @Mock
- private IslandsManager im;
- @Mock
- private @Nullable Island island;
- @Mock
- private IslandWorldManager iwm;
- private IslandSetCountCommand iscc;
- @Mock
- private BlockListener bl;
+public class IslandSetCountCommandTest extends CommonTestSetup {
@Mock
- private RanksManager rm;
-
- private @NonNull OneBlockIslands oneBlockIsland = new OneBlockIslands(UUID.randomUUID().toString());
+ private CompositeCommand ac;
- private static AbstractDatabaseHandler h;
+ @Mock
+ private User user;
+ @Mock
+ private AOneBlock addon;
+ private IslandSetCountCommand iscc;
+ @Mock
+ private BlockListener bl;
+ @Mock
+ private RanksManager rm;
- @SuppressWarnings("unchecked")
- @BeforeClass
- public static void beforeClass() throws IllegalAccessException, InvocationTargetException, IntrospectionException {
- // This has to be done beforeClass otherwise the tests will interfere with each
- // other
- h = mock(AbstractDatabaseHandler.class);
- // Database
- PowerMockito.mockStatic(DatabaseSetup.class);
- DatabaseSetup dbSetup = mock(DatabaseSetup.class);
- when(DatabaseSetup.getDatabase()).thenReturn(dbSetup);
- when(dbSetup.getHandler(any())).thenReturn(h);
- when(h.saveObject(any())).thenReturn(CompletableFuture.completedFuture(true));
- }
+ private final @NonNull OneBlockIslands oneBlockIsland = new OneBlockIslands(UUID.randomUUID().toString());
- @After
- public void tearDown() throws IOException {
- User.clearUsers();
- Mockito.framework().clearInlineMocks();
- deleteAll(new File("database"));
- deleteAll(new File("database_backup"));
- }
- private void deleteAll(File file) throws IOException {
- if (file.exists()) {
- Files.walk(file.toPath()).sorted(Comparator.reverseOrder()).map(Path::toFile).forEach(File::delete);
- }
+ @Override
+ @AfterEach
+ public void tearDown() throws Exception {
+ super.tearDown();
+ deleteAll(new File("database"));
+ deleteAll(new File("database_backup"));
+ }
- }
+ /**
+ * @throws java.lang.Exception
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ @BeforeEach
+ public void setUp() throws Exception {
+ super.setUp();
+ AbstractDatabaseHandler h = mock(AbstractDatabaseHandler.class);
+ // Database
+ MockedStatic mockedDb = Mockito.mockStatic(DatabaseSetup.class);
+ DatabaseSetup dbSetup = mock(DatabaseSetup.class);
+ mockedDb.when(DatabaseSetup::getDatabase).thenReturn(dbSetup);
+ when(dbSetup.getHandler(any())).thenReturn(h);
+ when(h.saveObject(any())).thenReturn(CompletableFuture.completedFuture(true));
- /**
- * @throws java.lang.Exception
- */
- @Before
- public void setUp() throws Exception {
- // Set up plugin
- BentoBox plugin = mock(BentoBox.class);
- Whitebox.setInternalState(BentoBox.class, "instance", plugin);
// Set up RanksManager
- Whitebox.setInternalState(RanksManager.class, "instance", rm);
-
- // Command manager
- CommandsManager cm = mock(CommandsManager.class);
- when(plugin.getCommandsManager()).thenReturn(cm);
-
- // Player
- Player p = mock(Player.class);
- // Sometimes use Mockito.withSettings().verboseLogging()
- when(user.isOp()).thenReturn(false);
- when(user.getPermissionValue(anyString(), anyInt())).thenReturn(4);
- when(user.getWorld()).thenReturn(world);
- uuid = UUID.randomUUID();
- when(user.getUniqueId()).thenReturn(uuid);
- when(user.getPlayer()).thenReturn(p);
- when(user.getName()).thenReturn("tastybento");
- when(user.getTranslation(any())).thenAnswer(invocation -> invocation.getArgument(0, String.class));
- User.setPlugin(plugin);
-
- // Parent command has no aliases
- when(ac.getSubCommandAliases()).thenReturn(new HashMap<>());
- when(ac.getWorld()).thenReturn(world);
- when(ac.getAddon()).thenReturn(addon);
-
- // Islands
- when(plugin.getIslands()).thenReturn(im);
- when(im.getIsland(world, user)).thenReturn(island);
- when(im.hasIsland(world, user)).thenReturn(true);
- when(im.inTeam(world, uuid)).thenReturn(true);
- when(island.getRankCommand(anyString())).thenReturn(RanksManager.OWNER_RANK);
- when(island.getRank(user)).thenReturn(RanksManager.MEMBER_RANK);
-
- // IWM
- when(plugin.getIWM()).thenReturn(iwm);
- when(iwm.getPermissionPrefix(any())).thenReturn("bskyblock.");
-
- // Settings
- Settings settings = new Settings();
- when(addon.getSettings()).thenReturn(settings);
-
- // BlockListener
- when(addon.getBlockListener()).thenReturn(bl);
- when(bl.getIsland(island)).thenReturn(oneBlockIsland);
-
- // DUT
- iscc = new IslandSetCountCommand(this.ac, settings.getSetCountCommand().split(" ")[0],
- settings.getSetCountCommand().split(" "));
- }
+ WhiteBox.setInternalState(RanksManager.class, "instance", rm);
+
+ // Command manager
+ CommandsManager cm = mock(CommandsManager.class);
+ when(plugin.getCommandsManager()).thenReturn(cm);
+
+ // Player
+ // Sometimes use Mockito.withSettings().verboseLogging()
+ when(user.isOp()).thenReturn(false);
+ when(user.getPermissionValue(anyString(), anyInt())).thenReturn(4);
+ when(user.getWorld()).thenReturn(world);
+ uuid = UUID.randomUUID();
+ when(user.getUniqueId()).thenReturn(uuid);
+ when(user.getPlayer()).thenReturn(mockPlayer);
+ when(user.getName()).thenReturn("tastybento");
+ when(user.getTranslation(any())).thenAnswer(invocation -> invocation.getArgument(0, String.class));
+ User.setPlugin(plugin);
+
+ // Parent command has no aliases
+ when(ac.getSubCommandAliases()).thenReturn(new HashMap<>());
+ when(ac.getWorld()).thenReturn(world);
+ when(ac.getAddon()).thenReturn(addon);
+
+ // Islands
+ //when(plugin.getIslands()).thenReturn(im);
+ when(im.getIsland(world, user)).thenReturn(island);
+ when(im.hasIsland(world, user)).thenReturn(true);
+ when(im.inTeam(world, uuid)).thenReturn(true);
+ when(island.getRankCommand(anyString())).thenReturn(RanksManager.OWNER_RANK);
+ when(island.getRank(user)).thenReturn(RanksManager.MEMBER_RANK);
+
+ // IWM
+ //when(plugin.getIWM()).thenReturn(iwm);
+ when(iwm.getPermissionPrefix(any())).thenReturn("bskyblock.");
+
+ // Settings
+ Settings settings = new Settings();
+ when(addon.getSettings()).thenReturn(settings);
+
+ // BlockListener
+ when(addon.getBlockListener()).thenReturn(bl);
+ when(bl.getIsland(island)).thenReturn(oneBlockIsland);
+
+ // DUT
+ iscc = new IslandSetCountCommand(this.ac, settings.getSetCountCommand().split(" ")[0],
+ settings.getSetCountCommand().split(" "));
+ }
- /**
- * Test method for
- * {@link world.bentobox.aoneblock.commands.island.IslandSetCountCommand#IslandSetCountCommand(world.bentobox.bentobox.api.commands.CompositeCommand, java.lang.String, java.lang.String[])}.
- */
- @Test
- public void testIslandSetCountCommand() {
- assertNotNull(iscc);
- }
+ /**
+ * Test method for
+ * {@link world.bentobox.aoneblock.commands.island.IslandSetCountCommand#IslandSetCountCommand(world.bentobox.bentobox.api.commands.CompositeCommand, java.lang.String, java.lang.String[])}.
+ */
+ @Test
+ public void testIslandSetCountCommand() {
+ assertNotNull(iscc);
+ }
- /**
- * Test method for
- * {@link world.bentobox.aoneblock.commands.island.IslandSetCountCommand#setup()}.
- */
- @Test
- public void testSetup() {
- assertEquals("island.setcount", iscc.getPermission());
- assertEquals("aoneblock.commands.island.setcount.parameters", iscc.getParameters());
- assertEquals("aoneblock.commands.island.setcount.description", iscc.getDescription());
- assertTrue(iscc.isConfigurableRankCommand());
- assertTrue(iscc.isOnlyPlayer());
+ /**
+ * Test method for
+ * {@link world.bentobox.aoneblock.commands.island.IslandSetCountCommand#setup()}.
+ */
+ @Test
+ public void testSetup() {
+ assertEquals("island.setcount", iscc.getPermission());
+ assertEquals("aoneblock.commands.island.setcount.parameters", iscc.getParameters());
+ assertEquals("aoneblock.commands.island.setcount.description", iscc.getDescription());
+ assertTrue(iscc.isConfigurableRankCommand());
+ assertTrue(iscc.isOnlyPlayer());
- }
+ }
- /**
- * Test method for
- * {@link world.bentobox.aoneblock.commands.island.IslandSetCountCommand#execute(world.bentobox.bentobox.api.user.User, java.lang.String, java.util.List)}.
- */
- public void testExecuteUserStringListOfStringShowHelp() {
- assertFalse(iscc.execute(user, "", Collections.emptyList()));
- verify(user).sendMessage("commands.help.header", "[label]", null);
- }
+ /**
+ * Test method for
+ * {@link world.bentobox.aoneblock.commands.island.IslandSetCountCommand#execute(world.bentobox.bentobox.api.user.User, java.lang.String, java.util.List)}.
+ */
+ public void testExecuteUserStringListOfStringShowHelp() {
+ assertFalse(iscc.execute(user, "", Collections.emptyList()));
+ verify(user).sendMessage("commands.help.header", "[label]", null);
+ }
- /**
+ /**
* Test method for {@link world.bentobox.aoneblock.commands.island.IslandSetCountCommand#execute(world.bentobox.bentobox.api.user.User, java.lang.String, java.util.List)}.
*/
@Test
@@ -227,18 +180,18 @@ public void testExecuteUserStringListOfStringNoIsland() {
verify(user).sendMessage("general.errors.no-island");
}
- /**
- * Test method for
- * {@link world.bentobox.aoneblock.commands.island.IslandSetCountCommand#execute(world.bentobox.bentobox.api.user.User, java.lang.String, java.util.List)}.
- */
- @Test
- public void testExecuteUserStringListOfStringLowRank() {
+ /**
+ * Test method for
+ * {@link world.bentobox.aoneblock.commands.island.IslandSetCountCommand#execute(world.bentobox.bentobox.api.user.User, java.lang.String, java.util.List)}.
+ */
+ @Test
+ public void testExecuteUserStringListOfStringLowRank() {
when(rm.getRank(anyInt())).thenReturn(RanksManager.MEMBER_RANK_REF);
- assertFalse(iscc.execute(user, "", List.of("2000")));
- verify(user).sendMessage("general.errors.insufficient-rank", TextVariables.RANK, RanksManager.MEMBER_RANK_REF);
- }
+ assertFalse(iscc.execute(user, "", List.of("2000")));
+ verify(user).sendMessage("general.errors.insufficient-rank", TextVariables.RANK, RanksManager.MEMBER_RANK_REF);
+ }
- /**
+ /**
* Test method for {@link world.bentobox.aoneblock.commands.island.IslandSetCountCommand#execute(world.bentobox.bentobox.api.user.User, java.lang.String, java.util.List)}.
*/
@Test
@@ -248,7 +201,7 @@ public void testExecuteUserStringListOfStringRankOKNegativeCount() {
verify(user).sendMessage("general.errors.must-be-positive-number", TextVariables.NUMBER, "-2000");
}
- /**
+ /**
* Test method for {@link world.bentobox.aoneblock.commands.island.IslandSetCountCommand#execute(world.bentobox.bentobox.api.user.User, java.lang.String, java.util.List)}.
*/
@Test
@@ -259,7 +212,7 @@ public void testExecuteUserStringListOfStringRankOKTooHighCount() {
verify(user).sendMessage("aoneblock.commands.island.setcount.too-high", TextVariables.NUMBER, "0");
}
- /**
+ /**
* Test method for {@link world.bentobox.aoneblock.commands.island.IslandSetCountCommand#execute(world.bentobox.bentobox.api.user.User, java.lang.String, java.util.List)}.
*/
@Test
diff --git a/src/test/java/world/bentobox/aoneblock/dataobjects/OneBlockIslandsTest.java b/src/test/java/world/bentobox/aoneblock/dataobjects/OneBlockIslandsTest.java
index 714e915f..de238ba2 100644
--- a/src/test/java/world/bentobox/aoneblock/dataobjects/OneBlockIslandsTest.java
+++ b/src/test/java/world/bentobox/aoneblock/dataobjects/OneBlockIslandsTest.java
@@ -1,29 +1,28 @@
package world.bentobox.aoneblock.dataobjects;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.List;
import java.util.Queue;
import java.util.UUID;
import org.bukkit.entity.EntityType;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.powermock.modules.junit4.PowerMockRunner;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import world.bentobox.aoneblock.CommonTestSetup;
import world.bentobox.aoneblock.oneblocks.OneBlockObject;
/**
* @author tastybento
*
*/
-@RunWith(PowerMockRunner.class)
-public class OneBlockIslandsTest {
+public class OneBlockIslandsTest extends CommonTestSetup {
private OneBlockIslands obi;
private String id;
@@ -31,8 +30,10 @@ public class OneBlockIslandsTest {
/**
* @throws java.lang.Exception
*/
- @Before
+ @Override
+ @BeforeEach
public void setUp() throws Exception {
+ super.setUp();
id = UUID.randomUUID().toString();
obi = new OneBlockIslands(id);
}
@@ -40,8 +41,10 @@ public void setUp() throws Exception {
/**
* @throws java.lang.Exception
*/
- @After
+ @Override
+ @AfterEach
public void tearDown() throws Exception {
+ super.tearDown();
}
/**
diff --git a/src/test/java/world/bentobox/aoneblock/listeners/BlockListenerTest.java b/src/test/java/world/bentobox/aoneblock/listeners/BlockListenerTest.java
index a43cca7d..63f39f46 100644
--- a/src/test/java/world/bentobox/aoneblock/listeners/BlockListenerTest.java
+++ b/src/test/java/world/bentobox/aoneblock/listeners/BlockListenerTest.java
@@ -1,135 +1,90 @@
package world.bentobox.aoneblock.listeners;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-import java.beans.IntrospectionException;
import java.io.File;
-import java.io.IOException;
-import java.lang.reflect.InvocationTargetException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.Comparator;
import java.util.Optional;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;
-import org.bukkit.Bukkit;
-import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
-import org.bukkit.entity.Player;
import org.bukkit.event.block.BlockFromToEvent;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.mockito.Mock;
+import org.mockito.MockedStatic;
import org.mockito.Mockito;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
-import org.powermock.reflect.Whitebox;
import world.bentobox.aoneblock.AOneBlock;
+import world.bentobox.aoneblock.CommonTestSetup;
import world.bentobox.aoneblock.dataobjects.OneBlockIslands;
import world.bentobox.aoneblock.oneblocks.OneBlockPhase;
import world.bentobox.aoneblock.oneblocks.OneBlocksManager;
import world.bentobox.bank.Bank;
import world.bentobox.bank.BankManager;
import world.bentobox.bank.data.Money;
-import world.bentobox.bentobox.BentoBox;
import world.bentobox.bentobox.Settings;
import world.bentobox.bentobox.api.user.User;
import world.bentobox.bentobox.database.AbstractDatabaseHandler;
import world.bentobox.bentobox.database.DatabaseSetup;
-import world.bentobox.bentobox.database.DatabaseSetup.DatabaseType;
import world.bentobox.bentobox.database.objects.Island;
-import world.bentobox.bentobox.managers.IslandsManager;
import world.bentobox.bentobox.managers.PlayersManager;
-import world.bentobox.bentobox.util.Util;
import world.bentobox.level.Level;
/**
* @author tastybento
*
*/
-@RunWith(PowerMockRunner.class)
-@PrepareForTest({Bukkit.class, BentoBox.class, DatabaseSetup.class, Util.class})
-public class BlockListenerTest {
+public class BlockListenerTest extends CommonTestSetup {
// Class under test
private BlockListener bl;
- @Mock
- BentoBox plugin;
@Mock
AOneBlock addon;
- private static AbstractDatabaseHandler h;
@Mock
private Settings pluginSettings;
- private User user;
- @Mock
- private World world;
@Mock
private OneBlocksManager obm;
private Island island;
- @Mock
- private @Nullable Player player;
-
@Mock
private PlayersManager pm;
@Mock
private Bank bank;
@Mock
private Level level;
- @Mock
- private Location location;
- @Mock
- private IslandsManager im;
private @NonNull OneBlockIslands is;
private @NonNull OneBlockPhase phase;
+ /**
+ * @throws java.lang.Exception
+ */
@SuppressWarnings("unchecked")
- @BeforeClass
- public static void beforeClass() throws IllegalAccessException, InvocationTargetException, IntrospectionException {
+ @BeforeEach
+ public void setUp() throws Exception {
+ super.setUp();
// This has to be done beforeClass otherwise the tests will interfere with each other
- h = mock(AbstractDatabaseHandler.class);
+ AbstractDatabaseHandler h = mock(AbstractDatabaseHandler.class);
// Database
- PowerMockito.mockStatic(DatabaseSetup.class);
+ MockedStatic mockDb = Mockito.mockStatic(DatabaseSetup.class);
DatabaseSetup dbSetup = mock(DatabaseSetup.class);
- when(DatabaseSetup.getDatabase()).thenReturn(dbSetup);
+ mockDb.when(DatabaseSetup::getDatabase).thenReturn(dbSetup);
when(dbSetup.getHandler(any())).thenReturn(h);
when(h.saveObject(any())).thenReturn(CompletableFuture.completedFuture(true));
- }
-
- /**
- * @throws java.lang.Exception
- */
- @Before
- public void setUp() throws Exception {
- tearDown();
- // Set up plugin
- Whitebox.setInternalState(BentoBox.class, "instance", plugin);
-
- PowerMockito.mockStatic(Bukkit.class, Mockito.RETURNS_MOCKS);
- // The database type has to be created one line before the thenReturn() to work!
- DatabaseType value = DatabaseType.JSON;
- when(plugin.getSettings()).thenReturn(pluginSettings);
- when(pluginSettings.getDatabaseType()).thenReturn(value);
// Addon
when(addon.getPlugin()).thenReturn(plugin);
@@ -140,12 +95,12 @@ public void setUp() throws Exception {
when(addon.inWorld(world)).thenReturn(true);
// Player
- when(player.getUniqueId()).thenReturn(UUID.randomUUID());
- when(player.getName()).thenReturn("tastybento");
- when(player.isOnline()).thenReturn(true);
- when(player.getWorld()).thenReturn(world);
+ when(mockPlayer.getUniqueId()).thenReturn(UUID.randomUUID());
+ when(mockPlayer.getName()).thenReturn("tastybento");
+ when(mockPlayer.isOnline()).thenReturn(true);
+ when(mockPlayer.getWorld()).thenReturn(world);
User.setPlugin(plugin);
- user = User.getInstance(player);
+ User user = User.getInstance(mockPlayer);
// Island
island = new Island();
@@ -176,20 +131,11 @@ public void setUp() throws Exception {
/**
* @throws java.lang.Exception - exception
*/
- @After
+ @Override
+ @AfterEach
public void tearDown() throws Exception {
+ super.tearDown();
deleteAll(new File("database"));
- User.clearUsers();
- Mockito.framework().clearInlineMocks();
- }
-
- private static void deleteAll(File file) throws IOException {
- if (file.exists()) {
- Files.walk(file.toPath())
- .sorted(Comparator.reverseOrder())
- .map(Path::toFile)
- .forEach(File::delete);
- }
}
/**
diff --git a/src/test/java/world/bentobox/aoneblock/listeners/BlockProtectTest.java b/src/test/java/world/bentobox/aoneblock/listeners/BlockProtectTest.java
index 66236c75..d96b9ac0 100644
--- a/src/test/java/world/bentobox/aoneblock/listeners/BlockProtectTest.java
+++ b/src/test/java/world/bentobox/aoneblock/listeners/BlockProtectTest.java
@@ -1,8 +1,8 @@
package world.bentobox.aoneblock.listeners;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyDouble;
import static org.mockito.ArgumentMatchers.anyInt;
@@ -20,14 +20,12 @@
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.Particle;
-import org.bukkit.Server;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.block.data.BlockData;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Player;
import org.bukkit.event.block.Action;
import org.bukkit.event.block.BlockPistonExtendEvent;
import org.bukkit.event.block.BlockPistonRetractEvent;
@@ -36,51 +34,36 @@
import org.bukkit.event.entity.EntitySpawnEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.ItemStack;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockbukkit.mockbukkit.MockBukkit;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.mockito.Mock;
-import org.powermock.modules.junit4.PowerMockRunner;
import world.bentobox.aoneblock.AOneBlock;
+import world.bentobox.aoneblock.CommonTestSetup;
import world.bentobox.aoneblock.Settings;
-import world.bentobox.bentobox.database.objects.Island;
-import world.bentobox.bentobox.managers.IslandsManager;
/**
* @author tastybento
*
*/
-@RunWith(PowerMockRunner.class)
-public class BlockProtectTest {
+public class BlockProtectTest extends CommonTestSetup {
private BlockProtect bp;
@Mock
AOneBlock addon;
@Mock
- private Player p;
- @Mock
private Block block;
- @Mock
- private World world;
- @Mock
- private Location location;
- @Mock
- private IslandsManager im;
- @Mock
- private Island island;
/**
* @throws java.lang.Exception
*/
- @Before
+ @Override
+ @BeforeEach
public void setUp() throws Exception {
-
- Server server = MockBukkit.mock();
-
- when(p.getWorld()).thenReturn(world);
+ super.setUp();
+
+ when(mockPlayer.getWorld()).thenReturn(world);
// In World
when(addon.inWorld(world)).thenReturn(true);
@@ -107,9 +90,10 @@ public void setUp() throws Exception {
/**
* @throws java.lang.Exception
*/
- @After
+ @Override
+ @AfterEach
public void tearDown() throws Exception {
- MockBukkit.unmock();
+ super.tearDown();
}
/**
@@ -121,12 +105,12 @@ public void testBlockProtect() {
}
/**
- * Test method for {@link world.bentobox.aoneblock.listeners.BlockProtect#onBlockDamage(org.bukkit.event.block.BlockDamageEvent)}.
+ * Test method for {@link world.bentobox.aoneblock.listeners.BlockProtect#onBlockDamage(PlayerInteractEvent)}.
*/
@Test
public void testOnBlockDamage() {
ItemStack item = new ItemStack(Material.DIAMOND_PICKAXE);
- PlayerInteractEvent blockDamageEvent = new PlayerInteractEvent(p, Action.LEFT_CLICK_BLOCK, item, block,
+ PlayerInteractEvent blockDamageEvent = new PlayerInteractEvent(mockPlayer, Action.LEFT_CLICK_BLOCK, item, block,
BlockFace.UP);
bp.onBlockDamage(blockDamageEvent);
verify(addon).inWorld(world);
@@ -136,13 +120,13 @@ public void testOnBlockDamage() {
}
/**
- * Test method for {@link world.bentobox.aoneblock.listeners.BlockProtect#onBlockDamage(org.bukkit.event.block.BlockDamageEvent)}.
+ * Test method for {@link world.bentobox.aoneblock.listeners.BlockProtect#onBlockDamage(PlayerInteractEvent)}.
*/
@Test
public void testOnBlockDamageWrongWorld() {
- when(p.getWorld()).thenReturn(mock(World.class));
+ when(mockPlayer.getWorld()).thenReturn(mock(World.class));
ItemStack item = new ItemStack(Material.DIAMOND_PICKAXE);
- PlayerInteractEvent blockDamageEvent = new PlayerInteractEvent(p, Action.LEFT_CLICK_BLOCK, item, block,
+ PlayerInteractEvent blockDamageEvent = new PlayerInteractEvent(mockPlayer, Action.LEFT_CLICK_BLOCK, item, block,
BlockFace.UP);
bp.onBlockDamage(blockDamageEvent);
verify(im, never()).getIslandAt(location);
@@ -151,13 +135,13 @@ public void testOnBlockDamageWrongWorld() {
}
/**
- * Test method for {@link world.bentobox.aoneblock.listeners.BlockProtect#onBlockDamage(org.bukkit.event.block.BlockDamageEvent)}.
+ * Test method for {@link world.bentobox.aoneblock.listeners.BlockProtect#onBlockDamage(PlayerInteractEvent)}.
*/
@Test
public void testOnBlockDamageNotCenterMagicBlock() {
when(block.getLocation()).thenReturn(mock(Location.class));
ItemStack item = new ItemStack(Material.DIAMOND_PICKAXE);
- PlayerInteractEvent blockDamageEvent = new PlayerInteractEvent(p, Action.LEFT_CLICK_BLOCK, item, block,
+ PlayerInteractEvent blockDamageEvent = new PlayerInteractEvent(mockPlayer, Action.LEFT_CLICK_BLOCK, item, block,
BlockFace.UP);
bp.onBlockDamage(blockDamageEvent);
verify(addon).inWorld(world);
@@ -172,7 +156,7 @@ public void testOnBlockDamageNotCenterMagicBlock() {
@Test
public void testOnBlockChange() {
BlockData blockData = mock(BlockData.class);
- EntityChangeBlockEvent event = new EntityChangeBlockEvent(p, block, blockData);
+ EntityChangeBlockEvent event = new EntityChangeBlockEvent(mockPlayer, block, blockData);
bp.onBlockChange(event);
assertTrue(event.isCancelled());
}
@@ -184,7 +168,7 @@ public void testOnBlockChange() {
public void testOnBlockChangeWrongWorld() {
when(block.getWorld()).thenReturn(mock(World.class));
BlockData blockData = mock(BlockData.class);
- EntityChangeBlockEvent event = new EntityChangeBlockEvent(p, block, blockData);
+ EntityChangeBlockEvent event = new EntityChangeBlockEvent(mockPlayer, block, blockData);
bp.onBlockChange(event);
assertFalse(event.isCancelled());
}
@@ -196,7 +180,7 @@ public void testOnBlockChangeWrongWorld() {
public void testOnBlockChangeNotMagicBlock() {
when(block.getLocation()).thenReturn(mock(Location.class));
BlockData blockData = mock(BlockData.class);
- EntityChangeBlockEvent event = new EntityChangeBlockEvent(p, block, blockData);
+ EntityChangeBlockEvent event = new EntityChangeBlockEvent(mockPlayer, block, blockData);
bp.onBlockChange(event);
assertFalse(event.isCancelled());
}
@@ -207,7 +191,7 @@ public void testOnBlockChangeNotMagicBlock() {
@Test
public void testOnExplosion() {
List blocks = new ArrayList<>();
- EntityExplodeEvent event = new EntityExplodeEvent(p, location, blocks, 0, null);
+ EntityExplodeEvent event = new EntityExplodeEvent(mockPlayer, location, blocks, 0, null);
bp.onExplosion(event);
assertTrue(blocks.isEmpty());
// Add the magic block
@@ -230,14 +214,14 @@ public void testOnExplosion() {
public void testOnExplosionWrongWorld() {
when(location.getWorld()).thenReturn(mock(World.class));
List blocks = new ArrayList<>();
- EntityExplodeEvent event = new EntityExplodeEvent(p, location, blocks, 0, null);
+ EntityExplodeEvent event = new EntityExplodeEvent(mockPlayer, location, blocks, 0, null);
blocks.add(block);
// Block as correct location, but wrong world
bp.onExplosion(event);
assertFalse(blocks.isEmpty());
// Normal blocks remain
blocks.add(mock(Block.class));
- event = new EntityExplodeEvent(p, location, blocks, 0, null);
+ event = new EntityExplodeEvent(mockPlayer, location, blocks, 0, null);
bp.onExplosion(event);
assertFalse(blocks.isEmpty());
}
diff --git a/src/test/java/world/bentobox/aoneblock/listeners/CheckPhaseTest.java b/src/test/java/world/bentobox/aoneblock/listeners/CheckPhaseTest.java
index c5a91791..557ed5e0 100644
--- a/src/test/java/world/bentobox/aoneblock/listeners/CheckPhaseTest.java
+++ b/src/test/java/world/bentobox/aoneblock/listeners/CheckPhaseTest.java
@@ -1,6 +1,6 @@
package world.bentobox.aoneblock.listeners;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
@@ -15,68 +15,45 @@
import java.util.Optional;
import java.util.UUID;
-import org.bukkit.Bukkit;
-import org.bukkit.World;
import org.bukkit.entity.Player;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
-import org.powermock.reflect.Whitebox;
import world.bentobox.aoneblock.AOneBlock;
+import world.bentobox.aoneblock.CommonTestSetup;
import world.bentobox.aoneblock.dataobjects.OneBlockIslands;
import world.bentobox.aoneblock.oneblocks.OneBlockPhase;
import world.bentobox.aoneblock.oneblocks.OneBlocksManager;
import world.bentobox.bank.Bank;
import world.bentobox.bank.BankManager;
import world.bentobox.bank.data.Money;
-import world.bentobox.bentobox.BentoBox;
import world.bentobox.bentobox.api.user.User;
-import world.bentobox.bentobox.database.DatabaseSetup;
import world.bentobox.bentobox.database.objects.Island;
-import world.bentobox.bentobox.managers.IslandsManager;
import world.bentobox.bentobox.managers.PlaceholdersManager;
import world.bentobox.bentobox.managers.PlayersManager;
-import world.bentobox.bentobox.util.Util;
import world.bentobox.level.Level;
/**
* @author tastybento
*
*/
-@RunWith(PowerMockRunner.class)
-@PrepareForTest({ Bukkit.class, BentoBox.class, DatabaseSetup.class, Util.class })
-public class CheckPhaseTest {
+public class CheckPhaseTest extends CommonTestSetup {
- @Mock
- BentoBox plugin;
@Mock
AOneBlock addon;
@Mock
- private World world;
- @Mock
private PlayersManager pm;
- @Mock
- private IslandsManager im;
private @NonNull OneBlockIslands is;
private @NonNull OneBlockPhase phase;
@Mock
private OneBlocksManager obm;
- @Mock
- private @Nullable Player player;
private Island island;
private CheckPhase bl;
- private User user;
@Mock
private PlaceholdersManager phm;
@Mock
@@ -89,60 +66,60 @@ public class CheckPhaseTest {
/**
* @throws java.lang.Exception
*/
- @Before
+ @Override
+ @BeforeEach
public void setUp() throws Exception {
- // Bukkit
- PowerMockito.mockStatic(Bukkit.class, Mockito.RETURNS_MOCKS);
- // Set up plugin
- Whitebox.setInternalState(BentoBox.class, "instance", plugin);
-
- // Addon
- when(addon.getPlugin()).thenReturn(plugin);
- when(addon.getOneBlockManager()).thenReturn(obm);
- when(addon.getPlayers()).thenReturn(pm);
- when(addon.getOverWorld()).thenReturn(world);
- when(addon.getIslands()).thenReturn(im);
- when(addon.inWorld(world)).thenReturn(true);
- when(addon.getBlockListener()).thenReturn(blis);
-
- // Player
- when(player.getUniqueId()).thenReturn(UUID.randomUUID());
- when(player.getName()).thenReturn("tastybento");
- when(player.isOnline()).thenReturn(true);
- when(player.getWorld()).thenReturn(world);
- User.setPlugin(plugin);
- user = User.getInstance(player);
-
- // Island
- island = new Island();
- island.setOwner(UUID.randomUUID());
- island.setName("island_name");
- // Players Manager
- when(pm.getName(any())).thenReturn("tastybento2");
- when(pm.getUser(any(UUID.class))).thenReturn(user);
-
- // Bank
- BankManager bm = mock(BankManager.class);
- when(bank.getBankManager()).thenReturn(bm);
- // Phat balance to start
- when(bm.getBalance(island)).thenReturn(new Money(100000D));
- when(addon.getAddonByName("Bank")).thenReturn(Optional.of(bank));
- // Level
- when(level.getIslandLevel(eq(world), any())).thenReturn(1000L);
- when(addon.getAddonByName("Level")).thenReturn(Optional.of(level));
-
- // Placeholders
- when(plugin.getPlaceholdersManager()).thenReturn(phm);
- when(phm.replacePlaceholders(any(), anyString())).thenAnswer(a -> (String) a.getArgument(1, String.class));
-
- bl = new CheckPhase(addon, blis);
+ super.setUp();
+
+ // Addon
+ when(addon.getPlugin()).thenReturn(plugin);
+ when(addon.getOneBlockManager()).thenReturn(obm);
+ when(addon.getPlayers()).thenReturn(pm);
+ when(addon.getOverWorld()).thenReturn(world);
+ when(addon.getIslands()).thenReturn(im);
+ when(addon.inWorld(world)).thenReturn(true);
+ when(addon.getBlockListener()).thenReturn(blis);
+
+ // Player
+ when(mockPlayer.getUniqueId()).thenReturn(UUID.randomUUID());
+ when(mockPlayer.getName()).thenReturn("tastybento");
+ when(mockPlayer.isOnline()).thenReturn(true);
+ when(mockPlayer.getWorld()).thenReturn(world);
+ User.setPlugin(plugin);
+ User user = User.getInstance(mockPlayer);
+
+ // Island
+ island = new Island();
+ island.setOwner(UUID.randomUUID());
+ island.setName("island_name");
+ // Players Manager
+ when(pm.getName(any())).thenReturn("tastybento2");
+ when(pm.getUser(any(UUID.class))).thenReturn(user);
+
+ // Bank
+ BankManager bm = mock(BankManager.class);
+ when(bank.getBankManager()).thenReturn(bm);
+ // Phat balance to start
+ when(bm.getBalance(island)).thenReturn(new Money(100000D));
+ when(addon.getAddonByName("Bank")).thenReturn(Optional.of(bank));
+ // Level
+ when(level.getIslandLevel(eq(world), any())).thenReturn(1000L);
+ when(addon.getAddonByName("Level")).thenReturn(Optional.of(level));
+
+ // Placeholders
+ when(plugin.getPlaceholdersManager()).thenReturn(phm);
+ when(phm.replacePlaceholders(any(), anyString())).thenAnswer(a -> (String) a.getArgument(1, String.class));
+
+ bl = new CheckPhase(addon, blis);
}
/**
* @throws java.lang.Exception
*/
- @After
+ @Override
+ @AfterEach
public void tearDown() throws Exception {
+ super.tearDown();
}
/**
@@ -151,30 +128,30 @@ public void tearDown() throws Exception {
*/
@Test
public void testSetNewPhase() {
- // Set up that a phase has been completed
- is = new OneBlockIslands(UUID.randomUUID().toString());
- is.setPhaseName("Previous");
- is.setBlockNumber(500);
- is.setLifetime(500L);
- // The phase the user has just moved to
- phase = new OneBlockPhase("500");
- phase.setPhaseName("Next Phase");
- phase.setStartCommands(List.of("start1", "start2"));
-
- // The previous phase
- OneBlockPhase previous = mock(OneBlockPhase.class);
- when(previous.getPhaseName()).thenReturn("Previous");
-
- when(obm.getPhase("Previous")).thenReturn(Optional.of(previous));
-
- bl.setNewPhase(player, island, is, phase);
- // Verify commands run
- verify(previous).getEndCommands();
- verify(previous).getFirstTimeEndCommands();
- // Verify phase name change
- assertEquals("Next Phase", is.getPhaseName());
- // Verify title shown
- verify(player).sendTitle("Next Phase", null, -1, -1, -1);
+ // Set up that a phase has been completed
+ is = new OneBlockIslands(UUID.randomUUID().toString());
+ is.setPhaseName("Previous");
+ is.setBlockNumber(500);
+ is.setLifetime(500L);
+ // The phase the user has just moved to
+ phase = new OneBlockPhase("500");
+ phase.setPhaseName("Next Phase");
+ phase.setStartCommands(List.of("start1", "start2"));
+
+ // The previous phase
+ OneBlockPhase previous = mock(OneBlockPhase.class);
+ when(previous.getPhaseName()).thenReturn("Previous");
+
+ when(obm.getPhase("Previous")).thenReturn(Optional.of(previous));
+
+ bl.setNewPhase(mockPlayer, island, is, phase);
+ // Verify commands run
+ verify(previous).getEndCommands();
+ verify(previous).getFirstTimeEndCommands();
+ // Verify phase name change
+ assertEquals("Next Phase", is.getPhaseName());
+ // Verify title shown
+ verify(mockPlayer).sendTitle("Next Phase", null, -1, -1, -1);
}
@@ -184,30 +161,30 @@ public void testSetNewPhase() {
*/
@Test
public void testSetNewPhaseSecondTime() {
- // Set up that a phase has been completed
- is = new OneBlockIslands(UUID.randomUUID().toString());
- is.setPhaseName("Previous");
- is.setBlockNumber(500);
- is.setLifetime(10500L);
- // The phase the user has just moved to
- phase = new OneBlockPhase("500");
- phase.setPhaseName("Next Phase");
- phase.setStartCommands(List.of("start1", "start2"));
-
- // The previous phase
- OneBlockPhase previous = mock(OneBlockPhase.class);
- when(previous.getPhaseName()).thenReturn("Previous");
-
- when(obm.getPhase("Previous")).thenReturn(Optional.of(previous));
-
- bl.setNewPhase(player, island, is, phase);
- // Verify commands run
- verify(previous).getEndCommands();
- verify(previous, never()).getFirstTimeEndCommands();
- // Verify phase name change
- assertEquals("Next Phase", is.getPhaseName());
- // Verify title shown
- verify(player).sendTitle("Next Phase", null, -1, -1, -1);
+ // Set up that a phase has been completed
+ is = new OneBlockIslands(UUID.randomUUID().toString());
+ is.setPhaseName("Previous");
+ is.setBlockNumber(500);
+ is.setLifetime(10500L);
+ // The phase the user has just moved to
+ phase = new OneBlockPhase("500");
+ phase.setPhaseName("Next Phase");
+ phase.setStartCommands(List.of("start1", "start2"));
+
+ // The previous phase
+ OneBlockPhase previous = mock(OneBlockPhase.class);
+ when(previous.getPhaseName()).thenReturn("Previous");
+
+ when(obm.getPhase("Previous")).thenReturn(Optional.of(previous));
+
+ bl.setNewPhase(mockPlayer, island, is, phase);
+ // Verify commands run
+ verify(previous).getEndCommands();
+ verify(previous, never()).getFirstTimeEndCommands();
+ // Verify phase name change
+ assertEquals("Next Phase", is.getPhaseName());
+ // Verify title shown
+ verify(mockPlayer).sendTitle("Next Phase", null, -1, -1, -1);
}
@@ -217,30 +194,30 @@ public void testSetNewPhaseSecondTime() {
*/
@Test
public void testSetNewPhaseNullPlayer() {
- // Set up that a phase has been completed
- is = new OneBlockIslands(UUID.randomUUID().toString());
- is.setPhaseName("Previous");
- is.setBlockNumber(500);
- is.setLifetime(500L);
- // The phase the user has just moved to
- phase = new OneBlockPhase("500");
- phase.setPhaseName("Next Phase");
- phase.setStartCommands(List.of("start1", "start2"));
-
- // The previous phase
- OneBlockPhase previous = mock(OneBlockPhase.class);
- when(previous.getPhaseName()).thenReturn("Previous");
-
- when(obm.getPhase("Previous")).thenReturn(Optional.of(previous));
-
- bl.setNewPhase(null, island, is, phase);
- // Verify commands run
- verify(previous).getEndCommands();
- verify(previous).getFirstTimeEndCommands();
- // Verify phase name change
- assertEquals("Next Phase", is.getPhaseName());
- // Verify title shown
- verify(player).sendTitle("Next Phase", null, -1, -1, -1);
+ // Set up that a phase has been completed
+ is = new OneBlockIslands(UUID.randomUUID().toString());
+ is.setPhaseName("Previous");
+ is.setBlockNumber(500);
+ is.setLifetime(500L);
+ // The phase the user has just moved to
+ phase = new OneBlockPhase("500");
+ phase.setPhaseName("Next Phase");
+ phase.setStartCommands(List.of("start1", "start2"));
+
+ // The previous phase
+ OneBlockPhase previous = mock(OneBlockPhase.class);
+ when(previous.getPhaseName()).thenReturn("Previous");
+
+ when(obm.getPhase("Previous")).thenReturn(Optional.of(previous));
+
+ bl.setNewPhase(null, island, is, phase);
+ // Verify commands run
+ verify(previous).getEndCommands();
+ verify(previous).getFirstTimeEndCommands();
+ // Verify phase name change
+ assertEquals("Next Phase", is.getPhaseName());
+ // Verify title shown
+ verify(mockPlayer).sendTitle("Next Phase", null, -1, -1, -1);
}
@@ -249,7 +226,7 @@ public void testSetNewPhaseNullPlayer() {
*/
@Test
public void testCheckPhaseNPCPlayer() {
- when(player.hasMetadata("NPC")).thenReturn(true);
+ when(mockPlayer.hasMetadata("NPC")).thenReturn(true);
// Set up that a phase has been completed
is = new OneBlockIslands(UUID.randomUUID().toString());
is.setPhaseName("Previous");
@@ -266,14 +243,14 @@ public void testCheckPhaseNPCPlayer() {
when(obm.getPhase("Previous")).thenReturn(Optional.of(previous));
- bl.setNewPhase(player, island, is, phase);
+ bl.setNewPhase(mockPlayer, island, is, phase);
// Verify commands run
verify(previous).getEndCommands();
verify(previous).getFirstTimeEndCommands();
// Verify phase name change
assertEquals("Next Phase", is.getPhaseName());
// Verify title shown
- verify(player).sendTitle("Next Phase", null, -1, -1, -1);
+ verify(mockPlayer).sendTitle("Next Phase", null, -1, -1, -1);
}
@@ -283,24 +260,24 @@ public void testCheckPhaseNPCPlayer() {
*/
@Test
public void testReplacePlaceholders() {
- // Commands
- /*
- * [island] - Island name [owner] - Island owner's name [player] - The name of
- * the player who broke the block triggering the commands [phase] - the name of
- * this phase [blocks] - the number of blocks broken [level] - island level
- * (Requires Levels Addon) [bank-balance] - island bank balance (Requires Bank
- * Addon) [eco-balance] - player's economy balance (Requires Vault and an
- * economy plugin)
- *
- */
- List commandList = new ArrayList<>();
-
- commandList.add("no replacement");
- commandList.add("[island] [owner] [phase] [blocks] [level] [bank-balance] [eco-balance]");
- List r = bl.replacePlaceholders(player, "phaseName", "1000", island, commandList);
- assertEquals(2, r.size());
- assertEquals("no replacement", r.get(0));
- assertEquals("island_name tastybento2 phaseName 1000 1000 100000.0 0.0", r.get(1));
- verify(phm, times(2)).replacePlaceholders(eq(player), any());
+ // Commands
+ /*
+ * [island] - Island name [owner] - Island owner's name [player] - The name of
+ * the player who broke the block triggering the commands [phase] - the name of
+ * this phase [blocks] - the number of blocks broken [level] - island level
+ * (Requires Levels Addon) [bank-balance] - island bank balance (Requires Bank
+ * Addon) [eco-balance] - player's economy balance (Requires Vault and an
+ * economy plugin)
+ *
+ */
+ List commandList = new ArrayList<>();
+
+ commandList.add("no replacement");
+ commandList.add("[island] [owner] [phase] [blocks] [level] [bank-balance] [eco-balance]");
+ List r = bl.replacePlaceholders(mockPlayer, "phaseName", "1000", island, commandList);
+ assertEquals(2, r.size());
+ assertEquals("no replacement", r.get(0));
+ assertEquals("island_name tastybento2 phaseName 1000 1000 100000.0 0.0", r.get(1));
+ verify(phm, times(2)).replacePlaceholders(eq(mockPlayer), any());
}
}
diff --git a/src/test/java/world/bentobox/aoneblock/listeners/HoloListenerTest.java b/src/test/java/world/bentobox/aoneblock/listeners/HoloListenerTest.java
index 5b4f40a9..5bb1b2a4 100644
--- a/src/test/java/world/bentobox/aoneblock/listeners/HoloListenerTest.java
+++ b/src/test/java/world/bentobox/aoneblock/listeners/HoloListenerTest.java
@@ -1,6 +1,6 @@
package world.bentobox.aoneblock.listeners;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyDouble;
import static org.mockito.ArgumentMatchers.anyInt;
@@ -16,86 +16,54 @@
import java.util.Collection;
import java.util.List;
-import java.util.UUID;
import java.util.concurrent.CompletableFuture;
-import org.bukkit.Bukkit;
import org.bukkit.Chunk;
import org.bukkit.Location;
-import org.bukkit.World;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Player;
import org.bukkit.entity.TextDisplay;
-import org.bukkit.scheduler.BukkitScheduler;
import org.bukkit.util.Vector;
import org.eclipse.jdt.annotation.NonNull;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
-import org.powermock.reflect.Whitebox;
import world.bentobox.aoneblock.AOneBlock;
+import world.bentobox.aoneblock.CommonTestSetup;
import world.bentobox.aoneblock.Settings;
import world.bentobox.aoneblock.dataobjects.OneBlockIslands;
import world.bentobox.aoneblock.oneblocks.OneBlockPhase;
-import world.bentobox.bentobox.BentoBox;
import world.bentobox.bentobox.api.events.island.IslandDeleteEvent;
import world.bentobox.bentobox.api.user.User;
-import world.bentobox.bentobox.database.objects.Island;
-import world.bentobox.bentobox.managers.LocalesManager;
-import world.bentobox.bentobox.managers.PlaceholdersManager;
import world.bentobox.bentobox.util.Util;
/**
* @author tastybento
*
*/
-@RunWith(PowerMockRunner.class)
-@PrepareForTest({ Bukkit.class, BentoBox.class, User.class, Util.class })
-public class HoloListenerTest {
- @Mock
- private BentoBox plugin;
+public class HoloListenerTest extends CommonTestSetup {
@Mock
AOneBlock addon;
private HoloListener hl;
@Mock
- private Island island;
- private UUID uuid = UUID.randomUUID();
- @Mock
- private Location location;
- @Mock
- private World world;
- @Mock
private TextDisplay hologram;
private Settings settings;
@Mock
private @NonNull OneBlockIslands is;
@Mock
- private Player player;
- @Mock
- private LocalesManager lm;
- @Mock
- private PlaceholdersManager pm;
- @Mock
- private BukkitScheduler scheduler;
- @Mock
private @NonNull OneBlockPhase phase;
/**
* @throws java.lang.Exception
*/
- @Before
+ @Override
+ @BeforeEach
public void setUp() throws Exception {
- // Set up plugin
- Whitebox.setInternalState(BentoBox.class, "instance", plugin);
+ super.setUp();
// Settings
settings = new Settings();
when(addon.getSettings()).thenReturn(settings);
@@ -115,9 +83,8 @@ public void setUp() throws Exception {
when(location.clone()).thenReturn(location);
when(location.add(any(Vector.class))).thenReturn(location);
// Chunks
- PowerMockito.mockStatic(Util.class, Mockito.RETURNS_MOCKS);
CompletableFuture future = CompletableFuture.completedFuture(null);
- when(Util.getChunkAtAsync(location)).thenReturn(future); // Load the chunk immediately
+ mockedUtil.when(() -> Util.getChunkAtAsync(location)).thenReturn(future); // Load the chunk immediately
Player nonHolo = mock(Player.class);
@@ -127,24 +94,18 @@ public void setUp() throws Exception {
when(world.getNearbyEntities(any(Location.class), anyDouble(), anyDouble(), anyDouble())).thenReturn(entities);
// Player and translations
- when(player.getUniqueId()).thenReturn(uuid);
- User.getInstance(player);
+ when(mockPlayer.getUniqueId()).thenReturn(uuid);
+ User.getInstance(mockPlayer);
User.setPlugin(plugin);
- when(plugin.getLocalesManager()).thenReturn(lm);
- when(plugin.getPlaceholdersManager()).thenReturn(pm);
-
- // Bukkit
- PowerMockito.mockStatic(Bukkit.class, Mockito.RETURNS_MOCKS);
- when(Bukkit.getScheduler()).thenReturn(scheduler);
-
// DUT
hl = new HoloListener(addon);
}
- @After
- public void tearDown() {
- User.clearUsers();
+ @Override
+ @AfterEach
+ public void tearDown()throws Exception {
+ super.tearDown();
}
/**
@@ -183,7 +144,7 @@ public void testOnDisable() {
public void testSetUpNoHolograms() {
settings.setUseHolograms(false);
hl.setUp(island, is, true);
- verify(scheduler, never()).runTaskLater(isNull(), any(Runnable.class), anyLong());
+ verify(sch, never()).runTaskLater(isNull(), any(Runnable.class), anyLong());
}
/**
@@ -193,7 +154,7 @@ public void testSetUpNoHolograms() {
public void testSetUpNoScheduling() {
settings.setHologramDuration(0);
hl.setUp(island, is, true);
- verify(scheduler, never()).runTaskLater(isNull(), any(Runnable.class), anyLong());
+ verify(sch, never()).runTaskLater(isNull(), any(Runnable.class), anyLong());
}
/**
@@ -202,8 +163,8 @@ public void testSetUpNoScheduling() {
@Test
public void testSetUpNewIsland() {
hl.setUp(island, is, true);
- verify(is).setHologram("");
- verify(scheduler).runTaskLater(isNull(), any(Runnable.class), anyLong());
+ verify(is).setHologram("aoneblock.island.starting-hologram");
+ verify(sch).runTaskLater(isNull(), any(Runnable.class), anyLong());
}
/**
@@ -213,7 +174,7 @@ public void testSetUpNewIsland() {
public void testSetUpNotNewIsland() {
hl.setUp(island, is, false);
verify(is, never()).setHologram(anyString());
- verify(scheduler).runTaskLater(isNull(), any(Runnable.class), anyLong());
+ verify(sch).runTaskLater(isNull(), any(Runnable.class), anyLong());
}
@@ -225,7 +186,7 @@ public void testProcessNull() {
when(phase.getHologramLine(anyInt())).thenReturn(null);
when(is.getHologram()).thenReturn(""); // Return blank
hl.process(island, is, phase);
- verify(scheduler, never()).runTaskLater(isNull(), any(Runnable.class), anyLong());
+ verify(sch, never()).runTaskLater(isNull(), any(Runnable.class), anyLong());
}
/**
@@ -235,7 +196,7 @@ public void testProcessNull() {
public void testProcess() {
when(phase.getHologramLine(anyInt())).thenReturn("my Holo");
hl.process(island, is, phase);
- verify(scheduler).runTaskLater(isNull(), any(Runnable.class), anyLong());
+ verify(sch).runTaskLater(isNull(), any(Runnable.class), anyLong());
}
}
diff --git a/src/test/java/world/bentobox/aoneblock/listeners/InfoListenerTest.java b/src/test/java/world/bentobox/aoneblock/listeners/InfoListenerTest.java
index 4a55b186..1ff37cbf 100644
--- a/src/test/java/world/bentobox/aoneblock/listeners/InfoListenerTest.java
+++ b/src/test/java/world/bentobox/aoneblock/listeners/InfoListenerTest.java
@@ -1,76 +1,47 @@
package world.bentobox.aoneblock.listeners;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.mockito.ArgumentMatchers.any;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.mockito.Mockito.atLeast;
import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.List;
import java.util.UUID;
-import org.bukkit.Location;
-import org.bukkit.World;
import org.bukkit.entity.Player;
import org.bukkit.entity.Player.Spigot;
import org.eclipse.jdt.annotation.NonNull;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.powermock.modules.junit4.PowerMockRunner;
import net.md_5.bungee.api.chat.TextComponent;
import world.bentobox.aoneblock.AOneBlock;
+import world.bentobox.aoneblock.CommonTestSetup;
import world.bentobox.aoneblock.dataobjects.OneBlockIslands;
-import world.bentobox.bentobox.BentoBox;
import world.bentobox.bentobox.api.addons.Addon;
import world.bentobox.bentobox.api.events.island.IslandInfoEvent;
import world.bentobox.bentobox.api.user.User;
-import world.bentobox.bentobox.database.objects.Island;
-import world.bentobox.bentobox.managers.IslandsManager;
-import world.bentobox.bentobox.managers.LocalesManager;
-import world.bentobox.bentobox.managers.PlaceholdersManager;
/**
* @author tastybento
*
*/
-@RunWith(PowerMockRunner.class)
-public class InfoListenerTest {
- @Mock
- private BentoBox plugin;
+public class InfoListenerTest extends CommonTestSetup {
@Mock
private AOneBlock addon;
- @Mock
- private Player p;
-
@Mock
private BlockListener bl;
@Mock
- private Location location;
- @Mock
- private IslandsManager im;
- @Mock
- private Island island;
- @Mock
private Player player;
- @Mock
- private World world;
private InfoListener il;
@Mock
private @NonNull OneBlockIslands is;
@Mock
- private LocalesManager lm;
- @Mock
- private PlaceholdersManager phm;
- @Mock
private Spigot spigot;
private static final UUID ID = UUID.randomUUID();
@@ -78,14 +49,12 @@ public class InfoListenerTest {
/**
* @throws java.lang.Exception
*/
- @Before
+ @Override
+ @BeforeEach
public void setUp() throws Exception {
+ super.setUp();
when(addon.getPlugin()).thenReturn(plugin);
- when(plugin.getLocalesManager()).thenReturn(lm);
- when(lm.get(toString())).thenAnswer(invocation -> invocation.getArgument(0, String.class));
- when(phm.replacePlaceholders(any(), any())).thenAnswer(invocation -> invocation.getArgument(1, String.class));
- when(plugin.getPlaceholdersManager()).thenReturn(phm);
User.setPlugin(plugin);
// Player
@@ -99,7 +68,7 @@ public void setUp() throws Exception {
when(addon.getOverWorld()).thenReturn(world);
// Player
- when(p.getUniqueId()).thenReturn(ID);
+ when(mockPlayer.getUniqueId()).thenReturn(ID);
User.getInstance(player);
// Island
@@ -118,10 +87,10 @@ public void setUp() throws Exception {
/**
* @throws java.lang.Exception - exception
*/
- @After
+ @Override
+ @AfterEach
public void tearDown() throws Exception {
- User.clearUsers();
- Mockito.framework().clearInlineMocks();
+ super.tearDown();
}
@@ -177,8 +146,8 @@ public void checkSpigotMessage(String expectedMessage, int expectedOccurrences)
.count(); // Count how many times the expected message appears
// Assert that the number of occurrences matches the expectedOccurrences
- assertEquals("Expected message occurrence mismatch: " + expectedMessage, expectedOccurrences,
- actualOccurrences);
+ assertEquals(expectedOccurrences,
+ actualOccurrences, "Expected message occurrence mismatch: " + expectedMessage);
}
}
diff --git a/src/test/java/world/bentobox/aoneblock/listeners/JoinLeaveListenerTest.java b/src/test/java/world/bentobox/aoneblock/listeners/JoinLeaveListenerTest.java
index e88d1269..e19b073f 100644
--- a/src/test/java/world/bentobox/aoneblock/listeners/JoinLeaveListenerTest.java
+++ b/src/test/java/world/bentobox/aoneblock/listeners/JoinLeaveListenerTest.java
@@ -1,6 +1,6 @@
package world.bentobox.aoneblock.listeners;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.never;
@@ -10,56 +10,40 @@
import java.util.UUID;
import java.util.concurrent.CompletableFuture;
-import org.bukkit.Location;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.util.Vector;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.mockito.Mock;
-import org.powermock.modules.junit4.PowerMockRunner;
import world.bentobox.aoneblock.AOneBlock;
-import world.bentobox.bentobox.database.objects.Island;
-import world.bentobox.bentobox.managers.IslandsManager;
+import world.bentobox.aoneblock.CommonTestSetup;
/**
* @author tastybento
*/
-@RunWith(PowerMockRunner.class)
-public class JoinLeaveListenerTest {
+public class JoinLeaveListenerTest extends CommonTestSetup {
@Mock
private AOneBlock aob;
- @Mock
- private Player p;
-
private JoinLeaveListener jll;
@Mock
private BlockListener bl;
- @Mock
- private Location location;
- @Mock
- private IslandsManager im;
- @Mock
- private Island island;
- @Mock
- private World world;
private static final UUID ID = UUID.randomUUID();
private static final Vector VECTOR = new Vector(123,120,456);
/**
* @throws java.lang.Exception
*/
- @Before
+ @Override
+ @BeforeEach
public void setUp() throws Exception {
+ super.setUp();
when(aob.getOverWorld()).thenReturn(world);
// Player
- when(p.getUniqueId()).thenReturn(ID);
+ when(mockPlayer.getUniqueId()).thenReturn(ID);
// Island
when(island.getCenter()).thenReturn(location);
@@ -80,8 +64,10 @@ public void setUp() throws Exception {
/**
* @throws java.lang.Exception
*/
- @After
+ @Override
+ @AfterEach
public void tearDown() throws Exception {
+ super.tearDown();
}
/**
@@ -97,7 +83,7 @@ public void testJoinLeaveListener() {
*/
@Test
public void testOnPlayerQuit() {
- PlayerQuitEvent event = new PlayerQuitEvent(p, "nothing");
+ PlayerQuitEvent event = new PlayerQuitEvent(mockPlayer, "nothing");
jll.onPlayerQuit(event);
verify(aob,never()).logError(anyString());
verify(bl).saveIsland(island);
@@ -109,7 +95,7 @@ public void testOnPlayerQuit() {
@Test
public void testOnPlayerQuitNoIsland() {
when(im.getIsland(world, ID)).thenReturn(null);
- PlayerQuitEvent event = new PlayerQuitEvent(p, "nothing");
+ PlayerQuitEvent event = new PlayerQuitEvent(mockPlayer, "nothing");
jll.onPlayerQuit(event);
verify(aob,never()).logError(anyString());
verify(bl, never()).saveIsland(island);
@@ -121,7 +107,7 @@ public void testOnPlayerQuitNoIsland() {
@Test
public void testOnPlayerQuitSaveError() {
when(bl.saveIsland(any())).thenReturn(CompletableFuture.completedFuture(Boolean.FALSE));
- PlayerQuitEvent event = new PlayerQuitEvent(p, "nothing");
+ PlayerQuitEvent event = new PlayerQuitEvent(mockPlayer, "nothing");
jll.onPlayerQuit(event);
verify(aob).logError(anyString());
verify(bl).saveIsland(island);
diff --git a/src/test/java/world/bentobox/aoneblock/listeners/NoBlockHandlerTest.java b/src/test/java/world/bentobox/aoneblock/listeners/NoBlockHandlerTest.java
index 379f85b2..78f6a129 100644
--- a/src/test/java/world/bentobox/aoneblock/listeners/NoBlockHandlerTest.java
+++ b/src/test/java/world/bentobox/aoneblock/listeners/NoBlockHandlerTest.java
@@ -1,6 +1,6 @@
package world.bentobox.aoneblock.listeners;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
@@ -8,60 +8,45 @@
import java.util.UUID;
-import org.bukkit.Location;
import org.bukkit.Material;
-import org.bukkit.World;
import org.bukkit.block.Block;
-import org.bukkit.entity.Player;
import org.bukkit.event.player.PlayerRespawnEvent;
import org.bukkit.event.player.PlayerRespawnEvent.RespawnReason;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.mockito.Mock;
-import org.powermock.modules.junit4.PowerMockRunner;
import world.bentobox.aoneblock.AOneBlock;
-import world.bentobox.bentobox.database.objects.Island;
-import world.bentobox.bentobox.managers.IslandsManager;
+import world.bentobox.aoneblock.CommonTestSetup;
/**
* @author tastybento
*
*/
-@RunWith(PowerMockRunner.class)
-public class NoBlockHandlerTest {
+public class NoBlockHandlerTest extends CommonTestSetup {
private static final UUID ID = UUID.randomUUID();
@Mock
private AOneBlock aob;
- @Mock
- private Player p;
-
+
private NoBlockHandler nbh;
@Mock
private Block block;
@Mock
private BlockListener bl;
- @Mock
- private Location location;
- @Mock
- private IslandsManager im;
- @Mock
- private Island island;
- @Mock
- private World world;
-
+
/**
* @throws java.lang.Exception
*/
- @Before
+ @Override
+ @BeforeEach
public void setUp() throws Exception {
+ super.setUp();
// Player
- when(p.getUniqueId()).thenReturn(ID);
+ when(mockPlayer.getUniqueId()).thenReturn(ID);
// In world
when(aob.inWorld(world)).thenReturn(true);
@@ -88,8 +73,10 @@ public void setUp() throws Exception {
/**
* @throws java.lang.Exception
*/
- @After
+ @Override
+ @AfterEach
public void tearDown() throws Exception {
+ super.tearDown();
}
/**
@@ -107,7 +94,7 @@ public void testNoBlockHandler() {
*/
@Test
public void testOnRespawnSolidBlock() {
- PlayerRespawnEvent event = new PlayerRespawnEvent(p, location, false, false, false, RespawnReason.DEATH);
+ PlayerRespawnEvent event = new PlayerRespawnEvent(mockPlayer, location, false, false, false, RespawnReason.DEATH);
nbh.onRespawn(event);
verify(block, never()).setType(any(Material.class));
@@ -119,7 +106,7 @@ public void testOnRespawnSolidBlock() {
@Test
public void testOnRespawnAirBlock() {
when(block.isEmpty()).thenReturn(true);
- PlayerRespawnEvent event = new PlayerRespawnEvent(p, location, false, false, false, RespawnReason.DEATH);
+ PlayerRespawnEvent event = new PlayerRespawnEvent(mockPlayer, location, false, false, false, RespawnReason.DEATH);
nbh.onRespawn(event);
verify(block).setType(any(Material.class));
@@ -132,7 +119,7 @@ public void testOnRespawnAirBlock() {
public void testOnRespawnAirBlockWrongWorld() {
when(aob.inWorld(world)).thenReturn(false);
when(block.isEmpty()).thenReturn(true);
- PlayerRespawnEvent event = new PlayerRespawnEvent(p, location, false, false, true, RespawnReason.DEATH);
+ PlayerRespawnEvent event = new PlayerRespawnEvent(mockPlayer, location, false, false, true, RespawnReason.DEATH);
nbh.onRespawn(event);
verify(block, never()).setType(any(Material.class));
@@ -145,7 +132,7 @@ public void testOnRespawnAirBlockWrongWorld() {
public void testOnRespawnAirBlockNoIsland() {
when(im.getIsland(world, ID)).thenReturn(null);
when(block.isEmpty()).thenReturn(true);
- PlayerRespawnEvent event = new PlayerRespawnEvent(p, location, false, false, false, RespawnReason.DEATH);
+ PlayerRespawnEvent event = new PlayerRespawnEvent(mockPlayer, location, false, false, false, RespawnReason.DEATH);
nbh.onRespawn(event);
verify(block, never()).setType(any(Material.class));
diff --git a/src/test/java/world/bentobox/aoneblock/listeners/StartSafetyListenerTest.java b/src/test/java/world/bentobox/aoneblock/listeners/StartSafetyListenerTest.java
index c3d351d8..644b5f54 100644
--- a/src/test/java/world/bentobox/aoneblock/listeners/StartSafetyListenerTest.java
+++ b/src/test/java/world/bentobox/aoneblock/listeners/StartSafetyListenerTest.java
@@ -1,10 +1,9 @@
package world.bentobox.aoneblock.listeners;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
-import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@@ -13,101 +12,55 @@
import java.util.List;
import java.util.Map;
import java.util.Set;
-import java.util.UUID;
-import org.bukkit.Bukkit;
import org.bukkit.Difficulty;
import org.bukkit.GameMode;
import org.bukkit.Location;
-import org.bukkit.World;
import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Player;
import org.bukkit.event.player.PlayerMoveEvent;
-import org.bukkit.scheduler.BukkitScheduler;
import org.eclipse.jdt.annotation.NonNull;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.stubbing.Answer;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
-import org.powermock.reflect.Whitebox;
import world.bentobox.aoneblock.AOneBlock;
+import world.bentobox.aoneblock.CommonTestSetup;
import world.bentobox.aoneblock.Settings;
-import world.bentobox.bentobox.BentoBox;
import world.bentobox.bentobox.api.configuration.WorldSettings;
import world.bentobox.bentobox.api.events.island.IslandCreatedEvent;
import world.bentobox.bentobox.api.events.island.IslandResetEvent;
import world.bentobox.bentobox.api.flags.Flag;
-import world.bentobox.bentobox.api.user.Notifier;
import world.bentobox.bentobox.api.user.User;
-import world.bentobox.bentobox.database.objects.Island;
-import world.bentobox.bentobox.managers.IslandWorldManager;
-import world.bentobox.bentobox.managers.LocalesManager;
-import world.bentobox.bentobox.managers.PlaceholdersManager;
/**
* @author tastybento
*/
-@RunWith(PowerMockRunner.class)
-@PrepareForTest({ Bukkit.class, BentoBox.class })
-public class StartSafetyListenerTest {
+public class StartSafetyListenerTest extends CommonTestSetup {
- private AOneBlock addon;
private StartSafetyListener ssl;
@Mock
- private Island island;
- private UUID uuid = UUID.randomUUID();
- @Mock
- private Location location;
- @Mock
private Location location2;
@Mock
- private World world;
- @Mock
- private BentoBox plugin;
- @Mock
- private IslandWorldManager iwm;
- @Mock
private Flag flag;
- private @NonNull WSettings ws = new WSettings();
- @Mock
- private BukkitScheduler scheduler;
- @Mock
- private Player player;
- @Mock
- private LocalesManager lm;
- @Mock
- private PlaceholdersManager phm;
- @Mock
- private Notifier notifier;
-
+ private final @NonNull WSettings ws = new WSettings();
/**
* @throws java.lang.Exception
*/
- @Before
+ @Override
+ @BeforeEach
public void setUp() throws Exception {
+ super.setUp();
- PowerMockito.mockStatic(Bukkit.class, Mockito.RETURNS_MOCKS);
- when(Bukkit.getScheduler()).thenReturn(scheduler);
-
- // Set up plugin
- Whitebox.setInternalState(BentoBox.class, "instance", plugin);
-
- addon = new AOneBlock();
+ AOneBlock addon = new AOneBlock();
addon.setIslandWorld(world);
addon.setSettings(new Settings());
// Player
- when(player.getUniqueId()).thenReturn(uuid);
- when(player.getWorld()).thenReturn(world);
- User.getInstance(player);
+ when(mockPlayer.getUniqueId()).thenReturn(uuid);
+ when(mockPlayer.getWorld()).thenReturn(world);
+ User.getInstance(mockPlayer);
when(world.getName()).thenReturn("world");
@@ -115,23 +68,12 @@ public void setUp() throws Exception {
when(iwm.inWorld(world)).thenReturn(true);
when(iwm.getWorldSettings(world)).thenReturn(ws);
- when(plugin.getIWM()).thenReturn(iwm);
when(location.getWorld()).thenReturn(world);
when(location2.getWorld()).thenReturn(world);
when(island.getWorld()).thenReturn(world);
when(island.getCenter()).thenReturn(location);
- when(plugin.getNotifier()).thenReturn(notifier);
-
- // Placeholders
- when(phm.replacePlaceholders(any(), anyString()))
- .thenAnswer((Answer) invocation -> invocation.getArgument(1, String.class));
-
- // BentoBox
- when(plugin.getLocalesManager()).thenReturn(lm);
- when(plugin.getPlaceholdersManager()).thenReturn(phm);
-
when(location2.getX()).thenReturn(0.5D);
addon.START_SAFETY.setSetting(world, true);
@@ -142,9 +84,10 @@ public void setUp() throws Exception {
/**
* @throws java.lang.Exception
*/
- @After
+ @Override
+ @AfterEach
public void tearDown() throws Exception {
- User.clearUsers();
+ super.tearDown();
}
/**
@@ -162,7 +105,7 @@ public void testStartSafetyListener() {
public void testOnNewIsland() {
IslandCreatedEvent e = new IslandCreatedEvent(island, uuid, false, location);
ssl.onNewIsland(e);
- verify(scheduler).runTaskLater(eq(plugin), any(Runnable.class), anyLong());
+ verify(sch).runTaskLater(eq(plugin), any(Runnable.class), anyLong());
}
/**
@@ -172,7 +115,7 @@ public void testOnNewIsland() {
public void testOnResetIsland() {
IslandResetEvent e = new IslandResetEvent(island, uuid, false, location, null, island);
ssl.onResetIsland(e);
- verify(scheduler).runTaskLater(eq(plugin), any(Runnable.class), anyLong());
+ verify(sch).runTaskLater(eq(plugin), any(Runnable.class), anyLong());
}
@@ -182,18 +125,18 @@ public void testOnResetIsland() {
@Test
public void testOnPlayerMove() {
testOnResetIsland();
- PlayerMoveEvent e = new PlayerMoveEvent(player, location, location2);
+ PlayerMoveEvent e = new PlayerMoveEvent(mockPlayer, location, location2);
ssl.onPlayerMove(e);
// No movement
assertEquals(0D, e.getTo().getX(), 0D);
assertEquals(0D, e.getTo().getZ(), 0D);
- verify(player).isSneaking();
+ verify(mockPlayer).isSneaking();
}
class WSettings implements WorldSettings {
- private Map flags = new HashMap<>();
+ private final Map flags = new HashMap<>();
@Override
public GameMode getDefaultGameMode() {
diff --git a/src/test/java/world/bentobox/aoneblock/oneblocks/OneBlocksManagerTest3.java b/src/test/java/world/bentobox/aoneblock/oneblocks/OneBlocksManagerTest3.java
index 57323b39..7bef532d 100644
--- a/src/test/java/world/bentobox/aoneblock/oneblocks/OneBlocksManagerTest3.java
+++ b/src/test/java/world/bentobox/aoneblock/oneblocks/OneBlocksManagerTest3.java
@@ -1,12 +1,10 @@
package world.bentobox.aoneblock.oneblocks;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.any;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@@ -15,65 +13,47 @@
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.Comparator;
import java.util.List;
import java.util.NavigableMap;
import java.util.jar.JarEntry;
import java.util.jar.JarOutputStream;
-import org.bukkit.Bukkit;
import org.bukkit.Material;
-import org.bukkit.UnsafeValues;
import org.bukkit.block.Biome;
import org.bukkit.configuration.InvalidConfigurationException;
import org.bukkit.configuration.file.YamlConfiguration;
-import org.bukkit.inventory.ItemFactory;
-import org.bukkit.inventory.meta.ItemMeta;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.junit.After;
-import org.junit.AfterClass;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Ignore;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
import org.mockito.Mock;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
-import org.powermock.reflect.Whitebox;
import world.bentobox.aoneblock.AOneBlock;
+import world.bentobox.aoneblock.CommonTestSetup;
import world.bentobox.aoneblock.dataobjects.OneBlockIslands;
-import world.bentobox.bentobox.BentoBox;
import world.bentobox.bentobox.api.addons.AddonDescription;
-import world.bentobox.bentobox.api.user.User;
import world.bentobox.bentobox.managers.AddonsManager;
/**
* @author tastybento
*
*/
-@RunWith(PowerMockRunner.class)
-@PrepareForTest({ Bukkit.class, BentoBox.class, User.class })
-public class OneBlocksManagerTest3 {
+public class OneBlocksManagerTest3 extends CommonTestSetup {
private static File jFile;
private static YamlConfiguration oneBlocks;
- @Mock
- private BentoBox plugin;
- private AOneBlock addon;
- @Mock
+ @Mock
private AddonsManager am;
private OneBlocksManager obm;
private OneBlockPhase obPhase;
@Mock
private @NonNull OneBlockIslands obi;
- @BeforeClass
+ @BeforeAll
public static void beforeClass() throws IOException, InvalidConfigurationException {
// Make the addon jar
jFile = new File("addon.jar");
@@ -83,12 +63,33 @@ public static void beforeClass() throws IOException, InvalidConfigurationExcepti
* Paths.get("config.yml"); Files.copy(fromPath, path);
*/
// Dummy oneblocks.yml
- String oneblocks = "'0':\n" + " name: Plains\n" + " icon: GRASS_BLOCK\n" + " firstBlock: GRASS_BLOCK\n"
- + " biome: PLAINS\n" + " fixedBlocks:\n" + " 0: GRASS_BLOCK\n" + " 1: GRASS_BLOCK\n"
- + " holograms:\n" + " 0: &aGood Luck!\n" + " blocks:\n" + " GRASS_BLOCK: 2000\n"
- + " BIRCH_LOG: 500\n" + " mobs:\n" + " SHEEP: 150\n" + " VILLAGER: 30\n" + "'700':\n"
- + " name: Underground\n" + " firstBlock: STONE\n" + " biome: TAIGA\n" + " blocks:\n"
- + " EMERALD_ORE: 5\n" + " COBWEB: 250\n" + " DIRT: 500\n" + "'11000':\n" + " gotoBlock: 0";
+ String oneblocks = """
+ '0':
+ name: Plains
+ icon: GRASS_BLOCK
+ firstBlock: GRASS_BLOCK
+ biome: PLAINS
+ fixedBlocks:
+ 0: GRASS_BLOCK
+ 1: GRASS_BLOCK
+ holograms:
+ 0: &aGood Luck!
+ blocks:
+ GRASS_BLOCK: 2000
+ BIRCH_LOG: 500
+ mobs:
+ SHEEP: 150
+ VILLAGER: 30
+ '700':
+ name: Underground
+ firstBlock: STONE
+ biome: TAIGA
+ blocks:
+ EMERALD_ORE: 5
+ COBWEB: 250
+ DIRT: 500
+ '11000':
+ gotoBlock: 0""";
oneBlocks = new YamlConfiguration();
oneBlocks.loadFromString(oneblocks);
// Save
@@ -119,32 +120,21 @@ public static void beforeClass() throws IOException, InvalidConfigurationExcepti
/**
* @throws java.lang.Exception
*/
- @Before
+ @Override
+ @BeforeEach
public void setUp() throws Exception {
- // Set up plugin
- Whitebox.setInternalState(BentoBox.class, "instance", plugin);
+ super.setUp();
// Addon
- addon = new AOneBlock();
+ AOneBlock addon = new AOneBlock();
File dataFolder = new File("addons/AOneBlock");
addon.setDataFolder(dataFolder);
addon.setFile(jFile);
AddonDescription desc = new AddonDescription.Builder("bentobox", "AOneBlock", "1.3").description("test")
.authors("tastybento").build();
addon.setDescription(desc);
- // addon.setSettings(new Settings());
// Addons manager
when(plugin.getAddonsManager()).thenReturn(am);
- // Bukkit
- PowerMockito.mockStatic(Bukkit.class);
- ItemMeta meta = mock(ItemMeta.class);
- ItemFactory itemFactory = mock(ItemFactory.class);
- when(itemFactory.getItemMeta(any())).thenReturn(meta);
- when(Bukkit.getItemFactory()).thenReturn(itemFactory);
- UnsafeValues unsafe = mock(UnsafeValues.class);
- when(unsafe.getDataVersion()).thenReturn(777);
- when(Bukkit.getUnsafe()).thenReturn(unsafe);
-
// Phase
obPhase = new OneBlockPhase("0");
@@ -155,12 +145,14 @@ public void setUp() throws Exception {
/**
* @throws java.lang.Exception
*/
- @After
+ @Override
+ @AfterEach
public void tearDown() throws Exception {
+ super.tearDown();
deleteAll(new File("database"));
}
- @AfterClass
+ @AfterAll
public static void cleanUp() throws Exception {
new File("addon.jar").delete();
@@ -170,20 +162,13 @@ public static void cleanUp() throws Exception {
deleteAll(new File("phases"));
}
- private static void deleteAll(File file) throws IOException {
- if (file.exists()) {
- Files.walk(file.toPath()).sorted(Comparator.reverseOrder()).map(Path::toFile).forEach(File::delete);
- }
- }
-
/**
* Test method for
* {@link world.bentobox.aoneblock.oneblocks.OneBlocksManager#OneBlocksManager(world.bentobox.aoneblock.AOneBlock)}.
- *
- * @throws IOException
- */
+ *
+ */
@Test
- public void testOneBlocksManager() throws IOException {
+ public void testOneBlocksManager() {
File f = new File("phases", "0_plains.yml");
assertTrue(f.exists());
}
@@ -192,13 +177,12 @@ public void testOneBlocksManager() throws IOException {
* Test method for
* {@link world.bentobox.aoneblock.oneblocks.OneBlocksManager#loadPhases()}.
*
- * @throws InvalidConfigurationException
* @throws IOException
* @throws NumberFormatException
*/
// @Ignore("Cannot deserialize objects right now")
@Test
- public void testLoadPhases() throws NumberFormatException, IOException, InvalidConfigurationException {
+ public void testLoadPhases() throws NumberFormatException, IOException {
obm.loadPhases();
verify(plugin, never()).logError(anyString());
assertEquals(Material.GRASS_BLOCK, obm.getPhase(0).getFirstBlock().getMaterial());
@@ -253,15 +237,14 @@ public void testGetPhaseString() throws NumberFormatException, IOException, Inva
* Test method for
* {@link world.bentobox.aoneblock.oneblocks.OneBlocksManager#saveOneBlockConfig()}.
*
- * @throws InvalidConfigurationException
- * @throws IOException
* @throws NumberFormatException
+ * @throws IOException
*/
- @Ignore("Not saving")
+ @Disabled("Not saving")
@Test
- public void testSaveOneBlockConfig() throws NumberFormatException, IOException, InvalidConfigurationException {
- // testLoadPhases();
- // assertTrue(obm.saveOneBlockConfig());
+ public void testSaveOneBlockConfig() throws NumberFormatException, IOException {
+ testLoadPhases();
+ assertTrue(obm.saveOneBlockConfig());
}
/**
@@ -307,7 +290,7 @@ public void testCopyPhasesFromAddonJar() throws IOException {
* @throws IOException
*/
@Test
- @Ignore
+ @Disabled
public void testInitBlock() throws IOException {
System.out.println(oneBlocks);
obm.initBlock("0", obPhase, oneBlocks);
@@ -383,7 +366,7 @@ public void testAddMobs() throws IOException {
* {@link world.bentobox.aoneblock.oneblocks.OneBlocksManager#addBlocks(world.bentobox.aoneblock.oneblocks.OneBlockPhase, org.bukkit.configuration.ConfigurationSection)}.
*/
@Test
- public void testAddBlocks() throws IOException {
+ public void testAddBlocks() {
obm.addBlocks(obPhase, oneBlocks);
}