bit-badger/solutions.bitbadger.documents
1
0
Fork 0
Code Issues Pull Requests Packages Releases 1 Activity

Initial Development #1

Merged
danieljsummers merged 88 commits from v1-rc into main 2025-04-16 01:29:20 +00:00
Conversation 0 Commits 88 Files Changed 385 +11626 -1574
363 changed files with 11626 additions and 1574 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 50188d939e - Show all commits

13
.idea/compiler.xml generated
View File

@ -6,13 +6,20 @@
<sourceOutputDir name="target/generated-sources/annotations" />
<sourceTestOutputDir name="target/generated-test-sources/test-annotations" />
<outputRelativeToContentRoot value="true" />
<module name="jvm" />
<module name="kotlin" />
<module name="core" />
<module name="groovy" />
<module name="scala" />
<module name="kotlinx" />
</profile>
</annotationProcessing>
<bytecodeTargetLevel>
<module name="common" target="1.8" />
<module name="documents" target="9" />
<module name="core8" target="1.8" />
<module name="documents" target="1.5" />
<module name="documents (2)" target="1.5" />
<module name="java" target="17" />
<module name="jvm" target="11" />
<module name="kotlin" target="17" />
<module name="sqlite" target="1.8" />
</bytecodeTargetLevel>
</component>

17
.idea/encodings.xml generated
View File

@ -1,13 +1,30 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="Encoding">
<file url="file://$PROJECT_DIR$/core/src/main/kotlin" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/core/src/main/resources" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/core/src/main/java" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/core/src/main/kotlin" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/core/src/main/resources" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/groovy/src/main/groovy" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/groovy/src/main/java" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/groovy/src/main/resources" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/java/src/main/java" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/java/src/main/kotlin" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/java/src/main/resources" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/jvm/src/main/kotlin" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/jvm/src/main/resources" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/kotlin/src/main/kotlin" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/kotlin/src/main/resources" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/kotlinx/src/main/java" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/kotlinx/src/main/kotlin" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/kotlinx/src/main/resources" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/main/java" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/main/kotlin" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/main/resources" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/scala/src/main/java" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/scala/src/main/resources" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/scala/src/main/scala" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/sqlite/src/main/kotlin" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/sqlite/src/main/resources" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/src/main/java" charset="UTF-8" />

12
.idea/kotlinc.xml generated
View File

@ -1,6 +1,16 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="Kotlin2JsCompilerArguments">
<option name="moduleKind" value="plain" />
</component>
<component name="Kotlin2JvmCompilerArguments">
<option name="jvmTarget" value="17" />
</component>
<component name="KotlinCommonCompilerArguments">
<option name="apiVersion" value="2.1" />
<option name="languageVersion" value="2.1" />
</component>
<component name="KotlinJpsPluginSettings">
<option name="version" value="2.1.10" />
<option name="version" value="2.1.20" />
</component>
</project>

4
.idea/modules.xml generated
View File

@ -2,7 +2,9 @@
<project version="4">
<component name="ProjectModuleManager">
<modules>
<module fileurl="file://$PROJECT_DIR$/src/jvm/jvm.iml" filepath="$PROJECT_DIR$/src/jvm/jvm.iml" />
<module fileurl="file://$PROJECT_DIR$/src/core/core.iml" filepath="$PROJECT_DIR$/src/core/core.iml" />
<module fileurl="file://$PROJECT_DIR$/src/groovy/groovy.iml" filepath="$PROJECT_DIR$/src/groovy/groovy.iml" />
<module fileurl="file://$PROJECT_DIR$/src/scala/scala.iml" filepath="$PROJECT_DIR$/src/scala/scala.iml" />
</modules>
</component>
</project>

2
.idea/scala_compiler.xml generated
View File

@ -2,6 +2,6 @@
<project version="4">
<component name="ScalaCompilerConfiguration">
<option name="incrementalityType" value="IDEA" />
<profile name="Maven 1" modules="jvm" />
<profile name="Maven 1" modules="core,jvm,scala" />
</component>
</project>

8
java.iml Normal file
View File

@ -0,0 +1,8 @@
<?xml version="1.0" encoding="UTF-8"?>
<module version="4">
<component name="AdditionalModuleElements">
<content url="file://$MODULE_DIR$/src/java" dumb="true">
<sourceFolder url="file://$MODULE_DIR$/src/java/src/main/java" isTestSource="false" />
</content>
</component>
</module>

50
pom.xml
View File

