public void startFinished() {
if (bets != null && !bets.isEmpty() && bets.size() > 0) {
for (int i = 0; i < bets.size(); i++) {
try {
Bet b = bets.get(i);
if (isTribute(server.getPlayer(b.tribute))) {
addScore(b.better, b.wager / 4);
addScore(b.tribute, b.wager / 4);
} else {
subtractScore(b.better, b.wager);
}
bets.remove(b);
} catch (Exception e) {
e.printStackTrace();
}
}
}
clearAll();
load();
bets.clear();
state = State.DONE;
game = new Finished(this);
startTimer();
}
@Test
public void playerNoOpSetLvl() {
Player player = Mockito.mock(Player.class);
cmd.onCommand(player, "setlvl");
Mockito.verify(player)
.sendMessage("§6[EC] §eSyntax: /level setLevel <Module> <Value> [Player]");
cmd.onCommand(player, "setlvl", "t");
Mockito.verify(player, Mockito.times(2))
.sendMessage("§6[EC] §eSyntax: /level setLevel <Module> <Value> [Player]");
cmd.onCommand(player, "setlevel", "t", "5");
Mockito.verify(player).sendMessage("§6[EC] §cYou cannot execute that command.");
player = Mockito.mock(Player.class);
cmd.onCommand(player, "setlevel", "t", "asd");
Mockito.verify(player)
.sendMessage("§6[EC] §eSyntax: /level setLevel <Module> <Value> [Player]");
Mockito.verify(player).sendMessage("§6[EC] §e<Value> has to be a natural number");
cmd.onCommand(player, "setlvl", "t", "5", "cryxli");
Mockito.verify(player).sendMessage("§6[EC] §cYou cannot execute that command.");
Mockito.when(server.getPlayer(player.getName())).thenReturn(player);
cmd.onCommand(player, "setlvl", "t", "5", "cryxli");
Mockito.verify(player, Mockito.times(2))
.sendMessage("§6[EC] §cYou cannot execute that command.");
cmd.onCommand(player, "setlvl", "d", "15", "cryxli");
Mockito.verify(player, Mockito.times(3))
.sendMessage("§6[EC] §cYou cannot execute that command.");
}
public boolean has(String player, String permission, String world) {
Player p = serv.getPlayer(player);
if (p != null) return p.hasPermission(permission);
// OfflinePlayer op = serv.getOfflinePlayer(player);
return false;
// TODO: Figure out offline player permission checks with bukkit-perms.
}
@Test
public void senderSetLvl() {
CommandSender sender = Mockito.mock(CommandSender.class);
cmd.onCommand(sender, "setlvl");
Mockito.verify(sender)
.sendMessage("§6[EC] §eSyntax: /level setLevel <Module> <Value> <Player>");
cmd.onCommand(sender, "setlvl", "t");
Mockito.verify(sender, Mockito.times(2))
.sendMessage("§6[EC] §eSyntax: /level setLevel <Module> <Value> <Player>");
cmd.onCommand(sender, "setlevel", "t", "5");
Mockito.verify(sender, Mockito.times(3))
.sendMessage("§6[EC] §eSyntax: /level setLevel <Module> <Value> <Player>");
cmd.onCommand(sender, "setlvl", "t", "5", "cryxli");
Mockito.verify(sender).sendMessage("§6[EC] §ePlayer cryxli is offline");
sender = Mockito.mock(CommandSender.class);
Player player = Mockito.mock(Player.class);
Mockito.when(player.getName()).thenReturn("cryxli");
Mockito.when(server.getPlayer(player.getName())).thenReturn(player);
cmd.onCommand(sender, "setlvl", "t", "asd", "cryxli");
Mockito.verify(sender)
.sendMessage("§6[EC] §eSyntax: /level setLevel <Module> <Value> [Player]");
Mockito.verify(sender).sendMessage("§6[EC] §e<Value> has to be a natural number");
Mockito.verify(sender, Mockito.times(2)).sendMessage(Mockito.anyString());
Mockito.when(server.getPlayer(player.getName())).thenReturn(player);
cmd.onCommand(sender, "setlvl", "t", "5", "cryxli");
Mockito.verify(sender).sendMessage("§6[EC] §eTest (T): lv5");
Assert.assertEquals(5, core.getPersistence().getLevel(testModule, player));
cmd.onCommand(sender, "setlvl", "d", "15", "cryxli");
Mockito.verify(sender).sendMessage("§6[EC] §eNo module found");
}
@Override
public final boolean onCommand(
final CommandSender commandSender,
final Command command,
final String label,
final String[] args) {
final String senderName = commandSender.getName();
final Server server = Bukkit.getServer();
final Player sender = server.getPlayer(senderName);
if (sender.hasPermission("udsplugin.lockdown")) {
if (args.length == 0) {
if (!UDSPlugin.getServerInLockdown()) {
UDSPlugin.setServerInLockdown(true);
UDSPlugin.getPlayers().get(senderName).setLockdownPass(true);
server.broadcastMessage(Color.BROADCAST + "Server is now in lockdown.");
} else {
UDSPlugin.setServerInLockdown(false);
server.broadcastMessage(Color.BROADCAST + "Server is no longer in lockdown.");
for (Map.Entry<String, UDSPlayer> i : UDSPlugin.getPlayers().entrySet()) {
i.getValue().setLockdownPass(false);
}
}
} else if (args.length == 1) {
final UDSPlayer serverPlayer = PlayerUtils.matchUDS(args[0]);
if (serverPlayer != null) {
final String targetName = serverPlayer.getNick();
if (serverPlayer.hasLockdownPass()) {
serverPlayer.setLockdownPass(false);
sender.sendMessage(Color.MESSAGE + targetName + "'s lockdown pass has been removed.");
} else {
serverPlayer.setLockdownPass(true);
sender.sendMessage(
Color.MESSAGE + targetName + " has been issued with a lockdown pass.");
}
} else {
sender.sendMessage(UDSMessage.NO_PLAYER);
}
} else {
sender.sendMessage(UDSMessage.BAD_ARGS);
}
} else {
sender.sendMessage(UDSMessage.NO_PERM);
}
return true;
}
@Test
public void playerOpAll() {
Player player = Mockito.mock(Player.class);
Mockito.when(player.getName()).thenReturn("cryxli");
Mockito.when(player.isOp()).thenReturn(true);
core.getPersistence().setExp(testModule, player, 0);
cmd.onCommand(player, "all");
Mockito.verify(player).sendMessage("§6[EC] --- ExpCraftPlugin ---");
Mockito.verify(player).sendMessage("§6[EC] §eTest (T): 1");
cmd.onCommand(player, "all", "cryxli");
Mockito.verify(player).sendMessage("§6[EC] §ePlayer cryxli is offline");
Mockito.when(server.getPlayer(player.getName())).thenReturn(player);
cmd.onCommand(player, "all", "cryxli");
Mockito.verify(player, Mockito.times(2)).sendMessage("§6[EC] --- ExpCraftPlugin ---");
Mockito.verify(player, Mockito.times(2)).sendMessage("§6[EC] §eTest (T): 1");
}
@Test
public void senderAll() {
CommandSender sender = Mockito.mock(CommandSender.class);
cmd.onCommand(sender, "all");
Mockito.verify(sender).sendMessage("§6[EC] §eSyntax: /level all <Player>");
cmd.onCommand(sender, "all", "cryxli");
Mockito.verify(sender).sendMessage("§6[EC] §ePlayer cryxli is offline");
Player player = Mockito.mock(Player.class);
Mockito.when(player.getName()).thenReturn("cryxli");
Mockito.when(server.getPlayer(player.getName())).thenReturn(player);
sender = Mockito.mock(CommandSender.class);
core.getPersistence().setExp(testModule, player, 0);
cmd.onCommand(sender, "all", "cryxli");
Mockito.verify(sender).sendMessage("§6[EC] --- ExpCraftPlugin ---");
Mockito.verify(sender).sendMessage("§6[EC] §eTest (T): 1");
Mockito.verify(sender, Mockito.times(2)).sendMessage(Mockito.anyString());
}
public boolean onCommand(CommandSender sender, Command cmd, String label, String args[]) {
boolean isPlayer = sender instanceof Player;
if (cmd.getName().equalsIgnoreCase("slenderman")) {
if (args.length < 1) {
return false;
}
if (args[0].equalsIgnoreCase("reload")) {
config = YamlConfiguration.loadConfiguration(configFile);
log.info("Configuration reloaded.");
if (isPlayer) sender.sendMessage(ChatColor.GREEN + "Configurations reloaded.");
return true;
}
if (args[0].equalsIgnoreCase("target")) {
if (args.length > 1) {
player = mc.getPlayer(args[1]);
if (!player.isOnline()) {
sender.sendMessage("That player is not online.");
return true;
}
if (player.isDead()) {
sender.sendMessage("That player is dead.");
return true;
}
if (!config.getStringList("worlds").contains(player.getWorld().getName())) {
sender.sendMessage("That player is in a world Slenderman cannot go to.");
return true;
}
slender.target(player);
return true;
}
}
if (args[0].equalsIgnoreCase("location")) {
sender.sendMessage(slender.slenderman.getLocation().toString());
return true;
}
}
return false;
}
@Test
public void playerOpGetExp() {
Player player = Mockito.mock(Player.class);
Mockito.when(player.getName()).thenReturn("cryxli");
Mockito.when(player.isOp()).thenReturn(true);
cmd.onCommand(player, "getexp");
Mockito.verify(player).sendMessage("§6[EC] §eSyntax: /level getExp <Module> [Player]");
core.getPersistence().setExp(testModule, player, 0);
cmd.onCommand(player, "getexp", "t");
Mockito.verify(player).sendMessage("§6[EC] §eTest (T): lv1 at 0 points");
cmd.onCommand(player, "getexp", "t", "cryxli");
Mockito.verify(player).sendMessage("§6[EC] §ePlayer cryxli is offline");
Mockito.when(server.getPlayer(player.getName())).thenReturn(player);
cmd.onCommand(player, "getexp", "t", "cryxli");
Mockito.verify(player, Mockito.times(2)).sendMessage("§6[EC] §eTest (T): lv1 at 0 points");
cmd.onCommand(player, "getexp", "d", "cryxli");
Mockito.verify(player).sendMessage("§6[EC] §eNo module found");
}
@Override
public final boolean onCommand(
final CommandSender commandSender,
final Command command,
final String label,
final String[] args) {
String senderName = commandSender.getName();
Server server = Bukkit.getServer();
Player sender = server.getPlayer(senderName);
String commandName = command.getName();
if (commandName.equalsIgnoreCase("udsreload")) {
if (sender.hasPermission("udsplugin.udsreload")) {
plugin.reloadConfig();
UDSPlugin.getUDSConfig().load(plugin.getConfig());
sender.sendMessage(UDSMessage.MSG_RELOAD);
} else {
sender.sendMessage(UDSMessage.NO_PERM);
}
} else {
sender.sendMessage(UDSMessage.BAD_COMMAND);
}
return true;
}
@Override
public SpoutPlayer getPlayer(String name) {
return (SpoutPlayer) server.getPlayer(name);
}
public boolean setUp() {
try {
FileUtils.deleteFolder(invDirectory);
FileUtils.deleteFolder(serverDirectory);
invDirectory.mkdirs();
Assert.assertTrue(invDirectory.exists());
MockGateway.MOCK_STANDARD_METHODS = false;
plugin = PowerMockito.spy(new MultiverseInventories());
core = PowerMockito.spy(new MultiverseCore());
// Let's let all MV files go to bin/test
doReturn(invDirectory).when(plugin).getDataFolder();
// Let's let all MV files go to bin/test
doReturn(coreDirectory).when(core).getDataFolder();
// Return a fake PDF file.
PluginDescriptionFile pdf =
PowerMockito.spy(
new PluginDescriptionFile(
"Multiverse-Inventories",
"2.4-test",
"com.onarandombox.multiverseinventories.MultiverseInventories"));
when(pdf.getAuthors()).thenReturn(new ArrayList<String>());
doReturn(pdf).when(plugin).getDescription();
doReturn(core).when(plugin).getCore();
doReturn(true).when(plugin).isEnabled();
PluginDescriptionFile pdfCore =
PowerMockito.spy(
new PluginDescriptionFile(
"Multiverse-Core", "2.2-Test", "com.onarandombox.MultiverseCore.MultiverseCore"));
when(pdfCore.getAuthors()).thenReturn(new ArrayList<String>());
doReturn(pdfCore).when(core).getDescription();
doReturn(true).when(core).isEnabled();
plugin.setServerFolder(serverDirectory);
// Add Core to the list of loaded plugins
JavaPlugin[] plugins = new JavaPlugin[] {plugin, core};
// Mock the Plugin Manager
PluginManager mockPluginManager = PowerMockito.mock(PluginManager.class);
when(mockPluginManager.getPlugins()).thenReturn(plugins);
when(mockPluginManager.getPlugin("Multiverse-Inventories")).thenReturn(plugin);
when(mockPluginManager.getPlugin("Multiverse-Core")).thenReturn(core);
when(mockPluginManager.getPermission(anyString())).thenReturn(null);
// Make some fake folders to fool the fake MV into thinking these worlds exist
File worldNormalFile = new File(plugin.getServerFolder(), "world");
Util.log("Creating world-folder: " + worldNormalFile.getAbsolutePath());
worldNormalFile.mkdirs();
MockWorldFactory.makeNewMockWorld("world", Environment.NORMAL, WorldType.NORMAL);
File worldNetherFile = new File(plugin.getServerFolder(), "world_nether");
Util.log("Creating world-folder: " + worldNetherFile.getAbsolutePath());
worldNetherFile.mkdirs();
MockWorldFactory.makeNewMockWorld("world_nether", Environment.NETHER, WorldType.NORMAL);
File worldSkylandsFile = new File(plugin.getServerFolder(), "world_the_end");
Util.log("Creating world-folder: " + worldSkylandsFile.getAbsolutePath());
worldSkylandsFile.mkdirs();
MockWorldFactory.makeNewMockWorld("world_the_end", Environment.THE_END, WorldType.NORMAL);
File world2File = new File(plugin.getServerFolder(), "world2");
Util.log("Creating world-folder: " + world2File.getAbsolutePath());
world2File.mkdirs();
MockWorldFactory.makeNewMockWorld("world2", Environment.NORMAL, WorldType.NORMAL);
// Initialize the Mock server.
mockServer = mock(Server.class);
when(mockServer.getName()).thenReturn("TestBukkit");
Logger.getLogger("Minecraft").setParent(Util.logger);
when(mockServer.getLogger()).thenReturn(Util.logger);
when(mockServer.getWorldContainer()).thenReturn(worldsDirectory);
when(plugin.getServer()).thenReturn(mockServer);
when(core.getServer()).thenReturn(mockServer);
when(mockServer.getPluginManager()).thenReturn(mockPluginManager);
Answer<Player> playerAnswer =
new Answer<Player>() {
public Player answer(InvocationOnMock invocation) throws Throwable {
String arg;
try {
arg = (String) invocation.getArguments()[0];
} catch (Exception e) {
return null;
}
Player player = players.get(arg);
if (player == null) {
player = new MockPlayer(arg, mockServer);
players.put(arg, player);
}
return player;
}
};
when(mockServer.getPlayer(anyString())).thenAnswer(playerAnswer);
when(mockServer.getOfflinePlayer(anyString())).thenAnswer(playerAnswer);
when(mockServer.getOfflinePlayers())
.thenAnswer(
new Answer<OfflinePlayer[]>() {
public OfflinePlayer[] answer(InvocationOnMock invocation) throws Throwable {
return players.values().toArray(new Player[players.values().size()]);
}
});
when(mockServer.getOnlinePlayers())
.thenAnswer(
new Answer<Player[]>() {
public Player[] answer(InvocationOnMock invocation) throws Throwable {
return players.values().toArray(new Player[players.values().size()]);
}
});
// Give the server some worlds
when(mockServer.getWorld(anyString()))
.thenAnswer(
new Answer<World>() {
public World answer(InvocationOnMock invocation) throws Throwable {
String arg;
try {
arg = (String) invocation.getArguments()[0];
} catch (Exception e) {
return null;
}
return MockWorldFactory.getWorld(arg);
}
});
when(mockServer.getWorld(any(UUID.class)))
.thenAnswer(
new Answer<World>() {
@Override
public World answer(InvocationOnMock invocation) throws Throwable {
UUID arg;
try {
arg = (UUID) invocation.getArguments()[0];
} catch (Exception e) {
return null;
}
return MockWorldFactory.getWorld(arg);
}
});
when(mockServer.getWorlds())
.thenAnswer(
new Answer<List<World>>() {
public List<World> answer(InvocationOnMock invocation) throws Throwable {
return MockWorldFactory.getWorlds();
}
});
when(mockServer.createWorld(Matchers.isA(WorldCreator.class)))
.thenAnswer(
new Answer<World>() {
public World answer(InvocationOnMock invocation) throws Throwable {
WorldCreator arg;
try {
arg = (WorldCreator) invocation.getArguments()[0];
} catch (Exception e) {
return null;
}
// Add special case for creating null worlds.
// Not sure I like doing it this way, but this is a special case
if (arg.name().equalsIgnoreCase("nullworld")) {
return MockWorldFactory.makeNewNullMockWorld(
arg.name(), arg.environment(), arg.type());
}
return MockWorldFactory.makeNewMockWorld(
arg.name(), arg.environment(), arg.type());
}
});
when(mockServer.unloadWorld(anyString(), anyBoolean())).thenReturn(true);
// add mock scheduler
BukkitScheduler mockScheduler = mock(BukkitScheduler.class);
when(mockScheduler.scheduleSyncDelayedTask(any(Plugin.class), any(Runnable.class), anyLong()))
.thenAnswer(
new Answer<Integer>() {
public Integer answer(InvocationOnMock invocation) throws Throwable {
Runnable arg;
try {
arg = (Runnable) invocation.getArguments()[1];
} catch (Exception e) {
return null;
}
arg.run();
return null;
}
});
when(mockScheduler.scheduleSyncDelayedTask(any(Plugin.class), any(Runnable.class)))
.thenAnswer(
new Answer<Integer>() {
public Integer answer(InvocationOnMock invocation) throws Throwable {
Runnable arg;
try {
arg = (Runnable) invocation.getArguments()[1];
} catch (Exception e) {
return null;
}
arg.run();
return null;
}
});
when(mockServer.getScheduler()).thenReturn(mockScheduler);
// Set InventoriesListener
InventoriesListener il = PowerMockito.spy(new InventoriesListener(plugin));
Field inventoriesListenerField =
MultiverseInventories.class.getDeclaredField("inventoriesListener");
inventoriesListenerField.setAccessible(true);
inventoriesListenerField.set(plugin, il);
// Set Core
Field coreField = MultiverseInventories.class.getDeclaredField("core");
coreField.setAccessible(true);
coreField.set(plugin, core);
// Set server
Field serverfield = JavaPlugin.class.getDeclaredField("server");
serverfield.setAccessible(true);
serverfield.set(plugin, mockServer);
// Set worldManager
WorldManager wm = PowerMockito.spy(new WorldManager(core));
Field worldmanagerfield = MultiverseCore.class.getDeclaredField("worldManager");
worldmanagerfield.setAccessible(true);
worldmanagerfield.set(core, wm);
// Set playerListener
MVPlayerListener pl = PowerMockito.spy(new MVPlayerListener(core));
Field playerlistenerfield = MultiverseCore.class.getDeclaredField("playerListener");
playerlistenerfield.setAccessible(true);
playerlistenerfield.set(core, pl);
// Set entityListener
MVEntityListener el = PowerMockito.spy(new MVEntityListener(core));
Field entitylistenerfield = MultiverseCore.class.getDeclaredField("entityListener");
entitylistenerfield.setAccessible(true);
entitylistenerfield.set(core, el);
// Set weatherListener
MVWeatherListener wl = PowerMockito.spy(new MVWeatherListener(core));
Field weatherlistenerfield = MultiverseCore.class.getDeclaredField("weatherListener");
weatherlistenerfield.setAccessible(true);
weatherlistenerfield.set(core, wl);
// Init our command sender
final Logger commandSenderLogger = Logger.getLogger("CommandSender");
commandSenderLogger.setParent(Util.logger);
commandSender = mock(CommandSender.class);
doAnswer(
new Answer<Void>() {
public Void answer(InvocationOnMock invocation) throws Throwable {
commandSenderLogger.info(
ChatColor.stripColor((String) invocation.getArguments()[0]));
return null;
}
})
.when(commandSender)
.sendMessage(anyString());
when(commandSender.getServer()).thenReturn(mockServer);
when(commandSender.getName()).thenReturn("MockCommandSender");
when(commandSender.isPermissionSet(anyString())).thenReturn(true);
when(commandSender.isPermissionSet(Matchers.isA(Permission.class))).thenReturn(true);
when(commandSender.hasPermission(anyString())).thenReturn(true);
when(commandSender.hasPermission(Matchers.isA(Permission.class))).thenReturn(true);
when(commandSender.addAttachment(plugin)).thenReturn(null);
when(commandSender.isOp()).thenReturn(true);
Bukkit.setServer(mockServer);
// Load Multiverse Core
core.onLoad();
plugin.onLoad();
// Enable it.
core.onEnable();
plugin.onEnable();
return true;
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
@Test
public void testEnableDebugMode() {
// Initialize a fake command
Command mockCommand = mock(Command.class);
when(mockCommand.getName()).thenReturn("spam");
// Assert debug mode is off
Assert.assertEquals(0, (int) myPlugin.config().get(BaseConfig.DEBUG_MODE));
// Send the debug command.
String[] cmdArgs = new String[] {"debug", "3"};
myPlugin.onCommand(mockCommandSender, mockCommand, "", cmdArgs);
cmdArgs = new String[] {"reload"};
myPlugin.onCommand(mockCommandSender, mockCommand, "", cmdArgs);
Assert.assertEquals(3, (int) myPlugin.config().get(BaseConfig.DEBUG_MODE));
Assert.assertEquals(
BaseConfig.LOCALE.getDefault().toString(),
myPlugin.config().get(BaseConfig.LOCALE).toString());
myPlugin.config().set(BaseConfig.LOCALE, Locale.CANADA);
Assert.assertEquals(Locale.CANADA, myPlugin.config().get(BaseConfig.LOCALE));
myPlugin.config().set(Config.MUTE_LENGTH, 3);
myPlugin.config().save();
Assert.assertEquals(myPlugin.config().get(Config.MUTE_LENGTH), Integer.valueOf(3));
Player player = mockServer.getPlayer("dumptruckman");
listener.onPlayerCommandPreprocess(new PlayerCommandPreprocessEvent(player, "/g hello"));
listener.onPlayerChat(new PlayerChatEvent(player, "hello"));
listener.onPlayerChat(new PlayerChatEvent(player, "hello"));
listener.onPlayerCommandPreprocess(new PlayerCommandPreprocessEvent(player, "/g hello"));
cmdArgs = new String[] {"unmute", "dumptruckman"};
myPlugin.onCommand(mockCommandSender, mockCommand, "", cmdArgs);
listener.onPlayerChat(new PlayerChatEvent(player, "hello"));
sleep(1002);
listener.onPlayerChat(new PlayerChatEvent(player, "hello"));
sleep(1002);
listener.onPlayerChat(new PlayerChatEvent(player, "hello"));
sleep(1002);
listener.onPlayerChat(new PlayerChatEvent(player, "hello"));
sleep(3000);
try {
Field field = DefaultSpamHandler.class.getDeclaredField("config");
field.setAccessible(true);
field.set(myPlugin.getSpamHandler(), myPlugin.config());
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
((DefaultSpamHandler) myPlugin.getSpamHandler()).checkTimes();
listener.onPlayerChat(new PlayerChatEvent(player, "hello"));
listener.onPlayerChat(new PlayerChatEvent(player, "hello"));
listener.onPlayerChat(new PlayerChatEvent(player, "hello"));
listener.onPlayerChat(new PlayerChatEvent(player, "hello"));
try {
Field field = DefaultSpamHandler.class.getDeclaredField("beenKicked");
field.setAccessible(true);
List<OfflinePlayer> kickedPlayers =
(List<OfflinePlayer>) field.get(myPlugin.getSpamHandler());
Assert.assertTrue(kickedPlayers.contains(player));
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
