path: root/tests/unit/src/android/net/testutils/TestableNetworkCallbackTest.kt

package android.net.testutils

import android.net.LinkAddress
import android.net.LinkProperties
import android.net.Network
import android.net.NetworkCapabilities
import com.android.testutils.ConcurrentIntepreter
import com.android.testutils.InterpretMatcher
import com.android.testutils.RecorderCallback.CallbackEntry
import com.android.testutils.RecorderCallback.CallbackEntry.Available
import com.android.testutils.RecorderCallback.CallbackEntry.BlockedStatus
import com.android.testutils.RecorderCallback.CallbackEntry.CapabilitiesChanged
import com.android.testutils.TestableNetworkCallback
import com.android.testutils.intArg
import com.android.testutils.strArg
import com.android.testutils.timeArg
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.runners.JUnit4
import kotlin.reflect.KClass
import kotlin.test.assertEquals
import kotlin.test.assertFails
import kotlin.test.assertNull
import kotlin.test.assertTrue
import kotlin.test.fail

const val SHORT_TIMEOUT_MS = 20L
const val DEFAULT_LINGER_DELAY_MS = 30000
const val NOT_METERED = NetworkCapabilities.NET_CAPABILITY_NOT_METERED
const val WIFI = NetworkCapabilities.TRANSPORT_WIFI
const val CELLULAR = NetworkCapabilities.TRANSPORT_CELLULAR
const val TEST_INTERFACE_NAME = "testInterfaceName"

@RunWith(JUnit4::class)
class TestableNetworkCallbackTest {
    private lateinit var mCallback: TestableNetworkCallback

    private fun makeHasNetwork(netId: Int) = object : TestableNetworkCallback.HasNetwork {
        override val network: Network = Network(netId)
    }

    @Before
    fun setUp() {
        mCallback = TestableNetworkCallback()
    }

    @Test
    fun testLastAvailableNetwork() {
        // Make sure there is no last available network at first, then the last available network
        // is returned after onAvailable is called.
        val net2097 = Network(2097)
        assertNull(mCallback.lastAvailableNetwork)
        mCallback.onAvailable(net2097)
        assertEquals(mCallback.lastAvailableNetwork, net2097)

        // Make sure calling onCapsChanged/onLinkPropertiesChanged don't affect the last available
        // network.
        mCallback.onCapabilitiesChanged(net2097, NetworkCapabilities())
        mCallback.onLinkPropertiesChanged(net2097, LinkProperties())
        assertEquals(mCallback.lastAvailableNetwork, net2097)

        // Make sure onLost clears the last available network.
        mCallback.onLost(net2097)
        assertNull(mCallback.lastAvailableNetwork)

        // Do the same but with a different network after onLost : make sure the last available
        // network is the new one, not the original one.
        val net2098 = Network(2098)
        mCallback.onAvailable(net2098)
        mCallback.onCapabilitiesChanged(net2098, NetworkCapabilities())
        mCallback.onLinkPropertiesChanged(net2098, LinkProperties())
        assertEquals(mCallback.lastAvailableNetwork, net2098)

        // Make sure onAvailable changes the last available network even if onLost was not called.
        val net2099 = Network(2099)
        mCallback.onAvailable(net2099)
        assertEquals(mCallback.lastAvailableNetwork, net2099)

        // For legacy reasons, lastAvailableNetwork is null as soon as any is lost, not necessarily
        // the last available one. Check that behavior.
        mCallback.onLost(net2098)
        assertNull(mCallback.lastAvailableNetwork)

        // Make sure that losing the really last available one still results in null.
        mCallback.onLost(net2099)
        assertNull(mCallback.lastAvailableNetwork)

        // Make sure multiple onAvailable in a row then onLost still results in null.
        mCallback.onAvailable(net2097)
        mCallback.onAvailable(net2098)
        mCallback.onAvailable(net2099)
        mCallback.onLost(net2097)
        assertNull(mCallback.lastAvailableNetwork)
    }

    @Test
    fun testAssertNoCallback() {
        mCallback.assertNoCallback(SHORT_TIMEOUT_MS)
        mCallback.onAvailable(Network(100))
        assertFails { mCallback.assertNoCallback(SHORT_TIMEOUT_MS) }
    }

