For #4398 - add HistoryController (#4837)

app/src/main/java/org/mozilla/fenix/library/history/HistoryController.kt

@@ -0,0 +1,58 @@
+/*
+ *  This Source Code Form is subject to the terms of the Mozilla Public
+ *  * License, v. 2.0. If a copy of the MPL was not distributed with this
+ *  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+package org.mozilla.fenix.library.history
+
+interface HistoryController {
+    fun handleOpen(item: HistoryItem)
+    fun handleSelect(item: HistoryItem)
+    fun handleDeselect(item: HistoryItem)
+    fun handleBackPressed(): Boolean
+    fun handleModeSwitched()
+    fun handleDeleteAll()
+    fun handleDeleteSome(items: Set<HistoryItem>)
+}
+
+class DefaultHistoryController(
+    private val store: HistoryStore,
+    private val openToBrowser: (item: HistoryItem) -> Unit,
+    private val displayDeleteAll: () -> Unit,
+    private val invalidateOptionsMenu: () -> Unit,
+    private val deleteHistoryItems: (Set<HistoryItem>) -> Unit
+) : HistoryController {
+    override fun handleOpen(item: HistoryItem) {
+        openToBrowser(item)
+    }
+
+    override fun handleSelect(item: HistoryItem) {
+        store.dispatch(HistoryAction.AddItemForRemoval(item))
+    }
+
+    override fun handleDeselect(item: HistoryItem) {
+        store.dispatch(HistoryAction.RemoveItemForRemoval(item))
+    }
+
+    override fun handleBackPressed(): Boolean {
+        return if (store.state.mode is HistoryState.Mode.Editing) {
+            store.dispatch(HistoryAction.ExitEditMode)
+            true
+        } else {
+            false
+        }
+    }
+
+    override fun handleModeSwitched() {
+        invalidateOptionsMenu.invoke()
+    }
+
+    override fun handleDeleteAll() {
+        displayDeleteAll.invoke()
+    }
+
+    override fun handleDeleteSome(items: Set<HistoryItem>) {
+        deleteHistoryItems.invoke(items)
+    }
+}

app/src/main/java/org/mozilla/fenix/library/history/HistoryFragment.kt

@@ -60,13 +60,16 @@ class HistoryFragment : LibraryPageFragment<HistoryItem>(), BackHandler {
                 )
             )
         }
-        historyInteractor = HistoryInteractor(
+        val historyController: HistoryController = DefaultHistoryController(
             historyStore,
             ::openItem,
             ::displayDeleteAllDialog,
             ::invalidateOptionsMenu,
             ::deleteHistoryItems
         )
+        historyInteractor = HistoryInteractor(
+            historyController
+        )
         historyView = HistoryView(view.historyLayout, historyInteractor)
 
         return view

app/src/main/java/org/mozilla/fenix/library/history/HistoryInteractor.kt

@@ -9,42 +9,33 @@ package org.mozilla.fenix.library.history
  * Provides implementations for the HistoryViewInteractor
  */
 class HistoryInteractor(
-    private val store: HistoryStore,
+    private val historyController: HistoryController
-    private val openToBrowser: (item: HistoryItem) -> Unit,
-    private val displayDeleteAll: () -> Unit,
-    private val invalidateOptionsMenu: () -> Unit,
-    private val deleteHistoryItems: (Set<HistoryItem>) -> Unit
 ) : HistoryViewInteractor {
     override fun open(item: HistoryItem) {
-        openToBrowser(item)
+        historyController.handleOpen(item)
     }
 
     override fun select(item: HistoryItem) {
-        store.dispatch(HistoryAction.AddItemForRemoval(item))
+        historyController.handleSelect(item)
     }
 
     override fun deselect(item: HistoryItem) {
-        store.dispatch(HistoryAction.RemoveItemForRemoval(item))
+        historyController.handleDeselect(item)
     }
 
     override fun onBackPressed(): Boolean {
-        return if (store.state.mode is HistoryState.Mode.Editing) {
+        return historyController.handleBackPressed()
-            store.dispatch(HistoryAction.ExitEditMode)
-            true
-        } else {
-            false
-        }
     }
 
     override fun onModeSwitched() {
-        invalidateOptionsMenu.invoke()
+        historyController.handleModeSwitched()
     }
 
     override fun onDeleteAll() {
-        displayDeleteAll.invoke()
+        historyController.handleDeleteAll()
     }
 
     override fun onDeleteSome(items: Set<HistoryItem>) {
-        deleteHistoryItems.invoke(items)
+        historyController.handleDeleteSome(items)
     }
 }

app/src/test/java/org/mozilla/fenix/library/history/HistoryControllerTest.kt

@@ -10,20 +10,27 @@ import io.mockk.verify
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
 import org.junit.Assert.assertTrue
+import org.junit.Before
 import org.junit.Test
 
