HSEARCH-3319 Test: Model properties with interfaces

Author: marko-bekhta

documentation/src/test/java/org/hibernate/search/documentation/search/predicate/FieldReferenceIT.java

@@ -12,16 +12,20 @@
 import java.util.Arrays;
 import java.util.function.Consumer;
 
+import jakarta.persistence.Embeddable;
 import jakarta.persistence.Entity;
 import jakarta.persistence.EntityManagerFactory;
 import jakarta.persistence.Id;
+import jakarta.persistence.MappedSuperclass;
 
 import org.hibernate.search.documentation.testsupport.BackendConfigurations;
 import org.hibernate.search.documentation.testsupport.DocumentationSetupHelper;
 import org.hibernate.search.engine.backend.types.Projectable;
 import org.hibernate.search.engine.search.common.ValueConvert;
 import org.hibernate.search.engine.search.predicate.SearchPredicate;
-import org.hibernate.search.engine.search.reference.RootReferenceScope;
+import org.hibernate.search.engine.search.predicate.dsl.PredicateFinalStep;
+import org.hibernate.search.engine.search.predicate.dsl.SearchPredicateFactory;
+import org.hibernate.search.engine.search.reference.object.ObjectFieldReference;
 import org.hibernate.search.engine.search.reference.predicate.MatchPredicateFieldReference;
 import org.hibernate.search.engine.search.reference.projection.FieldProjectionFieldReference;
 import org.hibernate.search.mapper.orm.Search;
@@ -30,7 +34,9 @@
 import org.hibernate.search.mapper.orm.scope.SearchScopeProvider;
 import org.hibernate.search.mapper.orm.session.SearchSession;
 import org.hibernate.search.mapper.pojo.mapping.definition.annotation.FullTextField;
+import org.hibernate.search.mapper.pojo.mapping.definition.annotation.GenericField;
 import org.hibernate.search.mapper.pojo.mapping.definition.annotation.Indexed;
+import org.hibernate.search.mapper.pojo.mapping.definition.annotation.IndexedEmbedded;
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -46,7 +52,9 @@ class FieldReferenceIT {
 	@BeforeEach
 	void setup() {
 		entityManagerFactory = setupHelper.start().setup( EntityA.class, EntityB.class, EntityC.class,
-				Entity2A.class, Entity2B.class, Entity2C.class );
+				Entity2A.class, Entity2B.class, Entity2C.class,
+				ContainingA.class, ContainingB.class, EmbeddedThing1.class, EmbeddedThing2.class, EmbeddedThing3.class
+		);
 		initData();
 	}
 
@@ -127,6 +135,23 @@ void smoke2() {
 		} );
 	}
 
