Class LangTest should be package-private
8import me.chancesd.pvpmanager.setting.lang.Replacement;
9
10@ExtendWith(InstanceCreator.class)
11public class LangTest {1213 @Test14 void allEnabled() {15 for (final Lang lang : Lang.values()) {16 final Replacement[] replacements = lang.getReplacements();17 for (final Replacement replacement : replacements) {18 assertTrue(lang.msg().contains(replacement.getPlaceholder()), "Missing replacement " + replacement + " in lang " + lang.getMessageKey());19 }20 }21 }2223}
Class DependencyTest should be package-private
21import me.chancesd.sdutils.utils.Utils;
22
23@ExtendWith(InstanceCreator.class)
24public class DependencyTest {2526 private static Server server;2728 @BeforeAll29 public static void setupClass() {30 final PluginSetup pt = InstanceCreator.getPt();31 server = pt.getServer();32 when(server.getServicesManager()).thenReturn(mock(ServicesManager.class));33 }3435 @Test36 void allEnabled() {37 final JavaPlugin plugin = Mockito.mock(JavaPlugin.class);38 when(plugin.getDescription()).thenReturn(new PluginDescriptionFile("Plugin", "1.0", "plugin"));39 when(server.getPluginManager().getPlugin(AdditionalMatchers.not(ArgumentMatchers.eq("Towny")))).thenReturn(plugin);40 assertEquals(server.getPluginManager().getPlugin("PvPManager"), plugin);41 new DependencyManager();42 }4344 @Test45 void versionTags() {46 final String v1 = Utils.stripTags("1.0.2-SNAPSHOT");47 final String v2 = Utils.stripTags("1.0.2;1994-9adac4f");48 final String v3 = Utils.stripTags("1.0.2+9adac4f");49 assertEquals("1.0.2", v1);50 assertEquals("1.0.2", v2);51 assertEquals("1.0.2", v3);52 }5354 @AfterAll55 public static void cleanup() {56 when(server.getPluginManager().getPlugin(ArgumentMatchers.anyString())).thenReturn(null);57 }5859}
Class PlayerListenerTest should be package-private
25import me.chancesd.pvpmanager.setting.Conf;
26
27@ExtendWith(InstanceCreator.class)
28public class PlayerListenerTest { 29 30 private static PlayerListener listener; 31 private static PlayerManager ph; 32 private static PluginSetup pt; 33 34 @BeforeAll 35 public static void setupClass() { 36 pt = InstanceCreator.getPt(); 37 final PvPManager plugin = pt.getPlugin(); 38 ph = plugin.getPlayerManager(); 39 listener = new PlayerListener(plugin.getPlayerManager()); 40 } 41 42 @BeforeEach 43 public final void setup() { 44 ph.getPlayers().clear(); 45 } 46 47 private void tagPlayer(final CombatPlayer player, final CombatPlayer enemy) { 48 player.tag(true, enemy); 49 assertTrue(player.isInCombat()); 50 } 51 52 private void tagPlayer(final CombatPlayer player) { 53 tagPlayer(player, ph.get(pt.createPlayer("Attacker"))); 54 } 55 56 @Test 57 void onPlayerJoinTest() { 58 final Player playerJoined = pt.createPlayer("onPlayerJoinTest"); 59 assertEquals(0, ph.getPlayers().size()); 60 listener.onPlayerJoin(new PlayerJoinEvent(playerJoined, "")); 61 assertEquals(1, ph.getPlayers().size()); 62 assertEquals(playerJoined, ph.getPlayers().values().stream().findFirst().get().getPlayer()); 63 } 64 65 @Test 66 void onPlayerLogoutTest() { 67 final Player player = pt.createPlayer("onPlayerLogoutTest"); 68 final CombatPlayer pvPlayer = ph.get(player); 69 final Player attacker = pt.createPlayer("Attacker"); 70 final CombatPlayer pvpAttacker = ph.get(attacker); 71 tagPlayer(pvPlayer, pvpAttacker); 72 73 listener.onPlayerLogout(new PlayerQuitEvent(player, "")); 74 listener.onPlayerLogoutMonitor(new PlayerQuitEvent(player, "")); 75 verify(player, times(1)).setHealth(0); 76 77 assertEquals(1, ph.getPlayers().size()); 78 listener.onPlayerLogoutMonitor(new PlayerQuitEvent(attacker, "")); 79 assertEquals(0, ph.getPlayers().size()); 80 } 81 82 @Test 83 void onPlayerKickTest() { 84 final Player kickPlayer = pt.createPlayer("onPlayerKickTest"); 85 final CombatPlayer pvPlayer = ph.get(kickPlayer); 86 87 tagPlayer(pvPlayer); 88 listener.onPlayerKick(new PlayerKickEvent(kickPlayer, "", "")); 89 assertTrue(pvPlayer.isInCombat()); 90 91 Conf.MATCH_KICK_REASON.set(true); 92 tagPlayer(pvPlayer); 93 listener.onPlayerKick(new PlayerKickEvent(kickPlayer, "", "")); 94 assertFalse(pvPlayer.isInCombat()); 95 96 tagPlayer(pvPlayer); 97 listener.onPlayerKick(new PlayerKickEvent(kickPlayer, "Kicked for spamming", "")); 98 assertTrue(pvPlayer.isInCombat()); 99 }100101 private PlayerDeathEvent createDeathEvent(final Player player) {102 final PlayerDeathEvent event = mock(PlayerDeathEvent.class);103 when(event.getEntity()).thenReturn(player);104 return event;105 }106107 @Test108 final void regularDeath() {109 final Player player = pt.createPlayer("regularDeath");110 final CombatPlayer pDefender = ph.get(player);111 assertFalse(pDefender.isInCombat());112 listener.onPlayerDeath(createDeathEvent(player));113 }114115 @Test116 final void inCombatDeath() {117 final Player attacker = pt.createPlayer("Attacker");118 final CombatPlayer pAttacker = ph.get(attacker);119 final Player defender = pt.createPlayer("Defender", attacker);120 final CombatPlayer pDefender = ph.get(defender);121122 tagPlayer(pDefender, pAttacker);123 tagPlayer(pAttacker, pDefender);124 listener.onPlayerDeath(createDeathEvent(defender));125 assertFalse(pDefender.isInCombat());126 assertTrue(pAttacker.isInCombat());127128 Conf.UNTAG_ON_KILL.set(true);129 tagPlayer(pDefender, pAttacker);130 tagPlayer(pAttacker, pDefender);131 listener.onPlayerDeath(createDeathEvent(defender));132 assertFalse(pDefender.isInCombat());133 assertFalse(pAttacker.isInCombat());134135 Conf.SELF_TAG.set(true);136 tagPlayer(pAttacker, pAttacker);137 tagPlayer(pDefender, pAttacker);138 tagPlayer(pAttacker, pDefender);139 listener.onPlayerDeath(createDeathEvent(defender));140 assertFalse(pDefender.isInCombat());141 assertFalse(pAttacker.isInCombat());142 }143144}
Class EntityListenerTest should be package-private
32import me.chancesd.pvpmanager.utils.CombatUtils;
33
34@ExtendWith(InstanceCreator.class)
35public class EntityListenerTest { 36 37 private static final PluginSetup PT = InstanceCreator.getPt(); 38 private static EntityListener damageListener; 39 private EntityDamageByEntityEvent mockEvent; 40 private EntityDamageByEntityEvent projMockEvent; 41 private static PlayerManager ph; 42 private static Player attacker; 43 private static Player defender; 44 45 @BeforeAll 46 public static void setupClass() { 47 final PvPManager plugin = PT.getPlugin(); 48 ph = plugin.getPlayerManager(); 49 damageListener = new EntityListener(ph); 50 Conf.PVP_BLOOD.disable(); // avoid loading Material class while testing 51 attacker = PT.getAttacker(); 52 defender = PT.getDefender(); 53 } 54 55 @BeforeEach 56 public final void setup() { 57 ph.getPlayers().clear(); 58 } 59 60 private void createAttack(final boolean cancelled) { 61 createAttack(attacker, defender, cancelled); 62 } 63 64 private void createAttack(final Player pAttacker, final Player pDefender, final boolean cancelled) { 65 mockEvent = createDamageEvent(pAttacker, pDefender, cancelled); 66 67 final Projectile proj = mock(Projectile.class); 68 when(proj.getShooter()).thenReturn(pAttacker); 69 projMockEvent = createDamageEvent(proj, pDefender, cancelled); 70 71 callEvent(mockEvent); 72 callEvent(projMockEvent); 73 } 74 75 private EntityDamageByEntityEvent createDamageEvent(final Entity attackerEntity, final Entity defenderEntity, final boolean cancelled) { 76 final EntityDamageByEntityEvent event = mock(EntityDamageByEntityEvent.class); 77 when(event.getDamager()).thenReturn(attackerEntity); 78 when(event.getEntity()).thenReturn(defenderEntity); 79 when(event.getDamage()).thenReturn(5.0); 80 Mockito.doCallRealMethod().when(event).setCancelled(ArgumentMatchers.anyBoolean()); 81 when(event.isCancelled()).thenCallRealMethod(); 82 event.setCancelled(cancelled); 83 return event; 84 } 85 86 private void createMobAttack(final boolean mobAttacker, final boolean cancelled) { 87 final Zombie zombie = mock(Zombie.class, RETURNS_MOCKS); 88 if (mobAttacker) { 89 mockEvent = createDamageEvent(zombie, defender, cancelled); 90 } else { 91 mockEvent = createDamageEvent(attacker, zombie, cancelled); 92 } 93 94 final Projectile proj = mock(Projectile.class); 95 when(proj.getShooter()).thenReturn(attacker); 96 if (mobAttacker) { 97 projMockEvent = createDamageEvent(proj, defender, cancelled); 98 } else { 99 projMockEvent = createDamageEvent(proj, zombie, cancelled);100 }101102 callEvent(mockEvent);103 callEvent(projMockEvent);104 }105106 private void callEvent(final EntityDamageByEntityEvent event) {107 if (!event.isCancelled()) { // ignore cancelled true108 damageListener.onPlayerDamage(event);109 }110 damageListener.onPlayerDamageOverride(event);111 if (!event.isCancelled()) { // ignore cancelled true112 damageListener.onPlayerDamageMonitor(event);113 }114 }115116 @Test117 final void testMobAttack() {118 createMobAttack(false, false);119 assertFalse(mockEvent.isCancelled());120 assertFalse(projMockEvent.isCancelled());121122 createMobAttack(true, false);123 assertFalse(mockEvent.isCancelled());124 assertFalse(projMockEvent.isCancelled());125 }126127 @Test128 final void testSelfTag() {129 final Projectile proj = mock(Projectile.class);130 projMockEvent = createDamageEvent(proj, defender, false);131132 assertFalse(Conf.SELF_TAG.asBool());133 // attacker different from defender134 when(proj.getShooter()).thenReturn(attacker);135 assertEquals(proj.getShooter(), attacker);136 assertTrue(CombatUtils.isPvP(projMockEvent));137138 // attacker equals defender139 when(proj.getShooter()).thenReturn(defender);140 assertEquals(proj.getShooter(), projMockEvent.getEntity());141 assertFalse(CombatUtils.isPvP(projMockEvent));142143 // now allow self tagging144 Conf.SELF_TAG.set(true);145 assertTrue(Conf.SELF_TAG.asBool());146 // attacker different from defender147 when(proj.getShooter()).thenReturn(attacker);148 assertEquals(proj.getShooter(), attacker);149 assertTrue(CombatUtils.isPvP(projMockEvent));150151 // attacker equals defender152 when(proj.getShooter()).thenReturn(defender);153 assertEquals(proj.getShooter(), projMockEvent.getEntity());154 assertTrue(CombatUtils.isPvP(projMockEvent));155 }156157 @Test158 final void testNoDamageHits() {159 final Projectile proj = mock(Projectile.class);160 when(proj.getShooter()).thenReturn(attacker);161162 // ignore no damage hits163 assertTrue(Conf.IGNORE_NO_DMG_HITS.asBool());164165 projMockEvent = createDamageEvent(proj, defender, false);166 when(projMockEvent.getDamage()).thenReturn(5.0);167 assertTrue(CombatUtils.isPvP(projMockEvent));168169 projMockEvent = createDamageEvent(proj, defender, false);170 when(projMockEvent.getDamage()).thenReturn(0.0);171 assertFalse(CombatUtils.isPvP(projMockEvent));172173 // don't ignore any hits174 Conf.IGNORE_NO_DMG_HITS.set(false);175 assertFalse(Conf.IGNORE_NO_DMG_HITS.asBool());176177 projMockEvent = createDamageEvent(proj, defender, false);178 when(projMockEvent.getDamage()).thenReturn(5.0);179 assertTrue(CombatUtils.isPvP(projMockEvent));180181 projMockEvent = createDamageEvent(proj, defender, false);182 when(projMockEvent.getDamage()).thenReturn(0.0);183 assertTrue(CombatUtils.isPvP(projMockEvent));184 }185186 @Test187 final void cancelNewbie() {188 ph.get(attacker).setNewbie(true);189 createAttack(false);190191 assertEquals(ProtectionType.NEWBIE, ph.checkProtection(attacker, defender).type());192 verify(attacker, times(2)).sendMessage(Lang.NEWBIE_PROTECTION_ON_HIT.msg());193194 verify(mockEvent).setCancelled(true);195 verify(projMockEvent).setCancelled(true);196 }197198 @Test199 final void cancelPvPDisabled() {200 ph.get(defender).setPvP(false);201 createAttack(false);202203 assertEquals(ProtectionType.PVPDISABLED, ph.checkProtection(attacker, defender).type());204 verify(attacker, times(2)).sendMessage(Lang.ATTACK_DENIED_OTHER.msg(defender.getName()));205206 verify(mockEvent).setCancelled(true);207 verify(projMockEvent).setCancelled(true);208 }209210 @Test211 final void failCancel() {212 final Player playerAttacker = PT.createPlayer("FailCancelAtttacker");213 final Player playerDefender = PT.createPlayer("FailCancelDefender");214 ph.get(playerDefender).setPvP(true);215 ph.get(playerAttacker).setPvP(true);216217 when(playerAttacker.isFlying()).thenReturn(true);218 when(playerDefender.isFlying()).thenReturn(true);219 assertEquals(ProtectionType.FAIL, ph.checkProtection(playerAttacker, playerDefender).type());220 createAttack(playerAttacker, playerDefender, false);221 assertTrue(ph.get(playerAttacker).isInCombat());222 assertTrue(ph.get(playerDefender).isInCombat());223 verify(playerAttacker, times(2)).setFlying(false);224 verify(playerDefender, times(2)).setFlying(false);225226 verify(mockEvent, never()).setCancelled(true);227 verify(projMockEvent, never()).setCancelled(true);228 }229230 @Test231 final void overrideCancel() {232 ph.get(attacker).toggleOverride();233 createAttack(false);234235 assertEquals(ProtectionType.FAIL_OVERRIDE, ph.checkProtection(attacker, defender).type());236 assertTrue(ph.get(attacker).isInCombat());237 assertTrue(ph.get(defender).isInCombat());238239 verify(mockEvent, times(1)).setCancelled(false); // only when creating the attack240 verify(projMockEvent, times(1)).setCancelled(false); // only when creating the attack241 }242243 @Test244 final void overrideCancelled() {245 ph.get(attacker).toggleOverride();246 createAttack(true);247248 assertEquals(ProtectionType.FAIL_OVERRIDE, ph.checkProtection(attacker, defender).type());249 assertTrue(ph.get(attacker).isInCombat());250 assertTrue(ph.get(defender).isInCombat());251252 verify(mockEvent).setCancelled(false);253 verify(projMockEvent).setCancelled(false);254 }255256}
Class BlockedActionsListenerTest should be package-private
18import me.chancesd.pvpmanager.setting.Lang;
19
20@ExtendWith(InstanceCreator.class)
21public class BlockedActionsListenerTest {2223 private static BlockedActionsListener listener;24 private static PlayerManager ph;25 private static PluginSetup pt;2627 @BeforeAll28 public static void setupClass() {29 pt = InstanceCreator.getPt();30 final PvPManager plugin = pt.getPlugin();31 ph = plugin.getPlayerManager();32 listener = new BlockedActionsListener(plugin.getPlayerManager());33 }3435 @BeforeEach36 public final void setup() {37 ph.getPlayers().clear();38 }3940 private void tagPlayer(final CombatPlayer player, final CombatPlayer enemy) {41 player.tag(true, enemy);42 assertTrue(player.isInCombat());43 }4445 private void tagPlayer(final CombatPlayer player) {46 tagPlayer(player, ph.get(pt.createPlayer("Attacker")));47 }4849 @Test50 final void onCommandTest() {51 final Player player = pt.createPlayer("onCommandTest");52 final CombatPlayer pvPlayer = ph.get(player);53 final PlayerCommandPreprocessEvent commandPreprocessEvent = new PlayerCommandPreprocessEvent(player, "/spawn");5455 assertFalse(commandPreprocessEvent.isCancelled());56 listener.onCommand(commandPreprocessEvent);57 assertFalse(commandPreprocessEvent.isCancelled());5859 tagPlayer(pvPlayer);60 listener.onCommand(commandPreprocessEvent);61 assertTrue(commandPreprocessEvent.isCancelled());62 verify(player, atMostOnce()).sendMessage(Lang.COMMAND_DENIED_INCOMBAT.msg());6364 final PlayerCommandPreprocessEvent commandPreprocessEvent2 = new PlayerCommandPreprocessEvent(player, "/tell");65 tagPlayer(pvPlayer);66 listener.onCommand(commandPreprocessEvent2);67 assertFalse(commandPreprocessEvent2.isCancelled());68 }6970}
Description
JUnit5 test classes and methods should be package-private.
Unlike JUnit4 which required all the test classes and methods to be declared public
, in JUnit5 they can be anything but private
.
To enforce maximum encapsulation, it is recommended to declare test classes and methods as package-private.
Bad Practice
public class MyTest {
@Test
public void testThis() {
// ..test things
}
}
Recommended
Consider making your test classes and methods package-private.
class MyTest {
@Test
void testThis() {
// ..test things
}
}