Best code snippets using org.fest.assertions.ListAssert.onProperty(Showing top 15 results out of 315)

@Test
public void testIndexSharing() throws Exception {
  Session s = openSession();
  FullTextSession session = Search.getFullTextSession( s );
  Transaction tx = s.beginTransaction();
  QueryDescriptor query = ElasticsearchQueries.fromJson( "{ 'query': { 'match' : { 'title' : 'findings' } } }" );
  List<?> result = session.createFullTextQuery( query, MasterThesis.class, BachelorThesis.class ).list();
  assertThat( result ).onProperty( "title" ).containsOnly( "Great findings", "Latest findings" );
  tx.commit();
  s.close();
}

@Test
public void canUseDateParameterForSimpleComparison() {
  EntityManager entityManager = getFactory().createEntityManager();
  entityManager.getTransaction().begin();
  List<Movie> thrillers = entityManager.createQuery( "SELECT m FROM Movie m WHERE m.releaseDate = :releaseDate", Movie.class )
    .setParameter( "releaseDate", new GregorianCalendar( 1958, 3, 2 ).getTime() )
    .getResultList();
  assertThat( thrillers ).onProperty( "title" ).containsOnly( "South by Southeast" );
  entityManager.getTransaction().commit();
  entityManager.close();
}

@SuppressWarnings("unchecked")
@Test
public void testResultOrderedByIdAsString() throws Exception {
  Transaction tx = fullTextSession.beginTransaction();
  Query query = queryParser.parse( "summary:lucene" );
  FullTextQuery hibQuery = fullTextSession.createFullTextQuery( query, Book.class );
  Sort sort = new Sort( new SortField( "id", SortField.Type.STRING, false ) );
  hibQuery.setSort( sort );
  List<Book> result = hibQuery.list();
  assertNotNull( result );
  assertThat( result ).onProperty( "id" ).containsExactly( 1, 10, 2, 3 );
  tx.commit();
}

  @Test
  public void nonSpringFieldBridge() {
    Function<String, List<EntityWithSpringAwareBridges>> search = dao::searchNonSpringBridge;

    assertThat( search.apply( NonSpringBridge.PREFIX + InternationalizedValue.HELLO.name() ) ).onProperty( "id" ).isEmpty();

    EntityWithSpringAwareBridges entity = new EntityWithSpringAwareBridges();
    entity.setInternationalizedValue( InternationalizedValue.HELLO );
    dao.create( entity );
    assertThat( search.apply( NonSpringBridge.PREFIX + InternationalizedValue.HELLO.name() ) ).onProperty( "id" ).containsOnly( entity.getId() );
  }
}

@Test
@Ignore("TODO HQLPARSER-59")
public void canUseDateLiteralForSimpleComparison() {
  EntityManager entityManager = getFactory().createEntityManager();
  entityManager.getTransaction().begin();
  List<Movie> thrillers = entityManager.createQuery( "SELECT m FROM Movie m WHERE m.releaseDate = '02 April 1958'", Movie.class )
    .getResultList();
  assertThat( thrillers ).onProperty( "title" ).containsOnly( "South by Southeast" );
  entityManager.getTransaction().commit();
  entityManager.close();
}

@Test
public void testElasticsearchFilterWithParameters() {
  Session s = openSession();
  FullTextSession fullTextSession = Search.getFullTextSession( s );
  Transaction tx = s.beginTransaction();
  FullTextQuery ftQuery = fullTextSession.createFullTextQuery( ElasticsearchQueries.fromJson( "{ 'query': { 'match_all': {} } }" ), Driver.class );
  ftQuery.enableFullTextFilter( "namedDriver" )
      .setParameter( "name", "liz" );
  assertThat( ftQuery.list() ).onProperty( "name" ).containsOnly( "Liz" );
  tx.commit();
  s.close();
}

@Test
public void testMultipleFieldIgnoreAnalyzer() throws Exception {
  try ( Session session = openSession() ) {
    FullTextSession fullTextSession = Search.getFullTextSession( session );
    Tweet tweet = new Tweet();
    tweet.setMultipleTweets( "close OPEN SOURCE test1" );
    tweet( session, tweet );
    @SuppressWarnings("unchecked")
    List<Tweet> expectedResult = fullTextSession.createFullTextQuery( termQuery( "tweetNotAnalyzed", "close OPEN SOURCE test1" ), Tweet.class ).list();
    assertThat( expectedResult ).onProperty( "multipleTweets" ).containsExactly( tweet.getMultipleTweets() );
  }
}

