Merge "Add test on spa.framework.common" (67aa0f16) · Commits · e / os / android_frameworks_base

packages/SettingsLib/Spa/spa/src/com/android/settingslib/spa/framework/common/SettingsEntryRepository.kt

+8 −3

Original line number	Diff line number	Diff line
		@@ -30,10 +30,14 @@ data class SettingsPageWithEntry(
		val injectEntry: SettingsEntry,
		)

		private fun SettingsPage.getTitle(sppRepository: SettingsPageProviderRepository): String {
		return sppRepository.getProviderOrNull(sppName)!!.getTitle(arguments)
		}

		/**
		* The repository to maintain all Settings entries
		*/
		class SettingsEntryRepository(sppRepository: SettingsPageProviderRepository) {
		class SettingsEntryRepository(private val sppRepository: SettingsPageProviderRepository) {
		// Map of entry unique Id to entry
		private val entryMap: Map<String, SettingsEntry>

		@@ -118,8 +122,9 @@ class SettingsEntryRepository(sppRepository: SettingsPageProviderRepository) {
		return entryPath.map {
		if (it.toPage == null)
		defaultTitle
		else
		it.toPage.getTitle()!!
		else {
		it.toPage.getTitle(sppRepository)
		}
		}
		}
		}

packages/SettingsLib/Spa/spa/src/com/android/settingslib/spa/framework/common/SettingsPage.kt

+0 −5

Original line number	Diff line number	Diff line
		@@ -95,11 +95,6 @@ data class SettingsPage(
		return false
		}

		fun getTitle(): String? {
		val sppRepository by SpaEnvironmentFactory.instance.pageProviderRepository
		return sppRepository.getProviderOrNull(sppName)?.getTitle(arguments)
		}

		fun enterPage() {
		SpaEnvironmentFactory.instance.logger.event(
		id,

packages/SettingsLib/Spa/tests/src/com/android/settingslib/spa/framework/common/SettingsEntryRepositoryTest.kt

0 → 100644

+146 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		package com.android.settingslib.spa.framework.common

		import android.content.Context
		import androidx.test.core.app.ApplicationProvider
		import androidx.test.ext.junit.runners.AndroidJUnit4
		import com.google.common.truth.Truth.assertThat
		import org.junit.Test
		import org.junit.runner.RunWith

		@RunWith(AndroidJUnit4::class)
		class SettingsEntryRepositoryTest {
		private val context: Context = ApplicationProvider.getApplicationContext()
		private val spaEnvironment = SpaEnvironmentForTest(context)
		private val entryRepository by spaEnvironment.entryRepository

		@Test
		fun testGetPageWithEntry() {
		val pageWithEntry = entryRepository.getAllPageWithEntry()
		assertThat(pageWithEntry.size).isEqualTo(3)
		assertThat(
		entryRepository.getPageWithEntry(getUniquePageId("SppHome"))
		?.entries?.size
		).isEqualTo(1)
		assertThat(
		entryRepository.getPageWithEntry(getUniquePageId("SppLayer1"))
		?.entries?.size
		).isEqualTo(3)
		assertThat(
		entryRepository.getPageWithEntry(getUniquePageId("SppLayer2"))
		?.entries?.size
		).isEqualTo(2)
		assertThat(entryRepository.getPageWithEntry(getUniquePageId("SppWithParam"))).isNull()
		}

		@Test
		fun testGetEntry() {
		val entry = entryRepository.getAllEntries()
		assertThat(entry.size).isEqualTo(7)
		assertThat(
		entryRepository.getEntry(
		getUniqueEntryId(
		"ROOT",
		SppHome.createSettingsPage(),
		SettingsPage.createNull(),
		SppHome.createSettingsPage(),
		)
		)
		).isNotNull()
		assertThat(
		entryRepository.getEntry(
		getUniqueEntryId(
		"INJECT",
		SppLayer1.createSettingsPage(),
		SppHome.createSettingsPage(),
		SppLayer1.createSettingsPage(),
		)
		)
		).isNotNull()
		assertThat(
		entryRepository.getEntry(
		getUniqueEntryId(
		"INJECT",
		SppLayer2.createSettingsPage(),
		SppLayer1.createSettingsPage(),
		SppLayer2.createSettingsPage(),
		)
		)
		).isNotNull()
		assertThat(
		entryRepository.getEntry(
		getUniqueEntryId("Layer1Entry1", SppLayer1.createSettingsPage())
		)
		).isNotNull()
		assertThat(
		entryRepository.getEntry(
		getUniqueEntryId("Layer1Entry2", SppLayer1.createSettingsPage())
		)
		).isNotNull()
		assertThat(
		entryRepository.getEntry(
		getUniqueEntryId("Layer2Entry1", SppLayer2.createSettingsPage())
		)
		).isNotNull()
		assertThat(
		entryRepository.getEntry(
		getUniqueEntryId("Layer2Entry2", SppLayer2.createSettingsPage())
		)
		).isNotNull()
		}

		@Test
		fun testGetEntryPath() {
		assertThat(
		entryRepository.getEntryPathWithDisplayName(
		getUniqueEntryId("Layer2Entry1", SppLayer2.createSettingsPage())
		)
		).containsExactly("Layer2Entry1", "INJECT_SppLayer2", "INJECT_SppLayer1", "ROOT_SppHome")
		.inOrder()

		assertThat(
		entryRepository.getEntryPathWithTitle(
		getUniqueEntryId("Layer2Entry2", SppLayer2.createSettingsPage()),
		"entryTitle"
		)
		).containsExactly("entryTitle", "SppLayer2", "TitleLayer1", "TitleHome").inOrder()

		assertThat(
		entryRepository.getEntryPathWithDisplayName(
		getUniqueEntryId(
		"INJECT",
		SppLayer1.createSettingsPage(),
		SppHome.createSettingsPage(),
		SppLayer1.createSettingsPage(),
		)
		)
		).containsExactly("INJECT_SppLayer1", "ROOT_SppHome").inOrder()

		assertThat(
		entryRepository.getEntryPathWithTitle(
		getUniqueEntryId(
		"INJECT",
		SppLayer2.createSettingsPage(),
		SppLayer1.createSettingsPage(),
		SppLayer2.createSettingsPage(),
		),
		"defaultTitle"
		)
		).containsExactly("SppLayer2", "TitleLayer1", "TitleHome").inOrder()
		}
		}

packages/SettingsLib/Spa/tests/src/com/android/settingslib/spa/framework/common/SettingsEntryTest.kt

0 → 100644

+160 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		package com.android.settingslib.spa.framework.common

		import androidx.compose.runtime.Composable
		import androidx.compose.ui.test.junit4.createComposeRule
		import androidx.core.os.bundleOf
		import androidx.test.ext.junit.runners.AndroidJUnit4
		import com.google.common.truth.Truth.assertThat
		import org.junit.Rule
		import org.junit.Test
		import org.junit.runner.RunWith

		const val INJECT_ENTRY_NAME = "INJECT"
		const val ROOT_ENTRY_NAME = "ROOT"

		class MacroForTest(private val pageId: String, private val entryId: String) : EntryMacro {
		@Composable
		override fun UiLayout() {
		val entryData = LocalEntryDataProvider.current
		assertThat(entryData.isHighlighted).isFalse()
		assertThat(entryData.pageId).isEqualTo(pageId)
		assertThat(entryData.entryId).isEqualTo(entryId)
		}

		override fun getSearchData(): EntrySearchData {
		return EntrySearchData("myTitle")
		}

		override fun getStatusData(): EntryStatusData {
		return EntryStatusData(isDisabled = true, isSwitchOff = true)
		}
		}

		@RunWith(AndroidJUnit4::class)
		class SettingsEntryTest {
		@get:Rule
		val composeTestRule = createComposeRule()

		@Test
		fun testBuildBasic() {
		val owner = SettingsPage.create("mySpp")
		val entry = SettingsEntryBuilder.create(owner, "myEntry").build()
		assertThat(entry.id).isEqualTo(getUniqueEntryId("myEntry", owner))
		assertThat(entry.displayName).isEqualTo("myEntry")
		assertThat(entry.owner.sppName).isEqualTo("mySpp")
		assertThat(entry.owner.displayName).isEqualTo("mySpp")
		assertThat(entry.fromPage).isNull()
		assertThat(entry.toPage).isNull()
		assertThat(entry.isAllowSearch).isFalse()
		assertThat(entry.isSearchDataDynamic).isFalse()
		assertThat(entry.mutableStatus).isFalse()
		}

		@Test
		fun testBuildWithLink() {
		val owner = SettingsPage.create("mySpp")
		val fromPage = SettingsPage.create("fromSpp")
		val toPage = SettingsPage.create("toSpp")
		val entryFrom = SettingsEntryBuilder.createLinkFrom("myEntry", owner)
		.setLink(toPage = toPage).build()
		assertThat(entryFrom.id).isEqualTo(getUniqueEntryId("myEntry", owner, owner, toPage))
		assertThat(entryFrom.displayName).isEqualTo("myEntry")
		assertThat(entryFrom.fromPage!!.sppName).isEqualTo("mySpp")
		assertThat(entryFrom.toPage!!.sppName).isEqualTo("toSpp")

		val entryTo = SettingsEntryBuilder.createLinkTo("myEntry", owner)
		.setLink(fromPage = fromPage).build()
		assertThat(entryTo.id).isEqualTo(getUniqueEntryId("myEntry", owner, fromPage, owner))
		assertThat(entryTo.displayName).isEqualTo("myEntry")
		assertThat(entryTo.fromPage!!.sppName).isEqualTo("fromSpp")
		assertThat(entryTo.toPage!!.sppName).isEqualTo("mySpp")
		}

		@Test
		fun testBuildInject() {
		val owner = SettingsPage.create("mySpp")
		val entryInject = SettingsEntryBuilder.createInject(owner).build()
		assertThat(entryInject.id).isEqualTo(
		getUniqueEntryId(
		INJECT_ENTRY_NAME,
		owner,
		toPage = owner
		)
		)
		assertThat(entryInject.displayName).isEqualTo("${INJECT_ENTRY_NAME}_mySpp")
		assertThat(entryInject.fromPage).isNull()
		assertThat(entryInject.toPage).isNotNull()
		}

		@Test
		fun testBuildRoot() {
		val owner = SettingsPage.create("mySpp")
		val entryInject = SettingsEntryBuilder.createRoot(owner, "myRootEntry").build()
		assertThat(entryInject.id).isEqualTo(
		getUniqueEntryId(
		ROOT_ENTRY_NAME,
		owner,
		toPage = owner
		)
		)
		assertThat(entryInject.displayName).isEqualTo("myRootEntry")
		assertThat(entryInject.fromPage).isNull()
		assertThat(entryInject.toPage).isNotNull()
		}

		@Test
		fun testSetAttributes() {
		val owner = SettingsPage.create("mySpp")
		val entry = SettingsEntryBuilder.create(owner, "myEntry")
		.setDisplayName("myEntryDisplay")
		.setIsAllowSearch(true)
		.setIsSearchDataDynamic(false)
		.setHasMutableStatus(true)
		.build()
		assertThat(entry.id).isEqualTo(getUniqueEntryId("myEntry", owner))
		assertThat(entry.displayName).isEqualTo("myEntryDisplay")
		assertThat(entry.fromPage).isNull()
		assertThat(entry.toPage).isNull()
		assertThat(entry.isAllowSearch).isTrue()
		assertThat(entry.isSearchDataDynamic).isFalse()
		assertThat(entry.mutableStatus).isTrue()
		}

		@Test
		fun testSetMarco() {
		val owner = SettingsPage.create("mySpp", arguments = bundleOf("param" to "v1"))
		val entry = SettingsEntryBuilder.create(owner, "myEntry")
		.setMacro {
		assertThat(it?.getString("param")).isEqualTo("v1")
		assertThat(it?.getString("rtParam")).isEqualTo("v2")
		assertThat(it?.getString("unknown")).isNull()
		MacroForTest(getUniquePageId("mySpp"), getUniqueEntryId("myEntry", owner))
		}
		.build()

		val rtArguments = bundleOf("rtParam" to "v2")
		composeTestRule.setContent { entry.UiLayout(rtArguments) }
		val searchData = entry.getSearchData(rtArguments)
		val statusData = entry.getStatusData(rtArguments)
		assertThat(searchData?.title).isEqualTo("myTitle")
		assertThat(searchData?.keyword).isEmpty()
		assertThat(statusData?.isDisabled).isTrue()
		assertThat(statusData?.isSwitchOff).isTrue()
		}
		}

packages/SettingsLib/Spa/tests/src/com/android/settingslib/spa/framework/common/SettingsPageProviderRepositoryTest.kt

0 → 100644

+62 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		package com.android.settingslib.spa.framework.common

		import androidx.test.ext.junit.runners.AndroidJUnit4
		import com.google.common.truth.Truth.assertThat
		import org.junit.Test
		import org.junit.runner.RunWith

		@RunWith(AndroidJUnit4::class)
		class SettingsPageProviderRepositoryTest {
		@Test
		fun getStartPageTest() {
		val sppRepoEmpty = SettingsPageProviderRepository(emptyList(), emptyList())
		assertThat(sppRepoEmpty.getDefaultStartPage()).isEqualTo("")
		assertThat(sppRepoEmpty.getAllRootPages()).isEmpty()

		val sppRepoNull =
		SettingsPageProviderRepository(emptyList(), listOf(SettingsPage.createNull()))
		assertThat(sppRepoNull.getDefaultStartPage()).isEqualTo("NULL")
		assertThat(sppRepoNull.getAllRootPages()).contains(SettingsPage.createNull())

		val rootPage1 = SettingsPage.create(name = "Spp1", displayName = "Spp1")
		val rootPage2 = SettingsPage.create(name = "Spp2", displayName = "Spp2")
		val sppRepo = SettingsPageProviderRepository(emptyList(), listOf(rootPage1, rootPage2))
		val allRoots = sppRepo.getAllRootPages()
		assertThat(sppRepo.getDefaultStartPage()).isEqualTo("Spp1")
		assertThat(allRoots.size).isEqualTo(2)
		assertThat(allRoots).contains(rootPage1)
		assertThat(allRoots).contains(rootPage2)
		}

		@Test
		fun getProviderTest() {
		val sppRepoEmpty = SettingsPageProviderRepository(emptyList(), emptyList())
		assertThat(sppRepoEmpty.getAllProviders()).isEmpty()
		assertThat(sppRepoEmpty.getProviderOrNull("Spp")).isNull()

		val sppRepo = SettingsPageProviderRepository(listOf(
		object : SettingsPageProvider {
		override val name = "Spp"
		}
		), emptyList())
		assertThat(sppRepo.getAllProviders().size).isEqualTo(1)
		assertThat(sppRepo.getProviderOrNull("Spp")).isNotNull()
		assertThat(sppRepo.getProviderOrNull("SppUnknown")).isNull()
		}
		}