Author: gk
Date: Mon Nov 25 15:22:32 2019
New Revision: 1870385
URL: http://svn.apache.org/viewvc?rev=1870385&view=rev
Log:
Showcase Java Testcontainer
- in profile mysql/docker-resources
- used for mysql adapter + just one test class: DataContainerTest.java (from DataTest.java)
- no need for a running mysql database installed locally
- still support pre-installed database and docker containerized test (cft. pom.xml)
pom.xml:
- generation: need to use docker-maven-plugin to init a temporary database image to generate sql (in maven torque-maven-plugin), stopping it after this is done
- separate id-table generation and pass on insert into dockerfile (may use some shell script indirection later)
- remove not used log4j.properties
- TODO use torque.wrapper.configuration.file instead of hard-coded configuration file path, add tests, add adapters
Added:
db/torque/torque4/trunk/torque-test/src/test/java/org/apache/torque/testcontainer/
db/torque/torque4/trunk/torque-test/src/test/java/org/apache/torque/testcontainer/BaseDatabaseContainerTestCase.java (with props)
db/torque/torque4/trunk/torque-test/src/test/java/org/apache/torque/testcontainer/DataContainerTest.java (with props)
db/torque/torque4/trunk/torque-test/src/test/profile/mysql/Torque4Test.xml (with props)
db/torque/torque4/trunk/torque-test/src/test/profile/mysql/docker-resources/
db/torque/torque4/trunk/torque-test/src/test/profile/mysql/docker-resources/db/
db/torque/torque4/trunk/torque-test/src/test/profile/mysql/docker-resources/db/.dockerignore
db/torque/torque4/trunk/torque-test/src/test/profile/mysql/docker-resources/db/Dockerfile
db/torque/torque4/trunk/torque-test/src/test/profile/mysql/docker-resources/docker-java.properties.template
db/torque/torque4/trunk/torque-test/src/test/profile/mysql/docker-resources/testcontainers.properties (with props)
db/torque/torque4/trunk/torque-test/src/test/profile/mysql/torque.usersettings.properties (with props)
Removed:
db/torque/torque4/trunk/torque-test/src/test/resources/log4j.properties
Modified:
db/torque/torque4/trunk/torque-test/pom.xml
Modified: db/torque/torque4/trunk/torque-test/pom.xml
URL: http://svn.apache.org/viewvc/db/torque/torque4/trunk/torque-test/pom.xml?rev=1870385&r1=1870384&r2=1870385&view=diff
==============================================================================
--- db/torque/torque4/trunk/torque-test/pom.xml (original)
+++ db/torque/torque4/trunk/torque-test/pom.xml Mon Nov 25 15:22:32 2019
@@ -30,6 +30,9 @@
Troubleshooting:
Exception org.apache.torque.generator.source.transform.SourceTransformerException: Option torque.database must be set:
You did not specify a correct profile name, see above.
+
+ Eclipse classpath generation:
+ First run mvn test -Pmysql -DskipTests=true, then mvn eclipse:eclipse -Dmaven.antrun.skip=true -Pmysql
-->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<parent>
@@ -54,6 +57,9 @@
<torque.test.mysql.log4j2.version>2.12.1</torque.test.mysql.log4j2.version>
<torque.test.oracle.version>10.2.0.3.0</torque.test.oracle.version>
<torque.test.postgres.version>9.1-901.jdbc4</torque.test.postgres.version>
+ <torque.test.testcontainer.version>1.12.3</torque.test.testcontainer.version>
+ <!-- -->
+ <torque.test.idmethod>native</torque.test.idmethod>
</properties>
<scm>
@@ -105,6 +111,19 @@
<artifactId>fulcrum-yaafi</artifactId>
<scope>test</scope>
</dependency>
+ <!-- testcontainer minimal shared resources -->
+ <dependency>
+ <groupId>org.testcontainers</groupId>
+ <artifactId>testcontainers</artifactId>
+ <version>${torque.test.testcontainer.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.testcontainers</groupId>
+ <artifactId>junit-jupiter</artifactId>
+ <version>${torque.test.testcontainer.version}</version>
+ <scope>test</scope>
+ </dependency>
</dependencies>
<build>
@@ -138,6 +157,7 @@
<copy todir="target/torque/test/schema">
<fileset dir="src/main/schema" />
<filterset>
+
<filter token="DATABASE_DEFAULT" value="bookstore" />
<filter token="DATABASE_ID_METHOD" value="${torque.test.idmethod}" />
<filter token="DATABASE_SCHEMA" value="${torque.test.databaseSchema}" />
@@ -282,7 +302,7 @@
<packaging>classpath</packaging>
<configPackage>org.apache.torque.templates.idtable</configPackage>
<sourceDir>target/torque/test/schema</sourceDir>
- <defaultOutputDir>target/generated-sql</defaultOutputDir>
+ <defaultOutputDir>target/generated-sql-init</defaultOutputDir>
<defaultOutputDirUsage>none</defaultOutputDirUsage>
<loglevel>error</loglevel>
<options>
@@ -453,7 +473,7 @@
<autocommit>true</autocommit>
<orderFile>ascending</orderFile>
<fileset>
- <basedir>${basedir}/target/generated-sql</basedir>
+ <basedir>${basedir}/target/generated-sql-init</basedir>
<includes>
<include>*idtable-init.sql</include>
</includes>
@@ -493,9 +513,10 @@
<include>**/${torque.test.include.managers}</include>
</includes>
<excludes>
- <exclude>**/BaseRuntimeTestCase.java</exclude>
+ <exclude>**/BaseDatabaseTestCase.java</exclude>
+ <exclude>**/*Container*.java</exclude>
</excludes>
- <forkMode>none</forkMode><!-- normally pertest, if remote debugging with mvnDebug port 8000, setting in console -DforkMode=none seems to have no effect, set here -->
+ <forkMode>pertest</forkMode><!-- normally pertest, if remote debugging with mvnDebug port 8000, setting in console -DforkMode=none seems to have no effect, set here -->
<systemProperties>
<property>
<name>torque.configuration.file</name>
@@ -1149,6 +1170,187 @@
</plugins>
</build>
</profile>
+ <!--
+ mvn clean test -Pmysql,docker-testcontainer
+ -->
+ <profile>
+ <id>docker-testcontainer</id>
+ <activation>
+ <activeByDefault>false</activeByDefault>
+ </activation>
+ <build>
+ <plugins>
+ <!-- requires a started docker host - starts database for sql-maven-plugin.
+ caution: Cancelling the maven process before life cycle process-classes is reached, the docker has to be stopped manually, docker stop <id>.
+ -->
+ <plugin>
+ <groupId>io.fabric8</groupId>
+ <artifactId>docker-maven-plugin</artifactId>
+ <version>0.30.0</version>
+ <configuration>
+ <filter>mysql:${torque.test.mysql.version}</filter>
+ </configuration>
+ <executions>
+ <execution>
+ <id>prepare-mysql-database</id>
+ <phase>initialize</phase>
+ <goals>
+ <goal>start</goal>
+ </goals>
+ <configuration>
+ <images>
+ <image>
+ <name>mysql:${torque.test.mysql.version}</name>
+ <alias>mysql-generate-helper-database</alias>
+ <run>
+ <env>
+ <MYSQL_ROOT_PASSWORD>${torque.database.password}</MYSQL_ROOT_PASSWORD>
+ <MYSQL_DATABASE>bookstore</MYSQL_DATABASE>
+ <MYSQL_USER>${torque.database.user}</MYSQL_USER>
+ <MYSQL_PASSWORD>${torque.database.password}</MYSQL_PASSWORD>
+ </env>
+ <ports>
+ <port>3306:3306</port>
+ </ports>
+ <!--wait>
+ <log>database system is ready to accept connections.</log>
+ <time>20000</time>
+ </wait-->
+ </run>
+ </image>
+ </images>
+ </configuration>
+ </execution>
+ <!-- close this init generate sources database outside tests, before starting tests -->
+ <execution>
+ <id>remove-mysql-database</id>
+ <phase>process-classes</phase>
+ <goals>
+ <goal>stop</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+ <!-- skip and use testcontaiers docker -->
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>sql-maven-plugin</artifactId>
+ <executions>
+ <execution>
+ <id>execute-ext-ddl</id>
+ <configuration>
+ <skip>true</skip>
+ </configuration>
+ </execution>
+ <execution>
+ <id>execute-ddl</id>
+ <configuration>
+ <skip>true</skip>
+ </configuration>
+ </execution>
+ <execution>
+ <id>execute-idtable-sql</id>
+ <configuration>
+ <skip>true</skip>
+ </configuration>
+ </execution><execution>
+ <id>shutdown-db-after-ddl</id>
+ <configuration>
+ <skip>true</skip>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ <!-- skip database test or do it in a later phase.. -->
+ <plugin>
+ <artifactId>maven-antrun-plugin</artifactId>
+ <executions>
+ <execution>
+ <id>test-database-filled</id>
+ <phase>generate-sources</phase>
+ <configuration>
+ <skip>true</skip>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ <plugin>
+ <artifactId>maven-resources-plugin</artifactId>
+ <version>2.6</version>
+ <executions>
+ <execution>
+ <id>copy-resources</id>
+ <phase>validate</phase>
+ <goals>
+ <goal>copy-resources</goal>
+ </goals>
+ <configuration>
+ <outputDirectory>${basedir}/target</outputDirectory>
+ <resources>
+ <resource>
+ <directory>src/test/profile/mysql/docker-resources/db</directory>
+ <filtering>false</filtering>
+ <includes>
+ <include>Dockerfile</include>
+ <include>.dockerignore</include>
+ </includes>
+ </resource>
+ </resources>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-surefire-plugin</artifactId>
+ <configuration>
+ <systemProperties>
+ <property>
+ <!-- file is sued, but not this configuration setting, cft. -->
+ <name>torque.wrapper.configuration.file</name>
+ <value>src/test/profile/${torque.test.profileDirectory}/Torque4Test.xml</value>
+ </property>
+ </systemProperties>
+ <excludes>
+ <exclude>**/Base*.java</exclude>
+ </excludes>
+ <includes>
+ <include>**/DataContainerTest.java</include>
+ </includes>
+ </configuration>
+ <executions>
+ <execution>
+ <id>default-test</id>
+ <configuration>
+ <!--groups>docker</groups-->
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
+ <dependencies>
+ <!-- docker testcontainer: mvn test -Pmysql,docker-testcontainer -->
+ <dependency>
+ <groupId>org.testcontainers</groupId>
+ <artifactId>testcontainers</artifactId>
+ <version>${torque.test.testcontainer.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.testcontainers</groupId>
+ <artifactId>junit-jupiter</artifactId>
+ <version>${torque.test.testcontainer.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.testcontainers</groupId>
+ <artifactId>mysql</artifactId>
+ <version>${torque.test.testcontainer.version}</version>
+ <scope>test</scope>
+ </dependency>
+ </dependencies>
+ </profile>
<profile>
<id>apache-release</id>
Added: db/torque/torque4/trunk/torque-test/src/test/java/org/apache/torque/testcontainer/BaseDatabaseContainerTestCase.java
URL: http://svn.apache.org/viewvc/db/torque/torque4/trunk/torque-test/src/test/java/org/apache/torque/testcontainer/BaseDatabaseContainerTestCase.java?rev=1870385&view=auto
==============================================================================
--- db/torque/torque4/trunk/torque-test/src/test/java/org/apache/torque/testcontainer/BaseDatabaseContainerTestCase.java (added)
+++ db/torque/torque4/trunk/torque-test/src/test/java/org/apache/torque/testcontainer/BaseDatabaseContainerTestCase.java Mon Nov 25 15:22:32 2019
@@ -0,0 +1,380 @@
+package org.apache.torque.testcontainer;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.torque.Torque;
+import org.apache.torque.TorqueException;
+import org.apache.torque.adapter.Adapter;
+import org.apache.torque.adapter.MysqlAdapter;
+import org.apache.torque.criteria.Criteria;
+import org.apache.torque.om.mapper.StringMapper;
+import org.apache.torque.test.dbobject.Author;
+import org.apache.torque.test.dbobject.Book;
+import org.apache.torque.test.peer.AuthorPeer;
+import org.apache.torque.test.peer.BookPeer;
+import org.apache.torque.util.BasePeerImpl;
+import org.apache.torque.util.CountHelper;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Tag;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.images.builder.ImageFromDockerfile;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+
+
+/**
+ * Base functionality for Test cases which use standard database setup.
+ *
+ * Uses T E S T C O N T A I N E R S
+ *
+ * https://www.testcontainers.org/features/configuration/
+ *
+ * Copy docker-java.properties.template to docker-java.properties and adapt it to your needs.
+ *
+ * @author <a href="mailto:[email protected]">Scott Eade</a>
+ * @author <a href="mailto:[email protected]">Georg Kallidis</a>
+ * @version $Id: BaseDatabaseTestCase.java 1839288 2018-08-27 09:48:33Z tv $
+ */
+@Tag("docker")
+@Testcontainers
+public abstract class BaseDatabaseContainerTestCase
+{
+ private static final String TORQUE_WRAPPER_CONFIGURATION_FILE = "src/test/profile/mysql/Torque4Test.xml";
+ /** TODO: use this key insted of hard coding
+ * The system property containing the path to the configuration file.
+ * */
+ public static final String CONFIG_FILE_SYSTEM_PROPERTY = "torque.wrapper.configuration.file";
+
+ protected static Adapter defaultAdapter;
+
+ // copied from src/test/profile/mysql/docker-resources/db/
+ public static final String DOCKERFILE = "./target/Dockerfile";
+
+ private static Logger log = LogManager.getLogger();
+
+ public static int SERVICE_PORT = 3306;
+
+ public static String DATABASE_NAME = "bookstore";
+
+ Connection connection;
+
+ @Container
+ public static GenericContainer MY_SQL_CONTAINER = new GenericContainer<>(
+ new ImageFromDockerfile()
+ .withDockerfile(new File(DOCKERFILE).toPath())
+ ).withExposedPorts( SERVICE_PORT ) //.withStartupAttempts( 2 )
+ .withEnv( "MYSQL_DATABASE", DATABASE_NAME )
+ .withEnv( "MYSQL_USER", "torque" )
+ .withEnv( "MYSQL_PASSWORD", "torque" )
+ .withEnv( "MYSQL_ROOT_PASSWORD","torque" );
+
+ /**
+ * Initialize Torque on the first setUp(). Subclasses which override
+ * setUp() must call super.setUp() as their first action.
+ * @throws TorqueException
+ * @throws InterruptedException
+ * @throws IOException
+ * @throws UnsupportedOperationException
+ */
+ @BeforeAll
+ public static void init() throws TorqueException, UnsupportedOperationException, IOException, InterruptedException {
+ log.info("Starting from dockerfile: {}", DOCKERFILE);
+
+ //before torque init
+ MY_SQL_CONTAINER.setStartupAttempts( 3 );
+
+ startDatabaseContainer();
+
+ //MY_SQL_CONTAINER.execInContainer("mysql -h localhost -u root -ptorque -P 3306 "+ DATABASE_NAME);
+
+ // TODO do resource filtering and read from properties
+ File targetFile = new File(TORQUE_WRAPPER_CONFIGURATION_FILE);
+ Path torqueConfBase = Paths.get(targetFile.toURI()).getParent();
+ updateTorque(torqueConfBase);
+
+ synchronized (BaseDatabaseContainerTestCase.class)
+ {
+ if (!Torque.isInit())
+ {
+ Torque.init(
+ TORQUE_WRAPPER_CONFIGURATION_FILE);
+ }
+ }
+ defaultAdapter = Torque.getDatabase(Torque.getDefaultDB()).getAdapter();
+ log.info("using adapter: {}", defaultAdapter);
+
+ }
+
+ protected static void updateTorque(Path torqueConfBase) {
+ try {
+ String jdbcConnectionString = generateJdbcUrl();
+ String customUrl = "torque.dsfactory.bookstore.connection.url="+ jdbcConnectionString;
+ // override and set mapped port in url, which is known only at runtime.
+ File file = torqueConfBase.resolve("torque.usersettings.properties").toFile();
+ try (FileOutputStream fop = new FileOutputStream(file )) {
+ if (!file.exists()) {
+ file.createNewFile();
+ }
+ fop.write( customUrl.getBytes() );
+ fop.flush();
+ }
+ } catch (Exception e) {
+ fail();
+ }
+ }
+
+ public static void startDatabaseContainer() {
+ if (!MY_SQL_CONTAINER.isRunning()) {
+ MY_SQL_CONTAINER.waitingFor(Wait.forListeningPort());
+ MY_SQL_CONTAINER.start();
+ }
+ }
+
+ /**
+ *
+ * @returns the JDBC string with mapped port binding
+ */
+ public static String generateJdbcUrl() {
+ startDatabaseContainer();
+ if (!MY_SQL_CONTAINER.isRunning()) { throw new RuntimeException("Could not find RUNNING database container"); }
+
+ //MY_SQL_CONTAINER.withCreateContainerCmdModifier(modifier) //
+ String serviceHost = MY_SQL_CONTAINER.getContainerIpAddress();
+ Integer mappedPort = MY_SQL_CONTAINER.getMappedPort(SERVICE_PORT);// e.g. 32811
+ log.info("generate jdbc url from {}, mapped Port: {}, bounded port: {}", serviceHost, mappedPort, MY_SQL_CONTAINER.getBoundPortNumbers());
+
+ String targetJDBC = //genJDBC;
+ String.format("jdbc:mysql://%s:%d/%s?loggerLevel=OFF", serviceHost,
+ mappedPort, DATABASE_NAME);
+ log.info( "used connect url: {}", targetJDBC);
+ return targetJDBC;
+ }
+
+ /**
+ * Queries mysql for its version.
+ * @return the version String mysql returns
+ * @throws TorqueException if the database is not mysql or the query fails.
+ */
+ protected String getMysqlVersion() throws TorqueException
+ {
+ Adapter adapter
+ = Torque.getDatabase(Torque.getDefaultDB()).getAdapter();
+ if (!(adapter instanceof MysqlAdapter))
+ {
+ throw new TorqueException(
+ "getMysqlVersion called but database adapter is "
+ + adapter.getClass().getName());
+ }
+ List<String> records = new BasePeerImpl<String>().doSelect(
+ "show variables like \"version\"",
+ new StringMapper(1),
+ (String) null);
+ return records.get(0);
+ }
+
+ /**
+ * Queries mysql for its major version. (format is major.minor.release)
+ * @return the major version of mysql
+ * @throws TorqueException if the database is not mysql or the query fails.
+ * @throws NumberFormatException if the mysql major version cannot be
+ * converted to an int
+ */
+ protected int getMysqlMajorVersion()
+ throws TorqueException
+ {
+ String completeVersion = getMysqlVersion();
+ String majorVersion
+ = completeVersion.substring(0, completeVersion.indexOf('.'));
+ return Integer.parseInt(majorVersion);
+ }
+
+ /**
+ * Queries mysql for its minor version. (format is major.minor.release)
+ * @return the minor version of mysql
+ * @throws TorqueException if the database is not mysql or the query fails.
+ */
+ protected int getMysqlMinorVersion()
+ throws TorqueException
+ {
+ String completeVersion = getMysqlVersion();
+ if (completeVersion.indexOf('-') != -1) // handle x.y.z-ubuntuSomething
+ {
+ completeVersion = completeVersion.substring(
+ 0,
+ completeVersion.indexOf('-'));
+ }
+ String minorVersion
+ = completeVersion.substring(
+ completeVersion.indexOf('.') + 1,
+ completeVersion.lastIndexOf('.'));
+ return Integer.parseInt(minorVersion);
+ }
+
+ /**
+ * Queries the database for its major version.
+ *
+ * @param connection a connection to the database.
+ *
+ * @return the version String from the connection metadata
+ *
+ * @throws TorqueException if the query fails.
+ */
+ protected int getDatabaseMajorVersion(final Connection connection)
+ throws TorqueException
+ {
+ try
+ {
+ return connection.getMetaData().getDatabaseMajorVersion();
+ }
+ catch (SQLException e)
+ {
+ throw new TorqueException(e);
+ }
+ }
+
+ /**
+ * Deletes all authors and books in the bookstore tables.
+ *
+ * @throws TorqueException if the bookstore could not be cleaned
+ */
+ protected void cleanBookstore() throws TorqueException
+ {
+ Criteria criteria = new Criteria();
+ BookPeer.doDelete(criteria);
+
+ criteria = new Criteria();
+ AuthorPeer.doDelete(criteria);
+ }
+
+ /**
+ * Inserts test data into the bookstore tables.
+ *
+ * @return the list of added authors, which in turn contain the added books.
+ *
+ * @throws TorqueException if filling data fails.
+ */
+ protected List<Author> insertBookstoreData() throws TorqueException
+ {
+ List<Author> result = new ArrayList<>();
+ for (int i = 1; i <= 10; i++)
+ {
+ Author author = new Author();
+ author.setName("Author " + i);
+ author.save();
+ result.add(author);
+ assertTrue("authorId should not be 0 after insert",
+ author.getAuthorId() != 0);
+
+ for (int j = 1; j <= 10; j++)
+ {
+ Book book = new Book();
+ author.addBook(book);
+ book.setTitle("Book " + j + " - Author " + i);
+ if (j < 10)
+ {
+ book.setIsbn("ISBN " + j + " - " + i);
+ }
+ else
+ {
+ book.setIsbn(null);
+ }
+ book.save();
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Checks that the bookstore tables contain exactly the records
+ * in the passed list.
+ * The books in the authors are also checked.
+ *
+ * @param toVerify the list of authors to check.
+ *
+ * @throws TorqueException if reading data fails.
+ */
+ protected void verifyBookstore(final List<Author> toVerify) throws TorqueException
+ {
+ int numBooks = 0;
+
+ for (Author author : toVerify)
+ {
+ Criteria criteria = new Criteria()
+ .where(AuthorPeer.NAME, author.getName())
+ .and(AuthorPeer.AUTHOR_ID, author.getAuthorId());
+ criteria.setSingleRecord(true);
+ List<Author> selectedAuthorList = AuthorPeer.doSelect(criteria);
+ assertEquals("Could not find author with id "
+ + author.getAuthorId()
+ + " and name "
+ + author.getName(),
+ 1,
+ selectedAuthorList.size());
+
+ numBooks += author.getBooks().size();
+
+ for (Book book : author.getBooks())
+ {
+ criteria = new Criteria()
+ .where(BookPeer.TITLE, book.getTitle())
+ .and(BookPeer.BOOK_ID, book.getBookId())
+ .and(BookPeer.AUTHOR_ID, book.getAuthorId())
+ .and(BookPeer.ISBN, book.getIsbn());
+ criteria.setSingleRecord(true);
+ List<Book> selectedBookList = BookPeer.doSelect(criteria);
+ assertEquals("Could not find book with id "
+ + book.getBookId()
+ + " title "
+ + book.getTitle()
+ + " ISBN "
+ + book.getIsbn()
+ + " authorId "
+ + book.getAuthorId(),
+ 1,
+ selectedBookList.size());
+ }
+ }
+
+ assertEquals(
+ toVerify.size(),
+ new CountHelper().count(AuthorPeer.getTableMap()));
+ assertEquals(
+ numBooks,
+ new CountHelper().count(BookPeer.getTableMap()));
+ }
+
+}
Propchange: db/torque/torque4/trunk/torque-test/src/test/java/org/apache/torque/testcontainer/BaseDatabaseContainerTestCase.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: db/torque/torque4/trunk/torque-test/src/test/java/org/apache/torque/testcontainer/DataContainerTest.java
URL: http://svn.apache.org/viewvc/db/torque/torque4/trunk/torque-test/src/test/java/org/apache/torque/testcontainer/DataContainerTest.java?rev=1870385&view=auto
==============================================================================
--- db/torque/torque4/trunk/torque-test/src/test/java/org/apache/torque/testcontainer/DataContainerTest.java (added)
+++ db/torque/torque4/trunk/torque-test/src/test/java/org/apache/torque/testcontainer/DataContainerTest.java Mon Nov 25 15:22:32 2019
@@ -0,0 +1,1452 @@
+package org.apache.torque.testcontainer;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import static org.junit.Assert.*;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.torque.ColumnImpl;
+import org.apache.torque.ForeignKeySchemaData;
+import org.apache.torque.TestInterface;
+import org.apache.torque.TestPeerInterface;
+import org.apache.torque.Torque;
+import org.apache.torque.TorqueException;
+import org.apache.torque.adapter.Adapter;
+import org.apache.torque.adapter.DerbyAdapter;
+import org.apache.torque.adapter.HsqldbAdapter;
+import org.apache.torque.adapter.MssqlAdapter;
+import org.apache.torque.adapter.MysqlAdapter;
+import org.apache.torque.criteria.Criteria;
+import org.apache.torque.criteria.Criterion;
+import org.apache.torque.om.mapper.CompositeMapper;
+import org.apache.torque.om.mapper.IntegerMapper;
+import org.apache.torque.om.mapper.RecordMapper;
+import org.apache.torque.test.InheritanceClassnameTestChild1;
+import org.apache.torque.test.InheritanceClassnameTestChild2;
+import org.apache.torque.test.dbobject.Author;
+import org.apache.torque.test.dbobject.BigintType;
+import org.apache.torque.test.dbobject.Book;
+import org.apache.torque.test.dbobject.CompPkContainsFk;
+import org.apache.torque.test.dbobject.IfcTable;
+import org.apache.torque.test.dbobject.InheritanceChildB;
+import org.apache.torque.test.dbobject.InheritanceChildC;
+import org.apache.torque.test.dbobject.InheritanceChildD;
+import org.apache.torque.test.dbobject.InheritanceClassnameTest;
+import org.apache.torque.test.dbobject.InheritanceTest;
+import org.apache.torque.test.dbobject.IntegerType;
+import org.apache.torque.test.dbobject.LocalIfcTable;
+import org.apache.torque.test.dbobject.LocalTestInterface;
+import org.apache.torque.test.dbobject.MultiPk;
+import org.apache.torque.test.dbobject.Nopk;
+import org.apache.torque.test.dbobject.OIntegerPk;
+import org.apache.torque.test.dbobject.VarcharType;
+import org.apache.torque.test.peer.AuthorPeer;
+import org.apache.torque.test.peer.BigintTypePeer;
+import org.apache.torque.test.peer.BookPeer;
+import org.apache.torque.test.peer.CompPkContainsFkPeer;
+import org.apache.torque.test.peer.IfcTablePeer;
+import org.apache.torque.test.peer.IfcTablePeerImpl;
+import org.apache.torque.test.peer.InheritanceClassnameTestPeer;
+import org.apache.torque.test.peer.InheritanceTestPeer;
+import org.apache.torque.test.peer.IntegerTypePeer;
+import org.apache.torque.test.peer.LocalIfcTablePeer;
+import org.apache.torque.test.peer.LocalIfcTablePeerImpl;
+import org.apache.torque.test.peer.LocalTestPeerInterface;
+import org.apache.torque.test.peer.MultiPkPeer;
+import org.apache.torque.test.peer.NopkPeer;
+import org.apache.torque.test.peer.VarcharTypePeer;
+import org.apache.torque.test.recordmapper.AuthorRecordMapper;
+import org.apache.torque.test.recordmapper.BookRecordMapper;
+import org.apache.torque.util.BasePeerImpl;
+import org.apache.torque.util.CountHelper;
+import org.apache.torque.util.Transaction;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+/**
+ * Runtime tests.
+ *
+ * @author <a href="mailto:[email protected]">Scott Eade</a>
+ * @author <a href="mailto:[email protected]">Martin Poeschl</a>
+ * @author <a href="mailto:[email protected]">Thomas Fischer</a>
+ * @author <a href="mailto:[email protected]">Patrick Carl</a>
+ * @author <a href="mailto:[email protected]">Thomas Vandahl</a>
+ * @author <a href="mailto:[email protected]">Georg Kallidis</a>
+ * @version $Id: DataTest.java 1869081 2019-10-28 16:17:11Z gk $
+ */
+@Tag("docker")
+@Testcontainers
+public class DataContainerTest extends BaseDatabaseContainerTestCase
+{
+ private static Logger log = LogManager.getLogger();
+
+ /**
+ * test whether we can connect to the database at all
+ * @throws Exception if no connection can be established
+ */
+ @Test
+ @Tag("docker")
+ public void testConnect() throws Exception
+ {
+ Connection connection = null;
+ try
+ {
+ connection = Torque.getConnection();
+ connection.close();
+ connection = null;
+ }
+ finally
+ {
+ if (connection != null)
+ {
+ connection.close();
+ }
+ }
+ }
+
+ /**
+ * multiple pk test (TRQ12)
+ * @throws Exception if the test fails
+ */
+ @Test
+ public void testMultiplePk() throws Exception
+ {
+ // clean table
+ Criteria criteria = new Criteria();
+ criteria.where(MultiPkPeer.PK1, (Object) null, Criteria.NOT_EQUAL);
+ MultiPkPeer.doDelete(criteria);
+
+ // do test
+ MultiPk mpk = new MultiPk();
+ mpk.setPrimaryKey("Svarchar:N5:Schar:N3:N-42:N3:N4:N5:N6:D9999999999:");
+ mpk.save();
+ // TODO assert saved values
+ }
+
+ private static final String[] validTitles = {
+ "Book 6 - Author 4", "Book 6 - Author 5", "Book 6 - Author 6",
+ "Book 6 - Author 7", "Book 6 - Author 8",
+ "Book 7 - Author 4", "Book 7 - Author 5", "Book 7 - Author 6",
+ "Book 7 - Author 7", "Book 7 - Author 8"
+ };
+
+ /**
+ * test limit/offset
+ *
+ * @throws Exception if the test fails
+ */
+ @Test
+ public void testLimitOffset() throws Exception
+ {
+ cleanBookstore();
+ insertBookstoreData();
+ Set<String> titleSet = new HashSet<>();
+ for (int j = 0; j < validTitles.length; j++)
+ {
+ titleSet.add(validTitles[j]);
+ }
+
+ Criteria crit = new Criteria();
+ Criterion c = new Criterion(BookPeer.TITLE,
+ "Book 6 - Author 1", Criteria.GREATER_EQUAL);
+ c.and(new Criterion(BookPeer.TITLE,
+ "Book 8 - Author 3", Criteria.LESS_EQUAL));
+ crit.where(c);
+ crit.addDescendingOrderByColumn(BookPeer.BOOK_ID);
+ crit.setLimit(10);
+ crit.setOffset(5);
+ List<Book> books = BookPeer.doSelect(crit);
+ assertEquals("List should have 10 books", 10, books.size());
+ for (Book book : books)
+ {
+ String title = book.getTitle();
+ assertTrue("Incorrect title: " + title,
+ titleSet.contains(title));
+ }
+
+
+ // Test limit of zero works
+ if (defaultAdapter instanceof DerbyAdapter || defaultAdapter instanceof HsqldbAdapter)
+ {
+ log.info("testLimitOffset(): "
+ + "A limit of 0 is not supported for Derby or Hsqldb");
+ }
+ else
+ {
+ crit = new Criteria();
+ crit.setLimit(0);
+ books = BookPeer.doSelect(crit);
+ assertEquals("List should have 0 books", 0, books.size());
+ }
+
+ // check that Offset also works without limit
+ crit = new Criteria();
+ crit.setOffset(5);
+ books = BookPeer.doSelect(crit);
+ assertEquals("List should have 95 books", 95, books.size());
+
+ // Check that limiting also works if a table with an equal column name
+ // is joined. This is problematic for oracle, see TORQUE-10.
+
+ crit = new Criteria();
+ crit.setLimit(10);
+ crit.setOffset(5);
+ books = BookPeer.doSelectJoinAuthor(crit);
+ assertEquals("List should have 10 books", 10, books.size());
+ }
+
+ /**
+ * Checks whether the setSingleRecord() method in criteria works
+ */
+ @Test
+ public void testSingleRecord() throws Exception
+ {
+ cleanBookstore();
+ insertBookstoreData();
+ Criteria criteria = new Criteria();
+ criteria.setSingleRecord(true);
+ criteria.setLimit(1);
+ criteria.setOffset(5);
+ List<Book> books = BookPeer.doSelect(criteria);
+ assertTrue("List should have 1 books, not " + books.size(),
+ books.size() == 1);
+
+ criteria = new Criteria();
+ criteria.setSingleRecord(true);
+ criteria.setLimit(2);
+ try
+ {
+ books = BookPeer.doSelect(criteria);
+ fail("doSelect should have failed "
+ + "because two records were selected "
+ + " and one was expected");
+ }
+ catch (TorqueException e)
+ {
+ }
+ }
+
+ /**
+ * Tests whether selects work correctly if the value <code>null</code>
+ * is used.
+ * @throws Exception if the test fails
+ */
+ @Test
+ public void testNullSelects() throws Exception
+ {
+ // clean table
+ VarcharTypePeer.doDelete(new Criteria());
+ IntegerTypePeer.doDelete(new Criteria());
+
+ // add test data
+ VarcharType varcharType = new VarcharType();
+ varcharType.setId("text2");
+ varcharType.setVarcharValue("text2");
+ varcharType.save();
+ varcharType = new VarcharType();
+ varcharType.setId("text");
+ varcharType.save();
+
+ IntegerType integerTypeNotNull = new IntegerType();
+ integerTypeNotNull.setIntegerObjectValue(1);
+ integerTypeNotNull.save();
+ IntegerType integerTypeNull = new IntegerType();
+ integerTypeNull.save();
+
+ // check for comparison NOT_EQUAL and value null
+ Criteria criteria = new Criteria();
+ criteria.where(VarcharTypePeer.ID, null, Criteria.NOT_EQUAL)
+ .and(VarcharTypePeer.VARCHAR_VALUE, null, Criteria.NOT_EQUAL);
+ List<VarcharType> varcharResult = VarcharTypePeer.doSelect(criteria);
+ assertEquals(1, varcharResult.size());
+ assertEquals("text2", varcharResult.get(0).getId());
+
+ criteria = new Criteria();
+ criteria.where(IntegerTypePeer.ID, null, Criteria.NOT_EQUAL)
+ .and(IntegerTypePeer.INTEGER_OBJECT_VALUE, null, Criteria.NOT_EQUAL);
+ List<IntegerType> integerResult = IntegerTypePeer.doSelect(criteria);
+ assertEquals(1, integerResult.size());
+ assertEquals(integerTypeNotNull.getId(), integerResult.get(0).getId());
+
+ // check for comparison EQUAL and value null
+ criteria = new Criteria();
+ criteria.where(VarcharTypePeer.VARCHAR_VALUE, null, Criteria.EQUAL);
+ varcharResult = VarcharTypePeer.doSelect(criteria);
+ assertEquals(1, varcharResult.size());
+ assertEquals("text", varcharResult.get(0).getId());
+
+ criteria = new Criteria();
+ criteria.where(IntegerTypePeer.INTEGER_OBJECT_VALUE, null, Criteria.EQUAL);
+ integerResult = IntegerTypePeer.doSelect(criteria);
+ assertEquals(1, integerResult.size());
+ assertEquals(integerTypeNull.getId(), integerResult.get(0).getId());
+ }
+
+ /**
+ * Test whether an update works and whether it only affects the
+ * specified record.
+ * @throws Exception if anything in the test goes wrong.
+ */
+ @Test
+ public void testUpdate() throws Exception
+ {
+ cleanBookstore();
+
+ Author otherAuthor = new Author();
+ otherAuthor.setName("OtherName");
+ otherAuthor.save();
+
+ Author author = new Author();
+ author.setName("Name");
+ author.save();
+
+
+ // Test doUpdate methods in Peer explicitly
+ Connection connection = Transaction.begin(AuthorPeer.DATABASE_NAME);
+ author.setName("NewName2");
+ AuthorPeer.doUpdate(author);
+ Transaction.commit(connection);
+
+ Criteria criteria = new Criteria();
+ criteria.addAscendingOrderByColumn(AuthorPeer.NAME);
+
+ List<Author> authors = AuthorPeer.doSelect(criteria);
+ assertEquals("List should contain 2 authors", 2, authors.size());
+ assertEquals("First Author's name should be \"NewName2\"",
+ "NewName2",
+ authors.get(0).getName());
+ assertEquals("Second Author's name should be \"OtherName\"",
+ "OtherName",
+ authors.get(1).getName());
+
+ author.setName("NewName3");
+ AuthorPeer.doUpdate(author);
+
+ criteria = new Criteria();
+ criteria.addAscendingOrderByColumn(AuthorPeer.NAME);
+
+ authors = AuthorPeer.doSelect(criteria);
+ assertEquals("List should contain 2 authors", 2, authors.size());
+ assertEquals("First Author's name should be \"NewName3\"",
+ "NewName3",
+ authors.get(0).getName());
+ assertEquals("Second Author's name should be \"OtherName\"",
+ "OtherName",
+ authors.get(1).getName());
+
+ Nopk nopk = new Nopk();
+ nopk.setName("name");
+ nopk.save();
+
+ // check the doPupdate Peer methods throw exceptions on a modified
+ // object without primary keys
+ try
+ {
+ NopkPeer.doUpdate(new Nopk());
+ fail("A Torque exception should be thrown (2)");
+ }
+ catch (TorqueException e)
+ {
+ }
+
+ connection = Transaction.begin(NopkPeer.DATABASE_NAME);
+ try
+ {
+ NopkPeer.doUpdate(new Nopk(),connection);
+ fail("A Torque exception should be thrown (3)");
+ }
+ catch (TorqueException e)
+ {
+ }
+ Transaction.safeRollback(connection);
+
+ }
+
+ /**
+ * test special cases in the select clause
+ * @throws Exception if the test fails
+ */
+ @Test
+ public void testSelectClause() throws Exception
+ {
+ // test double functions in select columns
+ Criteria criteria = new Criteria();
+ criteria.addSelectColumn(
+ new ColumnImpl("count(distinct(" + BookPeer.BOOK_ID + "))"));
+ new BasePeerImpl<>().doSelect(criteria, new IntegerMapper());
+
+ // test qualifiers in function in select columns
+ criteria = new Criteria();
+ criteria.addSelectColumn(
+ new ColumnImpl("count(distinct " + BookPeer.BOOK_ID + ")"));
+ new BasePeerImpl<>().doSelect(criteria, new IntegerMapper());
+ }
+
+ /**
+ * test if a select from the "default" database works
+ * @throws Exception (NPE) if the test fails
+ */
+ @Test
+ public void testSelectFromDefault() throws Exception
+ {
+ Criteria criteria = new Criteria("default");
+
+ criteria.addSelectColumn(BookPeer.BOOK_ID);
+
+ new BasePeerImpl<>().doSelect(criteria, new IntegerMapper());
+ }
+
+ /**
+ * Test the behaviour if a connection is supplied to access the database,
+ * but it is null. All methods on the user level should be fail
+ * because these methods will be only needed if a method should be executed
+ * in a transaction context. If one assumes that a transaction is open
+ * (connection is not null), but it is not (connection == null),
+ * it is a bad idea to silently start one as this behaviour is very
+ * difficult to tell from the correct one. A clean failure is much easier
+ * to test for.
+ */
+ @Test
+ public void testNullConnection() throws Exception
+ {
+ try
+ {
+ Criteria criteria = new Criteria();
+ AuthorPeer.doSelect(criteria, new IntegerMapper(), null);
+ fail("NullPointerException expected");
+ }
+ catch (NullPointerException e)
+ {
+ //expected
+ }
+
+ try
+ {
+ Criteria criteria = new Criteria();
+ criteria.where(BookPeer.BOOK_ID, (Long) null, Criteria.NOT_EQUAL);
+ BookPeer.doDelete(criteria, (Connection) null);
+ fail("NullPointerException expected");
+ }
+ catch (NullPointerException e)
+ {
+ //expected
+ }
+
+ try
+ {
+ Author author = new Author();
+ author.setName("name");
+ author.save((Connection) null);
+ fail("TorqueException expected");
+ }
+ catch (TorqueException e)
+ {
+ //expected
+ assertEquals("connection is null", e.getMessage());
+ }
+ }
+
+ /**
+ * test the order by, especially in joins and with aliases
+ * @throws Exception if the test fails
+ */
+ @Test
+ public void testOrderBy() throws Exception
+ {
+ cleanBookstore();
+
+ // insert test data
+ Author firstAuthor = new Author();
+ firstAuthor.setName("Author 1");
+ firstAuthor.save();
+ Book book = new Book();
+ book.setAuthor(firstAuthor);
+ book.setTitle("Book 1");
+ book.setIsbn("unknown");
+ book.save();
+
+ Author secondAuthor = new Author();
+ secondAuthor.setName("Author 2");
+ secondAuthor.save();
+ for (int bookNr = 2; bookNr <=4; bookNr++)
+ {
+ book = new Book();
+ book.setAuthor(secondAuthor);
+ book.setTitle("Book " + bookNr);
+ book.setIsbn("unknown");
+ book.save();
+ }
+
+ // test simple ascending order by
+ Criteria criteria = new Criteria();
+ criteria.addAscendingOrderByColumn(BookPeer.TITLE);
+ List<Book> bookList = BookPeer.doSelect(criteria);
+ if (bookList.size() != 4)
+ {
+ fail("Ascending Order By: "
+ + "incorrect numbers of books found : "
+ + bookList.size()
+ + ", should be 4");
+ }
+ if (! "Book 1".equals(bookList.get(0).getTitle()))
+ {
+ fail("Ascending Order By: "
+ + "Title of first Book is "
+ + bookList.get(0).getTitle()
+ + ", should be \"Book 1\"");
+ }
+ if (! "Book 4".equals(bookList.get(3).getTitle()))
+ {
+ fail("Ascending Order By: "
+ + "Title of fourth Book is "
+ + bookList.get(3).getTitle()
+ + ", should be \"Book 4\"");
+ }
+
+ // test simple descending order by
+ criteria = new Criteria();
+ criteria.addDescendingOrderByColumn(BookPeer.TITLE);
+ bookList = BookPeer.doSelect(criteria);
+ if (bookList.size() != 4)
+ {
+ fail("Descending Order By: "
+ + "incorrect numbers of books found : "
+ + bookList.size()
+ + ", should be 4");
+ }
+ if (! "Book 1".equals(bookList.get(3).getTitle()))
+ {
+ fail("Descending Order By: "
+ + "Title of fourth Book is "
+ + bookList.get(3).getTitle()
+ + ", should be \"Book 1\"");
+ }
+ if (! "Book 4".equals((bookList.get(0)).getTitle()))
+ {
+ fail("Descending Order By: "
+ + "Title of first Book is "
+ + bookList.get(0).getTitle()
+ + ", should be \"Book 4\"");
+ }
+
+ criteria = new Criteria();
+ criteria.addAlias("b", BookPeer.TABLE_NAME);
+ criteria.addJoin(BookPeer.AUTHOR_ID, AuthorPeer.AUTHOR_ID);
+ criteria.addJoin(
+ AuthorPeer.AUTHOR_ID,
+ new ColumnImpl("b." + BookPeer.AUTHOR_ID.getColumnName()));
+ criteria.addAscendingOrderByColumn(
+ new ColumnImpl("b." + BookPeer.TITLE.getColumnName()));
+ criteria.addDescendingOrderByColumn(BookPeer.TITLE);
+ // the retrieved columns are
+ // author book b
+ // author1 book1 book1
+ // author2 book4 book2
+ // author2 book3 book2
+ // author2 book2 book2
+ // author2 book4 book3
+ // ...
+ bookList = BookPeer.doSelect(criteria);
+ if (bookList.size() != 10)
+ {
+ fail("ordering by Aliases: "
+ + "incorrect numbers of books found : "
+ + bookList.size()
+ + ", should be 10");
+ }
+ if (!"Book 4".equals(bookList.get(1).getTitle()))
+ {
+ fail("ordering by Aliases: "
+ + "Title of second Book is "
+ + bookList.get(1).getTitle()
+ + ", should be \"Book 4\"");
+ }
+ if (!"Book 3".equals(bookList.get(2).getTitle()))
+ {
+ fail("ordering by Aliases: "
+ + "Title of third Book is "
+ + bookList.get(2).getTitle()
+ + ", should be \"Book 3\"");
+ }
+
+ criteria = new Criteria();
+ criteria.addAlias("b", BookPeer.TABLE_NAME);
+ criteria.addJoin(BookPeer.AUTHOR_ID, AuthorPeer.AUTHOR_ID);
+ criteria.addJoin(
+ AuthorPeer.AUTHOR_ID,
+ new ColumnImpl("b." + BookPeer.AUTHOR_ID.getColumnName()));
+ criteria.addAscendingOrderByColumn(BookPeer.TITLE);
+ criteria.addDescendingOrderByColumn(
+ new ColumnImpl("b." + BookPeer.TITLE.getColumnName()));
+ // the retrieved columns are
+ // author book b
+ // author1 book1 book1
+ // author2 book2 book4
+ // author2 book2 book3
+ // author2 book2 book2
+ // author2 book3 book4
+ // ...
+ bookList = BookPeer.doSelect(criteria);
+ if (bookList.size() != 10)
+ {
+ fail("ordering by Aliases (2): "
+ + "incorrect numbers of books found : "
+ + bookList.size()
+ + ", should be 10");
+ }
+ if (!"Book 2".equals(bookList.get(1).getTitle()))
+ {
+ fail("ordering by Aliases (2, PS): "
+ + "Title of second Book is "
+ + bookList.get(1).getTitle()
+ + ", should be \"Book 2\"");
+ }
+ if (!"Book 2".equals(bookList.get(2).getTitle()))
+ {
+ fail("ordering by Aliases (2, PS): "
+ + "Title of third Book is "
+ + bookList.get(2).getTitle()
+ + ", should be \"Book 2\"");
+ }
+
+ // test usage of Expressions in order by
+ criteria = new Criteria();
+ criteria.addAscendingOrderByColumn(
+ new ColumnImpl("UPPER(" + BookPeer.TITLE + ")"));
+ criteria.setIgnoreCase(true);
+ BookPeer.doSelect(criteria);
+ }
+
+
+ /**
+ * Tests whether ignoreCase works correctly
+ * @throws Exception if the test fails
+ */
+ @Test
+ public void testIgnoreCase() throws Exception
+ {
+ cleanBookstore();
+
+ // check ignore case in selects
+ Author author = new Author();
+ author.setName("AuTHor");
+ author.save();
+
+ Criteria criteria = new Criteria();
+ criteria.where(AuthorPeer.NAME, author.getName().toLowerCase());
+ criteria.setIgnoreCase(true);
+ List<Author> result = AuthorPeer.doSelect(criteria);
+ assertTrue("Size of result is not 1, but " + result.size(),
+ result.size() == 1);
+
+ // LIKE treatment might be different (e.g. postgres), so check extra
+ criteria = new Criteria();
+ criteria.where(
+ AuthorPeer.NAME,
+ author.getName().toLowerCase().replace('r', '%'),
+ Criteria.LIKE);
+ criteria.setIgnoreCase(true);
+ result = AuthorPeer.doSelect(criteria);
+ assertTrue("Size of result is not 1, but " + result.size(),
+ result.size() == 1);
+
+ // Test ignore case in criterion
+ criteria = new Criteria();
+ Criterion criterion1 = new Criterion(
+ AuthorPeer.NAME,
+ author.getName().toLowerCase(),
+ Criteria.EQUAL);
+ criterion1.setIgnoreCase(true);
+ Criterion criterion2 = new Criterion(
+ AuthorPeer.AUTHOR_ID, null, Criteria.NOT_EQUAL);
+ criterion1.and(criterion2);
+
+ result = AuthorPeer.doSelect(criteria);
+
+ // ignore case should not be set either in Criteria
+ // nor in other criterions
+ assertFalse(criteria.isIgnoreCase());
+ assertFalse(criterion2.isIgnoreCase());
+ assertTrue("Size of result is not 1, but " + result.size(),
+ result.size() == 1);
+
+
+ // Test ignore case in attached criterion
+ criteria = new Criteria();
+ criterion1 = new Criterion(
+ AuthorPeer.AUTHOR_ID, null, Criteria.NOT_EQUAL);
+ criterion2 = new Criterion(
+ AuthorPeer.NAME,
+ author.getName().toLowerCase(),
+ Criteria.EQUAL);
+ criterion2.setIgnoreCase(true);
+ criterion1.and(criterion2);
+
+ result = AuthorPeer.doSelect(criteria);
+
+ // ignore case should not be set either in Criteria
+ // nor in other criterions
+ assertFalse(criteria.isIgnoreCase());
+ assertFalse(criterion1.isIgnoreCase());
+
+ assertTrue("Size of result is not 1, but " + result.size(),
+ result.size() == 1);
+
+ // ignore case in "in" query
+ {
+ criteria = new Criteria();
+ Set<String> names = new HashSet<>();
+ names.add(author.getName().toLowerCase());
+ criteria.where(AuthorPeer.NAME, names, Criteria.IN);
+ criteria.setIgnoreCase(true);
+
+ result = AuthorPeer.doSelect(criteria);
+ assertEquals("Expected result of size 1 but got " + result.size(),
+ result.size(),
+ 1);
+ }
+
+ // Check that case is not ignored if ignoreCase is not set
+ // This is known not to work for mysql
+ author = new Author();
+ author.setName("author");
+ author.save();
+
+ Adapter adapter = Torque.getAdapter(Torque.getDefaultDB());
+ if (adapter instanceof MysqlAdapter
+ || adapter instanceof MssqlAdapter)
+ {
+ log.error("testIgnoreCase(): "
+ + "Case sensitive comparisons are known not to work"
+ + " with Mysql and MSSQL");
+ // failing is "expected", so bypass without error
+ }
+ else
+ {
+ criteria = new Criteria();
+ criteria.where(AuthorPeer.NAME, author.getName());
+ result = AuthorPeer.doSelect(criteria);
+ assertTrue("Size of result is not 1, but " + result.size(),
+ result.size() == 1);
+
+ // again check LIKE treatment
+ criteria = new Criteria();
+ criteria.where(
+ AuthorPeer.NAME,
+ author.getName().replace('r', '%'),
+ Criteria.LIKE);
+ result = AuthorPeer.doSelect(criteria);
+ assertTrue("Size of result is not 1, but " + result.size(),
+ result.size() == 1);
+
+ // Test different ignore cases in criterions
+ criteria = new Criteria();
+ criterion1 = new Criterion(
+ AuthorPeer.NAME,
+ author.getName().toLowerCase(),
+ Criteria.NOT_EQUAL);
+ criterion2 = new Criterion(
+ AuthorPeer.NAME,
+ author.getName().toLowerCase(),
+ Criteria.EQUAL);
+ criterion2.setIgnoreCase(true);
+ criterion1.and(criterion2);
+ criteria.where(criterion1);
+
+ result = AuthorPeer.doSelect(criteria);
+ assertTrue("Size of result is not 1, but " + result.size(),
+ result.size() == 1);
+
+ // ignore case in "in" query
+ {
+ criteria = new Criteria();
+ Set<String> names = new HashSet<>();
+ names.add(author.getName());
+ criteria.where(AuthorPeer.NAME, names, Criteria.IN);
+
+ result = AuthorPeer.doSelect(criteria);
+ assertEquals("Expected result of size 1 but got " + result.size(),
+ result.size(),
+ 1);
+ }
+ }
+
+ cleanBookstore();
+ author = new Author();
+ author.setName("AA");
+ author.save();
+ author = new Author();
+ author.setName("BB");
+ author.save();
+ author = new Author();
+ author.setName("ba");
+ author.save();
+ author = new Author();
+ author.setName("ab");
+ author.save();
+
+ // check ignoreCase in Criteria
+ criteria = new Criteria();
+ criteria.setIgnoreCase(true);
+ criteria.addAscendingOrderByColumn(AuthorPeer.NAME);
+ result = AuthorPeer.doSelect(criteria);
+ assertTrue("Size of result is not 4, but " + result.size(),
+ result.size() == 4);
+ assertEquals("AA", result.get(0).getName());
+ assertEquals("ab", result.get(1).getName());
+ assertEquals("ba", result.get(2).getName());
+ assertEquals("BB", result.get(3).getName());
+
+ // check ignoreCase in orderBy
+ criteria = new Criteria();
+ criteria.addAscendingOrderByColumn(AuthorPeer.NAME, true);
+ result = AuthorPeer.doSelect(criteria);
+ assertTrue("Size of result is not 4, but " + result.size(),
+ result.size() == 4);
+ assertEquals(result.get(0).getName(), "AA");
+ assertEquals(result.get(1).getName(), "ab");
+ assertEquals(result.get(2).getName(), "ba");
+ assertEquals(result.get(3).getName(), "BB");
+ }
+
+ /**
+ * tests whether AsColumns produce valid SQL code
+ * @throws Exception if the test fails
+ */
+ @Test
+ public void testAsColumn() throws Exception
+ {
+ Criteria criteria = new Criteria();
+ criteria.addAsColumn("ALIASNAME", AuthorPeer.NAME);
+ // we need an additional column to select from,
+ // to indicate the table we want use
+ criteria.addSelectColumn(AuthorPeer.AUTHOR_ID);
+ new BasePeerImpl<>().doSelect(criteria, new DoNothingMapper());
+ }
+
+ /**
+ * Test whether same column name in different tables
+ * are handled correctly
+ * @throws Exception if the test fails
+ */
+ @Test
+ public void testSameColumnName() throws Exception
+ {
+ cleanBookstore();
+ Author author = new Author();
+ author.setName("Name");
+ author.save();
+
+ author = new Author();
+ author.setName("NotCorrespondingName");
+ author.save();
+
+ Book book = new Book();
+ book.setTitle("Name");
+ book.setAuthor(author);
+ book.setIsbn("unknown");
+ book.save();
+
+ Criteria criteria = new Criteria();
+ criteria.addJoin(BookPeer.TITLE, AuthorPeer.NAME);
+ BookPeer.addSelectColumns(criteria);
+ AuthorPeer.addSelectColumns(criteria);
+ // basically a BaseBookPeer.setDbName(criteria);
+ // and BasePeer.doSelect(criteria);
+ CompositeMapper mapper = new CompositeMapper();
+ mapper.addMapper(new BookRecordMapper(), 0);
+ mapper.addMapper(
+ new AuthorRecordMapper(),
+ BookPeer.numColumns);
+
+ List<List<Object>> queryResult
+ = BookPeer.doSelect(criteria, mapper);
+ List<Object> mappedRow = queryResult.get(0);
+ book = (Book) mappedRow.get(0);
+ author = (Author) mappedRow.get(1);
+
+ if (book.getAuthorId() == author.getAuthorId())
+ {
+ fail("wrong Ids read");
+ }
+ }
+
+ /**
+ * tests whether large primary keys are inserted and read correctly
+ * @throws Exception if the test fails
+ */
+ @Test
+ public void testLargePk() throws Exception
+ {
+ if (defaultAdapter instanceof MssqlAdapter) {
+ log.error("testLargePk(): "
+ + "MSSQL does not support inserting defined PK values");
+ return;
+ }
+ BigintTypePeer.doDelete(new Criteria());
+
+ long longId = 8771507845873286l;
+ BigintType bigintType = new BigintType();
+ bigintType.setId(longId);
+ bigintType.save();
+
+ List<BigintType> bigintTypeList = BigintTypePeer.doSelect(new Criteria());
+ BigintType readBigintType = bigintTypeList.get(0);
+ assertEquals(bigintType.getId(), readBigintType.getId());
+ assertEquals(longId, readBigintType.getId());
+ }
+
+ /**
+ * tests whether large bigint values are inserted and read correctly
+ * @throws Exception if the test fails
+ */
+ @Test
+ public void testLargeValue() throws Exception
+ {
+ BigintTypePeer.doDelete(new Criteria());
+
+ long longValue = 8771507845873286l;
+ BigintType bigintType = new BigintType();
+ bigintType.setBigintValue(longValue);
+ bigintType.save();
+
+ List<BigintType> bigintTypeList = BigintTypePeer.doSelect(new Criteria());
+ BigintType readBigintType = bigintTypeList.get(0);
+ assertEquals(bigintType.getId(), readBigintType.getId());
+ assertEquals(longValue, readBigintType.getBigintValue());
+ }
+
+ /**
+ * Tests the CountHelper class
+ * @throws Exception if the test fails
+ */
+ @Test
+ public void testCountHelper() throws Exception
+ {
+ cleanBookstore();
+ Author author = new Author();
+ author.setName("Name");
+ author.save();
+
+ author = new Author();
+ author.setName("Name2");
+ author.save();
+
+ author = new Author();
+ author.setName("Name");
+ author.save();
+
+ Criteria criteria = new Criteria();
+ int count = new CountHelper().count(
+ criteria,
+ null,
+ AuthorPeer.AUTHOR_ID);
+
+ if (count != 3) {
+ fail("counted " + count + " datasets, should be 3 ");
+ }
+
+ criteria = new Criteria();
+ criteria.setDistinct();
+ count = new CountHelper().count(criteria, null, AuthorPeer.NAME);
+
+ if (count != 2) {
+ fail("counted " + count + " distinct datasets, should be 2 ");
+ }
+
+ criteria = new Criteria();
+ criteria.where(AuthorPeer.NAME, "Name2");
+ count = new CountHelper().count(criteria);
+
+ if (count != 1) {
+ fail("counted " + count + " datasets with name Name2,"
+ + " should be 1 ");
+ }
+ }
+
+
+ /**
+ * Tests whether we can handle multiple primary keys some of which are
+ * also foreign keys
+ * @throws Exception if the test fails
+ */
+ @Test
+ public void testMultiplePrimaryForeignKey() throws Exception
+ {
+ ForeignKeySchemaData.clearTablesInDatabase();
+
+ OIntegerPk oIntegerPk = new OIntegerPk();
+ oIntegerPk.save();
+ CompPkContainsFk compPkContainsFk = new CompPkContainsFk();
+ compPkContainsFk.setId1(oIntegerPk.getId());
+ compPkContainsFk.setId2("test");
+ compPkContainsFk.save();
+
+ List<CompPkContainsFk> selectedList
+ = CompPkContainsFkPeer.doSelect(new Criteria());
+ assertEquals(1, selectedList.size());
+ CompPkContainsFk selected = selectedList.get(0);
+ assertEquals(oIntegerPk.getId(), selected.getId1());
+ assertEquals("test", selected.getId2());
+ }
+
+ /**
+ * Tests inserting single quotes in Strings.
+ * This may not crash now, but in a later task like datasql,
+ * so the data has to be inserted in a table which does not get cleaned
+ * during the runtime test.
+ * @throws Exception if inserting the test data fails
+ */
+ @Test
+ public void testSingleQuotes() throws Exception
+ {
+ cleanBookstore();
+
+ Author author = new Author();
+ author.setName("has Single ' Quote");
+ author.save();
+ }
+
+ /**
+ * Test whether equals() is working correctly
+ * @throws Exception
+ */
+ @Test
+ public void testEquals() throws Exception
+ {
+ Author author = new Author();
+ author.setAuthorId(1000);
+
+ Book book = new Book();
+ book.setBookId(1000);
+
+ Book bookNotEqual = new Book();
+ bookNotEqual.setBookId(2000);
+
+ Book bookEqual = new Book();
+ bookEqual.setBookId(1000);
+
+ assertFalse("Author and Book should not be equal",
+ author.equals(book));
+ assertTrue("Book compared with itself should be equal",
+ book.equals(book));
+ assertTrue("Book compared with book with same id should be equal",
+ book.equals(bookEqual));
+ assertFalse("Book compared with book with different id "
+ + "should not be equal",
+ book.equals(bookNotEqual));
+ }
+
+ /**
+ * Tests whether a table implementing an interface actually
+ * returns an instance of this interface
+ * @throws Exception if the test fails
+ */
+ @Test
+ public void testInterface() throws Exception
+ {
+ Criteria criteria = new Criteria();
+ criteria.where(IfcTablePeer.ID, -1, Criteria.NOT_EQUAL);
+ IfcTablePeer.doDelete(criteria);
+
+ IfcTable ifc = new IfcTable();
+
+ assertTrue("IfcTable should be an instance of TestInterface",
+ ifc instanceof TestInterface);
+
+ ifc.setID(1);
+ ifc.setName("John Doe");
+ ifc.save();
+
+ List<IfcTable> results = IfcTablePeer.doSelect(new Criteria());
+
+ for (IfcTable ifcTable : results)
+ {
+ assertTrue("IfcTablePeer.doSelect should return"
+ + " instances of TestInterface",
+ ifcTable instanceof TestInterface);
+ }
+
+ IfcTablePeerImpl peerImpl = IfcTablePeer.getIfcTablePeerImpl();
+ assertTrue("IfcTablePeerImpl should be an instance of "
+ + "TestPeerInterface",
+ peerImpl instanceof TestPeerInterface);
+
+ LocalIfcTable localIfc = new LocalIfcTable();
+
+ assertTrue("LocalIfcTable should be an instance of LocalTestInterface",
+ localIfc instanceof LocalTestInterface);
+
+ List<LocalIfcTable> results2 = LocalIfcTablePeer.doSelect(new Criteria());
+
+ for (LocalIfcTable readLocalIfcTable : results2)
+ {
+ assertTrue("IfcTable2Peer.doSelect should return"
+ + " instances of LocalTestInterface",
+ readLocalIfcTable instanceof LocalTestInterface);
+ }
+
+ LocalIfcTablePeerImpl localPeerImpl = LocalIfcTablePeer.getLocalIfcTablePeerImpl();
+ assertTrue("LocalIfcTablePeerImpl should be an instance of "
+ + "LocalTestPeerInterface",
+ localPeerImpl instanceof LocalTestPeerInterface);
+ }
+
+ @Test
+ public void testInheritanceWithKeys() throws Exception
+ {
+ // make sure that the InheritanceTest table is empty before the test
+ Criteria criteria = new Criteria();
+ criteria.where(
+ InheritanceTestPeer.INHERITANCE_TEST,
+ (Object) null,
+ Criteria.ISNOTNULL);
+ InheritanceTestPeer.doDelete(criteria);
+ criteria = new Criteria();
+ criteria.where(
+ InheritanceTestPeer.INHERITANCE_TEST,
+ (Object) null,
+ Criteria.ISNOTNULL);
+ assertEquals(0,
+ new CountHelper().count(criteria));
+
+ // create & save test data
+ InheritanceTest inheritanceTest = new InheritanceTest();
+ inheritanceTest.setPayload("payload1");
+ inheritanceTest.save();
+ InheritanceChildB inheritanceChildB = new InheritanceChildB();
+ inheritanceChildB.setPayload("payload 2");
+ inheritanceChildB.save();
+ InheritanceChildC inheritanceChildC = new InheritanceChildC();
+ inheritanceChildC.setPayload("payload 3");
+ inheritanceChildC.save();
+ InheritanceChildD inheritanceChildD = new InheritanceChildD();
+ inheritanceChildD.setPayload("payload 4");
+ inheritanceChildD.save();
+
+ // Check that all objects are saved into the InheritanceTest table
+ criteria = new Criteria();
+ criteria.where(
+ InheritanceTestPeer.INHERITANCE_TEST,
+ null,
+ Criteria.ISNOTNULL);
+ assertEquals("InheritanceTestTable should contain 4 rows",
+ 4,
+ new CountHelper().count(criteria));
+ criteria = new Criteria();
+ criteria.addAscendingOrderByColumn(
+ InheritanceTestPeer.INHERITANCE_TEST);
+
+ // Check that the class of the object is retained when loading
+ List<InheritanceTest> inheritanceObjects
+ = InheritanceTestPeer.doSelect(criteria);
+ assertEquals(
+ InheritanceTest.class,
+ inheritanceObjects.get(0).getClass());
+ assertEquals(
+ InheritanceChildB.class,
+ inheritanceObjects.get(1).getClass());
+ assertEquals(
+ InheritanceChildC.class,
+ inheritanceObjects.get(2).getClass());
+ assertEquals(
+ InheritanceChildD.class,
+ inheritanceObjects.get(3).getClass());
+ }
+
+ @Test
+ public void testInheritanceWithClassname() throws Exception
+ {
+ // make sure that the InheritanceTest table is empty before the test
+ Criteria criteria = new Criteria();
+ InheritanceClassnameTestPeer.doDelete(criteria);
+ criteria = new Criteria();
+ criteria.where(
+ InheritanceClassnameTestPeer.INHERITANCE_TEST,
+ null,
+ Criteria.ISNOTNULL);
+ assertEquals(0,
+ new CountHelper().count(criteria));
+
+ // create & save test data
+ InheritanceClassnameTest inheritanceClassnameTest
+ = new InheritanceClassnameTest();
+ inheritanceClassnameTest.setPayload("0 parent");
+ inheritanceClassnameTest.save();
+ InheritanceClassnameTestChild1 inheritanceClassnameChild1
+ = new InheritanceClassnameTestChild1();
+ inheritanceClassnameChild1.setPayload("1 child");
+ inheritanceClassnameChild1.save();
+ InheritanceClassnameTestChild2 inheritanceClassnameChild2
+ = new InheritanceClassnameTestChild2();
+ inheritanceClassnameChild2.setPayload("2 child");
+ inheritanceClassnameChild2.save();
+
+ // Check that all objects are saved into the InheritanceTest table
+ criteria = new Criteria();
+ criteria.where(
+ InheritanceClassnameTestPeer.INHERITANCE_TEST,
+ null,
+ Criteria.ISNOTNULL);
+ assertEquals("InheritanceClassnameTest table should contain 3 rows",
+ 3,
+ new CountHelper().count(criteria));
+ criteria = new Criteria();
+ criteria.addAscendingOrderByColumn(
+ InheritanceClassnameTestPeer.PAYLOAD);
+
+ // Check that the class of the object is retained when loading
+ List<InheritanceClassnameTest> inheritanceObjects
+ = InheritanceClassnameTestPeer.doSelect(criteria);
+ assertEquals(
+ InheritanceClassnameTest.class,
+ inheritanceObjects.get(0).getClass());
+ assertEquals("0 parent", inheritanceObjects.get(0).getPayload());
+ assertEquals(
+ InheritanceClassnameTestChild1.class,
+ inheritanceObjects.get(1).getClass());
+ assertEquals("1 child", inheritanceObjects.get(1).getPayload());
+ assertEquals(
+ InheritanceClassnameTestChild2.class,
+ inheritanceObjects.get(2).getClass());
+ assertEquals("2 child", inheritanceObjects.get(2).getPayload());
+ }
+
+ /**
+ * Checks whether selects with unqualified column names work.
+ *
+ * @throws Exception if a problem occurs.
+ */
+ @Test
+ public void testUnqualifiedColumnNames() throws Exception
+ {
+ cleanBookstore();
+ Author author = new Author();
+ author.setName("Joshua Bloch");
+ author.save();
+
+ Criteria criteria = new Criteria();
+ criteria.where(AuthorPeer.AUTHOR_ID, (Object) null, Criteria.NOT_EQUAL);
+ criteria.and(new ColumnImpl("name"), "Joshua Bloch", Criteria.EQUAL);
+ List<Author> authors = AuthorPeer.doSelect(criteria);
+ assertEquals(1, authors.size());
+ }
+
+ @Test
+ public void testLikeClauseEscaping() throws Exception
+ {
+ String[] authorNames
+ = {"abc", "bbc", "a_c", "a%c", "a\\c",
+ "a\"c", "a'c", "a?c", "a*c" };
+
+ Map<String, String> likeResults = new LinkedHashMap<>();
+
+ likeResults.put("a\\_c", "a_c");
+ likeResults.put("a\\_%", "a_c");
+ likeResults.put("%\\_c", "a_c");
+
+ likeResults.put("a\\%c", "a%c");
+ likeResults.put("a\\%%", "a%c");
+ likeResults.put("%\\%c", "a%c"); // escaped second %
+
+ likeResults.put("a\\\\c", "a\\c"); // escaped \ three times
+ likeResults.put("a\\\\%", "a\\c");
+
+ // mysql: like '%\\c' ESCAPE '|' succeeds, but
+ // %\\\\c fails, see https://dev.mysql.com/doc/refman/8.0/en/string-comparison-functions.html,
+ // MySQL uses C escape syntax in strings.. you must double any \ that you use in LIKE strings.
+ // That is platform specific mysql:
+ // likeResults.put("%\\\\\\\\c", "a\\c"); // succeeds in mysql
+ // other platforms ?
+ //likeResults.put("%\\\\c", "a\\c"); // fails in mysql
+
+ likeResults.put("a\\*c", "a*c");
+ likeResults.put("a\\*%", "a*c");
+ //likeResults.put("%\\*c", "a*c"); // mysql: %\\*c fails, only underscore (_) is wild card
+ // this matches multiple users
+ //likeResults.put("%*c", "a%c");
+ likeResults.put("_\\*c", "a*c");
+
+ likeResults.put("a\\?c", "a?c");
+ likeResults.put("a\\?%", "a?c");
+ likeResults.put("%\\?c", "a?c");
+
+ likeResults.put("a\"c", "a\"c");
+ likeResults.put("a\"%", "a\"c");
+ likeResults.put("%\"c", "a\"c");
+
+ likeResults.put("a'c", "a'c");
+ likeResults.put("a'%", "a'c");
+ likeResults.put("%'c", "a'c");
+ cleanBookstore();
+
+ // Save authors
+ for (int i = 0; i < authorNames.length; ++i)
+ {
+ Author author = new Author();
+ author.setName(authorNames[i]);
+ author.save();
+ }
+
+ // Check authors are in the database
+ for (int i = 0; i < authorNames.length; ++i)
+ {
+ Criteria criteria = new Criteria();
+ criteria.where(AuthorPeer.NAME, authorNames[i]);
+ List<Author> authorList = AuthorPeer.doSelect(criteria);
+ assertEquals(
+ "AuthorList should contain one author"
+ + " when querying for " + authorNames[i],
+ 1,
+ authorList.size());
+ Author author = authorList.get(0);
+ assertEquals("Name of author should be " + authorNames[i],
+ authorNames[i],
+ author.getName());
+ }
+
+ for (Map.Entry<String, String> likeResult : likeResults.entrySet())
+ {
+ // System.out.println("Key: " + likeResult.getKey() + " - Value: " + likeResult.getValue());
+ Criteria criteria = new Criteria();
+ criteria.where(
+ AuthorPeer.NAME,
+ likeResult.getKey(),
+ Criteria.LIKE);
+ List<Author> authorList;
+ try
+ {
+ authorList = AuthorPeer.doSelect(criteria);
+ }
+ catch (Exception e)
+ {
+ throw new Exception(
+ "error executing select using like content "
+ + likeResult.getKey(),
+ e);
+ }
+ assertEquals(
+ "AuthorList contained " + authorList.size() + ", but should contain one author"
+ + " when querying for " + likeResult.getKey(),
+ 1,
+ authorList.size());
+ Author author = authorList.get(0);
+ assertEquals("Name of author should be "
+ + likeResult.getValue()
+ + " when querying for "
+ + likeResult.getKey(),
+ likeResult.getValue(),
+ author.getName());
+ }
+
+ // check that case insensitivity is maintained if
+ // a like is replaced with an equals (no wildcard present)
+ // This might be a problem for databases which use ILIKE
+ Criteria criteria = new Criteria();
+ criteria.where(AuthorPeer.NAME, "AbC", Criteria.LIKE);
+ criteria.setIgnoreCase(true);
+ List<Author> authorList = AuthorPeer.doSelect(criteria);
+ assertEquals(
+ "AuthorList should contain one author",
+ 1,
+ authorList.size());
+ Author author = authorList.get(0);
+ assertEquals("Name of author should be abc",
+ "abc",
+ author.getName());
+
+ // check that the escape clause (where needed) also works
+ // with limit, offset and order by
+ criteria = new Criteria();
+ Criterion criterion1 = new Criterion(
+ AuthorPeer.NAME,
+ "b%",
+ Criteria.LIKE);
+ Criterion criterion2 = new Criterion(
+ AuthorPeer.NAME,
+ "a\\%%",
+ Criteria.LIKE);
+ Criterion criterion3 = new Criterion(
+ AuthorPeer.NAME,
+ "cbc",
+ Criteria.LIKE);
+ criteria.where(criterion1.or(criterion2).or(criterion3));
+ criteria.addAscendingOrderByColumn(AuthorPeer.NAME);
+ criteria.setOffset(1);
+ criteria.setLimit(1);
+ authorList = AuthorPeer.doSelect(criteria);
+ assertEquals(
+ "AuthorList should contain one author",
+ 1,
+ authorList.size());
+ author = authorList.get(0);
+ assertEquals("Name of author should be bbc",
+ "bbc",
+ author.getName());
+ }
+
+
+ /**
+ * Strips the schema and table name from a fully qualified colum name
+ * This is useful for creating Query with aliases, as the constants
+ * for the colum names in the data objects are fully qualified.
+ * @param fullyQualifiedColumnName the fully qualified column name, not null
+ * @return the column name stripped from the table (and schema) prefixes
+ */
+ public static String getRawColumnName(final String fullyQualifiedColumnName)
+ {
+ int dotPosition = fullyQualifiedColumnName.lastIndexOf(".");
+ if (dotPosition == -1)
+ {
+ return fullyQualifiedColumnName;
+ }
+ String result = fullyQualifiedColumnName.substring(
+ dotPosition + 1,
+ fullyQualifiedColumnName.length());
+ return result;
+ }
+
+ static class DoNothingMapper implements RecordMapper<Object>
+ {
+
+ /** Serial version */
+ private static final long serialVersionUID = 1L;
+
+ @Override
+ public Object processRow(
+ final ResultSet resultSet,
+ final int rowOffset,
+ final Criteria criteria)
+ throws TorqueException
+ {
+ return null;
+ }
+ }
+}
Propchange: db/torque/torque4/trunk/torque-test/src/test/java/org/apache/torque/testcontainer/DataContainerTest.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: db/torque/torque4/trunk/torque-test/src/test/profile/mysql/Torque4Test.xml
URL: http://svn.apache.org/viewvc/db/torque/torque4/trunk/torque-test/src/test/profile/mysql/Torque4Test.xml?rev=1870385&view=auto
==============================================================================
--- db/torque/torque4/trunk/torque-test/src/test/profile/mysql/Torque4Test.xml (added)
+++ db/torque/torque4/trunk/torque-test/src/test/profile/mysql/Torque4Test.xml Mon Nov 25 15:22:32 2019
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="ISO-8859-1" ?>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+<!-- from the docs: CombinedConfigurationBuilder takes care that properties defined in the first file (the user file) are found; other properties which the user has not changed will still be returned from the second file (the defaults file). -->
+
+<configuration>
+ <properties config-name="torqueuser" fileName="torque.usersettings.properties" config-optional="true" config-forceCreate="true"/>
+ <properties config-name="torque" fileName="Torque.properties" throwExceptionOnMissing="true"/>
+</configuration>
\ No newline at end of file
Propchange: db/torque/torque4/trunk/torque-test/src/test/profile/mysql/Torque4Test.xml
------------------------------------------------------------------------------
svn:eol-style = native
Added: db/torque/torque4/trunk/torque-test/src/test/profile/mysql/docker-resources/db/.dockerignore
URL: http://svn.apache.org/viewvc/db/torque/torque4/trunk/torque-test/src/test/profile/mysql/docker-resources/db/.dockerignore?rev=1870385&view=auto
==============================================================================
--- db/torque/torque4/trunk/torque-test/src/test/profile/mysql/docker-resources/db/.dockerignore (added)
+++ db/torque/torque4/trunk/torque-test/src/test/profile/mysql/docker-resources/db/.dockerignore Mon Nov 25 15:22:32 2019
@@ -0,0 +1,19 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+*/tmp*
+*/*/tmp*
+tmp?
\ No newline at end of file
Added: db/torque/torque4/trunk/torque-test/src/test/profile/mysql/docker-resources/db/Dockerfile
URL: http://svn.apache.org/viewvc/db/torque/torque4/trunk/torque-test/src/test/profile/mysql/docker-resources/db/Dockerfile?rev=1870385&view=auto
==============================================================================
--- db/torque/torque4/trunk/torque-test/src/test/profile/mysql/docker-resources/db/Dockerfile (added)
+++ db/torque/torque4/trunk/torque-test/src/test/profile/mysql/docker-resources/db/Dockerfile Mon Nov 25 15:22:32 2019
@@ -0,0 +1,10 @@
+FROM mysql:8.0.18
+
+COPY [ "./generated-createddb-sql/*", "./generated-sql/*", "/docker-entrypoint-initdb.d/" ]
+
+ENV MYSQL_DATABASE ${MYSQL_DATABASE}
+ENV MYSQL_USER=${MYSQL_USER}
+ENV MYSQL_PASSWORD=${MYSQL_PASSWORD}
+ENV MYSQL_HOST=%
+
+ENV MYSQL_ROOT_PASSWORD=${MYSQL_PASSWORD}
lmpx.com only provides a reader for public news (NNTP) servers. It is not
affiliated with the servers or forums shown here and is not responsible for
the content of articles, which is written by their respective authors.