    @Test
    fun testCapabilitiesWithAndWithout() {
        val net = Network(101)
        val matcher = makeHasNetwork(101)
        val meteredNc = NetworkCapabilities()
        val unmeteredNc = NetworkCapabilities().addCapability(NOT_METERED)
        // Check that expecting caps (with or without) fails when no callback has been received.
        assertFails { mCallback.expectCapabilitiesWith(NOT_METERED, matcher, SHORT_TIMEOUT_MS) }
        assertFails { mCallback.expectCapabilitiesWithout(NOT_METERED, matcher, SHORT_TIMEOUT_MS) }

        // Add NOT_METERED and check that With succeeds and Without fails.
        mCallback.onCapabilitiesChanged(net, unmeteredNc)
        mCallback.expectCapabilitiesWith(NOT_METERED, matcher)
        mCallback.onCapabilitiesChanged(net, unmeteredNc)
        assertFails { mCallback.expectCapabilitiesWithout(NOT_METERED, matcher, SHORT_TIMEOUT_MS) }

        // Don't add NOT_METERED and check that With fails and Without succeeds.
        mCallback.onCapabilitiesChanged(net, meteredNc)
        assertFails { mCallback.expectCapabilitiesWith(NOT_METERED, matcher, SHORT_TIMEOUT_MS) }
        mCallback.onCapabilitiesChanged(net, meteredNc)
        mCallback.expectCapabilitiesWithout(NOT_METERED, matcher)
    }

    @Test
    fun testExpectCallbackThat() {
        val net = Network(193)
        val netCaps = NetworkCapabilities().addTransportType(CELLULAR)
        // Check that expecting callbackThat anything fails when no callback has been received.
        assertFails { mCallback.expectCallbackThat(SHORT_TIMEOUT_MS) { true } }

        // Basic test for true and false
        mCallback.onAvailable(net)
        mCallback.expectCallbackThat { true }
        mCallback.onAvailable(net)
        assertFails { mCallback.expectCallbackThat(SHORT_TIMEOUT_MS) { false } }

        // Try a positive and a negative case
        mCallback.onBlockedStatusChanged(net, true)
        mCallback.expectCallbackThat { cb -> cb is BlockedStatus && cb.blocked }
        mCallback.onCapabilitiesChanged(net, netCaps)
        assertFails { mCallback.expectCallbackThat(SHORT_TIMEOUT_MS) { cb ->
            cb is CapabilitiesChanged && cb.caps.hasTransport(WIFI)
        } }
    }

    @Test
    fun testCapabilitiesThat() {
        val net = Network(101)
        val netCaps = NetworkCapabilities().addCapability(NOT_METERED).addTransportType(WIFI)
        // Check that expecting capabilitiesThat anything fails when no callback has been received.
        assertFails { mCallback.expectCapabilitiesThat(net, SHORT_TIMEOUT_MS) { true } }

        // Basic test for true and false
        mCallback.onCapabilitiesChanged(net, netCaps)
        mCallback.expectCapabilitiesThat(net) { true }
        mCallback.onCapabilitiesChanged(net, netCaps)
        assertFails { mCallback.expectCapabilitiesThat(net, SHORT_TIMEOUT_MS) { false } }

        // Try a positive and a negative case
        mCallback.onCapabilitiesChanged(net, netCaps)
        mCallback.expectCapabilitiesThat(net) { caps ->
            caps.hasCapability(NOT_METERED) &&
                    caps.hasTransport(WIFI) &&
                    !caps.hasTransport(CELLULAR)
        }
        mCallback.onCapabilitiesChanged(net, netCaps)
        assertFails { mCallback.expectCapabilitiesThat(net, SHORT_TIMEOUT_MS) { caps ->
            caps.hasTransport(CELLULAR)
        } }

        // Try a matching callback on the wrong network
        mCallback.onCapabilitiesChanged(net, netCaps)
        assertFails { mCallback.expectCapabilitiesThat(Network(100), SHORT_TIMEOUT_MS) { true } }
    }

    @Test
    fun testLinkPropertiesThat() {
        val net = Network(112)
        val linkAddress = LinkAddress("fe80::ace:d00d/64")
        val mtu = 1984
        val linkProps = LinkProperties().apply {
            this.mtu = mtu
            interfaceName = TEST_INTERFACE_NAME
            addLinkAddress(linkAddress)
        }

        // Check that expecting linkPropsThat anything fails when no callback has been received.
        assertFails { mCallback.expectLinkPropertiesThat(net, SHORT_TIMEOUT_MS) { true } }

        // Basic test for true and false
        mCallback.onLinkPropertiesChanged(net, linkProps)
        mCallback.expectLinkPropertiesThat(net) { true }
        mCallback.onLinkPropertiesChanged(net, linkProps)
        assertFails { mCallback.expectLinkPropertiesThat(net, SHORT_TIMEOUT_MS) { false } }

        // Try a positive and negative case
        mCallback.onLinkPropertiesChanged(net, linkProps)
        mCallback.expectLinkPropertiesThat(net) { lp ->
            lp.interfaceName == TEST_INTERFACE_NAME &&
                    lp.linkAddresses.contains(linkAddress) &&
                    lp.mtu == mtu
        }
        mCallback.onLinkPropertiesChanged(net, linkProps)
        assertFails { mCallback.expectLinkPropertiesThat(net, SHORT_TIMEOUT_MS) { lp ->
            lp.interfaceName != TEST_INTERFACE_NAME
        } }

        // Try a matching callback on the wrong network
        mCallback.onLinkPropertiesChanged(net, linkProps)
        assertFails { mCallback.expectLinkPropertiesThat(Network(114), SHORT_TIMEOUT_MS) { lp ->
            lp.interfaceName == TEST_INTERFACE_NAME
        } }
    }

