ff-attic/tpquery
3
0
Fork 0
Code Issues 2 Pull requests Activity

[Task-3]-updated java11 and junit5 #5

Merged
immetoo merged 1 commit from feature/issue-3/upgrade-java-11 into master 2020-10-18 21:53:19 +00:00
Conversation 0 Commits 1 Files changed 28 +873 -798
28 changed files with 873 additions and 798 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

63
pom.xml
View file

@ -1,4 +1,5 @@
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" <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/xsd/maven-4.0.0.xsd"> xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion> <modelVersion>4.0.0</modelVersion>
<groupId>net.forwardfire.tpquery</groupId> <groupId>net.forwardfire.tpquery</groupId>
@ -30,13 +31,13 @@
</modules> </modules>
<properties> <properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.build.sourceVersion>1.8</project.build.sourceVersion> <project.build.sourceVersion>11</project.build.sourceVersion>
<!-- workaround for: [WARNING] 'reporting.plugins.plugin.version' for ... --> <!-- workaround for: [WARNING] 'reporting.plugins.plugin.version' for ... -->
<jacoco-maven-plugin.version>0.7.4.201502262128</jacoco-maven-plugin.version><!-- <jacoco-maven-plugin.version>0.8.4</jacoco-maven-plugin.version><!--
invalid format 1007: <version>0.7.5.201505241946</version> --> invalid format 1007: <version>0.7.5.201505241946</version> -->
<maven-javadoc-plugin.version>2.10.3</maven-javadoc-plugin.version> <maven-javadoc-plugin.version>2.10.3</maven-javadoc-plugin.version>
<maven-project-info-reports-plugin>2.8</maven-project-info-reports-plugin> <maven-project-info-reports-plugin>3.0.0</maven-project-info-reports-plugin>
</properties> </properties>
<dependencyManagement> <dependencyManagement>
<dependencies> <dependencies>
@ -51,9 +52,9 @@
<version>3.5</version> <version>3.5</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>junit</groupId> <groupId>org.junit.jupiter</groupId>
<artifactId>junit</artifactId> <artifactId>junit-jupiter-engine</artifactId>
<version>4.12</version> <version>5.5.2</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>ch.qos.logback</groupId> <groupId>ch.qos.logback</groupId>
@ -95,12 +96,27 @@
<artifactId>sonar-jacoco-listeners</artifactId> <artifactId>sonar-jacoco-listeners</artifactId>
<version>3.2</version> <version>3.2</version>
</dependency> </dependency>
<dependency>
<groupId>javax.xml.bind</groupId>
<artifactId>jaxb-api</artifactId>
<version>2.3.1</version>
</dependency>
<dependency>
<groupId>com.sun.xml.bind</groupId>
<artifactId>jaxb-impl</artifactId>
<version>2.3.1</version>
</dependency>
<dependency>
<groupId>com.sun.xml.bind</groupId>
<artifactId>jaxb-core</artifactId>
<version>2.3.0</version>
</dependency>
</dependencies> </dependencies>
</dependencyManagement> </dependencyManagement>
<dependencies> <dependencies>
<dependency> <dependency>
<groupId>junit</groupId> <groupId>org.junit.jupiter</groupId>
<artifactId>junit</artifactId> <artifactId>junit-jupiter-engine</artifactId>
<scope>test</scope> <scope>test</scope>
</dependency> </dependency>
<dependency> <dependency>
@ -165,22 +181,6 @@
</plugins> </plugins>
</pluginManagement> </pluginManagement>
<plugins> <plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jdeps-plugin</artifactId>
<version>3.0.0</version>
<executions>
<execution>
<phase>validate</phase>
<goals>
<goal>jdkinternals</goal> <!-- verify main classes -->
<goal>test-jdkinternals</goal> <!-- verify test classes -->
</goals>
</execution>
</executions>
<configuration>
</configuration>
</plugin>
<plugin> <plugin>
<groupId>org.apache.maven.plugins</groupId> <groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-enforcer-plugin</artifactId> <artifactId>maven-enforcer-plugin</artifactId>
@ -198,9 +198,7 @@
<requireMavenVersion> <requireMavenVersion>
<version>(3.0,)</version> <version>(3.0,)</version>
</requireMavenVersion> </requireMavenVersion>
<!-- jdk9 check <!-- jdk9 check <banDuplicateClasses></banDuplicateClasses> -->
<banDuplicateClasses></banDuplicateClasses>
-->
</rules> </rules>
</configuration> </configuration>
</plugin> </plugin>
@ -380,9 +378,12 @@
<configuration> <configuration>
<target> <target>
<echo>Copy project markdown to site.</echo> <echo>Copy project markdown to site.</echo>
<copy verbose="true" file="readme.md" toFile="src/site/markdown/index.md" /> <copy verbose="true" file="readme.md"
<copy verbose="true" file="todo.md" todir="src/site/markdown" /> toFile="src/site/markdown/index.md" />
<copy verbose="true" file="build.md" todir="src/site/markdown" /> <copy verbose="true" file="todo.md"
todir="src/site/markdown" />
<copy verbose="true" file="build.md"
todir="src/site/markdown" />
</target> </target>
</configuration> </configuration>
</execution> </execution>

0
README.md → readme.md
View file

0
TODO.md → todo.md
View file

176
tpquery-executor-jdbc/src/test/java/net/forwardfire/tpquery/store/executor/jdbc/TPQExecutorJdbcTest.java
View file

@ -1,7 +1,8 @@
package net.forwardfire.tpquery.store.executor.jdbc; package net.forwardfire.tpquery.store.executor.jdbc;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.sql.Connection; import java.sql.Connection;
import java.sql.DriverManager; import java.sql.DriverManager;
@ -11,20 +12,17 @@ import java.sql.SQLException;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import net.forwardfire.tpquery.TPQManager; import org.junit.jupiter.api.BeforeEach;
import net.forwardfire.tpquery.TPQFactory; import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.store.executor.jdbc.SQLExceptionRuntime;
import net.forwardfire.tpquery.store.executor.jdbc.TPQExecutorJdbc;
import org.junit.BeforeClass;
import org.junit.Test;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import ch.qos.logback.classic.LoggerContext; import ch.qos.logback.classic.LoggerContext;
import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.TPQManager;
public class TPQExecutorJdbcTest { public class TPQExecutorJdbcTest {
@BeforeClass @BeforeEach
public static void setupLogging() { public static void setupLogging() {
LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory(); LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
lc.reset(); // disable logging lc.reset(); // disable logging
@ -84,94 +82,104 @@ public class TPQExecutorJdbcTest {
} }
} }
@Test(expected=SQLExceptionRuntime.class) @Test
public void testExecuteUpdateFail() throws Exception { public void testExecuteUpdateFail() throws Exception {
try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) { assertThrows(SQLExceptionRuntime.class, () -> {
TPQManager store = TPQFactory try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) {
.createManagerBuilder() TPQManager store = TPQFactory
.createQuerySet("junit", "jar:junit:mem") .createManagerBuilder()
.setLanguage(TPQFactory.StatementLanguage.SQL) .createQuerySet("junit", "jar:junit:mem")
.createQuery("createTable").appendText("CREATE TABLE test_table (id serial,data int)").build() .setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("insertData").appendText("INSERT INTO test_table (data) VALUES (0)").build() .createQuery("createTable").appendText("CREATE TABLE test_table (id serial,data int)").build()
.createQuery("queryFail").appendText("update test_table tt set tt.data=10/(SELECT sum(t1.data) FROM test_table t1)").build() .createQuery("insertData").appendText("INSERT INTO test_table (data) VALUES (0)").build()
.build() .createQuery("queryFail").appendText("update test_table tt set tt.data=10/(SELECT sum(t1.data) FROM test_table t1)").build()
.build(); .build()
.build();
TPQExecutorJdbc exe = new TPQExecutorJdbc(store.getQueryExecutorContext());
exe.executeUpdate(connection, "junit.createTable"); TPQExecutorJdbc exe = new TPQExecutorJdbc(store.getQueryExecutorContext());
exe.executeUpdate(connection, "junit.insertData"); exe.executeUpdate(connection, "junit.createTable");
exe.executeUpdate(connection, "junit.queryFail"); // runtime data failure, as prepared will go correctly exe.executeUpdate(connection, "junit.insertData");
exe.executeUpdate(connection, "junit.queryFail"); // runtime data failure, as prepared will go correctly
} }
});
} }
@Test(expected=SQLExceptionRuntime.class) @Test
public void testExecuteSelectFail() throws Exception { public void testExecuteSelectFail() throws Exception {
try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) { assertThrows(SQLExceptionRuntime.class, () -> {
try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) {
TPQManager store = TPQFactory
.createManagerBuilder() TPQManager store = TPQFactory
.createQuerySet("junit", "jar:junit:mem") .createManagerBuilder()
.setLanguage(TPQFactory.StatementLanguage.SQL) .createQuerySet("junit", "jar:junit:mem")
.createQuery("createTable").appendText("CREATE TABLE test_table (id serial,data int)").build() .setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("insertData").appendText("INSERT INTO test_table (data) VALUES (0)").build() .createQuery("createTable").appendText("CREATE TABLE test_table (id serial,data int)").build()
.createQuery("queryFail").appendText("select tt.* from test_table tt where tt.data=10/(SELECT sum(t1.data) FROM test_table t1)").build() .createQuery("insertData").appendText("INSERT INTO test_table (data) VALUES (0)").build()
.build() .createQuery("queryFail").appendText("select tt.* from test_table tt where tt.data=10/(SELECT sum(t1.data) FROM test_table t1)").build()
.build(); .build()
.build();
TPQExecutorJdbc exe = new TPQExecutorJdbc(store.getQueryExecutorContext());
exe.executeUpdate(connection, "junit.createTable"); TPQExecutorJdbc exe = new TPQExecutorJdbc(store.getQueryExecutorContext());
exe.executeUpdate(connection, "junit.insertData"); exe.executeUpdate(connection, "junit.createTable");
exe.execute(connection, "junit.queryFail"); // runtime data failure, as prepared will go correctly exe.executeUpdate(connection, "junit.insertData");
} exe.execute(connection, "junit.queryFail"); // runtime data failure, as prepared will go correctly
}
});
} }
@Test(expected=SQLExceptionRuntime.class) @Test
public void testExecuteSelectFailPrepare() throws Exception { public void testExecuteSelectFailPrepare() throws Exception {
try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) { assertThrows(SQLExceptionRuntime.class, () -> {
TPQManager store = TPQFactory.createManagerBuilder() try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) {
.createQuerySet("junit", "jar:junit:mem:testcaseFail") TPQManager store = TPQFactory.createManagerBuilder()
.setLanguage(TPQFactory.StatementLanguage.SQL) .createQuerySet("junit", "jar:junit:mem:testcaseFail")
.createQuery("sql-fail").appendText("select * from article").build() .setLanguage(TPQFactory.StatementLanguage.SQL)
.build() .createQuery("sql-fail").appendText("select * from article").build()
.build(); .build()
TPQExecutorJdbc exe = new TPQExecutorJdbc(store.getQueryExecutorContext()); .build();
exe.execute(connection, "junit.sql-fail"); TPQExecutorJdbc exe = new TPQExecutorJdbc(store.getQueryExecutorContext());
} exe.execute(connection, "junit.sql-fail");
}
});
} }
@Test(expected=SQLExceptionRuntime.class) @Test
public void testTimeoutFail() throws Exception { public void testTimeoutFail() throws Exception {
try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) { assertThrows(SQLExceptionRuntime.class, () -> {
TPQManager store = TPQFactory.createManagerBuilder() try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) {
.createQuerySet("junit", "jar:junit:mem:test") TPQManager store = TPQFactory.createManagerBuilder()
.setLanguage(TPQFactory.StatementLanguage.SQL) .createQuerySet("junit", "jar:junit:mem:test")
.createQuery("createTable").appendText("CREATE TABLE test_table (id serial,data int)").build() .setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("test").appendText("select * from test_table").build() .createQuery("createTable").appendText("CREATE TABLE test_table (id serial,data int)").build()
.build() .createQuery("test").appendText("select * from test_table").build()
.build(); .build()
TPQExecutorJdbc exe = new TPQExecutorJdbc(store.getQueryExecutorContext()); .build();
exe.executeUpdate(connection, "junit.createTable"); TPQExecutorJdbc exe = new TPQExecutorJdbc(store.getQueryExecutorContext());
PreparedStatement ps = exe.createPreparedStatement(connection, "junit.test", null); exe.executeUpdate(connection, "junit.createTable");
ps.close(); PreparedStatement ps = exe.createPreparedStatement(connection, "junit.test", null);
exe.prepareTimeout(ps, 123); ps.close();
} exe.prepareTimeout(ps, 123);
}
});
} }
@Test(expected=SQLExceptionRuntime.class) @Test
public void testParameterFail() throws Exception { public void testParameterFail() throws Exception {
try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) { assertThrows(SQLExceptionRuntime.class, () -> {
TPQManager store = TPQFactory.createManagerBuilder() try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) {
.createQuerySet("junit", "jar:junit:mem:test") TPQManager store = TPQFactory.createManagerBuilder()
.setLanguage(TPQFactory.StatementLanguage.SQL) .createQuerySet("junit", "jar:junit:mem:test")
.createQuery("createTable").appendText("CREATE TABLE test_table (id serial,data int)").build() .setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("test").appendText("select * from test_table").build() .createQuery("createTable").appendText("CREATE TABLE test_table (id serial,data int)").build()
.build() .createQuery("test").appendText("select * from test_table").build()
.build(); .build()
TPQExecutorJdbc exe = new TPQExecutorJdbc(store.getQueryExecutorContext()); .build();
exe.executeUpdate(connection, "junit.createTable"); TPQExecutorJdbc exe = new TPQExecutorJdbc(store.getQueryExecutorContext());
PreparedStatement ps = exe.createPreparedStatement(connection, "junit.test", null); exe.executeUpdate(connection, "junit.createTable");
exe.prepareParameterValue(ps, 1, 123); PreparedStatement ps = exe.createPreparedStatement(connection, "junit.test", null);
} exe.prepareParameterValue(ps, 1, 123);
}
});
} }
@Test @Test

