aboutsummaryrefslogtreecommitdiffstats
path: root/config-model/src/test/java/com/yahoo/schema/document/ComplexAttributeFieldUtilsTestCase.java
diff options
context:
space:
mode:
Diffstat (limited to 'config-model/src/test/java/com/yahoo/schema/document/ComplexAttributeFieldUtilsTestCase.java')
-rw-r--r--config-model/src/test/java/com/yahoo/schema/document/ComplexAttributeFieldUtilsTestCase.java244
1 files changed, 244 insertions, 0 deletions
diff --git a/config-model/src/test/java/com/yahoo/schema/document/ComplexAttributeFieldUtilsTestCase.java b/config-model/src/test/java/com/yahoo/schema/document/ComplexAttributeFieldUtilsTestCase.java
new file mode 100644
index 00000000000..ea3f207df91
--- /dev/null
+++ b/config-model/src/test/java/com/yahoo/schema/document/ComplexAttributeFieldUtilsTestCase.java
@@ -0,0 +1,244 @@
+// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.schema.document;
+
+import com.yahoo.schema.Schema;
+import com.yahoo.schema.ApplicationBuilder;
+import com.yahoo.schema.parser.ParseException;
+import org.junit.Test;
+
+import static com.yahoo.config.model.test.TestUtil.joinLines;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class ComplexAttributeFieldUtilsTestCase {
+
+ private static class FixtureBase {
+
+ private final ImmutableSDField field;
+
+ FixtureBase(String fieldName, String sdContent) throws ParseException {
+ Schema schema = ApplicationBuilder.createFromString(sdContent).getSchema();
+ field = schema.getConcreteField(fieldName);
+ }
+
+ public ImmutableSDField field() {
+ return field;
+ }
+
+ boolean isSupportedComplexField() {
+ return ComplexAttributeFieldUtils.isSupportedComplexField(field());
+ }
+
+ boolean isArrayOfSimpleStruct() {
+ return ComplexAttributeFieldUtils.isArrayOfSimpleStruct(field());
+ }
+
+ boolean isMapOfSimpleStruct() {
+ return ComplexAttributeFieldUtils.isMapOfSimpleStruct(field());
+ }
+
+ boolean isMapOfPrimitiveType() {
+ return ComplexAttributeFieldUtils.isMapOfPrimitiveType(field());
+ }
+
+ boolean isComplexFieldWithOnlyStructFieldAttributes() {
+ return ComplexAttributeFieldUtils.isComplexFieldWithOnlyStructFieldAttributes(field());
+ }
+ }
+
+ private static class Fixture extends FixtureBase {
+
+ Fixture(String fieldName, String sdFieldContent) throws ParseException {
+ super(fieldName, joinLines("search test {",
+ " document test {",
+ " struct elem {",
+ " field name type string {}",
+ " field weight type int {}",
+ " }",
+ sdFieldContent,
+ " }",
+ "}"));
+ }
+ }
+
+ private static class ComplexFixture extends FixtureBase {
+
+ ComplexFixture(String fieldName, String sdFieldContent) throws ParseException {
+ super(fieldName, joinLines("search test {",
+ " document test {",
+ " struct elem {",
+ " field name type string {}",
+ " field weights type array<int> {}",
+ " }",
+ sdFieldContent,
+ " }",
+ "}"));
+ }
+ }
+
+ @Test
+ public void array_of_struct_with_only_struct_field_attributes_is_tagged_as_such() throws ParseException {
+ Fixture f = new Fixture("elem_array",
+ joinLines("field elem_array type array<elem> {",
+ " indexing: summary",
+ " struct-field name { indexing: attribute }",
+ " struct-field weight { indexing: attribute }",
+ "}"));
+ assertTrue(f.isSupportedComplexField());
+ assertTrue(f.isArrayOfSimpleStruct());
+ assertTrue(f.isComplexFieldWithOnlyStructFieldAttributes());
+ }
+
+ @Test
+ public void array_of_struct_with_some_struct_field_attributes_is_tagged_as_such() throws ParseException {
+ Fixture f = new Fixture("elem_array",
+ joinLines("field elem_array type array<elem> {",
+ " indexing: summary",
+ " struct-field weight { indexing: attribute }",
+ "}"));
+ assertTrue(f.isSupportedComplexField());
+ assertTrue(f.isArrayOfSimpleStruct());
+ assertFalse(f.isComplexFieldWithOnlyStructFieldAttributes());
+ }
+
+ @Test
+ public void map_of_struct_with_only_struct_field_attributes_is_tagged_as_such() throws ParseException {
+ Fixture f = new Fixture("elem_map",
+ joinLines("field elem_map type map<string, elem> {",
+ " indexing: summary",
+ " struct-field key { indexing: attribute }",
+ " struct-field value.name { indexing: attribute }",
+ " struct-field value.weight { indexing: attribute }",
+ "}"));
+ assertTrue(f.isSupportedComplexField());
+ assertTrue(f.isMapOfSimpleStruct());
+ assertFalse(f.isMapOfPrimitiveType());
+ assertTrue(f.isComplexFieldWithOnlyStructFieldAttributes());
+ }
+
+ @Test
+ public void map_of_struct_with_some_struct_field_attributes_is_tagged_as_such() throws ParseException {
+ {
+ Fixture f = new Fixture("elem_map",
+ joinLines("field elem_map type map<int, elem> {",
+ " indexing: summary",
+ " struct-field value.name { indexing: attribute }",
+ " struct-field value.weight { indexing: attribute }",
+ "}"));
+ assertTrue(f.isSupportedComplexField());
+ assertTrue(f.isMapOfSimpleStruct());
+ assertFalse(f.isMapOfPrimitiveType());
+ assertFalse(f.isComplexFieldWithOnlyStructFieldAttributes());
+ }
+ {
+ Fixture f = new Fixture("elem_map",
+ joinLines("field elem_map type map<int, elem> {",
+ " indexing: summary",
+ " struct-field key { indexing: attribute }",
+ " struct-field value.weight { indexing: attribute }",
+ "}"));
+ assertTrue(f.isSupportedComplexField());
+ assertTrue(f.isMapOfSimpleStruct());
+ assertFalse(f.isMapOfPrimitiveType());
+ assertFalse(f.isComplexFieldWithOnlyStructFieldAttributes());
+ }
+ }
+
+ @Test
+ public void map_of_primitive_type_with_only_struct_field_attributes_is_tagged_as_such() throws ParseException {
+ Fixture f = new Fixture("str_map",
+ joinLines("field str_map type map<string, string> {",
+ " indexing: summary",
+ " struct-field key { indexing: attribute }",
+ " struct-field value { indexing: attribute }",
+ "}"));
+ assertTrue(f.isSupportedComplexField());
+ assertTrue(f.isMapOfPrimitiveType());
+ assertFalse(f.isMapOfSimpleStruct());
+ assertTrue(f.isComplexFieldWithOnlyStructFieldAttributes());
+ }
+
+ @Test
+ public void map_of_primitive_type_with_some_struct_field_attributes_is_tagged_as_such() throws ParseException {
+ {
+ Fixture f = new Fixture("int_map",
+ joinLines("field int_map type map<int, int> {",
+ " indexing: summary",
+ " struct-field key { indexing: attribute }",
+ "}"));
+ assertTrue(f.isSupportedComplexField());
+ assertTrue(f.isMapOfPrimitiveType());
+ assertFalse(f.isMapOfSimpleStruct());
+ assertFalse(f.isComplexFieldWithOnlyStructFieldAttributes());
+ }
+ {
+ Fixture f = new Fixture("int_map",
+ joinLines("field int_map type map<int, int> {",
+ " indexing: summary",
+ " struct-field value { indexing: attribute }",
+ "}"));
+ assertTrue(f.isSupportedComplexField());
+ assertTrue(f.isMapOfPrimitiveType());
+ assertFalse(f.isMapOfSimpleStruct());
+ assertFalse(f.isComplexFieldWithOnlyStructFieldAttributes());
+ }
+ }
+
+ @Test
+ public void unsupported_complex_field_is_tagged_as_such() throws ParseException {
+ {
+ ComplexFixture f = new ComplexFixture("elem_array",
+ joinLines("field elem_array type array<elem> {",
+ " struct-field name { indexing: attribute }",
+ " struct-field weights { indexing: attribute }",
+ "}"));
+ assertFalse(f.isSupportedComplexField());
+ assertFalse(f.isArrayOfSimpleStruct());
+ assertFalse(f.isMapOfSimpleStruct());
+ assertFalse(f.isMapOfPrimitiveType());
+ assertFalse(f.isComplexFieldWithOnlyStructFieldAttributes());
+ }
+ {
+ ComplexFixture f = new ComplexFixture("elem_map",
+ joinLines("field elem_map type map<int, elem> {",
+ " indexing: summary",
+ " struct-field key { indexing: attribute }",
+ " struct-field value.weights { indexing: attribute }",
+ "}"));
+ assertFalse(f.isSupportedComplexField());
+ assertFalse(f.isArrayOfSimpleStruct());
+ assertFalse(f.isMapOfSimpleStruct());
+ assertFalse(f.isMapOfPrimitiveType());
+ assertFalse(f.isComplexFieldWithOnlyStructFieldAttributes());
+ }
+ }
+
+ @Test
+ public void only_struct_field_attributes_are_considered_when_tagging_a_complex_field() throws ParseException {
+ {
+ ComplexFixture f = new ComplexFixture("elem_array",
+ joinLines("field elem_array type array<elem> {",
+ " struct-field name { indexing: attribute }",
+ "}"));
+ assertTrue(f.isSupportedComplexField());
+ assertTrue(f.isArrayOfSimpleStruct());
+ assertFalse(f.isMapOfSimpleStruct());
+ assertFalse(f.isMapOfPrimitiveType());
+ assertFalse(f.isComplexFieldWithOnlyStructFieldAttributes());
+ }
+ {
+ ComplexFixture f = new ComplexFixture("elem_map",
+ joinLines("field elem_map type map<int, elem> {",
+ " indexing: summary",
+ " struct-field key { indexing: attribute }",
+ " struct-field value.name { indexing: attribute }",
+ "}"));
+ assertTrue(f.isSupportedComplexField());
+ assertFalse(f.isArrayOfSimpleStruct());
+ assertTrue(f.isMapOfSimpleStruct());
+ assertFalse(f.isMapOfPrimitiveType());
+ assertFalse(f.isComplexFieldWithOnlyStructFieldAttributes());
+ }
+ }
+
+}