@ -38,13 +38,57 @@
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<kotlin.code.style>official</kotlin.code.style>
<kotlin.compiler.jvmTarget>11</kotlin.compiler.jvmTarget>
<kotlin.version>2.1.0</kotlin.version>
<java.version>17</java.version>
<kotlin.compiler.jvmTarget>${java.version}</kotlin.compiler.jvmTarget>
<kotlin.version>2.1.20</kotlin.version>
<serialization.version>1.8.0</serialization.version>
<scala.version>3.5.2</scala.version>
<groovy.version>4.0.26</groovy.version>
<surefire.version>3.5.2</surefire.version>
<failsafe.version>3.5.2</failsafe.version>
<jackson.version>2.18.2</jackson.version>
<sqlite.version>3.46.1.2</sqlite.version>
<postgresql.version>42.7.5</postgresql.version>
</properties>
<modules>
<module>src</module>
<module>./src/core</module>
<module>./src/groovy</module>
<module>./src/kotlinx</module>
<module>./src/scala</module>
</modules>
<dependencies>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>5.10.0</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.jetbrains.kotlin</groupId>
<artifactId>kotlin-test-junit5</artifactId>
<version>${kotlin.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.xerial</groupId>
<artifactId>sqlite-jdbc</artifactId>
<version>${sqlite.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
<version>2.0.16</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<version>${postgresql.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

8
src/core/core.iml Normal file
View File

@ -0,0 +1,8 @@
<?xml version="1.0" encoding="UTF-8"?>
<module version="4">
<component name="AdditionalModuleElements">
<content url="file://$MODULE_DIR$" dumb="true">
<sourceFolder url="file://$MODULE_DIR$/src/test/java" isTestSource="true" />
</content>
</component>
</module>

119
src/jvm/pom.xml → src/core/pom.xml
View File

@ -3,61 +3,27 @@
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>solutions.bitbadger.documents</groupId>
<artifactId>jvm</artifactId>
<version>4.0.0-alpha1-SNAPSHOT</version>
<packaging>jar</packaging>
<parent>
<groupId>solutions.bitbadger</groupId>
<artifactId>documents</artifactId>
<version>4.0.0-alpha1-SNAPSHOT</version>
<relativePath>../../pom.xml</relativePath>
</parent>
<groupId>solutions.bitbadger.documents</groupId>
<artifactId>core</artifactId>
<name>${project.groupId}:${project.artifactId}</name>
<description>Expose a document store interface for PostgreSQL and SQLite (Standard JVM Library)</description>
<description>Expose a document store interface for PostgreSQL and SQLite (Core Library)</description>
<url>https://bitbadger.solutions/open-source/relational-documents/jvm/</url>
<scm>
<connection>scm:git:https://git.bitbadger.solutions/bit-badger/solutions.bitbadger.documents.git</connection>
<developerConnection>scm:git:https://git.bitbadger.solutions/bit-badger/solutions.bitbadger.documents.git</developerConnection>
<url>https://git.bitbadger.solutions/bit-badger/solutions.bitbadger.documents</url>
</scm>
<properties>
<jackson.version>2.18.2</jackson.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<kotlin.code.style>official</kotlin.code.style>
<kotlin.compiler.jvmTarget>1.8</kotlin.compiler.jvmTarget>
</properties>
<dependencies>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>${jackson.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.scala-lang</groupId>
<artifactId>scala3-library_3</artifactId>
<version>${scala.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.apache.groovy</groupId>
<artifactId>groovy-test</artifactId>
<version>${groovy.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.apache.groovy</groupId>
<artifactId>groovy-test-junit5</artifactId>
<version>${groovy.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<sourceDirectory>src/main/kotlin</sourceDirectory>
<plugins>
<plugin>
<groupId>org.jetbrains.kotlin</groupId>
@ -72,6 +38,7 @@
</goals>
<configuration>
<sourceDirs>
<sourceDir>${project.basedir}/src/main/java</sourceDir>
<sourceDir>${project.basedir}/src/main/kotlin</sourceDir>
</sourceDirs>
</configuration>
@ -84,62 +51,20 @@
</goals>
<configuration>
<sourceDirs>
<sourceDir>${project.basedir}/src/test/kotlin</sourceDir>
<sourceDir>${project.basedir}/src/test/java</sourceDir>
<sourceDir>${project.basedir}/src/test/scala</sourceDir>
<sourceDir>${project.basedir}/src/test/kotlin</sourceDir>
</sourceDirs>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<groupId>net.alchim31.maven</groupId>
<artifactId>scala-maven-plugin</artifactId>
<version>4.9.2</version>
<executions>
<execution>
<goals>
<goal>testCompile</goal>
</goals>
</execution>
</executions>
<configuration>
<source>${java.version}</source>
<target>${java.version}</target>
</configuration>
</plugin>
<plugin>
<groupId>org.codehaus.gmaven</groupId>
<artifactId>gmaven-plugin</artifactId>
<version>1.5</version>
<configuration>
<source>${java.version}</source>
</configuration>
<executions>
<execution>
<configuration>
<providerSelection>2.0</providerSelection>
</configuration>
<goals>
<goal>generateTestStubs</goal>
<goal>testCompile</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.22.2</version>
<configuration>
<argLine>
--add-opens=java.base/java.lang=ALL-UNNAMED
--add-opens=java.base/java.util=ALL-UNNAMED
</argLine>
</configuration>
<version>${surefire.version}</version>
</plugin>
<plugin>
<artifactId>maven-failsafe-plugin</artifactId>
<version>2.22.2</version>
<version>${failsafe.version}</version>
<executions>
<execution>
<goals>
@ -160,4 +85,24 @@
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>org.jetbrains.kotlin</groupId>
<artifactId>kotlin-stdlib</artifactId>
<version>${kotlin.version}</version>
</dependency>
<dependency>
<groupId>org.jetbrains.kotlin</groupId>
<artifactId>kotlin-reflect</artifactId>
<version>${kotlin.version}</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>${jackson.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

9
src/core/src/main/java/module-info.java Normal file
View File

@ -0,0 +1,9 @@
module solutions.bitbadger.documents.core {
requires kotlin.stdlib;
requires kotlin.reflect;
requires java.sql;
exports solutions.bitbadger.documents;
exports solutions.bitbadger.documents.java;
exports solutions.bitbadger.documents.java.extensions;
exports solutions.bitbadger.documents.query;
}

0
src/jvm/src/main/kotlin/AutoId.kt → src/core/src/main/kotlin/AutoId.kt
View File

0
src/jvm/src/main/kotlin/Comparison.kt → src/core/src/main/kotlin/Comparison.kt
View File

0
src/jvm/src/main/kotlin/Configuration.kt → src/core/src/main/kotlin/Configuration.kt
View File

0
src/jvm/src/main/kotlin/Dialect.kt → src/core/src/main/kotlin/Dialect.kt
View File

0
src/jvm/src/main/kotlin/DocumentException.kt → src/core/src/main/kotlin/DocumentException.kt
View File

0
src/jvm/src/main/kotlin/DocumentIndex.kt → src/core/src/main/kotlin/DocumentIndex.kt
View File

0
src/jvm/src/main/kotlin/DocumentSerializer.kt → src/core/src/main/kotlin/DocumentSerializer.kt
View File

0
src/jvm/src/main/kotlin/Field.kt → src/core/src/main/kotlin/Field.kt
View File

0
src/jvm/src/main/kotlin/FieldFormat.kt → src/core/src/main/kotlin/FieldFormat.kt
View File

0
src/jvm/src/main/kotlin/FieldMatch.kt → src/core/src/main/kotlin/FieldMatch.kt
View File

0
src/jvm/src/main/kotlin/Op.kt → src/core/src/main/kotlin/Op.kt
View File

0
src/jvm/src/main/kotlin/Parameter.kt → src/core/src/main/kotlin/Parameter.kt
View File

0
src/jvm/src/main/kotlin/ParameterName.kt → src/core/src/main/kotlin/ParameterName.kt
View File

0
src/jvm/src/main/kotlin/ParameterType.kt → src/core/src/main/kotlin/ParameterType.kt
View File

14
src/jvm/src/main/kotlin/jvm/Count.kt → src/core/src/main/kotlin/java/Count.kt
View File

@ -1,8 +1,7 @@
package solutions.bitbadger.documents.jvm
package solutions.bitbadger.documents.java
import solutions.bitbadger.documents.*
import solutions.bitbadger.documents.query.CountQuery
import solutions.bitbadger.documents.extensions.customScalar
import java.sql.Connection
import kotlin.jvm.Throws
@ -22,7 +21,7 @@ object Count {
@Throws(DocumentException::class)
@JvmStatic
fun all(tableName: String, conn: Connection) =
conn.customScalar(CountQuery.all(tableName), listOf(), Long::class.java, Results::toCount)
Custom.scalar(CountQuery.all(tableName), listOf(), Long::class.java, conn, Results::toCount)
/**
* Count all documents in the table
@ -56,10 +55,11 @@ object Count {
conn: Connection
): Long {
val named = Parameters.nameFields(fields)
return conn.customScalar(
return Custom.scalar(
CountQuery.byFields(tableName, named, howMatched),
Parameters.addFields(named),
Long::class.java,
conn,
Results::toCount
)
}
@ -91,10 +91,11 @@ object Count {
@Throws(DocumentException::class)
@JvmStatic
fun <TContains> byContains(tableName: String, criteria: TContains, conn: Connection) =
conn.customScalar(
Custom.scalar(
CountQuery.byContains(tableName),
listOf(Parameters.json(":criteria", criteria)),
Long::class.java,
conn,
Results::toCount
)
@ -123,10 +124,11 @@ object Count {
@Throws(DocumentException::class)
@JvmStatic
fun byJsonPath(tableName: String, path: String, conn: Connection) =
conn.customScalar(
Custom.scalar(
CountQuery.byJsonPath(tableName),
listOf(Parameter(":path", ParameterType.STRING, path)),
Long::class.java,
conn,
Results::toCount
)

30
src/jvm/src/main/kotlin/jvm/Custom.kt → src/core/src/main/kotlin/java/Custom.kt
View File

@ -1,10 +1,12 @@
package solutions.bitbadger.documents.jvm
package solutions.bitbadger.documents.java
import solutions.bitbadger.documents.Configuration
import solutions.bitbadger.documents.DocumentException
import solutions.bitbadger.documents.Parameter
import java.sql.Connection
import java.sql.ResultSet
import java.sql.SQLException
import java.util.*
import kotlin.jvm.Throws
object Custom {
@ -57,7 +59,7 @@ object Custom {
* @param clazz The class of the document to be returned
* @param conn The connection over which the query should be executed
* @param mapFunc The mapping function between the document and the domain item
* @return The document if one matches the query, `null` otherwise
* @return An `Optional` value, with the document if one matches the query
* @throws DocumentException If parameters are invalid
*/
@Throws(DocumentException::class)
@ -68,7 +70,7 @@ object Custom {
clazz: Class<TDoc>,
conn: Connection,
mapFunc: (ResultSet, Class<TDoc>) -> TDoc
) = list("$query LIMIT 1", parameters, clazz, conn, mapFunc).singleOrNull()
) = Optional.ofNullable(list("$query LIMIT 1", parameters, clazz, conn, mapFunc).singleOrNull())
/**
* Execute a query that returns one or no results
@ -95,12 +97,16 @@ object Custom {
* @param query The query to retrieve the results
* @param conn The connection over which the query should be executed
* @param parameters Parameters to use for the query
* @throws DocumentException If parameters are invalid
* @throws DocumentException If parameters are invalid or if the query fails
*/
@Throws(DocumentException::class)
@JvmStatic
fun nonQuery(query: String, parameters: Collection<Parameter<*>> = listOf(), conn: Connection) {
Parameters.apply(conn, query, parameters).use { it.executeUpdate() }
try {
Parameters.apply(conn, query, parameters).use { it.executeUpdate() }
} catch (ex: SQLException) {
throw DocumentException("Unable to execute non-query: ${ex.message}", ex)
}
}
/**
@ -108,7 +114,7 @@ object Custom {
*
* @param query The query to retrieve the results
* @param parameters Parameters to use for the query
* @throws DocumentException If no connection string has been set, or if parameters are invalid
* @throws DocumentException If no connection string has been set, if parameters are invalid, or if the query fails
*/
@Throws(DocumentException::class)
@JvmStatic
@ -124,7 +130,7 @@ object Custom {
* @param conn The connection over which the query should be executed
* @param mapFunc The mapping function between the document and the domain item
* @return The scalar value from the query
* @throws DocumentException If parameters are invalid
* @throws DocumentException If parameters are invalid or if the query fails
*/
@Throws(DocumentException::class)
@JvmStatic
@ -135,9 +141,13 @@ object Custom {
conn: Connection,
mapFunc: (ResultSet, Class<T>) -> T
) = Parameters.apply(conn, query, parameters).use { stmt ->
stmt.executeQuery().use { rs ->
rs.next()
mapFunc(rs, clazz)
try {
stmt.executeQuery().use { rs ->
rs.next()
mapFunc(rs, clazz)
}
} catch (ex: SQLException) {
throw DocumentException("Unable to retrieve scalar value: ${ex.message}", ex)
}
}

11
src/jvm/src/main/kotlin/jvm/Definition.kt → src/core/src/main/kotlin/java/Definition.kt
View File

@ -1,9 +1,8 @@
package solutions.bitbadger.documents.jvm
package solutions.bitbadger.documents.java
import solutions.bitbadger.documents.Configuration
import solutions.bitbadger.documents.DocumentException
import solutions.bitbadger.documents.DocumentIndex
import solutions.bitbadger.documents.extensions.customNonQuery
import solutions.bitbadger.documents.query.DefinitionQuery
import java.sql.Connection
import kotlin.jvm.Throws
@ -24,8 +23,8 @@ object Definition {
@JvmStatic
fun ensureTable(tableName: String, conn: Connection) =
Configuration.dialect("ensure $tableName exists").let {
conn.customNonQuery(DefinitionQuery.ensureTable(tableName, it))
conn.customNonQuery(DefinitionQuery.ensureKey(tableName, it))
Custom.nonQuery(DefinitionQuery.ensureTable(tableName, it), conn = conn)
Custom.nonQuery(DefinitionQuery.ensureKey(tableName, it), conn = conn)
}
/**
@ -51,7 +50,7 @@ object Definition {
@Throws(DocumentException::class)
@JvmStatic
fun ensureFieldIndex(tableName: String, indexName: String, fields: Collection<String>, conn: Connection) =
conn.customNonQuery(DefinitionQuery.ensureIndexOn(tableName, indexName, fields))
Custom.nonQuery(DefinitionQuery.ensureIndexOn(tableName, indexName, fields), conn = conn)
/**
* Create an index on field(s) within documents in the specified table if necessary
@ -77,7 +76,7 @@ object Definition {
@Throws(DocumentException::class)
@JvmStatic
fun ensureDocumentIndex(tableName: String, indexType: DocumentIndex, conn: Connection) =
conn.customNonQuery(DefinitionQuery.ensureDocumentIndexOn(tableName, indexType))
Custom.nonQuery(DefinitionQuery.ensureDocumentIndexOn(tableName, indexType), conn = conn)
/**
* Create a document index on a table (PostgreSQL only)

14
src/jvm/src/main/kotlin/jvm/Delete.kt → src/core/src/main/kotlin/java/Delete.kt
View File

@ -1,7 +1,6 @@
package solutions.bitbadger.documents.jvm
package solutions.bitbadger.documents.java
import solutions.bitbadger.documents.*
import solutions.bitbadger.documents.extensions.customNonQuery
import solutions.bitbadger.documents.query.DeleteQuery
import java.sql.Connection
import kotlin.jvm.Throws
@ -22,9 +21,10 @@ object Delete {
@Throws(DocumentException::class)
@JvmStatic
fun <TKey> byId(tableName: String, docId: TKey, conn: Connection) =
conn.customNonQuery(
Custom.nonQuery(
DeleteQuery.byId(tableName, docId),
Parameters.addFields(listOf(Field.equal(Configuration.idField, docId, ":id")))
Parameters.addFields(listOf(Field.equal(Configuration.idField, docId, ":id"))),
conn
)
/**
@ -53,7 +53,7 @@ object Delete {
@JvmOverloads
fun byFields(tableName: String, fields: Collection<Field<*>>, howMatched: FieldMatch? = null, conn: Connection) {
val named = Parameters.nameFields(fields)
conn.customNonQuery(DeleteQuery.byFields(tableName, named, howMatched), Parameters.addFields(named))
Custom.nonQuery(DeleteQuery.byFields(tableName, named, howMatched), Parameters.addFields(named), conn)
}
/**
@ -81,7 +81,7 @@ object Delete {
@Throws(DocumentException::class)
@JvmStatic
fun <TContains> byContains(tableName: String, criteria: TContains, conn: Connection) =
conn.customNonQuery(DeleteQuery.byContains(tableName), listOf(Parameters.json(":criteria", criteria)))
Custom.nonQuery(DeleteQuery.byContains(tableName), listOf(Parameters.json(":criteria", criteria)), conn)
/**
* Delete documents using a JSON containment query (PostgreSQL only)
@ -106,7 +106,7 @@ object Delete {
@Throws(DocumentException::class)
@JvmStatic
fun byJsonPath(tableName: String, path: String, conn: Connection) =
conn.customNonQuery(DeleteQuery.byJsonPath(tableName), listOf(Parameter(":path", ParameterType.STRING, path)))
Custom.nonQuery(DeleteQuery.byJsonPath(tableName), listOf(Parameter(":path", ParameterType.STRING, path)), conn)
/**
* Delete documents using a JSON Path match query (PostgreSQL only)

12
src/jvm/src/main/kotlin/jvm/Document.kt → src/core/src/main/kotlin/java/Document.kt
View File

@ -1,10 +1,9 @@
package solutions.bitbadger.documents.jvm
package solutions.bitbadger.documents.java
import solutions.bitbadger.documents.AutoId
import solutions.bitbadger.documents.Configuration
import solutions.bitbadger.documents.DocumentException
import solutions.bitbadger.documents.Field
import solutions.bitbadger.documents.extensions.customNonQuery
import solutions.bitbadger.documents.query.DocumentQuery
import solutions.bitbadger.documents.query.Where
import solutions.bitbadger.documents.query.statementWhere
@ -33,7 +32,7 @@ object Document {
} else {
DocumentQuery.insert(tableName, strategy)
}
conn.customNonQuery(query, listOf(Parameters.json(":data", document)))
Custom.nonQuery(query, listOf(Parameters.json(":data", document)), conn)
}
/**
@ -60,7 +59,7 @@ object Document {
@Throws(DocumentException::class)
@JvmStatic
fun <TDoc> save(tableName: String, document: TDoc, conn: Connection) =
conn.customNonQuery(DocumentQuery.save(tableName), listOf(Parameters.json(":data", document)))
Custom.nonQuery(DocumentQuery.save(tableName), listOf(Parameters.json(":data", document)), conn)
/**
* Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert")
@ -86,12 +85,13 @@ object Document {
@Throws(DocumentException::class)
@JvmStatic
fun <TKey, TDoc> update(tableName: String, docId: TKey, document: TDoc, conn: Connection) =
conn.customNonQuery(
Custom.nonQuery(
statementWhere(DocumentQuery.update(tableName), Where.byId(":id", docId)),
Parameters.addFields(
listOf(Field.equal(Configuration.idField, docId, ":id")),
mutableListOf(Parameters.json(":data", document))
)
),
conn
)
/**

2
src/jvm/src/main/kotlin/jvm/DocumentConfig.kt → src/core/src/main/kotlin/java/DocumentConfig.kt
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.jvm
package solutions.bitbadger.documents.java
import solutions.bitbadger.documents.DocumentSerializer

15
src/jvm/src/main/kotlin/jvm/Exists.kt → src/core/src/main/kotlin/java/Exists.kt
View File

@ -1,7 +1,6 @@
package solutions.bitbadger.documents.jvm
package solutions.bitbadger.documents.java
import solutions.bitbadger.documents.*
import solutions.bitbadger.documents.extensions.customScalar
import solutions.bitbadger.documents.query.ExistsQuery
import java.sql.Connection
import kotlin.jvm.Throws
@ -23,10 +22,11 @@ object Exists {
@Throws(DocumentException::class)
@JvmStatic
fun <TKey> byId(tableName: String, docId: TKey, conn: Connection) =
conn.customScalar(
Custom.scalar(
ExistsQuery.byId(tableName, docId),
Parameters.addFields(listOf(Field.equal(Configuration.idField, docId, ":id"))),
Boolean::class.java,
conn,
Results::toExists
)
@ -63,10 +63,11 @@ object Exists {
conn: Connection
): Boolean {
val named = Parameters.nameFields(fields)
return conn.customScalar(
return Custom.scalar(
ExistsQuery.byFields(tableName, named, howMatched),
Parameters.addFields(named),
Boolean::class.java,
conn,
Results::toExists
)
}
@ -98,10 +99,11 @@ object Exists {
@Throws(DocumentException::class)
@JvmStatic
fun <TContains> byContains(tableName: String, criteria: TContains, conn: Connection) =
conn.customScalar(
Custom.scalar(
ExistsQuery.byContains(tableName),
listOf(Parameters.json(":criteria", criteria)),
Boolean::class.java,
conn,
Results::toExists
)
@ -130,10 +132,11 @@ object Exists {
@Throws(DocumentException::class)
@JvmStatic
fun byJsonPath(tableName: String, path: String, conn: Connection) =
conn.customScalar(
Custom.scalar(
ExistsQuery.byJsonPath(tableName),
listOf(Parameter(":path", ParameterType.STRING, path)),
Boolean::class.java,
conn,
Results::toExists
)

52
src/jvm/src/main/kotlin/jvm/Find.kt → src/core/src/main/kotlin/java/Find.kt
View File

@ -1,11 +1,10 @@
package solutions.bitbadger.documents.jvm
package solutions.bitbadger.documents.java
import solutions.bitbadger.documents.*
import solutions.bitbadger.documents.extensions.customList
import solutions.bitbadger.documents.extensions.customSingle
import solutions.bitbadger.documents.query.FindQuery
import solutions.bitbadger.documents.query.orderBy
import java.sql.Connection
import java.util.Optional
import kotlin.jvm.Throws
/**
@ -26,7 +25,7 @@ object Find {
@Throws(DocumentException::class)
@JvmStatic
fun <TDoc> all(tableName: String, clazz: Class<TDoc>, orderBy: Collection<Field<*>>? = null, conn: Connection) =
conn.customList(FindQuery.all(tableName) + (orderBy?.let(::orderBy) ?: ""), listOf(), clazz, Results::fromData)
Custom.list(FindQuery.all(tableName) + (orderBy?.let(::orderBy) ?: ""), listOf(), clazz, conn, Results::fromData)
/**
* Retrieve all documents in the given table
@ -64,16 +63,17 @@ object Find {
* @param docId The ID of the document to retrieve
* @param clazz The class of the document to be returned
* @param conn The connection over which documents should be retrieved
* @return The document if it is found, `null` otherwise
* @return An `Optional` item with the document if it is found
* @throws DocumentException If no dialect has been configured
*/
@Throws(DocumentException::class)
@JvmStatic
fun <TKey, TDoc> byId(tableName: String, docId: TKey, clazz: Class<TDoc>, conn: Connection) =
conn.customSingle(
Custom.single(
FindQuery.byId(tableName, docId),
Parameters.addFields(listOf(Field.equal(Configuration.idField, docId, ":id"))),
clazz,
conn,
Results::fromData
)
@ -83,7 +83,7 @@ object Find {
* @param tableName The table from which the document should be retrieved
* @param docId The ID of the document to retrieve
* @param clazz The class of the document to be returned
* @return The document if it is found, `null` otherwise
* @return An `Optional` item with the document if it is found
* @throws DocumentException If no connection string has been set
*/
@Throws(DocumentException::class)
@ -114,10 +114,11 @@ object Find {
conn: Connection
): List<TDoc> {
val named = Parameters.nameFields(fields)
return conn.customList(
return Custom.list(
FindQuery.byFields(tableName, named, howMatched) + (orderBy?.let(::orderBy) ?: ""),
Parameters.addFields(named),
clazz,
conn,
Results::fromData
)
}
@ -187,10 +188,11 @@ object Find {
orderBy: Collection<Field<*>>? = null,
conn: Connection
) =
conn.customList(
Custom.list(
FindQuery.byContains(tableName) + (orderBy?.let(::orderBy) ?: ""),
listOf(Parameters.json(":criteria", criteria)),
clazz,
conn,
Results::fromData
)
@ -250,10 +252,11 @@ object Find {
orderBy: Collection<Field<*>>? = null,
conn: Connection
) =
conn.customList(
Custom.list(
FindQuery.byJsonPath(tableName) + (orderBy?.let(::orderBy) ?: ""),
listOf(Parameter(":path", ParameterType.STRING, path)),
clazz,
conn,
Results::fromData
)
@ -297,7 +300,7 @@ object Find {
* @param howMatched How the fields should be matched (optional, defaults to `FieldMatch.ALL`)
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @param conn The connection over which documents should be retrieved
* @return The first document matching the field comparison, or `null` if no matches are found
* @return An `Optional` item, with the first document matching the field comparison if found
* @throws DocumentException If no dialect has been configured, or if parameters are invalid
*/
@Throws(DocumentException::class)
@ -309,12 +312,13 @@ object Find {
howMatched: FieldMatch? = null,
orderBy: Collection<Field<*>>? = null,
conn: Connection
): TDoc? {
): Optional<TDoc & Any> {
val named = Parameters.nameFields(fields)
return conn.customSingle(
return Custom.single(
FindQuery.byFields(tableName, named, howMatched) + (orderBy?.let(::orderBy) ?: ""),
Parameters.addFields(named),
clazz,
conn,
Results::fromData
)
}
@ -327,7 +331,7 @@ object Find {
* @param clazz The class of the document to be returned
* @param howMatched How the fields should be matched (optional, defaults to `FieldMatch.ALL`)
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @return The first document matching the field comparison, or `null` if no matches are found
* @return An `Optional` item, with the first document matching the field comparison if found
* @throws DocumentException If no connection string has been set, or if parameters are invalid
*/
@Throws(DocumentException::class)
@ -350,7 +354,7 @@ object Find {
* @param clazz The class of the document to be returned
* @param howMatched How the fields should be matched (optional, defaults to `FieldMatch.ALL`)
* @param conn The connection over which documents should be retrieved
* @return The first document matching the field comparison, or `null` if no matches are found
* @return An `Optional` item, with the first document matching the field comparison if found
* @throws DocumentException If no dialect has been configured, or if parameters are invalid
*/
@Throws(DocumentException::class)
@ -371,7 +375,7 @@ object Find {
* @param criteria The object for which JSON containment should be checked
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @param conn The connection over which documents should be retrieved
* @return The first document matching the JSON containment query, or `null` if no matches are found
* @return An `Optional` item, with the first document matching the JSON containment query if found
* @throws DocumentException If called on a SQLite connection
*/
@Throws(DocumentException::class)
@ -383,10 +387,11 @@ object Find {
orderBy: Collection<Field<*>>? = null,
conn: Connection
) =
conn.customSingle(
Custom.single(
FindQuery.byContains(tableName) + (orderBy?.let(::orderBy) ?: ""),
listOf(Parameters.json(":criteria", criteria)),
clazz,
conn,
Results::fromData
)
@ -397,7 +402,7 @@ object Find {
* @param criteria The object for which JSON containment should be checked
* @param clazz The class of the document to be returned
* @param conn The connection over which documents should be retrieved
* @return The first document matching the JSON containment query, or `null` if no matches are found
* @return An `Optional` item, with the first document matching the JSON containment query if found
* @throws DocumentException If called on a SQLite connection
*/
@Throws(DocumentException::class)
@ -417,7 +422,7 @@ object Find {
* @param criteria The object for which JSON containment should be checked
* @param clazz The class of the document to be returned
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @return The first document matching the JSON containment query, or `null` if no matches are found
* @return An `Optional` item, with the first document matching the JSON containment query if found
* @throws DocumentException If no connection string has been set, or if called on a SQLite connection
*/
@Throws(DocumentException::class)
@ -439,7 +444,7 @@ object Find {
* @param clazz The class of the document to be returned
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @param conn The connection over which documents should be retrieved
* @return The first document matching the JSON Path match query, or `null` if no matches are found
* @return An `Optional` item, with the first document matching the JSON Path match query if found
* @throws DocumentException If called on a SQLite connection
*/
@Throws(DocumentException::class)
@ -451,10 +456,11 @@ object Find {
orderBy: Collection<Field<*>>? = null,
conn: Connection
) =
conn.customSingle(
Custom.single(
FindQuery.byJsonPath(tableName) + (orderBy?.let(::orderBy) ?: ""),
listOf(Parameter(":path", ParameterType.STRING, path)),
clazz,
conn,
Results::fromData
)
@ -465,7 +471,7 @@ object Find {
* @param path The JSON path comparison to match
* @param clazz The class of the document to be returned
* @param conn The connection over which documents should be retrieved
* @return The first document matching the JSON Path match query, or `null` if no matches are found
* @return An `Optional` item, with the first document matching the JSON Path match query if found
* @throws DocumentException If called on a SQLite connection
*/
@Throws(DocumentException::class)
@ -480,7 +486,7 @@ object Find {
* @param path The JSON path comparison to match
* @param clazz The class of the document to be returned
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @return The first document matching the JSON Path match query, or `null` if no matches are found
* @return An `Optional` item, with the first document matching the JSON Path match query if found
* @throws DocumentException If no connection string has been set, or if called on a SQLite connection
*/
@Throws(DocumentException::class)

2
src/jvm/src/main/kotlin/jvm/NullDocumentSerializer.kt → src/core/src/main/kotlin/java/NullDocumentSerializer.kt
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.jvm
package solutions.bitbadger.documents.java
import solutions.bitbadger.documents.DocumentSerializer

2
src/jvm/src/main/kotlin/jvm/Parameters.kt → src/core/src/main/kotlin/java/Parameters.kt
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.jvm
package solutions.bitbadger.documents.java
import solutions.bitbadger.documents.*
import solutions.bitbadger.documents.ParameterName

27
src/jvm/src/main/kotlin/jvm/Patch.kt → src/core/src/main/kotlin/java/Patch.kt
View File

@ -1,7 +1,6 @@
package solutions.bitbadger.documents.jvm
package solutions.bitbadger.documents.java
import solutions.bitbadger.documents.*
import solutions.bitbadger.documents.extensions.customNonQuery
import solutions.bitbadger.documents.query.PatchQuery
import java.sql.Connection
import kotlin.jvm.Throws
@ -23,12 +22,13 @@ object Patch {
@Throws(DocumentException::class)
@JvmStatic
fun <TKey, TPatch> byId(tableName: String, docId: TKey, patch: TPatch, conn: Connection) =
conn.customNonQuery(
Custom.nonQuery(
PatchQuery.byId(tableName, docId),
Parameters.addFields(
listOf(Field.equal(Configuration.idField, docId, ":id")),
mutableListOf(Parameters.json(":data", patch))
)
),
conn
)
/**
@ -64,11 +64,10 @@ object Patch {
conn: Connection
) {
val named = Parameters.nameFields(fields)
conn.customNonQuery(
PatchQuery.byFields(tableName, named, howMatched), Parameters.addFields(
named,
mutableListOf(Parameters.json(":data", patch))
)
Custom.nonQuery(
PatchQuery.byFields(tableName, named, howMatched),
Parameters.addFields(named, mutableListOf(Parameters.json(":data", patch))),
conn
)
}
@ -104,9 +103,10 @@ object Patch {
@Throws(DocumentException::class)
@JvmStatic
fun <TContains, TPatch> byContains(tableName: String, criteria: TContains, patch: TPatch, conn: Connection) =
conn.customNonQuery(
Custom.nonQuery(
PatchQuery.byContains(tableName),
listOf(Parameters.json(":criteria", criteria), Parameters.json(":data", patch))
listOf(Parameters.json(":criteria", criteria), Parameters.json(":data", patch)),
conn
)
/**
@ -134,9 +134,10 @@ object Patch {
@Throws(DocumentException::class)
@JvmStatic
fun <TPatch> byJsonPath(tableName: String, path: String, patch: TPatch, conn: Connection) =
conn.customNonQuery(
Custom.nonQuery(
PatchQuery.byJsonPath(tableName),
listOf(Parameter(":path", ParameterType.STRING, path), Parameters.json(":data", patch))
listOf(Parameter(":path", ParameterType.STRING, path), Parameters.json(":data", patch)),
conn
)
/**

26
src/jvm/src/main/kotlin/jvm/RemoveFields.kt → src/core/src/main/kotlin/java/RemoveFields.kt
View File

@ -1,7 +1,6 @@
package solutions.bitbadger.documents.jvm
package solutions.bitbadger.documents.java
import solutions.bitbadger.documents.*
import solutions.bitbadger.documents.extensions.customNonQuery
import solutions.bitbadger.documents.query.RemoveFieldsQuery
import java.sql.Connection
import kotlin.jvm.Throws
@ -38,12 +37,10 @@ object RemoveFields {
@JvmStatic
fun <TKey> byId(tableName: String, docId: TKey, toRemove: Collection<String>, conn: Connection) {
val nameParams = Parameters.fieldNames(toRemove)
conn.customNonQuery(
Custom.nonQuery(
RemoveFieldsQuery.byId(tableName, nameParams, docId),
Parameters.addFields(
listOf(Field.equal(Configuration.idField, docId, ":id")),
translatePath(nameParams)
)
Parameters.addFields(listOf(Field.equal(Configuration.idField, docId, ":id")), translatePath(nameParams)),
conn
)
}
@ -81,9 +78,10 @@ object RemoveFields {
) {
val named = Parameters.nameFields(fields)
val nameParams = Parameters.fieldNames(toRemove)
conn.customNonQuery(
Custom.nonQuery(
RemoveFieldsQuery.byFields(tableName, nameParams, named, howMatched),
Parameters.addFields(named, translatePath(nameParams))
Parameters.addFields(named, translatePath(nameParams)),
conn
)
}
@ -125,9 +123,10 @@ object RemoveFields {
conn: Connection
) {
val nameParams = Parameters.fieldNames(toRemove)
conn.customNonQuery(
Custom.nonQuery(
RemoveFieldsQuery.byContains(tableName, nameParams),
listOf(Parameters.json(":criteria", criteria), *nameParams.toTypedArray())
listOf(Parameters.json(":criteria", criteria), *nameParams.toTypedArray()),
conn
)
}
@ -157,9 +156,10 @@ object RemoveFields {
@JvmStatic
fun byJsonPath(tableName: String, path: String, toRemove: Collection<String>, conn: Connection) {
val nameParams = Parameters.fieldNames(toRemove)
conn.customNonQuery(
Custom.nonQuery(
RemoveFieldsQuery.byJsonPath(tableName, nameParams),
listOf(Parameter(":path", ParameterType.STRING, path), *nameParams.toTypedArray())
listOf(Parameter(":path", ParameterType.STRING, path), *nameParams.toTypedArray()),
conn
)
}

3
src/jvm/src/main/kotlin/jvm/Results.kt → src/core/src/main/kotlin/java/Results.kt
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.jvm
package solutions.bitbadger.documents.java
import solutions.bitbadger.documents.Configuration
import solutions.bitbadger.documents.Dialect
@ -6,7 +6,6 @@ import solutions.bitbadger.documents.DocumentException
import java.sql.PreparedStatement
import java.sql.ResultSet
import java.sql.SQLException
import kotlin.jvm.Throws
object Results {

6
src/jvm/src/main/kotlin/extensions/Connection.kt → src/core/src/main/kotlin/java/extensions/Connection.kt
View File

@ -1,9 +1,9 @@
@file:JvmName("ConnExt")
package solutions.bitbadger.documents.extensions
package solutions.bitbadger.documents.java.extensions
import solutions.bitbadger.documents.*
import solutions.bitbadger.documents.jvm.*
import solutions.bitbadger.documents.java.*
import java.sql.Connection
import java.sql.ResultSet
import kotlin.jvm.Throws
@ -430,6 +430,7 @@ fun <TKey, TPatch> Connection.patchById(tableName: String, docId: TKey, patch: T
* @throws DocumentException If no dialect has been configured, or if parameters are invalid
*/
@Throws(DocumentException::class)
@JvmOverloads
fun <TPatch> Connection.patchByFields(
tableName: String,
fields: Collection<Field<*>>,
@ -490,6 +491,7 @@ fun <TKey> Connection.removeFieldsById(tableName: String, docId: TKey, toRemove:
* @throws DocumentException If no dialect has been configured, or if parameters are invalid
*/
@Throws(DocumentException::class)
@JvmOverloads
fun Connection.removeFieldsByFields(
tableName: String,
fields: Collection<Field<*>>,

0
src/jvm/src/main/kotlin/query/CountQuery.kt → src/core/src/main/kotlin/query/CountQuery.kt
View File

0
src/jvm/src/main/kotlin/query/DefinitionQuery.kt → src/core/src/main/kotlin/query/DefinitionQuery.kt
View File

0
src/jvm/src/main/kotlin/query/DeleteQuery.kt → src/core/src/main/kotlin/query/DeleteQuery.kt
View File

0
src/jvm/src/main/kotlin/query/DocumentQuery.kt → src/core/src/main/kotlin/query/DocumentQuery.kt
View File

0
src/jvm/src/main/kotlin/query/ExistsQuery.kt → src/core/src/main/kotlin/query/ExistsQuery.kt
View File

0
src/jvm/src/main/kotlin/query/FindQuery.kt → src/core/src/main/kotlin/query/FindQuery.kt
View File

0
src/jvm/src/main/kotlin/query/PatchQuery.kt → src/core/src/main/kotlin/query/PatchQuery.kt
View File

0
src/jvm/src/main/kotlin/query/Query.kt → src/core/src/main/kotlin/query/Query.kt
View File

0
src/jvm/src/main/kotlin/query/RemoveFieldsQuery.kt → src/core/src/main/kotlin/query/RemoveFieldsQuery.kt
View File

0
src/jvm/src/main/kotlin/query/Where.kt → src/core/src/main/kotlin/query/Where.kt
View File

20
src/core/src/test/java/module-info.java Normal file
View File

@ -0,0 +1,20 @@
module solutions.bitbadger.documents.core.tests {
requires solutions.bitbadger.documents.core;
requires com.fasterxml.jackson.databind;
requires java.sql;
requires kotlin.stdlib;
requires kotlin.test.junit5;
requires org.junit.jupiter.api;
requires org.slf4j;
requires annotations;
//requires org.checkerframework.checker.qual;
exports solutions.bitbadger.documents.core.tests;
exports solutions.bitbadger.documents.core.tests.integration;
exports solutions.bitbadger.documents.core.tests.java;
exports solutions.bitbadger.documents.core.tests.java.integration;
opens solutions.bitbadger.documents.core.tests;
opens solutions.bitbadger.documents.core.tests.java;
opens solutions.bitbadger.documents.core.tests.java.integration;
}

5
src/jvm/src/test/java/solutions/bitbadger/documents/java/AutoIdTest.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/AutoIdTest.java
View File

@ -1,17 +1,16 @@
package solutions.bitbadger.documents.java;
package solutions.bitbadger.documents.core.tests.java;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import solutions.bitbadger.documents.AutoId;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.java.support.*;
import static org.junit.jupiter.api.Assertions.*;
/**
* Unit tests for the `AutoId` enum
*/
@DisplayName("JVM | Java | AutoId")
@DisplayName("Core | Java | AutoId")
final public class AutoIdTest {
@Test

2
src/jvm/src/test/java/solutions/bitbadger/documents/java/support/ByteIdClass.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/ByteIdClass.java
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.java.support;
package solutions.bitbadger.documents.core.tests.java;
public class ByteIdClass {

4
src/jvm/src/test/java/solutions/bitbadger/documents/java/ConfigurationTest.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/ConfigurationTest.java
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.java;
package solutions.bitbadger.documents.core.tests.java;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
@ -13,7 +13,7 @@ import static org.junit.jupiter.api.Assertions.assertThrows;
/**
* Unit tests for the `Configuration` object
*/
@DisplayName("JVM | Java | Configuration")
@DisplayName("Core | Java | Configuration")
final public class ConfigurationTest {
@Test

8
src/jvm/src/test/java/solutions/bitbadger/documents/java/query/CountQueryTest.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/CountQueryTest.java
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.java.query;
package solutions.bitbadger.documents.core.tests.java;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.DisplayName;
@ -6,18 +6,18 @@ import org.junit.jupiter.api.Test;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.Field;
import solutions.bitbadger.documents.query.CountQuery;
import solutions.bitbadger.documents.support.ForceDialect;
import solutions.bitbadger.documents.core.tests.ForceDialect;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static solutions.bitbadger.documents.support.TypesKt.TEST_TABLE;
import static solutions.bitbadger.documents.core.tests.TypesKt.TEST_TABLE;
/**
* Unit tests for the `Count` object
*/
@DisplayName("JVM | Java | Query | CountQuery")
@DisplayName("Core | Java | Query | CountQuery")
final public class CountQueryTest {
/**

8
src/jvm/src/test/java/solutions/bitbadger/documents/java/query/DefinitionQueryTest.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/DefinitionQueryTest.java
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.java.query;
package solutions.bitbadger.documents.core.tests.java;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.DisplayName;
@ -7,18 +7,18 @@ import solutions.bitbadger.documents.Dialect;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.DocumentIndex;
import solutions.bitbadger.documents.query.DefinitionQuery;
import solutions.bitbadger.documents.support.ForceDialect;
import solutions.bitbadger.documents.core.tests.ForceDialect;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static solutions.bitbadger.documents.support.TypesKt.TEST_TABLE;
import static solutions.bitbadger.documents.core.tests.TypesKt.TEST_TABLE;
/**
* Unit tests for the `Definition` object
*/
@DisplayName("JVM | Java | Query | DefinitionQuery")
@DisplayName("Core | Java | Query | DefinitionQuery")
final public class DefinitionQueryTest {
/**

8
src/jvm/src/test/java/solutions/bitbadger/documents/java/query/DeleteQueryTest.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/DeleteQueryTest.java
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.java.query;
package solutions.bitbadger.documents.core.tests.java;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.DisplayName;
@ -6,18 +6,18 @@ import org.junit.jupiter.api.Test;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.Field;
import solutions.bitbadger.documents.query.DeleteQuery;
import solutions.bitbadger.documents.support.ForceDialect;
import solutions.bitbadger.documents.core.tests.ForceDialect;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static solutions.bitbadger.documents.support.TypesKt.TEST_TABLE;
import static solutions.bitbadger.documents.core.tests.TypesKt.TEST_TABLE;
/**
* Unit tests for the `Delete` object
*/
@DisplayName("JVM | Java | Query | DeleteQuery")
@DisplayName("Core | Java | Query | DeleteQuery")
final public class DeleteQueryTest {
/**

4
src/jvm/src/test/java/solutions/bitbadger/documents/java/DialectTest.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/DialectTest.java
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.java;
package solutions.bitbadger.documents.core.tests.java;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
@ -10,7 +10,7 @@ import static org.junit.jupiter.api.Assertions.*;
/**
* Unit tests for the `Dialect` enum
*/
@DisplayName("JVM | Java | Dialect")
@DisplayName("Core | Java | Dialect")
final public class DialectTest {
@Test

4
src/jvm/src/test/java/solutions/bitbadger/documents/java/DocumentIndexTest.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/DocumentIndexTest.java
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.java;
package solutions.bitbadger.documents.core.tests.java;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
@ -9,7 +9,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
/**
* Unit tests for the `DocumentIndex` enum
*/
@DisplayName("JVM | Java | DocumentIndex")
@DisplayName("Core | Java | DocumentIndex")
final public class DocumentIndexTest {
@Test

8
src/jvm/src/test/java/solutions/bitbadger/documents/java/query/DocumentQueryTest.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/DocumentQueryTest.java
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.java.query;
package solutions.bitbadger.documents.core.tests.java;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.DisplayName;
@ -7,15 +7,15 @@ import solutions.bitbadger.documents.AutoId;
import solutions.bitbadger.documents.Configuration;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.query.DocumentQuery;
import solutions.bitbadger.documents.support.ForceDialect;
import solutions.bitbadger.documents.core.tests.ForceDialect;
import static org.junit.jupiter.api.Assertions.*;
import static solutions.bitbadger.documents.support.TypesKt.TEST_TABLE;
import static solutions.bitbadger.documents.core.tests.TypesKt.TEST_TABLE;
/**
* Unit tests for the `Document` object
*/
@DisplayName("JVM | Java | Query | DocumentQuery")
@DisplayName("Core | Java | Query | DocumentQuery")
final public class DocumentQueryTest {
/**

8
src/jvm/src/test/java/solutions/bitbadger/documents/java/query/ExistsQueryTest.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/ExistsQueryTest.java
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.java.query;
package solutions.bitbadger.documents.core.tests.java;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.DisplayName;
@ -6,18 +6,18 @@ import org.junit.jupiter.api.Test;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.Field;
import solutions.bitbadger.documents.query.ExistsQuery;
import solutions.bitbadger.documents.support.ForceDialect;
import solutions.bitbadger.documents.core.tests.ForceDialect;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static solutions.bitbadger.documents.support.TypesKt.TEST_TABLE;
import static solutions.bitbadger.documents.core.tests.TypesKt.TEST_TABLE;
/**
* Unit tests for the `Exists` object
*/
@DisplayName("JVM | Java | Query | ExistsQuery")
@DisplayName("Core | Java | Query | ExistsQuery")
final public class ExistsQueryTest {
/**

4
src/jvm/src/test/java/solutions/bitbadger/documents/java/FieldMatchTest.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/FieldMatchTest.java
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.java;
package solutions.bitbadger.documents.core.tests.java;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
@ -9,7 +9,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
/**
* Unit tests for the `FieldMatch` enum
*/
@DisplayName("JVM | Java | FieldMatch")
@DisplayName("Core | Java | FieldMatch")
final public class FieldMatchTest {
@Test

6
src/jvm/src/test/java/solutions/bitbadger/documents/java/FieldTest.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/FieldTest.java
View File

@ -1,11 +1,11 @@
package solutions.bitbadger.documents.java;
package solutions.bitbadger.documents.core.tests.java;
import kotlin.Pair;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import solutions.bitbadger.documents.*;
import solutions.bitbadger.documents.support.ForceDialect;
import solutions.bitbadger.documents.core.tests.ForceDialect;
import java.util.Collection;
import java.util.List;
@ -15,7 +15,7 @@ import static org.junit.jupiter.api.Assertions.*;
/**
* Unit tests for the `Field` class
*/
@DisplayName("JVM | Java | Field")
@DisplayName("Core | Java | Field")
final public class FieldTest {
/**

8
src/jvm/src/test/java/solutions/bitbadger/documents/java/query/FindQueryTest.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/FindQueryTest.java
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.java.query;
package solutions.bitbadger.documents.core.tests.java;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.DisplayName;
@ -6,18 +6,18 @@ import org.junit.jupiter.api.Test;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.Field;
import solutions.bitbadger.documents.query.FindQuery;
import solutions.bitbadger.documents.support.ForceDialect;
import solutions.bitbadger.documents.core.tests.ForceDialect;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static solutions.bitbadger.documents.support.TypesKt.TEST_TABLE;
import static solutions.bitbadger.documents.core.tests.TypesKt.TEST_TABLE;
/**
* Unit tests for the `Find` object
*/
@DisplayName("JVM | Java | Query | FindQuery")
@DisplayName("Core | Java | Query | FindQuery")
final public class FindQueryTest {
/**

2
src/jvm/src/test/java/solutions/bitbadger/documents/java/support/IntIdClass.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/IntIdClass.java
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.java.support;
package solutions.bitbadger.documents.core.tests.java;
public class IntIdClass {

2
src/jvm/src/test/java/solutions/bitbadger/documents/java/support/LongIdClass.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/LongIdClass.java
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.java.support;
package solutions.bitbadger.documents.core.tests.java;
public class LongIdClass {

4
src/jvm/src/test/java/solutions/bitbadger/documents/java/OpTest.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/OpTest.java
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.java;
package solutions.bitbadger.documents.core.tests.java;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
@ -9,7 +9,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
/**
* Unit tests for the `Op` enum
*/
@DisplayName("JVM | Java | Op")
@DisplayName("Core | Java | Op")
final public class OpTest {
@Test

4
src/jvm/src/test/java/solutions/bitbadger/documents/java/ParameterNameTest.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/ParameterNameTest.java
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.java;
package solutions.bitbadger.documents.core.tests.java;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
@ -9,7 +9,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
/**
* Unit tests for the `ParameterName` class
*/
@DisplayName("JVM | Java | ParameterName")
@DisplayName("Core | Java | ParameterName")
final public class ParameterNameTest {
@Test

4
src/jvm/src/test/java/solutions/bitbadger/documents/java/ParameterTest.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/ParameterTest.java
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.java;
package solutions.bitbadger.documents.core.tests.java;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
@ -11,7 +11,7 @@ import static org.junit.jupiter.api.Assertions.*;
/**
* Unit tests for the `Parameter` class
*/
@DisplayName("JVM | Java | Parameter")
@DisplayName("Core | Java | Parameter")
final public class ParameterTest {
@Test

6
src/jvm/src/test/java/solutions/bitbadger/documents/java/jvm/ParametersTest.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/ParametersTest.java
View File

@ -1,10 +1,10 @@
package solutions.bitbadger.documents.java.jvm;
package solutions.bitbadger.documents.core.tests.java;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import solutions.bitbadger.documents.*;
import solutions.bitbadger.documents.jvm.Parameters;
import solutions.bitbadger.documents.java.Parameters;
import java.util.List;
@ -13,7 +13,7 @@ import static org.junit.jupiter.api.Assertions.*;
/**
* Unit tests for the `Parameters` object
*/
@DisplayName("JVM | Java | Parameters")
@DisplayName("Core | Java | Parameters")
final public class ParametersTest {
/**

8
src/jvm/src/test/java/solutions/bitbadger/documents/java/query/PatchQueryTest.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/PatchQueryTest.java
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.java.query;
package solutions.bitbadger.documents.core.tests.java;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.DisplayName;
@ -6,18 +6,18 @@ import org.junit.jupiter.api.Test;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.Field;
import solutions.bitbadger.documents.query.PatchQuery;
import solutions.bitbadger.documents.support.ForceDialect;
import solutions.bitbadger.documents.core.tests.ForceDialect;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static solutions.bitbadger.documents.support.TypesKt.TEST_TABLE;
import static solutions.bitbadger.documents.core.tests.TypesKt.TEST_TABLE;
/**
* Unit tests for the `Patch` object
*/
@DisplayName("JVM | Java | Query | PatchQuery")
@DisplayName("Core | Java | Query | PatchQuery")
final public class PatchQueryTest {
/**

6
src/jvm/src/test/java/solutions/bitbadger/documents/java/query/QueryUtilsTest.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/QueryUtilsTest.java
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.java.query;
package solutions.bitbadger.documents.core.tests.java;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.DisplayName;
@ -8,7 +8,7 @@ import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.Field;
import solutions.bitbadger.documents.FieldMatch;
import solutions.bitbadger.documents.query.QueryUtils;
import solutions.bitbadger.documents.support.ForceDialect;
import solutions.bitbadger.documents.core.tests.ForceDialect;
import java.util.List;
@ -17,7 +17,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
/**
* Unit tests for the package-level query functions, presented as `QueryUtils` for Java-compatible use
*/
@DisplayName("JVM | Java | Query | QueryUtils")
@DisplayName("Core | Java | Query | QueryUtils")
final public class QueryUtilsTest {
/**

8
src/jvm/src/test/java/solutions/bitbadger/documents/java/query/RemoveFieldsQueryTest.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/RemoveFieldsQueryTest.java
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.java.query;
package solutions.bitbadger.documents.core.tests.java;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.DisplayName;
@ -8,18 +8,18 @@ import solutions.bitbadger.documents.Field;
import solutions.bitbadger.documents.Parameter;
import solutions.bitbadger.documents.ParameterType;
import solutions.bitbadger.documents.query.RemoveFieldsQuery;
import solutions.bitbadger.documents.support.ForceDialect;
import solutions.bitbadger.documents.core.tests.ForceDialect;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static solutions.bitbadger.documents.support.TypesKt.TEST_TABLE;
import static solutions.bitbadger.documents.core.tests.TypesKt.TEST_TABLE;
/**
* Unit tests for the `RemoveFields` object
*/
@DisplayName("JVM | Java | Query | RemoveFieldsQuery")
@DisplayName("Core | Java | Query | RemoveFieldsQuery")
final public class RemoveFieldsQueryTest {
/**

2
src/jvm/src/test/java/solutions/bitbadger/documents/java/support/ShortIdClass.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/ShortIdClass.java
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.java.support;
package solutions.bitbadger.documents.core.tests.java;
public class ShortIdClass {

2
src/jvm/src/test/java/solutions/bitbadger/documents/java/support/StringIdClass.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/StringIdClass.java
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.java.support;
package solutions.bitbadger.documents.core.tests.java;
public class StringIdClass {

6
src/jvm/src/test/java/solutions/bitbadger/documents/java/query/WhereTest.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/WhereTest.java
View File

@ -1,4 +1,4 @@
package solutions.bitbadger.documents.java.query;
package solutions.bitbadger.documents.core.tests.java;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.DisplayName;
@ -7,7 +7,7 @@ import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.Field;
import solutions.bitbadger.documents.FieldMatch;
import solutions.bitbadger.documents.query.Where;
import solutions.bitbadger.documents.support.ForceDialect;
import solutions.bitbadger.documents.core.tests.ForceDialect;
import java.util.List;
@ -17,7 +17,7 @@ import static org.junit.jupiter.api.Assertions.assertThrows;
/**
* Unit tests for the `Where` object
*/
@DisplayName("JVM | Java | Query | Where")
@DisplayName("Core | Java | Query | Where")
final public class WhereTest {
/**

41
src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/ArrayDocument.java Normal file
View File

@ -0,0 +1,41 @@
package solutions.bitbadger.documents.core.tests.java.integration;
import java.util.List;
public class ArrayDocument {
private String id;
private List<String> values;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public List<String> getValues() {
return values;
}
public void setValues(List<String> values) {
this.values = values;
}
public ArrayDocument(String id, List<String> values) {
this.id = id;
this.values = values;
}
public ArrayDocument() {
this("", List.of());
}
public static List<ArrayDocument> testDocuments =
List.of(
new ArrayDocument("first", List.of("a", "b", "c")),
new ArrayDocument("second", List.of("c", "d", "e")),
new ArrayDocument("third", List.of("x", "y", "z")));
}

9
src/jvm/src/test/java/solutions/bitbadger/documents/java/jvm/integration/common/CountFunctions.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/CountFunctions.java
View File

@ -1,16 +1,15 @@
package solutions.bitbadger.documents.java.jvm.integration.common;
package solutions.bitbadger.documents.core.tests.java.integration;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.Field;
import solutions.bitbadger.documents.java.support.JsonDocument;
import solutions.bitbadger.documents.support.ThrowawayDatabase;
import solutions.bitbadger.documents.core.tests.integration.ThrowawayDatabase;
import java.util.List;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static solutions.bitbadger.documents.extensions.ConnExt.*;
import static solutions.bitbadger.documents.support.TypesKt.TEST_TABLE;
import static solutions.bitbadger.documents.core.tests.TypesKt.TEST_TABLE;
import static solutions.bitbadger.documents.java.extensions.ConnExt.*;
/**
* Integration tests for the `Count` object

23
src/jvm/src/test/java/solutions/bitbadger/documents/java/jvm/integration/common/CustomFunctions.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/CustomFunctions.java
View File

@ -1,19 +1,18 @@
package solutions.bitbadger.documents.java.jvm.integration.common;
package solutions.bitbadger.documents.core.tests.java.integration;
import solutions.bitbadger.documents.*;
import solutions.bitbadger.documents.java.support.JsonDocument;
import solutions.bitbadger.documents.jvm.Results;
import solutions.bitbadger.documents.core.tests.integration.ThrowawayDatabase;
import solutions.bitbadger.documents.java.Results;
import solutions.bitbadger.documents.query.CountQuery;
import solutions.bitbadger.documents.query.DeleteQuery;
import solutions.bitbadger.documents.query.FindQuery;
import solutions.bitbadger.documents.support.ThrowawayDatabase;
import java.util.Collection;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;
import static solutions.bitbadger.documents.extensions.ConnExt.*;
import static solutions.bitbadger.documents.support.TypesKt.TEST_TABLE;
import static solutions.bitbadger.documents.core.tests.TypesKt.TEST_TABLE;
import static solutions.bitbadger.documents.java.extensions.ConnExt.*;
final public class CustomFunctions {
@ -33,16 +32,18 @@ final public class CustomFunctions {
}
public static void singleNone(ThrowawayDatabase db) throws DocumentException {
assertNull(
customSingle(db.getConn(), FindQuery.all(TEST_TABLE), List.of(), JsonDocument.class, Results::fromData),
assertFalse(
customSingle(db.getConn(), FindQuery.all(TEST_TABLE), List.of(), JsonDocument.class, Results::fromData)
.isPresent(),
"There should not have been a document returned");
}
public static void singleOne(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertNotNull(
customSingle(db.getConn(), FindQuery.all(TEST_TABLE), List.of(), JsonDocument.class, Results::fromData),
"There should not have been a document returned");
assertTrue(
customSingle(db.getConn(), FindQuery.all(TEST_TABLE), List.of(), JsonDocument.class, Results::fromData)
.isPresent(),
"There should have been a document returned");
}
public static void nonQueryChanges(ThrowawayDatabase db) throws DocumentException {

47
src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/DefinitionFunctions.java Normal file
View File

@ -0,0 +1,47 @@
package solutions.bitbadger.documents.core.tests.java.integration;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.DocumentIndex;
import solutions.bitbadger.documents.core.tests.integration.ThrowawayDatabase;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static solutions.bitbadger.documents.core.tests.TypesKt.TEST_TABLE;
import static solutions.bitbadger.documents.java.extensions.ConnExt.*;
final public class DefinitionFunctions {
public static void ensuresATable(ThrowawayDatabase db) throws DocumentException {
assertFalse(db.dbObjectExists("ensured"), "The 'ensured' table should not exist");
assertFalse(db.dbObjectExists("idx_ensured_key"), "The PK index for the 'ensured' table should not exist");
ensureTable(db.getConn(), "ensured");
assertTrue(db.dbObjectExists("ensured"), "The 'ensured' table should exist");
assertTrue(db.dbObjectExists("idx_ensured_key"), "The PK index for the 'ensured' table should now exist");
}
public static void ensuresAFieldIndex(ThrowawayDatabase db) throws DocumentException {
assertFalse(db.dbObjectExists(String.format("idx_%s_test", TEST_TABLE)), "The test index should not exist");
ensureFieldIndex(db.getConn(), TEST_TABLE, "test", List.of("id", "category"));
assertTrue(db.dbObjectExists(String.format("idx_%s_test", TEST_TABLE)), "The test index should now exist");
}
public static void ensureDocumentIndexFull(ThrowawayDatabase db) throws DocumentException {
assertFalse(db.dbObjectExists("doc_table"), "The 'doc_table' table should not exist");
ensureTable(db.getConn(), "doc_table");
assertTrue(db.dbObjectExists("doc_table"), "The 'doc_table' table should exist");
assertFalse(db.dbObjectExists("idx_doc_table_document"), "The document index should not exist");
ensureDocumentIndex(db.getConn(), "doc_table", DocumentIndex.FULL);
assertTrue(db.dbObjectExists("idx_doc_table_document"), "The document index should exist");
}
public static void ensureDocumentIndexOptimized(ThrowawayDatabase db) throws DocumentException {
assertFalse(db.dbObjectExists("doc_table"), "The 'doc_table' table should not exist");
ensureTable(db.getConn(), "doc_table");
assertTrue(db.dbObjectExists("doc_table"), "The 'doc_table' table should exist");
assertFalse(db.dbObjectExists("idx_doc_table_document"), "The document index should not exist");
ensureDocumentIndex(db.getConn(), "doc_table", DocumentIndex.OPTIMIZED);
assertTrue(db.dbObjectExists("idx_doc_table_document"), "The document index should exist");
}
}

71
src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/DeleteFunctions.java Normal file
View File

@ -0,0 +1,71 @@
package solutions.bitbadger.documents.core.tests.java.integration;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.Field;
import solutions.bitbadger.documents.core.tests.integration.ThrowawayDatabase;
import java.util.List;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static solutions.bitbadger.documents.core.tests.TypesKt.TEST_TABLE;
import static solutions.bitbadger.documents.java.extensions.ConnExt.*;
final public class DeleteFunctions {
public static void byIdMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertEquals(5L, countAll(db.getConn(), TEST_TABLE), "There should be 5 documents in the table");
deleteById(db.getConn(), TEST_TABLE, "four");
assertEquals(4L, countAll(db.getConn(), TEST_TABLE), "There should now be 4 documents in the table");
}
public static void byIdNoMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertEquals(5L, countAll(db.getConn(), TEST_TABLE), "There should be 5 documents in the table");
deleteById(db.getConn(), TEST_TABLE, "negative four");
assertEquals(5L, countAll(db.getConn(), TEST_TABLE), "There should still be 5 documents in the table");
}
public static void byFieldsMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertEquals(5L, countAll(db.getConn(), TEST_TABLE), "There should be 5 documents in the table");
deleteByFields( db.getConn(), TEST_TABLE, List.of(Field.notEqual("value", "purple")));
assertEquals(2L, countAll(db.getConn(), TEST_TABLE), "There should now be 2 documents in the table");
}
public static void byFieldsNoMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertEquals(5L, countAll(db.getConn(), TEST_TABLE), "There should be 5 documents in the table");
deleteByFields(db.getConn(), TEST_TABLE, List.of(Field.equal("value", "crimson")));
assertEquals(5L, countAll(db.getConn(), TEST_TABLE), "There should still be 5 documents in the table");
}
public static void byContainsMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertEquals(5L, countAll(db.getConn(), TEST_TABLE), "There should be 5 documents in the table");
deleteByContains(db.getConn(), TEST_TABLE, Map.of("value", "purple"));
assertEquals(3L, countAll(db.getConn(), TEST_TABLE), "There should now be 3 documents in the table");
}
public static void byContainsNoMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertEquals(5L, countAll(db.getConn(), TEST_TABLE), "There should be 5 documents in the table");
deleteByContains(db.getConn(), TEST_TABLE, Map.of("target", "acquired"));
assertEquals(5L, countAll(db.getConn(), TEST_TABLE), "There should still be 5 documents in the table");
}
public static void byJsonPathMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertEquals(5L, countAll(db.getConn(), TEST_TABLE), "There should be 5 documents in the table");
deleteByJsonPath(db.getConn(), TEST_TABLE, "$.value ? (@ == \"purple\")");
assertEquals(3L, countAll(db.getConn(), TEST_TABLE), "There should now be 3 documents in the table");
}
public static void byJsonPathNoMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertEquals(5L, countAll(db.getConn(), TEST_TABLE), "There should be 5 documents in the table");
deleteByJsonPath(db.getConn(), TEST_TABLE, "$.numValue ? (@ > 100)");
assertEquals(5L, countAll(db.getConn(), TEST_TABLE), "There should still be 5 documents in the table");
}
}

138
src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/DocumentFunctions.java Normal file
View File

@ -0,0 +1,138 @@
package solutions.bitbadger.documents.core.tests.java.integration;
import solutions.bitbadger.documents.AutoId;
import solutions.bitbadger.documents.Configuration;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.Field;
import solutions.bitbadger.documents.core.tests.integration.ThrowawayDatabase;
import java.util.List;
import java.util.Optional;
import static org.junit.jupiter.api.Assertions.*;
import static solutions.bitbadger.documents.core.tests.TypesKt.TEST_TABLE;
import static solutions.bitbadger.documents.java.extensions.ConnExt.*;
final public class DocumentFunctions {
public static void insertDefault(ThrowawayDatabase db) throws DocumentException {
assertEquals(0L, countAll(db.getConn(), TEST_TABLE), "There should be no documents in the table");
insert(db.getConn(), TEST_TABLE, new JsonDocument("turkey", "", 0, new SubDocument("gobble", "gobble!")));
final List<JsonDocument> after = findAll(db.getConn(), TEST_TABLE, JsonDocument.class);
assertEquals(1, after.size(), "There should be one document in the table");
final JsonDocument doc = after.get(0);
assertEquals("turkey", doc.getId(), "The inserted document's ID is incorrect");
assertEquals("", doc.getValue(), "The inserted document's value is incorrect");
assertEquals(0, doc.getNumValue(), "The document's numeric value is incorrect");
assertNotNull(doc.getSub(), "The inserted document's subdocument was not created");
assertEquals("gobble", doc.getSub().getFoo(), "The subdocument's \"foo\" property is incorrect");
assertEquals("gobble!", doc.getSub().getBar(), "The subdocument's \"bar\" property is incorrect");
}
public static void insertDupe(ThrowawayDatabase db) throws DocumentException {
insert(db.getConn(), TEST_TABLE, new JsonDocument("a", "", 0));
assertThrows(DocumentException.class, () -> insert(db.getConn(), TEST_TABLE, new JsonDocument("a", "b", 22)),
"Inserting a document with a duplicate key should have thrown an exception");
}
public static void insertNumAutoId(ThrowawayDatabase db) throws DocumentException {
try {
Configuration.autoIdStrategy = AutoId.NUMBER;
Configuration.idField = "key";
assertEquals(0L, countAll(db.getConn(), TEST_TABLE), "There should be no documents in the table");
insert(db.getConn(), TEST_TABLE, new NumIdDocument(0, "one"));
insert(db.getConn(), TEST_TABLE, new NumIdDocument(0, "two"));
insert(db.getConn(), TEST_TABLE, new NumIdDocument(77, "three"));
insert(db.getConn(), TEST_TABLE, new NumIdDocument(0, "four"));
final List<NumIdDocument> after = findAll(db.getConn(), TEST_TABLE, NumIdDocument.class,
List.of(Field.named("key")));
assertEquals(4, after.size(), "There should have been 4 documents returned");
assertEquals("1|2|77|78",
after.stream().map(doc -> String.valueOf(doc.getKey()))
.reduce((acc, item) -> String.format("%s|%s", acc, item)).get(),
"The IDs were not generated correctly");
} finally {
Configuration.autoIdStrategy = AutoId.DISABLED;
Configuration.idField = "id";
}
}
public static void insertUUIDAutoId(ThrowawayDatabase db) throws DocumentException {
try {
Configuration.autoIdStrategy = AutoId.UUID;
assertEquals(0L, countAll(db.getConn(), TEST_TABLE), "There should be no documents in the table");
insert(db.getConn(), TEST_TABLE, new JsonDocument(""));
final List<JsonDocument> after = findAll(db.getConn(), TEST_TABLE, JsonDocument.class);
assertEquals(1, after.size(), "There should have been 1 document returned");
assertEquals(32, after.get(0).getId().length(), "The ID was not generated correctly");
} finally {
Configuration.autoIdStrategy = AutoId.DISABLED;
}
}
public static void insertStringAutoId(ThrowawayDatabase db) throws DocumentException {
try {
Configuration.autoIdStrategy = AutoId.RANDOM_STRING;
assertEquals(0L, countAll(db.getConn(), TEST_TABLE), "There should be no documents in the table");
insert(db.getConn(), TEST_TABLE, new JsonDocument(""));
Configuration.idStringLength = 21;
insert(db.getConn(), TEST_TABLE, new JsonDocument(""));
final List<JsonDocument> after = findAll(db.getConn(), TEST_TABLE, JsonDocument.class);
assertEquals(2, after.size(), "There should have been 2 documents returned");
assertEquals(16, after.get(0).getId().length(), "The first document's ID was not generated correctly");
assertEquals(21, after.get(1).getId().length(), "The second document's ID was not generated correctly");
} finally {
Configuration.autoIdStrategy = AutoId.DISABLED;
Configuration.idStringLength = 16;
}
}
public static void saveMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
save(db.getConn(), TEST_TABLE, new JsonDocument("two", "", 44));
final Optional<JsonDocument> tryDoc = findById(db.getConn(), TEST_TABLE, "two", JsonDocument.class);
assertTrue(tryDoc.isPresent(), "There should have been a document returned");
final JsonDocument doc = tryDoc.get();
assertEquals("two", doc.getId(), "An incorrect document was returned");
assertEquals("", doc.getValue(), "The \"value\" field was not updated");
assertEquals(44, doc.getNumValue(), "The \"numValue\" field was not updated");
assertNull(doc.getSub(), "The \"sub\" field was not updated");
}
public static void saveNoMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final JsonDocument toSave = new JsonDocument("test");
toSave.setSub(new SubDocument("a", "b"));
save(db.getConn(), TEST_TABLE, toSave);
assertTrue(findById(db.getConn(), TEST_TABLE, "test", JsonDocument.class).isPresent(),
"The test document should have been saved");
}
public static void updateMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
update(db.getConn(), TEST_TABLE, "one", new JsonDocument("one", "howdy", 8, new SubDocument("y", "z")));
final Optional<JsonDocument> tryDoc = findById(db.getConn(), TEST_TABLE, "one", JsonDocument.class);
assertTrue(tryDoc.isPresent(), "There should have been a document returned");
final JsonDocument doc = tryDoc.get();
assertEquals("one", doc.getId(), "An incorrect document was returned");
assertEquals("howdy", doc.getValue(), "The \"value\" field was not updated");
assertEquals(8, doc.getNumValue(), "The \"numValue\" field was not updated");
assertNotNull(doc.getSub(), "The sub-document should not be null");
assertEquals("y", doc.getSub().getFoo(), "The sub-document \"foo\" field was not updated");
assertEquals("z", doc.getSub().getBar(), "The sub-document \"bar\" field was not updated");
}
public static void updateNoMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertFalse(existsById(db.getConn(), TEST_TABLE, "two-hundred"));
update(db.getConn(), TEST_TABLE, "two-hundred", new JsonDocument("two-hundred", "", 200));
assertFalse(existsById(db.getConn(), TEST_TABLE, "two-hundred"));
}
}

62
src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/ExistsFunctions.java Normal file
View File

@ -0,0 +1,62 @@
package solutions.bitbadger.documents.core.tests.java.integration;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.Field;
import solutions.bitbadger.documents.core.tests.integration.ThrowawayDatabase;
import java.util.List;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static solutions.bitbadger.documents.core.tests.TypesKt.TEST_TABLE;
import static solutions.bitbadger.documents.java.extensions.ConnExt.*;
final public class ExistsFunctions {
public static void byIdMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertTrue(existsById(db.getConn(), TEST_TABLE, "three"), "The document with ID \"three\" should exist");
}
public static void byIdNoMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertFalse(existsById(db.getConn(), TEST_TABLE, "seven"), "The document with ID \"seven\" should not exist");
}
public static void byFieldsMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertTrue(existsByFields(db.getConn(), TEST_TABLE, List.of(Field.equal("numValue", 10))),
"Matching documents should have been found");
}
public static void byFieldsNoMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertFalse(existsByFields(db.getConn(), TEST_TABLE, List.of(Field.equal("nothing", "none"))),
"No matching documents should have been found");
}
public static void byContainsMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertTrue(existsByContains(db.getConn(), TEST_TABLE, Map.of("value", "purple")),
"Matching documents should have been found");
}
public static void byContainsNoMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertFalse(existsByContains(db.getConn(), TEST_TABLE, Map.of("value", "violet")),
"Matching documents should not have been found");
}
public static void byJsonPathMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertTrue(existsByJsonPath(db.getConn(), TEST_TABLE, "$.numValue ? (@ == 10)"),
"Matching documents should have been found");
}
public static void byJsonPathNoMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertFalse(existsByJsonPath(db.getConn(), TEST_TABLE, "$.numValue ? (@ == 10.1)"),
"Matching documents should not have been found");
}
}

279
src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/FindFunctions.java Normal file
View File

@ -0,0 +1,279 @@
package solutions.bitbadger.documents.core.tests.java.integration;
import solutions.bitbadger.documents.Configuration;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.Field;
import solutions.bitbadger.documents.FieldMatch;
import solutions.bitbadger.documents.core.tests.integration.ThrowawayDatabase;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import static org.junit.jupiter.api.Assertions.*;
import static solutions.bitbadger.documents.core.tests.TypesKt.TEST_TABLE;
import static solutions.bitbadger.documents.java.extensions.ConnExt.*;
final public class FindFunctions {
private static String docIds(List<JsonDocument> docs) {
return docs.stream().map(JsonDocument::getId).reduce((acc, docId) -> String.format("%s|%s", acc, docId)).get();
}
public static void allDefault(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertEquals(5, findAll(db.getConn(), TEST_TABLE, JsonDocument.class).size(),
"There should have been 5 documents returned");
}
public static void allAscending(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final List<JsonDocument> docs = findAll(db.getConn(), TEST_TABLE, JsonDocument.class,
List.of(Field.named("id")));
assertEquals(5, docs.size(), "There should have been 5 documents returned");
assertEquals("five|four|one|three|two", docIds(docs), "The documents were not ordered correctly");
}
public static void allDescending(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final List<JsonDocument> docs = findAll(db.getConn(), TEST_TABLE, JsonDocument.class,
List.of(Field.named("id DESC")));
assertEquals(5, docs.size(), "There should have been 5 documents returned");
assertEquals("two|three|one|four|five", docIds(docs), "The documents were not ordered correctly");
}
public static void allNumOrder(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final List<JsonDocument> docs = findAll(db.getConn(), TEST_TABLE, JsonDocument.class,
List.of(Field.named("sub.foo NULLS LAST"), Field.named("n:numValue")));
assertEquals(5, docs.size(), "There should have been 5 documents returned");
assertEquals("two|four|one|three|five", docIds(docs), "The documents were not ordered correctly");
}
public static void allEmpty(ThrowawayDatabase db) throws DocumentException {
assertEquals(0, findAll(db.getConn(), TEST_TABLE, JsonDocument.class).size(),
"There should have been no documents returned");
}
public static void byIdString(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final Optional<JsonDocument> doc = findById(db.getConn(), TEST_TABLE, "two", JsonDocument.class);
assertTrue(doc.isPresent(), "The document should have been returned");
assertEquals("two", doc.get().getId(), "An incorrect document was returned");
}
public static void byIdNumber(ThrowawayDatabase db) throws DocumentException {
Configuration.idField = "key";
try {
insert(db.getConn(), TEST_TABLE, new NumIdDocument(18, "howdy"));
final Optional<NumIdDocument> doc = findById(db.getConn(), TEST_TABLE, 18, NumIdDocument.class);
assertTrue(doc.isPresent(), "The document should have been returned");
} finally {
Configuration.idField = "id";
}
}
public static void byIdNotFound(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertFalse(findById(db.getConn(), TEST_TABLE, "x", JsonDocument.class).isPresent(),
"There should have been no document returned");
}
public static void byFieldsMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final List<JsonDocument> docs = findByFields(db.getConn(), TEST_TABLE,
List.of(Field.any("value", List.of("blue", "purple")), Field.exists("sub")), JsonDocument.class,
FieldMatch.ALL);
assertEquals(1, docs.size(), "There should have been a document returned");
assertEquals("four", docs.get(0).getId(), "The incorrect document was returned");
}
public static void byFieldsMatchOrdered(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final List<JsonDocument> docs = findByFields(db.getConn(), TEST_TABLE, List.of(Field.equal("value", "purple")),
JsonDocument.class, null, List.of(Field.named("id")));
assertEquals(2, docs.size(), "There should have been 2 documents returned");
assertEquals("five|four", docIds(docs), "The documents were not ordered correctly");
}
public static void byFieldsMatchNumIn(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final List<JsonDocument> docs = findByFields(db.getConn(), TEST_TABLE,
List.of(Field.any("numValue", List.of(2, 4, 6, 8))), JsonDocument.class);
assertEquals(1, docs.size(), "There should have been a document returned");
assertEquals("three", docs.get(0).getId(), "The incorrect document was returned");
}
public static void byFieldsNoMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertEquals(0,
findByFields(db.getConn(), TEST_TABLE, List.of(Field.greater("numValue", 100)), JsonDocument.class)
.size(),
"There should have been no documents returned");
}
public static void byFieldsMatchInArray(ThrowawayDatabase db) throws DocumentException {
for (final ArrayDocument doc : ArrayDocument.testDocuments) { insert(db.getConn(), TEST_TABLE, doc); }
final List<ArrayDocument> docs = findByFields(db.getConn(), TEST_TABLE,
List.of(Field.inArray("values", TEST_TABLE, List.of("c"))), ArrayDocument.class);
assertEquals(2, docs.size(), "There should have been two documents returned");
assertTrue(List.of("first", "second").contains(docs.get(0).getId()),
String.format("An incorrect document was returned (%s)", docs.get(0).getId()));
assertTrue(List.of("first", "second").contains(docs.get(1).getId()),
String.format("An incorrect document was returned (%s)", docs.get(1).getId()));
}
public static void byFieldsNoMatchInArray(ThrowawayDatabase db) throws DocumentException {
for (final ArrayDocument doc : ArrayDocument.testDocuments) { insert(db.getConn(), TEST_TABLE, doc); }
assertEquals(0,
findByFields(db.getConn(), TEST_TABLE, List.of(Field.inArray("values", TEST_TABLE, List.of("j"))),
ArrayDocument.class).size(),
"There should have been no documents returned");
}
public static void byContainsMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final List<JsonDocument> docs = findByContains(db.getConn(), TEST_TABLE, Map.of("value", "purple"),
JsonDocument.class);
assertEquals(2, docs.size(), "There should have been 2 documents returned");
assertTrue(List.of("four", "five").contains(docs.get(0).getId()),
String.format("An incorrect document was returned (%s)", docs.get(0).getId()));
assertTrue(List.of("four", "five").contains(docs.get(1).getId()),
String.format("An incorrect document was returned (%s)", docs.get(1).getId()));
}
public static void byContainsMatchOrdered(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final List<JsonDocument> docs = findByContains(db.getConn(), TEST_TABLE, Map.of("sub", Map.of("foo", "green")),
JsonDocument.class, List.of(Field.named("value")));
assertEquals(2, docs.size(), "There should have been 2 documents returned");
assertEquals("two|four", docIds(docs), "The documents were not ordered correctly");
}
public static void byContainsNoMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertEquals(0, findByContains(db.getConn(), TEST_TABLE, Map.of("value", "indigo"), JsonDocument.class).size(),
"There should have been no documents returned");
}
public static void byJsonPathMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final List<JsonDocument> docs = findByJsonPath(db.getConn(), TEST_TABLE, "$.numValue ? (@ > 10)",
JsonDocument.class);
assertEquals(2, docs.size(), "There should have been 2 documents returned");
assertTrue(List.of("four", "five").contains(docs.get(0).getId()),
String.format("An incorrect document was returned (%s)", docs.get(0).getId()));
assertTrue(List.of("four", "five").contains(docs.get(1).getId()),
String.format("An incorrect document was returned (%s)", docs.get(1).getId())); }
public static void byJsonPathMatchOrdered(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final List<JsonDocument> docs = findByJsonPath(db.getConn(), TEST_TABLE, "$.numValue ? (@ > 10)",
JsonDocument.class, List.of(Field.named("id")));
assertEquals(2, docs.size(), "There should have been 2 documents returned");
assertEquals("five|four", docIds(docs), "The documents were not ordered correctly");
}
public static void byJsonPathNoMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertEquals(0, findByJsonPath(db.getConn(), TEST_TABLE, "$.numValue ? (@ > 100)", JsonDocument.class).size(),
"There should have been no documents returned");
}
public static void firstByFieldsMatchOne(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final Optional<JsonDocument> doc = findFirstByFields(db.getConn(), TEST_TABLE,
List.of(Field.equal("value", "another")), JsonDocument.class);
assertTrue(doc.isPresent(), "There should have been a document returned");
assertEquals("two", doc.get().getId(), "The incorrect document was returned");
}
public static void firstByFieldsMatchMany(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final Optional<JsonDocument> doc = findFirstByFields(db.getConn(), TEST_TABLE,
List.of(Field.equal("sub.foo", "green")), JsonDocument.class);
assertTrue(doc.isPresent(), "There should have been a document returned");
assertTrue(List.of("two", "four").contains(doc.get().getId()),
String.format("An incorrect document was returned (%s)", doc.get().getId()));
}
public static void firstByFieldsMatchOrdered(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final Optional<JsonDocument> doc = findFirstByFields(db.getConn(), TEST_TABLE,
List.of(Field.equal("sub.foo", "green")), JsonDocument.class, null,
List.of(Field.named("n:numValue DESC")));
assertTrue(doc.isPresent(), "There should have been a document returned");
assertEquals("four", doc.get().getId(), "An incorrect document was returned");
}
public static void firstByFieldsNoMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertFalse(findFirstByFields(db.getConn(), TEST_TABLE, List.of(Field.equal("value", "absent")),
JsonDocument.class).isPresent(),
"There should have been no document returned");
}
public static void firstByContainsMatchOne(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final Optional<JsonDocument> doc = findFirstByContains(db.getConn(), TEST_TABLE, Map.of("value", "FIRST!"),
JsonDocument.class);
assertTrue(doc.isPresent(), "There should have been a document returned");
assertEquals("one", doc.get().getId(), "An incorrect document was returned");
}
public static void firstByContainsMatchMany(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final Optional<JsonDocument> doc = findFirstByContains(db.getConn(), TEST_TABLE, Map.of("value", "purple"),
JsonDocument.class);
assertTrue(doc.isPresent(), "There should have been a document returned");
assertTrue(List.of("four", "five").contains(doc.get().getId()),
String.format("An incorrect document was returned (%s)", doc.get().getId()));
}
public static void firstByContainsMatchOrdered(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final Optional<JsonDocument> doc = findFirstByContains(db.getConn(), TEST_TABLE, Map.of("value", "purple"),
JsonDocument.class, List.of(Field.named("sub.bar NULLS FIRST")));
assertTrue(doc.isPresent(), "There should have been a document returned");
assertEquals("five", doc.get().getId(), "An incorrect document was returned");
}
public static void firstByContainsNoMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertFalse(findFirstByContains(db.getConn(), TEST_TABLE, Map.of("value", "indigo"), JsonDocument.class)
.isPresent(),
"There should have been no document returned");
}
public static void firstByJsonPathMatchOne(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final Optional<JsonDocument> doc = findFirstByJsonPath(db.getConn(), TEST_TABLE, "$.numValue ? (@ == 10)",
JsonDocument.class);
assertTrue(doc.isPresent(), "There should have been a document returned");
assertEquals("two", doc.get().getId(), "An incorrect document was returned");
}
public static void firstByJsonPathMatchMany(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final Optional<JsonDocument> doc = findFirstByJsonPath(db.getConn(), TEST_TABLE, "$.numValue ? (@ > 10)",
JsonDocument.class);
assertTrue(doc.isPresent(), "There should have been a document returned");
assertTrue(List.of("four", "five").contains(doc.get().getId()),
String.format("An incorrect document was returned (%s)", doc.get().getId()));
}
public static void firstByJsonPathMatchOrdered(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final Optional<JsonDocument> doc = findFirstByJsonPath(db.getConn(), TEST_TABLE, "$.numValue ? (@ > 10)",
JsonDocument.class, List.of(Field.named("id DESC")));
assertTrue(doc.isPresent(), "There should have been a document returned");
assertEquals("four", doc.get().getId(), "An incorrect document was returned");
}
public static void firstByJsonPathNoMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertFalse(findFirstByJsonPath(db.getConn(), TEST_TABLE, "$.numValue ? (@ > 100)", JsonDocument.class)
.isPresent(),
"There should have been no document returned");
}
}

8
src/jvm/src/test/java/solutions/bitbadger/documents/java/support/JsonDocument.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/JsonDocument.java
View File

@ -1,13 +1,13 @@
package solutions.bitbadger.documents.java.support;
package solutions.bitbadger.documents.core.tests.java.integration;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.jvm.Document;
import solutions.bitbadger.documents.support.ThrowawayDatabase;
import solutions.bitbadger.documents.java.Document;
import solutions.bitbadger.documents.core.tests.integration.ThrowawayDatabase;
import java.util.List;
import static org.junit.jupiter.api.Assertions.fail;
import static solutions.bitbadger.documents.support.TypesKt.TEST_TABLE;
import static solutions.bitbadger.documents.core.tests.TypesKt.TEST_TABLE;
public class JsonDocument {

32
src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/NumIdDocument.java Normal file
View File

@ -0,0 +1,32 @@
package solutions.bitbadger.documents.core.tests.java.integration;
public class NumIdDocument {
private int key;
private String value;
public int getKey() {
return key;
}
public void setKey(int key) {
this.key = key;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public NumIdDocument(int key, String value) {
this.key = key;
this.value = value;
}
public NumIdDocument() {
this(0, "");
}
}

85
src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/PatchFunctions.java Normal file
View File

@ -0,0 +1,85 @@
package solutions.bitbadger.documents.core.tests.java.integration;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.Field;
import solutions.bitbadger.documents.core.tests.integration.ThrowawayDatabase;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import static org.junit.jupiter.api.Assertions.*;
import static solutions.bitbadger.documents.core.tests.TypesKt.TEST_TABLE;
import static solutions.bitbadger.documents.java.extensions.ConnExt.*;
final public class PatchFunctions {
public static void byIdMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
patchById(db.getConn(), TEST_TABLE, "one", Map.of("numValue", 44));
final Optional<JsonDocument> doc = findById(db.getConn(), TEST_TABLE, "one", JsonDocument.class);
assertTrue(doc.isPresent(), "There should have been a document returned");
assertEquals("one", doc.get().getId(), "An incorrect document was returned");
assertEquals(44, doc.get().getNumValue(), "The document was not patched");
}
public static void byIdNoMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertFalse(existsById(db.getConn(), TEST_TABLE, "forty-seven"),
"Document with ID \"forty-seven\" should not exist");
patchById(db.getConn(), TEST_TABLE, "forty-seven", Map.of("foo", "green")); // no exception = pass
}
public static void byFieldsMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
patchByFields(db.getConn(), TEST_TABLE, List.of(Field.equal("value", "purple")), Map.of("numValue", 77));
assertEquals(2L, countByFields(db.getConn(), TEST_TABLE, List.of(Field.equal("numValue", 77))),
"There should have been 2 documents with numeric value 77");
}
public static void byFieldsNoMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final List<Field<?>> fields = List.of(Field.equal("value", "burgundy"));
assertFalse(existsByFields(db.getConn(), TEST_TABLE, fields),
"There should be no documents with value of \"burgundy\"");
patchByFields(db.getConn(), TEST_TABLE, fields, Map.of("foo", "green")); // no exception = pass
}
public static void byContainsMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final Map<String, String> contains = Map.of("value", "another");
patchByContains(db.getConn(), TEST_TABLE, contains, Map.of("numValue", 12));
final Optional<JsonDocument> doc = findFirstByContains(db.getConn(), TEST_TABLE, contains, JsonDocument.class);
assertTrue(doc.isPresent(), "There should have been a document returned");
assertEquals("two", doc.get().getId(), "The incorrect document was returned");
assertEquals(12, doc.get().getNumValue(), "The document was not updated");
}
public static void byContainsNoMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final Map<String, String> contains = Map.of("value", "updated");
assertFalse(existsByContains(db.getConn(), TEST_TABLE, contains), "There should be no matching documents");
patchByContains(db.getConn(), TEST_TABLE, contains, Map.of("sub.foo", "green")); // no exception = pass
}
public static void byJsonPathMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final String path = "$.numValue ? (@ > 10)";
patchByJsonPath(db.getConn(), TEST_TABLE, path, Map.of("value", "blue"));
final List<JsonDocument> docs = findByJsonPath(db.getConn(), TEST_TABLE, path, JsonDocument.class);
assertEquals(2, docs.size(), "There should have been two documents returned");
for (final JsonDocument doc : docs) {
assertTrue(List.of("four", "five").contains(doc.getId()),
String.format("An incorrect document was returned (%s)", doc.getId()));
assertEquals("blue", doc.getValue(), String.format("The value for ID %s was incorrect", doc.getId()));
}
}
public static void byJsonPathNoMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final String path = "$.numValue ? (@ > 100)";
assertFalse(existsByJsonPath(db.getConn(), TEST_TABLE, path),
"There should be no documents with numeric values over 100");
patchByJsonPath(db.getConn(), TEST_TABLE, path, Map.of("value", "blue")); // no exception = pass
}
}

9
src/jvm/src/test/java/solutions/bitbadger/documents/java/jvm/integration/postgresql/CountIT.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/PostgreSQLCountIT.java
View File

@ -1,16 +1,15 @@
package solutions.bitbadger.documents.java.jvm.integration.postgresql;
package solutions.bitbadger.documents.core.tests.java.integration;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.java.jvm.integration.common.CountFunctions;
import solutions.bitbadger.documents.jvm.integration.postgresql.PgDB;
import solutions.bitbadger.documents.core.tests.integration.PgDB;
/**
* PostgreSQL integration tests for the `Count` object / `count*` connection extension functions
*/
@DisplayName("JVM | Java | PostgreSQL: Count")
public class CountIT {
@DisplayName("Core | Java | PostgreSQL: Count")
public class PostgreSQLCountIT {
@Test
@DisplayName("all counts all documents")

9
src/jvm/src/test/java/solutions/bitbadger/documents/java/jvm/integration/postgresql/CustomIT.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/PostgreSQLCustomIT.java
View File

@ -1,16 +1,15 @@
package solutions.bitbadger.documents.java.jvm.integration.postgresql;
package solutions.bitbadger.documents.core.tests.java.integration;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.jvm.integration.postgresql.PgDB;
import solutions.bitbadger.documents.java.jvm.integration.common.CustomFunctions;
import solutions.bitbadger.documents.core.tests.integration.PgDB;
/**
* PostgreSQL integration tests for the `Custom` object / `custom*` connection extension functions
*/
@DisplayName("JVM | Java | PostgreSQL: Custom")
final public class CustomIT {
@DisplayName("Core | Java | PostgreSQL: Custom")
final public class PostgreSQLCustomIT {
@Test
@DisplayName("list succeeds with empty list")

45
src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/PostgreSQLDefinitionIT.java Normal file
View File

@ -0,0 +1,45 @@
package solutions.bitbadger.documents.core.tests.java.integration;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.core.tests.integration.PgDB;
/**
* PostgreSQL integration tests for the `Definition` object / `ensure*` connection extension functions
*/
@DisplayName("Core | Java | PostgreSQL: Definition")
final public class PostgreSQLDefinitionIT {
@Test
@DisplayName("ensureTable creates table and index")
public void ensureTable() throws DocumentException {
try (PgDB db = new PgDB()) {
DefinitionFunctions.ensuresATable(db);
}
}
@Test
@DisplayName("ensureFieldIndex creates an index")
public void ensureFieldIndex() throws DocumentException {
try (PgDB db = new PgDB()) {
DefinitionFunctions.ensuresAFieldIndex(db);
}
}
@Test
@DisplayName("ensureDocumentIndex creates a full index")
public void ensureDocumentIndexFull() throws DocumentException {
try (PgDB db = new PgDB()) {
DefinitionFunctions.ensureDocumentIndexFull(db);
}
}
@Test
@DisplayName("ensureDocumentIndex creates an optimized index")
public void ensureDocumentIndexOptimized() throws DocumentException {
try (PgDB db = new PgDB()) {
DefinitionFunctions.ensureDocumentIndexOptimized(db);
}
}
}

77
src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/PostgreSQLDeleteIT.java Normal file
View File

@ -0,0 +1,77 @@
package solutions.bitbadger.documents.core.tests.java.integration;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.core.tests.integration.PgDB;
/**
* PostgreSQL integration tests for the `Delete` object / `deleteBy*` connection extension functions
*/
@DisplayName("Core | Java | PostgreSQL: Delete")
final public class PostgreSQLDeleteIT {
@Test
@DisplayName("byId deletes a matching ID")
public void byIdMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
DeleteFunctions.byIdMatch(db);
}
}
@Test
@DisplayName("byId succeeds when no ID matches")
public void byIdNoMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
DeleteFunctions.byIdNoMatch(db);
}
}
@Test
@DisplayName("byFields deletes matching documents")
public void byFieldsMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
DeleteFunctions.byFieldsMatch(db);
}
}
@Test
@DisplayName("byFields succeeds when no documents match")
public void byFieldsNoMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
DeleteFunctions.byFieldsNoMatch(db);
}
}
@Test
@DisplayName("byContains deletes matching documents")
public void byContainsMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
DeleteFunctions.byContainsMatch(db);
}
}
@Test
@DisplayName("byContains succeeds when no documents match")
public void byContainsNoMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
DeleteFunctions.byContainsNoMatch(db);
}
}
@Test
@DisplayName("byJsonPath deletes matching documents")
public void byJsonPathMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
DeleteFunctions.byJsonPathMatch(db);
}
}
@Test
@DisplayName("byJsonPath succeeds when no documents match")
public void byJsonPathNoMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
DeleteFunctions.byJsonPathNoMatch(db);
}
}
}

85
src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/PostgreSQLDocumentIT.java Normal file
View File

@ -0,0 +1,85 @@
package solutions.bitbadger.documents.core.tests.java.integration;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.core.tests.integration.PgDB;
/**
* PostgreSQL integration tests for the `Document` object / `insert`, `save`, `update` connection extension functions
*/
@DisplayName("Core | Java | PostgreSQL: Document")
final public class PostgreSQLDocumentIT {
@Test
@DisplayName("insert works with default values")
public void insertDefault() throws DocumentException {
try (PgDB db = new PgDB()) {
DocumentFunctions.insertDefault(db);
}
}
@Test
@DisplayName("insert fails with duplicate key")
public void insertDupe() throws DocumentException {
try (PgDB db = new PgDB()) {
DocumentFunctions.insertDupe(db);
}
}
@Test
@DisplayName("insert succeeds with numeric auto IDs")
public void insertNumAutoId() throws DocumentException {
try (PgDB db = new PgDB()) {
DocumentFunctions.insertNumAutoId(db);
}
}
@Test
@DisplayName("insert succeeds with UUID auto ID")
public void insertUUIDAutoId() throws DocumentException {
try (PgDB db = new PgDB()) {
DocumentFunctions.insertUUIDAutoId(db);
}
}
@Test
@DisplayName("insert succeeds with random string auto ID")
public void insertStringAutoId() throws DocumentException {
try (PgDB db = new PgDB()) {
DocumentFunctions.insertStringAutoId(db);
}
}
@Test
@DisplayName("save updates an existing document")
public void saveMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
DocumentFunctions.saveMatch(db);
}
}
@Test
@DisplayName("save inserts a new document")
public void saveNoMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
DocumentFunctions.saveNoMatch(db);
}
}
@Test
@DisplayName("update replaces an existing document")
public void updateMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
DocumentFunctions.updateMatch(db);
}
}
@Test
@DisplayName("update succeeds when no document exists")
public void updateNoMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
DocumentFunctions.updateNoMatch(db);
}
}
}

77
src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/PostgreSQLExistsIT.java Normal file
View File

@ -0,0 +1,77 @@
package solutions.bitbadger.documents.core.tests.java.integration;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.core.tests.integration.PgDB;
/**
* PostgreSQL integration tests for the `Exists` object / `existsBy*` connection extension functions
*/
@DisplayName("Core | Java | PostgreSQL: Exists")
final public class PostgreSQLExistsIT {
@Test
@DisplayName("byId returns true when a document matches the ID")
public void byIdMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
ExistsFunctions.byIdMatch(db);
}
}
@Test
@DisplayName("byId returns false when no document matches the ID")
public void byIdNoMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
ExistsFunctions.byIdNoMatch(db);
}
}
@Test
@DisplayName("byFields returns true when documents match")
public void byFieldsMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
ExistsFunctions.byFieldsMatch(db);
}
}
@Test
@DisplayName("byFields returns false when no documents match")
public void byFieldsNoMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
ExistsFunctions.byFieldsNoMatch(db);
}
}
@Test
@DisplayName("byContains returns true when documents match")
public void byContainsMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
ExistsFunctions.byContainsMatch(db);
}
}
@Test
@DisplayName("byContains returns false when no documents match")
public void byContainsNoMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
ExistsFunctions.byContainsNoMatch(db);
}
}
@Test
@DisplayName("byJsonPath returns true when documents match")
public void byJsonPathMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
ExistsFunctions.byJsonPathMatch(db);
}
}
@Test
@DisplayName("byJsonPath returns false when no documents match")
public void byJsonPathNoMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
ExistsFunctions.byJsonPathNoMatch(db);
}
}
}

269
src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/PostgreSQLFindIT.java Normal file
View File

@ -0,0 +1,269 @@
package solutions.bitbadger.documents.core.tests.java.integration;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.core.tests.integration.PgDB;
/**
* PostgreSQL integration tests for the `Find` object / `find*` connection extension functions
*/
@DisplayName("Core | Java | PostgreSQL: Find")
final public class PostgreSQLFindIT {
@Test
@DisplayName("all retrieves all documents")
public void allDefault() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.allDefault(db);
}
}
@Test
@DisplayName("all sorts data ascending")
public void allAscending() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.allAscending(db);
}
}
@Test
@DisplayName("all sorts data descending")
public void allDescending() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.allDescending(db);
}
}
@Test
@DisplayName("all sorts data numerically")
public void allNumOrder() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.allNumOrder(db);
}
}
@Test
@DisplayName("all succeeds with an empty table")
public void allEmpty() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.allEmpty(db);
}
}
@Test
@DisplayName("byId retrieves a document via a string ID")
public void byIdString() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.byIdString(db);
}
}
@Test
@DisplayName("byId retrieves a document via a numeric ID")
public void byIdNumber() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.byIdNumber(db);
}
}
@Test
@DisplayName("byId returns null when a matching ID is not found")
public void byIdNotFound() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.byIdNotFound(db);
}
}
@Test
@DisplayName("byFields retrieves matching documents")
public void byFieldsMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.byFieldsMatch(db);
}
}
@Test
@DisplayName("byFields retrieves ordered matching documents")
public void byFieldsMatchOrdered() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.byFieldsMatchOrdered(db);
}
}
@Test
@DisplayName("byFields retrieves matching documents with a numeric IN clause")
public void byFieldsMatchNumIn() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.byFieldsMatchNumIn(db);
}
}
@Test
@DisplayName("byFields succeeds when no documents match")
public void byFieldsNoMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.byFieldsNoMatch(db);
}
}
@Test
@DisplayName("byFields retrieves matching documents with an IN_ARRAY comparison")
public void byFieldsMatchInArray() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.byFieldsMatchInArray(db);
}
}
@Test
@DisplayName("byFields succeeds when no documents match an IN_ARRAY comparison")
public void byFieldsNoMatchInArray() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.byFieldsNoMatchInArray(db);
}
}
@Test
@DisplayName("byContains retrieves matching documents")
public void byContainsMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.byContainsMatch(db);
}
}
@Test
@DisplayName("byContains retrieves ordered matching documents")
public void byContainsMatchOrdered() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.byContainsMatchOrdered(db);
}
}
@Test
@DisplayName("byContains succeeds when no documents match")
public void byContainsNoMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.byContainsNoMatch(db);
}
}
@Test
@DisplayName("byJsonPath retrieves matching documents")
public void byJsonPathMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.byJsonPathMatch(db);
}
}
@Test
@DisplayName("byJsonPath retrieves ordered matching documents")
public void byJsonPathMatchOrdered() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.byJsonPathMatchOrdered(db);
}
}
@Test
@DisplayName("byJsonPath succeeds when no documents match")
public void byJsonPathNoMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.byJsonPathNoMatch(db);
}
}
@Test
@DisplayName("firstByFields retrieves a matching document")
public void firstByFieldsMatchOne() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.firstByFieldsMatchOne(db);
}
}
@Test
@DisplayName("firstByFields retrieves a matching document among many")
public void firstByFieldsMatchMany() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.firstByFieldsMatchMany(db);
}
}
@Test
@DisplayName("firstByFields retrieves a matching document among many (ordered)")
public void firstByFieldsMatchOrdered() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.firstByFieldsMatchOrdered(db);
}
}
@Test
@DisplayName("firstByFields returns null when no document matches")
public void firstByFieldsNoMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.firstByFieldsNoMatch(db);
}
}
@Test
@DisplayName("firstByContains retrieves a matching document")
public void firstByContainsMatchOne() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.firstByContainsMatchOne(db);
}
}
@Test
@DisplayName("firstByContains retrieves a matching document among many")
public void firstByContainsMatchMany() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.firstByContainsMatchMany(db);
}
}
@Test
@DisplayName("firstByContains retrieves a matching document among many (ordered)")
public void firstByContainsMatchOrdered() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.firstByContainsMatchOrdered(db);
}
}
@Test
@DisplayName("firstByContains returns null when no document matches")
public void firstByContainsNoMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.firstByContainsNoMatch(db);
}
}
@Test
@DisplayName("firstByJsonPath retrieves a matching document")
public void firstByJsonPathMatchOne() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.firstByJsonPathMatchOne(db);
}
}
@Test
@DisplayName("firstByJsonPath retrieves a matching document among many")
public void firstByJsonPathMatchMany() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.firstByJsonPathMatchMany(db);
}
}
@Test
@DisplayName("firstByJsonPath retrieves a matching document among many (ordered)")
public void firstByJsonPathMatchOrdered() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.firstByJsonPathMatchOrdered(db);
}
}
@Test
@DisplayName("firstByJsonPath returns null when no document matches")
public void firstByJsonPathNoMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
FindFunctions.firstByJsonPathNoMatch(db);
}
}
}

