Compare commits

..

12 Commits

15 changed files with 5178 additions and 12 deletions
.gitignore
lib/src/main/java/net/tomatentum/marinara
wrapper/javacord/src

4
.gitignore vendored

@ -3,4 +3,6 @@
# Ignore Gradle build output directory # Ignore Gradle build output directory
build build
.vscode .vscode
lib/bin
wrapper/javacord/bin

@ -0,0 +1,12 @@
package net.tomatentum.marinara.interaction.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Button {
public String value(); //aka customId
}

@ -0,0 +1,40 @@
package net.tomatentum.marinara.interaction.methods;
import java.lang.reflect.Method;
import net.tomatentum.marinara.interaction.InteractionHandler;
import net.tomatentum.marinara.interaction.InteractionType;
import net.tomatentum.marinara.interaction.annotation.Button;
import net.tomatentum.marinara.wrapper.LibraryWrapper;
public class ButtonInteractionMethod extends InteractionMethod {
private String customId;
ButtonInteractionMethod(Method method, InteractionHandler handler, LibraryWrapper wrapper) {
super(method, handler, wrapper);
parseMethod();
}
@Override
public Object getParameter(Object parameter, int index) {
Class<?> type = getMethod().getParameterTypes()[index+1];
return wrapper.getComponentContextObject(parameter, type);
}
@Override
public boolean canRun(Object context) {
return wrapper.getButtonId(context).equals(customId);
}
@Override
public InteractionType getType() {
return InteractionType.BUTTON;
}
private void parseMethod() {
Button button = getMethod().getAnnotation(Button.class);
this.customId = button.value();
}
}

@ -9,6 +9,7 @@ import java.util.List;
import net.tomatentum.marinara.interaction.InteractionHandler; import net.tomatentum.marinara.interaction.InteractionHandler;
import net.tomatentum.marinara.interaction.InteractionType; import net.tomatentum.marinara.interaction.InteractionType;
import net.tomatentum.marinara.interaction.annotation.Button;
import net.tomatentum.marinara.interaction.commands.annotation.SlashCommand; import net.tomatentum.marinara.interaction.commands.annotation.SlashCommand;
import net.tomatentum.marinara.interaction.commands.annotation.SubCommand; import net.tomatentum.marinara.interaction.commands.annotation.SubCommand;
import net.tomatentum.marinara.wrapper.LibraryWrapper; import net.tomatentum.marinara.wrapper.LibraryWrapper;
@ -18,7 +19,8 @@ public abstract class InteractionMethod {
public static InteractionMethod create(Method method, InteractionHandler handler, LibraryWrapper wrapper) { public static InteractionMethod create(Method method, InteractionHandler handler, LibraryWrapper wrapper) {
if (method.isAnnotationPresent(SlashCommand.class) || method.isAnnotationPresent(SubCommand.class)) if (method.isAnnotationPresent(SlashCommand.class) || method.isAnnotationPresent(SubCommand.class))
return new SlashCommandInteractionMethod(method, handler, wrapper); return new SlashCommandInteractionMethod(method, handler, wrapper);
if (method.isAnnotationPresent(Button.class))
return new ButtonInteractionMethod(method, handler, wrapper);
return null; return null;
} }

@ -17,7 +17,6 @@ public abstract class LibraryWrapper {
interactionSubscriber = new ArrayList<>(); interactionSubscriber = new ArrayList<>();
} }
public abstract void registerSlashCommands(SlashCommandDefinition[] defs);
public void handleInteraction(Object context) { public void handleInteraction(Object context) {
interactionSubscriber.forEach((o) -> o.accept(context)); interactionSubscriber.forEach((o) -> o.accept(context));
@ -31,6 +30,11 @@ public abstract class LibraryWrapper {
} }
public abstract InteractionType getInteractionType(Class<?> clazz); public abstract InteractionType getInteractionType(Class<?> clazz);
public abstract void registerSlashCommands(SlashCommandDefinition[] defs);
public abstract Object convertCommandOption(Object context, SlashCommandOptionType type, String optionName); public abstract Object convertCommandOption(Object context, SlashCommandOptionType type, String optionName);
public abstract ExecutableSlashCommandDefinition getCommandDefinition(Object context); public abstract ExecutableSlashCommandDefinition getCommandDefinition(Object context);
public abstract String getButtonId(Object context);
public abstract Object getComponentContextObject(Object context, Class<?> type);
} }

@ -10,6 +10,7 @@ import java.util.Set;
import org.javacord.api.DiscordApi; import org.javacord.api.DiscordApi;
import org.javacord.api.interaction.ApplicationCommandInteraction; import org.javacord.api.interaction.ApplicationCommandInteraction;
import org.javacord.api.interaction.ButtonInteraction;
import org.javacord.api.interaction.SlashCommandBuilder; import org.javacord.api.interaction.SlashCommandBuilder;
import org.javacord.api.interaction.SlashCommandInteraction; import org.javacord.api.interaction.SlashCommandInteraction;
import org.javacord.api.interaction.SlashCommandInteractionOption; import org.javacord.api.interaction.SlashCommandInteractionOption;
@ -35,6 +36,16 @@ public class JavacordWrapper extends LibraryWrapper {
api.addInteractionCreateListener((e) -> handleInteraction(e.getInteraction())); api.addInteractionCreateListener((e) -> handleInteraction(e.getInteraction()));
} }
@Override
public InteractionType getInteractionType(Class<?> clazz) {
if (ApplicationCommandInteraction.class.isAssignableFrom(clazz))
return InteractionType.COMMAND;
if (ButtonInteraction.class.isAssignableFrom(clazz))
return InteractionType.BUTTON;
return null;
}
@Override @Override
public void registerSlashCommands(SlashCommandDefinition[] defs) { public void registerSlashCommands(SlashCommandDefinition[] defs) {
HashMap<Long, Set<SlashCommandBuilder>> serverCommands = new HashMap<>(); HashMap<Long, Set<SlashCommandBuilder>> serverCommands = new HashMap<>();
@ -56,14 +67,6 @@ public class JavacordWrapper extends LibraryWrapper {
api.bulkOverwriteGlobalApplicationCommands(globalCommands); api.bulkOverwriteGlobalApplicationCommands(globalCommands);
} }
@Override
public InteractionType getInteractionType(Class<?> clazz) {
if (ApplicationCommandInteraction.class.isAssignableFrom(clazz))
return InteractionType.COMMAND;
return null;
}
@Override @Override
public Object convertCommandOption(Object context, SlashCommandOptionType type, String optionName) { public Object convertCommandOption(Object context, SlashCommandOptionType type, String optionName) {
if (!(context instanceof SlashCommandInteraction)) if (!(context instanceof SlashCommandInteraction))
@ -156,4 +159,28 @@ public class JavacordWrapper extends LibraryWrapper {
return null; return null;
} }
} }
@Override
public String getButtonId(Object context) {
ButtonInteraction button = (ButtonInteraction) context;
return button.getCustomId();
}
@Override
public Object getComponentContextObject(Object context, Class<?> type) {
ButtonInteraction button = (ButtonInteraction) context;
switch (type.getName()) {
case "org.javacord.api.entity.channel.TextChannel":
return button.getChannel().orElse(null);
case "org.javacord.api.entity.message.Message":
return button.getMessage();
case "org.javacord.api.entity.server.Server":
return button.getServer().orElse(null);
case "org.javacord.api.entity.user.User":
return button.getUser();
}
return null;
}
} }

@ -0,0 +1,27 @@
package net.tomatentum.marinara.test;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInstance;
import org.junit.jupiter.api.TestInstance.Lifecycle;
import net.tomatentum.marinara.Marinara;
import net.tomatentum.marinara.test.mocks.ButtonInteractionMock;
import net.tomatentum.marinara.test.mocks.DiscordApiMock;
import net.tomatentum.marinara.wrapper.LibraryWrapper;
import net.tomatentum.marinare.wrapper.javacord.JavacordWrapper;
@TestInstance(Lifecycle.PER_CLASS)
public class ButtonTest {
@Test
public void testButtonExecution() {
LibraryWrapper wrapper = new JavacordWrapper(new DiscordApiMock()); //null okay as we don't use the discord API in this test.
Marinara marinara = Marinara.load(wrapper);
marinara.getRegistry().addInteractions(new TestButton());
wrapper.handleInteraction(new ButtonInteractionMock());
assertTrue(TestButton.didRun);
}
}

@ -0,0 +1,29 @@
package net.tomatentum.marinara.test;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import org.javacord.api.entity.channel.TextChannel;
import org.javacord.api.entity.message.Message;
import org.javacord.api.entity.server.Server;
import org.javacord.api.entity.user.User;
import org.javacord.api.interaction.ButtonInteraction;
import net.tomatentum.marinara.interaction.InteractionHandler;
import net.tomatentum.marinara.interaction.annotation.Button;
public class TestButton implements InteractionHandler {
public static boolean didRun = false;
@Button("test")
public void exec(ButtonInteraction interaction, TextChannel channel, Message message, User member, Server server) {
assertNotNull(interaction);
assertNotNull(channel);
assertNotNull(message);
assertNotNull(member);
assertNotNull(server);
didRun = true;
System.out.println("Success!");
}
}

