Feature1/opie10

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

src/main/java/org/jointheleague/Launcher.java

@@ -8,6 +8,7 @@ public static void main(String[] args) throws InterruptedException {
         //Initialize variables
         String channelName = System.getenv("CHANNEL_NAME");
         String discordToken = System.getenv("DISCORD_TOKEN");
+
         boolean printDiscordInvite = true;
 
         //Instantiate DiscordBot and connect

src/main/java/org/jointheleague/discord_bot/DiscordBot.java

@@ -14,6 +14,7 @@
 import org.jointheleague.features.examples.first_features.RandomNumber;
 import org.jointheleague.features.help_embed.HelpListener;
 import org.jointheleague.features.student.first_feature.FeatureOne;
+import org.jointheleague.features.student.first_feature.FirstFeature;
 
 public class DiscordBot {
 
@@ -61,6 +62,7 @@ public void connect(boolean printInvite) throws InterruptedException {
 		addFeature(new HighLowGame(channelName));
 		addFeature(new NewsApi(channelName));
 		addFeature(new CatFactsApi(channelName));
+		addFeature(new FirstFeature(channelName));
 	}
 
 	private void addFeature(Feature feature){

src/main/java/org/jointheleague/features/student/first_feature/FirstFeature.java

@@ -0,0 +1,118 @@
+package org.jointheleague.features.student.first_feature;
+
+
+import org.jointheleague.api_wrapper.ReceivedMessage;
+import org.jointheleague.features.abstract_classes.Feature;
+import org.jointheleague.features.help_embed.plain_old_java_objects.help_embed.HelpEmbed;
+
+import java.util.Random;
+
+public class FirstFeature extends Feature {
+
+    public final String COMMAND = "!riddle";
+    public final String ANSWERCOMMAND = "!riddleanswer";
+    boolean riddleSent = false;
+    Random r = new Random();
+    String[] generatedRiddle;
+
+    public FirstFeature(String channelName) {
+        super(channelName);
+
+        //Create a help embed to describe feature when !help command is sent
+        helpEmbed = new HelpEmbed(
+                COMMAND,
+                "Simple command, when called produced a mind-boggling riddle for the user to ponder. \n\nAnswer provided with " + ANSWERCOMMAND
+        );
+
+    }
+
+    @Override
+    public void handle(ReceivedMessage event) {
+
+
+        String messageContent = event.getMessageContent();
+
+
+        if (messageContent.startsWith(COMMAND) && !messageContent.contains(ANSWERCOMMAND)&&!riddleSent) {
+
+            int rand = r.nextInt(10);
+            generatedRiddle = generateRiddle(rand);
+            //respond to message here
+            event.sendResponse("Here is your riddle:\n" + generatedRiddle[0] + "\nType '" + ANSWERCOMMAND + "' to get the answer!");
+            riddleSent = true;
+        }
+        else if (messageContent.startsWith(ANSWERCOMMAND) && riddleSent) {
+            event.sendResponse("The answer to your riddle is:\n" + generatedRiddle[1]);
+            riddleSent = false;
+
+        }
+        else if (messageContent.startsWith(ANSWERCOMMAND)  && !riddleSent ){
+            event.sendResponse("You have to ask for a riddle first!");
+        }
+        else{
+            return;
+        }
+    }
+
+    public String[] generateRiddle(int r) {
+        String[] riddle = new String[2];
+        int rand = r;
+
+        switch (rand) {
+            case 0:
+                riddle[0] = "What is always on the ground but never dirty?";
+                riddle[1] = "A shadow";
+
+                break;
+            case 1:
+                riddle[0] = "What can fill a room without taking up any space?";
+                riddle[1] = "Light";
+
+                break;
+            case 2:
+                riddle[0] = "What do you bury alive, but dig up dead?";
+                riddle[1] = "A plant";
+
+                break;
+            case 3:
+                riddle[0] = "I am always old, but sometimes also new. While I'm never sad, sometimes I am blue. \nI am never empty, but only sometimes full. I never push, but I always pull. What am I?";
+                riddle[1] = "The moon";
+
+                break;
+            case 4:
+                riddle[0] = "If you give me a drink, I die, but if you feed me I grow, what am I?";
+                riddle[1] = "Fire";
+
+                break;
+            case 5:
+                riddle[0] = "What can go up but can never come down?";
+                riddle[1] = "Your age";
+
+                break;
+            case 6:
+                riddle[0] = "What word in the dictionary is spelled incorrectly?";
+                riddle[1] = "Incorrectly";
+
+                break;
+            case 7:
+                riddle[0] = "What occurs once in a minute, twice in a moment, and never in 1000 years?";
+                riddle[1] = "The letter 'M'";
+
+                break;
+            case 8:
+                riddle[0] = "What is so fragile that saying its name breaks it?";
+                riddle[1] = "Silence";
+
+                break;
+            case 9:
+                riddle[0] = "What has 13 hearts but no other organs?";
+                riddle[1] = "A deck of cards";
+                break;
+
+        }
+        ;
+
+        return riddle;
+    }
+
+}

src/test/java/org/jointheleague/features/student/first_feature/FirstFeatureTest.java

@@ -0,0 +1,189 @@
+package org.jointheleague.features.student.first_feature;
+
+import org.jointheleague.api_wrapper.ReceivedMessage;
+import org.jointheleague.features.abstract_classes.Feature;
+import org.jointheleague.features.help_embed.plain_old_java_objects.help_embed.HelpEmbed;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+
+import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.*;
+
+public class FirstFeatureTest {
+    private final String testChannelName = "testing";
+    private final FirstFeature firstFeature = new FirstFeature(testChannelName);
+
+    private final ByteArrayOutputStream outContent = new ByteArrayOutputStream();
+    private final PrintStream originalOut = System.out;
+
+    @Mock
+    private ReceivedMessage receivedMessage;
+
+    @BeforeEach
+    void setUp() {
+        MockitoAnnotations.openMocks(this);
+        System.setOut(new PrintStream(outContent));
+    }
+
+    @AfterEach
+    public void itShouldNotPrintToSystemOut() {
+        String expected = "";
+        String actual = outContent.toString();
+
+        assertEquals(expected, actual);
+        System.setOut(originalOut);
+    }
+
+    @Test
+    void itShouldHaveACommand() {
+        //Given
+
+        //When
+        String command = firstFeature.COMMAND;
+
+        //Then
+
+        if(!(firstFeature instanceof Feature)){
+            assertNotEquals("!command", command);
+        }
+
+        assertNotEquals("", command);
+        assertNotEquals("!", command);
+        assertNotEquals("!command", command);
+        assertEquals('!', command.charAt(0));
+        assertNotNull(command);
+    }
+
+    @Test
+    void itShouldHandleMessagesWithCommand() {
+        //Given
+        HelpEmbed helpEmbed = new HelpEmbed(firstFeature.COMMAND, "test");
+        when(receivedMessage.getMessageContent()).thenReturn(firstFeature.COMMAND);
+
+        //When
+        firstFeature.handle(receivedMessage);
+
+        //Then
+        verify(receivedMessage, times(1)).sendResponse(anyString());
+    }
+
+    @Test
+    void itShouldNotHandleMessagesWithoutCommand() {
+        //Given
+        String command = "";
+        when(receivedMessage.getMessageContent()).thenReturn(command);
+
+        //When
+        firstFeature.handle(receivedMessage);
+
+        //Then
+        verify(receivedMessage, never()).sendResponse("");
+    }
+
+    @Test
+    void itShouldHaveAHelpEmbed() {
+        //Given
+
+        //When
+        HelpEmbed actualHelpEmbed = firstFeature.getHelpEmbed();
+
+        //Then
+        assertNotNull(actualHelpEmbed);
+    }
+
+    @Test
+    void itShouldAnswer() {
+        String commandOne = firstFeature.ANSWERCOMMAND;
+        firstFeature.riddleSent = true;
+        firstFeature.generatedRiddle = firstFeature.generateRiddle(0);
+        when(receivedMessage.getMessageContent()).thenReturn(commandOne);
+
+        //When
+        firstFeature.handle(receivedMessage);
+
+        //Then
+        Assertions.assertTrue(receivedMessage.getMessageContent() != null);
+
+    }
+
+    @Test
+    void haventAsked() {
+        String commandOne = firstFeature.ANSWERCOMMAND;
+        firstFeature.riddleSent = false;
+        firstFeature.generatedRiddle = firstFeature.generateRiddle(0);
+
+        when(receivedMessage.getMessageContent()).thenReturn(commandOne);
+        //When
+        firstFeature.handle(receivedMessage);
+        //Then
+        verify(receivedMessage, times(1)).sendResponse("You have to ask for a riddle first!");
+        assertFalse(firstFeature.riddleSent);
+    }
+
+    @Test
+    void itShouldReturnTheRightThings() {
+
+
+        for (int i = 0; i < 10; i++) {
+            String[] riddle = firstFeature.generateRiddle(i);
+            if (i == 0) {
+                assertEquals(riddle[1], "A shadow");
+
+            } else if (i == 1) {
+                assertEquals(riddle[1], "Light");
+            } else if (i == 2) {
+                assertEquals(riddle[1], "A plant");
+
+            } else if (i == 3) {
+                assertEquals(riddle[1], "The moon");
+
+            } else if (i == 4) {
+                assertEquals(riddle[1], "Fire");
+
+            } else if (i == 5) {
+                assertEquals(riddle[1], "Your age");
+
+            } else if (i == 6) {
+                assertEquals(riddle[1], "Incorrectly");
+
+            } else if (i == 7) {
+                assertEquals(riddle[1], "The letter 'M'");
+
+            } else if (i == 8) {
+                assertEquals(riddle[1], "Silence");
+
+            } else if (i == 9) {
+                assertEquals(riddle[1], "A deck of cards");
+
+            } else if (i == 10) {
+                assertNull(riddle[1]);
+
+            }
+
+        }
+
+
+    }
+
+    @Test
+    void itShouldHaveTheCommandAsTheTitleOfTheHelpEmbed() {
+        //Given
+
+        //When
+        String helpEmbedTitle = firstFeature.getHelpEmbed().getTitle();
+        String command = firstFeature.COMMAND;
+
+        //Then
+        assertEquals(command, helpEmbedTitle);
+    }
+
+}