Mocking lab

.gitignore

@@ -9,6 +9,7 @@ local.properties
 .settings/
 .loadpath
 .recommenders
+JavaDoc/
 
 # External tool builders
 .externalToolBuilders/
@@ -60,3 +61,5 @@ local.properties
 #.project
 /target/
 api-key.txt
+
+

pom.xml

@@ -67,6 +67,12 @@
 			<artifactId>guava-annotations</artifactId>
 			<version>r03</version>
 		</dependency>
+		<dependency>
+        	<groupId>org.junit.jupiter</groupId>
+        	<artifactId>junit-jupiter-engine</artifactId>
+        	<version>5.4.0</version>
+        	<scope>test</scope>
+    	</dependency>
 	</dependencies>
 	<build>
 		<plugins>

src/main/java/edu/mills/cs180a/wordui/FXMLController.java

@@ -132,9 +132,13 @@ private void configureButtons() {
                         .or(freqValidProperty.not())
                         .or(wordTextField.textProperty().isEmpty())
                         .or(definitionTextArea.textProperty().isEmpty()));
-
-        // TODO: Disable the Create button if an existing entry is selected or any
+        // Disable the Create button if an existing entry is selected or any
         // field is empty or invalid.
+        createButton.disableProperty()
+                .bind(listView.getSelectionModel().selectedItemProperty().isNotNull()
+                        .or(wordTextField.textProperty().isEmpty())
+                        .or(freqValidProperty.not())
+                        .or(definitionTextArea.textProperty().isEmpty()));
     }
 
     // A frequency is valid if it is an integer and is at least 0.

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

@@ -42,37 +42,54 @@ private static int getFrequencyFromSummary(FrequencySummary fs, int year) {
         return 0;
     }
 
-    // TODO: Move to spring-swagger-wordnik-client
     @VisibleForTesting
     protected static int getFrequencyByYear(WordApi wordApi, String word, int year) {
         FrequencySummary fs = wordApi.getWordFrequency(word, "false", year, year);
         return getFrequencyFromSummary(fs, year);
     }
 
-    private static WordRecord buildWordRecord(String word, Map<Object, Object> definition) {
-        WordApi wordApi = client.buildClient(WordApi.class);
-        return new WordRecord(
-                word,
+    @VisibleForTesting
+    protected static WordOfTheDay getWordOfTheDay(WordsApi wordsApi) {
+        return wordsApi.getWordOfTheDay();
+    }
+
+    /**
+     * Downloads the Wordnik Word of the Day and adds it to a list.
+     * 
+     * @param the list to add the word to
+     */
+    public static void addWordOfTheDay(ObservableList<WordRecord> backingList, WordsApi wordsApi, WordApi wordApi) {
+        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(word.getWord(), definitionAsMap, wordApi)); // pass in API
+            }
+        }
+    }
+
+    private static WordRecord buildWordRecord(String word, Map<Object, Object> definition, WordApi wordApi) {
+        return new WordRecord(word,
                 getFrequencyByYear(wordApi, word, FREQ_YEAR),
                 definition.get("text").toString());
     }
 
+    /**
+     * Populates the passed list with sample words and Wordnik's Word of the Day.
+     * 
+     * @param the list to be populated
+     */
     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));
-                }
-            }
-        } catch (IOException e) {
-            System.err.println("Unable to get API key.");
+            WordApi wordApi = client.buildClient(WordApi.class);
+            addWordOfTheDay(backingList, wordsApi, wordApi);
+        } catch (IOException ex) {
+            System.out.println("Probably couldn't access the API client: " + ex);
         }
 
         backingList.add(new WordRecord("buffalo", 5153, "The North American bison."));

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

@@ -5,31 +5,63 @@
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
+import java.util.ArrayList;
 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.FrequencySummary;