@ -0,0 +1,137 @@
package net.tomatentum.marinara.test.mocks;
import java.util.EnumSet;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import org.javacord.api.DiscordApi;
import org.javacord.api.entity.channel.TextChannel;
import org.javacord.api.entity.message.Message;
import org.javacord.api.entity.message.component.ComponentType;
import org.javacord.api.entity.message.component.HighLevelComponent;
import org.javacord.api.entity.permission.PermissionType;
import org.javacord.api.entity.server.Server;
import org.javacord.api.entity.user.User;
import org.javacord.api.interaction.ButtonInteraction;
import org.javacord.api.interaction.DiscordLocale;
import org.javacord.api.interaction.InteractionType;
import org.javacord.api.interaction.callback.ComponentInteractionOriginalMessageUpdater;
import org.javacord.api.interaction.callback.InteractionFollowupMessageBuilder;
import org.javacord.api.interaction.callback.InteractionImmediateResponseBuilder;
import org.javacord.api.interaction.callback.InteractionOriginalResponseUpdater;
public class ButtonInteractionMock implements ButtonInteraction {
@Override
public Message getMessage() {
return new MessageMock();
}
@Override
public String getCustomId() {
return "test";
}
@Override
public ComponentType getComponentType() {
return ComponentType.BUTTON;
}
@Override
public CompletableFuture<Void> acknowledge() {
throw new UnsupportedOperationException("Unimplemented method 'acknowledge'");
}
@Override
public ComponentInteractionOriginalMessageUpdater createOriginalMessageUpdater() {
throw new UnsupportedOperationException("Unimplemented method 'createOriginalMessageUpdater'");
}
@Override
public long getApplicationId() {
throw new UnsupportedOperationException("Unimplemented method 'getApplicationId'");
}
@Override
public InteractionType getType() {
return InteractionType.MESSAGE_COMPONENT;
}
@Override
public InteractionImmediateResponseBuilder createImmediateResponder() {
throw new UnsupportedOperationException("Unimplemented method 'createImmediateResponder'");
}
@Override
public CompletableFuture<InteractionOriginalResponseUpdater> respondLater() {
throw new UnsupportedOperationException("Unimplemented method 'respondLater'");
}
@Override
public CompletableFuture<InteractionOriginalResponseUpdater> respondLater(boolean ephemeral) {
throw new UnsupportedOperationException("Unimplemented method 'respondLater'");
}
@Override
public CompletableFuture<Void> respondWithModal(String customId, String title,
List<HighLevelComponent> components) {
throw new UnsupportedOperationException("Unimplemented method 'respondWithModal'");
}
@Override
public InteractionFollowupMessageBuilder createFollowupMessageBuilder() {
throw new UnsupportedOperationException("Unimplemented method 'createFollowupMessageBuilder'");
}
@Override
public Optional<Server> getServer() {
return Optional.of(new ServerMock());
}
@Override
public Optional<TextChannel> getChannel() {
return Optional.of(new ChannelMock());
}
@Override
public User getUser() {
return new UserMock();
}
@Override
public String getToken() {
throw new UnsupportedOperationException("Unimplemented method 'getToken'");
}
@Override
public int getVersion() {
throw new UnsupportedOperationException("Unimplemented method 'getVersion'");
}
@Override
public DiscordLocale getLocale() {
throw new UnsupportedOperationException("Unimplemented method 'getLocale'");
}
@Override
public Optional<DiscordLocale> getServerLocale() {
throw new UnsupportedOperationException("Unimplemented method 'getServerLocale'");
}
@Override
public Optional<EnumSet<PermissionType>> getBotPermissions() {
throw new UnsupportedOperationException("Unimplemented method 'getBotPermissions'");
}
@Override
public DiscordApi getApi() {
throw new UnsupportedOperationException("Unimplemented method 'getApi'");
}
@Override
public long getId() {
throw new UnsupportedOperationException("Unimplemented method 'getId'");
}
}

