Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: Java; c-basic-offset: 4; tab-width: 4; indent-tabs-mode: nil; -*-
* Any copyright is dedicated to the Public Domain.
package org.mozilla.geckoview.test
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.filters.LargeTest
import androidx.test.filters.MediumTest
import junit.framework.TestCase.assertTrue
import org.hamcrest.Matchers.closeTo
import org.hamcrest.Matchers.endsWith
import org.hamcrest.Matchers.equalTo
import org.hamcrest.Matchers.greaterThan
import org.hamcrest.Matchers.greaterThanOrEqualTo
import org.hamcrest.Matchers.lessThan
import org.hamcrest.Matchers.lessThanOrEqualTo
import org.hamcrest.Matchers.notNullValue
import org.json.JSONObject
import org.junit.Assume.assumeThat
import org.junit.Test
import org.junit.runner.RunWith
import org.mozilla.geckoview.GeckoSession
import org.mozilla.geckoview.GeckoSession.NavigationDelegate
import org.mozilla.geckoview.GeckoSession.PermissionDelegate.ContentPermission
import org.mozilla.geckoview.GeckoSession.ProgressDelegate
import org.mozilla.geckoview.test.rule.GeckoSessionTestRule.AssertCalled
import org.mozilla.geckoview.test.rule.GeckoSessionTestRule.NullDelegate
import org.mozilla.geckoview.test.rule.GeckoSessionTestRule.WithDisplay
@RunWith(AndroidJUnit4::class)
@MediumTest
class ProgressDelegateTest : BaseSessionTest() {
fun testProgress(path: String) {
mainSession.loadTestPath(path)
sessionRule.waitForPageStop()
var counter = 0
var lastProgress = -1
sessionRule.forCallbacksDuringWait(object :
ProgressDelegate,
NavigationDelegate {
@AssertCalled
override fun onLocationChange(session: GeckoSession, url: String?, perms: MutableList<ContentPermission>, hasUserGesture: Boolean) {
assertThat("LocationChange is called", url, endsWith(path))
}
@AssertCalled
override fun onProgressChange(session: GeckoSession, progress: Int) {
assertThat(
"Progress must be strictly increasing",
progress,
greaterThan(lastProgress),
)
lastProgress = progress
counter++
}
@AssertCalled
override fun onPageStart(session: GeckoSession, url: String) {
assertThat("PageStart is called", url, endsWith(path))
}
@AssertCalled
override fun onPageStop(session: GeckoSession, success: Boolean) {
assertThat("PageStop is called", success, equalTo(true))
}
})
assertThat(
"Callback should be called at least twice",
counter,
greaterThanOrEqualTo(2),
)
assertThat(
"Last progress value should be 100",
lastProgress,
equalTo(100),
)
}
@Test fun loadProgress() {
testProgress(HELLO_HTML_PATH)
// Test that loading the same path again still
// results in the right progress events
testProgress(HELLO_HTML_PATH)
// Test that calling a different path works too
testProgress(HELLO2_HTML_PATH)
}
@Test fun load() {
mainSession.loadTestPath(HELLO_HTML_PATH)
sessionRule.waitForPageStop()
sessionRule.forCallbacksDuringWait(object : ProgressDelegate {
@AssertCalled(count = 1, order = [1])
override fun onPageStart(session: GeckoSession, url: String) {
assertThat("Session should not be null", session, notNullValue())
assertThat("URL should not be null", url, notNullValue())
assertThat("URL should match", url, endsWith(HELLO_HTML_PATH))
}
@AssertCalled(count = 1, order = [2])
override fun onSecurityChange(
session: GeckoSession,
securityInfo: GeckoSession.ProgressDelegate.SecurityInformation,
) {
assertThat("Session should not be null", session, notNullValue())
assertThat("Security info should not be null", securityInfo, notNullValue())
assertThat("Should not be secure", securityInfo.isSecure, equalTo(false))
}
@AssertCalled(count = 1, order = [3])
override fun onPageStop(session: GeckoSession, success: Boolean) {
assertThat("Session should not be null", session, notNullValue())
assertThat("Load should succeed", success, equalTo(true))
}
})
}
@Test
fun multipleLoads() {
mainSession.loadUri(UNKNOWN_HOST_URI)
mainSession.loadTestPath(HELLO_HTML_PATH)
sessionRule.waitForPageStops(2)
sessionRule.forCallbacksDuringWait(object : ProgressDelegate {
@AssertCalled(count = 2, order = [1, 3])
override fun onPageStart(session: GeckoSession, url: String) {
assertThat(
"URL should match",
url,
endsWith(forEachCall(UNKNOWN_HOST_URI, HELLO_HTML_PATH)),
)
}
@AssertCalled(count = 2, order = [2, 4])
override fun onPageStop(session: GeckoSession, success: Boolean) {
// The first load is certain to fail because of interruption by the second load
// or by invalid domain name, whereas the second load is certain to succeed.
assertThat(
"Success flag should match",
success,
equalTo(forEachCall(false, true)),
)
}
})
}
@Test fun reload() {
mainSession.loadTestPath(HELLO_HTML_PATH)
sessionRule.waitForPageStop()
mainSession.reload()
sessionRule.waitForPageStop()
sessionRule.forCallbacksDuringWait(object : ProgressDelegate {
@AssertCalled(count = 1, order = [1])
override fun onPageStart(session: GeckoSession, url: String) {
assertThat("URL should match", url, endsWith(HELLO_HTML_PATH))
}
@AssertCalled(count = 1, order = [2])
override fun onSecurityChange(
session: GeckoSession,
securityInfo: GeckoSession.ProgressDelegate.SecurityInformation,
) {
}
@AssertCalled(count = 1, order = [3])
override fun onPageStop(session: GeckoSession, success: Boolean) {
assertThat("Load should succeed", success, equalTo(true))
}
})
}
@Test fun goBackAndForward() {
mainSession.loadTestPath(HELLO_HTML_PATH)
sessionRule.waitForPageStop()
mainSession.loadTestPath(HELLO2_HTML_PATH)
sessionRule.waitForPageStop()
mainSession.goBack()
sessionRule.waitForPageStop()
sessionRule.forCallbacksDuringWait(object : ProgressDelegate {
@AssertCalled(count = 1, order = [1])
override fun onPageStart(session: GeckoSession, url: String) {
assertThat("URL should match", url, endsWith(HELLO_HTML_PATH))
}
@AssertCalled(count = 1, order = [2])
override fun onSecurityChange(
session: GeckoSession,
securityInfo: GeckoSession.ProgressDelegate.SecurityInformation,
) {
}
@AssertCalled(count = 1, order = [3])
override fun onPageStop(session: GeckoSession, success: Boolean) {
assertThat("Load should succeed", success, equalTo(true))
}
})
mainSession.goForward()
sessionRule.waitForPageStop()
sessionRule.forCallbacksDuringWait(object : ProgressDelegate {
@AssertCalled(count = 1, order = [1])
override fun onPageStart(session: GeckoSession, url: String) {
assertThat("URL should match", url, endsWith(HELLO2_HTML_PATH))
}
@AssertCalled(count = 1, order = [2])
override fun onSecurityChange(
session: GeckoSession,
securityInfo: GeckoSession.ProgressDelegate.SecurityInformation,
) {
}
@AssertCalled(count = 1, order = [3])
override fun onPageStop(session: GeckoSession, success: Boolean) {
assertThat("Load should succeed", success, equalTo(true))
}
})
}
@Test fun correctSecurityInfoForValidTLS_automation() {
assumeThat(sessionRule.env.isAutomation, equalTo(true))
sessionRule.waitForPageStop()
sessionRule.forCallbacksDuringWait(object : ProgressDelegate {
@AssertCalled(count = 1)
override fun onSecurityChange(
session: GeckoSession,
securityInfo: GeckoSession.ProgressDelegate.SecurityInformation,
) {
assertThat(
"Should be secure",
securityInfo.isSecure,
equalTo(true),
)
assertThat(
"Should not be exception",
securityInfo.isException,
equalTo(false),
)
assertThat(
"Origin should match",
securityInfo.origin,
)
assertThat(
"Host should match",
securityInfo.host,
equalTo("example.com"),
)
assertThat(
"Subject should match",
securityInfo.certificate?.subjectX500Principal?.name,
equalTo("CN=example.com"),
)
assertThat(
"Issuer should match",
securityInfo.certificate?.issuerX500Principal?.name,
equalTo("OU=Profile Guided Optimization,O=Mozilla Testing,CN=Temporary Certificate Authority"),
)
assertThat(
"Security mode should match",
securityInfo.securityMode,
equalTo(GeckoSession.ProgressDelegate.SecurityInformation.SECURITY_MODE_IDENTIFIED),
)
assertThat(
"Active mixed mode should match",
securityInfo.mixedModeActive,
equalTo(GeckoSession.ProgressDelegate.SecurityInformation.CONTENT_UNKNOWN),
)
assertThat(
"Passive mixed mode should match",
securityInfo.mixedModePassive,
equalTo(GeckoSession.ProgressDelegate.SecurityInformation.CONTENT_UNKNOWN),
)
}
})
}
@LargeTest
@Test
fun correctSecurityInfoForValidTLS_local() {
assumeThat(sessionRule.env.isAutomation, equalTo(false))
sessionRule.waitForPageStop()
sessionRule.forCallbacksDuringWait(object : ProgressDelegate {
@AssertCalled(count = 1)
override fun onSecurityChange(
session: GeckoSession,
securityInfo: GeckoSession.ProgressDelegate.SecurityInformation,
) {
assertThat(
"Should be secure",
securityInfo.isSecure,
equalTo(true),
)
assertThat(
"Should not be exception",
securityInfo.isException,
equalTo(false),
)
assertThat(
"Origin should match",
securityInfo.origin,
)
assertThat(
"Host should match",
securityInfo.host,
equalTo("mozilla-modern.badssl.com"),
)
assertThat(
"Subject should match",
securityInfo.certificate?.subjectX500Principal?.name,
equalTo("CN=*.badssl.com,O=Lucas Garron,L=Walnut Creek,ST=California,C=US"),
)
assertThat(
"Issuer should match",
securityInfo.certificate?.issuerX500Principal?.name,
equalTo("CN=DigiCert SHA2 Secure Server CA,O=DigiCert Inc,C=US"),
)
assertThat(
"Security mode should match",
securityInfo.securityMode,
equalTo(GeckoSession.ProgressDelegate.SecurityInformation.SECURITY_MODE_IDENTIFIED),
)
assertThat(
"Active mixed mode should match",
securityInfo.mixedModeActive,
equalTo(GeckoSession.ProgressDelegate.SecurityInformation.CONTENT_UNKNOWN),
)
assertThat(
"Passive mixed mode should match",
securityInfo.mixedModePassive,
equalTo(GeckoSession.ProgressDelegate.SecurityInformation.CONTENT_UNKNOWN),
)
}
})
}
@LargeTest
@Test
fun noSecurityInfoForExpiredTLS() {
mainSession.loadUri(
if (sessionRule.env.isAutomation) {
} else {
},
)
sessionRule.waitForPageStop()
sessionRule.forCallbacksDuringWait(object : ProgressDelegate {
@AssertCalled(count = 1)
override fun onPageStop(session: GeckoSession, success: Boolean) {
assertThat("Load should fail", success, equalTo(false))
}
@AssertCalled(false)
override fun onSecurityChange(
session: GeckoSession,
securityInfo: GeckoSession.ProgressDelegate.SecurityInformation,
) {
}
})
}
val errorEpsilon = 0.1
private fun waitForScroll(offset: Double, timeout: Double, param: String) {
mainSession.evaluateJS(
"""
new Promise((resolve, reject) => {
const start = Date.now();
function step() {
if (window.visualViewport.$param >= ($offset - $errorEpsilon)) {
resolve();
} else if ($timeout < (Date.now() - start)) {
reject();
} else {
window.requestAnimationFrame(step);
}
}
window.requestAnimationFrame(step);
});
""".trimIndent(),
)
}
private fun waitForVerticalScroll(offset: Double, timeout: Double) {
waitForScroll(offset, timeout, "pageTop")
}
fun collectState(vararg uris: String): GeckoSession.SessionState {
for (uri in uris) {
mainSession.loadUri(uri)
sessionRule.waitForPageStop()
}
mainSession.evaluateJS("document.querySelector('#name').value = 'the name';")
mainSession.evaluateJS("document.querySelector('#name').dispatchEvent(new Event('input'));")
mainSession.evaluateJS("window.scrollBy(0, 100);")
waitForVerticalScroll(100.0, sessionRule.env.defaultTimeoutMillis.toDouble())
var savedState: GeckoSession.SessionState? = null
sessionRule.waitUntilCalled(object : ProgressDelegate {
@AssertCalled(count = 1)
override fun onSessionStateChange(session: GeckoSession, state: GeckoSession.SessionState) {
savedState = state
val serialized = state.toString()
val deserialized = GeckoSession.SessionState.fromString(serialized)
assertThat("Deserialized session state should match", deserialized, equalTo(state))
}
})
assertThat("State should not be null", savedState, notNullValue())
return savedState!!
}
@WithDisplay(width = 400, height = 400)
@Test
fun containsFormData() {
val startUri = createTestUrl(SAVE_STATE_PATH)
mainSession.loadUri(startUri)
sessionRule.waitForPageStop()
val formData = mainSession.containsFormData()
sessionRule.waitForResult(formData).let {
assertThat("There should be no form data", it, equalTo(false))
}
mainSession.evaluateJS("document.querySelector('#name').value = 'the name';")
mainSession.evaluateJS("document.querySelector('#name').dispatchEvent(new Event('input'));")
val formData2 = mainSession.containsFormData()
sessionRule.waitForResult(formData2).let {
assertThat("There should be form data", it, equalTo(true))
}
}
@WithDisplay(width = 400, height = 400)
@Test
fun saveAndRestoreStateNewSession() {
val helloUri = createTestUrl(HELLO_HTML_PATH)
val startUri = createTestUrl(SAVE_STATE_PATH)
val savedState = collectState(helloUri, startUri)
val session = sessionRule.createOpenSession()
session.addDisplay(400, 400)
session.restoreState(savedState)
session.waitForPageStop()
session.forCallbacksDuringWait(object : NavigationDelegate {
@AssertCalled
override fun onLocationChange(
session: GeckoSession,
url: String?,
perms: MutableList<ContentPermission>,
hasUserGesture: Boolean,
) {
assertThat("URI should match", url, equalTo(startUri))
}
})
/* TODO: Reenable when we have a workaround for ContentSessionStore not
saving in response to JS-driven formdata changes.
assertThat("'name' field should match",
mainSession.evaluateJS("$('#name').value").toString(),
equalTo("the name"))*/
assertThat(
"Scroll position should match",
session.evaluateJS("window.visualViewport.pageTop") as Double,
closeTo(100.0, .5),
)
session.goBack()
session.waitUntilCalled(object : NavigationDelegate {
override fun onLocationChange(session: GeckoSession, url: String?, perms: MutableList<ContentPermission>, hasUserGesture: Boolean) {
assertThat("History should be preserved", url, equalTo(helloUri))
}
})
}
@WithDisplay(width = 400, height = 400)
@Test
fun saveAndRestoreState() {
assumeThat(sessionRule.env.isX86, equalTo(false))
val startUri = createTestUrl(SAVE_STATE_PATH)
val savedState = collectState(startUri)
mainSession.loadUri("about:blank")
sessionRule.waitForPageStop()
mainSession.restoreState(savedState)
sessionRule.waitForPageStop()
sessionRule.forCallbacksDuringWait(object : NavigationDelegate {
@AssertCalled
override fun onLocationChange(session: GeckoSession, url: String?, perms: MutableList<ContentPermission>, hasUserGesture: Boolean) {
assertThat("URI should match", url, equalTo(startUri))
}
})
/* TODO: Reenable when we have a workaround for ContentSessionStore not
saving in response to JS-driven formdata changes.
assertThat("'name' field should match",
mainSession.evaluateJS("$('#name').value").toString(),
equalTo("the name"))*/
assertThat(
"Scroll position should match",
mainSession.evaluateJS("window.visualViewport.pageTop") as Double,
closeTo(100.0, .5),
)
}
@WithDisplay(width = 400, height = 400)
@Test
fun flushSessionState() {
val startUri = createTestUrl(SAVE_STATE_PATH)
mainSession.loadUri(startUri)
sessionRule.waitForPageStop()
var oldState: GeckoSession.SessionState? = null
sessionRule.waitUntilCalled(object : ProgressDelegate {
@AssertCalled(count = 1)
override fun onSessionStateChange(session: GeckoSession, sessionState: GeckoSession.SessionState) {
oldState = sessionState
}
})
assertThat("State should not be null", oldState, notNullValue())
mainSession.setActive(false)
sessionRule.waitUntilCalled(object : ProgressDelegate {
@AssertCalled(count = 1)
override fun onSessionStateChange(session: GeckoSession, sessionState: GeckoSession.SessionState) {
assertThat("Old session state and new should match", sessionState, equalTo(oldState))
}
})
}
@Test fun nullState() {
val stateFromNull: GeckoSession.SessionState? = GeckoSession.SessionState.fromString(null)
val nullState: GeckoSession.SessionState? = null
assertThat("Null string should result in null state", stateFromNull, equalTo(nullState))
}
@NullDelegate(GeckoSession.HistoryDelegate::class)
@Test
fun noHistoryDelegateOnSessionStateChange() {
mainSession.loadTestPath(HELLO_HTML_PATH)
sessionRule.waitForPageStop()
sessionRule.waitUntilCalled(object : ProgressDelegate {
@AssertCalled(count = 1)
override fun onSessionStateChange(session: GeckoSession, sessionState: GeckoSession.SessionState) {
}
})
}
@Test
fun getWebCompatInfo() {
sessionRule.setPrefsUntilTestEnd(mapOf("browser.webcompat.geckoview.enableAllTestMocks" to true))
val expectedResult = """{"devicePixelRatio":2.5,"antitracking":{"hasTrackingContentBlocked":false}}"""
val info = mainSession.webCompatInfo
assertThat("Result should match mocked web compat info", sessionRule.waitForResult(info).toString(), equalTo(expectedResult))
}
@Test
fun getWebCompatInfoExampleSite() {
mainSession.loadUri(url)
sessionRule.waitForPageStop()
val info = sessionRule.waitForResult(mainSession.webCompatInfo)
val infoUrl = info.getString("url")
assertThat("Result should match actual url", infoUrl, equalTo(url))
}
@Test
fun getWebCompatInfoError() {
// Catch an exception when no web page is loaded
try {
sessionRule.waitForResult(mainSession.webCompatInfo)
assertThat("This test is expected to fail.", true, equalTo(false))
} catch (error: Exception) {
assertTrue("Expect an exception while getting web compat info.", true)
}
}
@Test
fun sendMoreWebCompatInfoSuccess() {
sessionRule.setPrefsUntilTestEnd(mapOf("browser.webcompat.geckoview.enableAllTestMocks" to true))
val testInfo = JSONObject().apply {
put("reason", "test-reason")
put("description", "test-description")
}
try {
sessionRule.waitForResult(mainSession.sendMoreWebCompatInfo(testInfo))
assertTrue("sendMoreWebCompatInfo() should succeed.", true)
} catch (error: Exception) {
assertTrue("sendMoreWebCompatInfo() should not fail.", false)
}
}
@Test
fun pageLoadProgressCompletedAtPageStop() {
sessionRule.setPrefsUntilTestEnd(mapOf("page_load.progressbar_completion" to 0))
val progressChanges = mutableListOf<Int>()
sessionRule.delegateUntilTestEnd(object : ProgressDelegate {
@AssertCalled
override fun onProgressChange(session: GeckoSession, progress: Int) {
progressChanges.add(progress)
}
})
mainSession.loadTestPath(HELLO_HTML_PATH)
sessionRule.waitForPageStop()
val completionIndex = progressChanges.indexOf(100)
assertThat("Must have more than 1 progress value", completionIndex, greaterThan(0))
val lastProgressBeforeCompletion = progressChanges[completionIndex - 1]
assertThat(
"Last progress before completion should be less than or equal to 80",
lastProgressBeforeCompletion,
lessThanOrEqualTo(80),
)
}
@Test
fun pageLoadProgressCompletedAtDOMContentLoaded() {
sessionRule.setPrefsUntilTestEnd(mapOf("page_load.progressbar_completion" to 1))
val progressChanges = mutableListOf<Int>()
sessionRule.delegateUntilTestEnd(object : ProgressDelegate {
@AssertCalled
override fun onProgressChange(session: GeckoSession, progress: Int) {
progressChanges.add(progress)
}
})
mainSession.loadTestPath(HELLO_HTML_PATH)
sessionRule.waitForPageStop()
val completionIndex = progressChanges.indexOf(100)
assertThat("Must have more than 1 progress value", completionIndex, greaterThan(0))
val lastProgressBeforeCompletion = progressChanges[completionIndex - 1]
assertThat(
"Last progress before completion should be less than 55",
lastProgressBeforeCompletion,
lessThan(55),
)
}
@Test
fun pageLoadProgressCompletedAtMozAfterPaintAfterDOMContentLoaded() {
sessionRule.setPrefsUntilTestEnd(mapOf("page_load.progressbar_completion" to 2))
val progressChanges = mutableListOf<Int>()
sessionRule.delegateUntilTestEnd(object : ProgressDelegate {
@AssertCalled
override fun onProgressChange(session: GeckoSession, progress: Int) {
progressChanges.add(progress)
}
})
mainSession.loadTestPath(HELLO_HTML_PATH)
sessionRule.waitForPageStop()
val completionIndex = progressChanges.indexOf(100)
assertThat("Must have more than 1 progress value", completionIndex, greaterThan(0))
val lastProgressBeforeCompletion = progressChanges[completionIndex - 1]
assertThat(
"Last progress before completion should be less than 80",
lastProgressBeforeCompletion,
lessThan(80),
)
}
}