diff --git a/exposed-tests/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/DDLTests.kt b/exposed-tests/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/DDLTests.kt index cb0ae49c59..565294e362 100644 --- a/exposed-tests/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/DDLTests.kt +++ b/exposed-tests/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/DDLTests.kt @@ -10,7 +10,6 @@ import org.jetbrains.exposed.exceptions.ExposedSQLException import org.jetbrains.exposed.exceptions.UnsupportedByDialectException import org.jetbrains.exposed.sql.* import org.jetbrains.exposed.sql.SqlExpressionBuilder.plus -import org.jetbrains.exposed.sql.statements.api.ExposedBlob import org.jetbrains.exposed.sql.tests.DatabaseTestsBase import org.jetbrains.exposed.sql.tests.TestDB import org.jetbrains.exposed.sql.tests.currentDialectTest @@ -20,15 +19,12 @@ import org.jetbrains.exposed.sql.transactions.transaction import org.jetbrains.exposed.sql.vendors.H2Dialect import org.jetbrains.exposed.sql.vendors.MysqlDialect import org.jetbrains.exposed.sql.vendors.OracleDialect -import org.jetbrains.exposed.sql.vendors.PostgreSQLDialect import org.jetbrains.exposed.sql.vendors.SQLServerDialect import org.jetbrains.exposed.sql.vendors.SQLiteDialect import org.junit.Assume import org.junit.Test import org.postgresql.util.PGobject import java.util.* -import kotlin.random.Random -import kotlin.test.assertContentEquals import kotlin.test.assertNotNull import kotlin.test.expect @@ -601,124 +597,6 @@ class DDLTests : DatabaseTestsBase() { } } - @Test - fun testBlob() { - val t = object : Table("t1") { - val id = integer("id").autoIncrement() - val b = blob("blob") - - override val primaryKey = PrimaryKey(id) - } - - withTables(t) { - val shortBytes = "Hello there!".toByteArray() - val longBytes = Random.nextBytes(1024) - val shortBlob = ExposedBlob(shortBytes) - val longBlob = ExposedBlob(longBytes) - - val id1 = t.insert { - it[t.b] = shortBlob - } get (t.id) - - val id2 = t.insert { - it[t.b] = longBlob - } get (t.id) - - val id3 = t.insert { - it[t.b] = blobParam(ExposedBlob(shortBytes)) - } get (t.id) - - val readOn1 = t.selectAll().where { t.id eq id1 }.first()[t.b] - val text1 = String(readOn1.bytes) - val text2 = readOn1.inputStream.bufferedReader().readText() - - assertEquals("Hello there!", text1) - assertEquals("Hello there!", text2) - - val readOn2 = t.selectAll().where { t.id eq id2 }.first()[t.b] - val bytes1 = readOn2.bytes - val bytes2 = readOn2.inputStream.readBytes() - - assertTrue(longBytes.contentEquals(bytes1)) - assertTrue(longBytes.contentEquals(bytes2)) - - val bytes3 = t.selectAll().where { t.id eq id3 }.first()[t.b].inputStream.readBytes() - assertTrue(shortBytes.contentEquals(bytes3)) - } - } - - @Test - fun testBlobDefault() { - val defaultBlobStr = "test" - val defaultBlob = ExposedBlob(defaultBlobStr.encodeToByteArray()) - - val testTable = object : Table("TestTable") { - val number = integer("number") - val blobWithDefault = blob("blobWithDefault") - .default(defaultBlob) - } - - withDb { testDb -> - when (testDb) { - TestDB.MYSQL -> { - expectException { - SchemaUtils.create(testTable) - } - } - else -> { - SchemaUtils.create(testTable) - - testTable.insert { - it[number] = 1 - } - assertEquals(defaultBlobStr, String(testTable.selectAll().first()[testTable.blobWithDefault].bytes)) - - SchemaUtils.drop(testTable) - } - } - } - } - - @Test - fun testBlobAsOid() { - val defaultBytes = "test".toByteArray() - val defaultBlob = ExposedBlob(defaultBytes) - val tester = object : Table("blob_tester") { - val blobCol = blob("blob_col", useObjectIdentifier = true).default(defaultBlob) - } - - withDb { - if (currentDialectTest !is PostgreSQLDialect) { - expectException { - SchemaUtils.create(tester) - } - } else { - assertEquals("oid", tester.blobCol.descriptionDdl().split(" ")[1]) - SchemaUtils.create(tester) - - tester.insert {} - - val result1 = tester.selectAll().single()[tester.blobCol] - assertContentEquals(defaultBytes, result1.bytes) - - tester.insert { - defaultBlob.inputStream.reset() - it[blobCol] = defaultBlob - } - tester.insert { - defaultBlob.inputStream.reset() - it[blobCol] = blobParam(defaultBlob, useObjectIdentifier = true) - } - - val result2 = tester.selectAll() - assertEquals(3, result2.count()) - assertTrue(result2.all { it[tester.blobCol].bytes.contentEquals(defaultBytes) }) - - SchemaUtils.drop(tester) - } - } - } - @Test fun testBinaryWithoutLength() { val tableWithBinary = object : Table("TableWithBinary") { diff --git a/exposed-tests/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/entities/EntityTests.kt b/exposed-tests/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/entities/EntityTests.kt index e93105a1fb..ad1f386478 100644 --- a/exposed-tests/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/entities/EntityTests.kt +++ b/exposed-tests/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/entities/EntityTests.kt @@ -8,7 +8,6 @@ import org.jetbrains.exposed.dao.id.IntIdTable import org.jetbrains.exposed.dao.id.LongIdTable import org.jetbrains.exposed.sql.* import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq -import org.jetbrains.exposed.sql.statements.api.ExposedBlob import org.jetbrains.exposed.sql.tests.DatabaseTestsBase import org.jetbrains.exposed.sql.tests.TestDB import org.jetbrains.exposed.sql.tests.currentDialectTest @@ -34,7 +33,6 @@ object EntityTestsData { } val x = bool("x").default(true) - val blob = blob("content").nullable() override val primaryKey = PrimaryKey(id) } @@ -90,7 +88,6 @@ object EntityTestsData { class YEntity(id: EntityID) : Entity(id) { var x by YTable.x val b: BEntity? by BEntity.backReferencedOn(XTable.y1) - var content by YTable.blob companion object : EntityClass(YTable) } @@ -125,28 +122,6 @@ class EntityTests : DatabaseTestsBase() { } } - @Test - fun testBlobField() { - withTables(EntityTestsData.YTable) { - val y1 = EntityTestsData.YEntity.new { - x = false - content = ExposedBlob("foo".toByteArray()) - } - - flushCache() - var y2 = EntityTestsData.YEntity.reload(y1)!! - assertEquals(String(y2.content!!.bytes), "foo") - - y2.content = null - flushCache() - y2 = EntityTestsData.YEntity.reload(y1)!! - assertNull(y2.content) - - y2.content = ExposedBlob("foo2".toByteArray()) - flushCache() - } - } - @Test fun testTextFieldOutsideTheTransaction() { val objectsToVerify = arrayListOf>() diff --git a/exposed-tests/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/entities/EntityWithBlobTests.kt b/exposed-tests/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/entities/EntityWithBlobTests.kt new file mode 100644 index 0000000000..bc562f21e7 --- /dev/null +++ b/exposed-tests/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/entities/EntityWithBlobTests.kt @@ -0,0 +1,55 @@ +package org.jetbrains.exposed.sql.tests.shared.entities + +import org.jetbrains.exposed.dao.Entity +import org.jetbrains.exposed.dao.EntityClass +import org.jetbrains.exposed.dao.flushCache +import org.jetbrains.exposed.dao.id.EntityID +import org.jetbrains.exposed.dao.id.IdTable +import org.jetbrains.exposed.sql.Column +import org.jetbrains.exposed.sql.statements.api.ExposedBlob +import org.jetbrains.exposed.sql.tests.DatabaseTestsBase +import org.jetbrains.exposed.sql.tests.shared.assertEquals +import org.jetbrains.exposed.sql.tests.shared.entities.EntityTestsData.YTable +import org.junit.Test +import java.util.* +import kotlin.test.assertNull + +class EntityWithBlobTests : DatabaseTestsBase() { + + object BlobTable : IdTable("YTable") { + override val id: Column> = varchar("uuid", 36).entityId().clientDefault { + EntityID(UUID.randomUUID().toString(), YTable) + } + + val blob = blob("content").nullable() + + override val primaryKey = PrimaryKey(id) + } + + class BlobEntity(id: EntityID) : Entity(id) { + var content by BlobTable.blob + + companion object : EntityClass(BlobTable) + } + + @Test + fun testBlobField() { + withTables(BlobTable) { + val y1 = BlobEntity.new { + content = ExposedBlob("foo".toByteArray()) + } + + flushCache() + var y2 = BlobEntity.reload(y1)!! + assertEquals(String(y2.content!!.bytes), "foo") + + y2.content = null + flushCache() + y2 = BlobEntity.reload(y1)!! + assertNull(y2.content) + + y2.content = ExposedBlob("foo2".toByteArray()) + flushCache() + } + } +} diff --git a/exposed-tests/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/types/BlobColumnTypeTests.kt b/exposed-tests/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/types/BlobColumnTypeTests.kt index 198da458dc..7d681f7de0 100644 --- a/exposed-tests/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/types/BlobColumnTypeTests.kt +++ b/exposed-tests/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/types/BlobColumnTypeTests.kt @@ -1,13 +1,25 @@ package org.jetbrains.exposed.sql.tests.shared.types -import junit.framework.TestCase.assertEquals import org.jetbrains.exposed.dao.id.IntIdTable +import org.jetbrains.exposed.exceptions.ExposedSQLException +import org.jetbrains.exposed.sql.SchemaUtils +import org.jetbrains.exposed.sql.Table import org.jetbrains.exposed.sql.alias +import org.jetbrains.exposed.sql.blobParam import org.jetbrains.exposed.sql.insert +import org.jetbrains.exposed.sql.selectAll import org.jetbrains.exposed.sql.statements.api.ExposedBlob import org.jetbrains.exposed.sql.tests.DatabaseTestsBase +import org.jetbrains.exposed.sql.tests.TestDB +import org.jetbrains.exposed.sql.tests.currentDialectTest +import org.jetbrains.exposed.sql.tests.shared.assertEquals +import org.jetbrains.exposed.sql.tests.shared.assertTrue +import org.jetbrains.exposed.sql.tests.shared.expectException +import org.jetbrains.exposed.sql.vendors.PostgreSQLDialect import org.junit.Test import java.nio.charset.Charset +import kotlin.random.Random +import kotlin.test.assertContentEquals class BlobColumnTypeTests : DatabaseTestsBase() { object BlobTable : IntIdTable("test-blob") { @@ -27,4 +39,115 @@ class BlobColumnTypeTests : DatabaseTestsBase() { assertEquals(content, sampleData) } } + + @Test + fun testBlob() { + withTables(BlobTable) { + val shortBytes = "Hello there!".toByteArray() + val longBytes = Random.nextBytes(1024) + val shortBlob = ExposedBlob(shortBytes) + val longBlob = ExposedBlob(longBytes) + + val id1 = BlobTable.insert { + it[content] = shortBlob + } get (BlobTable.id) + + val id2 = BlobTable.insert { + it[content] = longBlob + } get (BlobTable.id) + + val id3 = BlobTable.insert { + it[content] = blobParam(ExposedBlob(shortBytes)) + } get (BlobTable.id) + + val readOn1 = BlobTable.selectAll().where { BlobTable.id eq id1 }.first()[BlobTable.content] + val text1 = String(readOn1.bytes) + val text2 = readOn1.inputStream.bufferedReader().readText() + + assertEquals("Hello there!", text1) + assertEquals("Hello there!", text2) + + val readOn2 = BlobTable.selectAll().where { BlobTable.id eq id2 }.first()[BlobTable.content] + val bytes1 = readOn2.bytes + val bytes2 = readOn2.inputStream.readBytes() + + assertTrue(longBytes.contentEquals(bytes1)) + assertTrue(longBytes.contentEquals(bytes2)) + + val bytes3 = BlobTable.selectAll().where { BlobTable.id eq id3 }.first()[BlobTable.content].inputStream.readBytes() + assertTrue(shortBytes.contentEquals(bytes3)) + } + } + + @Test + fun testBlobDefault() { + val defaultBlobStr = "test" + val defaultBlob = ExposedBlob(defaultBlobStr.encodeToByteArray()) + + val testTable = object : Table("TestTable") { + val number = integer("number") + val blobWithDefault = blob("blobWithDefault").default(defaultBlob) + } + + withDb { testDb -> + when (testDb) { + TestDB.MYSQL -> { + expectException { + SchemaUtils.create(testTable) + } + } + + else -> { + SchemaUtils.create(testTable) + + testTable.insert { + it[number] = 1 + } + assertEquals(defaultBlobStr, String(testTable.selectAll().first()[testTable.blobWithDefault].bytes)) + + SchemaUtils.drop(testTable) + } + } + } + } + + @Test + fun testBlobAsOid() { + val defaultBytes = "test".toByteArray() + val defaultBlob = ExposedBlob(defaultBytes) + val tester = object : Table("blob_tester") { + val blobCol = blob("blob_col", useObjectIdentifier = true).default(defaultBlob) + } + + withDb { + if (currentDialectTest !is PostgreSQLDialect) { + expectException { + SchemaUtils.create(tester) + } + } else { + assertEquals("oid", tester.blobCol.descriptionDdl().split(" ")[1]) + SchemaUtils.create(tester) + + tester.insert {} + + val result1 = tester.selectAll().single()[tester.blobCol] + assertContentEquals(defaultBytes, result1.bytes) + + tester.insert { + defaultBlob.inputStream.reset() + it[blobCol] = defaultBlob + } + tester.insert { + defaultBlob.inputStream.reset() + it[blobCol] = blobParam(defaultBlob, useObjectIdentifier = true) + } + + val result2 = tester.selectAll() + assertEquals(3, result2.count()) + assertTrue(result2.all { it[tester.blobCol].bytes.contentEquals(defaultBytes) }) + + SchemaUtils.drop(tester) + } + } + } }