Create showcase & showcase test for queries

PiperOrigin-RevId: 346459397

javatests/arcs/core/allocator/AllocatorTestBase.kt

@@ -62,9 +62,6 @@ open class AllocatorTestBase {
   private val schedulerProvider = SimpleSchedulerProvider(Dispatchers.Default)
   private lateinit var scope: CoroutineScope
 
-  /**
-   * Recipe hand translated from 'person.arcs'
-   */
   protected lateinit var allocator: Allocator
   private lateinit var hostRegistry: HostRegistry
   private lateinit var writePersonParticle: Plan.Particle

javatests/arcs/showcase/queries/BUILD

@@ -0,0 +1,51 @@
+load(
+    "//third_party/java/arcs/build_defs:build_defs.bzl",
+    "arcs_kt_android_library",
+    "arcs_kt_android_test_suite",
+    "arcs_kt_gen",
+)
+
+licenses(["notice"])
+
+arcs_kt_gen(
+    name = "codegen",
+    srcs = ["queries.arcs"],
+)
+
+arcs_kt_android_library(
+    name = "particles",
+    testonly = 1,
+    srcs = [
+        "ProductClassifier.kt",
+        "ProductDatabase.kt",
+    ],
+    deps = [
+        ":codegen",
+        "//java/arcs/android/storage/database",
+        "//java/arcs/core/entity",
+        "//java/arcs/jvm/host",
+        "//java/arcs/sdk/android/storage",
+        "//java/arcs/sdk/android/storage/service",
+        "//javatests/arcs/android/integration",
+    ],
+)
+
+arcs_kt_android_test_suite(
+    name = "tests",
+    size = "small",
+    srcs = glob(["*Test.kt"]),
+    manifest = "//java/arcs/android/common:AndroidManifest.xml",
+    package = "arcs.showcase.queries",
+    deps = [
+        ":codegen",
+        ":particles",
+        "//java/arcs/core/host",
+        "//java/arcs/core/testutil",
+        "//java/arcs/core/testutil/handles",
+        "//javatests/arcs/android/integration",
+        "//third_party/android/androidx_test/ext/junit",
+        "//third_party/java/junit:junit-android",
+        "//third_party/java/truth:truth-android",
+        "//third_party/kotlin/kotlinx_coroutines",
+    ],
+)

javatests/arcs/showcase/queries/ProductClassifier.kt

@@ -0,0 +1,60 @@
+package arcs.showcase.queries
+
+import arcs.jvm.host.TargetHost
+
+/**
+ * This particle is an example of using handles with associated queries.
+ * It performs three different queries which select products based on values provided at runtime:
+ *  - an arbitrary double [CHEAP_PRICE]
+ *  - an arbitrary double [EXPENSIVE_PRICE], and
+ *  - an arbitrary string [SEARCH_NAME].
+ *
+ * It filters dummy data from [ProductDatabase], but could be used with any other source of data and
+ * performs a simple labelling task showing how data can be combined from different handles without
+ * loading the whole database into the Particle.
+ */
+@TargetHost(arcs.android.integration.IntegrationHost::class)
+class ProductClassifier : AbstractProductClassifier() {
+
+  override fun onReady() {
+    // This map from product names to 'tags' accumulates the output that this particle provides.
+    val productDescriptions = mutableMapOf<String, MutableSet<String>>()
+
+    // Here, 'cheap' products are defined as products from the [cheapProducts] handle that have a
+    // price less than or equal to [CHEAP_PRICE].
+    // i.e. `price <= ?` see the definition in [queries.arcs]
+    handles.cheapProducts.query(CHEAP_PRICE).forEach {
+      productDescriptions.getOrPut(it.name) { mutableSetOf() }.add("cheap")
+    }
+    // Here, 'expensive' products are defined as products from the [expensiveProducts] handle that have a
+    // price greater than or equal to [EXPENSIVE_PRICE].
+    // i.e. `price >= ?` see the definition in [queries.arcs]
+    handles.expensiveProducts.query(EXPENSIVE_PRICE).forEach {
+      productDescriptions.getOrPut(it.name) { mutableSetOf() }.add("expensive")
+    }
+    // Here, 'named' products are defined as products from the [namedProducts] handle that have the
+    // name equal to [SEARCH_NAME].
+    // i.e. `name == ?` see the definition in [queries.arcs]
+    handles.namedProducts.query(SEARCH_NAME).forEach {
+      productDescriptions.getOrPut(it.name) { mutableSetOf() }.add("selected")
+    }
+
+    // This renders the 'tags' and product names as strings and stores them using the
+    // [productDescriptions] handle.
+    handles.productDescriptions.storeAll(
+      productDescriptions.map { (name, tags) ->
+        ProductDescription(description = "$name: ${tags.joinToString()}")
+      }
+    )
+  }
+
+  companion object {
+    /**
+     * These constants are arbitrary values to show that query arguments are provided at runtime.
+     * They do not actually need to be constants and could be changed at runtime.
+     */
+    private const val CHEAP_PRICE = 3.0
+    private const val EXPENSIVE_PRICE = 25.0
+    private const val SEARCH_NAME = "Pencil"
+  }
+}

javatests/arcs/showcase/queries/ProductDatabase.kt

@@ -0,0 +1,27 @@
+package arcs.showcase.queries
+
+import arcs.jvm.host.TargetHost
+
+typealias Product = AbstractProductDatabase.Product
+
+/**
+ * This particle generates dummy data that is used in testing queries.
+ * @see ProductClassifier
+ */
+@TargetHost(arcs.android.integration.IntegrationHost::class)
+class ProductDatabase : AbstractProductDatabase() {
+  override fun onFirstStart() {
+    handles.products.storeAll(
+      listOf(
+        Product(name = "Pencil", price = 2.5),
+        Product(name = "Ice cream", price = 3.0),
+        Product(name = "Chocolate", price = 3.0),
+        Product(name = "Blueberries", price = 4.0),
+        Product(name = "Sandwich", price = 4.50),
+        Product(name = "Scarf", price = 20.0),
+        Product(name = "Hat", price = 25.0),
+        Product(name = "Stop sign", price = 100.0)
+      )
+    )
+  }
+}

javatests/arcs/showcase/queries/QueriesShowcaseTest.kt

@@ -0,0 +1,46 @@
+package arcs.showcase.queries
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import arcs.android.integration.IntegrationEnvironment
+import arcs.core.host.toRegistration
+import arcs.core.testutil.handles.dispatchFetchAll
+import com.google.common.truth.Truth.assertThat
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.runBlocking
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(AndroidJUnit4::class)
+class QueriesShowcaseTest {
+
+  @get:Rule
+  val env = IntegrationEnvironment(
+    ::ProductClassifier.toRegistration(),
+    ::ProductDatabase.toRegistration()
+  )
+
+  /**
+   * Tests that a set of known queries, on known runtime data produce expected results.
+   * - Products are defined in [ProductDatabase],
+   * - filtering criteria are defined in [ProductClassifier].
+   */
+  @Test
+  fun testQueries() = runBlocking {
+    val arc = env.startArc(ClassifyProductsPlan)
+    val productClassifier: ProductClassifier = env.getParticle<ProductClassifier>(arc)
+    val productDescriptions = productClassifier.handles.productDescriptions.dispatchFetchAll()
+    val descriptions = productDescriptions.map { it.description }
+
+    assertThat(descriptions).containsExactly(
+      "Pencil: cheap, selected",
+      "Ice cream: cheap",
+      "Chocolate: cheap",
+      "Hat: expensive",
+      "Stop sign: expensive"
+    )
+
+    env.stopArc(arc)
+  }
+}

javatests/arcs/showcase/queries/queries.arcs

@@ -0,0 +1,27 @@
+meta
+  namespace: arcs.showcase.queries
+
+schema Product
+   name: Text
+   price: Number
+
+particle ProductDatabase in '.ProductDatabase'
+  products: writes [Product {name, price}]
+
+particle ProductClassifier in '.ProductClassifier'
+  cheapProducts: reads [Product {name, price} [price <= ?]]
+  expensiveProducts: reads [Product {name, price} [price >= ?]]
+  namedProducts: reads [Product {name, price} [name == ?]]
+  productDescriptions: reads writes [ProductDescription {description: Text}] // reads is only for testing.
+
+@arcId('testArc')
+recipe ClassifyProducts
+  products: create 'products'
+  productDescriptions: create 'productDescriptions'
+  ProductDatabase
+    products: products
+  ProductClassifier
+    cheapProducts: products
+    expensiveProducts: products
+    namedProducts: products
+    productDescriptions: productDescriptions