77
src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/PostgreSQLPatchIT.java Normal file
View File

@ -0,0 +1,77 @@
package solutions.bitbadger.documents.core.tests.java.integration;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.core.tests.integration.PgDB;
/**
* PostgreSQL integration tests for the `Patch` object / `patchBy*` connection extension functions
*/
@DisplayName("Core | Java | PostgreSQL: Patch")
final public class PostgreSQLPatchIT {
@Test
@DisplayName("byId patches an existing document")
public void byIdMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
PatchFunctions.byIdMatch(db);
}
}
@Test
@DisplayName("byId succeeds for a non-existent document")
public void byIdNoMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
PatchFunctions.byIdNoMatch(db);
}
}
@Test
@DisplayName("byFields patches matching document")
public void byFieldsMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
PatchFunctions.byFieldsMatch(db);
}
}
@Test
@DisplayName("byFields succeeds when no documents match")
public void byFieldsNoMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
PatchFunctions.byFieldsNoMatch(db);
}
}
@Test
@DisplayName("byContains patches matching document")
public void byContainsMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
PatchFunctions.byContainsMatch(db);
}
}
@Test
@DisplayName("byContains succeeds when no documents match")
public void byContainsNoMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
PatchFunctions.byContainsNoMatch(db);
}
}
@Test
@DisplayName("byJsonPath patches matching document")
public void byJsonPathMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
PatchFunctions.byJsonPathMatch(db);
}
}
@Test
@DisplayName("byJsonPath succeeds when no documents match")
public void byJsonPathNoMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
PatchFunctions.byJsonPathNoMatch(db);
}
}
}