@ -0,0 +1,824 @@
package net.tomatentum.marinara.test.mocks;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.function.Predicate;
import java.util.stream.Stream;
import org.javacord.api.DiscordApi;
import org.javacord.api.entity.channel.ChannelType;
import org.javacord.api.entity.channel.TextChannel;
import org.javacord.api.entity.message.Message;
import org.javacord.api.entity.message.MessageSet;
import org.javacord.api.entity.user.User;
import org.javacord.api.entity.webhook.IncomingWebhook;
import org.javacord.api.entity.webhook.Webhook;
import org.javacord.api.listener.ObjectAttachableListener;
import org.javacord.api.listener.channel.ChannelAttachableListener;
import org.javacord.api.listener.channel.ServerThreadChannelAttachableListener;
import org.javacord.api.listener.channel.TextChannelAttachableListener;
import org.javacord.api.listener.channel.server.thread.ServerThreadChannelCreateListener;
import org.javacord.api.listener.channel.server.thread.ServerThreadChannelDeleteListener;
import org.javacord.api.listener.channel.server.thread.ServerThreadChannelMembersUpdateListener;
import org.javacord.api.listener.channel.server.thread.ServerThreadChannelUpdateListener;
import org.javacord.api.listener.interaction.AutocompleteCreateListener;
import org.javacord.api.listener.interaction.ButtonClickListener;
import org.javacord.api.listener.interaction.InteractionCreateListener;
import org.javacord.api.listener.interaction.MessageComponentCreateListener;
import org.javacord.api.listener.interaction.MessageContextMenuCommandListener;
import org.javacord.api.listener.interaction.ModalSubmitListener;
import org.javacord.api.listener.interaction.SelectMenuChooseListener;
import org.javacord.api.listener.interaction.SlashCommandCreateListener;
import org.javacord.api.listener.interaction.UserContextMenuCommandListener;
import org.javacord.api.listener.message.CachedMessagePinListener;
import org.javacord.api.listener.message.CachedMessageUnpinListener;
import org.javacord.api.listener.message.ChannelPinsUpdateListener;
import org.javacord.api.listener.message.MessageCreateListener;
import org.javacord.api.listener.message.MessageDeleteListener;
import org.javacord.api.listener.message.MessageEditListener;
import org.javacord.api.listener.message.MessageReplyListener;
import org.javacord.api.listener.message.reaction.ReactionAddListener;
import org.javacord.api.listener.message.reaction.ReactionRemoveAllListener;
import org.javacord.api.listener.message.reaction.ReactionRemoveListener;
import org.javacord.api.listener.server.thread.ServerPrivateThreadJoinListener;
import org.javacord.api.listener.server.thread.ServerThreadChannelChangeArchiveTimestampListener;
import org.javacord.api.listener.server.thread.ServerThreadChannelChangeArchivedListener;
import org.javacord.api.listener.server.thread.ServerThreadChannelChangeAutoArchiveDurationListener;
import org.javacord.api.listener.server.thread.ServerThreadChannelChangeInvitableListener;
import org.javacord.api.listener.server.thread.ServerThreadChannelChangeLastMessageIdListener;
import org.javacord.api.listener.server.thread.ServerThreadChannelChangeLockedListener;
import org.javacord.api.listener.server.thread.ServerThreadChannelChangeMemberCountListener;
import org.javacord.api.listener.server.thread.ServerThreadChannelChangeMessageCountListener;
import org.javacord.api.listener.server.thread.ServerThreadChannelChangeRateLimitPerUserListener;
import org.javacord.api.listener.server.thread.ServerThreadChannelChangeTotalMessageSentListener;
import org.javacord.api.listener.user.UserStartTypingListener;
import org.javacord.api.util.cache.MessageCache;
import org.javacord.api.util.event.ListenerManager;
public class ChannelMock implements TextChannel {
@Override
public ChannelType getType() {
throw new UnsupportedOperationException("Unimplemented method 'getType'");
}
@Override
public DiscordApi getApi() {
throw new UnsupportedOperationException("Unimplemented method 'getApi'");
}
@Override
public long getId() {
throw new UnsupportedOperationException("Unimplemented method 'getId'");
}
@Override
public <T extends ChannelAttachableListener & ObjectAttachableListener> Collection<ListenerManager<T>> addChannelAttachableListener(
T listener) {
throw new UnsupportedOperationException("Unimplemented method 'addChannelAttachableListener'");
}
@Override
public <T extends ChannelAttachableListener & ObjectAttachableListener> void removeChannelAttachableListener(
T listener) {
throw new UnsupportedOperationException("Unimplemented method 'removeChannelAttachableListener'");
}
@Override
public <T extends ChannelAttachableListener & ObjectAttachableListener> Map<T, List<Class<T>>> getChannelAttachableListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getChannelAttachableListeners'");
}
@Override
public <T extends ChannelAttachableListener & ObjectAttachableListener> void removeListener(Class<T> listenerClass,
T listener) {
throw new UnsupportedOperationException("Unimplemented method 'removeListener'");
}
@Override
public ListenerManager<InteractionCreateListener> addInteractionCreateListener(InteractionCreateListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addInteractionCreateListener'");
}
@Override
public List<InteractionCreateListener> getInteractionCreateListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getInteractionCreateListeners'");
}
@Override
public ListenerManager<SlashCommandCreateListener> addSlashCommandCreateListener(
SlashCommandCreateListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addSlashCommandCreateListener'");
}
@Override
public List<SlashCommandCreateListener> getSlashCommandCreateListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getSlashCommandCreateListeners'");
}
@Override
public ListenerManager<AutocompleteCreateListener> addAutocompleteCreateListener(
AutocompleteCreateListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addAutocompleteCreateListener'");
}
@Override
public List<AutocompleteCreateListener> getAutocompleteCreateListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getAutocompleteCreateListeners'");
}
@Override
public ListenerManager<ModalSubmitListener> addModalSubmitListener(ModalSubmitListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addModalSubmitListener'");
}
@Override
public List<ModalSubmitListener> getModalSubmitListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getModalSubmitListeners'");
}
@Override
public ListenerManager<MessageContextMenuCommandListener> addMessageContextMenuCommandListener(
MessageContextMenuCommandListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addMessageContextMenuCommandListener'");
}
@Override
public List<MessageContextMenuCommandListener> getMessageContextMenuCommandListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getMessageContextMenuCommandListeners'");
}
@Override
public ListenerManager<MessageComponentCreateListener> addMessageComponentCreateListener(
MessageComponentCreateListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addMessageComponentCreateListener'");
}
@Override
public List<MessageComponentCreateListener> getMessageComponentCreateListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getMessageComponentCreateListeners'");
}
@Override
public ListenerManager<UserContextMenuCommandListener> addUserContextMenuCommandListener(
UserContextMenuCommandListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addUserContextMenuCommandListener'");
}
@Override
public List<UserContextMenuCommandListener> getUserContextMenuCommandListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getUserContextMenuCommandListeners'");
}
@Override
public ListenerManager<SelectMenuChooseListener> addSelectMenuChooseListener(SelectMenuChooseListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addSelectMenuChooseListener'");
}
@Override
public List<SelectMenuChooseListener> getSelectMenuChooseListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getSelectMenuChooseListeners'");
}
@Override
public ListenerManager<ButtonClickListener> addButtonClickListener(ButtonClickListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addButtonClickListener'");
}
@Override
public List<ButtonClickListener> getButtonClickListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getButtonClickListeners'");
}
@Override
public ListenerManager<UserStartTypingListener> addUserStartTypingListener(UserStartTypingListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addUserStartTypingListener'");
}
@Override
public List<UserStartTypingListener> getUserStartTypingListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getUserStartTypingListeners'");
}
@Override
public ListenerManager<MessageEditListener> addMessageEditListener(MessageEditListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addMessageEditListener'");
}
@Override
public List<MessageEditListener> getMessageEditListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getMessageEditListeners'");
}
@Override
public ListenerManager<ChannelPinsUpdateListener> addChannelPinsUpdateListener(ChannelPinsUpdateListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addChannelPinsUpdateListener'");
}
@Override
public List<ChannelPinsUpdateListener> getChannelPinsUpdateListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getChannelPinsUpdateListeners'");
}
@Override
public ListenerManager<ReactionRemoveListener> addReactionRemoveListener(ReactionRemoveListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addReactionRemoveListener'");
}
@Override
public List<ReactionRemoveListener> getReactionRemoveListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getReactionRemoveListeners'");
}
@Override
public ListenerManager<ReactionAddListener> addReactionAddListener(ReactionAddListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addReactionAddListener'");
}
@Override
public List<ReactionAddListener> getReactionAddListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getReactionAddListeners'");
}
@Override
public ListenerManager<ReactionRemoveAllListener> addReactionRemoveAllListener(ReactionRemoveAllListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addReactionRemoveAllListener'");
}
@Override
public List<ReactionRemoveAllListener> getReactionRemoveAllListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getReactionRemoveAllListeners'");
}
@Override
public ListenerManager<MessageCreateListener> addMessageCreateListener(MessageCreateListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addMessageCreateListener'");
}
@Override
public List<MessageCreateListener> getMessageCreateListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getMessageCreateListeners'");
}
@Override
public ListenerManager<CachedMessageUnpinListener> addCachedMessageUnpinListener(
CachedMessageUnpinListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addCachedMessageUnpinListener'");
}
@Override
public List<CachedMessageUnpinListener> getCachedMessageUnpinListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getCachedMessageUnpinListeners'");
}
@Override
public ListenerManager<CachedMessagePinListener> addCachedMessagePinListener(CachedMessagePinListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addCachedMessagePinListener'");
}
@Override
public List<CachedMessagePinListener> getCachedMessagePinListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getCachedMessagePinListeners'");
}
@Override
public ListenerManager<MessageReplyListener> addMessageReplyListener(MessageReplyListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addMessageReplyListener'");
}
@Override
public List<MessageReplyListener> getMessageReplyListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getMessageReplyListeners'");
}
@Override
public ListenerManager<MessageDeleteListener> addMessageDeleteListener(MessageDeleteListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addMessageDeleteListener'");
}
@Override
public List<MessageDeleteListener> getMessageDeleteListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getMessageDeleteListeners'");
}
@Override
public <T extends TextChannelAttachableListener & ObjectAttachableListener> Collection<ListenerManager<? extends TextChannelAttachableListener>> addTextChannelAttachableListener(
T listener) {
throw new UnsupportedOperationException("Unimplemented method 'addTextChannelAttachableListener'");
}
@Override
public <T extends TextChannelAttachableListener & ObjectAttachableListener> void removeTextChannelAttachableListener(
T listener) {
throw new UnsupportedOperationException("Unimplemented method 'removeTextChannelAttachableListener'");
}
@Override
public <T extends TextChannelAttachableListener & ObjectAttachableListener> Map<T, List<Class<T>>> getTextChannelAttachableListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getTextChannelAttachableListeners'");
}
@Override
public <T extends TextChannelAttachableListener & ObjectAttachableListener> void removeListener(
Class<T> listenerClass, T listener) {
throw new UnsupportedOperationException("Unimplemented method 'removeListener'");
}
@Override
public ListenerManager<ServerThreadChannelChangeLastMessageIdListener> addServerThreadChannelChangeLastMessageIdListener(
ServerThreadChannelChangeLastMessageIdListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelChangeLastMessageIdListener'");
}
@Override
public List<ServerThreadChannelChangeLastMessageIdListener> getServerThreadChannelChangeLastMessageIdListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelChangeLastMessageIdListeners'");
}
@Override
public ListenerManager<ServerThreadChannelChangeArchivedListener> addServerThreadChannelChangeArchivedListener(
ServerThreadChannelChangeArchivedListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelChangeArchivedListener'");
}
@Override
public List<ServerThreadChannelChangeArchivedListener> getServerThreadChannelChangeArchivedListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelChangeArchivedListeners'");
}
@Override
public ListenerManager<ServerThreadChannelChangeMemberCountListener> addServerThreadChannelChangeMemberCountListener(
ServerThreadChannelChangeMemberCountListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelChangeMemberCountListener'");
}
@Override
public List<ServerThreadChannelChangeMemberCountListener> getServerThreadChannelChangeMemberCountListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelChangeMemberCountListeners'");
}
@Override
public ListenerManager<ServerPrivateThreadJoinListener> addServerPrivateThreadJoinListener(
ServerPrivateThreadJoinListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addServerPrivateThreadJoinListener'");
}
@Override
public List<ServerPrivateThreadJoinListener> getServerPrivateThreadJoinListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getServerPrivateThreadJoinListeners'");
}
@Override
public ListenerManager<ServerThreadChannelChangeInvitableListener> addServerThreadChannelChangeInvitableListener(
ServerThreadChannelChangeInvitableListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelChangeInvitableListener'");
}
@Override
public List<ServerThreadChannelChangeInvitableListener> getServerThreadChannelChangeInvitableListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelChangeInvitableListeners'");
}
@Override
public ListenerManager<ServerThreadChannelChangeAutoArchiveDurationListener> addServerThreadChannelChangeAutoArchiveDurationListener(
ServerThreadChannelChangeAutoArchiveDurationListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelChangeAutoArchiveDurationListener'");
}
@Override
public List<ServerThreadChannelChangeAutoArchiveDurationListener> getServerThreadChannelChangeAutoArchiveDurationListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelChangeAutoArchiveDurationListeners'");
}
@Override
public ListenerManager<ServerThreadChannelChangeRateLimitPerUserListener> addServerThreadChannelChangeRateLimitPerUserListener(
ServerThreadChannelChangeRateLimitPerUserListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelChangeRateLimitPerUserListener'");
}
@Override
public List<ServerThreadChannelChangeRateLimitPerUserListener> getServerThreadChannelChangeRateLimitPerUserListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelChangeRateLimitPerUserListeners'");
}
@Override
public ListenerManager<ServerThreadChannelChangeLockedListener> addServerThreadChannelChangeLockedListener(
ServerThreadChannelChangeLockedListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelChangeLockedListener'");
}
@Override
public List<ServerThreadChannelChangeLockedListener> getServerThreadChannelChangeLockedListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelChangeLockedListeners'");
}
@Override
public ListenerManager<ServerThreadChannelChangeArchiveTimestampListener> addServerThreadChannelChangeArchiveTimestampListener(
ServerThreadChannelChangeArchiveTimestampListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelChangeArchiveTimestampListener'");
}
@Override
public List<ServerThreadChannelChangeArchiveTimestampListener> getServerThreadChannelChangeArchiveTimestampListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelChangeArchiveTimestampListeners'");
}
@Override
public ListenerManager<ServerThreadChannelChangeTotalMessageSentListener> addServerThreadChannelChangeTotalMessageSentListener(
ServerThreadChannelChangeTotalMessageSentListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelChangeTotalMessageSentListener'");
}
@Override
public List<ServerThreadChannelChangeTotalMessageSentListener> getServerThreadChannelChangeTotalMessageSentListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelChangeTotalMessageSentListeners'");
}
@Override
public ListenerManager<ServerThreadChannelChangeMessageCountListener> addServerThreadChannelChangeMessageCountListener(
ServerThreadChannelChangeMessageCountListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelChangeMessageCountListener'");
}
@Override
public List<ServerThreadChannelChangeMessageCountListener> getServerThreadChannelChangeMessageCountListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelChangeMessageCountListeners'");
}
@Override
public ListenerManager<ServerThreadChannelUpdateListener> addServerThreadChannelUpdateListener(
ServerThreadChannelUpdateListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelUpdateListener'");
}
@Override
public List<ServerThreadChannelUpdateListener> getServerThreadChannelUpdateListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelUpdateListeners'");
}
@Override
public ListenerManager<ServerThreadChannelMembersUpdateListener> addServerThreadChannelMembersUpdateListener(
ServerThreadChannelMembersUpdateListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelMembersUpdateListener'");
}
@Override
public List<ServerThreadChannelMembersUpdateListener> getServerThreadChannelMembersUpdateListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelMembersUpdateListeners'");
}
@Override
public ListenerManager<ServerThreadChannelCreateListener> addServerThreadChannelCreateListener(
ServerThreadChannelCreateListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelCreateListener'");
}
@Override
public List<ServerThreadChannelCreateListener> getServerThreadChannelCreateListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelCreateListeners'");
}
@Override
public ListenerManager<ServerThreadChannelDeleteListener> addServerThreadChannelDeleteListener(
ServerThreadChannelDeleteListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelDeleteListener'");
}
@Override
public List<ServerThreadChannelDeleteListener> getServerThreadChannelDeleteListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelDeleteListeners'");
}
@Override
public <T extends ServerThreadChannelAttachableListener & ObjectAttachableListener> Collection<ListenerManager<T>> addServerThreadChannelAttachableListener(
T listener) {
throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelAttachableListener'");
}
@Override
public <T extends ServerThreadChannelAttachableListener & ObjectAttachableListener> void removeServerThreadChannelAttachableListener(
T listener) {
throw new UnsupportedOperationException("Unimplemented method 'removeServerThreadChannelAttachableListener'");
}
@Override
public <T extends ServerThreadChannelAttachableListener & ObjectAttachableListener> Map<T, List<Class<T>>> getServerThreadChannelAttachableListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelAttachableListeners'");
}
@Override
public <T extends ServerThreadChannelAttachableListener & ObjectAttachableListener> void removeListener(
Class<T> listenerClass, T listener) {
throw new UnsupportedOperationException("Unimplemented method 'removeListener'");
}
@Override
public CompletableFuture<Void> type() {
throw new UnsupportedOperationException("Unimplemented method 'type'");
}
@Override
public CompletableFuture<Void> bulkDelete(long... messageIds) {
throw new UnsupportedOperationException("Unimplemented method 'bulkDelete'");
}
@Override
public CompletableFuture<Message> getMessageById(long id) {
throw new UnsupportedOperationException("Unimplemented method 'getMessageById'");
}
@Override
public CompletableFuture<MessageSet> getPins() {
throw new UnsupportedOperationException("Unimplemented method 'getPins'");
}
@Override
public CompletableFuture<MessageSet> getMessages(int limit) {
throw new UnsupportedOperationException("Unimplemented method 'getMessages'");
}
@Override
public CompletableFuture<MessageSet> getMessagesUntil(Predicate<Message> condition) {
throw new UnsupportedOperationException("Unimplemented method 'getMessagesUntil'");
}
@Override
public CompletableFuture<MessageSet> getMessagesWhile(Predicate<Message> condition) {
throw new UnsupportedOperationException("Unimplemented method 'getMessagesWhile'");
}
@Override
public Stream<Message> getMessagesAsStream() {
throw new UnsupportedOperationException("Unimplemented method 'getMessagesAsStream'");
}
@Override
public CompletableFuture<MessageSet> getMessagesBefore(int limit, long before) {
throw new UnsupportedOperationException("Unimplemented method 'getMessagesBefore'");
}
@Override
public CompletableFuture<MessageSet> getMessagesBeforeUntil(Predicate<Message> condition, long before) {
throw new UnsupportedOperationException("Unimplemented method 'getMessagesBeforeUntil'");
}
@Override
public CompletableFuture<MessageSet> getMessagesBeforeWhile(Predicate<Message> condition, long before) {
throw new UnsupportedOperationException("Unimplemented method 'getMessagesBeforeWhile'");
}
@Override
public Stream<Message> getMessagesBeforeAsStream(long before) {
throw new UnsupportedOperationException("Unimplemented method 'getMessagesBeforeAsStream'");
}
@Override
public CompletableFuture<MessageSet> getMessagesAfter(int limit, long after) {
throw new UnsupportedOperationException("Unimplemented method 'getMessagesAfter'");
}
@Override
public CompletableFuture<MessageSet> getMessagesAfterUntil(Predicate<Message> condition, long after) {
throw new UnsupportedOperationException("Unimplemented method 'getMessagesAfterUntil'");
}
@Override
public CompletableFuture<MessageSet> getMessagesAfterWhile(Predicate<Message> condition, long after) {
throw new UnsupportedOperationException("Unimplemented method 'getMessagesAfterWhile'");
}
@Override
public Stream<Message> getMessagesAfterAsStream(long after) {
throw new UnsupportedOperationException("Unimplemented method 'getMessagesAfterAsStream'");
}
@Override
public CompletableFuture<MessageSet> getMessagesAround(int limit, long around) {
throw new UnsupportedOperationException("Unimplemented method 'getMessagesAround'");
}
@Override
public CompletableFuture<MessageSet> getMessagesAroundUntil(Predicate<Message> condition, long around) {
throw new UnsupportedOperationException("Unimplemented method 'getMessagesAroundUntil'");
}
@Override
public CompletableFuture<MessageSet> getMessagesAroundWhile(Predicate<Message> condition, long around) {
throw new UnsupportedOperationException("Unimplemented method 'getMessagesAroundWhile'");
}
@Override
public Stream<Message> getMessagesAroundAsStream(long around) {
throw new UnsupportedOperationException("Unimplemented method 'getMessagesAroundAsStream'");
}
@Override
public CompletableFuture<MessageSet> getMessagesBetween(long from, long to) {
throw new UnsupportedOperationException("Unimplemented method 'getMessagesBetween'");
}
@Override
public CompletableFuture<MessageSet> getMessagesBetweenUntil(Predicate<Message> condition, long from, long to) {
throw new UnsupportedOperationException("Unimplemented method 'getMessagesBetweenUntil'");
}
@Override
public CompletableFuture<MessageSet> getMessagesBetweenWhile(Predicate<Message> condition, long from, long to) {
throw new UnsupportedOperationException("Unimplemented method 'getMessagesBetweenWhile'");
}
@Override
public Stream<Message> getMessagesBetweenAsStream(long from, long to) {
throw new UnsupportedOperationException("Unimplemented method 'getMessagesBetweenAsStream'");
}
@Override
public MessageCache getMessageCache() {
throw new UnsupportedOperationException("Unimplemented method 'getMessageCache'");
}
@Override
public CompletableFuture<List<Webhook>> getWebhooks() {
throw new UnsupportedOperationException("Unimplemented method 'getWebhooks'");
}
@Override
public CompletableFuture<List<Webhook>> getAllIncomingWebhooks() {
throw new UnsupportedOperationException("Unimplemented method 'getAllIncomingWebhooks'");
}
@Override
public CompletableFuture<List<IncomingWebhook>> getIncomingWebhooks() {
throw new UnsupportedOperationException("Unimplemented method 'getIncomingWebhooks'");
}
@Override
public boolean canWrite(User user) {
throw new UnsupportedOperationException("Unimplemented method 'canWrite'");
}
@Override
public boolean canUseExternalEmojis(User user) {
throw new UnsupportedOperationException("Unimplemented method 'canUseExternalEmojis'");
}
@Override
public boolean canEmbedLinks(User user) {
throw new UnsupportedOperationException("Unimplemented method 'canEmbedLinks'");
}
@Override
public boolean canReadMessageHistory(User user) {
throw new UnsupportedOperationException("Unimplemented method 'canReadMessageHistory'");
}
@Override
public boolean canUseTts(User user) {
throw new UnsupportedOperationException("Unimplemented method 'canUseTts'");
}
@Override
public boolean canAttachFiles(User user) {
throw new UnsupportedOperationException("Unimplemented method 'canAttachFiles'");
}
@Override
public boolean canAddNewReactions(User user) {
throw new UnsupportedOperationException("Unimplemented method 'canAddNewReactions'");
}
@Override
public boolean canManageMessages(User user) {
throw new UnsupportedOperationException("Unimplemented method 'canManageMessages'");
}
@Override
public boolean canMentionEveryone(User user) {
throw new UnsupportedOperationException("Unimplemented method 'canMentionEveryone'");
}
}