97
tpquery-executor-jpa/src/test/java/net/forwardfire/tpquery/store/executor/jpa/TPQExecutorJpaTest.java
View file

@ -1,8 +1,9 @@
package net.forwardfire.tpquery.store.executor.jpa; package net.forwardfire.tpquery.store.executor.jpa;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
@ -12,44 +13,42 @@ import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory; import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence; import javax.persistence.Persistence;
import net.forwardfire.tpquery.TPQManager; import org.junit.jupiter.api.AfterEach;
import net.forwardfire.tpquery.TPQFactory; import org.junit.jupiter.api.BeforeAll;
import net.forwardfire.tpquery.config.TPQConfig; import org.junit.jupiter.api.BeforeEach;
import net.forwardfire.tpquery.statement.AbstractTPQStatementWriter; import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.statement.TPQStatementWriter;
import net.forwardfire.tpquery.statement.TPQStatementLanguage;
import net.forwardfire.tpquery.store.executor.jpa.TPQExecutorJpa;
import net.forwardfire.tpquery.store.proxy.TPQueryName;
import net.forwardfire.tpquery.store.proxy.TPQueryProxyFactory;
import net.forwardfire.tpquery.store.proxy.TPQueryParameterName;
import net.forwardfire.tpquery.store.proxy.TPQueryProxy;
import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import ch.qos.logback.classic.LoggerContext; import ch.qos.logback.classic.LoggerContext;
import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.config.TPQConfig;
import net.forwardfire.tpquery.statement.AbstractTPQStatementWriter;
import net.forwardfire.tpquery.statement.TPQStatementLanguage;
import net.forwardfire.tpquery.statement.TPQStatementWriter;
import net.forwardfire.tpquery.store.proxy.TPQueryName;
import net.forwardfire.tpquery.store.proxy.TPQueryParameterName;
import net.forwardfire.tpquery.store.proxy.TPQueryProxy;
import net.forwardfire.tpquery.store.proxy.TPQueryProxyFactory;
public class TPQExecutorJpaTest { public class TPQExecutorJpaTest {
private EntityManagerFactory emFactory; private EntityManagerFactory emFactory;
private EntityManager em = null; private EntityManager em = null;
@BeforeClass @BeforeAll
public static void setupLogging() { public static void setupLogging() {
LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory(); LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
lc.reset(); // disable logging lc.reset(); // disable logging
} }
@Before @BeforeEach
public void before() { public void before() {
emFactory = Persistence.createEntityManagerFactory("junit"); emFactory = Persistence.createEntityManagerFactory("junit");
em = emFactory.createEntityManager(); em = emFactory.createEntityManager();
} }
@After @AfterEach
public void close() { public void close() {
em.close(); em.close();
emFactory.close(); emFactory.close();
@ -116,36 +115,39 @@ public class TPQExecutorJpaTest {
//assertEquals("foobar",resultSingle.name); //assertEquals("foobar",resultSingle.name);
} }
@Test(expected=NullPointerException.class) @Test
public void testUnsupportedLanguage() throws Exception { public void testUnsupportedLanguage() throws Exception {
TPQConfig config = new TPQConfig(); assertThrows(NullPointerException.class, () -> {
config.addStatementLanguage(new TPQStatementLanguage() { TPQConfig config = new TPQConfig();
@Override config.addStatementLanguage(new TPQStatementLanguage() {
public String getLanguageType() { @Override
return "XQL"; public String getLanguageType() {
} return "XQL";
}
@Override
public TPQStatementWriter createQueryWriter(Map<String, Object> parameterData) { @Override
return new AbstractTPQStatementWriter(parameterData) { public TPQStatementWriter createQueryWriter(Map<String, Object> parameterData) {
}; return new AbstractTPQStatementWriter(parameterData) {
} };
}); }
TPQManager store = TPQFactory });
.createManagerBuilder(config) TPQManager store = TPQFactory
.createQuerySet("junit", "jar:mem:test") .createManagerBuilder(config)
.createQuery("test") .createQuerySet("junit", "jar:mem:test")
.setLanguage("XQL") .createQuery("test")
.parseStatement("select * from table") .setLanguage("XQL")
.parseStatement("select * from table")
.build()
.build() .build()
.build() .build();
.build(); TPQExecutorJpa exe = new TPQExecutorJpa(store.getQueryExecutorContext());
TPQExecutorJpa exe = new TPQExecutorJpa(store.getQueryExecutorContext()); exe.selectList(em, "junit.test", null);
exe.selectList(em, "junit.test", null); });
} }
@Test() @Test
public void testQueryProxy() throws Exception { public void testQueryProxy() throws Exception {
assertThrows(NullPointerException.class, () -> {
TPQManager store = TPQFactory.createManagerBuilder() TPQManager store = TPQFactory.createManagerBuilder()
.createQuerySet("junit", "jar:junit:mem") .createQuerySet("junit", "jar:junit:mem")
.setLanguage(TPQFactory.StatementLanguage.HQL) .setLanguage(TPQFactory.StatementLanguage.HQL)
@ -196,6 +198,7 @@ public class TPQExecutorJpaTest {
d = foobarService.testFoo(); d = foobarService.testFoo();
assertNotNull(d); assertNotNull(d);
});
} }
@TPQueryProxy(prefix="junit.") @TPQueryProxy(prefix="junit.")

18
tpquery-store/pom.xml
View file

@ -1,4 +1,5 @@
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" <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/xsd/maven-4.0.0.xsd"> xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion> <modelVersion>4.0.0</modelVersion>
<parent> <parent>
@ -22,6 +23,21 @@
<artifactId>commons-lang3</artifactId> <artifactId>commons-lang3</artifactId>
<scope>compile</scope> <scope>compile</scope>
</dependency> </dependency>
<dependency>
<groupId>javax.xml.bind</groupId>
<artifactId>jaxb-api</artifactId>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.sun.xml.bind</groupId>
<artifactId>jaxb-impl</artifactId>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.sun.xml.bind</groupId>
<artifactId>jaxb-core</artifactId>
<scope>compile</scope>
</dependency>
</dependencies> </dependencies>
</project> </project>

7
tpquery-store/src/test/java/net/forwardfire/tpquery/TPQFactoryTest.java
View file

@ -1,11 +1,10 @@
package net.forwardfire.tpquery; package net.forwardfire.tpquery;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import org.junit.Test; import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.config.TPQConfig; import net.forwardfire.tpquery.config.TPQConfig;
public class TPQFactoryTest { public class TPQFactoryTest {

19
tpquery-store/src/test/java/net/forwardfire/tpquery/TPQSpeedTest.java
View file

@ -11,15 +11,14 @@ import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors; import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
import org.junit.AfterClass; import org.junit.jupiter.api.AfterAll;
import org.junit.BeforeClass; import org.junit.jupiter.api.BeforeAll;
import org.junit.Test; import org.junit.jupiter.api.Test;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import ch.qos.logback.classic.LoggerContext; import ch.qos.logback.classic.LoggerContext;
import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.store.TPQueryStoreStatementMapper;
import net.forwardfire.tpquery.store.TPQueryStoreStatement; import net.forwardfire.tpquery.store.TPQueryStoreStatement;
import net.forwardfire.tpquery.store.TPQueryStoreStatementMapper;
import net.forwardfire.tpquery.store.manager.TPQStoreManagerExecutorContext; import net.forwardfire.tpquery.store.manager.TPQStoreManagerExecutorContext;
import net.forwardfire.tpquery.store.manager.TPQStoreManagerExecutorStatement; import net.forwardfire.tpquery.store.manager.TPQStoreManagerExecutorStatement;
@ -28,17 +27,17 @@ public class TPQSpeedTest {
static int loopSize; static int loopSize;
static int warmupSize; static int warmupSize;
static TPQManager queryManager; static TPQManager queryManager;
static List<String> result; static List<String> result = new ArrayList<>();;
@BeforeClass @BeforeAll
static public void initSpeedTest() throws Exception { static public void initSpeedTest() throws Exception {
LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory(); LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
lc.reset(); // disable logging in speed tests. lc.reset(); // disable logging in speed tests.
warmupSize = 10; warmupSize = 10;
loopSize = 100000*new Integer(System.getProperty("junit.speedtest.factor", "1")); loopSize = 100000 * Integer.parseInt(System.getProperty("junit.speedtest.factor", "1"));
result = new ArrayList<>();
queryManager = TPQFactory.createManagerBuilder() queryManager = TPQFactory.createManagerBuilder()
.createQuerySet("junit", "jar:junit:mem") .createQuerySet("junit", "jar:junit:mem")
.setLanguage(TPQFactory.StatementLanguage.SQL) .setLanguage(TPQFactory.StatementLanguage.SQL)
@ -122,7 +121,7 @@ public class TPQSpeedTest {
} }
} }
@AfterClass @AfterAll
public static void printResults() { public static void printResults() {
TPQStoreManagerExecutorContext exeCtx = (TPQStoreManagerExecutorContext)queryManager.getQueryExecutorContext(); TPQStoreManagerExecutorContext exeCtx = (TPQStoreManagerExecutorContext)queryManager.getQueryExecutorContext();

25
tpquery-store/src/test/java/net/forwardfire/tpquery/config/TPQueryStoreConfigBuilderTest.java
View file

@ -1,15 +1,16 @@
package net.forwardfire.tpquery.config; package net.forwardfire.tpquery.config;
import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.io.File; import java.io.File;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import org.junit.Test; import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.TPQFactory; import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.store.executor.TPQExecutorStatement; import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
public class TPQueryStoreConfigBuilderTest { public class TPQueryStoreConfigBuilderTest {
@ -38,9 +39,9 @@ public class TPQueryStoreConfigBuilderTest {
assertNotNull(manager.getQueryStore().getQueryNames()); assertNotNull(manager.getQueryStore().getQueryNames());
} }
@Test(expected=IllegalStateException.class) @Test
public void testBuildTreeInvalid() throws Exception { public void testBuildTreeInvalid() throws Exception {
TPQFactory assertThrows(IllegalStateException.class, () -> TPQFactory
.createManagerBuilder() .createManagerBuilder()
.createQuerySet("junit", "jar:mem:test") .createQuerySet("junit", "jar:mem:test")
.createQuery("test").parseStatement("select * from table $$inc:junit.inc.test$$ $$inc:junit.inc.inc.test$$").build() .createQuery("test").parseStatement("select * from table $$inc:junit.inc.test$$ $$inc:junit.inc.inc.test$$").build()
@ -56,7 +57,7 @@ public class TPQueryStoreConfigBuilderTest {
.buildTree() .buildTree()
// buildTree() should be here // buildTree() should be here
.build() .build()
.build(); .build());
} }
@Test @Test
@ -128,17 +129,17 @@ public class TPQueryStoreConfigBuilderTest {
assertNotNull(q.getName()); assertNotNull(q.getName());
} }
@Test(expected=TPQConfigException.class) @Test
public void testReadQuerySetFileNotFound() throws Exception { public void testReadQuerySetFileNotFound() throws Exception {
TPQFactory.createManagerBuilder() assertThrows(TPQConfigException.class, () -> TPQFactory.createManagerBuilder()
.readQuerySet(new File("./src/test/resources/net/forwardfire/tpquery/test-query.not-found")) .readQuerySet(new File("./src/test/resources/net/forwardfire/tpquery/test-query.not-found"))
.build(); .build());
} }
@Test(expected=TPQConfigException.class) @Test
public void testReadQuerySetInvalidContext() throws Exception { public void testReadQuerySetInvalidContext() throws Exception {
TPQFactory.createManagerBuilder() assertThrows(TPQConfigException.class, () -> TPQFactory.createManagerBuilder()
.readQuerySet(new File("./src/test/resources/net/forwardfire/tpquery/test-query-invalid.xml")) .readQuerySet(new File("./src/test/resources/net/forwardfire/tpquery/test-query-invalid.xml"))
.build(); .build());
} }
} }

116
tpquery-store/src/test/java/net/forwardfire/tpquery/config/TPQueryStoreConfigTest.java
View file

@ -1,15 +1,15 @@
package net.forwardfire.tpquery.config; package net.forwardfire.tpquery.config;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.Test; import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.TPQFactory; import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.config.TPQConfig; import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.statement.language.TPQStatementLanguageSql; import net.forwardfire.tpquery.statement.language.TPQStatementLanguageSql;
import net.forwardfire.tpquery.statement.parameter.TPQStatementParameterValue; import net.forwardfire.tpquery.statement.parameter.TPQStatementParameterValue;
import net.forwardfire.tpquery.store.executor.TPQExecutorStatement; import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
@ -40,32 +40,40 @@ public class TPQueryStoreConfigTest {
// --------- // ---------
@Test(expected=IllegalArgumentException.class) @Test
public void testTemplateTypeAdd() throws Exception { public void testTemplateTypeAdd() throws Exception {
TPQConfig c = TPQFactory.createConfig(); assertThrows(IllegalArgumentException.class, () -> {
c.addStatementParameter(new TPQStatementParameterValue(TPQFactory.StatementParameter.VALUE)); TPQConfig c = TPQFactory.createConfig();
c.addStatementParameter(new TPQStatementParameterValue(TPQFactory.StatementParameter.VALUE));
});
} }
@Test(expected=NullPointerException.class) @Test
public void testTemplateTypeRemove() throws Exception { public void testTemplateTypeRemove() throws Exception {
TPQConfig c = TPQFactory.createConfig(); assertThrows(NullPointerException.class, () -> {
c.removeStatementParameter(TPQFactory.StatementParameter.VALUE); TPQConfig c = TPQFactory.createConfig();
c.removeStatementParameter(TPQFactory.StatementParameter.VALUE); c.removeStatementParameter(TPQFactory.StatementParameter.VALUE);
c.removeStatementParameter(TPQFactory.StatementParameter.VALUE);
});
} }
// --------- // ---------
@Test(expected=IllegalArgumentException.class) @Test
public void testLanguageTypeAdd() throws Exception { public void testLanguageTypeAdd() throws Exception {
TPQConfig c = TPQFactory.createConfig(); assertThrows(IllegalArgumentException.class, () -> {
c.addStatementLanguage(new TPQStatementLanguageSql(TPQFactory.StatementLanguage.SQL)); TPQConfig c = TPQFactory.createConfig();
c.addStatementLanguage(new TPQStatementLanguageSql(TPQFactory.StatementLanguage.SQL));
});
} }
@Test(expected=NullPointerException.class) @Test
public void testLanguageTypeRemove() throws Exception { public void testLanguageTypeRemove() throws Exception {
TPQConfig c = TPQFactory.createConfig(); assertThrows(NullPointerException.class, () -> {
c.removeStatementLanguage(TPQFactory.StatementLanguage.SQL); TPQConfig c = TPQFactory.createConfig();
c.removeStatementLanguage(TPQFactory.StatementLanguage.SQL); c.removeStatementLanguage(TPQFactory.StatementLanguage.SQL);
c.removeStatementLanguage(TPQFactory.StatementLanguage.SQL);
});
} }
// --------- // ---------
@ -82,23 +90,29 @@ public class TPQueryStoreConfigTest {
c.addValueType(this.getClass().getName()); c.addValueType(this.getClass().getName());
} }
@Test(expected=IllegalArgumentException.class) @Test
public void testAddValueTypeClassNameError() throws Exception { public void testAddValueTypeClassNameError() throws Exception {
TPQConfig c = TPQFactory.createConfig(); assertThrows(IllegalArgumentException.class, () -> {
c.addValueType("net.foo.bar.NoneExcistingClassName"); TPQConfig c = TPQFactory.createConfig();
c.addValueType("net.foo.bar.NoneExcistingClassName");
});
} }
@Test(expected=IllegalArgumentException.class) @Test
public void testValueTypeAliasAdd() throws Exception { public void testValueTypeAliasAdd() throws Exception {
TPQConfig c = TPQFactory.createConfig(); assertThrows(IllegalArgumentException.class, () -> {
c.addValueTypeAlias("key", "v0"); TPQConfig c = TPQFactory.createConfig();
c.addValueTypeAlias("key", "v1"); c.addValueTypeAlias("key", "v0");
c.addValueTypeAlias("key", "v1");
});
} }
@Test(expected=NullPointerException.class) @Test
public void testValueTypeAliasRemoveIllegalKey() throws Exception { public void testValueTypeAliasRemoveIllegalKey() throws Exception {
TPQConfig c = TPQFactory.createConfig(); assertThrows(NullPointerException.class, () -> {
c.removeValueTypeAlias("unknown-key"); TPQConfig c = TPQFactory.createConfig();
c.removeValueTypeAlias("unknown-key");
});
} }
@Test() @Test()
@ -115,16 +129,20 @@ public class TPQueryStoreConfigTest {
// --------- // ---------
@Test(expected=NullPointerException.class) @Test
public void testQuerySetRemoveIllegalKey() throws Exception { public void testQuerySetRemoveIllegalKey() throws Exception {
TPQConfig c = TPQFactory.createConfig(); assertThrows(NullPointerException.class, () -> {
c.removeQuerySet("unknown-key"); TPQConfig c = TPQFactory.createConfig();
c.removeQuerySet("unknown-key");
});
} }
@Test(expected=NullPointerException.class) @Test
public void testQuerySetRemoveNull() throws Exception { public void testQuerySetRemoveNull() throws Exception {
TPQConfig c = TPQFactory.createConfig(); assertThrows(NullPointerException.class, () -> {
c.removeQuerySet(null); TPQConfig c = TPQFactory.createConfig();
c.removeQuerySet(null);
});
} }
@Test() @Test()
@ -204,19 +222,21 @@ public class TPQueryStoreConfigTest {
assertNotNull(q.getName()); assertNotNull(q.getName());
} }
@Test(expected=TPQConfigException.class) @Test
public void testWrongClassParameterType() throws Exception { public void testWrongClassParameterType() throws Exception {
TPQManager manager = TPQFactory assertThrows(TPQConfigException.class, () -> {
.createManagerBuilder() TPQManager manager = TPQFactory
.createQuerySet("junit", "jar:mem:test") .createManagerBuilder()
.setLanguage("SQL") .createQuerySet("junit", "jar:mem:test")
.createQuery("test") .setLanguage("SQL")
.parseStatement("select * from table where a=$$a$$") .createQuery("test")
.createQueryParameter("a", "java.lang.StringFooBar").build() .parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", "java.lang.StringFooBar").build()
.build()
.build() .build()
.build() .build();
.build(); assertNotNull(manager);
assertNotNull(manager); });
} }
@Test @Test

173
tpquery-store/src/test/java/net/forwardfire/tpquery/config/TPQueryStoreConfigValidatorTest.java
View file

@ -1,46 +1,33 @@
package net.forwardfire.tpquery.config; package net.forwardfire.tpquery.config;
import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.Test; import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.TPQFactory; import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.config.validate.TPQConfigValidator; import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.config.validate.TPQConfigValidatorCheck;
import net.forwardfire.tpquery.config.validate.TPQCheckDescriptionNotBlank; import net.forwardfire.tpquery.config.validate.TPQCheckDescriptionNotBlank;
import net.forwardfire.tpquery.config.validate.TPQCheckNamePattern; import net.forwardfire.tpquery.config.validate.TPQCheckNamePattern;
import net.forwardfire.tpquery.config.validate.TPQCheckParameterDefaultValueNotBlank; import net.forwardfire.tpquery.config.validate.TPQCheckParameterDefaultValueNotBlank;
import net.forwardfire.tpquery.config.validate.TPQCheckParameterNamePattern; import net.forwardfire.tpquery.config.validate.TPQCheckParameterNamePattern;
import net.forwardfire.tpquery.config.validate.TPQCheckParameterTypePattern; import net.forwardfire.tpquery.config.validate.TPQCheckParameterTypePattern;
import net.forwardfire.tpquery.config.validate.TPQCheckParameterValueTypePattern; import net.forwardfire.tpquery.config.validate.TPQCheckParameterValueTypePattern;
import net.forwardfire.tpquery.config.validate.TPQConfigValidator;
import net.forwardfire.tpquery.config.validate.TPQConfigValidatorCheck;
import net.forwardfire.tpquery.model.TPQuery; import net.forwardfire.tpquery.model.TPQuery;
public class TPQueryStoreConfigValidatorTest { public class TPQueryStoreConfigValidatorTest {
@Test() @Test()
public void testPatternValidators() throws Exception { public void testPatternValidators() throws Exception {
TPQConfig config = TPQFactory TPQConfig config = TPQFactory.createConfigBuilder().createQuerySet("junit", "jar:mem:test")
.createConfigBuilder() .createQuery("testCAPS")
.createQuerySet("junit", "jar:mem:test") .parseStatement("select * from table $$inc:junit.inc.test$$ $$inc:junit.inc.inc.test$$").build()
.createQuery("testCAPS").parseStatement("select * from table $$inc:junit.inc.test$$ $$inc:junit.inc.inc.test$$").build() .createQuerySetTree("inc").setTemplate(true).createQuery("test").parseStatement("where a=$$a$$ ")
.createQuerySetTree("inc") .createQueryParameter("a", Integer.class).setDefaultValue("1").build().build().createQuerySet("inc")
.setTemplate(true) .createQuery("test").parseStatement("AND 2=2").build().build().buildTree().build().build();
.createQuery("test")
.parseStatement("where a=$$a$$ ")
.createQueryParameter("a", Integer.class)
.setDefaultValue("1")
.build()
.build()
.createQuerySet("inc")
.createQuery("test")
.parseStatement("AND 2=2")
.build()
.build()
.buildTree()
.build()
.build();
config.addConfigValidator(".*", new TPQCheckNamePattern(".*")); config.addConfigValidator(".*", new TPQCheckNamePattern(".*"));
config.addConfigValidator(".*", new TPQCheckParameterNamePattern(".*")); config.addConfigValidator(".*", new TPQCheckParameterNamePattern(".*"));
config.addConfigValidator(".*", new TPQCheckParameterTypePattern(".*")); config.addConfigValidator(".*", new TPQCheckParameterTypePattern(".*"));
@ -53,78 +40,84 @@ public class TPQueryStoreConfigValidatorTest {
TPQManager manager = TPQFactory.createManager(config); TPQManager manager = TPQFactory.createManager(config);
assertNotNull(manager); assertNotNull(manager);
} }
@Test(expected=IllegalArgumentException.class) @Test
public void testDescriptionNotBlank() throws Exception { public void testDescriptionNotBlank() throws Exception {
TPQConfig config = TPQFactory assertThrows(IllegalArgumentException.class, () -> {
.createConfigBuilder() TPQConfig config = TPQFactory
.createQuerySet("junit", "jar:mem:test") .createConfigBuilder()
.createQuery("test-oke") .createQuerySet("junit", "jar:mem:test")
.setDescription("foobar") .createQuery("test-oke")
.parseStatement("select * from table") .setDescription("foobar")
.parseStatement("select * from table")
.build()
.createQuery("test-fail")
.setDescription("")
.parseStatement("select * from table")
.build()
.build() .build()
.createQuery("test-fail") .build();
.setDescription("")
.parseStatement("select * from table") TPQConfigValidator t = config.addConfigValidator("junit.test", new TPQCheckDescriptionNotBlank());
.build() config.removeConfigValidator(t);
.build()
.build(); config.addConfigValidator(".*", new TPQCheckDescriptionNotBlank());
TPQManager manager = TPQFactory.createManager(config);
TPQConfigValidator t = config.addConfigValidator("junit.test", new TPQCheckDescriptionNotBlank()); assertNotNull(manager);
config.removeConfigValidator(t); });
config.addConfigValidator(".*", new TPQCheckDescriptionNotBlank());
TPQManager manager = TPQFactory.createManager(config);
assertNotNull(manager);
} }
@Test(expected=IllegalArgumentException.class) @Test
public void testParameterDefaultValueNotBlank() throws Exception { public void testParameterDefaultValueNotBlank() throws Exception {
TPQConfig config = TPQFactory assertThrows(IllegalArgumentException.class, () -> {
.createConfigBuilder() TPQConfig config = TPQFactory
.createQuerySet("junit", "jar:mem:test") .createConfigBuilder()
.createQuery("test-oke") .createQuerySet("junit", "jar:mem:test")
.parseStatement("select * from table where a=$$a$$") .createQuery("test-oke")
.createQueryParameter("a", TPQFactory.ParameterValueType.INTEGER) .parseStatement("select * from table where a=$$a$$")
.setDefaultValue("1") .createQueryParameter("a", TPQFactory.ParameterValueType.INTEGER)
.setDefaultValue("1")
.build()
.build()
.createQuery("test-fail")
.setDescription("")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.INTEGER)
.setDefaultValue("")
.build()
.build() .build()
.build() .build()
.createQuery("test-fail") .build();
.setDescription("") config.addConfigValidator(".*", new TPQCheckParameterDefaultValueNotBlank());
.parseStatement("select * from table where a=$$a$$") TPQManager manager = TPQFactory.createManager(config);
.createQueryParameter("a", TPQFactory.ParameterValueType.INTEGER) assertNotNull(manager);
.setDefaultValue("") });
.build()
.build()
.build()
.build();
config.addConfigValidator(".*", new TPQCheckParameterDefaultValueNotBlank());
TPQManager manager = TPQFactory.createManager(config);
assertNotNull(manager);
} }
@Test(expected=IllegalArgumentException.class) @Test
public void testDisableRAWExample() throws Exception { public void testDisableRAWExample() throws Exception {
TPQConfig config = TPQFactory assertThrows(IllegalArgumentException.class, () -> {
.createConfigBuilder() TPQConfig config = TPQFactory
.createQuerySet("junit", "jar:mem:test") .createConfigBuilder()
.createQuery("test-oke") .createQuerySet("junit", "jar:mem:test")
.parseStatement("select * from table where a=$$a$$") .createQuery("test-oke")
.createQueryParameter("a", TPQFactory.ParameterValueType.INTEGER) .parseStatement("select * from table where a=$$a$$")
.setType(TPQFactory.StatementParameter.RAW) .createQueryParameter("a", TPQFactory.ParameterValueType.INTEGER)
.setType(TPQFactory.StatementParameter.RAW)
.build()
.build()
.createQuery("test-fail")
.setDescription("")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.INTEGER)
.setType(TPQFactory.StatementParameter.RAW)
.build()
.build() .build()
.build() .build()
.createQuery("test-fail") .build();
.setDescription("") config.addConfigValidator("junit.test-f.*", new TPQCheckParameterTypePattern("!RAW"));
.parseStatement("select * from table where a=$$a$$") TPQManager manager = TPQFactory.createManager(config);
.createQueryParameter("a", TPQFactory.ParameterValueType.INTEGER) assertNotNull(manager);
.setType(TPQFactory.StatementParameter.RAW) });
.build()
.build()
.build()
.build();
config.addConfigValidator("junit.test-f.*", new TPQCheckParameterTypePattern("!RAW"));
TPQManager manager = TPQFactory.createManager(config);
assertNotNull(manager);
} }
} }

4
tpquery-store/src/test/java/net/forwardfire/tpquery/executor/TQueryExecutorTest.java
View file

@ -5,12 +5,12 @@ import java.util.Collections;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.store.executor.AbstractTPQExecutor; import net.forwardfire.tpquery.store.executor.AbstractTPQExecutor;
import net.forwardfire.tpquery.store.executor.TPQExecutorContext; import net.forwardfire.tpquery.store.executor.TPQExecutorContext;
import net.forwardfire.tpquery.store.executor.TPQExecutorStatement; import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
import org.junit.Test;
public class TQueryExecutorTest { public class TQueryExecutorTest {
class TestExecutorConnection { class TestExecutorConnection {

18
tpquery-store/src/test/java/net/forwardfire/tpquery/model/ModelXMLMarshallerTest.java
View file

@ -1,8 +1,9 @@
package net.forwardfire.tpquery.model; package net.forwardfire.tpquery.model;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.io.ByteArrayInputStream; import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream; import java.io.ByteArrayOutputStream;
@ -12,15 +13,10 @@ import java.util.Map;
import javax.xml.bind.annotation.XmlElement; import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper; import javax.xml.bind.annotation.XmlElementWrapper;
import org.junit.Test; import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQFactory; import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.TPQManager; import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.model.TPQuery;
import net.forwardfire.tpquery.model.TPQueryParameter;
import net.forwardfire.tpquery.model.TPQuerySet;
import net.forwardfire.tpquery.model.ModelXMLInfoSet;
import net.forwardfire.tpquery.model.ModelXMLMarshaller;
import net.forwardfire.tpquery.statement.TPQStatementPartInclude; import net.forwardfire.tpquery.statement.TPQStatementPartInclude;
import net.forwardfire.tpquery.statement.TPQStatementPartParameter; import net.forwardfire.tpquery.statement.TPQStatementPartParameter;
import net.forwardfire.tpquery.statement.TPQStatementPartText; import net.forwardfire.tpquery.statement.TPQStatementPartText;
@ -117,9 +113,9 @@ public class ModelXMLMarshallerTest {
assertEquals("false",q.getQueryHints().get("junit")); assertEquals("false",q.getQueryHints().get("junit"));
} }
@Test(expected=IllegalArgumentException.class) @Test
public void testContextException() throws Exception { public void testContextException() throws Exception {
new ModelXMLMarshaller(JaxbContextError.class); assertThrows(IllegalArgumentException.class, () -> new ModelXMLMarshaller(JaxbContextError.class));
} }
private static class JaxbContextError { private static class JaxbContextError {

6
tpquery-store/src/test/java/net/forwardfire/tpquery/model/TPQueryPropertyTest.java
View file

@ -1,14 +1,14 @@
package net.forwardfire.tpquery.model; package net.forwardfire.tpquery.model;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import org.junit.Test; import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.TPQFactory; import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.store.executor.TPQExecutorStatement; import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
public class TPQueryPropertyTest { public class TPQueryPropertyTest {

7
tpquery-store/src/test/java/net/forwardfire/tpquery/statement/TPQueryStatementMarshallerAdapterTest.java
View file

@ -1,10 +1,9 @@
package net.forwardfire.tpquery.statement; package net.forwardfire.tpquery.statement;
import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
import net.forwardfire.tpquery.statement.TPQStatementMarshallerAdapter;
import org.junit.Test; import org.junit.jupiter.api.Test;
public class TPQueryStatementMarshallerAdapterTest { public class TPQueryStatementMarshallerAdapterTest {

70
tpquery-store/src/test/java/net/forwardfire/tpquery/statement/TPQueryStatementMarshallerTest.java
View file

@ -1,29 +1,26 @@
package net.forwardfire.tpquery.statement; package net.forwardfire.tpquery.statement;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import net.forwardfire.tpquery.statement.TPQStatement; import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.statement.TPQStatementMarshaller;
import net.forwardfire.tpquery.statement.TPQStatementPartInclude;
import net.forwardfire.tpquery.statement.TPQStatementPartParameter;
import net.forwardfire.tpquery.statement.TPQStatementPartText;
import org.junit.Test;
public class TPQueryStatementMarshallerTest { public class TPQueryStatementMarshallerTest {
@Test(expected=NullPointerException.class) @Test
public void testParseNull() throws Exception { public void testParseNull() throws Exception {
TPQStatementMarshaller parser = new TPQStatementMarshaller(); assertThrows(NullPointerException.class, () -> {
parser.unmarshal(null); TPQStatementMarshaller parser = new TPQStatementMarshaller();
parser.unmarshal(null);
});
} }
@Test() @Test()
public void testParseEmpty() throws Exception { public void testParseEmpty() throws Exception {
TPQStatementMarshaller parser = new TPQStatementMarshaller(); TPQStatementMarshaller parser = new TPQStatementMarshaller();
@ -31,58 +28,58 @@ public class TPQueryStatementMarshallerTest {
assertNotNull(result); assertNotNull(result);
assertTrue(result.isEmpty()); assertTrue(result.isEmpty());
} }
@Test() @Test()
public void testParseText() throws Exception { public void testParseText() throws Exception {
TPQStatementMarshaller parser = new TPQStatementMarshaller(); TPQStatementMarshaller parser = new TPQStatementMarshaller();
List<TPQStatement> result = parser.unmarshal("foobar"); List<TPQStatement> result = parser.unmarshal("foobar");
assertNotNull(result); assertNotNull(result);
assertFalse(result.isEmpty()); assertFalse(result.isEmpty());
assertTrue(result.size()==1); assertTrue(result.size() == 1);
assertNotNull(result.get(0)); assertNotNull(result.get(0));
assertTrue(result.get(0) instanceof TPQStatementPartText); assertTrue(result.get(0) instanceof TPQStatementPartText);
} }
@Test() @Test()
public void testParseTemplate() throws Exception { public void testParseTemplate() throws Exception {
TPQStatementMarshaller parser = new TPQStatementMarshaller(); TPQStatementMarshaller parser = new TPQStatementMarshaller();
List<TPQStatement> result = parser.unmarshal("$$foobar$$"); List<TPQStatement> result = parser.unmarshal("$$foobar$$");
assertNotNull(result); assertNotNull(result);
assertFalse(result.isEmpty()); assertFalse(result.isEmpty());
assertTrue(result.size()==1); assertTrue(result.size() == 1);
assertNotNull(result.get(0)); assertNotNull(result.get(0));
assertTrue(result.get(0) instanceof TPQStatementPartParameter); assertTrue(result.get(0) instanceof TPQStatementPartParameter);
} }
@Test(expected=IllegalArgumentException.class) @Test
public void testParseTemplateNoEnd() throws Exception { public void testParseTemplateNoEnd() throws Exception {
new TPQStatementMarshaller().unmarshal("$$foobar"); assertThrows(IllegalArgumentException.class, () -> new TPQStatementMarshaller().unmarshal("$$foobar"));
} }
@Test(expected=IllegalArgumentException.class) @Test
public void testParseTemplateEmpty() throws Exception { public void testParseTemplateEmpty() throws Exception {
new TPQStatementMarshaller().unmarshal("$$$$"); assertThrows(IllegalArgumentException.class, () -> new TPQStatementMarshaller().unmarshal("$$$$"));
} }
@Test() @Test()
public void testParseTemplateInclude() throws Exception { public void testParseTemplateInclude() throws Exception {
TPQStatementMarshaller parser = new TPQStatementMarshaller(); TPQStatementMarshaller parser = new TPQStatementMarshaller();
List<TPQStatement> result = parser.unmarshal("$$inc:foobar$$"); List<TPQStatement> result = parser.unmarshal("$$inc:foobar$$");
assertNotNull(result); assertNotNull(result);
assertFalse(result.isEmpty()); assertFalse(result.isEmpty());
assertTrue(result.size()==1); assertTrue(result.size() == 1);
assertNotNull(result.get(0)); assertNotNull(result.get(0));
assertTrue(result.get(0) instanceof TPQStatementPartInclude); assertTrue(result.get(0) instanceof TPQStatementPartInclude);
} }
@Test
@Test(expected=NullPointerException.class)
public void testPrintNull() throws Exception { public void testPrintNull() throws Exception {
TPQStatementMarshaller parser = new TPQStatementMarshaller(); assertThrows(NullPointerException.class, () -> {
parser.marshal(null); TPQStatementMarshaller parser = new TPQStatementMarshaller();
parser.marshal(null);
});
} }
@Test() @Test()
public void testPrintEmpty() throws Exception { public void testPrintEmpty() throws Exception {
List<TPQStatement> data = new ArrayList<>(); List<TPQStatement> data = new ArrayList<>();
@ -91,7 +88,7 @@ public class TPQueryStatementMarshallerTest {
assertNotNull(result); assertNotNull(result);
assertTrue(result.isEmpty()); assertTrue(result.isEmpty());
} }
@Test() @Test()
public void testPrintText() throws Exception { public void testPrintText() throws Exception {
List<TPQStatement> data = new ArrayList<>(); List<TPQStatement> data = new ArrayList<>();
@ -102,7 +99,6 @@ public class TPQueryStatementMarshallerTest {
String result = parser.marshal(data); String result = parser.marshal(data);
assertNotNull(result); assertNotNull(result);
assertFalse(result.isEmpty()); assertFalse(result.isEmpty());
assertEquals("p0p1p2",result); assertEquals("p0p1p2", result);
} }
} }

81
tpquery-store/src/test/java/net/forwardfire/tpquery/statement/TPQueryStatementPartIncludeTest.java
View file

@ -1,61 +1,64 @@
package net.forwardfire.tpquery.statement; package net.forwardfire.tpquery.statement;
import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertThrows;
import net.forwardfire.tpquery.TPQManager; import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQFactory; import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.store.executor.TPQExecutorStatement; import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
import org.junit.Test;
public class TPQueryStatementPartIncludeTest { public class TPQueryStatementPartIncludeTest {
@Test(expected=NullPointerException.class) @Test
public void testFailInclude() throws Exception { public void testFailInclude() throws Exception {
TPQFactory.createManagerBuilder() assertThrows(NullPointerException.class, () -> TPQFactory.createManagerBuilder()
.createQuerySet("junit", "jar:junit:mem:test") .createQuerySet("junit", "jar:junit:mem:test")
.setLanguage(TPQFactory.StatementLanguage.SQL) .setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("include-missing") .createQuery("include-missing")
.appendText("select * from foobar") .appendText("select * from foobar")
.appendInclude("include-missing-query") .appendInclude("include-missing-query")
.build() .build()
.build() .build()
.build(); .build());
} }
@Test @Test
public void testIncludeMultple() throws Exception { public void testIncludeMultple() throws Exception {
TPQManager store = TPQFactory TPQManager store = TPQFactory.createManagerBuilder()
.createManagerBuilder() .readQuerySet("net/forwardfire/tpquery/test-include-multiple.xml").build();
.readQuerySet("net/forwardfire/tpquery/test-include-multiple.xml")
.build();
TPQExecutorStatement q = store.getQueryExecutorContext().prepareQuery("test.multipleInclude", null); TPQExecutorStatement q = store.getQueryExecutorContext().prepareQuery("test.multipleInclude", null);
assertNotNull(q.getName()); assertNotNull(q.getName());
assertTrue(q.getStatement().contains("price_list")); assertTrue(q.getStatement().contains("price_list"));
assertTrue(q.getStatement().contains("key='stats_correction') AS mrt")); assertTrue(q.getStatement().contains("key='stats_correction') AS mrt"));
} }
@Test(expected=IllegalArgumentException.class) @Test
public void testIncludeLoop() throws Exception { public void testIncludeLoop() throws Exception {
TPQManager store = TPQFactory assertThrows(IllegalArgumentException.class, () -> {
.createManagerBuilder() TPQManager store = TPQFactory
.readQuerySet("net/forwardfire/tpquery/test-include-loop.xml") .createManagerBuilder()
.build(); .readQuerySet("net/forwardfire/tpquery/test-include-loop.xml")
store.getQueryExecutorContext().prepareQuery("test.loopInclude", null); .build();
store.getQueryExecutorContext().prepareQuery("test.loopInclude", null);
});
} }
@Test(expected=IllegalArgumentException.class) @Test
public void testQueryChecked() throws Exception { public void testQueryChecked() throws Exception {
TPQFactory.createManagerBuilder() assertThrows(IllegalArgumentException.class,
() -> TPQFactory.createManagerBuilder()
.createQuerySet("junit", "jar:junit:mem:test") .createQuerySet("junit", "jar:junit:mem:test")
.setLanguage(TPQFactory.StatementLanguage.SQL) .setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("test") .createQuery("test")
.appendText("select * from foobar") .appendText("select * from foobar")
.build() .build()
.createQuery("test-fail") .createQuery("test-fail")
.appendInclude("junit.test") .appendInclude("junit.test")
.build() .build()
.build() .build()
.build(); .build());
} }
} }

9
tpquery-store/src/test/java/net/forwardfire/tpquery/statement/TPQueryStatementWriterTest.java
View file

@ -1,21 +1,20 @@
package net.forwardfire.tpquery.statement; package net.forwardfire.tpquery.statement;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQFactory; import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.TPQManager; import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.config.TPQConfig; import net.forwardfire.tpquery.config.TPQConfig;
import net.forwardfire.tpquery.statement.TPQStatementWriter;
import net.forwardfire.tpquery.statement.language.AbstractTPQStatementLanguage; import net.forwardfire.tpquery.statement.language.AbstractTPQStatementLanguage;
import net.forwardfire.tpquery.statement.language.TPQStatementLanguageSql; import net.forwardfire.tpquery.statement.language.TPQStatementLanguageSql;
import net.forwardfire.tpquery.store.executor.TPQExecutorStatement; import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
import org.junit.Test;
public class TPQueryStatementWriterTest { public class TPQueryStatementWriterTest {
private TPQStatementWriter createWriter() { private TPQStatementWriter createWriter() {

13
tpquery-store/src/test/java/net/forwardfire/tpquery/statement/language/TPQStatementLanguageHqlTest.java
View file

@ -1,20 +1,19 @@
package net.forwardfire.tpquery.statement.language; package net.forwardfire.tpquery.statement.language;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQFactory; import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.statement.TPQStatementWriter; import net.forwardfire.tpquery.statement.TPQStatementWriter;
import net.forwardfire.tpquery.statement.language.TPQStatementLanguageHql;
import net.forwardfire.tpquery.store.TPQueryStoreStatementMapper; import net.forwardfire.tpquery.store.TPQueryStoreStatementMapper;
import org.junit.Test;
public class TPQStatementLanguageHqlTest { public class TPQStatementLanguageHqlTest {
private TPQStatementWriter createWriter() { private TPQStatementWriter createWriter() {

7
tpquery-store/src/test/java/net/forwardfire/tpquery/statement/language/TPQStatementLanguageSqlTest.java
View file

@ -1,16 +1,15 @@
package net.forwardfire.tpquery.statement.language; package net.forwardfire.tpquery.statement.language;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import org.junit.Test; import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQFactory; import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.statement.TPQStatementWriter; import net.forwardfire.tpquery.statement.TPQStatementWriter;
import net.forwardfire.tpquery.statement.language.TPQStatementLanguageSql;
import net.forwardfire.tpquery.store.TPQueryStoreStatementMapper; import net.forwardfire.tpquery.store.TPQueryStoreStatementMapper;
public class TPQStatementLanguageSqlTest { public class TPQStatementLanguageSqlTest {

45
tpquery-store/src/test/java/net/forwardfire/tpquery/statement/parameter/TPQueryParameterDefaultValueTest.java
View file

@ -1,21 +1,22 @@
package net.forwardfire.tpquery.statement.parameter; package net.forwardfire.tpquery.statement.parameter;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import net.forwardfire.tpquery.TPQManager; import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQFactory; import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.config.TPQConfig; import net.forwardfire.tpquery.config.TPQConfig;
import net.forwardfire.tpquery.store.executor.TPQExecutorStatement; import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
import org.junit.Test;
public class TPQueryParameterDefaultValueTest { public class TPQueryParameterDefaultValueTest {
@Test() @Test
public void testRawString() throws Exception { public void testRawString() throws Exception {
TPQConfig config = TPQFactory TPQConfig config = TPQFactory
.createConfigBuilder() .createConfigBuilder()
@ -44,7 +45,7 @@ public class TPQueryParameterDefaultValueTest {
.setLanguage(TPQFactory.StatementLanguage.SQL) .setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("test") .createQuery("test")
.parseStatement("select * from foobar where a=$$a$$") .parseStatement("select * from foobar where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.LONG) .createQueryParameter("a", TPQFactory.ParameterValueType.DOUBLE)
.setDefaultValue("js:epoch()") .setDefaultValue("js:epoch()")
.build() .build()
.build() .build()
@ -54,7 +55,7 @@ public class TPQueryParameterDefaultValueTest {
TPQExecutorStatement prepared = store.getQueryExecutorContext().prepareQuery("junit.test", para); TPQExecutorStatement prepared = store.getQueryExecutorContext().prepareQuery("junit.test", para);
assertTrue(!prepared.getParameters().isEmpty()); assertTrue(!prepared.getParameters().isEmpty());
assertTrue(prepared.getParameters().get(0) != null); assertTrue(prepared.getParameters().get(0) != null);
assertTrue(prepared.getParameters().get(0) instanceof Long); assertTrue(prepared.getParameters().get(0) instanceof Double);
} }
@Test() @Test()
@ -121,20 +122,22 @@ public class TPQueryParameterDefaultValueTest {
assertTrue(prepared.getParameters().get(0) instanceof java.lang.Integer); assertTrue(prepared.getParameters().get(0) instanceof java.lang.Integer);
} }
@Test(expected=Exception.class) @Test
public void testCreateObjectConstructorWrongClass() throws Exception { public void testCreateObjectConstructorWrongClass() throws Exception {
TPQManager store = TPQFactory assertThrows(Exception.class, () -> {
.createManagerBuilder() TPQManager store = TPQFactory
.createQuerySet("junit", "jar:junit:mem") .createManagerBuilder()
.setLanguage(TPQFactory.StatementLanguage.SQL) .createQuerySet("junit", "jar:junit:mem")
.createQuery("test") .setLanguage(TPQFactory.StatementLanguage.SQL)
.parseStatement("select * from foobar where a=$$a$$") .createQuery("test")
.createQueryParameter("a", TPQFactory.ParameterValueType.SQL_TIME) .parseStatement("select * from foobar where a=$$a$$")
.setDefaultValue("js:createObject(java.lang.StringNotFound,'foobar')") .createQueryParameter("a", TPQFactory.ParameterValueType.SQL_TIME)
.setDefaultValue("js:createObject(java.lang.StringNotFound,'foobar')")
.build()
.build() .build()
.build() .build()
.build() .build();
.build(); store.getQueryExecutorContext().prepareQuery("junit.test", new HashMap<String,Object>());
store.getQueryExecutorContext().prepareQuery("junit.test", new HashMap<String,Object>()); });
} }
} }

121
tpquery-store/src/test/java/net/forwardfire/tpquery/statement/parameter/TPQueryParameterTypeListTest.java
View file

@ -1,6 +1,7 @@
package net.forwardfire.tpquery.statement.parameter; package net.forwardfire.tpquery.statement.parameter;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
@ -8,10 +9,10 @@ import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import org.junit.Test; import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.TPQFactory; import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.model.TPQuery; import net.forwardfire.tpquery.model.TPQuery;
import net.forwardfire.tpquery.model.TPQueryParameter; import net.forwardfire.tpquery.model.TPQueryParameter;
import net.forwardfire.tpquery.model.TPQuerySet; import net.forwardfire.tpquery.model.TPQuerySet;
@ -20,67 +21,73 @@ import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
public class TPQueryParameterTypeListTest { public class TPQueryParameterTypeListTest {
@Test(expected=NullPointerException.class) @Test
public void testNullValue() throws Exception { public void testNullValue() throws Exception {
TPQuery q = new TPQuery(); assertThrows(NullPointerException.class, () -> {
q.setName("test"); TPQuery q = new TPQuery();
q.addQueryPart(new TPQStatementPartParameter("param")); q.setName("test");
TPQueryParameter qp = new TPQueryParameter(); q.addQueryPart(new TPQStatementPartParameter("param"));
qp.setType(TPQFactory.StatementParameter.LIST); TPQueryParameter qp = new TPQueryParameter();
qp.setName("param"); qp.setType(TPQFactory.StatementParameter.LIST);
//qp.setDefaultValue("1,2,3"); qp.setName("param");
qp.setValueType(TPQFactory.ParameterValueType.INTEGER); //qp.setDefaultValue("1,2,3");
q.addQueryParameter(qp); qp.setValueType(TPQFactory.ParameterValueType.INTEGER);
q.addQueryParameter(qp);
TPQuerySet qs = new TPQuerySet("junit");
qs.setLanguage(TPQFactory.StatementLanguage.SQL); TPQuerySet qs = new TPQuerySet("junit");
qs.addQuery(q); qs.setLanguage(TPQFactory.StatementLanguage.SQL);
TPQManager store = TPQFactory.createManagerBuilder().addQuerySet("jar:junit:test",qs).build(); qs.addQuery(q);
TPQManager store = TPQFactory.createManagerBuilder().addQuerySet("jar:junit:test",qs).build();
Map<String,Object> para = new HashMap<String,Object>();
store.getQueryExecutorContext().prepareQuery("junit.test", para); Map<String,Object> para = new HashMap<String,Object>();
store.getQueryExecutorContext().prepareQuery("junit.test", para);
});
} }
@Test(expected=IllegalArgumentException.class) @Test
public void testEmptyValue() throws Exception { public void testEmptyValue() throws Exception {
TPQuery q = new TPQuery(); assertThrows(IllegalArgumentException.class, () -> {
q.setName("test"); TPQuery q = new TPQuery();
q.addQueryPart(new TPQStatementPartParameter("param")); q.setName("test");
TPQueryParameter qp = new TPQueryParameter(); q.addQueryPart(new TPQStatementPartParameter("param"));
qp.setType(TPQFactory.StatementParameter.LIST); TPQueryParameter qp = new TPQueryParameter();
qp.setName("param"); qp.setType(TPQFactory.StatementParameter.LIST);
qp.setValueType(TPQFactory.ParameterValueType.INTEGER); qp.setName("param");
q.addQueryParameter(qp); qp.setValueType(TPQFactory.ParameterValueType.INTEGER);
q.addQueryParameter(qp);
TPQuerySet qs = new TPQuerySet("junit");
qs.setLanguage(TPQFactory.StatementLanguage.SQL); TPQuerySet qs = new TPQuerySet("junit");
qs.addQuery(q); qs.setLanguage(TPQFactory.StatementLanguage.SQL);
TPQManager store = TPQFactory.createManagerBuilder().addQuerySet("jar:junit:test",qs).build(); qs.addQuery(q);
TPQManager store = TPQFactory.createManagerBuilder().addQuerySet("jar:junit:test",qs).build();
Map<String,Object> para = new HashMap<String,Object>();
para.put("param", new ArrayList<String>()); Map<String,Object> para = new HashMap<String,Object>();
store.getQueryExecutorContext().prepareQuery("junit.test", para); para.put("param", new ArrayList<String>());
store.getQueryExecutorContext().prepareQuery("junit.test", para);
});
} }
@Test(expected=IllegalArgumentException.class) @Test
public void testWrongValue() throws Exception { public void testWrongValue() throws Exception {
TPQuery q = new TPQuery(); assertThrows(IllegalArgumentException.class, () -> {
q.setName("test"); TPQuery q = new TPQuery();
q.addQueryPart(new TPQStatementPartParameter("param")); q.setName("test");
TPQueryParameter qp = new TPQueryParameter(); q.addQueryPart(new TPQStatementPartParameter("param"));
qp.setType(TPQFactory.StatementParameter.LIST); TPQueryParameter qp = new TPQueryParameter();
qp.setName("param"); qp.setType(TPQFactory.StatementParameter.LIST);
qp.setValueType(TPQFactory.ParameterValueType.INTEGER); qp.setName("param");
q.addQueryParameter(qp); qp.setValueType(TPQFactory.ParameterValueType.INTEGER);
q.addQueryParameter(qp);
TPQuerySet qs = new TPQuerySet("junit");
qs.setLanguage(TPQFactory.StatementLanguage.SQL); TPQuerySet qs = new TPQuerySet("junit");
qs.addQuery(q); qs.setLanguage(TPQFactory.StatementLanguage.SQL);
TPQManager store = TPQFactory.createManagerBuilder().addQuerySet("jar:junit:test",qs).build(); qs.addQuery(q);
TPQManager store = TPQFactory.createManagerBuilder().addQuerySet("jar:junit:test",qs).build();
Map<String,Object> para = new HashMap<String,Object>();
para.put("param", new HashMap<String,String>()); Map<String,Object> para = new HashMap<String,Object>();
store.getQueryExecutorContext().prepareQuery("junit.test", para); para.put("param", new HashMap<String,String>());
store.getQueryExecutorContext().prepareQuery("junit.test", para);
});
} }
@Test() @Test()

14
tpquery-store/src/test/java/net/forwardfire/tpquery/statement/parameter/TPQueryParameterTypeRawTest.java
View file

@ -1,16 +1,16 @@
package net.forwardfire.tpquery.statement.parameter; package net.forwardfire.tpquery.statement.parameter;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import org.junit.Test; import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.TPQFactory; import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.model.TPQuery; import net.forwardfire.tpquery.model.TPQuery;
import net.forwardfire.tpquery.model.TPQueryParameter; import net.forwardfire.tpquery.model.TPQueryParameter;
import net.forwardfire.tpquery.model.TPQuerySet; import net.forwardfire.tpquery.model.TPQuerySet;
@ -19,7 +19,7 @@ import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
public class TPQueryParameterTypeRawTest { public class TPQueryParameterTypeRawTest {
@Test() @Test
public void testTypeRaw() throws Exception { public void testTypeRaw() throws Exception {
TPQuery q = new TPQuery(); TPQuery q = new TPQuery();
q.setName("test"); q.setName("test");
@ -49,7 +49,7 @@ public class TPQueryParameterTypeRawTest {
assertEquals(0,queryPreparedValue.getParameters().size()); assertEquals(0,queryPreparedValue.getParameters().size());
} }
@Test() @Test
public void testTypeRawNull() throws Exception { public void testTypeRawNull() throws Exception {
TPQManager store = TPQFactory.createManagerBuilder() TPQManager store = TPQFactory.createManagerBuilder()
.createQuerySet("junit", "jar:junit:mem:test") .createQuerySet("junit", "jar:junit:mem:test")

63
tpquery-store/src/test/java/net/forwardfire/tpquery/statement/parameter/TPQueryParameterTypeValueTest.java
View file

@ -1,14 +1,15 @@
package net.forwardfire.tpquery.statement.parameter; package net.forwardfire.tpquery.statement.parameter;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import org.junit.Test; import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.TPQFactory; import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.model.TPQuery; import net.forwardfire.tpquery.model.TPQuery;
import net.forwardfire.tpquery.model.TPQueryParameter; import net.forwardfire.tpquery.model.TPQueryParameter;
import net.forwardfire.tpquery.model.TPQuerySet; import net.forwardfire.tpquery.model.TPQuerySet;
@ -17,36 +18,40 @@ import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
public class TPQueryParameterTypeValueTest { public class TPQueryParameterTypeValueTest {
@Test(expected=NullPointerException.class) @Test
public void testMissingParameter() throws Exception { public void testMissingParameter() throws Exception {
TPQuery q = new TPQuery(); assertThrows(NullPointerException.class, () -> {
q.setName("test"); TPQuery q = new TPQuery();
q.addQueryPart(new TPQStatementPartParameter("missing-param")); q.setName("test");
q.addQueryPart(new TPQStatementPartParameter("missing-param"));
TPQuerySet qs = new TPQuerySet("junit");
qs.addQuery(q); TPQuerySet qs = new TPQuerySet("junit");
TPQManager store = TPQFactory.createManagerBuilder().addQuerySet("jar:junit:mem:testMissingParameter",qs).build(); qs.addQuery(q);
store.getQueryExecutorContext().prepareQuery("junit.test", null); TPQManager store = TPQFactory.createManagerBuilder().addQuerySet("jar:junit:mem:testMissingParameter",qs).build();
store.getQueryExecutorContext().prepareQuery("junit.test", null);
});
} }
@Test(expected=IllegalArgumentException.class) @Test
public void testTypeParamWrongType() throws Exception { public void testTypeParamWrongType() throws Exception {
TPQuery q = new TPQuery(); assertThrows(IllegalArgumentException.class, () -> {
q.setName("test"); TPQuery q = new TPQuery();
q.addQueryPart(new TPQStatementPartParameter("param")); q.setName("test");
TPQueryParameter qp = new TPQueryParameter(); q.addQueryPart(new TPQStatementPartParameter("param"));
qp.setType(TPQFactory.StatementParameter.VALUE); TPQueryParameter qp = new TPQueryParameter();
qp.setName("param"); qp.setType(TPQFactory.StatementParameter.VALUE);
qp.setValueType(TPQFactory.ParameterValueType.INTEGER); qp.setName("param");
q.addQueryParameter(qp); qp.setValueType(TPQFactory.ParameterValueType.INTEGER);
TPQuerySet qs = new TPQuerySet("junit"); q.addQueryParameter(qp);
qs.setLanguage(TPQFactory.StatementLanguage.SQL); TPQuerySet qs = new TPQuerySet("junit");
qs.addQuery(q); qs.setLanguage(TPQFactory.StatementLanguage.SQL);
TPQManager store = TPQFactory.createManagerBuilder().addQuerySet("jar:junit:mem:test",qs).build(); qs.addQuery(q);
TPQManager store = TPQFactory.createManagerBuilder().addQuerySet("jar:junit:mem:test",qs).build();
Map<String,Object> paraValue = new HashMap<String,Object>();
paraValue.put("param", "test"); Map<String,Object> paraValue = new HashMap<String,Object>();
store.getQueryExecutorContext().prepareQuery("junit.test", paraValue); paraValue.put("param", "test");
store.getQueryExecutorContext().prepareQuery("junit.test", paraValue);
});
} }
@Test() @Test()

16
tpquery-store/src/test/java/net/forwardfire/tpquery/store/TPQueryStoreTest.java
View file

@ -1,17 +1,17 @@
package net.forwardfire.tpquery.store; package net.forwardfire.tpquery.store;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Map; import java.util.Map;
import net.forwardfire.tpquery.TPQManager; import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.config.TPQConfig;
import org.junit.Test; import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.config.TPQConfig;
public class TPQueryStoreTest { public class TPQueryStoreTest {

365
tpquery-store/src/test/java/net/forwardfire/tpquery/store/manager/TPQStoreManagerStatementCacheTest.java
View file

@ -1,7 +1,8 @@
package net.forwardfire.tpquery.store.manager; package net.forwardfire.tpquery.store.manager;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.io.File; import java.io.File;
import java.io.FileInputStream; import java.io.FileInputStream;
@ -15,15 +16,15 @@ import java.util.HashMap;
import java.util.Map; import java.util.Map;
import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.Lock;
import net.forwardfire.tpquery.TPQManager; import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQFactory; import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.config.TPQConfig; import net.forwardfire.tpquery.config.TPQConfig;
import net.forwardfire.tpquery.statement.parameter.TPQStatementParameterListMapper; import net.forwardfire.tpquery.statement.parameter.TPQStatementParameterListMapper;
import net.forwardfire.tpquery.statement.parameter.TPQStatementParameterValueMapper; import net.forwardfire.tpquery.statement.parameter.TPQStatementParameterValueMapper;
import net.forwardfire.tpquery.store.TPQueryStoreStatement; import net.forwardfire.tpquery.store.TPQueryStoreStatement;
import org.junit.Test;
public class TPQStoreManagerStatementCacheTest { public class TPQStoreManagerStatementCacheTest {
private Lock createFailingLock(boolean lockOke) { private Lock createFailingLock(boolean lockOke) {
@ -40,140 +41,152 @@ public class TPQStoreManagerStatementCacheTest {
} }
@SuppressWarnings("serial") @SuppressWarnings("serial")
@Test(expected=IllegalStateException.class) @Test
public void testCacheFailPut() throws Exception { public void testCacheFailPut() throws Exception {
TPQConfig config = TPQFactory.createConfig(); assertThrows(IllegalStateException.class, () -> {
Map<String,TPQueryStoreStatement> cc = new HashMap<String,TPQueryStoreStatement>() { TPQConfig config = TPQFactory.createConfig();
@Override Map<String,TPQueryStoreStatement> cc = new HashMap<String,TPQueryStoreStatement>() {
public TPQueryStoreStatement put(String key,TPQueryStoreStatement value) { @Override
throw new IllegalStateException(); public TPQueryStoreStatement put(String key,TPQueryStoreStatement value) {
} throw new IllegalStateException();
}; }
config.setStatementCache(new TPQStoreManagerStatementCache(cc)); };
TPQManager queryManager = TPQFactory config.setStatementCache(new TPQStoreManagerStatementCache(cc));
.createManagerBuilder(config) TPQManager queryManager = TPQFactory
.createQuerySet("junit", "jar:mem:test") .createManagerBuilder(config)
.setLanguage("SQL") .createQuerySet("junit", "jar:mem:test")
.createQuery("test") .setLanguage("SQL")
.parseStatement("select * from table where a=$$a$$") .createQuery("test")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build() .parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build()
.build()
.build() .build()
.build() .build();
.build(); queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null); });
} }
@Test(expected=IllegalStateException.class) @Test
public void testCacheFailPutLock() throws Exception { public void testCacheFailPutLock() throws Exception {
TPQConfig config = TPQFactory.createConfig(); assertThrows(IllegalStateException.class, () -> {
config.setStatementCache(new TPQStoreManagerStatementCache(new HashMap<String,TPQueryStoreStatement>()) { TPQConfig config = TPQFactory.createConfig();
@Override config.setStatementCache(new TPQStoreManagerStatementCache(new HashMap<String,TPQueryStoreStatement>()) {
protected Lock getWriteLock() { @Override
return createFailingLock(false); protected Lock getWriteLock() {
} return createFailingLock(false);
}); }
TPQManager queryManager = TPQFactory });
.createManagerBuilder(config) TPQManager queryManager = TPQFactory
.createQuerySet("junit", "jar:mem:test") .createManagerBuilder(config)
.setLanguage("SQL") .createQuerySet("junit", "jar:mem:test")
.createQuery("test") .setLanguage("SQL")
.parseStatement("select * from table where a=$$a$$") .createQuery("test")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build() .parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build()
.build()
.build() .build()
.build() .build();
.build(); queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null); });
} }
@Test(expected=IllegalStateException.class) @Test
public void testCacheFailPutUnlock() throws Exception { public void testCacheFailPutUnlock() throws Exception {
TPQConfig config = TPQFactory.createConfig(); assertThrows(IllegalStateException.class, () -> {
config.setStatementCache(new TPQStoreManagerStatementCache(new HashMap<String,TPQueryStoreStatement>()) { TPQConfig config = TPQFactory.createConfig();
@Override config.setStatementCache(new TPQStoreManagerStatementCache(new HashMap<String,TPQueryStoreStatement>()) {
protected Lock getWriteLock() { @Override
return createFailingLock(true); protected Lock getWriteLock() {
} return createFailingLock(true);
}); }
TPQManager queryManager = TPQFactory });
.createManagerBuilder(config) TPQManager queryManager = TPQFactory
.createQuerySet("junit", "jar:mem:test") .createManagerBuilder(config)
.setLanguage("SQL") .createQuerySet("junit", "jar:mem:test")
.createQuery("test") .setLanguage("SQL")
.parseStatement("select * from table where a=$$a$$") .createQuery("test")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build() .parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build()
.build()
.build() .build()
.build() .build();
.build(); queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null); });
} }
@SuppressWarnings("serial") @SuppressWarnings("serial")
@Test(expected=IllegalStateException.class) @Test
public void testCacheFailGet() throws Exception { public void testCacheFailGet() throws Exception {
TPQConfig config = TPQFactory.createConfig(); assertThrows(IllegalStateException.class, () -> {
Map<String,TPQueryStoreStatement> cc = new HashMap<String,TPQueryStoreStatement>() { TPQConfig config = TPQFactory.createConfig();
@Override Map<String,TPQueryStoreStatement> cc = new HashMap<String,TPQueryStoreStatement>() {
public TPQueryStoreStatement get(Object key) { @Override
throw new IllegalStateException(); public TPQueryStoreStatement get(Object key) {
} throw new IllegalStateException();
}; }
config.setStatementCache(new TPQStoreManagerStatementCache(cc)); };
TPQManager queryManager = TPQFactory config.setStatementCache(new TPQStoreManagerStatementCache(cc));
.createManagerBuilder(config) TPQManager queryManager = TPQFactory
.createQuerySet("junit", "jar:mem:test") .createManagerBuilder(config)
.setLanguage("SQL") .createQuerySet("junit", "jar:mem:test")
.createQuery("test") .setLanguage("SQL")
.parseStatement("select * from table where a=$$a$$") .createQuery("test")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build() .parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build()
.build()
.build() .build()
.build() .build();
.build();
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null); });
} }
@Test(expected=IllegalStateException.class) @Test
public void testCacheFailGetLock() throws Exception { public void testCacheFailGetLock() throws Exception {
TPQConfig config = TPQFactory.createConfig(); assertThrows(IllegalStateException.class, () -> {
config.setStatementCache(new TPQStoreManagerStatementCache(new HashMap<String,TPQueryStoreStatement>()) { TPQConfig config = TPQFactory.createConfig();
@Override config.setStatementCache(new TPQStoreManagerStatementCache(new HashMap<String,TPQueryStoreStatement>()) {
protected Lock getWriteLock() { @Override
return createFailingLock(false); protected Lock getWriteLock() {
} return createFailingLock(false);
}); }
TPQManager queryManager = TPQFactory });
.createManagerBuilder(config) TPQManager queryManager = TPQFactory
.createQuerySet("junit", "jar:mem:test") .createManagerBuilder(config)
.setLanguage("SQL") .createQuerySet("junit", "jar:mem:test")
.createQuery("test") .setLanguage("SQL")
.parseStatement("select * from table where a=$$a$$") .createQuery("test")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build() .parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build()
.build()
.build() .build()
.build() .build();
.build(); queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null); });
} }
@Test(expected=IllegalStateException.class) @Test
public void testCacheFailGetUnlock() throws Exception { public void testCacheFailGetUnlock() throws Exception {
TPQConfig config = TPQFactory.createConfig(); assertThrows(IllegalStateException.class, () -> {
config.setStatementCache(new TPQStoreManagerStatementCache(new HashMap<String,TPQueryStoreStatement>()) { TPQConfig config = TPQFactory.createConfig();
@Override config.setStatementCache(new TPQStoreManagerStatementCache(new HashMap<String,TPQueryStoreStatement>()) {
protected Lock getWriteLock() { @Override
return createFailingLock(true); protected Lock getWriteLock() {
} return createFailingLock(true);
}); }
TPQManager queryManager = TPQFactory });
.createManagerBuilder(config) TPQManager queryManager = TPQFactory
.createQuerySet("junit", "jar:mem:test") .createManagerBuilder(config)
.setLanguage("SQL") .createQuerySet("junit", "jar:mem:test")
.createQuery("test") .setLanguage("SQL")
.parseStatement("select * from table where a=$$a$$") .createQuery("test")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build() .parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build()
.build()
.build() .build()
.build() .build();
.build(); queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null); });
} }
@ -217,72 +230,78 @@ public class TPQStoreManagerStatementCacheTest {
assertEquals(cache.size(),cache2.size()); assertEquals(cache.size(),cache2.size());
} }
@Test(expected=Exception.class) @Test
public void testCacheStatementReadObjectNoData() throws Exception { public void testCacheStatementReadObjectNoData() throws Exception {
Map<String,TPQueryStoreStatement> cache = new HashMap<>(); assertThrows(Exception.class, () -> {
TPQConfig config = TPQFactory.createConfig(); Map<String,TPQueryStoreStatement> cache = new HashMap<>();
config.setStatementCache(new TPQStoreManagerStatementCache(cache)); TPQConfig config = TPQFactory.createConfig();
TPQManager queryManager = TPQFactory config.setStatementCache(new TPQStoreManagerStatementCache(cache));
.createManagerBuilder(config) TPQManager queryManager = TPQFactory
.createQuerySet("junit", "jar:mem:test") .createManagerBuilder(config)
.setLanguage("SQL") .createQuerySet("junit", "jar:mem:test")
.createQuery("test") .setLanguage("SQL")
.parseStatement("select * from table where a=$$a$$") .createQuery("test")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build() .parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build()
.build()
.build() .build()
.build() .build();
.build(); queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null); TPQueryStoreStatement c = cache.values().iterator().next();
TPQueryStoreStatement c = cache.values().iterator().next(); assertNotNull(c);
assertNotNull(c); Method m = TPQueryStoreStatement.class.getDeclaredMethod("readObjectNoData", new Class<?>[]{});
Method m = TPQueryStoreStatement.class.getDeclaredMethod("readObjectNoData", new Class<?>[]{}); m.setAccessible(true);
m.setAccessible(true); m.invoke(c, new Object[]{});
m.invoke(c, new Object[]{}); });
} }
@Test(expected=Exception.class) @Test
public void testCacheValueMapperReadObjectNoData() throws Exception { public void testCacheValueMapperReadObjectNoData() throws Exception {
Map<String,TPQueryStoreStatement> cache = new HashMap<>(); assertThrows(Exception.class, () -> {
TPQConfig config = TPQFactory.createConfig(); Map<String,TPQueryStoreStatement> cache = new HashMap<>();
config.setStatementCache(new TPQStoreManagerStatementCache(cache)); TPQConfig config = TPQFactory.createConfig();
TPQManager queryManager = TPQFactory config.setStatementCache(new TPQStoreManagerStatementCache(cache));
.createManagerBuilder(config) TPQManager queryManager = TPQFactory
.createQuerySet("junit", "jar:mem:test") .createManagerBuilder(config)
.setLanguage("SQL") .createQuerySet("junit", "jar:mem:test")
.createQuery("test") .setLanguage("SQL")
.parseStatement("select * from table where a=$$a$$") .createQuery("test")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build() .parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build()
.build()
.build() .build()
.build() .build();
.build(); queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null); TPQueryStoreStatement c = cache.values().iterator().next();
TPQueryStoreStatement c = cache.values().iterator().next(); assertNotNull(c);
assertNotNull(c); Method m = TPQStatementParameterValueMapper.class.getDeclaredMethod("readObjectNoData", new Class<?>[]{});
Method m = TPQStatementParameterValueMapper.class.getDeclaredMethod("readObjectNoData", new Class<?>[]{}); m.setAccessible(true);
m.setAccessible(true); m.invoke(c.getValueMapping().get(0), new Object[]{});
m.invoke(c.getValueMapping().get(0), new Object[]{}); });
} }
@Test(expected=Exception.class) @Test
public void testCacheListMapperReadObjectNoData() throws Exception { public void testCacheListMapperReadObjectNoData() throws Exception {
Map<String,TPQueryStoreStatement> cache = new HashMap<>(); assertThrows(Exception.class, () -> {
TPQConfig config = TPQFactory.createConfig(); Map<String,TPQueryStoreStatement> cache = new HashMap<>();
config.setStatementCache(new TPQStoreManagerStatementCache(cache)); TPQConfig config = TPQFactory.createConfig();
TPQManager queryManager = TPQFactory config.setStatementCache(new TPQStoreManagerStatementCache(cache));
.createManagerBuilder(config) TPQManager queryManager = TPQFactory
.createQuerySet("junit", "jar:mem:test") .createManagerBuilder(config)
.setLanguage("SQL") .createQuerySet("junit", "jar:mem:test")
.createQuery("test") .setLanguage("SQL")
.parseStatement("select * from table where a=$$a$$") .createQuery("test")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setType("LIST").setDefaultValue("1,2,3").build() .parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setType("LIST").setDefaultValue("1,2,3").build()
.build()
.build() .build()
.build() .build();
.build(); queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null); TPQueryStoreStatement c = cache.values().iterator().next();
TPQueryStoreStatement c = cache.values().iterator().next(); assertNotNull(c);
assertNotNull(c); Method m = TPQStatementParameterListMapper.class.getDeclaredMethod("readObjectNoData", new Class<?>[]{});
Method m = TPQStatementParameterListMapper.class.getDeclaredMethod("readObjectNoData", new Class<?>[]{}); m.setAccessible(true);
m.setAccessible(true); m.invoke(c.getValueMapping().get(0), new Object[]{});
m.invoke(c.getValueMapping().get(0), new Object[]{}); });
} }
} }

132
tpquery-store/src/test/java/net/forwardfire/tpquery/store/manager/TPQStoreManagerTest.java
View file

@ -1,71 +1,80 @@
package net.forwardfire.tpquery.store.manager; package net.forwardfire.tpquery.store.manager;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.HashMap; import java.util.HashMap;
import net.forwardfire.tpquery.TPQManager; import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQFactory; import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.config.TPQConfig; import net.forwardfire.tpquery.config.TPQConfig;
import net.forwardfire.tpquery.config.TPQConfigException; import net.forwardfire.tpquery.config.TPQConfigException;
import net.forwardfire.tpquery.store.TPQueryStoreScriptEngineException; import net.forwardfire.tpquery.store.TPQueryStoreScriptEngineException;
import org.junit.Test;
public class TPQStoreManagerTest { public class TPQStoreManagerTest {
@Test(expected=TPQueryStoreScriptEngineException.class) @Test
public void testParameterValueScriptError() throws Exception { public void testParameterValueScriptError() throws Exception {
TPQConfig config = TPQFactory.createConfig(); assertThrows(TPQueryStoreScriptEngineException.class, () -> {
config.addParameterValueScript("throw 'error'"); TPQConfig config = TPQFactory.createConfig();
TPQFactory config.addParameterValueScript("throw 'error'");
.createManagerBuilder(config) TPQFactory
.createQuerySet("junit", "jar:junit:mem") .createManagerBuilder(config)
.setLanguage(TPQFactory.StatementLanguage.SQL) .createQuerySet("junit", "jar:junit:mem")
.createQuery("test") .setLanguage(TPQFactory.StatementLanguage.SQL)
.parseStatement("select * from foobar where a=$$a$$") .createQuery("test")
.createQueryParameter("a", TPQFactory.ParameterValueType.SQL_TIME) .parseStatement("select * from foobar where a=$$a$$")
.setDefaultValue("js:time()") .createQueryParameter("a", TPQFactory.ParameterValueType.SQL_TIME)
.setDefaultValue("js:time()")
.build()
.build()
.build()
.build();
});
}
@Test
public void testCompileScriptError() throws Exception {
assertThrows(TPQueryStoreScriptEngineException.class, () -> {
TPQManager manager = TPQFactory
.createManagerBuilder()
.createQuerySet("junit", "jar:junit:mem")
.setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("test")
.parseStatement("select * from foobar where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.SQL_TIME)
.setDefaultValue("js:+++++++-------------=========----------+++++++++")
.build() .build()
.build() .build()
.build()
.build();
}
@Test(expected=TPQueryStoreScriptEngineException.class)
public void testCompileScriptError() throws Exception {
TPQManager manager = TPQFactory
.createManagerBuilder()
.createQuerySet("junit", "jar:junit:mem")
.setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("test")
.parseStatement("select * from foobar where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.SQL_TIME)
.setDefaultValue("js:+++++++-------------=========----------+++++++++")
.build()
.build() .build()
.build() .build();
.build(); manager.getQueryExecutorContext().prepareQuery("junit.test", new HashMap<String,Object>());
manager.getQueryExecutorContext().prepareQuery("junit.test", new HashMap<String,Object>()); });
} }
@Test(expected=Exception.class) @Test
public void testRuntimeScriptError() throws Exception { public void testRuntimeScriptError() throws Exception {
TPQManager manager = TPQFactory assertThrows(Exception.class, () -> {
.createManagerBuilder() TPQManager manager = TPQFactory
.createQuerySet("junit", "jar:junit:mem") .createManagerBuilder()
.setLanguage(TPQFactory.StatementLanguage.SQL) .createQuerySet("junit", "jar:junit:mem")
.createQuery("test") .setLanguage(TPQFactory.StatementLanguage.SQL)
.parseStatement("select * from foobar where a=$$a$$") .createQuery("test")
.createQueryParameter("a", TPQFactory.ParameterValueType.SQL_TIME) .parseStatement("select * from foobar where a=$$a$$")
.setDefaultValue("js:throw createObject(java.lang.String,'error')") .createQueryParameter("a", TPQFactory.ParameterValueType.SQL_TIME)
.setDefaultValue("js:throw createObject(java.lang.String,'error')")
.build()
.build() .build()
.build() .build()
.build() .build();
.build(); manager.getQueryExecutorContext().prepareQuery("junit.test", new HashMap<String,Object>());
manager.getQueryExecutorContext().prepareQuery("junit.test", new HashMap<String,Object>()); });
} }
@Test(expected=TPQConfigException.class) @Test
public void testConfigErrorByTPQStoreManagerConfig() throws Exception { public void testConfigErrorByTPQStoreManagerConfig() throws Exception {
assertThrows(TPQConfigException.class, () ->
TPQFactory.createManagerBuilder() TPQFactory.createManagerBuilder()
.createQuerySet("junit", "jar:junit:mem") .createQuerySet("junit", "jar:junit:mem")
.setLanguage(TPQFactory.StatementLanguage.SQL) .setLanguage(TPQFactory.StatementLanguage.SQL)
@ -75,26 +84,27 @@ public class TPQStoreManagerTest {
.build() .build()
.build() .build()
.build() .build()
.build(); .build());
} }
@Test(expected=TPQConfigException.class) @Test
public void testConfigErrorByTPQStoreManager() throws Exception { public void testConfigErrorByTPQStoreManager() throws Exception {
assertThrows(TPQConfigException.class, () -> {
TPQConfig c = TPQFactory.createConfigBuilder() TPQConfig c = TPQFactory.createConfigBuilder()
.createQuerySet("junit", "jar:junit:mem") .createQuerySet("junit", "jar:junit:mem")
.setLanguage(TPQFactory.StatementLanguage.SQL) .setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("test") .createQuery("test")
.parseStatement("select * from foobar where a=$$a$$") .parseStatement("select * from foobar where a=$$a$$")
.createQueryParameter("a", "java.lang.String") .createQueryParameter("a", "java.lang.String")
.build()
.build() .build()
.build() .build()
.build() .build();
.build(); TPQStoreManagerConfig smc = new TPQStoreManagerConfig(c);
TPQStoreManagerConfig smc = new TPQStoreManagerConfig(c);
smc.getEntries().get("junit.test").getQuery().getQueryParameters().get(0).setValueType("net.foo.bar.NoneExcistingClass");
smc.getEntries().get("junit.test").getQuery().getQueryParameters().get(0).setValueType("net.foo.bar.NoneExcistingClass");
new TPQStoreManager(smc);
new TPQStoreManager(smc); });
} }
} }

6
tpquery-store/src/test/java/net/forwardfire/tpquery/store/proxy/TPQueryProxyFactoryTest.java
View file

@ -1,15 +1,15 @@
package net.forwardfire.tpquery.store.proxy; package net.forwardfire.tpquery.store.proxy;
import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQFactory; import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.TPQManager; import net.forwardfire.tpquery.TPQManager;
import org.junit.Test;
public class TPQueryProxyFactoryTest { public class TPQueryProxyFactoryTest {
@Test() @Test()