109
src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/PostgreSQLRemoveFieldsIT.java Normal file
View File

@ -0,0 +1,109 @@
package solutions.bitbadger.documents.core.tests.java.integration;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.core.tests.integration.PgDB;
/**
* PostgreSQL integration tests for the `RemoveFields` object / `removeFieldsBy*` connection extension functions
*/
@DisplayName("Core | Java | PostgreSQL: RemoveFields")
final public class PostgreSQLRemoveFieldsIT {
@Test
@DisplayName("byId removes fields from an existing document")
public void byIdMatchFields() throws DocumentException {
try (PgDB db = new PgDB()) {
RemoveFieldsFunctions.byIdMatchFields(db);
}
}
@Test
@DisplayName("byId succeeds when fields do not exist on an existing document")
public void byIdMatchNoFields() throws DocumentException {
try (PgDB db = new PgDB()) {
RemoveFieldsFunctions.byIdMatchNoFields(db);
}
}
@Test
@DisplayName("byId succeeds when no document exists")
public void byIdNoMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
RemoveFieldsFunctions.byIdNoMatch(db);
}
}
@Test
@DisplayName("byFields removes fields from matching documents")
public void byFieldsMatchFields() throws DocumentException {
try (PgDB db = new PgDB()) {
RemoveFieldsFunctions.byFieldsMatchFields(db);
}
}
@Test
@DisplayName("byFields succeeds when fields do not exist on matching documents")
public void byFieldsMatchNoFields() throws DocumentException {
try (PgDB db = new PgDB()) {
RemoveFieldsFunctions.byFieldsMatchNoFields(db);
}
}
@Test
@DisplayName("byFields succeeds when no matching documents exist")
public void byFieldsNoMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
RemoveFieldsFunctions.byFieldsNoMatch(db);
}
}
@Test
@DisplayName("byContains removes fields from matching documents")
public void byContainsMatchFields() throws DocumentException {
try (PgDB db = new PgDB()) {
RemoveFieldsFunctions.byContainsMatchFields(db);
}
}
@Test
@DisplayName("byContains succeeds when fields do not exist on matching documents")
public void byContainsMatchNoFields() throws DocumentException {
try (PgDB db = new PgDB()) {
RemoveFieldsFunctions.byContainsMatchNoFields(db);
}
}
@Test
@DisplayName("byContains succeeds when no matching documents exist")
public void byContainsNoMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
RemoveFieldsFunctions.byContainsNoMatch(db);
}
}
@Test
@DisplayName("byJsonPath removes fields from matching documents")
public void byJsonPathMatchFields() throws DocumentException {
try (PgDB db = new PgDB()) {
RemoveFieldsFunctions.byJsonPathMatchFields(db);
}
}
@Test
@DisplayName("byJsonPath succeeds when fields do not exist on matching documents")
public void byJsonPathMatchNoFields() throws DocumentException {
try (PgDB db = new PgDB()) {
RemoveFieldsFunctions.byJsonPathMatchNoFields(db);
}
}
@Test
@DisplayName("byJsonPath succeeds when no matching documents exist")
public void byJsonPathNoMatch() throws DocumentException {
try (PgDB db = new PgDB()) {
RemoveFieldsFunctions.byJsonPathNoMatch(db);
}
}
}

