firefox-main/mobile/android/android-components/components/browser/state/src/test/java/mozilla/components/browser/state/action/TranslationsActionTest.kt (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

Test Info:

/* 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 mozilla.components.browser.state.action
import kotlin.test.assertNotNull
import mozilla.components.browser.state.reducer.BrowserStateReducer
import mozilla.components.browser.state.selector.findTab
import mozilla.components.browser.state.state.BrowserState
import mozilla.components.browser.state.state.TabSessionState
import mozilla.components.browser.state.state.createTab
import mozilla.components.concept.engine.translate.DetectedLanguages
import mozilla.components.concept.engine.translate.Language
import mozilla.components.concept.engine.translate.LanguageModel
import mozilla.components.concept.engine.translate.LanguageSetting
import mozilla.components.concept.engine.translate.ModelManagementOptions
import mozilla.components.concept.engine.translate.ModelOperation
import mozilla.components.concept.engine.translate.ModelState
import mozilla.components.concept.engine.translate.OperationLevel
import mozilla.components.concept.engine.translate.TranslationDownloadSize
import mozilla.components.concept.engine.translate.TranslationEngineState
import mozilla.components.concept.engine.translate.TranslationError
import mozilla.components.concept.engine.translate.TranslationOperation
import mozilla.components.concept.engine.translate.TranslationPageSettingOperation
import mozilla.components.concept.engine.translate.TranslationPageSettings
import mozilla.components.concept.engine.translate.TranslationPair
import mozilla.components.concept.engine.translate.TranslationSupport
import mozilla.components.support.test.mock
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertNull
import org.junit.Assert.assertTrue
import org.junit.Before
import org.junit.Test
class TranslationsActionTest {
private lateinit var tab: TabSessionState
private lateinit var state: BrowserState
@Before
fun setUp() {
tab = createTab("https://www.mozilla.org")
state = BrowserState(tabs = listOf(tab))
}
private fun tabState(): TabSessionState = state.findTab(tab.id)!!
@Test
fun `WHEN a TranslateExpectedAction is dispatched THEN update translation expected status`() {
assertEquals(false, tabState().translationsState.isExpectedTranslate)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateExpectedAction(tabId = tab.id),
)
assertEquals(true, tabState().translationsState.isExpectedTranslate)
}
@Test
fun `WHEN a TranslateOfferAction is dispatched THEN update translation expected status`() {
assertEquals(false, tabState().translationsState.isOfferTranslate)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateOfferAction(tabId = tab.id, isOfferTranslate = true),
)
assertEquals(true, tabState().translationsState.isOfferTranslate)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateOfferAction(tabId = tab.id, isOfferTranslate = false),
)
assertFalse(tabState().translationsState.isOfferTranslate)
}
@Test
fun `WHEN a TranslateStateChangeAction is dispatched THEN update translation expected status`() {
assertEquals(null, tabState().translationsState.translationEngineState)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateStateChangeAction(tabId = tab.id, mock()),
)
assertEquals(true, tabState().translationsState.translationEngineState != null)
}
@Test
fun `WHEN a TranslateStateChangeAction is dispatched THEN the translation status updates accordingly`() {
assertNull(tabState().translationsState.translationEngineState)
assertFalse(tabState().translationsState.isTranslated)
assertFalse(tabState().translationsState.isExpectedTranslate)
assertFalse(tabState().translationsState.isTranslateProcessing)
// Set an initial state for is translate processing via a translation request:
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateAction(tabId = tab.id, "en", "es", null),
)
assertTrue(tabState().translationsState.isTranslateProcessing)
val translatedEngineState =
TranslationEngineState(
detectedLanguages =
DetectedLanguages(
documentLangTag = "es",
supportedDocumentLang = true,
userPreferredLangTag = "en",
),
error = null,
isEngineReady = true,
requestedTranslationPair = TranslationPair(fromLanguage = "es", toLanguage = "en"),
hasVisibleChange = true,
)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateStateChangeAction(
tabId = tab.id,
translationEngineState = translatedEngineState,
),
)
// Translated state
assertEquals(translatedEngineState, tabState().translationsState.translationEngineState)
assertTrue(tabState().translationsState.isTranslated)
assertFalse(tabState().translationsState.isExpectedTranslate)
assertFalse(tabState().translationsState.isTranslateProcessing)
val nonTranslatedEngineState =
TranslationEngineState(
detectedLanguages =
DetectedLanguages(
documentLangTag = "es",
supportedDocumentLang = true,
userPreferredLangTag = "en",
),
error = null,
isEngineReady = true,
requestedTranslationPair = TranslationPair(fromLanguage = null, toLanguage = null),
hasVisibleChange = false,
)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateStateChangeAction(tabId = tab.id, nonTranslatedEngineState),
)
// Non-translated state
assertEquals(nonTranslatedEngineState, tabState().translationsState.translationEngineState)
assertFalse(tabState().translationsState.isTranslated)
assertFalse(tabState().translationsState.isExpectedTranslate)
}
@Test
fun `GIVEN isOfferTranslate is true WHEN a TranslateAction is dispatched THEN isOfferTranslate should be set to false`() {
// Initial State
assertFalse(tabState().translationsState.isOfferTranslate)
// Initial Offer State
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateOfferAction(tabId = tab.id, true),
)
assertTrue(tabState().translationsState.isOfferTranslate)
// Action
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateAction(
tabId = tab.id,
fromLanguage = "en",
toLanguage = "en",
options = null,
),
)
// Should revert to false
assertFalse(tabState().translationsState.isOfferTranslate)
}
@Test
fun `WHEN a TranslateStateChangeAction is dispatched THEN the isExpectedTranslate status updates accordingly`() {
// Initial State
assertNull(tabState().translationsState.translationEngineState)
// Sending an initial request to set state; however, the engine hasn't decided if it is an
// expected state
var translatedEngineState =
TranslationEngineState(
detectedLanguages =
DetectedLanguages(
documentLangTag = "es",
supportedDocumentLang = true,
userPreferredLangTag = "en",
),
error = null,
isEngineReady = true,
requestedTranslationPair = TranslationPair(fromLanguage = "es", toLanguage = "en"),
)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateStateChangeAction(
tabId = tab.id,
translationEngineState = translatedEngineState,
),
)
assertFalse(tabState().translationsState.isExpectedTranslate)
// Engine is sending a translation expected action
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateExpectedAction(tabId = tab.id),
)
// Initial expected translation state
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateStateChangeAction(
tabId = tab.id,
translationEngineState = translatedEngineState,
),
)
assertTrue(tabState().translationsState.isExpectedTranslate)
// Not expected translation state, because it is no longer supported
translatedEngineState =
TranslationEngineState(
detectedLanguages =
DetectedLanguages(
documentLangTag = "es",
supportedDocumentLang = false,
userPreferredLangTag = "en",
),
error = null,
isEngineReady = true,
requestedTranslationPair = TranslationPair(fromLanguage = "es", toLanguage = "en"),
)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateStateChangeAction(
tabId = tab.id,
translationEngineState = translatedEngineState,
),
)
assertFalse(tabState().translationsState.isExpectedTranslate)
}
@Test
fun `WHEN a TranslateStateChangeAction is dispatched THEN the isOfferTranslate status updates accordingly`() {
// Initial State
assertNull(tabState().translationsState.translationEngineState)
// Sending an initial request to set state; however, the engine hasn't decided if it is an
// offered state
var translatedEngineState =
TranslationEngineState(
detectedLanguages =
DetectedLanguages(
documentLangTag = "es",
supportedDocumentLang = true,
userPreferredLangTag = "en",
),
error = null,
isEngineReady = true,
requestedTranslationPair = TranslationPair(fromLanguage = "es", toLanguage = "en"),
)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateStateChangeAction(
tabId = tab.id,
translationEngineState = translatedEngineState,
),
)
assertFalse(tabState().translationsState.isOfferTranslate)
// Engine is sending a translation offer action
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateOfferAction(tabId = tab.id, isOfferTranslate = true),
)
// Initial expected translation state
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateStateChangeAction(
tabId = tab.id,
translationEngineState = translatedEngineState,
),
)
assertTrue(tabState().translationsState.isOfferTranslate)
// Not in an offer translation state, because it is no longer supported
translatedEngineState =
TranslationEngineState(
detectedLanguages =
DetectedLanguages(
documentLangTag = "es",
supportedDocumentLang = false,
userPreferredLangTag = "en",
),
error = null,
isEngineReady = true,
requestedTranslationPair = TranslationPair(fromLanguage = "es", toLanguage = "en"),
)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateStateChangeAction(
tabId = tab.id,
translationEngineState = translatedEngineState,
),
)
assertFalse(tabState().translationsState.isOfferTranslate)
}
@Test
fun `WHEN a TranslateStateChangeAction is dispatched THEN the translationError status updates accordingly`() {
// Initial State
assertNull(tabState().translationsState.translationEngineState)
assertNull(tabState().translationsState.translationError)
// Sending an initial request to set state, notice the supportedDocumentLang isn't supported
val noSupportedState =
TranslationEngineState(
detectedLanguages =
DetectedLanguages(
documentLangTag = "unknown",
supportedDocumentLang = false,
userPreferredLangTag = "en",
),
error = null,
isEngineReady = true,
requestedTranslationPair = null,
)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateStateChangeAction(
tabId = tab.id,
translationEngineState = noSupportedState,
),
)
// Response state
assertEquals(noSupportedState, tabState().translationsState.translationEngineState)
assertNotNull(tabState().translationsState.translationError)
// Sending a request to show state change, notice the supportedDocumentLang is now supported
val supportedState =
TranslationEngineState(
detectedLanguages =
DetectedLanguages(
documentLangTag = "es",
supportedDocumentLang = true,
userPreferredLangTag = "en",
),
error = null,
isEngineReady = true,
requestedTranslationPair = null,
)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateStateChangeAction(
tabId = tab.id,
translationEngineState = supportedState,
),
)
// Response state
assertEquals(supportedState, tabState().translationsState.translationEngineState)
assertNull(tabState().translationsState.translationError)
}
@Test
fun `WHEN a TranslateAction is dispatched AND successful THEN update translation processing status`() {
// Initial
assertEquals(false, tabState().translationsState.isTranslateProcessing)
// Action started
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateAction(tabId = tab.id, "en", "es", null),
)
assertEquals(true, tabState().translationsState.isTranslateProcessing)
// Action success
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateSuccessAction(
tabId = tab.id,
operation = TranslationOperation.TRANSLATE,
),
)
assertEquals(null, tabState().translationsState.translationError)
}
@Test
fun `WHEN a TranslateAction is dispatched AND fails THEN update translation processing status`() {
// Initial
assertEquals(false, tabState().translationsState.isTranslateProcessing)
// Action started
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateAction(tabId = tab.id, "en", "es", null),
)
assertEquals(true, tabState().translationsState.isTranslateProcessing)
// Action failure
val error = TranslationError.UnknownError(Exception())
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateExceptionAction(
tabId = tab.id,
operation = TranslationOperation.TRANSLATE,
error,
),
)
assertEquals(false, tabState().translationsState.isTranslateProcessing)
assertEquals(false, tabState().translationsState.isTranslated)
assertEquals(error, tabState().translationsState.translationError)
}
@Test
fun `WHEN a TranslateRestoreAction is dispatched AND successful THEN update translation processing status`() {
// Initial
assertEquals(false, tabState().translationsState.isRestoreProcessing)
// Action started
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateRestoreAction(tabId = tab.id),
)
assertEquals(true, tabState().translationsState.isRestoreProcessing)
// Action success
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateSuccessAction(
tabId = tab.id,
operation = TranslationOperation.RESTORE,
),
)
assertEquals(false, tabState().translationsState.isRestoreProcessing)
assertEquals(false, tabState().translationsState.isTranslated)
assertEquals(null, tabState().translationsState.translationError)
}
@Test
fun `WHEN a TranslateRestoreAction is dispatched AND fails THEN update translation processing status`() {
// Initial
assertEquals(false, tabState().translationsState.isRestoreProcessing)
// Action started
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateRestoreAction(tabId = tab.id),
)
assertEquals(true, tabState().translationsState.isRestoreProcessing)
// Action failure
val error = TranslationError.UnknownError(Exception())
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateExceptionAction(
tabId = tab.id,
operation = TranslationOperation.RESTORE,
error,
),
)
assertEquals(false, tabState().translationsState.isRestoreProcessing)
assertEquals(false, tabState().translationsState.isTranslated)
assertEquals(error, tabState().translationsState.translationError)
}
@Test
fun `WHEN a SetSupportedLanguagesAction is dispatched AND successful THEN update supportedLanguages`() {
// Initial
assertNull(state.translationEngine.supportedLanguages)
// Action started
val toLanguage = Language("de", "German")
val fromLanguage = Language("es", "Spanish")
val supportedLanguages = TranslationSupport(listOf(fromLanguage), listOf(toLanguage))
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.SetSupportedLanguagesAction(supportedLanguages = supportedLanguages),
)
// Action success
assertEquals(supportedLanguages, state.translationEngine.supportedLanguages)
}
@Test
fun `WHEN a SetNeverTranslateSitesAction is dispatched AND successful THEN update neverTranslateSites`() {
// Initial
assertNull(state.translationEngine.neverTranslateSites)
// Action started
val neverTranslateSites = listOf("google.com")
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.SetNeverTranslateSitesAction(neverTranslateSites = neverTranslateSites),
)
// Action success
assertEquals(neverTranslateSites, state.translationEngine.neverTranslateSites)
}
@Test
fun `WHEN a RemoveNeverTranslateSiteAction is dispatched AND successful THEN update neverTranslateSites`() {
// Initial add to neverTranslateSites
assertNull(state.translationEngine.neverTranslateSites)
val neverTranslateSites = listOf("google.com")
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.SetNeverTranslateSitesAction(neverTranslateSites = neverTranslateSites),
)
assertEquals(neverTranslateSites, state.translationEngine.neverTranslateSites)
// Action started
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.RemoveNeverTranslateSiteAction(origin = "google.com"),
)
// Action success
assertEquals(listOf<String>(), state.translationEngine.neverTranslateSites)
}
@Test
fun `WHEN a TranslateExceptionAction is dispatched due to an error THEN update the error condition according to the operation`() {
// Initial state
assertEquals(null, tabState().translationsState.translationError)
assertFalse(tabState().translationsState.isTranslateProcessing)
// Set an initial state for is translate processing via a translation request:
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateAction(tabId = tab.id, "en", "es", null),
)
assertTrue(tabState().translationsState.isTranslateProcessing)
// TRANSLATE usage
val translateError = TranslationError.CouldNotLoadLanguagesError(null)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateExceptionAction(
tabId = tab.id,
operation = TranslationOperation.TRANSLATE,
translationError = translateError,
),
)
assertEquals(translateError, tabState().translationsState.translationError)
// A translate error should clear this state
assertFalse(tabState().translationsState.isTranslateProcessing)
// RESTORE usage
val restoreError = TranslationError.CouldNotRestoreError(null)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateExceptionAction(
tabId = tab.id,
operation = TranslationOperation.RESTORE,
translationError = restoreError,
),
)
assertEquals(restoreError, tabState().translationsState.translationError)
// FETCH_LANGUAGES usage
val fetchLanguagesError = TranslationError.CouldNotLoadLanguagesError(null)
// Testing setting tab level error
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateExceptionAction(
tabId = tab.id,
operation = TranslationOperation.FETCH_SUPPORTED_LANGUAGES,
translationError = fetchLanguagesError,
),
)
assertEquals(fetchLanguagesError, tabState().translationsState.translationError)
// Testing setting browser level error
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.EngineExceptionAction(error = fetchLanguagesError),
)
assertEquals(fetchLanguagesError, state.translationEngine.engineError)
}
@Test
fun `WHEN a TranslateSuccessAction is dispatched THEN update the condition according to the operation`() {
// Initial state
assertEquals(null, tabState().translationsState.translationError)
assertEquals(false, tabState().translationsState.isTranslated)
assertEquals(false, tabState().translationsState.isTranslateProcessing)
// TRANSLATE usage
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateSuccessAction(
tabId = tab.id,
operation = TranslationOperation.TRANSLATE,
),
)
assertEquals(null, tabState().translationsState.translationError)
assertEquals(false, tabState().translationsState.isTranslateProcessing)
// RESTORE usage
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateSuccessAction(
tabId = tab.id,
operation = TranslationOperation.RESTORE,
),
)
assertEquals(null, tabState().translationsState.translationError)
assertEquals(false, tabState().translationsState.isTranslated)
assertEquals(false, tabState().translationsState.isRestoreProcessing)
// FETCH_LANGUAGES usage
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateSuccessAction(
tabId = tab.id,
operation = TranslationOperation.FETCH_SUPPORTED_LANGUAGES,
),
)
assertEquals(null, tabState().translationsState.translationError)
assertEquals(false, tabState().translationsState.isTranslated)
}
@Test
fun `WHEN a SetPageSettingsAction is dispatched THEN set pageSettings`() {
// Initial
assertNull(tabState().translationsState.pageSettings)
// Action started
val pageSettings =
TranslationPageSettings(
alwaysOfferPopup = true,
alwaysTranslateLanguage = true,
neverTranslateLanguage = true,
neverTranslateSite = true,
)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.SetPageSettingsAction(
tabId = tab.id,
pageSettings = pageSettings,
),
)
// Action success
assertEquals(pageSettings, tabState().translationsState.pageSettings)
}
@Test
fun `WHEN a SetTranslateProcessingAction is dispatched THEN set isTranslateProcessing`() {
// Initial
assertFalse(tabState().translationsState.isTranslateProcessing)
// Action started
val isProcessing = true
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.SetTranslateProcessingAction(
tabId = tab.id,
isProcessing = isProcessing,
),
)
// Action success
assertEquals(isProcessing, tabState().translationsState.isTranslateProcessing)
}
@Test
fun `WHEN a SetTranslationDownloadSize is dispatched THEN set translationSize is set`() {
// Initial
assertNull(tabState().translationsState.translationDownloadSize)
// Action started
val translationSize =
TranslationDownloadSize(
fromLanguage = Language("en", "English"),
toLanguage = Language("fr", "French"),
size = 10000L,
error = null,
)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.SetTranslationDownloadSizeAction(
tabId = tab.id,
translationSize = translationSize,
),
)
// Action success
assertEquals(translationSize, tabState().translationsState.translationDownloadSize)
}
@Test
fun `WHEN a FetchTranslationDownloadSize is dispatched THEN translationSize is cleared`() {
// Initial setting size for a more robust test
val translationSize =
TranslationDownloadSize(
fromLanguage = Language("en", "English"),
toLanguage = Language("fr", "French"),
size = 10000L,
error = null,
)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.SetTranslationDownloadSizeAction(
tabId = tab.id,
translationSize = translationSize,
),
)
assertEquals(translationSize, tabState().translationsState.translationDownloadSize)
// Action started
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.FetchTranslationDownloadSizeAction(
tabId = tab.id,
fromLanguage = Language("en", "English"),
toLanguage = Language("fr", "French"),
),
)
// Action success
assertNull(tabState().translationsState.translationDownloadSize)
}
@Test
fun `WHEN a OperationRequestedAction is dispatched for FETCH_PAGE_SETTINGS THEN clear pageSettings`() {
// Setting first to have a more robust initial state
assertNull(tabState().translationsState.pageSettings)
val pageSettings =
TranslationPageSettings(
alwaysOfferPopup = true,
alwaysTranslateLanguage = true,
neverTranslateLanguage = true,
neverTranslateSite = true,
)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.SetPageSettingsAction(
tabId = tab.id,
pageSettings = pageSettings,
),
)
assertEquals(pageSettings, tabState().translationsState.pageSettings)
assertNull(tabState().translationsState.settingsError)
// Action started
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.OperationRequestedAction(
tabId = tab.id,
operation = TranslationOperation.FETCH_PAGE_SETTINGS,
),
)
// Action success
assertNull(tabState().translationsState.pageSettings)
}
@Test
fun `WHEN a OperationRequestedAction is dispatched for FETCH_SUPPORTED_LANGUAGES THEN clear supportLanguages`() {
// Setting first to have a more robust initial state
assertNull(state.translationEngine.supportedLanguages)
val supportLanguages =
TranslationSupport(
fromLanguages = listOf(Language("en", "English")),
toLanguages = listOf(Language("en", "English")),
)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.SetSupportedLanguagesAction(supportedLanguages = supportLanguages),
)
assertEquals(supportLanguages, state.translationEngine.supportedLanguages)
// Action started
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.OperationRequestedAction(
tabId = tab.id,
operation = TranslationOperation.FETCH_SUPPORTED_LANGUAGES,
),
)
// Action success
assertNull(state.translationEngine.supportedLanguages)
}
@Test
fun `WHEN a UpdatePageSettingAction is dispatched for UPDATE_ALWAYS_OFFER_POPUP THEN set page settings for alwaysOfferPopup `() {
// Initial State
assertNull(tabState().translationsState.pageSettings?.alwaysOfferPopup)
// Action started
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.UpdatePageSettingAction(
tabId = tab.id,
operation = TranslationPageSettingOperation.UPDATE_ALWAYS_OFFER_POPUP,
setting = true,
),
)
// Action success
assertTrue(tabState().translationsState.pageSettings?.alwaysOfferPopup!!)
}
@Test
fun `WHEN a UpdatePageSettingAction is dispatched for UPDATE_ALWAYS_TRANSLATE_LANGUAGE THEN set page settings for alwaysTranslateLanguage `() {
// Initial State
assertNull(tabState().translationsState.pageSettings?.alwaysTranslateLanguage)
assertNull(tabState().translationsState.pageSettings?.neverTranslateLanguage)
// Action started
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.UpdatePageSettingAction(
tabId = tab.id,
operation = TranslationPageSettingOperation.UPDATE_ALWAYS_TRANSLATE_LANGUAGE,
setting = true,
),
)
// Action success
assertTrue(tabState().translationsState.pageSettings?.alwaysTranslateLanguage!!)
assertFalse(tabState().translationsState.pageSettings?.neverTranslateLanguage!!)
}
@Test
fun `WHEN a UpdatePageSettingAction is dispatched for UPDATE_NEVER_TRANSLATE_LANGUAGE THEN set page settings for alwaysTranslateLanguage `() {
// Initial State
assertNull(tabState().translationsState.pageSettings?.neverTranslateLanguage)
assertNull(tabState().translationsState.pageSettings?.alwaysTranslateLanguage)
// Action started
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.UpdatePageSettingAction(
tabId = tab.id,
operation = TranslationPageSettingOperation.UPDATE_NEVER_TRANSLATE_LANGUAGE,
setting = true,
),
)
// Action success
assertTrue(tabState().translationsState.pageSettings?.neverTranslateLanguage!!)
assertFalse(tabState().translationsState.pageSettings?.alwaysTranslateLanguage!!)
}
@Test
fun `WHEN a UpdatePageSettingAction is dispatched for UPDATE_NEVER_TRANSLATE_SITE THEN set page settings for neverTranslateSite`() {
// Initial State
assertNull(tabState().translationsState.pageSettings?.neverTranslateLanguage)
// Action started
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.UpdatePageSettingAction(
tabId = tab.id,
operation = TranslationPageSettingOperation.UPDATE_NEVER_TRANSLATE_SITE,
setting = true,
),
)
// Action success
assertTrue(tabState().translationsState.pageSettings?.neverTranslateSite!!)
}
@Test
fun `WHEN an UpdatePageSettingAction is dispatched for UPDATE_ALWAYS_TRANSLATE_LANGUAGE AND UPDATE_ALWAYS_TRANSLATE_LANGUAGE THEN must be opposites of each other or both must be false `() {
// Initial state
assertNull(tabState().translationsState.pageSettings?.alwaysTranslateLanguage)
assertNull(tabState().translationsState.pageSettings?.neverTranslateLanguage)
// Action started to update the always offer setting to true
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.UpdatePageSettingAction(
tabId = tab.id,
operation = TranslationPageSettingOperation.UPDATE_ALWAYS_TRANSLATE_LANGUAGE,
setting = true,
),
)
// When always is true, never should be false
assertTrue(tabState().translationsState.pageSettings?.alwaysTranslateLanguage!!)
assertFalse(tabState().translationsState.pageSettings?.neverTranslateLanguage!!)
// Action started to update the never offer setting to true
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.UpdatePageSettingAction(
tabId = tab.id,
operation = TranslationPageSettingOperation.UPDATE_NEVER_TRANSLATE_LANGUAGE,
setting = true,
),
)
// When never is true, always should be false
assertFalse(tabState().translationsState.pageSettings?.alwaysTranslateLanguage!!)
assertTrue(tabState().translationsState.pageSettings?.neverTranslateLanguage!!)
// Action started to update the never language setting to false
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.UpdatePageSettingAction(
tabId = tab.id,
operation = TranslationPageSettingOperation.UPDATE_NEVER_TRANSLATE_LANGUAGE,
setting = false,
),
)
// When never is false, always may also be false
assertFalse(tabState().translationsState.pageSettings?.alwaysTranslateLanguage!!)
assertFalse(tabState().translationsState.pageSettings?.neverTranslateLanguage!!)
}
@Test
fun `WHEN a UpdatePageSettingAction is dispatched for each option THEN the page setting is consistent`() {
// Initial State
assertNull(tabState().translationsState.pageSettings?.alwaysOfferPopup)
assertNull(tabState().translationsState.pageSettings?.alwaysTranslateLanguage)
assertNull(tabState().translationsState.pageSettings?.neverTranslateLanguage)
assertNull(tabState().translationsState.pageSettings?.neverTranslateSite)
// Action started
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.UpdatePageSettingAction(
tabId = tab.id,
operation = TranslationPageSettingOperation.UPDATE_ALWAYS_OFFER_POPUP,
setting = true,
),
)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.UpdatePageSettingAction(
tabId = tab.id,
operation = TranslationPageSettingOperation.UPDATE_ALWAYS_TRANSLATE_LANGUAGE,
setting = true,
),
)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.UpdatePageSettingAction(
tabId = tab.id,
operation = TranslationPageSettingOperation.UPDATE_NEVER_TRANSLATE_LANGUAGE,
setting = true,
),
)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.UpdatePageSettingAction(
tabId = tab.id,
operation = TranslationPageSettingOperation.UPDATE_NEVER_TRANSLATE_SITE,
setting = true,
),
)
// Action success
assertTrue(tabState().translationsState.pageSettings?.alwaysOfferPopup!!)
// neverTranslateLanguage was posted last and will prevent a contradictory state on the alwaysTranslateLanguage
// state.
assertFalse(tabState().translationsState.pageSettings?.alwaysTranslateLanguage!!)
assertTrue(tabState().translationsState.pageSettings?.neverTranslateLanguage!!)
assertTrue(tabState().translationsState.pageSettings?.neverTranslateSite!!)
}
@Test
fun `WHEN a SetLanguageSettingsAction is dispatched THEN the browser store is updated to match`() {
// Initial state
assertNull(state.translationEngine.languageSettings)
// Dispatch
val languageSetting = mapOf("es" to LanguageSetting.OFFER)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.SetLanguageSettingsAction(languageSettings = languageSetting),
)
// Final state
assertEquals(state.translationEngine.languageSettings!!, languageSetting)
}
@Test
fun `WHEN a OperationRequestedAction is dispatched for FETCH_AUTOMATIC_LANGUAGE_SETTINGS THEN clear languageSettings`() {
// Setting first to have a more robust initial state
val languageSetting = mapOf("es" to LanguageSetting.OFFER)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.SetLanguageSettingsAction(languageSettings = languageSetting),
)
assertEquals(state.translationEngine.languageSettings, languageSetting)
// Action started
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.OperationRequestedAction(
tabId = tab.id,
operation = TranslationOperation.FETCH_AUTOMATIC_LANGUAGE_SETTINGS,
),
)
// Action success
assertNull(state.translationEngine.languageSettings)
}
@Test
fun `WHEN a TranslateExceptionAction is dispatched for FETCH_AUTOMATIC_LANGUAGE_SETTINGS THEN set the error`() {
// Action started
val error = TranslationError.UnknownError(IllegalStateException())
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateExceptionAction(
tabId = tab.id,
operation = TranslationOperation.FETCH_AUTOMATIC_LANGUAGE_SETTINGS,
translationError = error,
),
)
// Action success
assertEquals(error, tabState().translationsState.translationError)
}
@Test
fun `WHEN a SetTranslationsEnabledAction is dispatched THEN the browser store is updated to match`() {
// Initial state
assertTrue(state.translationEngine.isTranslationsEnabled)
// Dispatch
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.SetTranslationsEnabledAction(isTranslationsEnabled = false),
)
// Final state
assertFalse(state.translationEngine.isTranslationsEnabled)
}
@Test
fun `WHEN a SetTranslationsEnabledAction is dispatched with false THEN both the browser and session translation stores are cleared`() {
val fromLanguage = Language("en", "English")
val toLanguage = Language("es", "Spanish")
val supportedLanguages = TranslationSupport(listOf(fromLanguage), listOf(toLanguage))
// Set up populated browser store state
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.SetSupportedLanguagesAction(supportedLanguages = supportedLanguages),
)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.SetEngineSupportedAction(isEngineSupported = true),
)
// Set up populated session store state
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.TranslateExpectedAction(tabId = tab.id),
)
// Verify initial populated state
assertEquals(supportedLanguages, state.translationEngine.supportedLanguages)
assertTrue(tabState().translationsState.isExpectedTranslate)
// Turn off translations
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.SetTranslationsEnabledAction(isTranslationsEnabled = false),
)
// Browser store is cleared and disabled
assertFalse(state.translationEngine.isTranslationsEnabled)
assertNull(state.translationEngine.supportedLanguages)
assertNull(state.translationEngine.languageModels)
assertNull(state.translationEngine.languageSettings)
assertNull(state.translationEngine.neverTranslateSites)
// isEngineSupported is kept
assertTrue(state.translationEngine.isEngineSupported!!)
// Session store is cleared
assertFalse(tabState().translationsState.isExpectedTranslate)
assertFalse(tabState().translationsState.isTranslated)
assertNull(tabState().translationsState.translationEngineState)
assertNull(tabState().translationsState.pageSettings)
}
@Test
fun `WHEN a SetEngineSupportAction is dispatched THEN the browser store is updated to match`() {
// Initial state
assertNull(state.translationEngine.isEngineSupported)
// Dispatch
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.SetEngineSupportedAction(isEngineSupported = true),
)
// Final state
assertTrue(state.translationEngine.isEngineSupported!!)
}
@Test
fun `WHEN an EngineExceptionAction is dispatched THEN the browser store is updated to match`() {
// Initial state
assertNull(state.translationEngine.engineError)
// Dispatch
val error = TranslationError.UnknownError(Throwable())
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.EngineExceptionAction(error = error),
)
// Final state
assertEquals(state.translationEngine.engineError!!, error)
}
@Test
fun `WHEN a SetLanguageModelsAction is dispatched and successful THEN the browser store is updated to match`() {
// Initial state
assertNull(state.translationEngine.languageModels)
val code = "es"
val localizedDisplayName = "Spanish"
val downloaded = ModelState.DOWNLOADED
val size: Long = 1234
val language = Language(code, localizedDisplayName)
val languageModel = LanguageModel(language, downloaded, size)
val languageModels = mutableListOf(languageModel)
// Dispatch
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.SetLanguageModelsAction(languageModels = languageModels),
)
// Final state
assertEquals(languageModels, state.translationEngine.languageModels)
}
@Test
fun `WHEN a ManageLanguageModelsAction is dispatched and successful THEN the browser store is updated to match`() {
// Initial state
assertNull(state.translationEngine.languageModels)
// Test Operation
val options =
ModelManagementOptions(
languageToManage = "es",
operation = ModelOperation.DOWNLOAD,
operationLevel = OperationLevel.LANGUAGE,
)
// Dispatch a request when state is not setup
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.ManageLanguageModelsAction(options = options),
)
// We don't have an initial state, so nothing should change.
assertNull(state.translationEngine.languageModels)
// Setting up an initial test state.
val code = "es"
val localizedDisplayName = "Spanish"
val processState = ModelState.NOT_DOWNLOADED
val size: Long = 1234
val language = Language(code, localizedDisplayName)
val languageModel = LanguageModel(language, processState, size)
val languageModels = mutableListOf(languageModel)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.SetLanguageModelsAction(languageModels = languageModels),
)
// Dispatch a valid request
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.ManageLanguageModelsAction(options = options),
)
// Expectations based on operation
val expectedLanguageModel = LanguageModel(language, ModelState.DOWNLOAD_IN_PROGRESS, size)
val expectedLanguageModels = mutableListOf(expectedLanguageModel)
assertEquals(expectedLanguageModels, state.translationEngine.languageModels)
// Dispatch a language not listed
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.ManageLanguageModelsAction(
options =
ModelManagementOptions(
languageToManage = "de",
operation = ModelOperation.DOWNLOAD,
operationLevel = OperationLevel.LANGUAGE,
)
),
)
// Nothing should change, since it isn't a known option
assertEquals(expectedLanguageModels, state.translationEngine.languageModels)
}
@Test
fun `WHEN SetOfferTranslateSettingAction is called then set offerToTranslate`() {
// Initial State
assertNull(state.translationEngine.offerTranslation)
// Action started
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.SetGlobalOfferTranslateSettingAction(offerTranslation = false),
)
// Action success
assertFalse(state.translationEngine.offerTranslation!!)
}
@Test
fun `WHEN UpdateOfferTranslateSettingAction is called then set offerToTranslate`() {
// Initial State
assertNull(state.translationEngine.offerTranslation)
// Action started
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.UpdateGlobalOfferTranslateSettingAction(offerTranslation = false),
)
// Action success
assertFalse(state.translationEngine.offerTranslation!!)
}
@Test
fun `WHEN UpdateGlobalLanguageSettingAction is called then update languageSettings`() {
// Initial State
assertNull(state.translationEngine.languageSettings)
// No-op null test
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.UpdateLanguageSettingsAction(
languageCode = "fr",
setting = LanguageSetting.ALWAYS,
),
)
assertNull(state.translationEngine.languageSettings)
// Setting Initial State
val languageSettings =
mapOf<String, LanguageSetting>(
"en" to LanguageSetting.OFFER,
"es" to LanguageSetting.NEVER,
"de" to LanguageSetting.ALWAYS,
)
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.SetLanguageSettingsAction(languageSettings = languageSettings),
)
assertEquals(languageSettings, state.translationEngine.languageSettings)
// No-op update test
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.UpdateLanguageSettingsAction(
languageCode = "fr",
setting = LanguageSetting.ALWAYS,
),
)
assertEquals(languageSettings, state.translationEngine.languageSettings)
// Main action started
state =
BrowserStateReducer.reduce(
state,
TranslationsAction.UpdateLanguageSettingsAction(
languageCode = "es",
setting = LanguageSetting.ALWAYS,
),
)
// Action success
assertEquals(LanguageSetting.ALWAYS, state.translationEngine.languageSettings!!["es"])
}
}