@ -0,0 +1,605 @@
package net.tomatentum.marinara.test.mocks;
import java.time.Duration;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.function.Function;
import org.javacord.api.DiscordApi;
import org.javacord.api.entity.ApplicationInfo;
import org.javacord.api.entity.activity.Activity;
import org.javacord.api.entity.activity.ActivityType;
import org.javacord.api.entity.channel.Channel;
import org.javacord.api.entity.channel.ChannelCategory;
import org.javacord.api.entity.channel.PrivateChannel;
import org.javacord.api.entity.channel.RegularServerChannel;
import org.javacord.api.entity.channel.ServerChannel;
import org.javacord.api.entity.channel.ServerForumChannel;
import org.javacord.api.entity.channel.ServerStageVoiceChannel;
import org.javacord.api.entity.channel.ServerTextChannel;
import org.javacord.api.entity.channel.ServerThreadChannel;
import org.javacord.api.entity.channel.ServerVoiceChannel;
import org.javacord.api.entity.channel.TextChannel;
import org.javacord.api.entity.channel.VoiceChannel;
import org.javacord.api.entity.emoji.CustomEmoji;
import org.javacord.api.entity.emoji.KnownCustomEmoji;
import org.javacord.api.entity.intent.Intent;
import org.javacord.api.entity.message.Message;
import org.javacord.api.entity.message.MessageSet;
import org.javacord.api.entity.message.UncachedMessageUtil;
import org.javacord.api.entity.server.Server;
import org.javacord.api.entity.server.invite.Invite;
import org.javacord.api.entity.sticker.Sticker;
import org.javacord.api.entity.sticker.StickerPack;
import org.javacord.api.entity.user.User;
import org.javacord.api.entity.user.UserStatus;
import org.javacord.api.entity.webhook.IncomingWebhook;
import org.javacord.api.entity.webhook.Webhook;
import org.javacord.api.interaction.ApplicationCommand;
import org.javacord.api.interaction.ApplicationCommandBuilder;
import org.javacord.api.interaction.MessageContextMenu;
import org.javacord.api.interaction.ServerApplicationCommandPermissions;
import org.javacord.api.interaction.SlashCommand;
import org.javacord.api.interaction.UserContextMenu;
import org.javacord.api.listener.GloballyAttachableListener;
import org.javacord.api.util.concurrent.ThreadPool;
import org.javacord.api.util.event.ListenerManager;
import org.javacord.api.util.ratelimit.Ratelimiter;
public class DiscordApiMock implements DiscordApi{
@Override
public <T extends GloballyAttachableListener> ListenerManager<T> addListener(Class<T> listenerClass, T listener) {
return null;
}
@Override
public Collection<ListenerManager<? extends GloballyAttachableListener>> addListener(
GloballyAttachableListener listener) {
return null;
}
@Override
public void removeListener(GloballyAttachableListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'removeListener'");
}
@Override
public <T extends GloballyAttachableListener> void removeListener(Class<T> listenerClass, T listener) {
throw new UnsupportedOperationException("Unimplemented method 'removeListener'");
}
@Override
public <T extends GloballyAttachableListener> Map<T, List<Class<T>>> getListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getListeners'");
}
@Override
public <T extends GloballyAttachableListener> List<T> getListeners(Class<T> listenerClass) {
throw new UnsupportedOperationException("Unimplemented method 'getListeners'");
}
@Override
public String getToken() {
throw new UnsupportedOperationException("Unimplemented method 'getToken'");
}
@Override
public String getPrefixedToken() {
throw new UnsupportedOperationException("Unimplemented method 'getPrefixedToken'");
}
@Override
public Set<Intent> getIntents() {
throw new UnsupportedOperationException("Unimplemented method 'getIntents'");
}
@Override
public ThreadPool getThreadPool() {
throw new UnsupportedOperationException("Unimplemented method 'getThreadPool'");
}
@Override
public void setEventsDispatchable(boolean dispatchEvents) {
throw new UnsupportedOperationException("Unimplemented method 'setEventsDispatchable'");
}
@Override
public boolean canDispatchEvents() {
throw new UnsupportedOperationException("Unimplemented method 'canDispatchEvents'");
}
@Override
public CompletableFuture<Set<ApplicationCommand>> getGlobalApplicationCommands() {
throw new UnsupportedOperationException("Unimplemented method 'getGlobalApplicationCommands'");
}
@Override
public CompletableFuture<ApplicationCommand> getGlobalApplicationCommandById(long applicationCommandId) {
throw new UnsupportedOperationException("Unimplemented method 'getGlobalApplicationCommandById'");
}
@Override
public CompletableFuture<Set<ApplicationCommand>> getServerApplicationCommands(Server server) {
throw new UnsupportedOperationException("Unimplemented method 'getServerApplicationCommands'");
}
@Override
public CompletableFuture<ApplicationCommand> getServerApplicationCommandById(Server server,
long applicationCommandId) {
throw new UnsupportedOperationException("Unimplemented method 'getServerApplicationCommandById'");
}
@Override
public CompletableFuture<Set<SlashCommand>> getGlobalSlashCommands() {
throw new UnsupportedOperationException("Unimplemented method 'getGlobalSlashCommands'");
}
@Override
public CompletableFuture<SlashCommand> getGlobalSlashCommandById(long commandId) {
throw new UnsupportedOperationException("Unimplemented method 'getGlobalSlashCommandById'");
}
@Override
public CompletableFuture<Set<SlashCommand>> getServerSlashCommands(Server server) {
throw new UnsupportedOperationException("Unimplemented method 'getServerSlashCommands'");
}
@Override
public CompletableFuture<SlashCommand> getServerSlashCommandById(Server server, long commandId) {
throw new UnsupportedOperationException("Unimplemented method 'getServerSlashCommandById'");
}
@Override
public CompletableFuture<Set<UserContextMenu>> getGlobalUserContextMenus() {
throw new UnsupportedOperationException("Unimplemented method 'getGlobalUserContextMenus'");
}
@Override
public CompletableFuture<UserContextMenu> getGlobalUserContextMenuById(long commandId) {
throw new UnsupportedOperationException("Unimplemented method 'getGlobalUserContextMenuById'");
}
@Override
public CompletableFuture<Set<UserContextMenu>> getServerUserContextMenus(Server server) {
throw new UnsupportedOperationException("Unimplemented method 'getServerUserContextMenus'");
}
@Override
public CompletableFuture<UserContextMenu> getServerUserContextMenuById(Server server, long commandId) {
throw new UnsupportedOperationException("Unimplemented method 'getServerUserContextMenuById'");
}
@Override
public CompletableFuture<Set<MessageContextMenu>> getGlobalMessageContextMenus() {
throw new UnsupportedOperationException("Unimplemented method 'getGlobalMessageContextMenus'");
}
@Override
public CompletableFuture<MessageContextMenu> getGlobalMessageContextMenuById(long commandId) {
throw new UnsupportedOperationException("Unimplemented method 'getGlobalMessageContextMenuById'");
}
@Override
public CompletableFuture<Set<MessageContextMenu>> getServerMessageContextMenus(Server server) {
throw new UnsupportedOperationException("Unimplemented method 'getServerMessageContextMenus'");
}
@Override
public CompletableFuture<MessageContextMenu> getServerMessageContextMenuById(Server server, long commandId) {
throw new UnsupportedOperationException("Unimplemented method 'getServerMessageContextMenuById'");
}
@Override
public CompletableFuture<Set<ServerApplicationCommandPermissions>> getServerApplicationCommandPermissions(
Server server) {
throw new UnsupportedOperationException("Unimplemented method 'getServerApplicationCommandPermissions'");
}
@Override
public CompletableFuture<ServerApplicationCommandPermissions> getServerApplicationCommandPermissionsById(
Server server, long commandId) {
throw new UnsupportedOperationException("Unimplemented method 'getServerApplicationCommandPermissionsById'");
}
@Override
public CompletableFuture<Set<ApplicationCommand>> bulkOverwriteGlobalApplicationCommands(
Set<? extends ApplicationCommandBuilder<?, ?, ?>> applicationCommandBuilderList) {
throw new UnsupportedOperationException("Unimplemented method 'bulkOverwriteGlobalApplicationCommands'");
}
@Override
public CompletableFuture<Set<ApplicationCommand>> bulkOverwriteServerApplicationCommands(long server,
Set<? extends ApplicationCommandBuilder<?, ?, ?>> applicationCommandBuilderList) {
throw new UnsupportedOperationException("Unimplemented method 'bulkOverwriteServerApplicationCommands'");
}
@Override
public UncachedMessageUtil getUncachedMessageUtil() {
throw new UnsupportedOperationException("Unimplemented method 'getUncachedMessageUtil'");
}
@Override
public Optional<Ratelimiter> getGlobalRatelimiter() {
throw new UnsupportedOperationException("Unimplemented method 'getGlobalRatelimiter'");
}
@Override
public Ratelimiter getGatewayIdentifyRatelimiter() {
throw new UnsupportedOperationException("Unimplemented method 'getGatewayIdentifyRatelimiter'");
}
@Override
public Duration getLatestGatewayLatency() {
throw new UnsupportedOperationException("Unimplemented method 'getLatestGatewayLatency'");
}
@Override
public CompletableFuture<Duration> measureRestLatency() {
throw new UnsupportedOperationException("Unimplemented method 'measureRestLatency'");
}
@Override
public void setMessageCacheSize(int capacity, int storageTimeInSeconds) {
throw new UnsupportedOperationException("Unimplemented method 'setMessageCacheSize'");
}
@Override
public int getDefaultMessageCacheCapacity() {
throw new UnsupportedOperationException("Unimplemented method 'getDefaultMessageCacheCapacity'");
}
@Override
public int getDefaultMessageCacheStorageTimeInSeconds() {
throw new UnsupportedOperationException("Unimplemented method 'getDefaultMessageCacheStorageTimeInSeconds'");
}
@Override
public void setAutomaticMessageCacheCleanupEnabled(boolean automaticMessageCacheCleanupEnabled) {
throw new UnsupportedOperationException("Unimplemented method 'setAutomaticMessageCacheCleanupEnabled'");
}
@Override
public boolean isDefaultAutomaticMessageCacheCleanupEnabled() {
throw new UnsupportedOperationException("Unimplemented method 'isDefaultAutomaticMessageCacheCleanupEnabled'");
}
@Override
public int getCurrentShard() {
throw new UnsupportedOperationException("Unimplemented method 'getCurrentShard'");
}
@Override
public int getTotalShards() {
throw new UnsupportedOperationException("Unimplemented method 'getTotalShards'");
}
@Override
public boolean isWaitingForServersOnStartup() {
throw new UnsupportedOperationException("Unimplemented method 'isWaitingForServersOnStartup'");
}
@Override
public boolean isWaitingForUsersOnStartup() {
throw new UnsupportedOperationException("Unimplemented method 'isWaitingForUsersOnStartup'");
}
@Override
public void updateStatus(UserStatus status) {
throw new UnsupportedOperationException("Unimplemented method 'updateStatus'");
}
@Override
public UserStatus getStatus() {
throw new UnsupportedOperationException("Unimplemented method 'getStatus'");
}
@Override
public void updateActivity(String name) {
throw new UnsupportedOperationException("Unimplemented method 'updateActivity'");
}
@Override
public void updateActivity(ActivityType type, String name) {
throw new UnsupportedOperationException("Unimplemented method 'updateActivity'");
}
@Override
public void updateActivity(String name, String streamingUrl) {
throw new UnsupportedOperationException("Unimplemented method 'updateActivity'");
}
@Override
public void unsetActivity() {
throw new UnsupportedOperationException("Unimplemented method 'unsetActivity'");
}
@Override
public Optional<Activity> getActivity() {
throw new UnsupportedOperationException("Unimplemented method 'getActivity'");
}
@Override
public User getYourself() {
throw new UnsupportedOperationException("Unimplemented method 'getYourself'");
}
@Override
public CompletableFuture<Void> disconnect() {
throw new UnsupportedOperationException("Unimplemented method 'disconnect'");
}
@Override
public void setReconnectDelay(Function<Integer, Integer> reconnectDelayProvider) {
throw new UnsupportedOperationException("Unimplemented method 'setReconnectDelay'");
}
@Override
public int getReconnectDelay(int attempt) {
throw new UnsupportedOperationException("Unimplemented method 'getReconnectDelay'");
}
@Override
public ApplicationInfo getCachedApplicationInfo() {
throw new UnsupportedOperationException("Unimplemented method 'getCachedApplicationInfo'");
}
@Override
public CompletableFuture<ApplicationInfo> requestApplicationInfo() {
throw new UnsupportedOperationException("Unimplemented method 'requestApplicationInfo'");
}
@Override
public CompletableFuture<Webhook> getWebhookById(long id) {
throw new UnsupportedOperationException("Unimplemented method 'getWebhookById'");
}
@Override
public CompletableFuture<IncomingWebhook> getIncomingWebhookByIdAndToken(String id, String token) {
throw new UnsupportedOperationException("Unimplemented method 'getIncomingWebhookByIdAndToken'");
}
@Override
public Set<Long> getUnavailableServers() {
throw new UnsupportedOperationException("Unimplemented method 'getUnavailableServers'");
}
@Override
public CompletableFuture<Invite> getInviteByCode(String code) {
throw new UnsupportedOperationException("Unimplemented method 'getInviteByCode'");
}
@Override
public CompletableFuture<Invite> getInviteWithMemberCountsByCode(String code) {
throw new UnsupportedOperationException("Unimplemented method 'getInviteWithMemberCountsByCode'");
}
@Override
public boolean isUserCacheEnabled() {
throw new UnsupportedOperationException("Unimplemented method 'isUserCacheEnabled'");
}
@Override
public Set<User> getCachedUsers() {
throw new UnsupportedOperationException("Unimplemented method 'getCachedUsers'");
}
@Override
public Optional<User> getCachedUserById(long id) {
throw new UnsupportedOperationException("Unimplemented method 'getCachedUserById'");
}
@Override
public CompletableFuture<User> getUserById(long id) {
throw new UnsupportedOperationException("Unimplemented method 'getUserById'");
}
@Override
public MessageSet getCachedMessages() {
throw new UnsupportedOperationException("Unimplemented method 'getCachedMessages'");
}
@Override
public Optional<Message> getCachedMessageById(long id) {
throw new UnsupportedOperationException("Unimplemented method 'getCachedMessageById'");
}
@Override
public Set<Server> getServers() {
throw new UnsupportedOperationException("Unimplemented method 'getServers'");
}
@Override
public Set<KnownCustomEmoji> getCustomEmojis() {
throw new UnsupportedOperationException("Unimplemented method 'getCustomEmojis'");
}
@Override
public CustomEmoji getKnownCustomEmojiOrCreateCustomEmoji(long id, String name, boolean animated) {
throw new UnsupportedOperationException("Unimplemented method 'getKnownCustomEmojiOrCreateCustomEmoji'");
}
@Override
public CompletableFuture<Set<StickerPack>> getNitroStickerPacks() {
throw new UnsupportedOperationException("Unimplemented method 'getNitroStickerPacks'");
}
@Override
public Optional<Sticker> getStickerById(long id) {
throw new UnsupportedOperationException("Unimplemented method 'getStickerById'");
}
@Override
public CompletableFuture<Sticker> requestStickerById(long id) {
throw new UnsupportedOperationException("Unimplemented method 'requestStickerById'");
}
@Override
public Set<Channel> getChannels() {
throw new UnsupportedOperationException("Unimplemented method 'getChannels'");
}
@Override
public Set<PrivateChannel> getPrivateChannels() {
throw new UnsupportedOperationException("Unimplemented method 'getPrivateChannels'");
}
@Override
public Set<ServerChannel> getServerChannels() {
throw new UnsupportedOperationException("Unimplemented method 'getServerChannels'");
}
@Override
public Set<RegularServerChannel> getRegularServerChannels() {
throw new UnsupportedOperationException("Unimplemented method 'getRegularServerChannels'");
}
@Override
public Set<ChannelCategory> getChannelCategories() {
throw new UnsupportedOperationException("Unimplemented method 'getChannelCategories'");
}
@Override
public Set<ServerTextChannel> getServerTextChannels() {
throw new UnsupportedOperationException("Unimplemented method 'getServerTextChannels'");
}
@Override
public Set<ServerForumChannel> getServerForumChannels() {
throw new UnsupportedOperationException("Unimplemented method 'getServerForumChannels'");
}
@Override
public Set<ServerThreadChannel> getServerThreadChannels() {
throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannels'");
}
@Override
public Set<ServerThreadChannel> getPrivateServerThreadChannels() {
throw new UnsupportedOperationException("Unimplemented method 'getPrivateServerThreadChannels'");
}
@Override
public Set<ServerThreadChannel> getPublicServerThreadChannels() {
throw new UnsupportedOperationException("Unimplemented method 'getPublicServerThreadChannels'");
}
@Override
public Set<ServerVoiceChannel> getServerVoiceChannels() {
throw new UnsupportedOperationException("Unimplemented method 'getServerVoiceChannels'");
}
@Override
public Set<ServerStageVoiceChannel> getServerStageVoiceChannels() {
throw new UnsupportedOperationException("Unimplemented method 'getServerStageVoiceChannels'");
}
@Override
public Set<TextChannel> getTextChannels() {
throw new UnsupportedOperationException("Unimplemented method 'getTextChannels'");
}
@Override
public Set<VoiceChannel> getVoiceChannels() {
throw new UnsupportedOperationException("Unimplemented method 'getVoiceChannels'");
}
@Override
public Optional<Channel> getChannelById(long id) {
throw new UnsupportedOperationException("Unimplemented method 'getChannelById'");
}
}