@Test
public void canUseEnumAsParameterForSimpleComparison() {
  EntityManager entityManager = getFactory().createEntityManager();
  entityManager.getTransaction().begin();
  List<Movie> thrillers = entityManager.createQuery( "SELECT m FROM Movie m WHERE m.genre = :genre", Movie.class )
    .setParameter( "genre", Genre.THRILLER )
    .getResultList();
  assertThat( thrillers ).onProperty( "title" ).containsOnly( "South by Southeast", "Front Door" );
  entityManager.getTransaction().commit();
  entityManager.close();
}

@Test
public void canUseByteForSimpleComparison() {
  EntityManager entityManager = getFactory().createEntityManager();
  entityManager.getTransaction().begin();
  List<Movie> thrillers = entityManager.createQuery( "SELECT m FROM Movie m WHERE m.viewerRating = 8", Movie.class )
    .getResultList();
  assertThat( thrillers ).onProperty( "title" ).containsOnly( "To thatch a roof" );
  entityManager.getTransaction().commit();
  entityManager.close();
}

@Test
public void testRestrictionByType() throws Exception {
  Session s = openSession();
  FullTextSession session = Search.getFullTextSession( s );
  Transaction tx = s.beginTransaction();
  QueryDescriptor query = ElasticsearchQueries.fromJson( "{ 'query': { 'match' : { 'abstract' : 'Hibernate' } } }" );
  List<?> result = session.createFullTextQuery( query, ResearchPaper.class ).list();
  assertThat( result ).onProperty( "title" ).containsOnly( "Very important research on Hibernate", "Some research" );
  tx.commit();
  s.close();
}

@Test
public void canUseByteAsParameterForSimpleComparison() {
  EntityManager entityManager = getFactory().createEntityManager();
  entityManager.getTransaction().begin();
  List<Movie> thrillers = entityManager.createQuery( "SELECT m FROM Movie m WHERE m.viewerRating = :viewerRating", Movie.class )
    .setParameter( "viewerRating", (byte) 8 )
    .getResultList();
  assertThat( thrillers ).onProperty( "title" ).containsOnly( "To thatch a roof" );
  entityManager.getTransaction().commit();
  entityManager.close();
}

@Test
public void canUseBooleanAsParameterForSimpleComparison() {
  EntityManager entityManager = getFactory().createEntityManager();
  entityManager.getTransaction().begin();
  List<Movie> thrillers = entityManager.createQuery( "SELECT m FROM Movie m WHERE m.suitableForKids = :suitable", Movie.class )
    .setParameter( "suitable", Boolean.FALSE )
    .getResultList();
  assertThat( thrillers ).onProperty( "title" ).containsOnly( "Front Door", "Barnie" );
  entityManager.getTransaction().commit();
  entityManager.close();
}

@Test
@Ignore("TODO HQLPARSER-59")
public void canUseEnumLiteralForSimpleComparison() {
  EntityManager entityManager = getFactory().createEntityManager();
  entityManager.getTransaction().begin();
  List<Movie> thrillers = entityManager.createQuery( "SELECT m FROM Movie m WHERE m.genre = org.hibernate.ogm.backendtck.queries.enums.Genre.THRILLER", Movie.class )
    .getResultList();
  assertThat( thrillers ).onProperty( "title" ).containsOnly( "South by Southeast", "Front Door" );
  entityManager.getTransaction().commit();
  entityManager.close();
}

@Test
@Ignore("TODO HQLPARSER-59")
public void canUseBooleanLiteralForSimpleComparison() {
  EntityManager entityManager = getFactory().createEntityManager();
  entityManager.getTransaction().begin();
  List<Movie> thrillers = entityManager.createQuery( "SELECT m FROM Movie m WHERE m.suitableForKids = FALSE", Movie.class )
    .getResultList();
  assertThat( thrillers ).onProperty( "title" ).containsOnly( "Front Door", "Barnie" );
  entityManager.getTransaction().commit();
  entityManager.close();
}

@Test
public void testNumericFieldQuery() throws Exception {
  Session s = openSession();
  FullTextSession session = Search.getFullTextSession( s );
  Transaction tx = s.beginTransaction();
  QueryDescriptor query = ElasticsearchQueries.fromJson( "{ 'query': { 'range' : { 'wordCount' : { 'gte' : 8, 'lt' : 10 } } } }" );
  List<?> result = session.createFullTextQuery( query ).list();
  assertThat( result ).onProperty( "title" ).containsOnly( "Latest in ORM", "ORM for beginners" );
  tx.commit();
  s.close();
}