[AB-197] splitting utility maven module into separate maven modules

aligning some package names
removing some unnecessary computed values from liquibase

abstracto-application/abstracto-modules/entertainment/entertainment-impl/pom.xml

@@ -0,0 +1,65 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>entertainment</artifactId>
+        <groupId>dev.sheldan.abstracto.modules</groupId>
+        <version>1.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>entertainment-impl</artifactId>
+
+    <properties>
+        <maven.compiler.source>8</maven.compiler.source>
+        <maven.compiler.target>8</maven.compiler.target>
+    </properties>
+
+    <build>
+        <plugins>
+            <plugin>
+                <artifactId>maven-assembly-plugin</artifactId>
+                <configuration>
+                    <descriptors>
+                        <descriptor>src/main/assembly/liquibase.xml</descriptor>
+                    </descriptors>
+                </configuration>
+                <executions>
+                    <execution>
+                        <id>make-assembly</id>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>single</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
+    <dependencies>
+        <dependency>
+            <groupId>dev.sheldan.abstracto.modules</groupId>
+            <artifactId>entertainment-int</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>dev.sheldan.abstracto.core</groupId>
+            <artifactId>metrics-int</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>dev.sheldan.abstracto.core</groupId>
+            <artifactId>core-int</artifactId>
+            <version>${project.version}</version>
+            <type>test-jar</type>
+            <scope>test</scope>
+        </dependency>
+
+
+    </dependencies>
+
+</project>

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/assembly/liquibase.xml