+import edu.mills.cs180a.wordnik.client.model.WordOfTheDay;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
 
 class SampleDataTest {
     private final WordApi mockWordApi = mock(WordApi.class);
+    private final WordsApi mockWordsApi = mock(WordsApi.class);
+    private static final String WORD_OF_THE_DAY = "yucca";
     private static final Map<String, FrequencySummary> FREQS_MAP = Map.of(
             "apple", makeFrequencySummary(List.of(makeMap(2000, 339), makeMap(2001, 464))),
-            "orange", makeFrequencySummary(List.of(makeMap(2000, 774), makeMap(2001, 941))));
+            "orange", makeFrequencySummary(List.of(makeMap(2000, 774), makeMap(2001, 941))),
+            WORD_OF_THE_DAY, makeFrequencySummary(List.of(makeMap(2020, 37), makeMap(2012, 57))));
+    private static final String DEFINITION1 = "Definition #1";
+    private static final String DEFINITION2 = "Definition #2";
+    private static final String DEFINITION3 = "Definition #3";
+    private static final String[] DEFINITION_ARRAY = new String[] {DEFINITION1, DEFINITION2, DEFINITION3};
+    private static final List<Object> DEFINITIONS = makeDefinitions(DEFINITION_ARRAY);
+
 
     @BeforeEach
     void setup() {
         when(mockWordApi.getWordFrequency(anyString(), anyString(), anyInt(), anyInt()))
                 .thenAnswer(invocation -> FREQS_MAP.get(invocation.getArgument(0)));
+
+        WordOfTheDay mockWordOfTheDay = mock(WordOfTheDay.class);
+        when(mockWordsApi.getWordOfTheDay()).thenReturn(mockWordOfTheDay);
+        when(mockWordOfTheDay.getWord()).thenReturn(WORD_OF_THE_DAY);
+        when(mockWordOfTheDay.getDefinitions()).thenReturn(DEFINITIONS);
     }
 
     private static Map<Object, Object> makeMap(int year, int count) {
         return Map.of(SampleData.FREQ_YEAR_KEY, String.valueOf(year),
                 SampleData.FREQ_COUNT_KEY, count);
     }
 
+    private static Map<Object, Object> makeDefinition(String definition) {
+        return Map.of("text", definition);
+    }
+
+    private static List<Object> makeDefinitions(String[] definitions) {
+        List<Object> definitionList = new ArrayList<Object>();
+        for (int i = 0; i < definitions.length; i++) {
+            definitionList.add(makeDefinition(definitions[i]));
+        }
+        return definitionList;
+    }
+
     private static FrequencySummary makeFrequencySummary(List<Object> freqs) {
         FrequencySummary fs = mock(FrequencySummary.class);
         when(fs.getFrequency()).thenReturn(freqs);
@@ -38,8 +70,37 @@ private static FrequencySummary makeFrequencySummary(List<Object> freqs) {
 
     @ParameterizedTest
     @CsvSource({"apple,2000,339", "apple,2001,464", "apple,2020,0", "orange,2000,774",
-            "orange,2001,941", "orange,2050,0"})
+            "orange,2001,941", "orange,2050,0", "yucca,2020,37", "yucca,2012,57"})
     void testGetFrequencyFromSummary(String word, int year, int count) {
         assertEquals(count, SampleData.getFrequencyByYear(mockWordApi, word, year));
     }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    void testGetWordOfTheDay() {
+        WordOfTheDay wordOfTheDay = SampleData.getWordOfTheDay(mockWordsApi);
+
+        Map<String, String> definition1 = (Map<String, String>) wordOfTheDay.getDefinitions().get(0);
+        Map<String, String> definition2 = (Map<String, String>) wordOfTheDay.getDefinitions().get(1);
+        Map<String, String> definition3 = (Map<String, String>) wordOfTheDay.getDefinitions().get(2);
+
+        assertEquals(WORD_OF_THE_DAY, wordOfTheDay.getWord());
+        assertEquals(DEFINITIONS, wordOfTheDay.getDefinitions());
+        assertEquals(DEFINITION1, definition1.get("text").toString());
+        assertEquals(DEFINITION2, definition2.get("text").toString());
+        assertEquals(DEFINITION3, definition3.get("text").toString());
+    }
+
+    @Test
+    void testAddWordOfTheDay() {
+        ObservableList<WordRecord> wordRecordList = FXCollections.observableArrayList();
+        assertEquals(0, wordRecordList.size());
+        SampleData.addWordOfTheDay(wordRecordList, mockWordsApi, mockWordApi);
+        assertEquals(1, wordRecordList.size());
+
+        WordRecord wordRecord = wordRecordList.get(0);
+        assertEquals(WORD_OF_THE_DAY, wordRecord.getWord());
+        assertEquals(DEFINITION1, wordRecord.getDefinition());
+        assertEquals(57, wordRecord.getFrequency());
+    }
 }