304 lines
14 KiB
Java
304 lines
14 KiB
Java
package me.libraryaddict.disguise.utilities.parser;
|
|
|
|
import org.bukkit.permissions.Permissible;
|
|
import org.bukkit.permissions.Permission;
|
|
import org.bukkit.permissions.PermissionAttachment;
|
|
import org.bukkit.permissions.PermissionAttachmentInfo;
|
|
import org.bukkit.plugin.Plugin;
|
|
import org.junit.Assert;
|
|
import org.junit.Test;
|
|
|
|
import java.util.*;
|
|
|
|
/**
|
|
* Created by libraryaddict on 21/10/2018.
|
|
*/
|
|
public class DisguisePermissionsTest {
|
|
@Test
|
|
public void testDisguisesExist() {
|
|
Assert.assertNull("There should not be a reindeer disguise", DisguiseParser.getDisguisePerm("Reindeer"));
|
|
|
|
Assert.assertNotNull("There should be a cow disguise", DisguiseParser.getDisguisePerm("Cow"));
|
|
|
|
Assert.assertNotNull("There should be a firework disguise", DisguiseParser.getDisguisePerm("Firework"));
|
|
}
|
|
|
|
@Test
|
|
public void testPermissionNames() {
|
|
Assert.assertFalse("There should not be permissions", createPermissions("Disguise", false).hasPermissions());
|
|
|
|
Assert.assertFalse("The commands should not match",
|
|
createPermissions("Disguise", false, "libsdisguises.disguiseentity.cow").hasPermissions());
|
|
|
|
Assert.assertFalse("The commands should not match",
|
|
createPermissions("Disguised", false, "libsdisguises.disguise.cow").hasPermissions());
|
|
|
|
Assert.assertTrue("There should be permissions",
|
|
createPermissions("Disguise", false, "libsdisguises.*.animal").hasPermissions());
|
|
}
|
|
|
|
@Test
|
|
public void testOperatorPermissions() {
|
|
DisguisePermissions permissions = createPermissions("Disguise", true, "-libsdisguises.disguise.sheep",
|
|
"-libsdisguises.disguise.horse.setBaby");
|
|
|
|
Assert.assertTrue("There should be permissions", permissions.hasPermissions());
|
|
|
|
Assert.assertTrue("The disguise cow should be allowed",
|
|
permissions.isAllowedDisguise(DisguiseParser.getDisguisePerm("Cow")));
|
|
|
|
Assert.assertFalse("The disguise sheep should not be allowed",
|
|
permissions.isAllowedDisguise(DisguiseParser.getDisguisePerm("Sheep")));
|
|
|
|
Assert.assertTrue("The disguise horse should be allowed",
|
|
permissions.isAllowedDisguise(DisguiseParser.getDisguisePerm("Horse")));
|
|
|
|
Assert.assertFalse("The disguise horse should not be allowed with setBaby", permissions
|
|
.isAllowedDisguise(DisguiseParser.getDisguisePerm("Horse"), Collections.singletonList("setBaby")));
|
|
}
|
|
|
|
@Test
|
|
public void testWildcardsPermissions() {
|
|
Assert.assertTrue("The cow disguise should be allowed",
|
|
createPermissions("Disguise", false, "libsdisguises.*.animal")
|
|
.isAllowedDisguise(DisguiseParser.getDisguisePerm("Cow")));
|
|
|
|
Assert.assertFalse("The firework disguise should not be allowed",
|
|
createPermissions("Disguise", false, "libsdisguises.*.animal")
|
|
.isAllowedDisguise(DisguiseParser.getDisguisePerm("Firework")));
|
|
|
|
Assert.assertTrue("The firework disguise should be allowed",
|
|
createPermissions("Disguise", false, "libsdisguises.*.*")
|
|
.isAllowedDisguise(DisguiseParser.getDisguisePerm("Firework")));
|
|
|
|
Assert.assertTrue("The firework disguise should be allowed",
|
|
createPermissions("Disguise", false, "libsdisguises.disguise.*")
|
|
.isAllowedDisguise(DisguiseParser.getDisguisePerm("Firework")));
|
|
|
|
Assert.assertTrue("The firework disguise should be allowed",
|
|
createPermissions("Disguise", false, "libsdisguises.*.Firework")
|
|
.isAllowedDisguise(DisguiseParser.getDisguisePerm("Firework")));
|
|
|
|
Assert.assertFalse("The firework disguise should not be allowed",
|
|
createPermissions("Disguise", false, "libsdisguises.*.*", "-libsdisguises.*.misc")
|
|
.isAllowedDisguise(DisguiseParser.getDisguisePerm("Firework")));
|
|
|
|
Assert.assertTrue("The firework disguise should be allowed",
|
|
createPermissions("Disguise", false, "libsdisguises.disguise.*", "-libsdisguises.*.*")
|
|
.isAllowedDisguise(DisguiseParser.getDisguisePerm("Firework")));
|
|
|
|
Assert.assertTrue("The firework disguise should be allowed",
|
|
createPermissions("Disguise", false, "libsdisguises.disguise.firework", "-libsdisguises.disguise.misc")
|
|
.isAllowedDisguise(DisguiseParser.getDisguisePerm("Firework")));
|
|
}
|
|
|
|
@Test
|
|
public void testInheritedPermissions() {
|
|
testInheritedPermissions(createPermissions("Disguise", false, "libsdisguises.disguise.animal.setBaby",
|
|
"-libsdisguises.disguise.sheep.setBaby"));
|
|
|
|
testInheritedPermissions(createPermissions("Disguise", false, "libsdisguises.disguise.animal.setBaby",
|
|
"libsdisguises.disguise.sheep.-setBaby"));
|
|
}
|
|
|
|
private void testInheritedPermissions(DisguisePermissions permissions) {
|
|
Assert.assertTrue("The sheep disguise should be allowed",
|
|
permissions.isAllowedDisguise(DisguiseParser.getDisguisePerm("Sheep")));
|
|
|
|
Assert.assertTrue("The cow disguise should be allowed",
|
|
permissions.isAllowedDisguise(DisguiseParser.getDisguisePerm("Cow")));
|
|
|
|
Assert.assertTrue("The cow disguise should be allowed with setBaby", permissions
|
|
.isAllowedDisguise(DisguiseParser.getDisguisePerm("Cow"), Collections.singletonList("setBaby")));
|
|
|
|
Assert.assertFalse("The sheep disguise should not be allowed with setBaby", permissions
|
|
.isAllowedDisguise(DisguiseParser.getDisguisePerm("Sheep"), Collections.singletonList("setBaby")));
|
|
|
|
Assert.assertFalse("The firework disguise should not be allowed",
|
|
permissions.isAllowedDisguise(DisguiseParser.getDisguisePerm("Firework")));
|
|
}
|
|
|
|
@Test
|
|
public void testNegatedPermissions() {
|
|
DisguisePermissions permissions = createPermissions("Disguise", false, "libsdisguises.disguise.sheep",
|
|
"-libsdisguises.disguise.cow.setSprinting", "-libsdisguises.disguise.donkey",
|
|
"-libsdisguises.disguise.horse.setRearing", "libsdisguises.disguise.horse");
|
|
|
|
Assert.assertFalse("The cow disguise should not be allowed",
|
|
permissions.isAllowedDisguise(DisguiseParser.getDisguisePerm("Cow")));
|
|
|
|
Assert.assertTrue("The sheep disguise should be allowed",
|
|
permissions.isAllowedDisguise(DisguiseParser.getDisguisePerm("Sheep")));
|
|
|
|
Assert.assertFalse("The donkey disguise should not be allowed",
|
|
permissions.isAllowedDisguise(DisguiseParser.getDisguisePerm("Donkey")));
|
|
|
|
Assert.assertTrue("The horse disguise should be allowed",
|
|
permissions.isAllowedDisguise(DisguiseParser.getDisguisePerm("Horse")));
|
|
|
|
Assert.assertTrue("The horse disguise should be allowed with options", permissions
|
|
.isAllowedDisguise(DisguiseParser.getDisguisePerm("Horse"), Collections.singletonList("setBaby")));
|
|
|
|
Assert.assertFalse("The horse disguise should not be allowed setRearing", permissions
|
|
.isAllowedDisguise(DisguiseParser.getDisguisePerm("Horse"), Collections.singletonList("setRearing")));
|
|
}
|
|
|
|
@Test
|
|
public void testMultiDisguises() {
|
|
DisguisePermissions permissions = createPermissions("Disguise", false, "libsdisguises.disguise.cow.setBaby",
|
|
"libsdisguises.disguise.cow.setHealth", "libsdisguises.disguise.cow.-setBurning");
|
|
|
|
Assert.assertTrue("The cow disguise should be able to use setBaby", permissions
|
|
.isAllowedDisguise(DisguiseParser.getDisguisePerm("Cow"), Collections.singletonList("setBaby")));
|
|
|
|
Assert.assertTrue("The cow disguise should be able to use setHealth", permissions
|
|
.isAllowedDisguise(DisguiseParser.getDisguisePerm("Cow"), Collections.singletonList("setHealth")));
|
|
|
|
Assert.assertTrue("The cow disguise should be able to use setBaby and setHealth", permissions
|
|
.isAllowedDisguise(DisguiseParser.getDisguisePerm("Cow"), Arrays.asList("setBaby", "setHealth")));
|
|
|
|
Assert.assertFalse("The cow disguise should not be able to use setBurning", permissions
|
|
.isAllowedDisguise(DisguiseParser.getDisguisePerm("Cow"), Collections.singletonList("setBurning")));
|
|
|
|
Assert.assertFalse("The cow disguise should not be able to use setSprinting", permissions
|
|
.isAllowedDisguise(DisguiseParser.getDisguisePerm("Cow"), Collections.singletonList("setSprinting")));
|
|
|
|
Assert.assertFalse("The cow disguise should not be able to use setSprinting with setBaby", permissions
|
|
.isAllowedDisguise(DisguiseParser.getDisguisePerm("Cow"), Arrays.asList("setSprinting", "setBaby")));
|
|
}
|
|
|
|
@Test
|
|
public void testOptions() {
|
|
Assert.assertFalse("The disguise should not be valid",
|
|
createPermissions("Disguise", false, "libsdisguises.disguise.cow", "-libsdisguises.disguise.cow")
|
|
.hasPermissions());
|
|
|
|
DisguisePermissions permissions = createPermissions("Disguise", false, "libsdisguises.disguise.cow",
|
|
"libsdisguises.disguise.sheep.setColor.setSprinting", "libsdisguises.disguise.animal.-setSprinting");
|
|
|
|
Assert.assertTrue("There should be a valid disguise", permissions.hasPermissions());
|
|
|
|
DisguisePerm cow = DisguiseParser.getDisguisePerm("Cow");
|
|
|
|
Assert.assertTrue("The cow disguise should be allowed", permissions.isAllowedDisguise(cow));
|
|
|
|
Assert.assertTrue("The cow disguise should be allowed with options",
|
|
permissions.isAllowedDisguise(cow, Arrays.asList("setBaby", "setBurning")));
|
|
|
|
Assert.assertFalse("The cow disguise should not be allowed with options setSprinting",
|
|
permissions.isAllowedDisguise(cow, Arrays.asList("setBaby", "setSprinting")));
|
|
|
|
Assert.assertFalse("The cow disguise should not be allowed with options",
|
|
permissions.isAllowedDisguise(cow, Collections.singletonList("setSprinting")));
|
|
|
|
DisguisePerm sheep = DisguiseParser.getDisguisePerm("Sheep");
|
|
|
|
Assert.assertFalse("The sheep disguise should not be allowed with options",
|
|
permissions.isAllowedDisguise(sheep, Arrays.asList("setBaby", "setBurning")));
|
|
|
|
Assert.assertTrue("The sheep disguise should be allowed setColor",
|
|
permissions.isAllowedDisguise(sheep, Collections.singletonList("setColor")));
|
|
|
|
Assert.assertTrue("The sheep disguise should be allowed setSprinting",
|
|
permissions.isAllowedDisguise(sheep, Collections.singletonList("setSprinting")));
|
|
|
|
Assert.assertFalse("The sheep disguise should not be allowed setColor and setBaby",
|
|
permissions.isAllowedDisguise(sheep, Arrays.asList("setColor", "setBaby")));
|
|
|
|
DisguisePerm firework = DisguiseParser.getDisguisePerm("Firework");
|
|
|
|
Assert.assertFalse("The firework disguise should not be allowed", permissions.isAllowedDisguise(firework));
|
|
|
|
Assert.assertFalse("The disguise should not be allowed even with options",
|
|
permissions.isAllowedDisguise(firework, Arrays.asList("setBaby", "setBurning")));
|
|
}
|
|
|
|
private DisguisePermissions createPermissions(String commandName, boolean isOp, String... perms) {
|
|
List<String> permitted = new ArrayList<>();
|
|
List<String> negated = new ArrayList<>();
|
|
Set<PermissionAttachmentInfo> attachments = new HashSet<>();
|
|
|
|
Permissible permissible = new Permissible() {
|
|
@Override
|
|
public boolean isPermissionSet(String s) {
|
|
return permitted.contains(s) || negated.contains(s);
|
|
}
|
|
|
|
@Override
|
|
public boolean isPermissionSet(Permission permission) {
|
|
throw new UnsupportedOperationException("Not Supported");
|
|
}
|
|
|
|
@Override
|
|
public boolean hasPermission(String s) {
|
|
return permitted.contains(s) || (isOp() && !negated.contains(s));
|
|
}
|
|
|
|
@Override
|
|
public boolean hasPermission(Permission permission) {
|
|
throw new UnsupportedOperationException("Not Supported");
|
|
}
|
|
|
|
@Override
|
|
public PermissionAttachment addAttachment(Plugin plugin, String s, boolean b) {
|
|
throw new UnsupportedOperationException("Not Supported");
|
|
}
|
|
|
|
@Override
|
|
public PermissionAttachment addAttachment(Plugin plugin) {
|
|
throw new UnsupportedOperationException("Not Supported");
|
|
}
|
|
|
|
@Override
|
|
public PermissionAttachment addAttachment(Plugin plugin, String s, boolean b, int i) {
|
|
throw new UnsupportedOperationException("Not Supported");
|
|
}
|
|
|
|
@Override
|
|
public PermissionAttachment addAttachment(Plugin plugin, int i) {
|
|
throw new UnsupportedOperationException("Not Supported");
|
|
}
|
|
|
|
@Override
|
|
public void removeAttachment(PermissionAttachment permissionAttachment) {
|
|
throw new UnsupportedOperationException("Not Supported");
|
|
}
|
|
|
|
@Override
|
|
public void recalculatePermissions() {
|
|
throw new UnsupportedOperationException("Not Supported");
|
|
}
|
|
|
|
@Override
|
|
public Set<PermissionAttachmentInfo> getEffectivePermissions() {
|
|
return attachments;
|
|
}
|
|
|
|
@Override
|
|
public boolean isOp() {
|
|
return isOp;
|
|
}
|
|
|
|
@Override
|
|
public void setOp(boolean b) {
|
|
throw new UnsupportedOperationException("Not Supported");
|
|
}
|
|
};
|
|
|
|
// If permission starts with a - then it was negated
|
|
Arrays.stream(perms).forEach(perm -> {
|
|
boolean setTrue = !perm.startsWith("-");
|
|
|
|
if (setTrue) {
|
|
permitted.add(perm);
|
|
} else {
|
|
negated.add(perm = perm.substring(1));
|
|
}
|
|
|
|
attachments.add(new PermissionAttachmentInfo(permissible, perm, null, setTrue));
|
|
});
|
|
|
|
return new DisguisePermissions(permissible, commandName);
|
|
}
|
|
}
|