arch-jedi/tpquery
3
0
Fork 0
Code Issues 2 Pull requests Activity

Merge pull request '[Task-3]-updated java11 and junit5' (#5) from feature/issue-3/upgrade-java-11 into master

Browse source
This commit is contained in:
immetoo 2020-10-18 21:53:18 +00:00
parent ccd7320be5 e8fb5b6181
commit 39a311aac9
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">
<modelVersion>4.0.0</modelVersion>
<groupId>net.forwardfire.tpquery</groupId>
@ -30,13 +31,13 @@
</modules>
<properties>
<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 ... -->
<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> -->
<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>
<dependencyManagement>
<dependencies>
@ -51,9 +52,9 @@
<version>3.5</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<version>5.5.2</version>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
@ -95,12 +96,27 @@
<artifactId>sonar-jacoco-listeners</artifactId>
<version>3.2</version>
</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>
</dependencyManagement>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<scope>test</scope>
</dependency>
<dependency>
@ -165,22 +181,6 @@
</plugins>
</pluginManagement>
<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>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-enforcer-plugin</artifactId>
@ -198,9 +198,7 @@
<requireMavenVersion>
<version>(3.0,)</version>
</requireMavenVersion>
<!-- jdk9 check
<banDuplicateClasses></banDuplicateClasses>
-->
<!-- jdk9 check <banDuplicateClasses></banDuplicateClasses> -->
</rules>
</configuration>
</plugin>
@ -380,9 +378,12 @@
<configuration>
<target>
<echo>Copy project markdown to site.</echo>
<copy verbose="true" file="readme.md" toFile="src/site/markdown/index.md" />
<copy verbose="true" file="todo.md" todir="src/site/markdown" />
<copy verbose="true" file="build.md" todir="src/site/markdown" />
<copy verbose="true" file="readme.md"
toFile="src/site/markdown/index.md" />
<copy verbose="true" file="todo.md"
todir="src/site/markdown" />
<copy verbose="true" file="build.md"
todir="src/site/markdown" />
</target>
</configuration>
</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;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.sql.Connection;
import java.sql.DriverManager;
@ -11,20 +12,17 @@ import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.TPQFactory;
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.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.slf4j.LoggerFactory;
import ch.qos.logback.classic.LoggerContext;
import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.TPQManager;
public class TPQExecutorJdbcTest {
@BeforeClass
@BeforeEach
public static void setupLogging() {
LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
lc.reset(); // disable logging
@ -84,94 +82,104 @@ public class TPQExecutorJdbcTest {
}
}
@Test(expected=SQLExceptionRuntime.class)
@Test
public void testExecuteUpdateFail() throws Exception {
try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) {
TPQManager store = TPQFactory
.createManagerBuilder()
.createQuerySet("junit", "jar:junit:mem")
.setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("createTable").appendText("CREATE TABLE test_table (id serial,data int)").build()
.createQuery("insertData").appendText("INSERT INTO test_table (data) VALUES (0)").build()
.createQuery("queryFail").appendText("update test_table tt set tt.data=10/(SELECT sum(t1.data) FROM test_table t1)").build()
.build()
.build();
TPQExecutorJdbc exe = new TPQExecutorJdbc(store.getQueryExecutorContext());
exe.executeUpdate(connection, "junit.createTable");
exe.executeUpdate(connection, "junit.insertData");
exe.executeUpdate(connection, "junit.queryFail"); // runtime data failure, as prepared will go correctly
assertThrows(SQLExceptionRuntime.class, () -> {
try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) {
TPQManager store = TPQFactory
.createManagerBuilder()
.createQuerySet("junit", "jar:junit:mem")
.setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("createTable").appendText("CREATE TABLE test_table (id serial,data int)").build()
.createQuery("insertData").appendText("INSERT INTO test_table (data) VALUES (0)").build()
.createQuery("queryFail").appendText("update test_table tt set tt.data=10/(SELECT sum(t1.data) FROM test_table t1)").build()
.build()
.build();
TPQExecutorJdbc exe = new TPQExecutorJdbc(store.getQueryExecutorContext());
exe.executeUpdate(connection, "junit.createTable");
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 {
try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) {
TPQManager store = TPQFactory
.createManagerBuilder()
.createQuerySet("junit", "jar:junit:mem")
.setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("createTable").appendText("CREATE TABLE test_table (id serial,data int)").build()
.createQuery("insertData").appendText("INSERT INTO test_table (data) VALUES (0)").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();
TPQExecutorJdbc exe = new TPQExecutorJdbc(store.getQueryExecutorContext());
exe.executeUpdate(connection, "junit.createTable");
exe.executeUpdate(connection, "junit.insertData");
exe.execute(connection, "junit.queryFail"); // runtime data failure, as prepared will go correctly
}
assertThrows(SQLExceptionRuntime.class, () -> {
try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) {
TPQManager store = TPQFactory
.createManagerBuilder()
.createQuerySet("junit", "jar:junit:mem")
.setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("createTable").appendText("CREATE TABLE test_table (id serial,data int)").build()
.createQuery("insertData").appendText("INSERT INTO test_table (data) VALUES (0)").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();
TPQExecutorJdbc exe = new TPQExecutorJdbc(store.getQueryExecutorContext());
exe.executeUpdate(connection, "junit.createTable");
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 {
try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) {
TPQManager store = TPQFactory.createManagerBuilder()
.createQuerySet("junit", "jar:junit:mem:testcaseFail")
.setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("sql-fail").appendText("select * from article").build()
.build()
.build();
TPQExecutorJdbc exe = new TPQExecutorJdbc(store.getQueryExecutorContext());
exe.execute(connection, "junit.sql-fail");
}
assertThrows(SQLExceptionRuntime.class, () -> {
try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) {
TPQManager store = TPQFactory.createManagerBuilder()
.createQuerySet("junit", "jar:junit:mem:testcaseFail")
.setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("sql-fail").appendText("select * from article").build()
.build()
.build();
TPQExecutorJdbc exe = new TPQExecutorJdbc(store.getQueryExecutorContext());
exe.execute(connection, "junit.sql-fail");
}
});
}
@Test(expected=SQLExceptionRuntime.class)
@Test
public void testTimeoutFail() throws Exception {
try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) {
TPQManager store = TPQFactory.createManagerBuilder()
.createQuerySet("junit", "jar:junit:mem:test")
.setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("createTable").appendText("CREATE TABLE test_table (id serial,data int)").build()
.createQuery("test").appendText("select * from test_table").build()
.build()
.build();
TPQExecutorJdbc exe = new TPQExecutorJdbc(store.getQueryExecutorContext());
exe.executeUpdate(connection, "junit.createTable");
PreparedStatement ps = exe.createPreparedStatement(connection, "junit.test", null);
ps.close();
exe.prepareTimeout(ps, 123);
}
assertThrows(SQLExceptionRuntime.class, () -> {
try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) {
TPQManager store = TPQFactory.createManagerBuilder()
.createQuerySet("junit", "jar:junit:mem:test")
.setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("createTable").appendText("CREATE TABLE test_table (id serial,data int)").build()
.createQuery("test").appendText("select * from test_table").build()
.build()
.build();
TPQExecutorJdbc exe = new TPQExecutorJdbc(store.getQueryExecutorContext());
exe.executeUpdate(connection, "junit.createTable");
PreparedStatement ps = exe.createPreparedStatement(connection, "junit.test", null);
ps.close();
exe.prepareTimeout(ps, 123);
}
});
}
@Test(expected=SQLExceptionRuntime.class)
@Test
public void testParameterFail() throws Exception {
try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) {
TPQManager store = TPQFactory.createManagerBuilder()
.createQuerySet("junit", "jar:junit:mem:test")
.setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("createTable").appendText("CREATE TABLE test_table (id serial,data int)").build()
.createQuery("test").appendText("select * from test_table").build()
.build()
.build();
TPQExecutorJdbc exe = new TPQExecutorJdbc(store.getQueryExecutorContext());
exe.executeUpdate(connection, "junit.createTable");
PreparedStatement ps = exe.createPreparedStatement(connection, "junit.test", null);
exe.prepareParameterValue(ps, 1, 123);
}
assertThrows(SQLExceptionRuntime.class, () -> {
try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) {
TPQManager store = TPQFactory.createManagerBuilder()
.createQuerySet("junit", "jar:junit:mem:test")
.setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("createTable").appendText("CREATE TABLE test_table (id serial,data int)").build()
.createQuery("test").appendText("select * from test_table").build()
.build()
.build();
TPQExecutorJdbc exe = new TPQExecutorJdbc(store.getQueryExecutorContext());
exe.executeUpdate(connection, "junit.createTable");
PreparedStatement ps = exe.createPreparedStatement(connection, "junit.test", null);
exe.prepareParameterValue(ps, 1, 123);
}
});
}
@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;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.HashMap;
import java.util.List;
@ -12,44 +13,42 @@ import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.config.TPQConfig;
import net.forwardfire.tpquery.statement.AbstractTPQStatementWriter;
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.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.slf4j.LoggerFactory;
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 {
private EntityManagerFactory emFactory;
private EntityManager em = null;
@BeforeClass
@BeforeAll
public static void setupLogging() {
LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
lc.reset(); // disable logging
}
@Before
@BeforeEach
public void before() {
emFactory = Persistence.createEntityManagerFactory("junit");
em = emFactory.createEntityManager();
}
@After
@AfterEach
public void close() {
em.close();
emFactory.close();
@ -116,36 +115,39 @@ public class TPQExecutorJpaTest {
//assertEquals("foobar",resultSingle.name);
}
@Test(expected=NullPointerException.class)
@Test
public void testUnsupportedLanguage() throws Exception {
TPQConfig config = new TPQConfig();
config.addStatementLanguage(new TPQStatementLanguage() {
@Override
public String getLanguageType() {
return "XQL";
}
@Override
public TPQStatementWriter createQueryWriter(Map<String, Object> parameterData) {
return new AbstractTPQStatementWriter(parameterData) {
};
}
});
TPQManager store = TPQFactory
.createManagerBuilder(config)
.createQuerySet("junit", "jar:mem:test")
.createQuery("test")
.setLanguage("XQL")
.parseStatement("select * from table")
assertThrows(NullPointerException.class, () -> {
TPQConfig config = new TPQConfig();
config.addStatementLanguage(new TPQStatementLanguage() {
@Override
public String getLanguageType() {
return "XQL";
}
@Override
public TPQStatementWriter createQueryWriter(Map<String, Object> parameterData) {
return new AbstractTPQStatementWriter(parameterData) {
};
}
});
TPQManager store = TPQFactory
.createManagerBuilder(config)
.createQuerySet("junit", "jar:mem:test")
.createQuery("test")
.setLanguage("XQL")
.parseStatement("select * from table")
.build()
.build()
.build()
.build();
TPQExecutorJpa exe = new TPQExecutorJpa(store.getQueryExecutorContext());
exe.selectList(em, "junit.test", null);
.build();
TPQExecutorJpa exe = new TPQExecutorJpa(store.getQueryExecutorContext());
exe.selectList(em, "junit.test", null);
});
}
@Test()
@Test
public void testQueryProxy() throws Exception {
assertThrows(NullPointerException.class, () -> {
TPQManager store = TPQFactory.createManagerBuilder()
.createQuerySet("junit", "jar:junit:mem")
.setLanguage(TPQFactory.StatementLanguage.HQL)
@ -196,6 +198,7 @@ public class TPQExecutorJpaTest {
d = foobarService.testFoo();
assertNotNull(d);
});
}
@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">
<modelVersion>4.0.0</modelVersion>
<parent>
@ -22,6 +23,21 @@
<artifactId>commons-lang3</artifactId>
<scope>compile</scope>
</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>
</project>

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

@ -1,11 +1,10 @@
package net.forwardfire.tpquery;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.config.TPQConfig;
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.TimeUnit;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.slf4j.LoggerFactory;
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.TPQueryStoreStatementMapper;
import net.forwardfire.tpquery.store.manager.TPQStoreManagerExecutorContext;
import net.forwardfire.tpquery.store.manager.TPQStoreManagerExecutorStatement;
@ -28,17 +27,17 @@ public class TPQSpeedTest {
static int loopSize;
static int warmupSize;
static TPQManager queryManager;
static List<String> result;
static List<String> result = new ArrayList<>();;
@BeforeClass
@BeforeAll
static public void initSpeedTest() throws Exception {
LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
lc.reset(); // disable logging in speed tests.
warmupSize = 10;
loopSize = 100000*new Integer(System.getProperty("junit.speedtest.factor", "1"));
result = new ArrayList<>();
loopSize = 100000 * Integer.parseInt(System.getProperty("junit.speedtest.factor", "1"));
queryManager = TPQFactory.createManagerBuilder()
.createQuerySet("junit", "jar:junit:mem")
.setLanguage(TPQFactory.StatementLanguage.SQL)
@ -122,7 +121,7 @@ public class TPQSpeedTest {
}
}
@AfterClass
@AfterAll
public static void printResults() {
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;
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.util.HashMap;
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.TPQManager;
import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
public class TPQueryStoreConfigBuilderTest {
@ -38,9 +39,9 @@ public class TPQueryStoreConfigBuilderTest {
assertNotNull(manager.getQueryStore().getQueryNames());
}
@Test(expected=IllegalStateException.class)
@Test
public void testBuildTreeInvalid() throws Exception {
TPQFactory
assertThrows(IllegalStateException.class, () -> TPQFactory
.createManagerBuilder()
.createQuerySet("junit", "jar:mem:test")
.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() should be here
.build()
.build();
.build());
}
@Test
@ -128,17 +129,17 @@ public class TPQueryStoreConfigBuilderTest {
assertNotNull(q.getName());
}
@Test(expected=TPQConfigException.class)
@Test
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"))
.build();
.build());
}
@Test(expected=TPQConfigException.class)
@Test
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"))
.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;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
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.config.TPQConfig;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.statement.language.TPQStatementLanguageSql;
import net.forwardfire.tpquery.statement.parameter.TPQStatementParameterValue;
import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
@ -40,32 +40,40 @@ public class TPQueryStoreConfigTest {
// ---------
@Test(expected=IllegalArgumentException.class)
@Test
public void testTemplateTypeAdd() throws Exception {
TPQConfig c = TPQFactory.createConfig();
c.addStatementParameter(new TPQStatementParameterValue(TPQFactory.StatementParameter.VALUE));
assertThrows(IllegalArgumentException.class, () -> {
TPQConfig c = TPQFactory.createConfig();
c.addStatementParameter(new TPQStatementParameterValue(TPQFactory.StatementParameter.VALUE));
});
}
@Test(expected=NullPointerException.class)
@Test
public void testTemplateTypeRemove() throws Exception {
TPQConfig c = TPQFactory.createConfig();
c.removeStatementParameter(TPQFactory.StatementParameter.VALUE);
c.removeStatementParameter(TPQFactory.StatementParameter.VALUE);
assertThrows(NullPointerException.class, () -> {
TPQConfig c = TPQFactory.createConfig();
c.removeStatementParameter(TPQFactory.StatementParameter.VALUE);
c.removeStatementParameter(TPQFactory.StatementParameter.VALUE);
});
}
// ---------
@Test(expected=IllegalArgumentException.class)
@Test
public void testLanguageTypeAdd() throws Exception {
TPQConfig c = TPQFactory.createConfig();
c.addStatementLanguage(new TPQStatementLanguageSql(TPQFactory.StatementLanguage.SQL));
assertThrows(IllegalArgumentException.class, () -> {
TPQConfig c = TPQFactory.createConfig();
c.addStatementLanguage(new TPQStatementLanguageSql(TPQFactory.StatementLanguage.SQL));
});
}
@Test(expected=NullPointerException.class)
@Test
public void testLanguageTypeRemove() throws Exception {
TPQConfig c = TPQFactory.createConfig();
c.removeStatementLanguage(TPQFactory.StatementLanguage.SQL);
c.removeStatementLanguage(TPQFactory.StatementLanguage.SQL);
assertThrows(NullPointerException.class, () -> {
TPQConfig c = TPQFactory.createConfig();
c.removeStatementLanguage(TPQFactory.StatementLanguage.SQL);
c.removeStatementLanguage(TPQFactory.StatementLanguage.SQL);
});
}
// ---------
@ -82,23 +90,29 @@ public class TPQueryStoreConfigTest {
c.addValueType(this.getClass().getName());
}
@Test(expected=IllegalArgumentException.class)
@Test
public void testAddValueTypeClassNameError() throws Exception {
TPQConfig c = TPQFactory.createConfig();
c.addValueType("net.foo.bar.NoneExcistingClassName");
assertThrows(IllegalArgumentException.class, () -> {
TPQConfig c = TPQFactory.createConfig();
c.addValueType("net.foo.bar.NoneExcistingClassName");
});
}
@Test(expected=IllegalArgumentException.class)
@Test
public void testValueTypeAliasAdd() throws Exception {
TPQConfig c = TPQFactory.createConfig();
c.addValueTypeAlias("key", "v0");
c.addValueTypeAlias("key", "v1");
assertThrows(IllegalArgumentException.class, () -> {
TPQConfig c = TPQFactory.createConfig();
c.addValueTypeAlias("key", "v0");
c.addValueTypeAlias("key", "v1");
});
}
@Test(expected=NullPointerException.class)
@Test
public void testValueTypeAliasRemoveIllegalKey() throws Exception {
TPQConfig c = TPQFactory.createConfig();
c.removeValueTypeAlias("unknown-key");
assertThrows(NullPointerException.class, () -> {
TPQConfig c = TPQFactory.createConfig();
c.removeValueTypeAlias("unknown-key");
});
}
@Test()
@ -115,16 +129,20 @@ public class TPQueryStoreConfigTest {
// ---------
@Test(expected=NullPointerException.class)
@Test
public void testQuerySetRemoveIllegalKey() throws Exception {
TPQConfig c = TPQFactory.createConfig();
c.removeQuerySet("unknown-key");
assertThrows(NullPointerException.class, () -> {
TPQConfig c = TPQFactory.createConfig();
c.removeQuerySet("unknown-key");
});
}
@Test(expected=NullPointerException.class)
@Test
public void testQuerySetRemoveNull() throws Exception {
TPQConfig c = TPQFactory.createConfig();
c.removeQuerySet(null);
assertThrows(NullPointerException.class, () -> {
TPQConfig c = TPQFactory.createConfig();
c.removeQuerySet(null);
});
}
@Test()
@ -204,19 +222,21 @@ public class TPQueryStoreConfigTest {
assertNotNull(q.getName());
}
@Test(expected=TPQConfigException.class)
@Test
public void testWrongClassParameterType() throws Exception {
TPQManager manager = TPQFactory
.createManagerBuilder()
.createQuerySet("junit", "jar:mem:test")
.setLanguage("SQL")
.createQuery("test")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", "java.lang.StringFooBar").build()
assertThrows(TPQConfigException.class, () -> {
TPQManager manager = TPQFactory
.createManagerBuilder()
.createQuerySet("junit", "jar:mem:test")
.setLanguage("SQL")
.createQuery("test")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", "java.lang.StringFooBar").build()
.build()
.build()
.build()
.build();
assertNotNull(manager);
.build();
assertNotNull(manager);
});
}
@Test

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

@ -1,46 +1,33 @@
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.config.validate.TPQConfigValidator;
import net.forwardfire.tpquery.config.validate.TPQConfigValidatorCheck;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.config.validate.TPQCheckDescriptionNotBlank;
import net.forwardfire.tpquery.config.validate.TPQCheckNamePattern;
import net.forwardfire.tpquery.config.validate.TPQCheckParameterDefaultValueNotBlank;
import net.forwardfire.tpquery.config.validate.TPQCheckParameterNamePattern;
import net.forwardfire.tpquery.config.validate.TPQCheckParameterTypePattern;
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;
public class TPQueryStoreConfigValidatorTest {
@Test()
public void testPatternValidators() throws Exception {
TPQConfig config = TPQFactory
.createConfigBuilder()
.createQuerySet("junit", "jar:mem:test")
.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$$ ")
.createQueryParameter("a", Integer.class)
.setDefaultValue("1")
.build()
.build()
.createQuerySet("inc")
.createQuery("test")
.parseStatement("AND 2=2")
.build()
.build()
.buildTree()
.build()
.build();
TPQConfig config = TPQFactory.createConfigBuilder().createQuerySet("junit", "jar:mem:test")
.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$$ ")
.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 TPQCheckParameterNamePattern(".*"));
config.addConfigValidator(".*", new TPQCheckParameterTypePattern(".*"));
@ -53,78 +40,84 @@ public class TPQueryStoreConfigValidatorTest {
TPQManager manager = TPQFactory.createManager(config);
assertNotNull(manager);
}
@Test(expected=IllegalArgumentException.class)
@Test
public void testDescriptionNotBlank() throws Exception {
TPQConfig config = TPQFactory
.createConfigBuilder()
.createQuerySet("junit", "jar:mem:test")
.createQuery("test-oke")
.setDescription("foobar")
.parseStatement("select * from table")
assertThrows(IllegalArgumentException.class, () -> {
TPQConfig config = TPQFactory
.createConfigBuilder()
.createQuerySet("junit", "jar:mem:test")
.createQuery("test-oke")
.setDescription("foobar")
.parseStatement("select * from table")
.build()
.createQuery("test-fail")
.setDescription("")
.parseStatement("select * from table")
.build()
.build()
.createQuery("test-fail")
.setDescription("")
.parseStatement("select * from table")
.build()
.build()
.build();
TPQConfigValidator t = config.addConfigValidator("junit.test", new TPQCheckDescriptionNotBlank());
config.removeConfigValidator(t);
config.addConfigValidator(".*", new TPQCheckDescriptionNotBlank());
TPQManager manager = TPQFactory.createManager(config);
assertNotNull(manager);
.build();
TPQConfigValidator t = config.addConfigValidator("junit.test", new TPQCheckDescriptionNotBlank());
config.removeConfigValidator(t);
config.addConfigValidator(".*", new TPQCheckDescriptionNotBlank());
TPQManager manager = TPQFactory.createManager(config);
assertNotNull(manager);
});
}
@Test(expected=IllegalArgumentException.class)
@Test
public void testParameterDefaultValueNotBlank() throws Exception {
TPQConfig config = TPQFactory
.createConfigBuilder()
.createQuerySet("junit", "jar:mem:test")
.createQuery("test-oke")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.INTEGER)
.setDefaultValue("1")
assertThrows(IllegalArgumentException.class, () -> {
TPQConfig config = TPQFactory
.createConfigBuilder()
.createQuerySet("junit", "jar:mem:test")
.createQuery("test-oke")
.parseStatement("select * from table where a=$$a$$")
.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()
.createQuery("test-fail")
.setDescription("")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.INTEGER)
.setDefaultValue("")
.build()
.build()
.build()
.build();
config.addConfigValidator(".*", new TPQCheckParameterDefaultValueNotBlank());
TPQManager manager = TPQFactory.createManager(config);
assertNotNull(manager);
.build();
config.addConfigValidator(".*", new TPQCheckParameterDefaultValueNotBlank());
TPQManager manager = TPQFactory.createManager(config);
assertNotNull(manager);
});
}
@Test(expected=IllegalArgumentException.class)
@Test
public void testDisableRAWExample() throws Exception {
TPQConfig config = TPQFactory
.createConfigBuilder()
.createQuerySet("junit", "jar:mem:test")
.createQuery("test-oke")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.INTEGER)
.setType(TPQFactory.StatementParameter.RAW)
assertThrows(IllegalArgumentException.class, () -> {
TPQConfig config = TPQFactory
.createConfigBuilder()
.createQuerySet("junit", "jar:mem:test")
.createQuery("test-oke")
.parseStatement("select * from table where a=$$a$$")
.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()
.createQuery("test-fail")
.setDescription("")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.INTEGER)
.setType(TPQFactory.StatementParameter.RAW)
.build()
.build()
.build()
.build();
config.addConfigValidator("junit.test-f.*", new TPQCheckParameterTypePattern("!RAW"));
TPQManager manager = TPQFactory.createManager(config);
assertNotNull(manager);
.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.Map;
import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.store.executor.AbstractTPQExecutor;
import net.forwardfire.tpquery.store.executor.TPQExecutorContext;
import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
import org.junit.Test;
public class TQueryExecutorTest {
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;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
@ -12,15 +13,10 @@ import java.util.Map;
import javax.xml.bind.annotation.XmlElement;
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.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.TPQStatementPartParameter;
import net.forwardfire.tpquery.statement.TPQStatementPartText;
@ -117,9 +113,9 @@ public class ModelXMLMarshallerTest {
assertEquals("false",q.getQueryHints().get("junit"));
}
@Test(expected=IllegalArgumentException.class)
@Test
public void testContextException() throws Exception {
new ModelXMLMarshaller(JaxbContextError.class);
assertThrows(IllegalArgumentException.class, () -> new ModelXMLMarshaller(JaxbContextError.class));
}
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;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.HashMap;
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.TPQManager;
import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
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;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import net.forwardfire.tpquery.statement.TPQStatementMarshallerAdapter;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.Test;
import org.junit.jupiter.api.Test;
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;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.ArrayList;
import java.util.List;
import net.forwardfire.tpquery.statement.TPQStatement;
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;
import org.junit.jupiter.api.Test;
public class TPQueryStatementMarshallerTest {
@Test(expected=NullPointerException.class)
@Test
public void testParseNull() throws Exception {
TPQStatementMarshaller parser = new TPQStatementMarshaller();
parser.unmarshal(null);
assertThrows(NullPointerException.class, () -> {
TPQStatementMarshaller parser = new TPQStatementMarshaller();
parser.unmarshal(null);
});
}
@Test()
public void testParseEmpty() throws Exception {
TPQStatementMarshaller parser = new TPQStatementMarshaller();
@ -31,58 +28,58 @@ public class TPQueryStatementMarshallerTest {
assertNotNull(result);
assertTrue(result.isEmpty());
}
@Test()
public void testParseText() throws Exception {
TPQStatementMarshaller parser = new TPQStatementMarshaller();
List<TPQStatement> result = parser.unmarshal("foobar");
assertNotNull(result);
assertFalse(result.isEmpty());
assertTrue(result.size()==1);
assertTrue(result.size() == 1);
assertNotNull(result.get(0));
assertTrue(result.get(0) instanceof TPQStatementPartText);
}
@Test()
public void testParseTemplate() throws Exception {
TPQStatementMarshaller parser = new TPQStatementMarshaller();
List<TPQStatement> result = parser.unmarshal("$$foobar$$");
assertNotNull(result);
assertFalse(result.isEmpty());
assertTrue(result.size()==1);
assertTrue(result.size() == 1);
assertNotNull(result.get(0));
assertTrue(result.get(0) instanceof TPQStatementPartParameter);
}
@Test(expected=IllegalArgumentException.class)
@Test
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 {
new TPQStatementMarshaller().unmarshal("$$$$");
assertThrows(IllegalArgumentException.class, () -> new TPQStatementMarshaller().unmarshal("$$$$"));
}
@Test()
public void testParseTemplateInclude() throws Exception {
TPQStatementMarshaller parser = new TPQStatementMarshaller();
List<TPQStatement> result = parser.unmarshal("$$inc:foobar$$");
assertNotNull(result);
assertFalse(result.isEmpty());
assertTrue(result.size()==1);
assertTrue(result.size() == 1);
assertNotNull(result.get(0));
assertTrue(result.get(0) instanceof TPQStatementPartInclude);
}
@Test(expected=NullPointerException.class)
@Test
public void testPrintNull() throws Exception {
TPQStatementMarshaller parser = new TPQStatementMarshaller();
parser.marshal(null);
assertThrows(NullPointerException.class, () -> {
TPQStatementMarshaller parser = new TPQStatementMarshaller();
parser.marshal(null);
});
}
@Test()
public void testPrintEmpty() throws Exception {
List<TPQStatement> data = new ArrayList<>();
@ -91,7 +88,7 @@ public class TPQueryStatementMarshallerTest {
assertNotNull(result);
assertTrue(result.isEmpty());
}
@Test()
public void testPrintText() throws Exception {
List<TPQStatement> data = new ArrayList<>();
@ -102,7 +99,6 @@ public class TPQueryStatementMarshallerTest {
String result = parser.marshal(data);
assertNotNull(result);
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;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import net.forwardfire.tpquery.TPQManager;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
import org.junit.Test;
public class TPQueryStatementPartIncludeTest {
@Test(expected=NullPointerException.class)
@Test
public void testFailInclude() throws Exception {
TPQFactory.createManagerBuilder()
assertThrows(NullPointerException.class, () -> TPQFactory.createManagerBuilder()
.createQuerySet("junit", "jar:junit:mem:test")
.setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("include-missing")
.appendText("select * from foobar")
.appendInclude("include-missing-query")
.build()
.build()
.build();
.setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("include-missing")
.appendText("select * from foobar")
.appendInclude("include-missing-query")
.build()
.build()
.build());
}
@Test
public void testIncludeMultple() throws Exception {
TPQManager store = TPQFactory
.createManagerBuilder()
.readQuerySet("net/forwardfire/tpquery/test-include-multiple.xml")
.build();
TPQManager store = TPQFactory.createManagerBuilder()
.readQuerySet("net/forwardfire/tpquery/test-include-multiple.xml").build();
TPQExecutorStatement q = store.getQueryExecutorContext().prepareQuery("test.multipleInclude", null);
assertNotNull(q.getName());
assertTrue(q.getStatement().contains("price_list"));
assertTrue(q.getStatement().contains("key='stats_correction') AS mrt"));
}
@Test(expected=IllegalArgumentException.class)
@Test
public void testIncludeLoop() throws Exception {
TPQManager store = TPQFactory
.createManagerBuilder()
.readQuerySet("net/forwardfire/tpquery/test-include-loop.xml")
.build();
store.getQueryExecutorContext().prepareQuery("test.loopInclude", null);
assertThrows(IllegalArgumentException.class, () -> {
TPQManager store = TPQFactory
.createManagerBuilder()
.readQuerySet("net/forwardfire/tpquery/test-include-loop.xml")
.build();
store.getQueryExecutorContext().prepareQuery("test.loopInclude", null);
});
}
@Test(expected=IllegalArgumentException.class)
@Test
public void testQueryChecked() throws Exception {
TPQFactory.createManagerBuilder()
assertThrows(IllegalArgumentException.class,
() -> TPQFactory.createManagerBuilder()
.createQuerySet("junit", "jar:junit:mem:test")
.setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("test")
.appendText("select * from foobar")
.build()
.createQuery("test-fail")
.appendInclude("junit.test")
.build()
.build()
.build();
.setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("test")
.appendText("select * from foobar")
.build()
.createQuery("test-fail")
.appendInclude("junit.test")
.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;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import java.util.HashMap;
import java.util.Map;
import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.TPQManager;
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.TPQStatementLanguageSql;
import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
import org.junit.Test;
public class TPQueryStatementWriterTest {
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;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.HashMap;
import java.util.Map;
import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.statement.TPQStatementWriter;
import net.forwardfire.tpquery.statement.language.TPQStatementLanguageHql;
import net.forwardfire.tpquery.store.TPQueryStoreStatementMapper;
import org.junit.Test;
public class TPQStatementLanguageHqlTest {
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;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import java.util.HashMap;
import java.util.Map;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.statement.TPQStatementWriter;
import net.forwardfire.tpquery.statement.language.TPQStatementLanguageSql;
import net.forwardfire.tpquery.store.TPQueryStoreStatementMapper;
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;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.HashMap;
import java.util.Map;
import net.forwardfire.tpquery.TPQManager;
import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.config.TPQConfig;
import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
import org.junit.Test;
public class TPQueryParameterDefaultValueTest {
@Test()
@Test
public void testRawString() throws Exception {
TPQConfig config = TPQFactory
.createConfigBuilder()
@ -44,7 +45,7 @@ public class TPQueryParameterDefaultValueTest {
.setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("test")
.parseStatement("select * from foobar where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.LONG)
.createQueryParameter("a", TPQFactory.ParameterValueType.DOUBLE)
.setDefaultValue("js:epoch()")
.build()
.build()
@ -54,7 +55,7 @@ public class TPQueryParameterDefaultValueTest {
TPQExecutorStatement prepared = store.getQueryExecutorContext().prepareQuery("junit.test", para);
assertTrue(!prepared.getParameters().isEmpty());
assertTrue(prepared.getParameters().get(0) != null);
assertTrue(prepared.getParameters().get(0) instanceof Long);
assertTrue(prepared.getParameters().get(0) instanceof Double);
}
@Test()
@ -121,20 +122,22 @@ public class TPQueryParameterDefaultValueTest {
assertTrue(prepared.getParameters().get(0) instanceof java.lang.Integer);
}
@Test(expected=Exception.class)
@Test
public void testCreateObjectConstructorWrongClass() throws Exception {
TPQManager store = 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:createObject(java.lang.StringNotFound,'foobar')")
assertThrows(Exception.class, () -> {
TPQManager store = 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:createObject(java.lang.StringNotFound,'foobar')")
.build()
.build()
.build()
.build()
.build();
store.getQueryExecutorContext().prepareQuery("junit.test", new HashMap<String,Object>());
.build()
.build();
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;
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.Arrays;
@ -8,10 +9,10 @@ import java.util.HashMap;
import java.util.List;
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.TPQManager;
import net.forwardfire.tpquery.model.TPQuery;
import net.forwardfire.tpquery.model.TPQueryParameter;
import net.forwardfire.tpquery.model.TPQuerySet;
@ -20,67 +21,73 @@ import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
public class TPQueryParameterTypeListTest {
@Test(expected=NullPointerException.class)
@Test
public void testNullValue() throws Exception {
TPQuery q = new TPQuery();
q.setName("test");
q.addQueryPart(new TPQStatementPartParameter("param"));
TPQueryParameter qp = new TPQueryParameter();
qp.setType(TPQFactory.StatementParameter.LIST);
qp.setName("param");
//qp.setDefaultValue("1,2,3");
qp.setValueType(TPQFactory.ParameterValueType.INTEGER);
q.addQueryParameter(qp);
TPQuerySet qs = new TPQuerySet("junit");
qs.setLanguage(TPQFactory.StatementLanguage.SQL);
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);
assertThrows(NullPointerException.class, () -> {
TPQuery q = new TPQuery();
q.setName("test");
q.addQueryPart(new TPQStatementPartParameter("param"));
TPQueryParameter qp = new TPQueryParameter();
qp.setType(TPQFactory.StatementParameter.LIST);
qp.setName("param");
//qp.setDefaultValue("1,2,3");
qp.setValueType(TPQFactory.ParameterValueType.INTEGER);
q.addQueryParameter(qp);
TPQuerySet qs = new TPQuerySet("junit");
qs.setLanguage(TPQFactory.StatementLanguage.SQL);
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);
});
}
@Test(expected=IllegalArgumentException.class)
@Test
public void testEmptyValue() throws Exception {
TPQuery q = new TPQuery();
q.setName("test");
q.addQueryPart(new TPQStatementPartParameter("param"));
TPQueryParameter qp = new TPQueryParameter();
qp.setType(TPQFactory.StatementParameter.LIST);
qp.setName("param");
qp.setValueType(TPQFactory.ParameterValueType.INTEGER);
q.addQueryParameter(qp);
TPQuerySet qs = new TPQuerySet("junit");
qs.setLanguage(TPQFactory.StatementLanguage.SQL);
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>());
store.getQueryExecutorContext().prepareQuery("junit.test", para);
assertThrows(IllegalArgumentException.class, () -> {
TPQuery q = new TPQuery();
q.setName("test");
q.addQueryPart(new TPQStatementPartParameter("param"));
TPQueryParameter qp = new TPQueryParameter();
qp.setType(TPQFactory.StatementParameter.LIST);
qp.setName("param");
qp.setValueType(TPQFactory.ParameterValueType.INTEGER);
q.addQueryParameter(qp);
TPQuerySet qs = new TPQuerySet("junit");
qs.setLanguage(TPQFactory.StatementLanguage.SQL);
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>());
store.getQueryExecutorContext().prepareQuery("junit.test", para);
});
}
@Test(expected=IllegalArgumentException.class)
@Test
public void testWrongValue() throws Exception {
TPQuery q = new TPQuery();
q.setName("test");
q.addQueryPart(new TPQStatementPartParameter("param"));
TPQueryParameter qp = new TPQueryParameter();
qp.setType(TPQFactory.StatementParameter.LIST);
qp.setName("param");
qp.setValueType(TPQFactory.ParameterValueType.INTEGER);
q.addQueryParameter(qp);
TPQuerySet qs = new TPQuerySet("junit");
qs.setLanguage(TPQFactory.StatementLanguage.SQL);
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>());
store.getQueryExecutorContext().prepareQuery("junit.test", para);
assertThrows(IllegalArgumentException.class, () -> {
TPQuery q = new TPQuery();
q.setName("test");
q.addQueryPart(new TPQStatementPartParameter("param"));
TPQueryParameter qp = new TPQueryParameter();
qp.setType(TPQFactory.StatementParameter.LIST);
qp.setName("param");
qp.setValueType(TPQFactory.ParameterValueType.INTEGER);
q.addQueryParameter(qp);
TPQuerySet qs = new TPQuerySet("junit");
qs.setLanguage(TPQFactory.StatementLanguage.SQL);
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>());
store.getQueryExecutorContext().prepareQuery("junit.test", para);
});
}
@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;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.HashMap;
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.TPQManager;
import net.forwardfire.tpquery.model.TPQuery;
import net.forwardfire.tpquery.model.TPQueryParameter;
import net.forwardfire.tpquery.model.TPQuerySet;
@ -19,7 +19,7 @@ import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
public class TPQueryParameterTypeRawTest {
@Test()
@Test
public void testTypeRaw() throws Exception {
TPQuery q = new TPQuery();
q.setName("test");
@ -49,7 +49,7 @@ public class TPQueryParameterTypeRawTest {
assertEquals(0,queryPreparedValue.getParameters().size());
}
@Test()
@Test
public void testTypeRawNull() throws Exception {
TPQManager store = TPQFactory.createManagerBuilder()
.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;
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.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.TPQManager;
import net.forwardfire.tpquery.model.TPQuery;
import net.forwardfire.tpquery.model.TPQueryParameter;
import net.forwardfire.tpquery.model.TPQuerySet;
@ -17,36 +18,40 @@ import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
public class TPQueryParameterTypeValueTest {
@Test(expected=NullPointerException.class)
@Test
public void testMissingParameter() throws Exception {
TPQuery q = new TPQuery();
q.setName("test");
q.addQueryPart(new TPQStatementPartParameter("missing-param"));
TPQuerySet qs = new TPQuerySet("junit");
qs.addQuery(q);
TPQManager store = TPQFactory.createManagerBuilder().addQuerySet("jar:junit:mem:testMissingParameter",qs).build();
store.getQueryExecutorContext().prepareQuery("junit.test", null);
assertThrows(NullPointerException.class, () -> {
TPQuery q = new TPQuery();
q.setName("test");
q.addQueryPart(new TPQStatementPartParameter("missing-param"));
TPQuerySet qs = new TPQuerySet("junit");
qs.addQuery(q);
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 {
TPQuery q = new TPQuery();
q.setName("test");
q.addQueryPart(new TPQStatementPartParameter("param"));
TPQueryParameter qp = new TPQueryParameter();
qp.setType(TPQFactory.StatementParameter.VALUE);
qp.setName("param");
qp.setValueType(TPQFactory.ParameterValueType.INTEGER);
q.addQueryParameter(qp);
TPQuerySet qs = new TPQuerySet("junit");
qs.setLanguage(TPQFactory.StatementLanguage.SQL);
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");
store.getQueryExecutorContext().prepareQuery("junit.test", paraValue);
assertThrows(IllegalArgumentException.class, () -> {
TPQuery q = new TPQuery();
q.setName("test");
q.addQueryPart(new TPQStatementPartParameter("param"));
TPQueryParameter qp = new TPQueryParameter();
qp.setType(TPQFactory.StatementParameter.VALUE);
qp.setName("param");
qp.setValueType(TPQFactory.ParameterValueType.INTEGER);
q.addQueryParameter(qp);
TPQuerySet qs = new TPQuerySet("junit");
qs.setLanguage(TPQFactory.StatementLanguage.SQL);
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");
store.getQueryExecutorContext().prepareQuery("junit.test", paraValue);
});
}
@Test()

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

@ -1,17 +1,17 @@
package net.forwardfire.tpquery.store;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Map;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.config.TPQConfig;
import org.junit.jupiter.api.Test;
import org.junit.Test;
import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.config.TPQConfig;
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;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.io.File;
import java.io.FileInputStream;
@ -15,15 +16,15 @@ import java.util.HashMap;
import java.util.Map;
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.TPQManager;
import net.forwardfire.tpquery.config.TPQConfig;
import net.forwardfire.tpquery.statement.parameter.TPQStatementParameterListMapper;
import net.forwardfire.tpquery.statement.parameter.TPQStatementParameterValueMapper;
import net.forwardfire.tpquery.store.TPQueryStoreStatement;
import org.junit.Test;
public class TPQStoreManagerStatementCacheTest {
private Lock createFailingLock(boolean lockOke) {
@ -40,140 +41,152 @@ public class TPQStoreManagerStatementCacheTest {
}
@SuppressWarnings("serial")
@Test(expected=IllegalStateException.class)
@Test
public void testCacheFailPut() throws Exception {
TPQConfig config = TPQFactory.createConfig();
Map<String,TPQueryStoreStatement> cc = new HashMap<String,TPQueryStoreStatement>() {
@Override
public TPQueryStoreStatement put(String key,TPQueryStoreStatement value) {
throw new IllegalStateException();
}
};
config.setStatementCache(new TPQStoreManagerStatementCache(cc));
TPQManager queryManager = TPQFactory
.createManagerBuilder(config)
.createQuerySet("junit", "jar:mem:test")
.setLanguage("SQL")
.createQuery("test")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build()
assertThrows(IllegalStateException.class, () -> {
TPQConfig config = TPQFactory.createConfig();
Map<String,TPQueryStoreStatement> cc = new HashMap<String,TPQueryStoreStatement>() {
@Override
public TPQueryStoreStatement put(String key,TPQueryStoreStatement value) {
throw new IllegalStateException();
}
};
config.setStatementCache(new TPQStoreManagerStatementCache(cc));
TPQManager queryManager = TPQFactory
.createManagerBuilder(config)
.createQuerySet("junit", "jar:mem:test")
.setLanguage("SQL")
.createQuery("test")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build()
.build()
.build()
.build()
.build();
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
.build();
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
});
}
@Test(expected=IllegalStateException.class)
@Test
public void testCacheFailPutLock() throws Exception {
TPQConfig config = TPQFactory.createConfig();
config.setStatementCache(new TPQStoreManagerStatementCache(new HashMap<String,TPQueryStoreStatement>()) {
@Override
protected Lock getWriteLock() {
return createFailingLock(false);
}
});
TPQManager queryManager = TPQFactory
.createManagerBuilder(config)
.createQuerySet("junit", "jar:mem:test")
.setLanguage("SQL")
.createQuery("test")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build()
assertThrows(IllegalStateException.class, () -> {
TPQConfig config = TPQFactory.createConfig();
config.setStatementCache(new TPQStoreManagerStatementCache(new HashMap<String,TPQueryStoreStatement>()) {
@Override
protected Lock getWriteLock() {
return createFailingLock(false);
}
});
TPQManager queryManager = TPQFactory
.createManagerBuilder(config)
.createQuerySet("junit", "jar:mem:test")
.setLanguage("SQL")
.createQuery("test")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build()
.build()
.build()
.build()
.build();
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
.build();
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
});
}
@Test(expected=IllegalStateException.class)
@Test
public void testCacheFailPutUnlock() throws Exception {
TPQConfig config = TPQFactory.createConfig();
config.setStatementCache(new TPQStoreManagerStatementCache(new HashMap<String,TPQueryStoreStatement>()) {
@Override
protected Lock getWriteLock() {
return createFailingLock(true);
}
});
TPQManager queryManager = TPQFactory
.createManagerBuilder(config)
.createQuerySet("junit", "jar:mem:test")
.setLanguage("SQL")
.createQuery("test")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build()
assertThrows(IllegalStateException.class, () -> {
TPQConfig config = TPQFactory.createConfig();
config.setStatementCache(new TPQStoreManagerStatementCache(new HashMap<String,TPQueryStoreStatement>()) {
@Override
protected Lock getWriteLock() {
return createFailingLock(true);
}
});
TPQManager queryManager = TPQFactory
.createManagerBuilder(config)
.createQuerySet("junit", "jar:mem:test")
.setLanguage("SQL")
.createQuery("test")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build()
.build()
.build()
.build()
.build();
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
.build();
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
});
}
@SuppressWarnings("serial")
@Test(expected=IllegalStateException.class)
@Test
public void testCacheFailGet() throws Exception {
TPQConfig config = TPQFactory.createConfig();
Map<String,TPQueryStoreStatement> cc = new HashMap<String,TPQueryStoreStatement>() {
@Override
public TPQueryStoreStatement get(Object key) {
throw new IllegalStateException();
}
};
config.setStatementCache(new TPQStoreManagerStatementCache(cc));
TPQManager queryManager = TPQFactory
.createManagerBuilder(config)
.createQuerySet("junit", "jar:mem:test")
.setLanguage("SQL")
.createQuery("test")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build()
assertThrows(IllegalStateException.class, () -> {
TPQConfig config = TPQFactory.createConfig();
Map<String,TPQueryStoreStatement> cc = new HashMap<String,TPQueryStoreStatement>() {
@Override
public TPQueryStoreStatement get(Object key) {
throw new IllegalStateException();
}
};
config.setStatementCache(new TPQStoreManagerStatementCache(cc));
TPQManager queryManager = TPQFactory
.createManagerBuilder(config)
.createQuerySet("junit", "jar:mem:test")
.setLanguage("SQL")
.createQuery("test")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build()
.build()
.build()
.build()
.build();
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
.build();
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
});
}
@Test(expected=IllegalStateException.class)
@Test
public void testCacheFailGetLock() throws Exception {
TPQConfig config = TPQFactory.createConfig();
config.setStatementCache(new TPQStoreManagerStatementCache(new HashMap<String,TPQueryStoreStatement>()) {
@Override
protected Lock getWriteLock() {
return createFailingLock(false);
}
});
TPQManager queryManager = TPQFactory
.createManagerBuilder(config)
.createQuerySet("junit", "jar:mem:test")
.setLanguage("SQL")
.createQuery("test")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build()
assertThrows(IllegalStateException.class, () -> {
TPQConfig config = TPQFactory.createConfig();
config.setStatementCache(new TPQStoreManagerStatementCache(new HashMap<String,TPQueryStoreStatement>()) {
@Override
protected Lock getWriteLock() {
return createFailingLock(false);
}
});
TPQManager queryManager = TPQFactory
.createManagerBuilder(config)
.createQuerySet("junit", "jar:mem:test")
.setLanguage("SQL")
.createQuery("test")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build()
.build()
.build()
.build()
.build();
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
.build();
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
});
}
@Test(expected=IllegalStateException.class)
@Test
public void testCacheFailGetUnlock() throws Exception {
TPQConfig config = TPQFactory.createConfig();
config.setStatementCache(new TPQStoreManagerStatementCache(new HashMap<String,TPQueryStoreStatement>()) {
@Override
protected Lock getWriteLock() {
return createFailingLock(true);
}
});
TPQManager queryManager = TPQFactory
.createManagerBuilder(config)
.createQuerySet("junit", "jar:mem:test")
.setLanguage("SQL")
.createQuery("test")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build()
assertThrows(IllegalStateException.class, () -> {
TPQConfig config = TPQFactory.createConfig();
config.setStatementCache(new TPQStoreManagerStatementCache(new HashMap<String,TPQueryStoreStatement>()) {
@Override
protected Lock getWriteLock() {
return createFailingLock(true);
}
});
TPQManager queryManager = TPQFactory
.createManagerBuilder(config)
.createQuerySet("junit", "jar:mem:test")
.setLanguage("SQL")
.createQuery("test")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build()
.build()
.build()
.build()
.build();
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
.build();
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
});
}
@ -217,72 +230,78 @@ public class TPQStoreManagerStatementCacheTest {
assertEquals(cache.size(),cache2.size());
}
@Test(expected=Exception.class)
@Test
public void testCacheStatementReadObjectNoData() throws Exception {
Map<String,TPQueryStoreStatement> cache = new HashMap<>();
TPQConfig config = TPQFactory.createConfig();
config.setStatementCache(new TPQStoreManagerStatementCache(cache));
TPQManager queryManager = TPQFactory
.createManagerBuilder(config)
.createQuerySet("junit", "jar:mem:test")
.setLanguage("SQL")
.createQuery("test")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build()
assertThrows(Exception.class, () -> {
Map<String,TPQueryStoreStatement> cache = new HashMap<>();
TPQConfig config = TPQFactory.createConfig();
config.setStatementCache(new TPQStoreManagerStatementCache(cache));
TPQManager queryManager = TPQFactory
.createManagerBuilder(config)
.createQuerySet("junit", "jar:mem:test")
.setLanguage("SQL")
.createQuery("test")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build()
.build()
.build()
.build()
.build();
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
TPQueryStoreStatement c = cache.values().iterator().next();
assertNotNull(c);
Method m = TPQueryStoreStatement.class.getDeclaredMethod("readObjectNoData", new Class<?>[]{});
m.setAccessible(true);
m.invoke(c, new Object[]{});
.build();
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
TPQueryStoreStatement c = cache.values().iterator().next();
assertNotNull(c);
Method m = TPQueryStoreStatement.class.getDeclaredMethod("readObjectNoData", new Class<?>[]{});
m.setAccessible(true);
m.invoke(c, new Object[]{});
});
}
@Test(expected=Exception.class)
@Test
public void testCacheValueMapperReadObjectNoData() throws Exception {
Map<String,TPQueryStoreStatement> cache = new HashMap<>();
TPQConfig config = TPQFactory.createConfig();
config.setStatementCache(new TPQStoreManagerStatementCache(cache));
TPQManager queryManager = TPQFactory
.createManagerBuilder(config)
.createQuerySet("junit", "jar:mem:test")
.setLanguage("SQL")
.createQuery("test")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build()
assertThrows(Exception.class, () -> {
Map<String,TPQueryStoreStatement> cache = new HashMap<>();
TPQConfig config = TPQFactory.createConfig();
config.setStatementCache(new TPQStoreManagerStatementCache(cache));
TPQManager queryManager = TPQFactory
.createManagerBuilder(config)
.createQuerySet("junit", "jar:mem:test")
.setLanguage("SQL")
.createQuery("test")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setDefaultValue("a").build()
.build()
.build()
.build()
.build();
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
TPQueryStoreStatement c = cache.values().iterator().next();
assertNotNull(c);
Method m = TPQStatementParameterValueMapper.class.getDeclaredMethod("readObjectNoData", new Class<?>[]{});
m.setAccessible(true);
m.invoke(c.getValueMapping().get(0), new Object[]{});
.build();
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
TPQueryStoreStatement c = cache.values().iterator().next();
assertNotNull(c);
Method m = TPQStatementParameterValueMapper.class.getDeclaredMethod("readObjectNoData", new Class<?>[]{});
m.setAccessible(true);
m.invoke(c.getValueMapping().get(0), new Object[]{});
});
}
@Test(expected=Exception.class)
@Test
public void testCacheListMapperReadObjectNoData() throws Exception {
Map<String,TPQueryStoreStatement> cache = new HashMap<>();
TPQConfig config = TPQFactory.createConfig();
config.setStatementCache(new TPQStoreManagerStatementCache(cache));
TPQManager queryManager = TPQFactory
.createManagerBuilder(config)
.createQuerySet("junit", "jar:mem:test")
.setLanguage("SQL")
.createQuery("test")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setType("LIST").setDefaultValue("1,2,3").build()
assertThrows(Exception.class, () -> {
Map<String,TPQueryStoreStatement> cache = new HashMap<>();
TPQConfig config = TPQFactory.createConfig();
config.setStatementCache(new TPQStoreManagerStatementCache(cache));
TPQManager queryManager = TPQFactory
.createManagerBuilder(config)
.createQuerySet("junit", "jar:mem:test")
.setLanguage("SQL")
.createQuery("test")
.parseStatement("select * from table where a=$$a$$")
.createQueryParameter("a", TPQFactory.ParameterValueType.STRING).setType("LIST").setDefaultValue("1,2,3").build()
.build()
.build()
.build()
.build();
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
TPQueryStoreStatement c = cache.values().iterator().next();
assertNotNull(c);
Method m = TPQStatementParameterListMapper.class.getDeclaredMethod("readObjectNoData", new Class<?>[]{});
m.setAccessible(true);
m.invoke(c.getValueMapping().get(0), new Object[]{});
.build();
queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
TPQueryStoreStatement c = cache.values().iterator().next();
assertNotNull(c);
Method m = TPQStatementParameterListMapper.class.getDeclaredMethod("readObjectNoData", new Class<?>[]{});
m.setAccessible(true);
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;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.HashMap;
import net.forwardfire.tpquery.TPQManager;
import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.TPQManager;
import net.forwardfire.tpquery.config.TPQConfig;
import net.forwardfire.tpquery.config.TPQConfigException;
import net.forwardfire.tpquery.store.TPQueryStoreScriptEngineException;
import org.junit.Test;
public class TPQStoreManagerTest {
@Test(expected=TPQueryStoreScriptEngineException.class)
@Test
public void testParameterValueScriptError() throws Exception {
TPQConfig config = TPQFactory.createConfig();
config.addParameterValueScript("throw 'error'");
TPQFactory
.createManagerBuilder(config)
.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:time()")
assertThrows(TPQueryStoreScriptEngineException.class, () -> {
TPQConfig config = TPQFactory.createConfig();
config.addParameterValueScript("throw 'error'");
TPQFactory
.createManagerBuilder(config)
.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: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();
}
@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();
manager.getQueryExecutorContext().prepareQuery("junit.test", new HashMap<String,Object>());
.build();
manager.getQueryExecutorContext().prepareQuery("junit.test", new HashMap<String,Object>());
});
}
@Test(expected=Exception.class)
@Test
public void testRuntimeScriptError() 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:throw createObject(java.lang.String,'error')")
assertThrows(Exception.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:throw createObject(java.lang.String,'error')")
.build()
.build()
.build()
.build()
.build();
manager.getQueryExecutorContext().prepareQuery("junit.test", new HashMap<String,Object>());
.build();
manager.getQueryExecutorContext().prepareQuery("junit.test", new HashMap<String,Object>());
});
}
@Test(expected=TPQConfigException.class)
@Test
public void testConfigErrorByTPQStoreManagerConfig() throws Exception {
assertThrows(TPQConfigException.class, () ->
TPQFactory.createManagerBuilder()
.createQuerySet("junit", "jar:junit:mem")
.setLanguage(TPQFactory.StatementLanguage.SQL)
@ -75,26 +84,27 @@ public class TPQStoreManagerTest {
.build()
.build()
.build()
.build();
.build());
}
@Test(expected=TPQConfigException.class)
@Test
public void testConfigErrorByTPQStoreManager() throws Exception {
TPQConfig c = TPQFactory.createConfigBuilder()
.createQuerySet("junit", "jar:junit:mem")
.setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("test")
.parseStatement("select * from foobar where a=$$a$$")
.createQueryParameter("a", "java.lang.String")
assertThrows(TPQConfigException.class, () -> {
TPQConfig c = TPQFactory.createConfigBuilder()
.createQuerySet("junit", "jar:junit:mem")
.setLanguage(TPQFactory.StatementLanguage.SQL)
.createQuery("test")
.parseStatement("select * from foobar where a=$$a$$")
.createQueryParameter("a", "java.lang.String")
.build()
.build()
.build()
.build()
.build();
TPQStoreManagerConfig smc = new TPQStoreManagerConfig(c);
smc.getEntries().get("junit.test").getQuery().getQueryParameters().get(0).setValueType("net.foo.bar.NoneExcistingClass");
new TPQStoreManager(smc);
.build();
TPQStoreManagerConfig smc = new TPQStoreManagerConfig(c);
smc.getEntries().get("junit.test").getQuery().getQueryParameters().get(0).setValueType("net.foo.bar.NoneExcistingClass");
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;
import static org.junit.Assert.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import java.util.ArrayList;
import java.util.List;
import org.junit.jupiter.api.Test;
import net.forwardfire.tpquery.TPQFactory;
import net.forwardfire.tpquery.TPQManager;
import org.junit.Test;
public class TPQueryProxyFactoryTest {
@Test()