115
src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/RemoveFieldsFunctions.java Normal file
View File

@ -0,0 +1,115 @@
package solutions.bitbadger.documents.core.tests.java.integration;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.Field;
import solutions.bitbadger.documents.core.tests.integration.ThrowawayDatabase;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import static org.junit.jupiter.api.Assertions.*;
import static solutions.bitbadger.documents.core.tests.TypesKt.TEST_TABLE;
import static solutions.bitbadger.documents.java.extensions.ConnExt.*;
final public class RemoveFieldsFunctions {
public static void byIdMatchFields(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
removeFieldsById(db.getConn(), TEST_TABLE, "two", List.of("sub", "value"));
final Optional<JsonDocument> doc = findById(db.getConn(), TEST_TABLE, "two", JsonDocument.class);
assertTrue(doc.isPresent(), "There should have been a document returned");
assertEquals("", doc.get().getValue(), "The value should have been empty");
assertNull(doc.get().getSub(), "The sub-document should have been removed");
}
public static void byIdMatchNoFields(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertFalse(existsByFields(db.getConn(), TEST_TABLE, List.of(Field.exists("a_field_that_does_not_exist"))));
removeFieldsById(db.getConn(), TEST_TABLE, "one", List.of("a_field_that_does_not_exist")); // no exn = pass
}
public static void byIdNoMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertFalse(existsById(db.getConn(), TEST_TABLE, "fifty"));
removeFieldsById(db.getConn(), TEST_TABLE, "fifty", List.of("sub")); // no exception = pass
}
public static void byFieldsMatchFields(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final List<Field<?>> fields = List.of(Field.equal("numValue", 17));
removeFieldsByFields(db.getConn(), TEST_TABLE, fields, List.of("sub"));
final Optional<JsonDocument> doc = findFirstByFields(db.getConn(), TEST_TABLE, fields, JsonDocument.class);
assertTrue(doc.isPresent(), "The document should have been returned");
assertEquals("four", doc.get().getId(), "An incorrect document was returned");
assertNull(doc.get().getSub(), "The sub-document should have been removed");
}
public static void byFieldsMatchNoFields(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertFalse(existsByFields(db.getConn(), TEST_TABLE, List.of(Field.exists("nada"))));
removeFieldsByFields(db.getConn(), TEST_TABLE, List.of(Field.equal("numValue", 17)), List.of("nada"));
// no exception = pass
}
public static void byFieldsNoMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final List<Field<?>> fields = List.of(Field.notEqual("missing", "nope"));
assertFalse(existsByFields(db.getConn(), TEST_TABLE, fields));
removeFieldsByFields(db.getConn(), TEST_TABLE, fields, List.of("value")); // no exception = pass
}
public static void byContainsMatchFields(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final Map<String, Map<String, String>> criteria = Map.of("sub", Map.of("foo", "green"));
removeFieldsByContains(db.getConn(), TEST_TABLE, criteria, List.of("value"));
final List<JsonDocument> docs = findByContains(db.getConn(), TEST_TABLE, criteria, JsonDocument.class);
assertEquals(2, docs.size(), "There should have been 2 documents returned");
for (final JsonDocument doc : docs) {
assertTrue(List.of("two", "four").contains(doc.getId()),
String.format("An incorrect document was returned (%s)", doc.getId()));
assertEquals("", doc.getValue(), "The value should have been empty");
}
}
public static void byContainsMatchNoFields(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertFalse(existsByFields(db.getConn(), TEST_TABLE, List.of(Field.exists("invalid_field"))));
removeFieldsByContains(db.getConn(), TEST_TABLE, Map.of("sub", Map.of("foo", "green")),
List.of("invalid_field")); // no exception = pass
}
public static void byContainsNoMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final Map<String, String> contains = Map.of("value", "substantial");
assertFalse(existsByContains(db.getConn(), TEST_TABLE, contains));
removeFieldsByContains(db.getConn(), TEST_TABLE, contains, List.of("numValue")); // no exception = pass
}
public static void byJsonPathMatchFields(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final String path = "$.value ? (@ == \"purple\")";
removeFieldsByJsonPath(db.getConn(), TEST_TABLE, path, List.of("sub"));
final List<JsonDocument> docs = findByJsonPath(db.getConn(), TEST_TABLE, path, JsonDocument.class);
assertEquals(2, docs.size(), "There should have been 2 documents returned");
for (final JsonDocument doc : docs) {
assertTrue(List.of("four", "five").contains(doc.getId()),
String.format("An incorrect document was returned (%s)", doc.getId()));
assertNull(doc.getSub(), "The sub-document should have been removed");
}
}
public static void byJsonPathMatchNoFields(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
assertFalse(existsByFields(db.getConn(), TEST_TABLE, List.of(Field.exists("submarine"))));
removeFieldsByJsonPath(db.getConn(), TEST_TABLE, "$.value ? (@ == \"purple\")", List.of("submarine"));
// no exception = pass
}
public static void byJsonPathNoMatch(ThrowawayDatabase db) throws DocumentException {
JsonDocument.load(db);
final String path = "$.value ? (@ == \"mauve\")";
assertFalse(existsByJsonPath(db.getConn(), TEST_TABLE, path));
removeFieldsByJsonPath(db.getConn(), TEST_TABLE, path, List.of("value")); // no exception = pass
}
}

