Wordnik lab

.gitignore

@@ -1,4 +1,5 @@
 .metadata
+doc/
 bin/
 tmp/
 *.tmp

pom.xml

@@ -67,6 +67,13 @@
 			<artifactId>guava-annotations</artifactId>
 			<version>r03</version>
 		</dependency>
+		<!-- https://mvnrepository.com/artifact/org.mockito/mockito-core -->
+		<dependency>
+		    <groupId>org.mockito</groupId>
+		    <artifactId>mockito-core</artifactId>
+		    <version>3.6.0</version>
+		    <scope>test</scope>
+		</dependency>
 	</dependencies>
 	<build>
 		<plugins>

src/main/java/edu/mills/cs180a/wordui/model/SampleData.java

@@ -12,6 +12,12 @@
 import edu.mills.cs180a.wordnik.client.model.WordOfTheDay;
 import javafx.collections.ObservableList;
 
+/**
+ * A resource to process sample data.
+ *
+ * @author Ellen Spertus
+ * @author Zoe Abrams
+ */
 public class SampleData {
     @VisibleForTesting
     protected static final String FREQ_COUNT_KEY = "count";
@@ -25,7 +31,7 @@ private static int getFrequencyFromSummary(FrequencySummary fs, int year) {
         // freqObjects is a List<Map> [{"year" = "2012", "count" = 179}] for "Java"
 
         if (freqObjects instanceof List) {
-            List<Object> maps = (List<Object>) freqObjects;
+            List<Object> maps = freqObjects;
             for (Object map : maps) {
                 if (map instanceof Map) {
                     @SuppressWarnings("unchecked")
@@ -49,37 +55,59 @@ protected static int getFrequencyByYear(WordApi wordApi, String word, int year)
         return getFrequencyFromSummary(fs, year);
     }
 
-    private static WordRecord buildWordRecord(String word, Map<Object, Object> definition) {
-        WordApi wordApi = client.buildClient(WordApi.class);
+    private static WordRecord buildWordRecord(WordApi wordApi, String word,
+            Map<Object, Object> definition) {
         return new WordRecord(
                 word,
                 getFrequencyByYear(wordApi, word, FREQ_YEAR),
                 definition.get("text").toString());
     }
 
+    @VisibleForTesting
+    protected static WordOfTheDay getWordOfTheDay(WordsApi wordsApi) {
+        return wordsApi.getWordOfTheDay();
+    }
+
+    /**
+     * Adds sample data to the provided observable list.
+     *
+     * @param backingList the list
+     * @throws IOException if unable to get API key
+     */
     public static void fillSampleData(ObservableList<WordRecord> backingList) {
         try {
             client = ApiClientHelper.getApiClient();
             WordsApi wordsApi = client.buildClient(WordsApi.class);
-            WordOfTheDay word = wordsApi.getWordOfTheDay();
-            List<Object> definitions = word.getDefinitions();
-            if (definitions != null && !definitions.isEmpty()) {
-                Object definition = definitions.get(0);
-                if (definition instanceof Map) {
-                    @SuppressWarnings("unchecked")
-                    Map<Object, Object> definitionAsMap = (Map<Object, Object>) definition;
-                    backingList.add(buildWordRecord(word.getWord(), definitionAsMap));
-                }
-            }
+            WordApi wordApi = client.buildClient(WordApi.class);
+            addWordOfTheDay(wordsApi, wordApi, backingList);
         } catch (IOException e) {
             System.err.println("Unable to get API key.");
         }
-
         backingList.add(new WordRecord("buffalo", 5153, "The North American bison."));
         backingList.add(new WordRecord("school", 23736, "A large group of aquatic animals."));
         backingList.add(new WordRecord("Java",
                 179, "An island of Indonesia in the Malay Archipelago"));
         backingList.add(new WordRecord("random",
                 794, "Having no specific pattern, purpose, or objective"));
     }
+
+    /**
+     * Adds a new word of the day to the list.
+     *
+     * @param backingList the list
+     */
+    public static void addWordOfTheDay(WordsApi wordsApi, WordApi wordApi,
+            ObservableList<WordRecord> backingList) {
+
+        WordOfTheDay word = getWordOfTheDay(wordsApi);
+        List<Object> definitions = word.getDefinitions();
+        if (definitions != null && !definitions.isEmpty()) {
+            Object definition = definitions.get(0);
+            if (definition instanceof Map) {
+                @SuppressWarnings("unchecked")
+                Map<Object, Object> definitionAsMap = (Map<Object, Object>) definition;
+                backingList.add(buildWordRecord(wordApi, word.getWord(), definitionAsMap));
+            }
+        }
+    }
 }

src/test/java/edu/mills/cs180a/wordui/model/SampleDataTest.java

@@ -1,28 +1,53 @@
 package edu.mills.cs180a.wordui.model;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
+import java.io.IOException;
 import java.util.List;
 import java.util.Map;
 import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.CsvSource;
 import edu.mills.cs180a.wordnik.client.api.WordApi;
+import edu.mills.cs180a.wordnik.client.api.WordsApi;
+import edu.mills.cs180a.wordnik.client.model.WordOfTheDay;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
 import edu.mills.cs180a.wordnik.client.model.FrequencySummary;
 
 class SampleDataTest {
-    private final WordApi mockWordApi = mock(WordApi.class);
+    private static final WordApi mockWordApi = mock(WordApi.class);
+    private static final WordsApi mockWordsApi = mock(WordsApi.class);
+
+    private static final WordOfTheDay WORD =
+            makeWordOfTheDay("cromulent",
+                    List.of(
+                            Map.of("text", "a valid word",
+                                    "partOfSpeech", "adjective",
+                                    "source", "wiktionary",
+                                    "note", "null"),
+                            Map.of("text", "appropriate for use",
+                                    "partOfSpeech", "adjective",
+                                    "source", "wiktionary",
+                                    "note", "null")));
+
     private static final Map<String, FrequencySummary> FREQS_MAP = Map.of(
+            "cromulent", makeFrequencySummary(List.of(makeMap(2000, 10), makeMap(2001, 20))),
             "apple", makeFrequencySummary(List.of(makeMap(2000, 339), makeMap(2001, 464))),
             "orange", makeFrequencySummary(List.of(makeMap(2000, 774), makeMap(2001, 941))));
 
     @BeforeEach
     void setup() {
         when(mockWordApi.getWordFrequency(anyString(), anyString(), anyInt(), anyInt()))
                 .thenAnswer(invocation -> FREQS_MAP.get(invocation.getArgument(0)));
+
+        when(mockWordsApi.getWordOfTheDay())
+                .thenAnswer(invocation -> WORD);
     }
 
     private static Map<Object, Object> makeMap(int year, int count) {
@@ -36,6 +61,42 @@ private static FrequencySummary makeFrequencySummary(List<Object> freqs) {
         return fs;
     }
 
+    private static WordOfTheDay makeWordOfTheDay(String words,
+            List<Object> definitions) {
+        WordOfTheDay wrd = mock(WordOfTheDay.class);
+        when(wrd.getWord()).thenReturn(words);
+        when(wrd.getDefinitions()).thenReturn(definitions);
+        return wrd;
+    }
+
+    @Test
+    void testGetWordOfTheDayGetWord() {
+        assertEquals("cromulent", SampleData.getWordOfTheDay(mockWordsApi).getWord());
+    }
+
+    @Test
+    void testGetWordOfTheDayGetDefinitionInstanceofMap() {
+        assertTrue(SampleData.getWordOfTheDay(mockWordsApi).getDefinitions().get(0) instanceof Map);
+    }
+
+    @Test
+    void testGetWordOfTheDayGetDefinition() {
+        @SuppressWarnings("unchecked")
+        Map<Object, Object> definitions = (Map<Object, Object>) SampleData
+                .getWordOfTheDay(mockWordsApi).getDefinitions().get(0);
+        assertEquals("a valid word", definitions.get("text"));
+    }
+
+    @Test
+    void testAddWordOfTheDay() throws IOException {
+        ObservableList<WordRecord> list = FXCollections.observableArrayList(
+                new WordRecord("schoolbus", 23736, "A bus to take children to school."));
+        assertEquals("schoolbus", list.get(0).getWord());
+        SampleData.addWordOfTheDay(mockWordsApi, mockWordApi, list);
+        assertEquals(2, list.size());
+        assertEquals("cromulent", list.get(1).getWord());
+    }
+
     @ParameterizedTest
     @CsvSource({"apple,2000,339", "apple,2001,464", "apple,2020,0", "orange,2000,774",
             "orange,2001,941", "orange,2050,0"})