-class HistoryInteractorTest {
+class HistoryControllerTest {
+
+    private val historyItem = HistoryItem(0, "title", "url", 0.toLong())
+    private val store: HistoryStore = mockk(relaxed = true)
+    private val state: HistoryState = mockk(relaxed = true)
+
+    @Before
+    fun setUp() {
+        every { store.state } returns state
+    }
 
     @Test
     fun onPressHistoryItemInNormalMode() {
         var historyItemReceived: HistoryItem? = null
-        val historyItem = HistoryItem(0, "title", "url", 0.toLong())
+
-        val store: HistoryStore = mockk()
-        val state: HistoryState = mockk()
-        every { store.state } returns state
         every { state.mode } returns HistoryState.Mode.Normal
 
-        val interactor = HistoryInteractor(
+        val controller = DefaultHistoryController(
             store,
             { historyItemReceived = it },
             mockk(),
@@ -31,19 +38,15 @@ class HistoryInteractorTest {
             mockk()
         )
 
-        interactor.open(historyItem)
+        controller.handleOpen(historyItem)
         assertEquals(historyItem, historyItemReceived)
     }
 
     @Test
     fun onPressHistoryItemInEditMode() {
-        val historyItem = HistoryItem(0, "title", "url", 0.toLong())
-        val store: HistoryStore = mockk(relaxed = true)
-        val state: HistoryState = mockk()
-        every { store.state } returns state
         every { state.mode } returns HistoryState.Mode.Editing(setOf())
 
-        val interactor = HistoryInteractor(
+        val controller = DefaultHistoryController(
             store,
             { },
             mockk(),
@@ -51,7 +54,7 @@ class HistoryInteractorTest {
             mockk()
         )
 
-        interactor.select(historyItem)
+        controller.handleSelect(historyItem)
 
         verify {
             store.dispatch(HistoryAction.AddItemForRemoval(historyItem))
@@ -60,13 +63,9 @@ class HistoryInteractorTest {
 
     @Test
     fun onPressSelectedHistoryItemInEditMode() {
-        val historyItem = HistoryItem(0, "title", "url", 0.toLong())
-        val store: HistoryStore = mockk(relaxed = true)
-        val state: HistoryState = mockk()
-        every { store.state } returns state
         every { state.mode } returns HistoryState.Mode.Editing(setOf(historyItem))
 
-        val interactor = HistoryInteractor(
+        val controller = DefaultHistoryController(
             store,
             { },
             mockk(),
@@ -74,7 +73,7 @@ class HistoryInteractorTest {
             mockk()
         )
 
-        interactor.deselect(historyItem)
+        controller.handleDeselect(historyItem)
 
         verify {
             store.dispatch(HistoryAction.RemoveItemForRemoval(historyItem))
@@ -83,24 +82,18 @@ class HistoryInteractorTest {
 
     @Test
     fun onBackPressedInNormalMode() {
-        val store: HistoryStore = mockk(relaxed = true)
-        val state: HistoryState = mockk()
-        every { store.state } returns state
         every { state.mode } returns HistoryState.Mode.Normal
 
-        val interactor = HistoryInteractor(store, mockk(), mockk(), mockk(), mockk())
+        val controller = DefaultHistoryController(store, mockk(), mockk(), mockk(), mockk())
-        assertFalse(interactor.onBackPressed())
+        assertFalse(controller.handleBackPressed())
     }
 
     @Test
     fun onBackPressedInEditMode() {
-        val store: HistoryStore = mockk(relaxed = true)
-        val state: HistoryState = mockk()
-        every { store.state } returns state
         every { state.mode } returns HistoryState.Mode.Editing(setOf())
 
-        val interactor = HistoryInteractor(store, mockk(), mockk(), mockk(), mockk())
+        val controller = DefaultHistoryController(store, mockk(), mockk(), mockk(), mockk())
-        assertTrue(interactor.onBackPressed())
+        assertTrue(controller.handleBackPressed())
 
         verify {
             store.dispatch(HistoryAction.ExitEditMode)
@@ -110,28 +103,28 @@ class HistoryInteractorTest {
     @Test
     fun onModeSwitched() {
         var menuInvalidated = false
-        val interactor = HistoryInteractor(
+        val controller = DefaultHistoryController(
             mockk(),
             mockk(),
             mockk(),
             { menuInvalidated = true },
             mockk()
         )
-        interactor.onModeSwitched()
+        controller.handleModeSwitched()
         assertEquals(true, menuInvalidated)
     }
 
     @Test
     fun onDeleteAll() {
         var deleteAllDialogShown = false
-        val interactor = HistoryInteractor(
+        val controller = DefaultHistoryController(
             mockk(),
             mockk(),
             { deleteAllDialogShown = true },
             mockk(),
             mockk()
         )
-        interactor.onDeleteAll()
+        controller.handleDeleteAll()
         assertEquals(true, deleteAllDialogShown)
     }
 
@@ -140,15 +133,14 @@ class HistoryInteractorTest {
         var itemsToDelete: Set<HistoryItem>? = null
         val historyItem = HistoryItem(0, "title", "url", 0.toLong())
         val newHistoryItem = HistoryItem(1, "title", "url", 0.toLong())
-        val interactor =
+        val controller = DefaultHistoryController(
-            HistoryInteractor(
                 mockk(),
                 mockk(),
                 mockk(),
                 mockk(),
                 { itemsToDelete = it }
             )
-        interactor.onDeleteSome(setOf(historyItem, newHistoryItem))
+        controller.handleDeleteSome(setOf(historyItem, newHistoryItem))
         assertEquals(itemsToDelete, setOf(historyItem, newHistoryItem))
     }
 }