grain.social/grain-android

Switch repository

Loading…

package social.grain

import androidx.test.ext.junit.runners.AndroidJUnit4
import kotlinx.coroutines.runBlocking
import kotlinx.serialization.json.jsonPrimitive
import org.junit.After
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
import org.junit.runner.RunWith
import social.grain.data.location.LocationServices
import social.grain.support.StubServer
import social.grain.support.testJson

/**
 * Place search and reverse geocoding against Nominatim.
 *
 * The parsing is the whole of it, and the shapes it has to survive are the
 * awkward ones: a result with no `name`, one with no country code, and the
 * `display_name` that has to be split into a name and the context that tells
 * two identically-named corners apart.
 *
 * H3 itself is absent here — the native library ships for arm only — so this
 * also pins the behaviour of the build where it didn't load: no cell, no
 * coordinate, and nothing that throws.
 */
@RunWith(AndroidJUnit4::class)
class LocationServicesTest {

    private lateinit var server: StubServer
    private lateinit var locations: LocationServices

    @Before
    fun setUp() {
        server = StubServer()
        locations = LocationServices(server.client(), testJson)
    }

    @After
    fun tearDown() = server.shutdown()

    private fun result(
        name: String? = "Mission District",
        displayName: String? = "Mission District, San Francisco, California, United States",
        lat: String? = "37.7599",
        lon: String? = "-122.4148",
        address: String = """{"city":"San Francisco","state":"California",""" +
            """"country":"United States","country_code":"us","postcode":"94110",""" +
            """"road":"Valencia Street","house_number":"1000"}""",
    ) = buildString {
        append("{")
        name?.let { append(""""name":"$it",""") }
        displayName?.let { append(""""display_name":"$it",""") }
        lat?.let { append(""""lat":"$it",""") }
        lon?.let { append(""""lon":"$it",""") }
        append(""""address":$address}""")
    }

    @Test
    fun aSearchParsesTheNameTheContextAndTheAddressRecord() = runBlocking {
        server.on("search", "[${result()}]")

        val place = locations.search("mission").single()

        assertEquals("Mission District", place.name)
        assertEquals("San Francisco, California, United States", place.context)
        assertEquals(37.7599, place.latitude, 0.0001)
        assertEquals(-122.4148, place.longitude, 0.0001)

        val address = place.address!!
        assertEquals("US", address["country"]!!.jsonPrimitive.content)
        assertEquals("San Francisco", address["locality"]!!.jsonPrimitive.content)
        assertEquals("California", address["region"]!!.jsonPrimitive.content)
        assertEquals("94110", address["postalCode"]!!.jsonPrimitive.content)
        assertEquals(
            "The house number is folded into the street line",
            "1000 Valencia Street",
            address["street"]!!.jsonPrimitive.content,
        )
    }

    @Test
    fun theQueryIsUrlEncodedAndCapped() = runBlocking {
        server.on("search", "[]")

        locations.search("mission district")

        val call = server.lastCall("search")
        assertEquals("mission district", call.params["q"])
        assertEquals("5", call.params["limit"])
        assertEquals("json", call.params["format"])
    }

    @Test
    fun aQueryTooShortToBeUsefulIsNotSent() = runBlocking {
        assertTrue(locations.search("m").isEmpty())
        assertTrue(locations.search("  ").isEmpty())
        assertEquals(0, server.countOf("search"))
    }

    @Test
    fun aResultWithNoNameFallsBackToTheAddressItDoesHave() = runBlocking {
        server.on("search", "[${result(name = null)}]")

        val place = locations.search("mission").single()

        assertEquals("San Francisco, California, United States", place.name)
    }

    @Test
    fun aResultWithNoAddressAtAllFallsBackToTheDisplayName() = runBlocking {
        server.on("search", "[${result(name = null, address = "{}")}]")

        val place = locations.search("mission").single()

        assertEquals("Mission District", place.name)
        assertNull("With no country code there is no address record", place.address)
    }

    @Test
    fun aResultWithNoCoordinatesIsDropped() = runBlocking {
        server.on("search", "[${result(lat = null)}, ${result()}]")

        assertEquals(1, locations.search("mission").size)
    }

    @Test
    fun aSearchThatFailsComesBackEmptyRatherThanThrowing() = runBlocking {
        server.on("search", """{"error":"rate limited"}""", code = 429)

        assertTrue(locations.search("mission").isEmpty())
    }

    @Test
    fun aBodyThatIsNotAListComesBackEmpty() = runBlocking {
        server.on("search", """{"not":"a list"}""")

        assertTrue(locations.search("mission").isEmpty())
    }

    @Test
    fun reverseGeocodingReadsOnePlaceOutOfACoordinate() = runBlocking {
        server.on("reverse", result())

        val place = locations.reverseGeocode(37.76, -122.41)

        assertEquals("Mission District", place!!.name)
        val call = server.lastCall("reverse")
        assertEquals("37.76", call.params["lat"])
        assertEquals("-122.41", call.params["lon"])
    }

    @Test
    fun reverseGeocodingThatFailsAnswersWithNothing() = runBlocking {
        server.on("reverse", """{"error":"no"}""", code = 500)

        assertNull(locations.reverseGeocode(37.76, -122.41))
    }

    @Test
    fun theRequestIdentifiesItselfAsNominatimAsks() = runBlocking {
        server.on("search", "[]")

        locations.search("mission")

        assertEquals("Nominatim's policy requires a User-Agent", "search", server.lastCall("search").nsid)
    }

    @Test
    fun withoutTheNativeLibraryThereIsNoCellAndNoCoordinate() {
        // h3 ships arm binaries only, so a JVM sandbox never has it — which is
        // the same state an x86 emulator is in, and the app has to stay usable
        // in both.
        assertFalse(locations.isAvailable)
        assertNull(locations.cellFor(37.76, -122.41))
        assertNull(locations.coordinateFor("8928308280fffff"))
    }
}