@ -0,0 +1,443 @@
package net.tomatentum.marinara.test.mocks;
import java.time.Instant;
import java.util.Collection;
import java.util.EnumSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import org.javacord.api.DiscordApi;
import org.javacord.api.entity.channel.TextChannel;
import org.javacord.api.entity.emoji.CustomEmoji;
import org.javacord.api.entity.message.Message;
import org.javacord.api.entity.message.MessageActivity;
import org.javacord.api.entity.message.MessageAttachment;
import org.javacord.api.entity.message.MessageAuthor;
import org.javacord.api.entity.message.MessageFlag;
import org.javacord.api.entity.message.MessageReference;
import org.javacord.api.entity.message.MessageType;
import org.javacord.api.entity.message.Reaction;
import org.javacord.api.entity.message.component.HighLevelComponent;
import org.javacord.api.entity.message.embed.Embed;
import org.javacord.api.entity.permission.Role;
import org.javacord.api.entity.sticker.StickerItem;
import org.javacord.api.entity.user.User;
import org.javacord.api.interaction.MessageInteraction;
import org.javacord.api.listener.ObjectAttachableListener;
import org.javacord.api.listener.interaction.ButtonClickListener;
import org.javacord.api.listener.interaction.MessageComponentCreateListener;
import org.javacord.api.listener.interaction.MessageContextMenuCommandListener;
import org.javacord.api.listener.interaction.SelectMenuChooseListener;
import org.javacord.api.listener.message.CachedMessagePinListener;
import org.javacord.api.listener.message.CachedMessageUnpinListener;
import org.javacord.api.listener.message.MessageAttachableListener;
import org.javacord.api.listener.message.MessageDeleteListener;
import org.javacord.api.listener.message.MessageEditListener;
import org.javacord.api.listener.message.MessageReplyListener;
import org.javacord.api.listener.message.reaction.ReactionAddListener;
import org.javacord.api.listener.message.reaction.ReactionRemoveAllListener;
import org.javacord.api.listener.message.reaction.ReactionRemoveListener;
import org.javacord.api.util.event.ListenerManager;
public class MessageMock implements Message{
@Override
public DiscordApi getApi() {
throw new UnsupportedOperationException("Unimplemented method 'getApi'");
}
@Override
public long getId() {
throw new UnsupportedOperationException("Unimplemented method 'getId'");
}
@Override
public int compareTo(Message arg0) {
throw new UnsupportedOperationException("Unimplemented method 'compareTo'");
}
@Override
public ListenerManager<MessageContextMenuCommandListener> addMessageContextMenuCommandListener(
MessageContextMenuCommandListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addMessageContextMenuCommandListener'");
}
@Override
public List<MessageContextMenuCommandListener> getMessageContextMenuCommandListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getMessageContextMenuCommandListeners'");
}
@Override
public ListenerManager<MessageComponentCreateListener> addMessageComponentCreateListener(
MessageComponentCreateListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addMessageComponentCreateListener'");
}
@Override
public List<MessageComponentCreateListener> getMessageComponentCreateListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getMessageComponentCreateListeners'");
}
@Override
public ListenerManager<SelectMenuChooseListener> addSelectMenuChooseListener(SelectMenuChooseListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addSelectMenuChooseListener'");
}
@Override
public List<SelectMenuChooseListener> getSelectMenuChooseListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getSelectMenuChooseListeners'");
}
@Override
public ListenerManager<ButtonClickListener> addButtonClickListener(ButtonClickListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addButtonClickListener'");
}
@Override
public List<ButtonClickListener> getButtonClickListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getButtonClickListeners'");
}
@Override
public ListenerManager<MessageEditListener> addMessageEditListener(MessageEditListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addMessageEditListener'");
}
@Override
public List<MessageEditListener> getMessageEditListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getMessageEditListeners'");
}
@Override
public ListenerManager<ReactionRemoveListener> addReactionRemoveListener(ReactionRemoveListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addReactionRemoveListener'");
}
@Override
public List<ReactionRemoveListener> getReactionRemoveListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getReactionRemoveListeners'");
}
@Override
public ListenerManager<ReactionAddListener> addReactionAddListener(ReactionAddListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addReactionAddListener'");
}
@Override
public List<ReactionAddListener> getReactionAddListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getReactionAddListeners'");
}
@Override
public ListenerManager<ReactionRemoveAllListener> addReactionRemoveAllListener(ReactionRemoveAllListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addReactionRemoveAllListener'");
}
@Override
public List<ReactionRemoveAllListener> getReactionRemoveAllListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getReactionRemoveAllListeners'");
}
@Override
public ListenerManager<CachedMessageUnpinListener> addCachedMessageUnpinListener(
CachedMessageUnpinListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addCachedMessageUnpinListener'");
}
@Override
public List<CachedMessageUnpinListener> getCachedMessageUnpinListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getCachedMessageUnpinListeners'");
}
@Override
public ListenerManager<CachedMessagePinListener> addCachedMessagePinListener(CachedMessagePinListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addCachedMessagePinListener'");
}
@Override
public List<CachedMessagePinListener> getCachedMessagePinListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getCachedMessagePinListeners'");
}
@Override
public ListenerManager<MessageReplyListener> addMessageReplyListener(MessageReplyListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addMessageReplyListener'");
}
@Override
public List<MessageReplyListener> getMessageReplyListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getMessageReplyListeners'");
}
@Override
public ListenerManager<MessageDeleteListener> addMessageDeleteListener(MessageDeleteListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addMessageDeleteListener'");
}
@Override
public List<MessageDeleteListener> getMessageDeleteListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getMessageDeleteListeners'");
}
@Override
public <T extends MessageAttachableListener & ObjectAttachableListener> Collection<ListenerManager<T>> addMessageAttachableListener(
T listener) {
throw new UnsupportedOperationException("Unimplemented method 'addMessageAttachableListener'");
}
@Override
public <T extends MessageAttachableListener & ObjectAttachableListener> void removeMessageAttachableListener(
T listener) {
throw new UnsupportedOperationException("Unimplemented method 'removeMessageAttachableListener'");
}
@Override
public <T extends MessageAttachableListener & ObjectAttachableListener> Map<T, List<Class<T>>> getMessageAttachableListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getMessageAttachableListeners'");
}
@Override
public <T extends MessageAttachableListener & ObjectAttachableListener> void removeListener(Class<T> listenerClass,
T listener) {
throw new UnsupportedOperationException("Unimplemented method 'removeListener'");
}
@Override
public boolean canYouReadContent() {
throw new UnsupportedOperationException("Unimplemented method 'canYouReadContent'");
}
@Override
public String getContent() {
throw new UnsupportedOperationException("Unimplemented method 'getContent'");
}
@Override
public Optional<Instant> getLastEditTimestamp() {
throw new UnsupportedOperationException("Unimplemented method 'getLastEditTimestamp'");
}
@Override
public List<MessageAttachment> getAttachments() {
throw new UnsupportedOperationException("Unimplemented method 'getAttachments'");
}
@Override
public List<CustomEmoji> getCustomEmojis() {
throw new UnsupportedOperationException("Unimplemented method 'getCustomEmojis'");
}
@Override
public MessageType getType() {
throw new UnsupportedOperationException("Unimplemented method 'getType'");
}
@Override
public TextChannel getChannel() {
throw new UnsupportedOperationException("Unimplemented method 'getChannel'");
}
@Override
public Optional<MessageActivity> getActivity() {
throw new UnsupportedOperationException("Unimplemented method 'getActivity'");
}
@Override
public EnumSet<MessageFlag> getFlags() {
throw new UnsupportedOperationException("Unimplemented method 'getFlags'");
}
@Override
public boolean isPinned() {
throw new UnsupportedOperationException("Unimplemented method 'isPinned'");
}
@Override
public boolean isTts() {
throw new UnsupportedOperationException("Unimplemented method 'isTts'");
}
@Override
public boolean mentionsEveryone() {
throw new UnsupportedOperationException("Unimplemented method 'mentionsEveryone'");
}
@Override
public List<Embed> getEmbeds() {
throw new UnsupportedOperationException("Unimplemented method 'getEmbeds'");
}
@Override
public Optional<User> getUserAuthor() {
throw new UnsupportedOperationException("Unimplemented method 'getUserAuthor'");
}
@Override
public MessageAuthor getAuthor() {
throw new UnsupportedOperationException("Unimplemented method 'getAuthor'");
}
@Override
public Optional<MessageReference> getMessageReference() {
throw new UnsupportedOperationException("Unimplemented method 'getMessageReference'");
}
@Override
public Optional<Message> getReferencedMessage() {
throw new UnsupportedOperationException("Unimplemented method 'getReferencedMessage'");
}
@Override
public boolean isCachedForever() {
throw new UnsupportedOperationException("Unimplemented method 'isCachedForever'");
}
@Override
public void setCachedForever(boolean cachedForever) {
throw new UnsupportedOperationException("Unimplemented method 'setCachedForever'");
}
@Override
public List<Reaction> getReactions() {
throw new UnsupportedOperationException("Unimplemented method 'getReactions'");
}
@Override
public Optional<MessageInteraction> getMessageInteraction() {
throw new UnsupportedOperationException("Unimplemented method 'getMessageInteraction'");
}
@Override
public List<HighLevelComponent> getComponents() {
throw new UnsupportedOperationException("Unimplemented method 'getComponents'");
}
@Override
public List<User> getMentionedUsers() {
throw new UnsupportedOperationException("Unimplemented method 'getMentionedUsers'");
}
@Override
public List<Role> getMentionedRoles() {
throw new UnsupportedOperationException("Unimplemented method 'getMentionedRoles'");
}
@Override
public Optional<String> getNonce() {
throw new UnsupportedOperationException("Unimplemented method 'getNonce'");
}
@Override
public Set<StickerItem> getStickerItems() {
throw new UnsupportedOperationException("Unimplemented method 'getStickerItems'");
}
@Override
public Optional<Integer> getPosition() {
throw new UnsupportedOperationException("Unimplemented method 'getPosition'");
}
@Override
public CompletableFuture<Void> addReactions(String... unicodeEmojis) {
throw new UnsupportedOperationException("Unimplemented method 'addReactions'");
}
@Override
public CompletableFuture<Void> removeReactionByEmoji(User user, String unicodeEmoji) {
throw new UnsupportedOperationException("Unimplemented method 'removeReactionByEmoji'");
}
@Override
public CompletableFuture<Void> removeReactionByEmoji(String unicodeEmoji) {
throw new UnsupportedOperationException("Unimplemented method 'removeReactionByEmoji'");
}
@Override
public CompletableFuture<Void> removeReactionsByEmoji(User user, String... unicodeEmojis) {
throw new UnsupportedOperationException("Unimplemented method 'removeReactionsByEmoji'");
}
@Override
public CompletableFuture<Void> removeReactionsByEmoji(String... unicodeEmojis) {
throw new UnsupportedOperationException("Unimplemented method 'removeReactionsByEmoji'");
}
@Override
public CompletableFuture<Void> removeOwnReactionByEmoji(String unicodeEmoji) {
throw new UnsupportedOperationException("Unimplemented method 'removeOwnReactionByEmoji'");
}
@Override
public CompletableFuture<Void> removeOwnReactionsByEmoji(String... unicodeEmojis) {
throw new UnsupportedOperationException("Unimplemented method 'removeOwnReactionsByEmoji'");
}
}