    @Test
    fun testExpectCallback() {
        val net = Network(103)
        // Test expectCallback fails when nothing was sent.
        assertFails { mCallback.expectCallback<BlockedStatus>(net, SHORT_TIMEOUT_MS) }

        // Test onAvailable is seen and can be expected
        mCallback.onAvailable(net)
        mCallback.expectCallback<Available>(net, SHORT_TIMEOUT_MS)

        // Test onAvailable won't return calls with a different network
        mCallback.onAvailable(Network(106))
        assertFails { mCallback.expectCallback<Available>(net, SHORT_TIMEOUT_MS) }

        // Test onAvailable won't return calls with a different callback
        mCallback.onAvailable(net)
        assertFails { mCallback.expectCallback<BlockedStatus>(net, SHORT_TIMEOUT_MS) }
    }

    @Test
    fun testPollForNextCallback() {
        assertFails { mCallback.pollForNextCallback(SHORT_TIMEOUT_MS) }
        TNCInterpreter.interpretTestSpec(initial = mCallback, lineShift = 1,
                threadTransform = { cb -> cb.createLinkedCopy() }, spec = """
            sleep; onAvailable(133)    | poll(2) = Available(133) time 1..4
                                       | poll(1) fails
            onCapabilitiesChanged(108) | poll(1) = CapabilitiesChanged(108) time 0..3
            onBlockedStatus(199)       | poll(1) = BlockedStatus(199) time 0..3
        """)
    }
}

private object TNCInterpreter : ConcurrentIntepreter<TestableNetworkCallback>(interpretTable)

val EntryList = CallbackEntry::class.sealedSubclasses.map { it.simpleName }.joinToString("|")
private fun callbackEntryFromString(name: String): KClass<out CallbackEntry> {
    return CallbackEntry::class.sealedSubclasses.first { it.simpleName == name }
}

private val interpretTable = listOf<InterpretMatcher<TestableNetworkCallback>>(
    // Interpret "Available(xx)" as "call to onAvailable with netId xx", and likewise for
    // all callback types. This is implemented above by enumerating the subclasses of
    // CallbackEntry and reading their simpleName.
    Regex("""(.*)\s+=\s+($EntryList)\((\d+)\)""") to { i, cb, t ->
        val record = i.interpret(t.strArg(1), cb)
        assertTrue(callbackEntryFromString(t.strArg(2)).isInstance(record))
        // Strictly speaking testing for is CallbackEntry is useless as it's been tested above
        // but the compiler can't figure things out from the isInstance call. It does understand
        // from the assertTrue(is CallbackEntry) that this is true, which allows to access
        // the 'network' member below.
        assertTrue(record is CallbackEntry)
        assertEquals(record.network.netId, t.intArg(3))
    },
    // Interpret "onAvailable(xx)" as calling "onAvailable" with a netId of xx, and likewise for
    // all callback types. NetworkCapabilities and LinkProperties just get an empty object
    // as their argument. Losing gets the default linger timer. Blocked gets false.
    Regex("""on($EntryList)\((\d+)\)""") to { i, cb, t ->
        val net = Network(t.intArg(2))
        when (t.strArg(1)) {
            "Available" -> cb.onAvailable(net)
            // PreCheck not used in tests. Add it here if it becomes useful.
            "CapabilitiesChanged" -> cb.onCapabilitiesChanged(net, NetworkCapabilities())
            "LinkPropertiesChanged" -> cb.onLinkPropertiesChanged(net, LinkProperties())
            "Suspended" -> cb.onNetworkSuspended(net)
            "Resumed" -> cb.onNetworkResumed(net)
            "Losing" -> cb.onLosing(net, DEFAULT_LINGER_DELAY_MS)
            "Lost" -> cb.onLost(net)
            "Unavailable" -> cb.onUnavailable()
            "BlockedStatus" -> cb.onBlockedStatusChanged(net, false)
            else -> fail("Unknown callback type")
        }
    },
    Regex("""poll\((\d+)\)""") to { i, cb, t ->
        cb.pollForNextCallback(t.timeArg(1))
    }
)