@@ -0,0 +1,18 @@
+<assembly xmlns="http://maven.apache.org/ASSEMBLY/2.1.0"
+          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+          xsi:schemaLocation="http://maven.apache.org/ASSEMBLY/2.1.0 http://maven.apache.org/xsd/assembly-2.1.0.xsd">
+    <id>liquibase</id>
+    <formats>
+        <format>zip</format>
+    </formats>
+    <includeBaseDirectory>false</includeBaseDirectory>
+    <fileSets>
+        <fileSet>
+            <outputDirectory>.</outputDirectory>
+            <directory>${project.basedir}/src/main/resources/migrations</directory>
+            <includes>
+                <include>**/*</include>
+            </includes>
+        </fileSet>
+    </fileSets>
+</assembly>

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/Choose.java

@@ -0,0 +1,65 @@
+package dev.sheldan.abstracto.entertainment.command;
+
+import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
+import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
+import dev.sheldan.abstracto.core.command.config.HelpInfo;
+import dev.sheldan.abstracto.core.command.config.Parameter;
+import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.command.execution.ContextConverter;
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.utils.FutureUtils;
+import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
+import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
+import dev.sheldan.abstracto.entertainment.model.ChooseResponseModel;
+import dev.sheldan.abstracto.entertainment.service.EntertainmentService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+@Component
+public class Choose extends AbstractConditionableCommand {
+
+    public static final String CHOOSE_RESPONSE_TEMPLATE_KEY = "choose_response";
+    @Autowired
+    private EntertainmentService entertainmentService;
+
+    @Autowired
+    private ChannelService channelService;
+
+    @Override
+    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
+        List<String> choices = (List) commandContext.getParameters().getParameters().get(0);
+        String choice = entertainmentService.takeChoice(choices, commandContext.getAuthor());
+        ChooseResponseModel responseModel = (ChooseResponseModel) ContextConverter.slimFromCommandContext(commandContext, ChooseResponseModel.class);
+        responseModel.setChosenValue(choice);
+        return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInTextChannelList(CHOOSE_RESPONSE_TEMPLATE_KEY, responseModel, commandContext.getChannel()))
+            .thenApply(unused -> CommandResult.fromIgnored());
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        List<Parameter> parameters = new ArrayList<>();
+        parameters.add(Parameter.builder().name("text").type(String.class).templated(true).remainder(true).isListParam(true).build());
+        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        return CommandConfiguration.builder()
+                .name("choose")
+                .async(true)
+                .module(EntertainmentModuleDefinition.ENTERTAINMENT)
+                .templated(true)
+                .supportsEmbedException(true)
+                .causesReaction(true)
+                .parameters(parameters)
+                .help(helpInfo)
+                .build();
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return EntertainmentFeatureDefinition.ENTERTAINMENT;
+    }
+}

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/EightBall.java

@@ -0,0 +1,69 @@
+package dev.sheldan.abstracto.entertainment.command;
+
+import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
+import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
+import dev.sheldan.abstracto.core.command.config.HelpInfo;
+import dev.sheldan.abstracto.core.command.config.Parameter;
+import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.command.execution.ContextConverter;
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.utils.FutureUtils;
+import dev.sheldan.abstracto.core.templating.service.TemplateService;
+import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
+import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
+import dev.sheldan.abstracto.entertainment.model.EightBallResponseModel;
+import dev.sheldan.abstracto.entertainment.service.EntertainmentService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+@Component
+public class EightBall extends AbstractConditionableCommand {
+
+    public static final String EIGHT_BALL_RESPONSE_TEMPLATE_KEY = "eight_ball_response";
+    @Autowired
+    private EntertainmentService entertainmentService;
+
+    @Autowired
+    private TemplateService templateService;
+
+    @Autowired
+    private ChannelService channelService;
+
+    @Override
+    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
+        String text = (String) commandContext.getParameters().getParameters().get(0);
+        String chosenKey = entertainmentService.getEightBallValue(text);
+        EightBallResponseModel responseModel = (EightBallResponseModel) ContextConverter.slimFromCommandContext(commandContext, EightBallResponseModel.class);
+        responseModel.setChosenKey(chosenKey);
+        return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInTextChannelList(EIGHT_BALL_RESPONSE_TEMPLATE_KEY, responseModel, commandContext.getChannel()))
+                .thenApply(unused -> CommandResult.fromIgnored());
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        List<Parameter> parameters = new ArrayList<>();
+        parameters.add(Parameter.builder().name("text").type(String.class).templated(true).remainder(true).build());
+        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        return CommandConfiguration.builder()
+                .name("8Ball")
+                .async(true)
+                .module(EntertainmentModuleDefinition.ENTERTAINMENT)
+                .templated(true)
+                .supportsEmbedException(true)
+                .causesReaction(true)
+                .parameters(parameters)
+                .help(helpInfo)
+                .build();
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return EntertainmentFeatureDefinition.ENTERTAINMENT;
+    }
+}

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/LoveCalc.java

@@ -0,0 +1,71 @@
+package dev.sheldan.abstracto.entertainment.command;
+
+import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
+import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
+import dev.sheldan.abstracto.core.command.config.HelpInfo;
+import dev.sheldan.abstracto.core.command.config.Parameter;
+import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.command.execution.ContextConverter;
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.utils.FutureUtils;
+import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
+import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
+import dev.sheldan.abstracto.entertainment.model.LoveCalcResponseModel;
+import dev.sheldan.abstracto.entertainment.service.EntertainmentService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+@Component
+public class LoveCalc extends AbstractConditionableCommand {
+
+    public static final String LOVE_CALC_RESPONSE_TEMPLATE_KEY = "loveCalc_response";
+
+    @Autowired
+    private ChannelService channelService;
+
+    @Autowired
+    private EntertainmentService entertainmentService;
+
+    @Override
+    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
+        List<Object> parameters = commandContext.getParameters().getParameters();
+        String firstPart = (String) parameters.get(0);
+        String secondPart = (String) parameters.get(1);
+        Integer rolled = entertainmentService.getLoveCalcValue(firstPart, secondPart);
+        LoveCalcResponseModel model = (LoveCalcResponseModel) ContextConverter.slimFromCommandContext(commandContext, LoveCalcResponseModel.class);
+        model.setRolled(rolled);
+        model.setFirstPart(firstPart);
+        model.setSecondPart(secondPart);
+        return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInTextChannelList(LOVE_CALC_RESPONSE_TEMPLATE_KEY, model, commandContext.getChannel()))
+                .thenApply(unused -> CommandResult.fromIgnored());
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        List<Parameter> parameters = new ArrayList<>();
+        parameters.add(Parameter.builder().name("firstSubject").type(String.class).templated(true).optional(true).build());
+        parameters.add(Parameter.builder().name("secondSubject").type(String.class).templated(true).optional(true).build());
+        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        return CommandConfiguration.builder()
+                .name("loveCalc")
+                .async(true)
+                .module(EntertainmentModuleDefinition.ENTERTAINMENT)
+                .templated(true)
+                .supportsEmbedException(true)
+                .causesReaction(true)
+                .parameters(parameters)
+                .help(helpInfo)
+                .build();
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return EntertainmentFeatureDefinition.ENTERTAINMENT;
+    }
+}

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/Roll.java

@@ -0,0 +1,83 @@
+package dev.sheldan.abstracto.entertainment.command;
+
+import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
+import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
+import dev.sheldan.abstracto.core.command.config.HelpInfo;
+import dev.sheldan.abstracto.core.command.config.Parameter;
+import dev.sheldan.abstracto.core.command.config.validator.MinIntegerValueValidator;
+import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.command.execution.ContextConverter;
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.service.ConfigService;
+import dev.sheldan.abstracto.core.utils.FutureUtils;
+import dev.sheldan.abstracto.entertainment.config.EntertainmentFeature;
+import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
+import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
+import dev.sheldan.abstracto.entertainment.model.RollResponseModel;
+import dev.sheldan.abstracto.entertainment.service.EntertainmentService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+@Component
+public class Roll extends AbstractConditionableCommand {
+
+    public static final String ROLL_RESPONSE_TEMPLATE_KEY = "roll_response";
+
+    @Autowired
+    private ChannelService channelService;
+
+    @Autowired
+    private EntertainmentService entertainmentService;
+
+    @Autowired
+    private ConfigService configService;
+
+    @Override
+    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
+        List<Object> parameters = commandContext.getParameters().getParameters();
+        Integer high = configService.getLongValue(EntertainmentFeature.ROLL_DEFAULT_HIGH_KEY, commandContext.getGuild().getIdLong()).intValue();
+        Integer low = 1;
+        if(parameters.size() > 1) {
+            low = (Integer) parameters.get(1);
+        }
+        if(!parameters.isEmpty()) {
+            high = (Integer) parameters.get(0);
+        }
+
+        Integer rolled = entertainmentService.calculateRollResult(low, high);
+        RollResponseModel model = (RollResponseModel) ContextConverter.slimFromCommandContext(commandContext, RollResponseModel.class);
+        model.setRolled(rolled);
+        return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInTextChannelList(ROLL_RESPONSE_TEMPLATE_KEY, model, commandContext.getChannel()))
+                .thenApply(unused -> CommandResult.fromIgnored());
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        List<Parameter> parameters = new ArrayList<>();
+        parameters.add(Parameter.builder().name("high").type(Integer.class).templated(true).validators(Arrays.asList(MinIntegerValueValidator.min(2L))).optional(true).build());
+        parameters.add(Parameter.builder().name("low").type(Integer.class).templated(true).validators(Arrays.asList(MinIntegerValueValidator.min(0L))).optional(true).build());
+        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        return CommandConfiguration.builder()
+                .name("roll")
+                .async(true)
+                .module(EntertainmentModuleDefinition.ENTERTAINMENT)
+                .templated(true)
+                .supportsEmbedException(true)
+                .causesReaction(true)
+                .parameters(parameters)
+                .help(helpInfo)
+                .build();
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return EntertainmentFeatureDefinition.ENTERTAINMENT;
+    }
+}

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/Roulette.java

@@ -0,0 +1,63 @@
+package dev.sheldan.abstracto.entertainment.command;
+
+import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
+import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
+import dev.sheldan.abstracto.core.command.config.HelpInfo;
+import dev.sheldan.abstracto.core.command.config.Parameter;
+import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.command.execution.ContextConverter;
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.utils.FutureUtils;
+import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
+import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
+import dev.sheldan.abstracto.entertainment.model.RouletteResponseModel;
+import dev.sheldan.abstracto.entertainment.service.EntertainmentService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+@Component
+public class Roulette extends AbstractConditionableCommand {
+
+    public static final String ROULETTE_RESPONSE_TEMPLATE_KEY = "roulette_response";
+    @Autowired
+    private ChannelService channelService;
+
+    @Autowired
+    private EntertainmentService entertainmentService;
+
+    @Override
+    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
+        boolean rouletteResult = entertainmentService.executeRoulette(commandContext.getAuthor());
+        RouletteResponseModel responseModel = (RouletteResponseModel) ContextConverter.slimFromCommandContext(commandContext, RouletteResponseModel.class);
+        responseModel.setResult(rouletteResult);
+        return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInTextChannelList(ROULETTE_RESPONSE_TEMPLATE_KEY, responseModel, commandContext.getChannel()))
+                .thenApply(unused -> CommandResult.fromIgnored());
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        List<Parameter> parameters = new ArrayList<>();
+        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        return CommandConfiguration.builder()
+                .name("roulette")
+                .async(true)
+                .module(EntertainmentModuleDefinition.ENTERTAINMENT)
+                .templated(true)
+                .supportsEmbedException(true)
+                .causesReaction(true)
+                .parameters(parameters)
+                .help(helpInfo)
+                .build();
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return EntertainmentFeatureDefinition.ENTERTAINMENT;
+    }
+}

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/config/EntertainmentConfig.java

@@ -0,0 +1,10 @@
+package dev.sheldan.abstracto.entertainment.config;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.PropertySource;
+
+@Configuration
+@PropertySource("classpath:entertainment-config.properties")
+public class EntertainmentConfig {
+}
+

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/service/EntertainmentServiceBean.java

@@ -0,0 +1,57 @@
+package dev.sheldan.abstracto.entertainment.service;
+
+import dev.sheldan.abstracto.core.service.ConfigService;
+import dev.sheldan.abstracto.entertainment.config.EntertainmentFeature;
+import net.dv8tion.jda.api.entities.Member;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.security.SecureRandom;
+import java.util.Arrays;
+import java.util.List;
+
+@Component
+public class EntertainmentServiceBean implements EntertainmentService {
+
+    public static final List<String> EIGHT_BALL_ANSWER_KEYS = Arrays.asList(
+            "IS_CERTAIN", "IS_DECIDEDLY", "WITHOUT_DOUBT", "DEFINITELY_SO", "MAY_RELY", // certain
+            "SEE_IT", "MOST_LIKELY", "OUTLOOK", "YES", "POINT_YES", // certain
+            "HAZY", "ASK_AGAIN", "NOT_TELL", "CANNOT_PREDICT", "CONCENTRATE", // uncertain
+            "DONT_COUNT", "REPLY_NO", "SOURCES_NO", "OUTLOOK_NOT_GOOD", "DOUBTFUL" // negative
+    );
+
+    @Autowired
+    private SecureRandom secureRandom;
+
+    @Autowired
+    private ConfigService configService;
+
+    @Override
+    public String getEightBallValue(String text) {
+        return EIGHT_BALL_ANSWER_KEYS.get(secureRandom.nextInt(EIGHT_BALL_ANSWER_KEYS.size()));
+    }
+
+    @Override
+    public Integer getLoveCalcValue(String firstPart, String secondPart) {
+        return secureRandom.nextInt(100);
+    }
+
+    @Override
+    public Integer calculateRollResult(Integer low, Integer high) {
+        int actualLow = Math.min(low, high);
+        int actualHigh = Math.max(low, high);
+        return actualLow + secureRandom.nextInt(actualHigh - actualLow);
+    }
+
+    @Override
+    public boolean executeRoulette(Member memberExecuting) {
+        Long possibilities = configService.getLongValue(EntertainmentFeature.ROULETTE_BULLETS_CONFIG_KEY, memberExecuting.getGuild().getIdLong());
+        // 1/possibilities of chance, we don't have a state, each time its reset
+        return secureRandom.nextInt(possibilities.intValue()) == 0;
+    }
+
+    @Override
+    public String takeChoice(List<String> choices, Member memberExecuting) {
+        return choices.get(secureRandom.nextInt(choices.size()));
+    }
+}

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/resources/entertainment-config.properties

@@ -0,0 +1,8 @@
+abstracto.systemConfigs.rouletteBullets.name=rouletteBullets
+abstracto.systemConfigs.rouletteBullets.longValue=6
+
+abstracto.systemConfigs.rollDefaultHigh.name=rollDefaultHigh
+abstracto.systemConfigs.rollDefaultHigh.longValue=6
+
+abstracto.featureFlags.entertainment.featureName=entertainment
+abstracto.featureFlags.entertainment.enabled=false

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/resources/migrations/1.0-entertainment/collection.xml

@@ -0,0 +1,10 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog ../dbchangelog-3.8.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext ../dbchangelog-3.8.xsd
+    http://www.liquibase.org/xml/ns/pro ../dbchangelog-3.8.xsd" >
+    <include file="entertainment-seedData/data.xml" relativeToChangelogFile="true"/>
+</databaseChangeLog>

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/resources/migrations/1.0-entertainment/entertainment-seedData/command.xml

@@ -0,0 +1,40 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog ../../dbchangelog-3.8.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext ../../dbchangelog-3.8.xsd
+    http://www.liquibase.org/xml/ns/pro ../../dbchangelog-3.8.xsd" >
+    <property name="entertainmentModule" value="(SELECT id FROM module WHERE name = 'entertainment')"/>
+    <property name="entertainmentFeature" value="(SELECT id FROM feature WHERE key = 'entertainment')"/>
+
+    <changeSet  author="Sheldan"  id="entertainment-commands">
+        <insert tableName="command">
+            <column name="name" value="8Ball"/>
+            <column name="module_id" valueComputed="${entertainmentModule}"/>
+            <column name="feature_id" valueComputed="${entertainmentFeature}"/>
+        </insert>
+        <insert tableName="command">
+            <column name="name" value="loveCalc"/>
+            <column name="module_id" valueComputed="${entertainmentModule}"/>
+            <column name="feature_id" valueComputed="${entertainmentFeature}"/>
+        </insert>
+        <insert tableName="command">
+            <column name="name" value="roll"/>
+            <column name="module_id" valueComputed="${entertainmentModule}"/>
+            <column name="feature_id" valueComputed="${entertainmentFeature}"/>
+        </insert>
+        <insert tableName="command">
+            <column name="name" value="roulette"/>
+            <column name="module_id" valueComputed="${entertainmentModule}"/>
+            <column name="feature_id" valueComputed="${entertainmentFeature}"/>
+        </insert>
+        <insert tableName="command">
+            <column name="name" value="choose"/>
+            <column name="module_id" valueComputed="${entertainmentModule}"/>
+            <column name="feature_id" valueComputed="${entertainmentFeature}"/>
+        </insert>
+    </changeSet>
+
+</databaseChangeLog>

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/resources/migrations/1.0-entertainment/entertainment-seedData/data.xml

@@ -0,0 +1,12 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog ../../dbchangelog-3.8.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext ../../dbchangelog-3.8.xsd
+    http://www.liquibase.org/xml/ns/pro ../../dbchangelog-3.8.xsd" >
+    <include file="feature.xml" relativeToChangelogFile="true"/>
+    <include file="module.xml" relativeToChangelogFile="true"/>
+    <include file="command.xml" relativeToChangelogFile="true"/>
+</databaseChangeLog>

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/resources/migrations/1.0-entertainment/entertainment-seedData/feature.xml

@@ -0,0 +1,14 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog ../../dbchangelog-3.8.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext ../../dbchangelog-3.8.xsd
+    http://www.liquibase.org/xml/ns/pro ../../dbchangelog-3.8.xsd" >
+    <changeSet author="Sheldan"  id="entertainment_feature-insertion">
+        <insert tableName="feature">
+            <column name="key" value="entertainment"/>
+        </insert>
+    </changeSet>
+</databaseChangeLog>

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/resources/migrations/1.0-entertainment/entertainment-seedData/module.xml

@@ -0,0 +1,14 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog ../../dbchangelog-3.8.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext ../../dbchangelog-3.8.xsd
+    http://www.liquibase.org/xml/ns/pro ../../dbchangelog-3.8.xsd" >
+    <changeSet  author="Sheldan"  id="entertainment-module-insertion">
+        <insert tableName="module">
+            <column name="name"  value="entertainment"/>
+        </insert>
+    </changeSet>
+</databaseChangeLog>

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/resources/migrations/entertainment-changeLog.xml

@@ -0,0 +1,10 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog dbchangelog-3.8.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext dbchangelog-3.8.xsd
+    http://www.liquibase.org/xml/ns/pro dbchangelog-3.8.xsd" >
+    <include file="1.0-entertainment/collection.xml" relativeToChangelogFile="true"/>
+</databaseChangeLog>

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/test/java/dev/sheldan/abstracto/entertainment/command/ChooseTest.java

@@ -0,0 +1,56 @@
+package dev.sheldan.abstracto.entertainment.command;
+
+import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
+import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
+import dev.sheldan.abstracto.entertainment.model.ChooseResponseModel;
+import dev.sheldan.abstracto.entertainment.service.EntertainmentService;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ChooseTest {
+
+    @InjectMocks
+    private Choose testUnit;
+
+    @Mock
+    private EntertainmentService entertainmentService;
+
+    @Mock
+    private ChannelService channelService;
+
+    @Captor
+    private ArgumentCaptor<ChooseResponseModel> responseModelArgumentCaptor;
+
+    @Test
+    public void executeChooseCommand() {
+        List<String> choices = Arrays.asList("choice1", "choice2");
+        CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(choices));
+        when(entertainmentService.takeChoice(choices, parameters.getAuthor())).thenReturn(choices.get(0));
+        when(channelService.sendEmbedTemplateInTextChannelList(eq(Choose.CHOOSE_RESPONSE_TEMPLATE_KEY), responseModelArgumentCaptor.capture(), eq(parameters.getChannel()))).thenReturn(CommandTestUtilities.messageFutureList());
+        CompletableFuture<CommandResult> result = testUnit.executeAsync(parameters);
+        CommandTestUtilities.checkSuccessfulCompletionAsync(result);
+        Assert.assertEquals(choices.get(0), responseModelArgumentCaptor.getValue().getChosenValue());
+    }
+
+    @Test
+    public void validateCommand() {
+        CommandConfigValidator.validateCommandConfiguration(testUnit.getConfiguration());
+    }
+}

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/test/java/dev/sheldan/abstracto/entertainment/command/EightBallTest.java

@@ -0,0 +1,57 @@
+package dev.sheldan.abstracto.entertainment.command;
+
+import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
+import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
+import dev.sheldan.abstracto.entertainment.model.EightBallResponseModel;
+import dev.sheldan.abstracto.entertainment.service.EntertainmentService;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Arrays;
+import java.util.concurrent.CompletableFuture;
+
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class EightBallTest {
+
+    @InjectMocks
+    private EightBall testUnit;
+
+    @Mock
+    private EntertainmentService entertainmentService;
+
+    @Mock
+    private ChannelService channelService;
+
+    @Captor
+    private ArgumentCaptor<EightBallResponseModel> responseModelArgumentCaptor;
+
+    @Test
+    public void execute8BallCommand() {
+        String inputText = "text";
+        String chosenKey = "key";
+        CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(inputText));
+        when(entertainmentService.getEightBallValue(inputText)).thenReturn(chosenKey);
+        when(channelService.sendEmbedTemplateInTextChannelList(eq(EightBall.EIGHT_BALL_RESPONSE_TEMPLATE_KEY), responseModelArgumentCaptor.capture(), eq(parameters.getChannel()))).thenReturn(CommandTestUtilities.messageFutureList());
+        CompletableFuture<CommandResult> result = testUnit.executeAsync(parameters);
+        CommandTestUtilities.checkSuccessfulCompletionAsync(result);
+        Assert.assertEquals(chosenKey, responseModelArgumentCaptor.getValue().getChosenKey());
+    }
+
+    @Test
+    public void validateCommand() {
+        CommandConfigValidator.validateCommandConfiguration(testUnit.getConfiguration());
+    }
+
+}

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/test/java/dev/sheldan/abstracto/entertainment/command/LoveCalcTest.java

@@ -0,0 +1,61 @@
+package dev.sheldan.abstracto.entertainment.command;
+
+import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
+import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
+import dev.sheldan.abstracto.entertainment.model.LoveCalcResponseModel;
+import dev.sheldan.abstracto.entertainment.service.EntertainmentService;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Arrays;
+import java.util.concurrent.CompletableFuture;
+
+import static dev.sheldan.abstracto.entertainment.command.LoveCalc.LOVE_CALC_RESPONSE_TEMPLATE_KEY;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class LoveCalcTest {
+
+    @InjectMocks
+    private LoveCalc testUnit;
+
+    @Mock
+    private EntertainmentService entertainmentService;
+
+    @Mock
+    private ChannelService channelService;
+
+    @Captor
+    private ArgumentCaptor<LoveCalcResponseModel> responseModelArgumentCaptor;
+
+    @Test
+    public void execute8BallCommand() {
+        String inputText = "text";
+        String inputText2 = "text2";
+        Integer loveResult = 2;
+        CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(inputText, inputText2));
+        when(entertainmentService.getLoveCalcValue(inputText, inputText2)).thenReturn(loveResult);
+        when(channelService.sendEmbedTemplateInTextChannelList(eq(LOVE_CALC_RESPONSE_TEMPLATE_KEY), responseModelArgumentCaptor.capture(), eq(parameters.getChannel()))).thenReturn(CommandTestUtilities.messageFutureList());
+        CompletableFuture<CommandResult> result = testUnit.executeAsync(parameters);
+        CommandTestUtilities.checkSuccessfulCompletionAsync(result);
+        Assert.assertEquals(loveResult, responseModelArgumentCaptor.getValue().getRolled());
+        Assert.assertEquals(inputText, responseModelArgumentCaptor.getValue().getFirstPart());
+        Assert.assertEquals(inputText2, responseModelArgumentCaptor.getValue().getSecondPart());
+    }
+
+    @Test
+    public void validateCommand() {
+        CommandConfigValidator.validateCommandConfiguration(testUnit.getConfiguration());
+    }
+
+}

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/test/java/dev/sheldan/abstracto/entertainment/command/RollTest.java

@@ -0,0 +1,87 @@
+package dev.sheldan.abstracto.entertainment.command;
+
+import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.service.ConfigService;
+import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
+import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
+import dev.sheldan.abstracto.entertainment.model.RollResponseModel;
+import dev.sheldan.abstracto.entertainment.service.EntertainmentService;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Arrays;
+import java.util.concurrent.CompletableFuture;
+
+import static dev.sheldan.abstracto.entertainment.config.EntertainmentFeature.ROLL_DEFAULT_HIGH_KEY;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class RollTest {
+
+    @InjectMocks
+    private Roll testUnit;
+
+    @Mock
+    private EntertainmentService entertainmentService;
+
+    @Mock
+    private ChannelService channelService;
+
+    @Mock
+    private ConfigService configService;
+
+    @Captor
+    private ArgumentCaptor<RollResponseModel> responseModelArgumentCaptor;
+
+    @Test
+    public void executeWithNoParameter() {
+        CommandContext noParameters = CommandTestUtilities.getNoParameters();
+        Integer result = 4;
+        Long serverId = 3L;
+        Integer max = 10;
+        when(noParameters.getGuild().getIdLong()).thenReturn(serverId);
+        when(configService.getLongValue(ROLL_DEFAULT_HIGH_KEY, serverId)).thenReturn(max.longValue());
+        when(entertainmentService.calculateRollResult(1, max)).thenReturn(result);
+        when(channelService.sendEmbedTemplateInTextChannelList(eq(Roll.ROLL_RESPONSE_TEMPLATE_KEY), responseModelArgumentCaptor.capture(), eq(noParameters.getChannel()))).thenReturn(CommandTestUtilities.messageFutureList());
+        CompletableFuture<CommandResult> futureResult = testUnit.executeAsync(noParameters);
+        CommandTestUtilities.checkSuccessfulCompletionAsync(futureResult);
+        Assert.assertEquals(4, responseModelArgumentCaptor.getValue().getRolled().intValue());
+    }
+
+    @Test
+    public void executeWithHighParameter() {
+        CommandContext noParameters = CommandTestUtilities.getWithParameters(Arrays.asList(20));
+        Integer result = 4;
+        when(entertainmentService.calculateRollResult(1, 20)).thenReturn(result);
+        when(channelService.sendEmbedTemplateInTextChannelList(eq(Roll.ROLL_RESPONSE_TEMPLATE_KEY), responseModelArgumentCaptor.capture(), eq(noParameters.getChannel()))).thenReturn(CommandTestUtilities.messageFutureList());
+        CompletableFuture<CommandResult> futureResult = testUnit.executeAsync(noParameters);
+        CommandTestUtilities.checkSuccessfulCompletionAsync(futureResult);
+        Assert.assertEquals(4, responseModelArgumentCaptor.getValue().getRolled().intValue());
+    }
+
+    @Test
+    public void executeWithBothParameters() {
+        CommandContext noParameters = CommandTestUtilities.getWithParameters(Arrays.asList(20, 10));
+        Integer result = 4;
+        when(entertainmentService.calculateRollResult(10, 20)).thenReturn(result);
+        when(channelService.sendEmbedTemplateInTextChannelList(eq(Roll.ROLL_RESPONSE_TEMPLATE_KEY), responseModelArgumentCaptor.capture(), eq(noParameters.getChannel()))).thenReturn(CommandTestUtilities.messageFutureList());
+        CompletableFuture<CommandResult> futureResult = testUnit.executeAsync(noParameters);
+        CommandTestUtilities.checkSuccessfulCompletionAsync(futureResult);
+        Assert.assertEquals(4, responseModelArgumentCaptor.getValue().getRolled().intValue());
+    }
+
+    @Test
+    public void validateCommand() {
+        CommandConfigValidator.validateCommandConfiguration(testUnit.getConfiguration());
+    }
+
+}

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/test/java/dev/sheldan/abstracto/entertainment/command/RouletteTest.java

@@ -0,0 +1,55 @@
+package dev.sheldan.abstracto.entertainment.command;
+
+import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
+import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
+import dev.sheldan.abstracto.entertainment.model.RouletteResponseModel;
+import dev.sheldan.abstracto.entertainment.service.EntertainmentService;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.concurrent.CompletableFuture;
+
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class RouletteTest {
+
+    @InjectMocks
+    private Roulette testUnit;
+
+    @Mock
+    private EntertainmentService entertainmentService;
+
+    @Mock
+    private ChannelService channelService;
+
+    @Captor
+    private ArgumentCaptor<RouletteResponseModel> responseModelArgumentCaptor;
+
+    @Test
+    public void executeWithNoParameter() {
+        CommandContext noParameters = CommandTestUtilities.getNoParameters();
+        Boolean result = false;
+        when(entertainmentService.executeRoulette(noParameters.getAuthor())).thenReturn(result);
+        when(channelService.sendEmbedTemplateInTextChannelList(eq(Roulette.ROULETTE_RESPONSE_TEMPLATE_KEY), responseModelArgumentCaptor.capture(), eq(noParameters.getChannel()))).thenReturn(CommandTestUtilities.messageFutureList());
+        CompletableFuture<CommandResult> futureResult = testUnit.executeAsync(noParameters);
+        CommandTestUtilities.checkSuccessfulCompletionAsync(futureResult);
+        Assert.assertEquals(result, responseModelArgumentCaptor.getValue().getResult());
+    }
+
+    @Test
+    public void validateCommand() {
+        CommandConfigValidator.validateCommandConfiguration(testUnit.getConfiguration());
+    }
+
+}

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/test/java/dev/sheldan/abstracto/entertainment/service/EntertainmentServiceBeanTest.java

@@ -0,0 +1,97 @@
+package dev.sheldan.abstracto.entertainment.service;
+
+import dev.sheldan.abstracto.core.service.ConfigService;
+import dev.sheldan.abstracto.entertainment.config.EntertainmentFeature;
+import net.dv8tion.jda.api.entities.Guild;
+import net.dv8tion.jda.api.entities.Member;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.security.SecureRandom;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class EntertainmentServiceBeanTest {
+    @InjectMocks
+    private EntertainmentServiceBean testUnit;
+
+    @Mock
+    private SecureRandom secureRandom;
+
+    @Mock
+    private ConfigService configService;
+
+    private static final String INPUT_TEXT = "input";
+    private static final int RANDOM_VALUE = 0;
+
+    @Test
+    public void testEightBallChoice() {
+        when(secureRandom.nextInt(EntertainmentServiceBean.EIGHT_BALL_ANSWER_KEYS.size())).thenReturn(RANDOM_VALUE);
+        String chosenKey = testUnit.getEightBallValue(INPUT_TEXT);
+        Assert.assertEquals(EntertainmentServiceBean.EIGHT_BALL_ANSWER_KEYS.get(RANDOM_VALUE), chosenKey);
+    }
+
+    @Test
+    public void testLoveCalc() {
+        when(secureRandom.nextInt(100)).thenReturn(RANDOM_VALUE);
+        Integer loveCalcValue = testUnit.getLoveCalcValue(INPUT_TEXT, INPUT_TEXT);
+        Assert.assertEquals(RANDOM_VALUE, loveCalcValue.intValue());
+    }
+
+    @Test
+    public void testRoll() {
+        executeRollTest(20, 10);
+    }
+
+    @Test
+    public void testRollOutOfOrderParams() {
+        executeRollTest(10, 20);
+    }
+
+    private void executeRollTest(int high, int low) {
+        when(secureRandom.nextInt(10)).thenReturn(RANDOM_VALUE);
+        Integer loveCalcValue = testUnit.calculateRollResult(low, high);
+        Assert.assertEquals(Math.min(low, high) + RANDOM_VALUE, loveCalcValue.intValue());
+    }
+
+    @Test
+    public void testRouletteNoShot() {
+        executeRouletteTest(1);
+    }
+
+    @Test
+    public void testRouletteShot() {
+        executeRouletteTest(0);
+    }
+
+    private void executeRouletteTest(int randomValue) {
+        Long serverId = 3L;
+        Member member = Mockito.mock(Member.class);
+        Guild guild = Mockito.mock(Guild.class);
+        when(guild.getIdLong()).thenReturn(serverId);
+        when(member.getGuild()).thenReturn(guild);
+        Long sides = 6L;
+        when(configService.getLongValue(EntertainmentFeature.ROULETTE_BULLETS_CONFIG_KEY, serverId)).thenReturn(sides);
+        when(secureRandom.nextInt(sides.intValue())).thenReturn(randomValue);
+        boolean shot = testUnit.executeRoulette(member);
+        Assert.assertEquals(randomValue == 0, shot);
+    }
+
+    @Test
+    public void testTakeChoice(){
+        Member member = Mockito.mock(Member.class);
+        List<String> choices = Arrays.asList(INPUT_TEXT, INPUT_TEXT + "test");
+        when(secureRandom.nextInt(choices.size())).thenReturn(RANDOM_VALUE);
+        String choiceTaken = testUnit.takeChoice(choices, member);
+        Assert.assertEquals(choices.get(0), choiceTaken);
+    }
+
+}