File diff suppressed because it is too large Load Diff

@ -1,7 +1,6 @@
package net.tomatentum.marinara.test.mocks; package net.tomatentum.marinara.test.mocks;
import java.util.Arrays; import java.util.Arrays;
import java.util.Collections;
import java.util.EnumSet; import java.util.EnumSet;
import java.util.List; import java.util.List;
import java.util.Optional; import java.util.Optional;

@ -0,0 +1,752 @@
package net.tomatentum.marinara.test.mocks;
import java.awt.Color;
import java.time.Instant;
import java.util.Collection;
import java.util.EnumSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import org.javacord.api.DiscordApi;
import org.javacord.api.entity.DiscordClient;
import org.javacord.api.entity.Icon;
import org.javacord.api.entity.activity.Activity;
import org.javacord.api.entity.channel.PrivateChannel;
import org.javacord.api.entity.permission.Role;
import org.javacord.api.entity.server.Server;
import org.javacord.api.entity.user.User;
import org.javacord.api.entity.user.UserFlag;
import org.javacord.api.entity.user.UserStatus;
import org.javacord.api.listener.ObjectAttachableListener;
import org.javacord.api.listener.channel.server.ServerChannelChangeOverwrittenPermissionsListener;
import org.javacord.api.listener.channel.server.voice.ServerVoiceChannelMemberJoinListener;
import org.javacord.api.listener.channel.server.voice.ServerVoiceChannelMemberLeaveListener;
import org.javacord.api.listener.channel.user.PrivateChannelCreateListener;
import org.javacord.api.listener.channel.user.PrivateChannelDeleteListener;
import org.javacord.api.listener.interaction.AutocompleteCreateListener;
import org.javacord.api.listener.interaction.ButtonClickListener;
import org.javacord.api.listener.interaction.InteractionCreateListener;
import org.javacord.api.listener.interaction.MessageComponentCreateListener;
import org.javacord.api.listener.interaction.MessageContextMenuCommandListener;
import org.javacord.api.listener.interaction.ModalSubmitListener;
import org.javacord.api.listener.interaction.SelectMenuChooseListener;
import org.javacord.api.listener.interaction.SlashCommandCreateListener;
import org.javacord.api.listener.interaction.UserContextMenuCommandListener;
import org.javacord.api.listener.message.MessageCreateListener;
import org.javacord.api.listener.message.MessageReplyListener;
import org.javacord.api.listener.message.reaction.ReactionAddListener;
import org.javacord.api.listener.message.reaction.ReactionRemoveListener;
import org.javacord.api.listener.server.member.ServerMemberBanListener;
import org.javacord.api.listener.server.member.ServerMemberJoinListener;
import org.javacord.api.listener.server.member.ServerMemberLeaveListener;
import org.javacord.api.listener.server.member.ServerMemberUnbanListener;
import org.javacord.api.listener.server.role.UserRoleAddListener;
import org.javacord.api.listener.server.role.UserRoleRemoveListener;
import org.javacord.api.listener.user.UserAttachableListener;
import org.javacord.api.listener.user.UserChangeActivityListener;
import org.javacord.api.listener.user.UserChangeAvatarListener;
import org.javacord.api.listener.user.UserChangeDeafenedListener;
import org.javacord.api.listener.user.UserChangeDiscriminatorListener;
import org.javacord.api.listener.user.UserChangeMutedListener;
import org.javacord.api.listener.user.UserChangeNameListener;
import org.javacord.api.listener.user.UserChangeNicknameListener;
import org.javacord.api.listener.user.UserChangePendingListener;
import org.javacord.api.listener.user.UserChangeSelfDeafenedListener;
import org.javacord.api.listener.user.UserChangeSelfMutedListener;
import org.javacord.api.listener.user.UserChangeServerAvatarListener;
import org.javacord.api.listener.user.UserChangeStatusListener;
import org.javacord.api.listener.user.UserChangeTimeoutListener;
import org.javacord.api.listener.user.UserStartTypingListener;
import org.javacord.api.util.event.ListenerManager;
public class UserMock implements User {
@Override
public DiscordApi getApi() {
throw new UnsupportedOperationException("Unimplemented method 'getApi'");
}
@Override
public long getId() {
throw new UnsupportedOperationException("Unimplemented method 'getId'");
}
@Override
public String getName() {
throw new UnsupportedOperationException("Unimplemented method 'getName'");
}
@Override
public ListenerManager<InteractionCreateListener> addInteractionCreateListener(InteractionCreateListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addInteractionCreateListener'");
}
@Override
public List<InteractionCreateListener> getInteractionCreateListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getInteractionCreateListeners'");
}
@Override
public ListenerManager<SlashCommandCreateListener> addSlashCommandCreateListener(
SlashCommandCreateListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addSlashCommandCreateListener'");
}
@Override
public List<SlashCommandCreateListener> getSlashCommandCreateListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getSlashCommandCreateListeners'");
}
@Override
public ListenerManager<AutocompleteCreateListener> addAutocompleteCreateListener(
AutocompleteCreateListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addAutocompleteCreateListener'");
}
@Override
public List<AutocompleteCreateListener> getAutocompleteCreateListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getAutocompleteCreateListeners'");
}
@Override
public ListenerManager<ModalSubmitListener> addModalSubmitListener(ModalSubmitListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addModalSubmitListener'");
}
@Override
public List<ModalSubmitListener> getModalSubmitListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getModalSubmitListeners'");
}
@Override
public ListenerManager<MessageContextMenuCommandListener> addMessageContextMenuCommandListener(
MessageContextMenuCommandListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addMessageContextMenuCommandListener'");
}
@Override
public List<MessageContextMenuCommandListener> getMessageContextMenuCommandListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getMessageContextMenuCommandListeners'");
}
@Override
public ListenerManager<MessageComponentCreateListener> addMessageComponentCreateListener(
MessageComponentCreateListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addMessageComponentCreateListener'");
}
@Override
public List<MessageComponentCreateListener> getMessageComponentCreateListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getMessageComponentCreateListeners'");
}
@Override
public ListenerManager<UserContextMenuCommandListener> addUserContextMenuCommandListener(
UserContextMenuCommandListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addUserContextMenuCommandListener'");
}
@Override
public List<UserContextMenuCommandListener> getUserContextMenuCommandListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getUserContextMenuCommandListeners'");
}
@Override
public ListenerManager<SelectMenuChooseListener> addSelectMenuChooseListener(SelectMenuChooseListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addSelectMenuChooseListener'");
}
@Override
public List<SelectMenuChooseListener> getSelectMenuChooseListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getSelectMenuChooseListeners'");
}
@Override
public ListenerManager<ButtonClickListener> addButtonClickListener(ButtonClickListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addButtonClickListener'");
}
@Override
public List<ButtonClickListener> getButtonClickListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getButtonClickListeners'");
}
@Override
public ListenerManager<ServerMemberJoinListener> addServerMemberJoinListener(ServerMemberJoinListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addServerMemberJoinListener'");
}
@Override
public List<ServerMemberJoinListener> getServerMemberJoinListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getServerMemberJoinListeners'");
}
@Override
public ListenerManager<ServerMemberLeaveListener> addServerMemberLeaveListener(ServerMemberLeaveListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addServerMemberLeaveListener'");
}
@Override
public List<ServerMemberLeaveListener> getServerMemberLeaveListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getServerMemberLeaveListeners'");
}
@Override
public ListenerManager<ServerMemberBanListener> addServerMemberBanListener(ServerMemberBanListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addServerMemberBanListener'");
}
@Override
public List<ServerMemberBanListener> getServerMemberBanListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getServerMemberBanListeners'");
}
@Override
public ListenerManager<ServerMemberUnbanListener> addServerMemberUnbanListener(ServerMemberUnbanListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addServerMemberUnbanListener'");
}
@Override
public List<ServerMemberUnbanListener> getServerMemberUnbanListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getServerMemberUnbanListeners'");
}
@Override
public ListenerManager<UserRoleRemoveListener> addUserRoleRemoveListener(UserRoleRemoveListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addUserRoleRemoveListener'");
}
@Override
public List<UserRoleRemoveListener> getUserRoleRemoveListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getUserRoleRemoveListeners'");
}
@Override
public ListenerManager<UserRoleAddListener> addUserRoleAddListener(UserRoleAddListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addUserRoleAddListener'");
}
@Override
public List<UserRoleAddListener> getUserRoleAddListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getUserRoleAddListeners'");
}
@Override
public ListenerManager<ServerChannelChangeOverwrittenPermissionsListener> addServerChannelChangeOverwrittenPermissionsListener(
ServerChannelChangeOverwrittenPermissionsListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addServerChannelChangeOverwrittenPermissionsListener'");
}
@Override
public List<ServerChannelChangeOverwrittenPermissionsListener> getServerChannelChangeOverwrittenPermissionsListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getServerChannelChangeOverwrittenPermissionsListeners'");
}
@Override
public ListenerManager<ServerVoiceChannelMemberLeaveListener> addServerVoiceChannelMemberLeaveListener(
ServerVoiceChannelMemberLeaveListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addServerVoiceChannelMemberLeaveListener'");
}
@Override
public List<ServerVoiceChannelMemberLeaveListener> getServerVoiceChannelMemberLeaveListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getServerVoiceChannelMemberLeaveListeners'");
}
@Override
public ListenerManager<ServerVoiceChannelMemberJoinListener> addServerVoiceChannelMemberJoinListener(
ServerVoiceChannelMemberJoinListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addServerVoiceChannelMemberJoinListener'");
}
@Override
public List<ServerVoiceChannelMemberJoinListener> getServerVoiceChannelMemberJoinListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getServerVoiceChannelMemberJoinListeners'");
}
@Override
public ListenerManager<PrivateChannelDeleteListener> addPrivateChannelDeleteListener(
PrivateChannelDeleteListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addPrivateChannelDeleteListener'");
}
@Override
public List<PrivateChannelDeleteListener> getPrivateChannelDeleteListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getPrivateChannelDeleteListeners'");
}
@Override
public ListenerManager<PrivateChannelCreateListener> addPrivateChannelCreateListener(
PrivateChannelCreateListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addPrivateChannelCreateListener'");
}
@Override
public List<PrivateChannelCreateListener> getPrivateChannelCreateListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getPrivateChannelCreateListeners'");
}
@Override
public ListenerManager<UserChangeDeafenedListener> addUserChangeDeafenedListener(
UserChangeDeafenedListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addUserChangeDeafenedListener'");
}
@Override
public List<UserChangeDeafenedListener> getUserChangeDeafenedListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getUserChangeDeafenedListeners'");
}
@Override
public ListenerManager<UserChangeNicknameListener> addUserChangeNicknameListener(
UserChangeNicknameListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addUserChangeNicknameListener'");
}
@Override
public List<UserChangeNicknameListener> getUserChangeNicknameListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getUserChangeNicknameListeners'");
}
@Override
public ListenerManager<UserChangePendingListener> addUserChangePendingListener(UserChangePendingListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addUserChangePendingListener'");
}
@Override
public List<UserChangePendingListener> getUserChangePendingListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getUserChangePendingListeners'");
}
@Override
public ListenerManager<UserStartTypingListener> addUserStartTypingListener(UserStartTypingListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addUserStartTypingListener'");
}
@Override
public List<UserStartTypingListener> getUserStartTypingListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getUserStartTypingListeners'");
}
@Override
public ListenerManager<UserChangeDiscriminatorListener> addUserChangeDiscriminatorListener(
UserChangeDiscriminatorListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addUserChangeDiscriminatorListener'");
}
@Override
public List<UserChangeDiscriminatorListener> getUserChangeDiscriminatorListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getUserChangeDiscriminatorListeners'");
}
@Override
public ListenerManager<UserChangeStatusListener> addUserChangeStatusListener(UserChangeStatusListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addUserChangeStatusListener'");
}
@Override
public List<UserChangeStatusListener> getUserChangeStatusListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getUserChangeStatusListeners'");
}
@Override
public ListenerManager<UserChangeServerAvatarListener> addUserChangeServerAvatarListener(
UserChangeServerAvatarListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addUserChangeServerAvatarListener'");
}
@Override
public List<UserChangeServerAvatarListener> getUserChangeServerAvatarListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getUserChangeServerAvatarListeners'");
}
@Override
public ListenerManager<UserChangeSelfMutedListener> addUserChangeSelfMutedListener(
UserChangeSelfMutedListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addUserChangeSelfMutedListener'");
}
@Override
public List<UserChangeSelfMutedListener> getUserChangeSelfMutedListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getUserChangeSelfMutedListeners'");
}
@Override
public ListenerManager<UserChangeNameListener> addUserChangeNameListener(UserChangeNameListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addUserChangeNameListener'");
}
@Override
public List<UserChangeNameListener> getUserChangeNameListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getUserChangeNameListeners'");
}
@Override
public ListenerManager<UserChangeTimeoutListener> addUserChangeTimeoutListener(UserChangeTimeoutListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addUserChangeTimeoutListener'");
}
@Override
public List<UserChangeTimeoutListener> getUserChangeTimeoutListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getUserChangeTimeoutListeners'");
}
@Override
public ListenerManager<UserChangeAvatarListener> addUserChangeAvatarListener(UserChangeAvatarListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addUserChangeAvatarListener'");
}
@Override
public List<UserChangeAvatarListener> getUserChangeAvatarListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getUserChangeAvatarListeners'");
}
@Override
public ListenerManager<UserChangeSelfDeafenedListener> addUserChangeSelfDeafenedListener(
UserChangeSelfDeafenedListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addUserChangeSelfDeafenedListener'");
}
@Override
public List<UserChangeSelfDeafenedListener> getUserChangeSelfDeafenedListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getUserChangeSelfDeafenedListeners'");
}
@Override
public ListenerManager<UserChangeMutedListener> addUserChangeMutedListener(UserChangeMutedListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addUserChangeMutedListener'");
}
@Override
public List<UserChangeMutedListener> getUserChangeMutedListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getUserChangeMutedListeners'");
}
@Override
public ListenerManager<UserChangeActivityListener> addUserChangeActivityListener(
UserChangeActivityListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addUserChangeActivityListener'");
}
@Override
public List<UserChangeActivityListener> getUserChangeActivityListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getUserChangeActivityListeners'");
}
@Override
public ListenerManager<ReactionRemoveListener> addReactionRemoveListener(ReactionRemoveListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addReactionRemoveListener'");
}
@Override
public List<ReactionRemoveListener> getReactionRemoveListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getReactionRemoveListeners'");
}
@Override
public ListenerManager<ReactionAddListener> addReactionAddListener(ReactionAddListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addReactionAddListener'");
}
@Override
public List<ReactionAddListener> getReactionAddListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getReactionAddListeners'");
}
@Override
public ListenerManager<MessageCreateListener> addMessageCreateListener(MessageCreateListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addMessageCreateListener'");
}
@Override
public List<MessageCreateListener> getMessageCreateListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getMessageCreateListeners'");
}
@Override
public ListenerManager<MessageReplyListener> addMessageReplyListener(MessageReplyListener listener) {
throw new UnsupportedOperationException("Unimplemented method 'addMessageReplyListener'");
}
@Override
public List<MessageReplyListener> getMessageReplyListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getMessageReplyListeners'");
}
@Override
public <T extends UserAttachableListener & ObjectAttachableListener> Collection<ListenerManager<T>> addUserAttachableListener(
T listener) {
throw new UnsupportedOperationException("Unimplemented method 'addUserAttachableListener'");
}
@Override
public <T extends UserAttachableListener & ObjectAttachableListener> void removeUserAttachableListener(T listener) {
throw new UnsupportedOperationException("Unimplemented method 'removeUserAttachableListener'");
}
@Override
public <T extends UserAttachableListener & ObjectAttachableListener> Map<T, List<Class<T>>> getUserAttachableListeners() {
throw new UnsupportedOperationException("Unimplemented method 'getUserAttachableListeners'");
}
@Override
public <T extends UserAttachableListener & ObjectAttachableListener> void removeListener(Class<T> listenerClass,
T listener) {
throw new UnsupportedOperationException("Unimplemented method 'removeListener'");
}
@Override
public String getDiscriminator() {
throw new UnsupportedOperationException("Unimplemented method 'getDiscriminator'");
}
@Override
public boolean isBot() {
throw new UnsupportedOperationException("Unimplemented method 'isBot'");
}
@Override
public Set<Activity> getActivities() {
throw new UnsupportedOperationException("Unimplemented method 'getActivities'");
}
@Override
public UserStatus getStatus() {
throw new UnsupportedOperationException("Unimplemented method 'getStatus'");
}
@Override
public UserStatus getStatusOnClient(DiscordClient client) {
throw new UnsupportedOperationException("Unimplemented method 'getStatusOnClient'");
}
@Override
public EnumSet<UserFlag> getUserFlags() {
throw new UnsupportedOperationException("Unimplemented method 'getUserFlags'");
}
@Override
public Optional<String> getAvatarHash() {
throw new UnsupportedOperationException("Unimplemented method 'getAvatarHash'");
}
@Override
public Icon getAvatar() {
throw new UnsupportedOperationException("Unimplemented method 'getAvatar'");
}
@Override
public Icon getAvatar(int size) {
throw new UnsupportedOperationException("Unimplemented method 'getAvatar'");
}
@Override
public Optional<String> getServerAvatarHash(Server server) {
throw new UnsupportedOperationException("Unimplemented method 'getServerAvatarHash'");
}
@Override
public Optional<Icon> getServerAvatar(Server server) {
throw new UnsupportedOperationException("Unimplemented method 'getServerAvatar'");
}
@Override
public Optional<Icon> getServerAvatar(Server server, int size) {
throw new UnsupportedOperationException("Unimplemented method 'getServerAvatar'");
}
@Override
public Icon getEffectiveAvatar(Server server) {
throw new UnsupportedOperationException("Unimplemented method 'getEffectiveAvatar'");
}
@Override
public Icon getEffectiveAvatar(Server server, int size) {
throw new UnsupportedOperationException("Unimplemented method 'getEffectiveAvatar'");
}
@Override
public boolean hasDefaultAvatar() {
throw new UnsupportedOperationException("Unimplemented method 'hasDefaultAvatar'");
}
@Override
public Set<Server> getMutualServers() {
throw new UnsupportedOperationException("Unimplemented method 'getMutualServers'");
}
@Override
public String getDisplayName(Server server) {
throw new UnsupportedOperationException("Unimplemented method 'getDisplayName'");
}
@Override
public Optional<String> getNickname(Server server) {
throw new UnsupportedOperationException("Unimplemented method 'getNickname'");
}
@Override
public Optional<Instant> getServerBoostingSinceTimestamp(Server server) {
throw new UnsupportedOperationException("Unimplemented method 'getServerBoostingSinceTimestamp'");
}
@Override
public Optional<Instant> getTimeout(Server server) {
throw new UnsupportedOperationException("Unimplemented method 'getTimeout'");
}
@Override
public boolean isPending(Server server) {
throw new UnsupportedOperationException("Unimplemented method 'isPending'");
}
@Override
public boolean isSelfMuted(Server server) {
throw new UnsupportedOperationException("Unimplemented method 'isSelfMuted'");
}
@Override
public boolean isSelfDeafened(Server server) {
throw new UnsupportedOperationException("Unimplemented method 'isSelfDeafened'");
}
@Override
public Optional<Instant> getJoinedAtTimestamp(Server server) {
throw new UnsupportedOperationException("Unimplemented method 'getJoinedAtTimestamp'");
}
@Override
public List<Role> getRoles(Server server) {
throw new UnsupportedOperationException("Unimplemented method 'getRoles'");
}
@Override
public Optional<Color> getRoleColor(Server server) {
throw new UnsupportedOperationException("Unimplemented method 'getRoleColor'");
}
@Override
public Optional<PrivateChannel> getPrivateChannel() {
throw new UnsupportedOperationException("Unimplemented method 'getPrivateChannel'");
}
@Override
public CompletableFuture<PrivateChannel> openPrivateChannel() {
throw new UnsupportedOperationException("Unimplemented method 'openPrivateChannel'");
}
}