#1318 functional test for usages of Schema mapper

plugin/ignite-plugin/pom.xml

@@ -57,6 +57,12 @@
             <version>0.9.65-SNAPSHOT</version>
         </dependency>
 
+        <dependency>
+            <groupId>org.finos.vuu.plugin</groupId>
+            <artifactId>virtualized-table-plugin</artifactId>
+            <version>0.9.65-SNAPSHOT</version>
+        </dependency>
+
         <dependency>
             <groupId>org.scala-lang</groupId>
             <artifactId>scala-library</artifactId>

plugin/ignite-plugin/src/test/scala/org/finos/vuu/feature/ignite/SchemaMapperFunctionalTest.scala

@@ -0,0 +1,83 @@
+package org.finos.vuu.feature.ignite
+
+import org.finos.vuu.core.sort.SortDirection
+import org.finos.vuu.core.table.{ColumnValueProvider, Columns}
+import org.finos.vuu.net.FilterSpec
+import org.finos.vuu.plugin.virtualized.api.VirtualizedSessionTableDef
+import org.finos.vuu.provider.VirtualizedProvider
+import org.finos.vuu.test.{FakeDataSource, FakeInMemoryTable}
+import org.finos.vuu.util.schema.{ExternalEntitySchema, SchemaMapperBuilder, SchemaMapperFunctionalTestBase, SchemaTestData}
+import org.finos.vuu.viewport.ViewPort
+
+class SchemaMapperFunctionalTest  extends SchemaMapperFunctionalTestBase {
+
+  Feature("Filter data in virtualised table using schema mapper") {
+    Scenario("When table columns and entity fields has same type") {
+
+      val externalEntitySchema: ExternalEntitySchema = createExternalEntitySchema
+      val tableDef = VirtualizedSessionTableDef(
+        name = "MyExampleVirtualTable",
+        keyField = "id",
+        columns = Columns.fromExternalSchema(externalEntitySchema)
+      )
+      val schemaMapper = SchemaMapperBuilder(externalEntitySchema, tableDef.columns)
+        .build()
+      val table = new FakeInMemoryTable("SchemaMapTest", tableDef)
+
+      //simulate using typeahead
+      givenColumnQueryReturns("unique", "clientId", Array("5","6"))
+
+      val dataProvider = new TestVirtualProvider(fakeDataSource)
+      val columnValueProvider = dataProvider.asInstanceOf[ColumnValueProvider]
+      columnValueProvider.getUniqueValues("clientId")
+
+      //todo assert on the result returned for typeahead
+
+      //simulate using user entered filter and sort to the data query
+      val filterSpec = FilterSpec("orderId > 1 and ric starts \"ABC\"")
+      val sortSpec = Map("price" -> SortDirection.Ascending)
+
+      val filterAndSortSpecToSql = FilterAndSortSpecToSql(schemaMapper)
+      filterAndSortSpecToSql.sortToSql(sortSpec)
+      filterAndSortSpecToSql.filterToSql(filterSpec)
+
+      //todo assert that correct sql query is created - should use real ignite or assert on expected sql query?
+
+      //todo test once query is returned it can be mapped appropriate to table rows & assert on what exist in table
+      givenQueryReturns("filtered", List(
+        List("testId1", 5, 10.5),
+        List("testId2", 6, 11.5),
+        List("testId3", 5, 12.5),
+      ))
+      fakeDataSource.getAsListOfValues("filtered")
+    }
+
+    Scenario("When table columns and entity fields has different type"){}
+  }
+}
+
+
+class TestVirtualProvider(fakeDataSource:FakeDataSource[SchemaTestData]) extends VirtualizedProvider {
+  override def runOnce(viewPort: ViewPort): Unit = ???
+
+  override def getUniqueValues(columnName: String): Array[String] = getColumnQueryResult("unique", columnName)
+
+  override def getUniqueValuesStartingWith(columnName: String, starts: String): Array[String] = ???
+
+  override def subscribe(key: String): Unit = ???
+
+  override def doStart(): Unit = ???
+
+  override def doStop(): Unit = ???
+
+  override def doInitialize(): Unit = ???
+
+  override def doDestroy(): Unit = ???
+
+  override val lifecycleId: String = "SchemaMapperFunctionalTest"
+
+  private def getColumnQueryResult(queryName: String, columnName:String): Array[String] = {
+    fakeDataSource.getColumnValues(queryName, columnName)
+      .getOrElse(throw new Exception("query does not exist in store. make sure it is setup"))
+  }
+}

vuu/src/main/java/org/finos/vuu/util/ScalaCollectionConverter.java

