Hibernate/hibernate-orm
1
0
Fork 0
mirror of https://github.com/hibernate/hibernate-orm synced 2025-02-17 16:44:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

HHH-15406 Tests annotated with org.hibernate.testing.RequiresDialect having as value a deprecated dialect are not executed

Browse Source
This commit is contained in:
Andrea Boriero 2022-07-20 13:16:41 +02:00 committed by Andrea Boriero
parent 38589b5e7b
commit 0f599da6c4
17 changed files with 562 additions and 528 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
documentation/src/test/java/org/hibernate/userguide/inheritance/SingleTableDiscriminatorFormulaTest.java
View File

@ -15,32 +15,30 @@
import jakarta.persistence.InheritanceType;
import org.hibernate.annotations.DiscriminatorFormula;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.orm.test.jpa.BaseEntityManagerFunctionalTestCase;
import org.hibernate.dialect.PostgreSQLDialect;
import org.hibernate.testing.RequiresDialect;
import org.junit.Assert;
import org.junit.Test;
import org.hibernate.testing.orm.junit.EntityManagerFactoryScope;
import org.hibernate.testing.orm.junit.Jpa;
import org.hibernate.testing.orm.junit.RequiresDialect;
import org.junit.jupiter.api.Test;
import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
import static org.junit.jupiter.api.Assertions.assertEquals;
/**
* @author Vlad Mihalcea
*/
public class SingleTableDiscriminatorFormulaTest extends BaseEntityManagerFunctionalTestCase {
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class<?>[] {
DebitAccount.class,
CreditAccount.class,
};
@Jpa(
annotatedClasses = {
SingleTableDiscriminatorFormulaTest.DebitAccount.class,
SingleTableDiscriminatorFormulaTest.CreditAccount.class,
}
)
public class SingleTableDiscriminatorFormulaTest {
@Test
@RequiresDialect({PostgreSQL81Dialect.class})
public void test() {
doInJPA(this::entityManagerFactory, entityManager -> {
@RequiresDialect(value = PostgreSQLDialect.class, majorVersion = 8, minorVersion = 1)
public void test(EntityManagerFactoryScope scope) {
scope.inTransaction(entityManager -> {
DebitAccount debitAccount = new DebitAccount("123-debit");
debitAccount.setId(1L);
debitAccount.setOwner("John Doe");
@ -59,10 +57,10 @@ public void test() {
entityManager.persist(creditAccount);
});
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction(entityManager -> {
List<Account> accounts =
entityManager.createQuery("select a from Account a").getResultList();
Assert.assertEquals(2, accounts.size());
assertEquals(2, accounts.size());
});
}

81
documentation/src/test/java/org/hibernate/userguide/locking/ExplicitLockingTest.java
View File

@ -23,38 +23,51 @@
import org.hibernate.LockMode;
import org.hibernate.LockOptions;
import org.hibernate.Session;
import org.hibernate.dialect.Oracle8iDialect;
import org.hibernate.orm.test.jpa.BaseEntityManagerFunctionalTestCase;
import org.hibernate.dialect.OracleDialect;
import org.hibernate.query.Query;
import org.hibernate.testing.RequiresDialect;
import org.junit.Test;
import org.hibernate.testing.orm.junit.EntityManagerFactoryScope;
import org.hibernate.testing.orm.junit.Jpa;
import org.hibernate.testing.orm.junit.RequiresDialect;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
import org.jboss.logging.Logger;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
import static org.junit.Assert.assertEquals;
/**
* @author Vlad Mihalcea
*/
public class ExplicitLockingTest extends BaseEntityManagerFunctionalTestCase {
@Jpa(
annotatedClasses = {
ExplicitLockingTest.Person.class,
ExplicitLockingTest.Phone.class,
}
)
public class ExplicitLockingTest {
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class<?>[] {
Person.class,
Phone.class,
};
protected final Logger log = Logger.getLogger( getClass() );
@AfterEach
public void tearDown(EntityManagerFactoryScope scope) {
scope.inTransaction(
entityManager ->
entityManager.createQuery( "delete from Person" ).executeUpdate()
);
}
@Test
public void testJPALockTimeout() {
doInJPA(this::entityManagerFactory, entityManager -> {
public void testJPALockTimeout(EntityManagerFactoryScope scope) {
Person p = scope.fromTransaction( entityManager -> {
Person person = new Person("John Doe");
entityManager.persist(person);
return person;
});
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
log.info("testJPALockTimeout");
Long id = 1L;
Long id = p.getId();
//tag::locking-jpa-query-hints-timeout-example[]
entityManager.find(
Person.class, id, LockModeType.PESSIMISTIC_WRITE,
@ -65,8 +78,8 @@ public void testJPALockTimeout() {
}
@Test
public void testJPALockScope() {
doInJPA(this::entityManagerFactory, entityManager -> {
public void testJPALockScope(EntityManagerFactoryScope scope) {
Person p = scope.fromTransaction( entityManager -> {
Person person = new Person("John Doe");
entityManager.persist(person);
Phone home = new Phone("123-456-7890");
@ -74,10 +87,11 @@ public void testJPALockScope() {
person.getPhones().add(home);
person.getPhones().add(office);
entityManager.persist(person);
return person;
});
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
log.info("testJPALockScope");
Long id = 1L;
Long id = p.getId();
//tag::locking-jpa-query-hints-scope-example[]
Person person = entityManager.find(
Person.class, id, LockModeType.PESSIMISTIC_WRITE,
@ -91,8 +105,8 @@ public void testJPALockScope() {
}
@Test
public void testBuildLockRequest() {
doInJPA(this::entityManagerFactory, entityManager -> {
public void testBuildLockRequest(EntityManagerFactoryScope scope) {
Person p = scope.fromTransaction( entityManager -> {
log.info("testBuildLockRequest");
Person person = new Person("John Doe");
Phone home = new Phone("123-456-7890");
@ -101,9 +115,10 @@ public void testBuildLockRequest() {
person.getPhones().add(office);
entityManager.persist(person);
entityManager.flush();
return person;
});
doInJPA(this::entityManagerFactory, entityManager -> {
Long id = 1L;
scope.inTransaction( entityManager -> {
Long id = p.getId();
//tag::locking-buildLockRequest-example[]
Person person = entityManager.find(Person.class, id);
Session session = entityManager.unwrap(Session.class);
@ -115,8 +130,8 @@ public void testBuildLockRequest() {
//end::locking-buildLockRequest-example[]
});
doInJPA(this::entityManagerFactory, entityManager -> {
Long id = 1L;
scope.inTransaction( entityManager -> {
Long id = p.getId();
//tag::locking-buildLockRequest-scope-example[]
Person person = entityManager.find(Person.class, id);
Session session = entityManager.unwrap(Session.class);
@ -132,9 +147,9 @@ public void testBuildLockRequest() {
}
@Test
@RequiresDialect(Oracle8iDialect.class)
public void testFollowOnLocking() {
doInJPA(this::entityManagerFactory, entityManager -> {
@RequiresDialect(value = OracleDialect.class, majorVersion = 8)
public void testFollowOnLocking(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
log.info("testBuildLockRequest");
Person person1 = new Person("John Doe");
Person person2 = new Person("Mrs. John Doe");
@ -144,7 +159,7 @@ public void testFollowOnLocking() {
entityManager.flush();
});
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
//tag::locking-follow-on-example[]
List<Person> persons = entityManager.createQuery(
"select DISTINCT p from Person p", Person.class)
@ -153,7 +168,7 @@ public void testFollowOnLocking() {
//end::locking-follow-on-example[]
});
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
//tag::locking-follow-on-secondary-query-example[]
List<Person> persons = entityManager.createQuery(
"select DISTINCT p from Person p", Person.class)
@ -167,7 +182,7 @@ public void testFollowOnLocking() {
//end::locking-follow-on-secondary-query-example[]
});
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
//tag::locking-follow-on-explicit-example[]
List<Person> persons = entityManager.createQuery(
"select p from Person p", Person.class)

30
documentation/src/test/java/org/hibernate/userguide/mapping/generated/GeneratedTest.java
View File

@ -13,30 +13,26 @@
import org.hibernate.annotations.Generated;
import org.hibernate.annotations.GenerationTime;
import org.hibernate.dialect.SQLServer2005Dialect;
import org.hibernate.orm.test.jpa.BaseEntityManagerFunctionalTestCase;
import org.hibernate.testing.RequiresDialect;
import org.junit.Test;
import org.hibernate.testing.orm.junit.EntityManagerFactoryScope;
import org.hibernate.testing.orm.junit.Jpa;
import org.hibernate.testing.orm.junit.RequiresDialect;
import org.junit.jupiter.api.Test;
import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
/**
* @author Vlad Mihalcea
*/
@RequiresDialect(SQLServer2005Dialect.class)
public class GeneratedTest extends BaseEntityManagerFunctionalTestCase {
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class<?>[] {
Person.class
};
}
@RequiresDialect(value = SQLServer2005Dialect.class, majorVersion = 9)
@Jpa(
annotatedClasses = GeneratedTest.Person.class
)
public class GeneratedTest {
@Test
public void test() {
doInJPA(this::entityManagerFactory, entityManager -> {
public void test(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
//tag::mapping-generated-Generated-persist-example[]
Person person = new Person();
person.setId(1L);
@ -54,7 +50,7 @@ public void test() {
assertEquals("John Flávio André Frederico Rúben Artur Doe", person.getFullName());
//end::mapping-generated-Generated-persist-example[]
});
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
//tag::mapping-generated-Generated-update-example[]
Person person = entityManager.find(Person.class, 1L);
person.setLastName("Doe Jr");

31
documentation/src/test/java/org/hibernate/userguide/mapping/identifier/RowIdTest.java
View File

@ -11,37 +11,32 @@
import jakarta.persistence.Id;
import org.hibernate.annotations.RowId;
import org.hibernate.dialect.Oracle8iDialect;
import org.hibernate.orm.test.jpa.BaseEntityManagerFunctionalTestCase;
import org.hibernate.dialect.OracleDialect;
import org.hibernate.testing.RequiresDialect;
import org.junit.Test;
import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
import org.hibernate.testing.orm.junit.EntityManagerFactoryScope;
import org.hibernate.testing.orm.junit.Jpa;
import org.hibernate.testing.orm.junit.RequiresDialect;
import org.junit.jupiter.api.Test;
/**
* @author Vlad Mihalcea
*/
@RequiresDialect(Oracle8iDialect.class)
public class RowIdTest extends BaseEntityManagerFunctionalTestCase {
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class<?>[] {
Product.class
};
}
@RequiresDialect(value = OracleDialect.class, majorVersion = 8)
@Jpa(
annotatedClasses = RowIdTest.Product.class
)
public class RowIdTest {
@Test
public void test() {
doInJPA(this::entityManagerFactory, entityManager -> {
public void test(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
Product product = new Product();
product.setId(1L);
product.setName("Mobile phone");
product.setNumber("123-456-7890");
entityManager.persist(product);
});
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
//tag::identifiers-rowid-example[]
Product product = entityManager.find(Product.class, 1L);

61
documentation/src/test/java/org/hibernate/userguide/schema/SchemaGenerationTest.java → documentation/src/test/java/org/hibernate/userguide/schema/BaseSchemaGeneratorTest.java
View File

@ -9,8 +9,11 @@
import java.sql.Blob;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import org.hibernate.annotations.LazyGroup;
import org.hibernate.annotations.NaturalId;
import jakarta.persistence.Basic;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
@ -19,61 +22,7 @@
import jakarta.persistence.ManyToOne;
import jakarta.persistence.OneToMany;
import org.hibernate.annotations.LazyGroup;
import org.hibernate.annotations.NaturalId;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.dialect.H2Dialect;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.orm.test.jpa.BaseEntityManagerFunctionalTestCase;
import org.hibernate.testing.RequiresDialect;
import org.junit.Test;
/**
* @author Vlad Mihalcea
*/
public class SchemaGenerationTest extends BaseEntityManagerFunctionalTestCase {
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class<?>[] {
Person.class,
Book.class,
Customer.class
};
}
@Override
protected Map buildSettings() {
Map settings = super.buildSettings();
if (getDialect().getClass().equals(H2Dialect.class)) {
settings.put(
AvailableSettings.HBM2DDL_IMPORT_FILES,
"schema-generation.sql"
);
settings.put(AvailableSettings.HBM2DDL_AUTO, "update");
}
return settings;
}
@Override
protected String[] getMappings() {
if (PostgreSQL81Dialect.class.isAssignableFrom(getDialect().getClass())) {
return new String[] { "org/hibernate/userguide/schema/SchemaGenerationTest.hbm.xml" };
}
return super.getMappings();
}
@Test
@RequiresDialect(H2Dialect.class)
public void testH2() {
}
@Test
@RequiresDialect(PostgreSQL81Dialect.class)
public void testPostgres() {
}
public abstract class BaseSchemaGeneratorTest {
//tag::schema-generation-domain-model-example[]
@Entity(name = "Customer")
public class Customer {

38
documentation/src/test/java/org/hibernate/userguide/schema/H2SchemaGenerationTest.java Normal file
View File

@ -0,0 +1,38 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
package org.hibernate.userguide.schema;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.dialect.H2Dialect;
import org.hibernate.testing.orm.junit.Jpa;
import org.hibernate.testing.orm.junit.RequiresDialect;
import org.hibernate.testing.orm.junit.Setting;
import org.junit.jupiter.api.Test;
/**
* @author Vlad Mihalcea
*/
@RequiresDialect( H2Dialect.class )
@Jpa(
annotatedClasses = {
BaseSchemaGeneratorTest.Person.class,
BaseSchemaGeneratorTest.Book.class,
BaseSchemaGeneratorTest.Customer.class
},
integrationSettings = {
@Setting( name = AvailableSettings.HBM2DDL_IMPORT_FILES, value = "schema-generation.sql"),
@Setting( name = AvailableSettings.HBM2DDL_AUTO, value = "update")
}
)
public class H2SchemaGenerationTest extends BaseSchemaGeneratorTest {
@Test
public void testH2() {
}
}

34
documentation/src/test/java/org/hibernate/userguide/schema/PostgreSQLSchemaGenerationTest.java Normal file
View File

@ -0,0 +1,34 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
package org.hibernate.userguide.schema;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.dialect.PostgreSQLDialect;
import org.hibernate.testing.orm.junit.Jpa;
import org.hibernate.testing.orm.junit.RequiresDialect;
import org.hibernate.testing.orm.junit.Setting;
import org.junit.jupiter.api.Test;
@RequiresDialect(value = PostgreSQLDialect.class, majorVersion = 8)
@Jpa(
annotatedClasses = {
BaseSchemaGeneratorTest.Person.class,
BaseSchemaGeneratorTest.Book.class,
BaseSchemaGeneratorTest.Customer.class
},
xmlMappings = "org/hibernate/userguide/schema/SchemaGenerationTest.hbm.xml",
integrationSettings = {
@Setting(name = AvailableSettings.HBM2DDL_IMPORT_FILES, value = "schema-generation.sql"),
@Setting(name = AvailableSettings.HBM2DDL_AUTO, value = "update")
}
)
public class PostgreSQLSchemaGenerationTest extends BaseSchemaGeneratorTest {
@Test
public void testPostgres() {
}
}

95
documentation/src/test/java/org/hibernate/userguide/sql/MySQLStoredProcedureTest.java
View File

@ -8,52 +8,58 @@
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
import java.util.regex.Pattern;
import jakarta.persistence.ParameterMode;
import jakarta.persistence.StoredProcedureQuery;
import org.hibernate.Session;
import org.hibernate.dialect.MySQL5Dialect;
import org.hibernate.orm.test.jpa.BaseEntityManagerFunctionalTestCase;
import org.hibernate.dialect.MySQLDialect;
import org.hibernate.dialect.TiDBDialect;
import org.hibernate.procedure.ProcedureCall;
import org.hibernate.query.procedure.ProcedureParameter;
import org.hibernate.result.Output;
import org.hibernate.result.ResultSetOutput;
import org.hibernate.userguide.model.Account;
import org.hibernate.userguide.model.AddressType;
import org.hibernate.userguide.model.Call;
import org.hibernate.userguide.model.Partner;
import org.hibernate.userguide.model.Payment;
import org.hibernate.userguide.model.Person;
import org.hibernate.userguide.model.Phone;
import org.hibernate.userguide.model.PhoneType;
import org.hibernate.testing.RequiresDialect;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.hibernate.testing.orm.junit.EntityManagerFactoryScope;
import org.hibernate.testing.orm.junit.Jpa;
import org.hibernate.testing.orm.junit.RequiresDialect;
import org.hibernate.testing.orm.junit.SkipForDialect;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import jakarta.persistence.ParameterMode;
import jakarta.persistence.StoredProcedureQuery;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* @author Vlad Mihalcea
*/
@RequiresDialect(MySQL5Dialect.class)
public class MySQLStoredProcedureTest extends BaseEntityManagerFunctionalTestCase {
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class<?>[] {
@RequiresDialect(value = MySQLDialect.class, majorVersion = 5)
@SkipForDialect(dialectClass = TiDBDialect.class, reason = "TiDB doesn't support stored procedures")
@Jpa(
annotatedClasses = {
Person.class,
Partner.class,
Phone.class,
Call.class,
};
Payment.class,
Account.class
}
)
public class MySQLStoredProcedureTest {
@Before
public void init() {
destroy();
doInJPA(this::entityManagerFactory, entityManager -> {
@BeforeAll
public void init(EntityManagerFactoryScope scope) {
destroy( scope );
scope.inTransaction( entityManager -> {
Session session = entityManager.unwrap( Session.class );
session.doWork( connection -> {
try (Statement statement = connection.createStatement()) {
@ -98,7 +104,7 @@ public void init() {
}
} );
} );
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
Person person1 = new Person( "John Doe" );
person1.setNickName( "JD" );
person1.setAddress( "Earth" );
@ -122,9 +128,9 @@ public void init() {
} );
}
@After
public void destroy() {
doInJPA(this::entityManagerFactory, entityManager -> {
@AfterAll
public void destroy(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
Session session = entityManager.unwrap( Session.class );
session.doWork( connection -> {
try (Statement statement = connection.createStatement()) {
@ -134,7 +140,7 @@ public void destroy() {
}
} );
} );
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
Session session = entityManager.unwrap( Session.class );
session.doWork( connection -> {
try (Statement statement = connection.createStatement()) {
@ -144,7 +150,7 @@ public void destroy() {
}
} );
} );
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
Session session = entityManager.unwrap( Session.class );
session.doWork( connection -> {
try (Statement statement = connection.createStatement()) {
@ -157,8 +163,8 @@ public void destroy() {
}
@Test
public void testStoredProcedureOutParameter() {
doInJPA(this::entityManagerFactory, entityManager -> {
public void testStoredProcedureOutParameter(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
//tag::sql-jpa-call-sp-out-mysql-example[]
StoredProcedureQuery query = entityManager.createStoredProcedureQuery( "sp_count_phones" );
query.registerStoredProcedureParameter( "personId", Long.class, ParameterMode.IN );
@ -169,13 +175,13 @@ public void testStoredProcedureOutParameter() {
query.execute();
Long phoneCount = (Long) query.getOutputParameterValue( "phoneCount" );
//end::sql-jpa-call-sp-out-mysql-example[]
assertEquals(Long.valueOf(2), phoneCount);
assertEquals( 2l, phoneCount );
} );
}
@Test
public void testHibernateProcedureCallOutParameter() {
doInJPA(this::entityManagerFactory, entityManager -> {
public void testHibernateProcedureCallOutParameter(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
//tag::sql-hibernate-call-sp-out-mysql-example[]
Session session = entityManager.unwrap( Session.class );
@ -191,9 +197,9 @@ public void testHibernateProcedureCallOutParameter() {
}
@Test
public void testStoredProcedureRefCursor() {
public void testStoredProcedureRefCursor(EntityManagerFactoryScope scope) {
try {
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
StoredProcedureQuery query = entityManager.createStoredProcedureQuery( "sp_phones" );
query.registerStoredProcedureParameter( 1, void.class, ParameterMode.REF_CURSOR );
query.registerStoredProcedureParameter( 2, Long.class, ParameterMode.IN );
@ -203,14 +209,17 @@ public void testStoredProcedureRefCursor() {
List<Object[]> personComments = query.getResultList();
assertEquals( 2, personComments.size() );
} );
} catch (Exception e) {
assertTrue(Pattern.compile("Dialect .*? not known to support REF_CURSOR parameters").matcher(e.getCause().getMessage()).matches());
}
catch (Exception e) {
assertTrue( Pattern.compile( "Dialect .*? not known to support REF_CURSOR parameters" )
.matcher( e.getCause().getMessage() )
.matches() );
}
}
@Test
public void testStoredProcedureReturnValue() {
doInJPA(this::entityManagerFactory, entityManager -> {
public void testStoredProcedureReturnValue(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
//tag::sql-jpa-call-sp-no-out-mysql-example[]
StoredProcedureQuery query = entityManager.createStoredProcedureQuery( "sp_phones" );
query.registerStoredProcedureParameter( 1, Long.class, ParameterMode.IN );
@ -224,8 +233,8 @@ public void testStoredProcedureReturnValue() {
}
@Test
public void testHibernateProcedureCallReturnValueParameter() {
doInJPA(this::entityManagerFactory, entityManager -> {
public void testHibernateProcedureCallReturnValueParameter(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
//tag::sql-hibernate-call-sp-no-out-mysql-example[]
Session session = entityManager.unwrap( Session.class );
@ -242,8 +251,8 @@ public void testHibernateProcedureCallReturnValueParameter() {
}
@Test
public void testFunctionWithJDBC() {
doInJPA(this::entityManagerFactory, entityManager -> {
public void testFunctionWithJDBC(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
//tag::sql-call-function-mysql-example[]
final AtomicReference<Integer> phoneCount = new AtomicReference<>();
Session session = entityManager.unwrap( Session.class );

59
documentation/src/test/java/org/hibernate/userguide/sql/OracleCustomSQLWithStoredProcedureTest.java
View File

@ -7,44 +7,42 @@
package org.hibernate.userguide.sql;
import java.sql.Statement;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.Id;
import jakarta.persistence.NamedNativeQueries;
import jakarta.persistence.NamedNativeQuery;
import org.hibernate.Session;
import org.hibernate.annotations.Loader;
import org.hibernate.annotations.ResultCheckStyle;
import org.hibernate.annotations.SQLDelete;
import org.hibernate.annotations.SQLInsert;
import org.hibernate.dialect.Oracle8iDialect;
import org.hibernate.orm.test.jpa.BaseEntityManagerFunctionalTestCase;
import org.hibernate.dialect.OracleDialect;
import org.hibernate.testing.RequiresDialect;
import org.junit.Before;
import org.junit.Test;
import org.hibernate.testing.orm.junit.EntityManagerFactoryScope;
import org.hibernate.testing.orm.junit.Jpa;
import org.hibernate.testing.orm.junit.RequiresDialect;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.Id;
import jakarta.persistence.NamedNativeQueries;
import jakarta.persistence.NamedNativeQuery;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
/**
* @author Vlad Mihalcea
*/
@RequiresDialect(Oracle8iDialect.class)
public class OracleCustomSQLWithStoredProcedureTest extends BaseEntityManagerFunctionalTestCase {
@RequiresDialect(value = OracleDialect.class, majorVersion = 8)
@Jpa(
annotatedClasses = OracleCustomSQLWithStoredProcedureTest.Person.class
)
public class OracleCustomSQLWithStoredProcedureTest {
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class<?>[] {
Person.class
};
}
@Before
public void init() {
doInJPA(this::entityManagerFactory, entityManager -> {
@BeforeAll
public void init(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
Session session = entityManager.unwrap( Session.class );
session.doWork( connection -> {
try (Statement statement = connection.createStatement();) {
@ -57,30 +55,31 @@ public void init() {
"BEGIN " +
" UPDATE person SET valid = 0 WHERE id = personId; " +
"END;"
);}
);
}
//end::sql-sp-soft-delete-example[]
} );
} );
}
@Test
public void test_sql_custom_crud() {
public void test_sql_custom_crud(EntityManagerFactoryScope scope) {
Person _person = doInJPA(this::entityManagerFactory, entityManager -> {
Person _person = scope.fromTransaction( entityManager -> {
Person person = new Person();
person.setName( "John Doe" );
entityManager.persist( person );
return person;
} );
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
Long postId = _person.getId();
Person person = entityManager.find( Person.class, postId );
assertNotNull( person );
entityManager.remove( person );
} );
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
Long postId = _person.getId();
Person person = entityManager.find( Person.class, postId );
assertNull( person );

87
documentation/src/test/java/org/hibernate/userguide/sql/OracleStoredProcedureTest.java
View File

@ -3,55 +3,57 @@
import java.math.BigDecimal;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Timestamp;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.List;
import jakarta.persistence.ParameterMode;
import jakarta.persistence.StoredProcedureQuery;
import org.hibernate.Session;
import org.hibernate.dialect.Oracle8iDialect;
import org.hibernate.orm.test.jpa.BaseEntityManagerFunctionalTestCase;
import org.hibernate.dialect.OracleDialect;
import org.hibernate.procedure.ProcedureCall;
import org.hibernate.query.procedure.ProcedureParameter;
import org.hibernate.result.Output;
import org.hibernate.result.ResultSetOutput;
import org.hibernate.userguide.model.Account;
import org.hibernate.userguide.model.AddressType;
import org.hibernate.userguide.model.Call;
import org.hibernate.userguide.model.Partner;
import org.hibernate.userguide.model.Payment;
import org.hibernate.userguide.model.Person;
import org.hibernate.userguide.model.Phone;
import org.hibernate.userguide.model.PhoneType;
import org.hibernate.testing.RequiresDialect;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.hibernate.testing.orm.junit.EntityManagerFactoryScope;
import org.hibernate.testing.orm.junit.Jpa;
import org.hibernate.testing.orm.junit.RequiresDialect;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import jakarta.persistence.ParameterMode;
import jakarta.persistence.StoredProcedureQuery;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
/**
* @author Vlad Mihalcea
*/
@RequiresDialect(Oracle8iDialect.class)
public class OracleStoredProcedureTest extends BaseEntityManagerFunctionalTestCase {
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class<?>[] {
@RequiresDialect(value = OracleDialect.class, majorVersion = 8)
@Jpa(
annotatedClasses = {
Person.class,
Partner.class,
Phone.class,
Call.class,
};
Payment.class,
Account.class
}
)
public class OracleStoredProcedureTest {
@Before
public void init() {
doInJPA(this::entityManagerFactory, entityManager -> {
@BeforeAll
public void init(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
Session session = entityManager.unwrap(Session.class);
session.doWork(connection -> {
try(Statement statement = connection.createStatement()) {
@ -96,7 +98,7 @@ public void init() {
}
});
});
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
Person person1 = new Person("John Doe");
person1.setNickName("JD");
person1.setAddress("Earth");
@ -120,9 +122,9 @@ public void init() {
});
}
@After
public void destroy() {
doInJPA(this::entityManagerFactory, entityManager -> {
@AfterAll
public void destroy(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
Session session = entityManager.unwrap(Session.class);
session.doWork(connection -> {
try(Statement statement = connection.createStatement()) {
@ -132,7 +134,7 @@ public void destroy() {
}
});
});
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
Session session = entityManager.unwrap(Session.class);
session.doWork(connection -> {
try(Statement statement = connection.createStatement()) {
@ -142,7 +144,7 @@ public void destroy() {
}
});
});
doInJPA(this::entityManagerFactory, entityManager -> {
scope.inTransaction( entityManager -> {
Session session = entityManager.unwrap(Session.class);
session.doWork(connection -> {
try(Statement statement = connection.createStatement()) {
@ -155,8 +157,8 @@ public void destroy() {
}
@Test
public void testStoredProcedureOutParameter() {
doInJPA(this::entityManagerFactory, entityManager -> {
public void testStoredProcedureOutParameter(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
StoredProcedureQuery query = entityManager.createStoredProcedureQuery("sp_count_phones");
query.registerStoredProcedureParameter(1, Long.class, ParameterMode.IN);
query.registerStoredProcedureParameter(2, Long.class, ParameterMode.OUT);
@ -165,13 +167,13 @@ public void testStoredProcedureOutParameter() {
query.execute();
Long phoneCount = (Long) query.getOutputParameterValue(2);
assertEquals(Long.valueOf(2), phoneCount);
assertEquals(2l, phoneCount);
});
}
@Test
public void testStoredProcedureRefCursor() {
doInJPA(this::entityManagerFactory, entityManager -> {
public void testStoredProcedureRefCursor(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
//tag::sql-jpa-call-sp-ref-cursor-oracle-example[]
StoredProcedureQuery query = entityManager.createStoredProcedureQuery("sp_person_phones");
query.registerStoredProcedureParameter(1, Long.class, ParameterMode.IN);
@ -186,8 +188,8 @@ public void testStoredProcedureRefCursor() {
}
@Test
public void testStoredProcedureRefCursorUsingNamedQuery() {
doInJPA(this::entityManagerFactory, entityManager -> {
public void testStoredProcedureRefCursorUsingNamedQuery(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
//tag::sql-jpa-call-sp-ref-cursor-oracle-named-query-example[]
List<Object[]> postComments = entityManager
.createNamedStoredProcedureQuery("sp_person_phones")
@ -200,8 +202,8 @@ public void testStoredProcedureRefCursorUsingNamedQuery() {
}
@Test
public void testHibernateProcedureCallRefCursor() {
doInJPA(this::entityManagerFactory, entityManager -> {
public void testHibernateProcedureCallRefCursor(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
//tag::sql-hibernate-call-sp-ref-cursor-oracle-example[]
Session session = entityManager.unwrap(Session.class);
@ -218,9 +220,8 @@ public void testHibernateProcedureCallRefCursor() {
}
@Test
public void testStoredProcedureReturnValue() {
try {
doInJPA(this::entityManagerFactory, entityManager -> {
public void testStoredProcedureReturnValue(EntityManagerFactoryScope scope) {
scope.inTransaction( entityManager -> {
BigDecimal phoneCount = (BigDecimal) entityManager
.createNativeQuery( "SELECT fn_count_phones(:personId) FROM DUAL" )
.setParameter( "personId", 1 )
@ -228,8 +229,4 @@ public void testStoredProcedureReturnValue() {
assertEquals( BigDecimal.valueOf( 2 ), phoneCount );
} );
}
catch (Exception e) {
e.printStackTrace();
}
}
}

35
hibernate-c3p0/src/test/java/org/hibernate/test/c3p0/JdbcCompatibilityTest.java
View File

@ -8,29 +8,34 @@
import java.sql.Statement;
import org.hibernate.dialect.SQLServer2005Dialect;
import org.hibernate.dialect.SQLServerDialect;
import org.hibernate.testing.RequiresDialect;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
import org.junit.Test;
import org.hibernate.testing.orm.junit.DomainModel;
import org.hibernate.testing.orm.junit.RequiresDialect;
import org.hibernate.testing.orm.junit.SessionFactory;
import org.hibernate.testing.orm.junit.SessionFactoryScope;
import org.junit.jupiter.api.Test;
import static org.hibernate.testing.transaction.TransactionUtil.doInHibernate;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
/**
* Tests that checks the JDBC 4.2 compatibility of c3p0
*
* @author Vlad Mihalcea
*/
@RequiresDialect(SQLServer2005Dialect.class)
public class JdbcCompatibilityTest extends BaseCoreFunctionalTestCase {
@RequiresDialect(value = SQLServerDialect.class, majorVersion = 9)
@DomainModel(
annotatedClasses = { IrrelevantEntity.class }
)
@SessionFactory
public class JdbcCompatibilityTest {
@Test
@TestForIssue(jiraKey = "HHH-11308")
public void testJdbc41() {
doInHibernate( this::sessionFactory, session -> {
public void testJdbc41(SessionFactoryScope scope) {
scope.inTransaction( session -> {
session.doWork( connection -> {
//Connection#getSchema was added in Java 1.7
String schema = connection.getSchema();
@ -41,8 +46,8 @@ public void testJdbc41() {
@Test
@TestForIssue(jiraKey = "HHH-11308")
public void testJdbc42() {
doInHibernate( this::sessionFactory, session -> {
public void testJdbc42(SessionFactoryScope scope) {
scope.inTransaction( session -> {
for ( int i = 0; i < 5; i++ ) {
IrrelevantEntity entity = new IrrelevantEntity();
entity.setName( getClass().getName() );
@ -58,8 +63,4 @@ public void testJdbc42() {
} );
}
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class[]{ IrrelevantEntity.class };
}
}

1
hibernate-core/src/test/java/org/hibernate/orm/test/jpa/procedure/StoreProcedureRefCursorOutParameterByNameTest.java
View File

@ -20,7 +20,6 @@
import jakarta.persistence.StoredProcedureQuery;
import jakarta.persistence.Table;
import org.hibernate.dialect.Oracle10gDialect;
import org.hibernate.dialect.OracleDialect;
import org.hibernate.engine.jdbc.connections.spi.JdbcConnectionAccess;
import org.hibernate.engine.jdbc.spi.JdbcServices;

1
hibernate-core/src/test/java/org/hibernate/orm/test/jpa/procedure/StoreProcedureRefCursorOutParameterByPositionTest.java
View File

@ -20,7 +20,6 @@
import jakarta.persistence.StoredProcedureQuery;
import jakarta.persistence.Table;
import org.hibernate.dialect.Oracle10gDialect;
import org.hibernate.dialect.OracleDialect;
import org.hibernate.engine.jdbc.connections.spi.JdbcConnectionAccess;
import org.hibernate.engine.jdbc.spi.JdbcServices;

3
hibernate-core/src/test/java/org/hibernate/orm/test/procedure/MySQLStoredProcedureTest.java
View File

@ -20,6 +20,7 @@
import org.hibernate.Session;
import org.hibernate.dialect.MariaDBDialect;
import org.hibernate.dialect.MySQLDialect;
import org.hibernate.dialect.TiDBDialect;
import org.hibernate.procedure.ProcedureCall;
import org.hibernate.query.procedure.ProcedureParameter;
import org.hibernate.result.Output;
@ -30,6 +31,7 @@
import org.hibernate.testing.orm.junit.EntityManagerFactoryScope;
import org.hibernate.testing.orm.junit.Jpa;
import org.hibernate.testing.orm.junit.RequiresDialect;
import org.hibernate.testing.orm.junit.SkipForDialect;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@ -48,6 +50,7 @@
*/
@RequiresDialect(value = MySQLDialect.class, matchSubTypes = false, majorVersion = 5)
@RequiresDialect(value = MariaDBDialect.class, majorVersion = 5)
@SkipForDialect(dialectClass = TiDBDialect.class, reason = "TiDB doesn't support stored procedures")
@Jpa(
annotatedClasses = {
Person.class,

40
hibernate-core/src/test/java/org/hibernate/orm/test/query/SQLServer2008NationalizedScalarQueryTest.java
View File

@ -7,46 +7,48 @@
package org.hibernate.orm.test.query;
import java.util.List;
import org.hibernate.annotations.Nationalized;
import org.hibernate.dialect.SQLServerDialect;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.orm.junit.DomainModel;
import org.hibernate.testing.orm.junit.RequiresDialect;
import org.hibernate.testing.orm.junit.SessionFactory;
import org.hibernate.testing.orm.junit.SessionFactoryScope;
import org.junit.jupiter.api.Test;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import org.hibernate.annotations.Nationalized;
import org.hibernate.dialect.SQLServer2008Dialect;
import org.hibernate.testing.RequiresDialect;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
import org.junit.Test;
import static org.hibernate.testing.transaction.TransactionUtil.doInHibernate;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
/**
* @author Vlad Mihalcea
*/
@TestForIssue(jiraKey = "HHH-10183")
@RequiresDialect(SQLServer2008Dialect.class)
public class SQLServer2008NationalizedScalarQueryTest extends BaseCoreFunctionalTestCase {
@RequiresDialect(value = SQLServerDialect.class, majorVersion = 10)
@DomainModel(
annotatedClasses = SQLServer2008NationalizedScalarQueryTest.User.class
)
@SessionFactory
public class SQLServer2008NationalizedScalarQueryTest {
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class[] { User.class };
}
@Test
public void testScalarResult() {
public void testScalarResult(SessionFactoryScope scope) {
User user1 = new User( 1, "Chris" );
User user2 = new User( 2, "Steve" );
doInHibernate( this::sessionFactory, session -> {
scope.inTransaction( session -> {
session.save( user1 );
session.save( user2 );
} );
doInHibernate( this::sessionFactory, session -> {
scope.inTransaction( session -> {
List<Object[]> users = session.createNativeQuery(
"select * from users" ).getResultList();
assertEquals( 2, users.size() );

4
hibernate-envers/src/test/java/org/hibernate/orm/test/envers/integration/basic/EmptyStringTest.java
View File

@ -9,7 +9,7 @@
import java.util.Arrays;
import jakarta.persistence.EntityManager;
import org.hibernate.dialect.Oracle8iDialect;
import org.hibernate.dialect.OracleDialect;
import org.hibernate.orm.test.envers.BaseEnversJPAFunctionalTestCase;
import org.hibernate.orm.test.envers.Priority;
import org.hibernate.orm.test.envers.entities.StrTestEntity;
@ -23,7 +23,7 @@
* @author Lukasz Antoniak (lukasz dot antoniak at gmail dot com)
*/
@TestForIssue(jiraKey = "HHH-7246")
@RequiresDialect(Oracle8iDialect.class)
@RequiresDialect(OracleDialect.class)
public class EmptyStringTest extends BaseEnversJPAFunctionalTestCase {
private Integer emptyId = null;
private Integer nullId = null;

4
hibernate-envers/src/test/java/org/hibernate/orm/test/envers/integration/reventity/MonotonicRevisionNumberTest.java
View File

@ -14,7 +14,7 @@
import org.hibernate.boot.model.relational.Database;
import org.hibernate.boot.model.relational.SqlStringGenerationContext;
import org.hibernate.boot.model.relational.internal.SqlStringGenerationContextImpl;
import org.hibernate.dialect.Oracle8iDialect;
import org.hibernate.dialect.OracleDialect;
import org.hibernate.envers.enhanced.OrderedSequenceGenerator;
import org.hibernate.envers.enhanced.SequenceIdRevisionEntity;
import org.hibernate.orm.test.envers.BaseEnversFunctionalTestCase;
@ -31,7 +31,7 @@
* @author Lukasz Antoniak (lukasz dot antoniak at gmail dot com)
*/
@TestForIssue(jiraKey = "HHH-7669")
@RequiresDialect(Oracle8iDialect.class)
@RequiresDialect(OracleDialect.class)
public class MonotonicRevisionNumberTest extends BaseEnversFunctionalTestCase {
@Override
protected Class<?>[] getAnnotatedClasses() {