+	@Test
+	void smoke3() {
+
+		withinSearchSession( searchSession -> {
+
+			SearchScope<ContainingA_, ContainingA> scope = ContainingA_.scope.create( searchSession );
+
+			assertThat(
+					searchSession.search( scope )
+							.select( f -> f.field( ContainingA_.a ) )
+							.where( f -> utilMethodForPredicate( f ) )
+							.fetchHits( 20 )
+			).containsOnly( "b" );
+
+		} );
+	}
+
 	private void initData() {
 		with( entityManagerFactory ).runInTransaction( entityManager -> {
 			EntityA a = new EntityA();
@@ -195,16 +220,18 @@ public static class EntityC extends EntityB {
 
 	}
 
-	public static class EntityA_ {
-		public static ValueFieldReference1<EntityA_, String, String, String> stringA;
-
+	public static class EntityA_ implements Properties_EntityA_ {
 		public static HibernateOrmRootReferenceScope<EntityA_, EntityA> scope;
 
 		static {
-			stringA = ValueFieldReference1.of( "stringA", EntityA_.class, String.class, String.class, String.class );
-
 			scope = RootReferenceScopeImpl.of( EntityA_.class, EntityA.class );
 		}
+
+	}
+
+	public interface Properties_EntityA_ {
+		ValueFieldReference1<EntityA_, String, String, String> stringA =
+				ValueFieldReference1.of( "stringA", EntityA_.class, String.class, String.class, String.class );
 	}
 
 	public static class EntityB_ extends EntityA_ {
@@ -335,6 +362,178 @@ public static class Entity2C_ {
 		}
 	}
 
+	@MappedSuperclass
+	public static class MappedSuperclassThing {
+		@Id
+		Long id;
+
+		@FullTextField(projectable = Projectable.YES)
+		String a;
+	}
+
+	@Indexed
+	@Entity
+	public static class ContainingA extends MappedSuperclassThing {
+		@IndexedEmbedded
+		EmbeddedThing1 e1;
+		@IndexedEmbedded
+		EmbeddedThing1 e2;
+	}
+
+	@Embeddable
+	public static class EmbeddedThing1 {
+		@FullTextField
+		String a;
+		@FullTextField
+		String b;
+		// some other fields
+	}
+
+	@Embeddable
+	public static class EmbeddedThing2 {
+		@FullTextField
+		String a;
+		// some other fields maybe different from EmbeddedThing1
+	}
+
+	@Entity
+	@Indexed
+	public static class ContainingB extends MappedSuperclassThing {
+		@IndexedEmbedded
+		EmbeddedThing3 e3;
+	}
+
+	@Embeddable
+	public static class EmbeddedThing3 {
+		@GenericField
+		Integer a;
+		// some other fields maybe different from EmbeddedThing1/EmbeddedThing2
+	}
+
+
+	interface Property_String_a_ {
+		ValueFieldReference1<Property_String_a_, String, String, String> a =
+				ValueFieldReference1.of( "a", Property_String_a_.class, String.class, String.class, String.class );
+	}
+
+	interface Property_String_b_ {
+		ValueFieldReference1<Property_String_b_, String, String, String> b =
+				ValueFieldReference1.of( "b", Property_String_b_.class, String.class, String.class, String.class );
+	}
+
+	interface Property_Integer_a_ {
+		ValueFieldReference1<Property_Integer_a_, Integer, Integer, Integer> a =
+				ValueFieldReference1.of( "a", Property_Integer_a_.class, Integer.class, Integer.class, Integer.class );
+	}
+
+	public static class MappedSuperclassThing_ implements Property_String_a_ {
+
+		public static HibernateOrmRootReferenceScope<MappedSuperclassThing_, MappedSuperclassThing> scope;
+
+		static {
+			//a = ValueFieldReference1.of( "a", MappedSuperclassThing_.class, String.class, String.class, String.class );
+
+			scope = RootReferenceScopeImpl.of( MappedSuperclassThing_.class, MappedSuperclassThing.class );
+		}
+	}
+
+	public static class ContainingA_ extends MappedSuperclassThing_ {
+		public static e1_.Absolute e1;
+		public static e2_.Absolute e2;
+
+		public static HibernateOrmRootReferenceScope<ContainingA_, ContainingA> scope;
+
+		static {
+			e1 = new e1_.Absolute();
+			e2 = new e2_.Absolute();
+
+			scope = RootReferenceScopeImpl.of( ContainingA_.class, ContainingA.class );
+		}
+
+		public static class e1_ implements ObjectFieldReference<ContainingA_>, Property_String_a_, Property_String_b_ {
+
+			@Override
+			public String absolutePath() {
+				return "e1";
+			}
+
+			@Override
+			public Class<ContainingA_> scopeRootType() {
+				return ContainingA_.class;
+			}
+
+			static class Absolute extends e1_ {
+				public static ValueFieldReference1<ContainingA_, String, String, String> a;
+				public static ValueFieldReference1<ContainingA_, String, String, String> b;
+
+				static {
+					a = ValueFieldReference1.of( "e1.a", ContainingA_.class, String.class, String.class, String.class );
+					b = ValueFieldReference1.of( "e1.b", ContainingA_.class, String.class, String.class, String.class );
+				}
+			}
+		}
+
+		public static class e2_ implements ObjectFieldReference<ContainingA_>, Property_String_a_, Property_String_b_ {
+
+			@Override
+			public String absolutePath() {
+				return "e2";
+			}
+
+			@Override
+			public Class<ContainingA_> scopeRootType() {
+				return ContainingA_.class;
+			}
+
+			static class Absolute extends e2_ {
+				public static ValueFieldReference1<ContainingA_, String, String, String> a;
+				public static ValueFieldReference1<ContainingA_, String, String, String> b;
+
+				static {
+					a = ValueFieldReference1.of( "e2.a", ContainingA_.class, String.class, String.class, String.class );
+					b = ValueFieldReference1.of( "e2.b", ContainingA_.class, String.class, String.class, String.class );
+				}
+			}
+		}
+	}
+
+	public static class ContainingB_ extends MappedSuperclassThing_ {
+		public static e3_.Absolute e3;
+
+		public static HibernateOrmRootReferenceScope<ContainingB_, ContainingB> scope;
+
+		static {
+			e3 = new e3_.Absolute();
+
+			scope = RootReferenceScopeImpl.of( ContainingB_.class, ContainingB.class );
+		}
+
+		public static class e3_ implements ObjectFieldReference<ContainingB_>, Property_Integer_a_ {
+
+			@Override
+			public String absolutePath() {
+				return "e3";
+			}
+
+			@Override
+			public Class<ContainingB_> scopeRootType() {
+				return ContainingB_.class;
+			}
+
+			public static class Absolute extends e3_ {
+				public static ValueFieldReference1<ContainingB_, Integer, Integer, Integer> a;
+
+				static {
+					a = ValueFieldReference1.of( "e3.a", ContainingB_.class, Integer.class, Integer.class, Integer.class );
+				}
+			}
+		}
+	}
+
+	public static PredicateFinalStep utilMethodForPredicate(SearchPredicateFactory<? extends Property_String_a_> factory) {
+		return factory.match().field( Property_String_a_.a ).matching( "a" );
+	}
+
 
 	public static class ValueFieldReference1<E, T, V, P> extends TypedFieldReference1<E, T, P> {