@@ -0,0 +1,30 @@
+package org.finos.vuu.util;
+
+import scala.jdk.CollectionConverters;
+
+import java.util.List;
+import java.util.Map;
+
+public class ScalaCollectionConverter {
+
+    public static <K, V> scala.collection.immutable.Map<K, V> toScala(Map<K, V> m) {
+        return scala.collection.immutable.Map.from(scala.jdk.CollectionConverters.MapHasAsScala(m).asScala());
+    }
+
+    public static <T> scala.collection.Iterable<T> toScala(Iterable<T> l) {
+        return CollectionConverters.IterableHasAsScala(l).asScala();
+    }
+
+    public static <T> scala.collection.immutable.List<T> toScala(List<T> l) {
+        return CollectionConverters.IterableHasAsScala(l).asScala().toList();
+    }
+
+    public static <T> scala.collection.immutable.Seq<T> toScalaSeq(List<T> l) {
+        return CollectionConverters.IterableHasAsScala(l).asScala().toSeq();
+    }
+
+    public static <T> List<T> toJava(scala.collection.immutable.List<T> l) {
+        return CollectionConverters.SeqHasAsJava(l).asJava();
+    }
+}
+

vuu/src/main/scala/org/finos/vuu/api/ColumnBuilder.scala

@@ -0,0 +1,44 @@
+package org.finos.vuu.api
+
+import org.finos.vuu.core.table.{Column, Columns}
+
+import scala.collection.mutable
+
+class ColumnBuilder {
+
+  val columns = new mutable.ArrayBuilder.ofRef[String]()
+
+  def addString(columnName: String): ColumnBuilder = {
+    columns += (columnName + ":String")
+    this
+  }
+
+  def addDouble(columnName: String): ColumnBuilder = {
+    columns += (columnName + ":Double")
+    this
+  }
+
+  def addInt(columnName: String): ColumnBuilder = {
+    columns += (columnName + ":Int")
+    this
+  }
+
+  def addLong(columnName: String): ColumnBuilder = {
+    columns += (columnName + ":Long")
+    this
+  }
+
+  def addBoolean(columnName: String): ColumnBuilder = {
+    columns += (columnName + ":Boolean")
+    this
+  }
+
+  def addChar(columnName: String): ColumnBuilder = {
+    columns += (columnName + ":Char")
+    this
+  }
+
+  def build(): Array[Column] = Columns.fromNames(columns.result())
+}
+
+

vuu/src/main/scala/org/finos/vuu/core/table/Column.scala

@@ -3,6 +3,7 @@ package org.finos.vuu.core.table
 import com.typesafe.scalalogging.StrictLogging
 import org.finos.vuu.api.TableDef
 import org.finos.vuu.core.table.column.CalculatedColumnClause
+import org.finos.vuu.util.schema.ExternalEntitySchema
 import org.finos.vuu.util.types.{DefaultTypeConverters, TypeConverterContainerBuilder}
 
 import scala.util.Try
@@ -86,15 +87,21 @@ object Columns {
     table.columns.filter(c => aliased.contains(c.name)) map (c => new AliasedJoinColumn(aliased(c.name), c.index, c.dataType, table, c).asInstanceOf[Column])
   }
 
-  //def calculated(name: String, definition: String): Array[Column] = ???
-
   def allFromExcept(table: TableDef, excludeColumns: String*): Array[Column] = {
 
     val excluded = excludeColumns.map(s => s -> 1).toMap
 
     table.columns.filterNot(c => excluded.contains(c.name)).map(c => new JoinColumn(c.name, c.index, c.dataType, table, c))
   }
 
+  /**
+   * Create columns that use same name, type, order as the external entity fields
+   * */
+  def fromExternalSchema(externalSchema: ExternalEntitySchema): Array[Column] = {
+    externalSchema.fields.map(field => SimpleColumn(field.name, field.index, field.dataType))
+      .toArray
+  }
+
 }
 
 trait Column {

vuu/src/test/java/org/finos/vuu/util/ScalaList.java

@@ -0,0 +1,11 @@
+package org.finos.vuu.util;
+
+import java.util.Arrays;
+
+import static org.finos.vuu.util.ScalaCollectionConverter.toScala;
+
+public class ScalaList {
+    public static <T> scala.collection.immutable.List<T>  of(T... args) {
+        return toScala(Arrays.asList(args));
+    }
+}

vuu/src/test/java/org/finos/vuu/util/SchemaJavaTestData.java

@@ -0,0 +1,7 @@
+package org.finos.vuu.util;
+
+public class SchemaJavaTestData {
+    public String Id;
+    public int ClientId;
+    public double NotionalValue;
+}