9
src/jvm/src/test/java/solutions/bitbadger/documents/java/jvm/integration/sqlite/CountIT.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/SQLiteCountIT.java
View File

@ -1,18 +1,17 @@
package solutions.bitbadger.documents.java.jvm.integration.sqlite;
package solutions.bitbadger.documents.core.tests.java.integration;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.java.jvm.integration.common.CountFunctions;
import solutions.bitbadger.documents.jvm.integration.sqlite.SQLiteDB;
import solutions.bitbadger.documents.core.tests.integration.SQLiteDB;
import static org.junit.jupiter.api.Assertions.assertThrows;
/**
* SQLite integration tests for the `Count` object / `count*` connection extension functions
*/
@DisplayName("JVM | Java | SQLite: Count")
public class CountIT {
@DisplayName("Core | Java | SQLite: Count")
public class SQLiteCountIT {
@Test
@DisplayName("all counts all documents")

9
src/jvm/src/test/java/solutions/bitbadger/documents/java/jvm/integration/sqlite/CustomIT.java → src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/SQLiteCustomIT.java
View File

@ -1,16 +1,15 @@
package solutions.bitbadger.documents.java.jvm.integration.sqlite;
package solutions.bitbadger.documents.core.tests.java.integration;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.java.jvm.integration.common.CustomFunctions;
import solutions.bitbadger.documents.jvm.integration.sqlite.SQLiteDB;
import solutions.bitbadger.documents.core.tests.integration.SQLiteDB;
/**
* SQLite integration tests for the `Custom` object / `custom*` connection extension functions
*/
@DisplayName("JVM | Java | SQLite: Custom")
final public class CustomIT {
@DisplayName("Core | Java | SQLite: Custom")
final public class SQLiteCustomIT {
@Test
@DisplayName("list succeeds with empty list")

47
src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/SQLiteDefinitionIT.java Normal file
View File

@ -0,0 +1,47 @@
package solutions.bitbadger.documents.core.tests.java.integration;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.core.tests.integration.SQLiteDB;
import static org.junit.jupiter.api.Assertions.assertThrows;
/**
* SQLite integration tests for the `Definition` object / `ensure*` connection extension functions
*/
@DisplayName("Core | Java | SQLite: Definition")
final public class SQLiteDefinitionIT {
@Test
@DisplayName("ensureTable creates table and index")
public void ensureTable() throws DocumentException {
try (SQLiteDB db = new SQLiteDB()) {
DefinitionFunctions.ensuresATable(db);
}
}
@Test
@DisplayName("ensureFieldIndex creates an index")
public void ensureFieldIndex() throws DocumentException {
try (SQLiteDB db = new SQLiteDB()) {
DefinitionFunctions.ensuresAFieldIndex(db);
}
}
@Test
@DisplayName("ensureDocumentIndex fails for full index")
public void ensureDocumentIndexFull() {
try (SQLiteDB db = new SQLiteDB()) {
assertThrows(DocumentException.class, () -> DefinitionFunctions.ensureDocumentIndexFull(db));
}
}
@Test
@DisplayName("ensureDocumentIndex fails for optimized index")
public void ensureDocumentIndexOptimized() {
try (SQLiteDB db = new SQLiteDB()) {
assertThrows(DocumentException.class, () -> DefinitionFunctions.ensureDocumentIndexOptimized(db));
}
}
}

63
src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/SQLiteDeleteIT.java Normal file
View File

@ -0,0 +1,63 @@
package solutions.bitbadger.documents.core.tests.java.integration;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.core.tests.integration.SQLiteDB;
import static org.junit.jupiter.api.Assertions.assertThrows;
/**
* SQLite integration tests for the `Delete` object / `deleteBy*` connection extension functions
*/
@DisplayName("Core | Java | SQLite: Delete")
final public class SQLiteDeleteIT {
@Test
@DisplayName("byId deletes a matching ID")
public void byIdMatch() throws DocumentException {
try (SQLiteDB db = new SQLiteDB()) {
DeleteFunctions.byIdMatch(db);
}
}
@Test
@DisplayName("byId succeeds when no ID matches")
public void byIdNoMatch() throws DocumentException {
try (SQLiteDB db = new SQLiteDB()) {
DeleteFunctions.byIdNoMatch(db);
}
}
@Test
@DisplayName("byFields deletes matching documents")
public void byFieldsMatch() throws DocumentException {
try (SQLiteDB db = new SQLiteDB()) {
DeleteFunctions.byFieldsMatch(db);
}
}
@Test
@DisplayName("byFields succeeds when no documents match")
public void byFieldsNoMatch() throws DocumentException {
try (SQLiteDB db = new SQLiteDB()) {
DeleteFunctions.byFieldsNoMatch(db);
}
}
@Test
@DisplayName("byContains fails")
public void byContainsMatch() {
try (SQLiteDB db = new SQLiteDB()) {
assertThrows(DocumentException.class, () -> DeleteFunctions.byContainsMatch(db));
}
}
@Test
@DisplayName("byJsonPath fails")
public void byJsonPathMatch() {
try (SQLiteDB db = new SQLiteDB()) {
assertThrows(DocumentException.class, () -> DeleteFunctions.byJsonPathMatch(db));
}
}
}

84
src/core/src/test/java/solutions/bitbadger/documents/core/tests/java/integration/SQLiteDocumentIT.java Normal file
View File

@ -0,0 +1,84 @@
package solutions.bitbadger.documents.core.tests.java.integration;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import solutions.bitbadger.documents.DocumentException;
import solutions.bitbadger.documents.core.tests.integration.SQLiteDB;
/**
* SQLite integration tests for the `Document` object / `insert`, `save`, `update` connection extension functions
*/
@DisplayName("Core | Java | SQLite: Document")
final public class SQLiteDocumentIT {
@Test
@DisplayName("insert works with default values")
public void insertDefault() throws DocumentException {
try (SQLiteDB db = new SQLiteDB()) {
DocumentFunctions.insertDefault(db);
}
}
@Test
@DisplayName("insert fails with duplicate key")
public void insertDupe() throws DocumentException {
try (SQLiteDB db = new SQLiteDB()) {
DocumentFunctions.insertDupe(db);
}
}
@Test
@DisplayName("insert succeeds with numeric auto IDs")
public void insertNumAutoId() throws DocumentException {
try (SQLiteDB db = new SQLiteDB()) {
DocumentFunctions.insertNumAutoId(db);
}
}
@Test
@DisplayName("insert succeeds with UUID auto ID")
public void insertUUIDAutoId() throws DocumentException {
try (SQLiteDB db = new SQLiteDB()) {
DocumentFunctions.insertUUIDAutoId(db);
}
}
@Test
@DisplayName("insert succeeds with random string auto ID")
public void insertStringAutoId() throws DocumentException {
try (SQLiteDB db = new SQLiteDB()) {
DocumentFunctions.insertStringAutoId(db);
}
}
@Test
@DisplayName("save updates an existing document")
public void saveMatch() throws DocumentException {
try (SQLiteDB db = new SQLiteDB()) {
DocumentFunctions.saveMatch(db);
}
}
@Test
@DisplayName("save inserts a new document")
public void saveNoMatch() throws DocumentException {
try (SQLiteDB db = new SQLiteDB()) {
DocumentFunctions.saveNoMatch(db);
}
}
@Test
@DisplayName("update replaces an existing document")
public void updateMatch() throws DocumentException {
try (SQLiteDB db = new SQLiteDB()) {
DocumentFunctions.updateMatch(db);
}
}
@Test
@DisplayName("update succeeds when no document exists")
public void updateNoMatch() throws DocumentException {
try (SQLiteDB db = new SQLiteDB()) {
DocumentFunctions.updateNoMatch(db);
}
}
}

Some files were not shown because too many files have changed in this diff Show More