diff --git a/.github/workflows/meterian.yml b/.github/workflows/meterian.yml
index d6d3956808..2695cb2a9e 100644
--- a/.github/workflows/meterian.yml
+++ b/.github/workflows/meterian.yml
@@ -23,5 +23,10 @@ jobs:
uses: actions/checkout@v4
- name: Meterian Scanner
uses: MeterianHQ/meterian-github-action@v1.0.17
- env:
- METERIAN_API_TOKEN: ${{ secrets.METERIAN_API_TOKEN }}
+ with:
+ cli_args: "--report-sarif=report.sarif"
+ oss: true
+ - uses: github/codeql-action/upload-sarif@v3
+ if: success() || failure()
+ with:
+ sarif_file: report.sarif
diff --git a/.github/workflows/mvn-deploy.yml b/.github/workflows/mvn-deploy.yml
index b3ab95f801..02e72a3ff8 100644
--- a/.github/workflows/mvn-deploy.yml
+++ b/.github/workflows/mvn-deploy.yml
@@ -11,14 +11,11 @@ jobs:
runs-on: ubuntu-latest
steps:
- - uses: xembly/workflow-manager@v1
+ - uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4.2.1
+ - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3 # v5.2.0
with:
- token: ${{ secrets.GITHUB_TOKEN }}
- run: clean, cancel
- verbose: false
- - uses: actions/checkout@v4
- - uses: actions/setup-python@v5
- - uses: pre-commit/action@v3.0.1
+ python-version: "3.13.0"
+ - uses: pre-commit/action@2c7b3805fd2a0fd8c1884dcaebf91fc102a13ecd # v3.0.1
- name: Login to Docker Hub
uses: docker/login-action@v3
@@ -32,11 +29,11 @@ jobs:
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v3
- - name: Set up JDK 11
+ - name: Set up JDK 17
uses: actions/setup-java@v4
with:
distribution: "temurin"
- java-version: 11
+ java-version: 17
cache: "maven"
server-id: ossrh
server-username: MAVEN_USERNAME
diff --git a/.github/workflows/mvn-release.yml b/.github/workflows/mvn-release.yml
index 89a08b7dae..9de79ae3e2 100644
--- a/.github/workflows/mvn-release.yml
+++ b/.github/workflows/mvn-release.yml
@@ -26,11 +26,11 @@ jobs:
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v3
- - name: Set up JDK 11
+ - name: Set up JDK 17
uses: actions/setup-java@v4
with:
distribution: "temurin"
- java-version: 11
+ java-version: 17
cache: "maven"
server-id: ossrh
server-username: MAVEN_USERNAME
diff --git a/.github/workflows/mvn-test.yml b/.github/workflows/mvn-test.yml
index c084fa0c9f..8dc5cb73fb 100644
--- a/.github/workflows/mvn-test.yml
+++ b/.github/workflows/mvn-test.yml
@@ -14,14 +14,11 @@ jobs:
runs-on: ubuntu-latest
steps:
- - uses: xembly/workflow-manager@v1
+ - uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4.2.1
+ - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3 # v5.2.0
with:
- token: ${{ secrets.GITHUB_TOKEN }}
- run: clean, cancel
- verbose: false
- - uses: actions/checkout@v4
- - uses: actions/setup-python@v5
- - uses: pre-commit/action@v3.0.1
+ python-version: "3.13.0"
+ - uses: pre-commit/action@2c7b3805fd2a0fd8c1884dcaebf91fc102a13ecd # v3.0.1
- name: Set up QEMU
uses: docker/setup-qemu-action@v3
@@ -29,11 +26,11 @@ jobs:
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v3
- - name: Set up JDK 11
+ - name: Set up JDK 17
uses: actions/setup-java@v4
with:
distribution: "temurin"
- java-version: 11
+ java-version: 17
cache: "maven"
- name: Install jars
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 686b176b06..cab27eeb96 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,6 +1,6 @@
repos:
- repo: https://github.com/pre-commit/pre-commit-hooks
- rev: v4.5.0
+ rev: v5.0.0
hooks:
- id: fix-byte-order-marker
- id: trailing-whitespace
diff --git a/console/pom.xml b/console/pom.xml
index 2bf074ba59..985fc40e2a 100644
--- a/console/pom.xml
+++ b/console/pom.xml
@@ -25,12 +25,12 @@
com.arcadedb
arcadedb-parent
- 24.8.1-SNAPSHOT
+ 24.11.1-SNAPSHOT
../pom.xml
- 3.26.3
+ 3.27.1
arcadedb-console
diff --git a/console/src/test/java/com/arcadedb/console/CompositeIndexUpdateTest.java b/console/src/test/java/com/arcadedb/console/CompositeIndexUpdateTest.java
index 2af8591f7d..906e303556 100644
--- a/console/src/test/java/com/arcadedb/console/CompositeIndexUpdateTest.java
+++ b/console/src/test/java/com/arcadedb/console/CompositeIndexUpdateTest.java
@@ -39,14 +39,19 @@
import com.arcadedb.server.TestServerHelper;
import com.arcadedb.utility.FileUtils;
import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
-import java.io.*;
-import java.time.*;
-import java.util.*;
-import java.util.concurrent.atomic.*;
+import java.io.File;
+import java.io.PrintStream;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
/**
* Issue https://github.com/ArcadeData/arcadedb/issues/1233
@@ -153,16 +158,16 @@ public void testWhereAfterAsyncInsert() {
System.out.println();
// insert TOTAL_ORDERS orders
- Assertions.assertEquals(insertOrders(database, TOTAL_ORDERS).get("totalRows"), TOTAL_ORDERS);
+ assertThat(TOTAL_ORDERS).isEqualTo(insertOrders(database, TOTAL_ORDERS).get("totalRows"));
// retrieve next eligible, it should return order id = 1
- Assertions.assertEquals(retrieveNextEligibleOrder(database), 1);
+ assertThat(retrieveNextEligibleOrder(database)).isEqualTo(1);
// update order 1 to ERROR
updateOrderAsync(database, 1, "ERROR", LocalDateTime.now(), LocalDateTime.now().plusMinutes(5), "cs2minipds-test");
// retrieve next eligible, it should return order id = 2
- Assertions.assertEquals(retrieveNextEligibleOrder(database), 2);
+ assertThat(retrieveNextEligibleOrder(database)).isEqualTo(2);
database.async().waitCompletion();
// re-submit order
@@ -171,7 +176,7 @@ public void testWhereAfterAsyncInsert() {
// retrieve correct order by id
try (ResultSet resultSet = database.query("sql", "select status from Order where id = 1")) {
- Assertions.assertEquals(resultSet.next().getProperty("status"), "PENDING");
+ assertThat(resultSet.next().getProperty("status")).isEqualTo("PENDING");
}
try (ResultSet resultSet = database.query("sql", "SELECT FROM Order WHERE status = 'PENDING' ORDER BY id ASC")) {
@@ -183,7 +188,7 @@ public void testWhereAfterAsyncInsert() {
// retrieve next eligible, it should return order id = 1
try {
- Assertions.assertEquals(1, retrieveNextEligibleOrder(database));
+ assertThat(retrieveNextEligibleOrder(database)).isEqualTo(1);
} finally {
arcadeDBServer.stop();
}
@@ -269,7 +274,7 @@ private int retrieveNextEligibleOrder(Database database) {
System.out.println("retrieve result = " + result.toJSON());
return result.getProperty("id");
} else {
- Assertions.fail("no orders found");
+ fail("no orders found");
return 0;
}
}
@@ -289,10 +294,10 @@ record = indexCursor.next().getRecord().asDocument(true).modify();
System.out.println("modified record = " + record);
record.save();
} else {
- Assertions.fail("could not find order id = " + orderId);
+ fail("could not find order id = " + orderId);
}
if (!database.async().waitCompletion(3000)) {
- Assertions.fail("timeout expired before order update completion");
+ fail("timeout expired before order update completion");
}
return updateCount.get();
}
@@ -309,7 +314,7 @@ private MutableDocument resubmitOrder(Database database, int orderId) {
}
});
} catch (Exception e) {
- Assertions.fail();
+ fail("");
}
return record[0];
}
diff --git a/console/src/test/java/com/arcadedb/console/ConsoleAsyncInsertTest.java b/console/src/test/java/com/arcadedb/console/ConsoleAsyncInsertTest.java
index 69e1d478ae..354347fac2 100644
--- a/console/src/test/java/com/arcadedb/console/ConsoleAsyncInsertTest.java
+++ b/console/src/test/java/com/arcadedb/console/ConsoleAsyncInsertTest.java
@@ -42,8 +42,9 @@
import com.arcadedb.server.TestServerHelper;
import com.arcadedb.server.security.ServerSecurity;
import com.arcadedb.utility.FileUtils;
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -53,6 +54,8 @@
import java.util.concurrent.atomic.*;
import static com.arcadedb.server.StaticBaseServerTest.DEFAULT_PASSWORD_FOR_TESTS;
+import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.Assertions.assertThat;
/**
* From Discussion https://github.com/ArcadeData/arcadedb/discussions/1129#discussioncomment-6226545
@@ -165,7 +168,7 @@ public void testBulkAsyncInsertProductsUsingSQL() {
dtProducts.setBucketSelectionStrategy(new ThreadBucketSelectionStrategy());
- Assertions.assertEquals(PARALLEL_LEVEL, dtProducts.getBuckets(false).size());
+ assertThat(dtProducts.getBuckets(false).size()).isEqualTo(PARALLEL_LEVEL);
});
}
}
@@ -242,7 +245,7 @@ public void testBulkAsyncInsertProductsUsingAPI() {
//dtProducts.setBucketSelectionStrategy(new ThreadBucketSelectionStrategy());
dtProducts.setBucketSelectionStrategy(new PartitionedBucketSelectionStrategy(List.of("name")));
- Assertions.assertEquals(PARALLEL_LEVEL, dtProducts.getBuckets(false).size());
+ assertThat(dtProducts.getBuckets(false).size()).isEqualTo(PARALLEL_LEVEL);
});
}
}
@@ -354,7 +357,7 @@ public void testOrderByAfterDeleteInsert() {
try (ResultSet resultSet = database.command("sql",
"insert into Product set name = ?, type = ?, start = ?, stop = ?, v = ? return @rid", arcadeDBServer.getConfiguration(),
p.fileName, p.fileType, p.getStartValidity(), p.getStopValidity(), p.getVersion())) {
- Assertions.assertTrue(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isTrue();
Result result = resultSet.next();
rid = result.getProperty("@rid").toString();
}
@@ -367,29 +370,29 @@ public void testOrderByAfterDeleteInsert() {
orders.add(new CandidateOrder("SIR1LRM-7.1", rid, start, stop, "cs2minipds-test", "PENDING"));
}
JSONObject insertResult = insertOrdersAsync(database, orders);
- Assertions.assertEquals(insertResult.getInt("totalRows"), TOTAL);
+ assertThat(TOTAL).isEqualTo(insertResult.getInt("totalRows"));
int firstOrderId = 1;
int lastOrderId = TOTAL;
try (ResultSet resultSet = database.query("sql", "select from Order order by id")) {
- Assertions.assertTrue(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isTrue();
}
String DELETE_ORDERS = "DELETE FROM Order WHERE id >= ? AND id <= ?";
try (ResultSet resultSet = database.command("sql", DELETE_ORDERS, firstOrderId, lastOrderId)) {
- Assertions.assertEquals(TOTAL, (Long) resultSet.next().getProperty("count"));
+ assertThat((Long) resultSet.next().getProperty("count")).isEqualTo(TOTAL);
}
try (ResultSet resultSet = database.query("sql", "select from Order order by id")) {
- Assertions.assertFalse(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isFalse();
}
insertResult = insertOrdersAsync(database, orders);
- Assertions.assertEquals(TOTAL, insertResult.getInt("totalRows"));
+ assertThat(insertResult.getInt("totalRows")).isEqualTo(TOTAL);
try (ResultSet resultSet = database.query("sql", "select from Order")) {
- Assertions.assertTrue(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isTrue();
}
try (ResultSet resultSet = database.query("sql", "select from Order order by processor")) {
- Assertions.assertTrue(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isTrue();
}
try (ResultSet resultSet = database.query("sql", "select from Order order by id")) {
- Assertions.assertTrue(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isTrue();
} finally {
arcadeDBServer.stop();
FileUtils.deleteRecursively(new File(arcadeDBServer.getRootPath() + File.separator + "config"));
@@ -398,25 +401,25 @@ public void testOrderByAfterDeleteInsert() {
private void checkResults(AtomicLong txErrorCounter, Database database, AtomicLong okCount, AtomicLong errCount, long N,
long begin) {
- Assertions.assertTrue(database.async().waitCompletion(30_000));
+ assertThat(database.async().waitCompletion(30_000)).isTrue();
System.out.println("Total async insertion of " + N + " elements in " + (System.currentTimeMillis() - begin));
- Assertions.assertEquals(okCount.get(), N);
- Assertions.assertEquals(errCount.get(), 0);
- Assertions.assertEquals(txErrorCounter.get(), 0);
+ assertThat(N).isEqualTo(okCount.get());
+ assertThat(errCount.get()).isEqualTo(0);
+ assertThat(txErrorCounter.get()).isEqualTo(0);
try (ResultSet resultSet = database.query("sql", "SELECT count(*) as total FROM Product")) {
Result result = resultSet.next();
- Assertions.assertEquals((Long) result.getProperty("total"), N);
+ assertThat(N).isEqualTo((Long) result.getProperty("total"));
Console console = new Console();
String URL = "remote:localhost/" + DATABASE_NAME + " " + userName + " " + password;
- Assertions.assertTrue(console.parse("connect " + URL));
+ assertThat(console.parse("connect " + URL)).isTrue();
final StringBuilder buffer = new StringBuilder();
console.setOutput(output -> buffer.append(output));
- Assertions.assertTrue(console.parse("select count(*) from Product"));
+ assertThat(console.parse("select count(*) from Product")).isTrue();
String[] lines = buffer.toString().split("\\r?\\n|\\r");
int count = Integer.parseInt(lines[4].split("\\|")[2].trim());
- Assertions.assertEquals(N, count);
+ assertThat(count).isEqualTo(N);
} catch (IOException e) {
System.out.println(e.getMessage());
}
diff --git a/console/src/test/java/com/arcadedb/console/ConsoleBatchTest.java b/console/src/test/java/com/arcadedb/console/ConsoleBatchTest.java
index 0dee216024..d3ff0c7368 100644
--- a/console/src/test/java/com/arcadedb/console/ConsoleBatchTest.java
+++ b/console/src/test/java/com/arcadedb/console/ConsoleBatchTest.java
@@ -24,18 +24,19 @@
import com.arcadedb.server.TestServerHelper;
import com.arcadedb.utility.FileUtils;
import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.io.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class ConsoleBatchTest {
@Test
public void batchMode() throws IOException {
Console.execute(new String[] { "-b", "create database console; create vertex type ConsoleOnlyVertex;" });
final Database db = new DatabaseFactory("./target/databases/console").open();
- Assertions.assertTrue(db.getSchema().existsType("ConsoleOnlyVertex"));
+ assertThat(db.getSchema().existsType("ConsoleOnlyVertex")).isTrue();
db.drop();
}
@@ -43,7 +44,7 @@ public void batchMode() throws IOException {
public void interactiveMode() throws IOException {
Console.execute(new String[] { "create database console; create vertex type ConsoleOnlyVertex;exit" });
final Database db = new DatabaseFactory("./target/databases/console").open();
- Assertions.assertTrue(db.getSchema().existsType("ConsoleOnlyVertex"));
+ assertThat(db.getSchema().existsType("ConsoleOnlyVertex")).isTrue();
db.drop();
}
@@ -52,7 +53,7 @@ public void swallowSettings() throws IOException {
FileUtils.deleteRecursively(new File("./console"));
Console.execute(new String[] { "-Darcadedb.server.databaseDirectory=.", "create database console; create vertex type ConsoleOnlyVertex;exit;" });
final Database db = new DatabaseFactory("./console").open();
- Assertions.assertTrue(db.getSchema().existsType("ConsoleOnlyVertex"));
+ assertThat(db.getSchema().existsType("ConsoleOnlyVertex")).isTrue();
db.drop();
GlobalConfiguration.resetAll();
}
diff --git a/console/src/test/java/com/arcadedb/console/ConsoleTest.java b/console/src/test/java/com/arcadedb/console/ConsoleTest.java
index 1cf81de5da..5e788fe771 100644
--- a/console/src/test/java/com/arcadedb/console/ConsoleTest.java
+++ b/console/src/test/java/com/arcadedb/console/ConsoleTest.java
@@ -33,7 +33,7 @@
import com.arcadedb.server.TestServerHelper;
import com.arcadedb.utility.FileUtils;
import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -41,6 +41,9 @@
import java.text.*;
import java.util.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
public class ConsoleTest {
private static final String DB_NAME = "console";
private static Console console;
@@ -53,14 +56,14 @@ public void populate() throws IOException {
FileUtils.deleteRecursively(dbFile);
GlobalConfiguration.SERVER_ROOT_PATH.setValue("./target");
console = new Console();
- Assertions.assertTrue(console.parse("create database " + DB_NAME + "; close"));
+ assertThat(console.parse("create database " + DB_NAME + "; close")).isTrue();
}
@AfterEach
public void drop() throws IOException {
console.close();
TestServerHelper.checkActiveDatabases();
- Assertions.assertTrue(console.parse("drop database " + DB_NAME + "; close", false));
+ assertThat(console.parse("drop database " + DB_NAME + "; close", false)).isTrue();
GlobalConfiguration.resetAll();
}
@@ -70,57 +73,57 @@ public void testDropCreateWithLocalUrl() throws IOException {
return;
String localUrl = "local:/" + absoluteDBPath + "/" + DB_NAME;
- Assertions.assertTrue(console.parse("drop database " + localUrl + "; close", false));
- Assertions.assertTrue(console.parse("create database " + localUrl + "; close", false));
+ assertThat(console.parse("drop database " + localUrl + "; close", false)).isTrue();
+ assertThat(console.parse("create database " + localUrl + "; close", false)).isTrue();
}
@Test
public void testNull() throws IOException {
- Assertions.assertTrue(console.parse(null));
+ assertThat(console.parse(null)).isTrue();
}
@Test
public void testEmpty() throws IOException {
- Assertions.assertTrue(console.parse(""));
+ assertThat(console.parse("")).isTrue();
}
@Test
public void testEmpty2() throws IOException {
- Assertions.assertTrue(console.parse(" "));
+ assertThat(console.parse(" ")).isTrue();
}
@Test
public void testEmpty3() throws IOException {
- Assertions.assertTrue(console.parse(";"));
+ assertThat(console.parse(";")).isTrue();
}
@Test
public void testComment() throws IOException {
- Assertions.assertTrue(console.parse("-- This is a comment;"));
+ assertThat(console.parse("-- This is a comment;")).isTrue();
}
@Test
public void testListDatabases() throws IOException {
- Assertions.assertTrue(console.parse("list databases;"));
+ assertThat(console.parse("list databases;")).isTrue();
}
@Test
public void testConnect() throws IOException {
- Assertions.assertTrue(console.parse("connect " + DB_NAME + ";info types"));
+ assertThat(console.parse("connect " + DB_NAME + ";info types")).isTrue();
}
@Test
public void testLocalConnect() throws IOException {
if (System.getProperty("os.name").toLowerCase().contains("windows"))
return;
- Assertions.assertTrue(console.parse("connect local:/" + absoluteDBPath + "/" + DB_NAME + ";info types", false));
+ assertThat(console.parse("connect local:/" + absoluteDBPath + "/" + DB_NAME + ";info types", false)).isTrue();
}
@Test
public void testSetVerbose() throws IOException {
try {
console.parse("set verbose = 2; close; connect " + DB_NAME + "XX");
- Assertions.fail();
+ fail("");
} catch (final DatabaseOperationException e) {
// EXPECTED
}
@@ -133,59 +136,59 @@ public void testSetLanguage() throws IOException {
@Test
public void testCreateClass() throws IOException {
- Assertions.assertTrue(console.parse("connect " + DB_NAME));
- Assertions.assertTrue(console.parse("create document type Person"));
+ assertThat(console.parse("connect " + DB_NAME)).isTrue();
+ assertThat(console.parse("create document type Person")).isTrue();
final StringBuilder buffer = new StringBuilder();
console.setOutput(output -> buffer.append(output));
- Assertions.assertTrue(console.parse("info types"));
- Assertions.assertTrue(buffer.toString().contains("Person"));
+ assertThat(console.parse("info types")).isTrue();
+ assertThat(buffer.toString().contains("Person")).isTrue();
buffer.setLength(0);
- Assertions.assertTrue(console.parse("info type Person"));
- Assertions.assertTrue(buffer.toString().contains("DOCUMENT TYPE 'Person'"));
+ assertThat(console.parse("info type Person")).isTrue();
+ assertThat(buffer.toString().contains("DOCUMENT TYPE 'Person'")).isTrue();
}
@Test
public void testInsertAndSelectRecord() throws IOException {
- Assertions.assertTrue(console.parse("connect " + DB_NAME));
- Assertions.assertTrue(console.parse("create document type Person"));
- Assertions.assertTrue(console.parse("insert into Person set name = 'Jay', lastname='Miner'"));
+ assertThat(console.parse("connect " + DB_NAME)).isTrue();
+ assertThat(console.parse("create document type Person")).isTrue();
+ assertThat(console.parse("insert into Person set name = 'Jay', lastname='Miner'")).isTrue();
final StringBuilder buffer = new StringBuilder();
console.setOutput(output -> buffer.append(output));
- Assertions.assertTrue(console.parse("select from Person"));
- Assertions.assertTrue(buffer.toString().contains("Jay"));
+ assertThat(console.parse("select from Person")).isTrue();
+ assertThat(buffer.toString().contains("Jay")).isTrue();
}
@Test
public void testInsertAndRollback() throws IOException {
- Assertions.assertTrue(console.parse("connect " + DB_NAME));
- Assertions.assertTrue(console.parse("begin"));
- Assertions.assertTrue(console.parse("create document type Person"));
- Assertions.assertTrue(console.parse("insert into Person set name = 'Jay', lastname='Miner'"));
- Assertions.assertTrue(console.parse("rollback"));
+ assertThat(console.parse("connect " + DB_NAME)).isTrue();
+ assertThat(console.parse("begin")).isTrue();
+ assertThat(console.parse("create document type Person")).isTrue();
+ assertThat(console.parse("insert into Person set name = 'Jay', lastname='Miner'")).isTrue();
+ assertThat(console.parse("rollback")).isTrue();
final StringBuilder buffer = new StringBuilder();
console.setOutput(output -> buffer.append(output));
- Assertions.assertTrue(console.parse("select from Person"));
- Assertions.assertFalse(buffer.toString().contains("Jay"));
+ assertThat(console.parse("select from Person")).isTrue();
+ assertThat(buffer.toString().contains("Jay")).isFalse();
}
@Test
public void testHelp() throws IOException {
final StringBuilder buffer = new StringBuilder();
console.setOutput(output -> buffer.append(output));
- Assertions.assertTrue(console.parse("?"));
- Assertions.assertTrue(buffer.toString().contains("quit"));
+ assertThat(console.parse("?")).isTrue();
+ assertThat(buffer.toString().contains("quit")).isTrue();
}
@Test
public void testInfoError() throws IOException {
- Assertions.assertTrue(console.parse("connect " + DB_NAME));
+ assertThat(console.parse("connect " + DB_NAME)).isTrue();
try {
- Assertions.assertTrue(console.parse("info blablabla"));
- Assertions.fail();
+ assertThat(console.parse("info blablabla")).isTrue();
+ fail("");
} catch (final ConsoleException e) {
// EXPECTED
}
@@ -193,25 +196,24 @@ public void testInfoError() throws IOException {
@Test
public void testAllRecordTypes() throws IOException {
- Assertions.assertTrue(console.parse("connect " + DB_NAME));
- Assertions.assertTrue(console.parse("create document type D"));
- Assertions.assertTrue(console.parse("create vertex type V"));
- Assertions.assertTrue(console.parse("create edge type E"));
+ assertThat(console.parse("connect " + DB_NAME)).isTrue();
+ assertThat(console.parse("create document type D")).isTrue();
+ assertThat(console.parse("create vertex type V")).isTrue();
+ assertThat(console.parse("create edge type E")).isTrue();
- Assertions.assertTrue(console.parse("insert into D set name = 'Jay', lastname='Miner'"));
- Assertions.assertTrue(console.parse("insert into V set name = 'Jay', lastname='Miner'"));
- Assertions.assertTrue(console.parse("insert into V set name = 'Elon', lastname='Musk'"));
- Assertions.assertTrue(
- console.parse("create edge E from (select from V where name ='Jay') to (select from V where name ='Elon')"));
+ assertThat(console.parse("insert into D set name = 'Jay', lastname='Miner'")).isTrue();
+ assertThat(console.parse("insert into V set name = 'Jay', lastname='Miner'")).isTrue();
+ assertThat(console.parse("insert into V set name = 'Elon', lastname='Musk'")).isTrue();
+ assertThat(console.parse("create edge E from (select from V where name ='Jay') to (select from V where name ='Elon')")).isTrue();
final StringBuilder buffer = new StringBuilder();
console.setOutput(output -> buffer.append(output));
- Assertions.assertTrue(console.parse("select from D"));
- Assertions.assertTrue(buffer.toString().contains("Jay"));
+ assertThat(console.parse("select from D")).isTrue();
+ assertThat(buffer.toString().contains("Jay")).isTrue();
- Assertions.assertTrue(console.parse("select from V"));
- Assertions.assertTrue(console.parse("select from E"));
- Assertions.assertTrue(buffer.toString().contains("Elon"));
+ assertThat(console.parse("select from V")).isTrue();
+ assertThat(console.parse("select from E")).isTrue();
+ assertThat(buffer.toString().contains("Elon")).isTrue();
}
/**
@@ -219,34 +221,34 @@ public void testAllRecordTypes() throws IOException {
*/
@Test
public void testNotStringProperties() throws IOException {
- Assertions.assertTrue(console.parse("connect " + DB_NAME));
- Assertions.assertTrue(console.parse("CREATE VERTEX TYPE v"));
- Assertions.assertTrue(console.parse("CREATE PROPERTY v.s STRING"));
- Assertions.assertTrue(console.parse("CREATE PROPERTY v.i INTEGER"));
- Assertions.assertTrue(console.parse("CREATE PROPERTY v.b BOOLEAN"));
- Assertions.assertTrue(console.parse("CREATE PROPERTY v.sh SHORT"));
- Assertions.assertTrue(console.parse("CREATE PROPERTY v.d DOUBLE"));
- Assertions.assertTrue(console.parse("CREATE PROPERTY v.da DATETIME"));
+ assertThat(console.parse("connect " + DB_NAME)).isTrue();
+ assertThat(console.parse("CREATE VERTEX TYPE v")).isTrue();
+ assertThat(console.parse("CREATE PROPERTY v.s STRING")).isTrue();
+ assertThat(console.parse("CREATE PROPERTY v.i INTEGER")).isTrue();
+ assertThat(console.parse("CREATE PROPERTY v.b BOOLEAN")).isTrue();
+ assertThat(console.parse("CREATE PROPERTY v.sh SHORT")).isTrue();
+ assertThat(console.parse("CREATE PROPERTY v.d DOUBLE")).isTrue();
+ assertThat(console.parse("CREATE PROPERTY v.da DATETIME")).isTrue();
final StringBuilder buffer = new StringBuilder();
console.setOutput(output -> buffer.append(output));
- Assertions.assertTrue(console.parse("CREATE VERTEX v SET s=\"abc\", i=1, b=true, sh=2, d=3.5, da=\"2022-12-20 18:00\""));
- Assertions.assertTrue(buffer.toString().contains("true"));
+ assertThat(console.parse("CREATE VERTEX v SET s=\"abc\", i=1, b=true, sh=2, d=3.5, da=\"2022-12-20 18:00\"")).isTrue();
+ assertThat(buffer.toString().contains("true")).isTrue();
}
@Test
public void testUserMgmtLocalError() throws IOException {
- Assertions.assertTrue(console.parse("connect " + DB_NAME));
+ assertThat(console.parse("connect " + DB_NAME)).isTrue();
try {
- Assertions.assertTrue(console.parse("create user elon identified by musk"));
- Assertions.fail("local connection allowed user creation");
+ assertThat(console.parse("create user elon identified by musk")).isTrue();
+ fail("local connection allowed user creation");
} catch (final Exception e) {
// EXPECTED
}
try {
- Assertions.assertTrue(console.parse("drop user jack"));
- Assertions.fail("local connection allowed user deletion");
+ assertThat(console.parse("drop user jack")).isTrue();
+ fail("local connection allowed user deletion");
} catch (final Exception e) {
// EXPECTED
}
@@ -265,31 +267,31 @@ public void testImportNeo4jConsoleOK() throws IOException {
try (final DatabaseFactory factory = new DatabaseFactory("./target/databases/" + DATABASE_PATH)) {
try (final Database database = factory.open()) {
final DocumentType personType = database.getSchema().getType("User");
- Assertions.assertNotNull(personType);
- Assertions.assertEquals(3, database.countType("User", true));
+ assertThat(personType).isNotNull();
+ assertThat(database.countType("User", true)).isEqualTo(3);
final IndexCursor cursor = database.lookupByKey("User", "id", "0");
- Assertions.assertTrue(cursor.hasNext());
+ assertThat(cursor.hasNext()).isTrue();
final Vertex v = cursor.next().asVertex();
- Assertions.assertEquals("Adam", v.get("name"));
- Assertions.assertEquals("2015-07-04T19:32:24", new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss").format(v.getLong("born")));
+ assertThat(v.get("name")).isEqualTo("Adam");
+ assertThat(new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss").format(v.getLong("born"))).isEqualTo("2015-07-04T19:32:24");
final Map place = (Map) v.get("place");
- Assertions.assertEquals(33.46789, ((Number) place.get("latitude")).doubleValue());
- Assertions.assertNull(place.get("height"));
+ assertThat(((Number) place.get("latitude")).doubleValue()).isEqualTo(33.46789);
+ assertThat(place.get("height")).isNull();
- Assertions.assertEquals(Arrays.asList("Sam", "Anna", "Grace"), v.get("kids"));
+ assertThat(v.get("kids")).isEqualTo(Arrays.asList("Sam", "Anna", "Grace"));
final DocumentType friendType = database.getSchema().getType("KNOWS");
- Assertions.assertNotNull(friendType);
- Assertions.assertEquals(1, database.countType("KNOWS", true));
+ assertThat(friendType).isNotNull();
+ assertThat(database.countType("KNOWS", true)).isEqualTo(1);
final Iterator relationships = v.getEdges(Vertex.DIRECTION.OUT, "KNOWS").iterator();
- Assertions.assertTrue(relationships.hasNext());
+ assertThat(relationships.hasNext()).isTrue();
final Edge e = relationships.next();
- Assertions.assertEquals(1993, e.get("since"));
- Assertions.assertEquals("P5M1DT12H", e.get("bffSince"));
+ assertThat(e.get("since")).isEqualTo(1993);
+ assertThat(e.get("bffSince")).isEqualTo("P5M1DT12H");
}
}
}
@@ -321,7 +323,7 @@ public void testImportCSVConsoleOK() throws IOException {
newConsole.close();
int vertices = 0;
- int edges = 0;
+ long edges = 0;
try (final DatabaseFactory factory = new DatabaseFactory("./target/databases/" + DATABASE_PATH)) {
try (final Database database = factory.open()) {
@@ -333,34 +335,34 @@ public void testImportCSVConsoleOK() throws IOException {
}
}
- Assertions.assertEquals(101, vertices);
- Assertions.assertEquals(135, edges);
+ assertThat(vertices).isEqualTo(101);
+ assertThat(edges).isEqualTo(135);
}
@Test
public void testNullValues() throws IOException {
- Assertions.assertTrue(console.parse("connect " + DB_NAME));
- Assertions.assertTrue(console.parse("create document type Person"));
- Assertions.assertTrue(console.parse("insert into Person set name = 'Jay', lastname='Miner', nothing = null"));
- Assertions.assertTrue(console.parse("insert into Person set name = 'Thom', lastname='Yorke', nothing = 'something'"));
+ assertThat(console.parse("connect " + DB_NAME)).isTrue();
+ assertThat(console.parse("create document type Person")).isTrue();
+ assertThat(console.parse("insert into Person set name = 'Jay', lastname='Miner', nothing = null")).isTrue();
+ assertThat(console.parse("insert into Person set name = 'Thom', lastname='Yorke', nothing = 'something'")).isTrue();
{
final StringBuilder buffer = new StringBuilder();
console.setOutput(output -> buffer.append(output));
- Assertions.assertTrue(console.parse("select from Person where nothing is null"));
- Assertions.assertTrue(buffer.toString().contains(""));
+ assertThat(console.parse("select from Person where nothing is null")).isTrue();
+ assertThat(buffer.toString().contains("")).isTrue();
}
{
final StringBuilder buffer = new StringBuilder();
console.setOutput(output -> buffer.append(output));
- Assertions.assertTrue(console.parse("select nothing, lastname, name from Person where nothing is null"));
- Assertions.assertTrue(buffer.toString().contains(""));
+ assertThat(console.parse("select nothing, lastname, name from Person where nothing is null")).isTrue();
+ assertThat(buffer.toString().contains("")).isTrue();
}
{
final StringBuilder buffer = new StringBuilder();
console.setOutput(output -> buffer.append(output));
- Assertions.assertTrue(console.parse("select nothing, lastname, name from Person"));
- Assertions.assertTrue(buffer.toString().contains(""));
+ assertThat(console.parse("select nothing, lastname, name from Person")).isTrue();
+ assertThat(buffer.toString().contains("")).isTrue();
}
}
@@ -369,89 +371,89 @@ public void testNullValues() throws IOException {
*/
@Test
public void testProjectionOrder() throws IOException {
- Assertions.assertTrue(console.parse("connect " + DB_NAME));
- Assertions.assertTrue(console.parse("create document type Order"));
- Assertions.assertTrue(console.parse(
- "insert into Order set processor = 'SIR1LRM-7.1', vstart = '20220319_002624.404379', vstop = '20220319_002826.525650', status = 'PENDING'"));
+ assertThat(console.parse("connect " + DB_NAME)).isTrue();
+ assertThat(console.parse("create document type Order")).isTrue();
+ assertThat(console.parse(
+ "insert into Order set processor = 'SIR1LRM-7.1', vstart = '20220319_002624.404379', vstop = '20220319_002826.525650', status = 'PENDING'")).isTrue();
{
final StringBuilder buffer = new StringBuilder();
console.setOutput(output -> buffer.append(output));
- Assertions.assertTrue(console.parse("select processor, vstart, vstop, pstart, pstop, status, node from Order"));
+ assertThat(console.parse("select processor, vstart, vstop, pstart, pstop, status, node from Order")).isTrue();
int pos = buffer.toString().indexOf("processor");
- Assertions.assertTrue(pos > -1);
+ assertThat(pos > -1).isTrue();
pos = buffer.toString().indexOf("vstart", pos);
- Assertions.assertTrue(pos > -1);
+ assertThat(pos > -1).isTrue();
pos = buffer.toString().indexOf("vstop", pos);
- Assertions.assertTrue(pos > -1);
+ assertThat(pos > -1).isTrue();
pos = buffer.toString().indexOf("pstart", pos);
- Assertions.assertTrue(pos > -1);
+ assertThat(pos > -1).isTrue();
pos = buffer.toString().indexOf("pstop", pos);
- Assertions.assertTrue(pos > -1);
+ assertThat(pos > -1).isTrue();
pos = buffer.toString().indexOf("status", pos);
- Assertions.assertTrue(pos > -1);
+ assertThat(pos > -1).isTrue();
pos = buffer.toString().indexOf("node", pos);
- Assertions.assertTrue(pos > -1);
+ assertThat(pos > -1).isTrue();
}
}
@Test
public void testAsyncMode() throws IOException {
- Assertions.assertTrue(console.parse("connect " + DB_NAME));
- Assertions.assertTrue(console.parse("create document type D"));
- Assertions.assertTrue(console.parse("create vertex type V"));
- Assertions.assertTrue(console.parse("create edge type E"));
+ assertThat(console.parse("connect " + DB_NAME)).isTrue();
+ assertThat(console.parse("create document type D")).isTrue();
+ assertThat(console.parse("create vertex type V")).isTrue();
+ assertThat(console.parse("create edge type E")).isTrue();
- Assertions.assertTrue(console.parse("insert into D set name = 'Jay', lastname='Miner'"));
+ assertThat(console.parse("insert into D set name = 'Jay', lastname='Miner'")).isTrue();
int asyncOperations = (int) ((DatabaseAsyncExecutorImpl) ((DatabaseInternal) console.getDatabase()).async()).getStats().scheduledTasks;
- Assertions.assertEquals(0, asyncOperations);
+ assertThat(asyncOperations).isEqualTo(0);
- Assertions.assertTrue(console.parse("set asyncMode = true"));
+ assertThat(console.parse("set asyncMode = true")).isTrue();
- Assertions.assertTrue(console.parse("insert into V set name = 'Jay', lastname='Miner'"));
- Assertions.assertTrue(console.parse("insert into V set name = 'Elon', lastname='Musk'"));
+ assertThat(console.parse("insert into V set name = 'Jay', lastname='Miner'")).isTrue();
+ assertThat(console.parse("insert into V set name = 'Elon', lastname='Musk'")).isTrue();
- Assertions.assertTrue(console.parse("set asyncMode = false"));
+ assertThat(console.parse("set asyncMode = false")).isTrue();
asyncOperations = (int) ((DatabaseAsyncExecutorImpl) ((DatabaseInternal) console.getDatabase()).async()).getStats().scheduledTasks;
- Assertions.assertEquals(2, asyncOperations);
+ assertThat(asyncOperations).isEqualTo(2);
}
@Test
public void testBatchMode() throws IOException {
- Assertions.assertTrue(console.parse("connect " + DB_NAME));
- Assertions.assertTrue(console.parse("create document type D"));
- Assertions.assertTrue(console.parse("create vertex type V"));
- Assertions.assertTrue(console.parse("create edge type E"));
+ assertThat(console.parse("connect " + DB_NAME)).isTrue();
+ assertThat(console.parse("create document type D")).isTrue();
+ assertThat(console.parse("create vertex type V")).isTrue();
+ assertThat(console.parse("create edge type E")).isTrue();
- Assertions.assertTrue(console.parse("set transactionBatchSize = 2"));
+ assertThat(console.parse("set transactionBatchSize = 2")).isTrue();
- Assertions.assertTrue(console.parse("insert into D set name = 'Jay', lastname='Miner'"));
- Assertions.assertEquals(1, console.currentOperationsInBatch);
+ assertThat(console.parse("insert into D set name = 'Jay', lastname='Miner'")).isTrue();
+ assertThat(console.currentOperationsInBatch).isEqualTo(1);
- Assertions.assertTrue(((DatabaseInternal) console.getDatabase()).getTransaction().isActive());
- Assertions.assertTrue(((DatabaseInternal) console.getDatabase()).getTransaction().getModifiedPages() > 0);
+ assertThat(((DatabaseInternal) console.getDatabase()).getTransaction().isActive()).isTrue();
+ assertThat(((DatabaseInternal) console.getDatabase()).getTransaction().getModifiedPages() > 0).isTrue();
- Assertions.assertTrue(console.parse("insert into V set name = 'Jay', lastname='Miner'"));
- Assertions.assertEquals(2, console.currentOperationsInBatch);
- Assertions.assertTrue(console.parse("insert into V set name = 'Elon', lastname='Musk'"));
- Assertions.assertEquals(1, console.currentOperationsInBatch);
+ assertThat(console.parse("insert into V set name = 'Jay', lastname='Miner'")).isTrue();
+ assertThat(console.currentOperationsInBatch).isEqualTo(2);
+ assertThat(console.parse("insert into V set name = 'Elon', lastname='Musk'")).isTrue();
+ assertThat(console.currentOperationsInBatch).isEqualTo(1);
- Assertions.assertTrue(console.parse("set transactionBatchSize = 0"));
+ assertThat(console.parse("set transactionBatchSize = 0")).isTrue();
}
@Test
public void testLoad() throws IOException {
- Assertions.assertTrue(console.parse("connect " + DB_NAME));
- Assertions.assertTrue(console.parse("load " + new File("src/test/resources/console-batch.sql").toString().replace('\\', '/')));
+ assertThat(console.parse("connect " + DB_NAME)).isTrue();
+ assertThat(console.parse("load " + new File("src/test/resources/console-batch.sql").toString().replace('\\', '/'))).isTrue();
final String[] urls = new String[] { "http://arcadedb.com", "https://www.arcadedb.com", "file://this/is/myfile.txt" };
// VALIDATE WITH PLAIN JAVA REGEXP FIRST
for (String url : urls)
- Assertions.assertTrue(url.matches("^([a-zA-Z]{1,15}:)(\\/\\/)?[^\\s\\/$.?#].[^\\s]*$"), "Cannot validate URL: " + url);
+ assertThat(url.matches("^([a-zA-Z]{1,15}:)(\\/\\/)?[^\\s\\/$.?#].[^\\s]*$")).as("Cannot validate URL: " + url).isTrue();
// VALIDATE WITH DATABASE SCHEMA
for (String url : urls)
@@ -460,19 +462,17 @@ public void testLoad() throws IOException {
@Test
public void testCustomPropertyInSchema() throws IOException {
- Assertions.assertTrue(console.parse("connect " + DB_NAME));
- Assertions.assertTrue(console.parse("CREATE DOCUMENT TYPE doc;"));
- Assertions.assertTrue(console.parse("CREATE PROPERTY doc.prop STRING;"));
- Assertions.assertTrue(console.parse("ALTER PROPERTY doc.prop CUSTOM test = true;"));
- Assertions.assertEquals(true, console.getDatabase().getSchema().getType("doc").getProperty("prop").getCustomValue("test"));
-
- Assertions.assertEquals(Type.BOOLEAN.name().toUpperCase(),
- console.getDatabase().query("sql", "SELECT properties.custom.test[0].type() as type FROM schema:types").next()
- .getProperty("type"));
-
- Assertions.assertEquals(Type.BOOLEAN.name().toUpperCase(),
- console.getDatabase().command("sql", "SELECT properties.custom.test[0].type() as type FROM schema:types").next()
- .getProperty("type"));
+ assertThat(console.parse("connect " + DB_NAME)).isTrue();
+ assertThat(console.parse("CREATE DOCUMENT TYPE doc;")).isTrue();
+ assertThat(console.parse("CREATE PROPERTY doc.prop STRING;")).isTrue();
+ assertThat(console.parse("ALTER PROPERTY doc.prop CUSTOM test = true;")).isTrue();
+ assertThat(console.getDatabase().getSchema().getType("doc").getProperty("prop").getCustomValue("test")).isEqualTo(true);
+
+ assertThat(console.getDatabase().query("sql", "SELECT properties.custom.test[0].type() as type FROM schema:types").next()
+ .getProperty("type")).isEqualTo(Type.BOOLEAN.name().toUpperCase());
+
+ assertThat(console.getDatabase().command("sql", "SELECT properties.custom.test[0].type() as type FROM schema:types").next()
+ .getProperty("type")).isEqualTo(Type.BOOLEAN.name().toUpperCase());
}
/**
@@ -480,21 +480,21 @@ public void testCustomPropertyInSchema() throws IOException {
*/
@Test
public void testNotNullProperties() throws IOException {
- Assertions.assertTrue(console.parse("connect " + DB_NAME));
- Assertions.assertTrue(console.parse("CREATE DOCUMENT TYPE doc;"));
- Assertions.assertTrue(console.parse("CREATE PROPERTY doc.prop STRING (notnull);"));
- Assertions.assertTrue(console.getDatabase().getSchema().getType("doc").getProperty("prop").isNotNull());
+ assertThat(console.parse("connect " + DB_NAME)).isTrue();
+ assertThat(console.parse("CREATE DOCUMENT TYPE doc;")).isTrue();
+ assertThat(console.parse("CREATE PROPERTY doc.prop STRING (notnull);")).isTrue();
+ assertThat(console.getDatabase().getSchema().getType("doc").getProperty("prop").isNotNull()).isTrue();
- Assertions.assertTrue(console.parse("INSERT INTO doc set a = null;"));
+ assertThat(console.parse("INSERT INTO doc set a = null;")).isTrue();
final StringBuilder buffer = new StringBuilder();
console.setOutput(output -> buffer.append(output));
- Assertions.assertTrue(console.parse("INSERT INTO doc set prop = null;"));
+ assertThat(console.parse("INSERT INTO doc set prop = null;")).isTrue();
int pos = buffer.toString().indexOf("ValidationException");
- Assertions.assertTrue(pos > -1);
+ assertThat(pos > -1).isTrue();
- Assertions.assertNull(console.getDatabase().query("sql", "SELECT FROM doc").nextIfAvailable().getProperty("prop"));
+ assertThat(console.getDatabase().query("sql", "SELECT FROM doc").nextIfAvailable().getProperty("prop")).isNull();
}
/**
@@ -502,23 +502,23 @@ public void testNotNullProperties() throws IOException {
*/
@Test
public void testPercentWildcardInQuery() throws IOException {
- Assertions.assertTrue(console.parse("connect " + DB_NAME));
- Assertions.assertTrue(console.parse("create document type Person"));
- Assertions.assertTrue(console.parse("insert into Person set name = 'Jay', lastname='Miner', nothing = null"));
- Assertions.assertTrue(console.parse("insert into Person set name = 'Thom', lastname='Yorke', nothing = 'something'"));
+ assertThat(console.parse("connect " + DB_NAME)).isTrue();
+ assertThat(console.parse("create document type Person")).isTrue();
+ assertThat(console.parse("insert into Person set name = 'Jay', lastname='Miner', nothing = null")).isTrue();
+ assertThat(console.parse("insert into Person set name = 'Thom', lastname='Yorke', nothing = 'something'")).isTrue();
{
final StringBuilder buffer = new StringBuilder();
console.setOutput(output -> buffer.append(output));
- Assertions.assertTrue(console.parse("select from Person where name like 'Thom%'"));
- Assertions.assertTrue(buffer.toString().contains("Yorke"));
+ assertThat(console.parse("select from Person where name like 'Thom%'")).isTrue();
+ assertThat(buffer.toString().contains("Yorke")).isTrue();
}
{
final StringBuilder buffer = new StringBuilder();
console.setOutput(output -> buffer.append(output));
- Assertions.assertTrue(console.parse("select from Person where not ( name like 'Thom%' )"));
- Assertions.assertTrue(buffer.toString().contains("Miner"));
+ assertThat(console.parse("select from Person where not ( name like 'Thom%' )")).isTrue();
+ assertThat(buffer.toString().contains("Miner")).isTrue();
}
}
}
diff --git a/console/src/test/java/com/arcadedb/console/RemoteConsoleIT.java b/console/src/test/java/com/arcadedb/console/RemoteConsoleIT.java
index 7575d409bc..9c5bed3107 100644
--- a/console/src/test/java/com/arcadedb/console/RemoteConsoleIT.java
+++ b/console/src/test/java/com/arcadedb/console/RemoteConsoleIT.java
@@ -25,11 +25,13 @@
import com.arcadedb.server.BaseGraphServerTest;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
-import java.io.*;
+import java.io.IOException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
public class RemoteConsoleIT extends BaseGraphServerTest {
private static final String URL = "remote:localhost:2480/console root " + DEFAULT_PASSWORD_FOR_TESTS;
@@ -47,24 +49,24 @@ public void setTestConfiguration() {
@Test
public void testCreateDatabase() throws IOException {
- Assertions.assertTrue(console.parse("create database " + URL_NEW_DB));
+ assertThat(console.parse("create database " + URL_NEW_DB)).isTrue();
}
@Test
public void testConnect() throws IOException {
- Assertions.assertTrue(console.parse("connect " + URL));
+ assertThat(console.parse("connect " + URL)).isTrue();
}
@Test
public void testConnectShortURL() throws IOException {
- Assertions.assertTrue(console.parse("connect " + URL_SHORT));
+ assertThat(console.parse("connect " + URL_SHORT)).isTrue();
}
@Test
public void testConnectNoCredentials() throws IOException {
try {
- Assertions.assertTrue(console.parse("connect " + URL_NOCREDENTIALS + ";create document type VVVV"));
- Assertions.fail("Security was bypassed!");
+ assertThat(console.parse("connect " + URL_NOCREDENTIALS + ";create document type VVVV")).isTrue();
+ fail("Security was bypassed!");
} catch (final ConsoleException e) {
// EXPECTED
}
@@ -73,8 +75,8 @@ public void testConnectNoCredentials() throws IOException {
@Test
public void testConnectWrongPassword() throws IOException {
try {
- Assertions.assertTrue(console.parse("connect " + URL_WRONGPASSWD + ";create document type VVVV"));
- Assertions.fail("Security was bypassed!");
+ assertThat(console.parse("connect " + URL_WRONGPASSWD + ";create document type VVVV")).isTrue();
+ fail("Security was bypassed!");
} catch (final SecurityException e) {
// EXPECTED
}
@@ -82,95 +84,95 @@ public void testConnectWrongPassword() throws IOException {
@Test
public void testCreateType() throws IOException {
- Assertions.assertTrue(console.parse("connect " + URL));
- Assertions.assertTrue(console.parse("create document type Person2"));
+ assertThat(console.parse("connect " + URL)).isTrue();
+ assertThat(console.parse("create document type Person2")).isTrue();
final StringBuilder buffer = new StringBuilder();
console.setOutput(buffer::append);
- Assertions.assertTrue(console.parse("info types"));
- Assertions.assertTrue(buffer.toString().contains("Person2"));
- Assertions.assertTrue(console.parse("drop type Person2"));
+ assertThat(console.parse("info types")).isTrue();
+ assertThat(buffer.toString().contains("Person2")).isTrue();
+ assertThat(console.parse("drop type Person2")).isTrue();
}
@Test
public void testInsertAndSelectRecord() throws IOException {
- Assertions.assertTrue(console.parse("connect " + URL));
- Assertions.assertTrue(console.parse("create document type Person2"));
- Assertions.assertTrue(console.parse("insert into Person2 set name = 'Jay', lastname='Miner'"));
+ assertThat(console.parse("connect " + URL)).isTrue();
+ assertThat(console.parse("create document type Person2")).isTrue();
+ assertThat(console.parse("insert into Person2 set name = 'Jay', lastname='Miner'")).isTrue();
final StringBuilder buffer = new StringBuilder();
console.setOutput(buffer::append);
- Assertions.assertTrue(console.parse("select from Person2"));
- Assertions.assertTrue(buffer.toString().contains("Jay"));
- Assertions.assertTrue(console.parse("drop type Person2"));
+ assertThat(console.parse("select from Person2")).isTrue();
+ assertThat(buffer.toString().contains("Jay")).isTrue();
+ assertThat(console.parse("drop type Person2")).isTrue();
}
@Test
public void testListDatabases() throws IOException {
- Assertions.assertTrue(console.parse("connect " + URL));
- Assertions.assertTrue(console.parse("list databases;"));
+ assertThat(console.parse("connect " + URL)).isTrue();
+ assertThat(console.parse("list databases;")).isTrue();
}
@Test
public void testInsertAndRollback() throws IOException {
- Assertions.assertTrue(console.parse("connect " + URL));
- Assertions.assertTrue(console.parse("begin"));
- Assertions.assertTrue(console.parse("create document type Person"));
- Assertions.assertTrue(console.parse("insert into Person set name = 'Jay', lastname='Miner'"));
- Assertions.assertTrue(console.parse("rollback"));
+ assertThat(console.parse("connect " + URL)).isTrue();
+ assertThat(console.parse("begin")).isTrue();
+ assertThat(console.parse("create document type Person")).isTrue();
+ assertThat(console.parse("insert into Person set name = 'Jay', lastname='Miner'")).isTrue();
+ assertThat(console.parse("rollback")).isTrue();
final StringBuilder buffer = new StringBuilder();
console.setOutput(buffer::append);
- Assertions.assertTrue(console.parse("select from Person"));
- Assertions.assertFalse(buffer.toString().contains("Jay"));
+ assertThat(console.parse("select from Person")).isTrue();
+ assertThat(buffer.toString().contains("Jay")).isFalse();
}
@Test
public void testInsertAndCommit() throws IOException {
- Assertions.assertTrue(console.parse("connect " + URL));
- Assertions.assertTrue(console.parse("begin"));
- Assertions.assertTrue(console.parse("create document type Person"));
- Assertions.assertTrue(console.parse("insert into Person set name = 'Jay', lastname='Miner'"));
- Assertions.assertTrue(console.parse("commit"));
+ assertThat(console.parse("connect " + URL)).isTrue();
+ assertThat(console.parse("begin")).isTrue();
+ assertThat(console.parse("create document type Person")).isTrue();
+ assertThat(console.parse("insert into Person set name = 'Jay', lastname='Miner'")).isTrue();
+ assertThat(console.parse("commit")).isTrue();
final StringBuilder buffer = new StringBuilder();
console.setOutput(buffer::append);
- Assertions.assertTrue(console.parse("select from Person"));
- Assertions.assertTrue(buffer.toString().contains("Jay"));
+ assertThat(console.parse("select from Person")).isTrue();
+ assertThat(buffer.toString().contains("Jay")).isTrue();
}
@Test
public void testTransactionExpired() throws IOException, InterruptedException {
- Assertions.assertTrue(console.parse("connect " + URL));
- Assertions.assertTrue(console.parse("begin"));
- Assertions.assertTrue(console.parse("create document type Person"));
- Assertions.assertTrue(console.parse("insert into Person set name = 'Jay', lastname='Miner'"));
+ assertThat(console.parse("connect " + URL)).isTrue();
+ assertThat(console.parse("begin")).isTrue();
+ assertThat(console.parse("create document type Person")).isTrue();
+ assertThat(console.parse("insert into Person set name = 'Jay', lastname='Miner'")).isTrue();
Thread.sleep(5000);
try {
- Assertions.assertTrue(console.parse("commit"));
- Assertions.fail();
+ assertThat(console.parse("commit")).isTrue();
+ fail("");
} catch (final Exception e) {
// EXPECTED
}
final StringBuilder buffer = new StringBuilder();
console.setOutput(buffer::append);
- Assertions.assertTrue(console.parse("select from Person"));
- Assertions.assertFalse(buffer.toString().contains("Jay"));
+ assertThat(console.parse("select from Person")).isTrue();
+ assertThat(buffer.toString().contains("Jay")).isFalse();
}
@Test
public void testUserMgmt() throws IOException {
- Assertions.assertTrue(console.parse("connect " + URL));
+ assertThat(console.parse("connect " + URL)).isTrue();
try {
- Assertions.assertTrue(console.parse("drop user elon"));
+ assertThat(console.parse("drop user elon")).isTrue();
} catch (final Exception e) {
// EXPECTED IF ALREADY EXISTENT
}
try {
- Assertions.assertTrue(console.parse("create user jay identified by m"));
- Assertions.fail();
+ assertThat(console.parse("create user jay identified by m")).isTrue();
+ fail("");
} catch (final RuntimeException e) {
// PASSWORD MUST BE AT LEAST 5 CHARS
}
@@ -180,34 +182,34 @@ public void testUserMgmt() throws IOException {
for (int i = 0; i < 257; i++)
longPassword += "P";
- Assertions.assertTrue(console.parse("create user jay identified by " + longPassword));
- Assertions.fail();
+ assertThat(console.parse("create user jay identified by " + longPassword)).isTrue();
+ fail("");
} catch (final RuntimeException e) {
// PASSWORD MUST BE MAX 256 CHARS LONG
}
- Assertions.assertTrue(console.parse("create user elon identified by musk"));
- Assertions.assertTrue(console.parse("drop user elon"));
+ assertThat(console.parse("create user elon identified by musk")).isTrue();
+ assertThat(console.parse("drop user elon")).isTrue();
// TEST SYNTAX ERROR
try {
- Assertions.assertTrue(console.parse("create user elon identified by musk grand connect on db1"));
- Assertions.fail();
+ assertThat(console.parse("create user elon identified by musk grand connect on db1")).isTrue();
+ fail("");
} catch (final Exception e) {
// EXPECTED
}
- Assertions.assertTrue(console.parse("create user elon identified by musk grant connect to db1"));
- Assertions.assertTrue(console.parse("create user jeff identified by amazon grant connect to db1:readonly"));
- Assertions.assertTrue(console.parse("drop user elon"));
+ assertThat(console.parse("create user elon identified by musk grant connect to db1")).isTrue();
+ assertThat(console.parse("create user jeff identified by amazon grant connect to db1:readonly")).isTrue();
+ assertThat(console.parse("drop user elon")).isTrue();
}
@Test
public void testHelp() throws IOException {
final StringBuilder buffer = new StringBuilder();
console.setOutput(buffer::append);
- Assertions.assertTrue(console.parse("?"));
- Assertions.assertTrue(buffer.toString().contains("quit"));
+ assertThat(console.parse("?")).isTrue();
+ assertThat(buffer.toString().contains("quit")).isTrue();
}
/**
@@ -215,84 +217,82 @@ public void testHelp() throws IOException {
*/
@Test
public void testProjectionOrder() throws IOException {
- Assertions.assertTrue(console.parse("connect " + URL));
- Assertions.assertTrue(console.parse("create document type Order"));
- Assertions.assertTrue(console.parse(
- "insert into Order set processor = 'SIR1LRM-7.1', vstart = '20220319_002624.404379', vstop = '20220319_002826.525650', status = 'PENDING'"));
+ assertThat(console.parse("connect " + URL)).isTrue();
+ assertThat(console.parse("create document type Order")).isTrue();
+ assertThat(console.parse(
+ "insert into Order set processor = 'SIR1LRM-7.1', vstart = '20220319_002624.404379', vstop = '20220319_002826.525650', status = 'PENDING'")).isTrue();
{
final StringBuilder buffer = new StringBuilder();
console.setOutput(output -> buffer.append(output));
- Assertions.assertTrue(console.parse("select processor, vstart, vstop, pstart, pstop, status, node from Order"));
+ assertThat(console.parse("select processor, vstart, vstop, pstart, pstop, status, node from Order")).isTrue();
int pos = buffer.toString().indexOf("processor");
- Assertions.assertTrue(pos > -1);
+ assertThat(pos > -1).isTrue();
pos = buffer.toString().indexOf("vstart", pos);
- Assertions.assertTrue(pos > -1);
+ assertThat(pos > -1).isTrue();
pos = buffer.toString().indexOf("vstop", pos);
- Assertions.assertTrue(pos > -1);
+ assertThat(pos > -1).isTrue();
pos = buffer.toString().indexOf("pstart", pos);
- Assertions.assertTrue(pos > -1);
+ assertThat(pos > -1).isTrue();
pos = buffer.toString().indexOf("pstop", pos);
- Assertions.assertTrue(pos > -1);
+ assertThat(pos > -1).isTrue();
pos = buffer.toString().indexOf("status", pos);
- Assertions.assertTrue(pos > -1);
+ assertThat(pos > -1).isTrue();
pos = buffer.toString().indexOf("node", pos);
- Assertions.assertTrue(pos > -1);
+ assertThat(pos > -1).isTrue();
}
}
@Test
public void testCustomPropertyInSchema() throws IOException {
- Assertions.assertTrue(console.parse("connect " + URL));
- Assertions.assertTrue(console.parse("CREATE DOCUMENT TYPE doc;"));
- Assertions.assertTrue(console.parse("ALTER TYPE doc CUSTOM testType = 444;"));
- Assertions.assertTrue(console.parse("CREATE PROPERTY doc.prop STRING;"));
- Assertions.assertTrue(console.parse("ALTER PROPERTY doc.prop CUSTOM test = true;"));
+ assertThat(console.parse("connect " + URL)).isTrue();
+ assertThat(console.parse("CREATE DOCUMENT TYPE doc;")).isTrue();
+ assertThat(console.parse("ALTER TYPE doc CUSTOM testType = 444;")).isTrue();
+ assertThat(console.parse("CREATE PROPERTY doc.prop STRING;")).isTrue();
+ assertThat(console.parse("ALTER PROPERTY doc.prop CUSTOM test = true;")).isTrue();
- Assertions.assertEquals(444, console.getDatabase().getSchema().getType("doc").getCustomValue("testType"));
- Assertions.assertEquals(true, console.getDatabase().getSchema().getType("doc").getProperty("prop").getCustomValue("test"));
+ assertThat(console.getDatabase().getSchema().getType("doc").getCustomValue("testType")).isEqualTo(444);
+ assertThat(console.getDatabase().getSchema().getType("doc").getProperty("prop").getCustomValue("test")).isEqualTo(true);
console.getDatabase().getSchema().getType("doc").setCustomValue("testType", "555");
- Assertions.assertEquals("555", console.getDatabase().getSchema().getType("doc").getCustomValue("testType"));
+ assertThat(console.getDatabase().getSchema().getType("doc").getCustomValue("testType")).isEqualTo("555");
- Assertions.assertEquals(Type.BOOLEAN.name().toUpperCase(),
- console.getDatabase().query("sql", "SELECT properties.custom.test[0].type() as type FROM schema:types").next()
- .getProperty("type"));
+ assertThat(console.getDatabase().query("sql", "SELECT properties.custom.test[0].type() as type FROM schema:types").next()
+ .getProperty("type")).isEqualTo(Type.BOOLEAN.name().toUpperCase());
- Assertions.assertEquals(Type.BOOLEAN.name().toUpperCase(),
- console.getDatabase().command("sql", "SELECT properties.custom.test[0].type() as type FROM schema:types").next()
- .getProperty("type"));
+ assertThat(console.getDatabase().command("sql", "SELECT properties.custom.test[0].type() as type FROM schema:types").next()
+ .getProperty("type")).isEqualTo(Type.BOOLEAN.name().toUpperCase());
}
@Test
public void testIfWithSchemaResult() throws IOException {
- Assertions.assertTrue(console.parse("connect " + URL));
- Assertions.assertTrue(console.parse("CREATE DOCUMENT TYPE doc;"));
- Assertions.assertTrue(console.parse("CREATE PROPERTY doc.prop STRING;"));
+ assertThat(console.parse("connect " + URL)).isTrue();
+ assertThat(console.parse("CREATE DOCUMENT TYPE doc;")).isTrue();
+ assertThat(console.parse("CREATE PROPERTY doc.prop STRING;")).isTrue();
- Assertions.assertTrue(console.parse("INSERT INTO doc set name = 'doc'"));
+ assertThat(console.parse("INSERT INTO doc set name = 'doc'")).isTrue();
ResultSet resultSet = console.getDatabase().command("sql",
"SELECT name, (name = 'doc') as name2, if( (name = 'doc'), true, false) as name3, if( (name IN ['doc','XXX']), true, false) as name4, ifnull( (name = 'doc'), null) as name5 FROM schema:types");
- Assertions.assertTrue(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isTrue();
Result result = resultSet.next();
- Assertions.assertEquals("doc", result.getProperty("name"));
- Assertions.assertTrue((boolean) result.getProperty("name2"));
- Assertions.assertTrue((boolean) result.getProperty("name3"));
- Assertions.assertTrue((boolean) result.getProperty("name4"));
- Assertions.assertTrue((boolean) result.getProperty("name5"));
+ assertThat(result.getProperty("name")).isEqualTo("doc");
+ assertThat( result.getProperty("name2")).isTrue();
+ assertThat( result.getProperty("name3")).isTrue();
+ assertThat( result.getProperty("name4")).isTrue();
+ assertThat( result.getProperty("name5")).isTrue();
resultSet = console.getDatabase().command("sql", "SELECT name FROM schema:types WHERE 'a_b' = 'a b'.replace(' ','_')");
- Assertions.assertTrue(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isTrue();
result = resultSet.next();
- Assertions.assertEquals("doc", result.getProperty("name"));
+ assertThat(result.getProperty("name")).isEqualTo("doc");
}
@Override
@@ -315,7 +315,7 @@ public void beginTest() {
console = new Console();
console.parse("close");
} catch (final IOException e) {
- Assertions.fail(e);
+ fail("", e);
}
}
diff --git a/coverage/pom.xml b/coverage/pom.xml
index f74d322e67..f9677f1433 100644
--- a/coverage/pom.xml
+++ b/coverage/pom.xml
@@ -26,7 +26,7 @@
com.arcadedb
arcadedb-parent
- 24.8.1-SNAPSHOT
+ 24.11.1-SNAPSHOT
../pom.xml
diff --git a/e2e/pom.xml b/e2e/pom.xml
index b897800132..59c814e5e1 100644
--- a/e2e/pom.xml
+++ b/e2e/pom.xml
@@ -25,14 +25,14 @@
com.arcadedb
arcadedb-parent
- 24.8.1-SNAPSHOT
+ 24.11.1-SNAPSHOT
../pom.xml
- 1.20.1
+ 1.20.2
42.7.4
- 1.5.7
+ 1.5.11
true
diff --git a/engine/pom.xml b/engine/pom.xml
index 518fadb943..b9b6605436 100644
--- a/engine/pom.xml
+++ b/engine/pom.xml
@@ -25,7 +25,7 @@
com.arcadedb
arcadedb-parent
- 24.8.1-SNAPSHOT
+ 24.11.1-SNAPSHOT
../pom.xml
@@ -37,7 +37,7 @@
1.2.21
2.11.0
1.8.0
- 9.11.1
+ 9.12.0
22.3.5
1.1.0
0.8
@@ -55,7 +55,7 @@
org.codehaus.mojo
buildnumber-maven-plugin
- 1.4
+ 3.2.1
validate
diff --git a/engine/src/main/java/com/arcadedb/database/DataEncryption.java b/engine/src/main/java/com/arcadedb/database/DataEncryption.java
new file mode 100644
index 0000000000..42e44f4309
--- /dev/null
+++ b/engine/src/main/java/com/arcadedb/database/DataEncryption.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright © 2024-present Arcade Data Ltd (info@arcadedata.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-FileCopyrightText: 2024-present Arcade Data Ltd (info@arcadedata.com)
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package com.arcadedb.database;
+
+/**
+ * Provides methods to intercept serialization of data allowing encryption and decryption.
+ *
+ * @author Pawel Maslej
+ * @since 27 Jun 2024
+ */
+public interface DataEncryption {
+ public byte[] encrypt(byte[] data);
+ public byte[] decrypt(byte[] data);
+}
diff --git a/engine/src/main/java/com/arcadedb/database/Database.java b/engine/src/main/java/com/arcadedb/database/Database.java
index 2963c5c1d1..ffd657b095 100644
--- a/engine/src/main/java/com/arcadedb/database/Database.java
+++ b/engine/src/main/java/com/arcadedb/database/Database.java
@@ -331,4 +331,14 @@ Edge newEdgeByKeys(Vertex sourceVertex, String destinationVertexType, String[] d
* @see #isAsyncFlush()
*/
Database setAsyncFlush(boolean value);
+
+ /**
+ * Sets data encryption to be used by the database.
+ * THIS MUST BE DONE BEFORE WRITING ANY DATA TO THE DATABASE.
+ *
+ * @param encryption implementation of DataEncryption
+ *
+ * @see DefaultDataEncryption
+ */
+ void setDataEncryption(DataEncryption encryption);
}
diff --git a/engine/src/main/java/com/arcadedb/database/DatabaseInternal.java b/engine/src/main/java/com/arcadedb/database/DatabaseInternal.java
index d197e9881c..fbf7182885 100644
--- a/engine/src/main/java/com/arcadedb/database/DatabaseInternal.java
+++ b/engine/src/main/java/com/arcadedb/database/DatabaseInternal.java
@@ -128,4 +128,9 @@ default TransactionContext getTransaction() {
* Executes an operation after having locked files.
*/
RET executeLockingFiles(Collection fileIds, Callable callable);
+
+ @Override
+ default void setDataEncryption(DataEncryption encryption) {
+ getSerializer().setDataEncryption(encryption);
+ }
}
diff --git a/engine/src/main/java/com/arcadedb/database/DefaultDataEncryption.java b/engine/src/main/java/com/arcadedb/database/DefaultDataEncryption.java
new file mode 100644
index 0000000000..fcf312e921
--- /dev/null
+++ b/engine/src/main/java/com/arcadedb/database/DefaultDataEncryption.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright © 2024-present Arcade Data Ltd (info@arcadedata.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-FileCopyrightText: 2024-present Arcade Data Ltd (info@arcadedata.com)
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package com.arcadedb.database;
+
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.security.spec.InvalidKeySpecException;
+import java.security.spec.KeySpec;
+import javax.crypto.Cipher;
+import javax.crypto.KeyGenerator;
+import javax.crypto.NoSuchPaddingException;
+import javax.crypto.SecretKey;
+import javax.crypto.SecretKeyFactory;
+import javax.crypto.spec.GCMParameterSpec;
+import javax.crypto.spec.PBEKeySpec;
+import javax.crypto.spec.SecretKeySpec;
+
+import com.arcadedb.exception.EncryptionException;
+
+/**
+ * Provides configurable default with implementation for data encryption and decryption.
+ *
+ * @author Pawel Maslej
+ * @since 27 Jun 2024
+ */
+public class DefaultDataEncryption implements DataEncryption {
+ public static final int DEFAULT_SALT_ITERATIONS = 65536;
+ public static final int DEFAULT_KEY_LENGTH = 256;
+ public static final String DEFAULT_PASSWORD_ALGORITHM = "PBKDF2WithHmacSHA256";
+ public static final String DEFAULT_SECRET_KEY_ALGORITHM = "AES";
+
+ public static final String DEFAULT_ALGORITHM = "AES/GCM/NoPadding";
+ public static final int DEFAULT_IV_SIZE = 12;
+ public static final int DEFAULT_TAG_SIZE = 128;
+
+ private SecretKey secretKey;
+ private String algorithm;
+ private int ivSize;
+ private int tagSize;
+
+ public DefaultDataEncryption(SecretKey secretKey, String algorithm, int ivSize, int tagSize) throws NoSuchAlgorithmException, NoSuchPaddingException {
+ this.secretKey = secretKey;
+ this.algorithm = algorithm;
+ this.ivSize = ivSize;
+ this.tagSize = tagSize;
+ Cipher.getInstance(algorithm); // validates before execution
+ }
+
+ @Override
+ public byte[] encrypt(byte[] data) {
+ try {
+ var ivBytes = generateIv(ivSize);
+ var cipher = Cipher.getInstance(algorithm);
+ cipher.init(Cipher.ENCRYPT_MODE, secretKey, new GCMParameterSpec(tagSize, ivBytes));
+ byte[] encryptedData = cipher.doFinal(data);
+ byte[] ivAndEncryptedData = new byte[ivBytes.length + encryptedData.length];
+ System.arraycopy(ivBytes, 0, ivAndEncryptedData, 0, ivBytes.length);
+ System.arraycopy(encryptedData, 0, ivAndEncryptedData, ivBytes.length, encryptedData.length);
+ return ivAndEncryptedData;
+ } catch (Exception e) {
+ throw new EncryptionException("Error while encrypting data", e);
+ }
+ }
+
+ @Override
+ public byte[] decrypt(byte[] data) {
+ try {
+ byte[] ivBytes = new byte[ivSize];
+ byte[] encryptedData = new byte[data.length - ivSize];
+ System.arraycopy(data, 0, ivBytes, 0, ivSize);
+ System.arraycopy(data, ivSize, encryptedData, 0, encryptedData.length);
+ var decipher = Cipher.getInstance(algorithm);
+ decipher.init(Cipher.DECRYPT_MODE, secretKey, new GCMParameterSpec(tagSize, ivBytes));
+ return decipher.doFinal(encryptedData);
+ } catch (Exception e) {
+ throw new EncryptionException("Error while decrypting data", e);
+ }
+ }
+
+ public static DefaultDataEncryption useDefaults(SecretKey secretKey) throws NoSuchAlgorithmException, NoSuchPaddingException {
+ return new DefaultDataEncryption(secretKey, DEFAULT_ALGORITHM, DEFAULT_IV_SIZE, DEFAULT_TAG_SIZE);
+ }
+
+ public static SecretKey generateRandomSecretKeyUsingDefaults() throws NoSuchAlgorithmException {
+ KeyGenerator keyGen = KeyGenerator.getInstance(DEFAULT_SECRET_KEY_ALGORITHM);
+ keyGen.init(DEFAULT_KEY_LENGTH);
+ return keyGen.generateKey();
+ }
+
+ public static SecretKey getSecretKeyFromPasswordUsingDefaults(String password, String salt) throws NoSuchAlgorithmException, InvalidKeySpecException {
+ return getKeyFromPassword(password, salt, DEFAULT_PASSWORD_ALGORITHM, DEFAULT_SECRET_KEY_ALGORITHM, DEFAULT_SALT_ITERATIONS, DEFAULT_KEY_LENGTH);
+ }
+
+ private static byte[] generateIv(int ivSize) {
+ final byte[] iv = new byte[ivSize];
+ new SecureRandom().nextBytes(iv);
+ return iv;
+ }
+
+ public static SecretKey getKeyFromPassword(String password, String salt, String passwordAlgorithm, String secretKeyAlgorithm, int saltIterations, int keyLength)
+ throws NoSuchAlgorithmException, InvalidKeySpecException {
+ final SecretKeyFactory factory = SecretKeyFactory.getInstance(passwordAlgorithm);
+ final KeySpec spec = new PBEKeySpec(password.toCharArray(), salt.getBytes(), saltIterations, keyLength);
+ return new SecretKeySpec(factory.generateSecret(spec).getEncoded(), secretKeyAlgorithm);
+ }
+}
diff --git a/engine/src/main/java/com/arcadedb/engine/PaginatedComponentFile.java b/engine/src/main/java/com/arcadedb/engine/PaginatedComponentFile.java
index b68666313a..e1943ecd00 100644
--- a/engine/src/main/java/com/arcadedb/engine/PaginatedComponentFile.java
+++ b/engine/src/main/java/com/arcadedb/engine/PaginatedComponentFile.java
@@ -21,8 +21,10 @@
import com.arcadedb.log.LogManager;
import java.io.*;
+import java.lang.reflect.*;
import java.nio.*;
import java.nio.channels.*;
+import java.nio.channels.spi.*;
import java.util.logging.*;
import java.util.zip.*;
@@ -32,6 +34,14 @@ public class PaginatedComponentFile extends ComponentFile {
private FileChannel channel;
private int pageSize;
+ public class InterruptibleInvocationHandler implements InvocationHandler {
+ @Override
+ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+ LogManager.instance().log(this, Level.SEVERE, "Attempt to close channel");
+ return null;
+ }
+ }
+
public PaginatedComponentFile() {
}
@@ -195,6 +205,21 @@ protected void open(final String filePath, final MODE mode) throws FileNotFoundE
this.osFile = new File(filePath);
this.file = new RandomAccessFile(osFile, mode == MODE.READ_WRITE ? "rw" : "r");
this.channel = this.file.getChannel();
+ doNotCloseOnInterrupt(this.channel);
this.open = true;
}
+
+ private void doNotCloseOnInterrupt(final FileChannel fc) {
+ try {
+ final Field field = AbstractInterruptibleChannel.class.getDeclaredField("interruptor");
+ final Class> interruptibleClass = field.getType();
+ field.setAccessible(true);
+ field.set(fc, Proxy.newProxyInstance(
+ interruptibleClass.getClassLoader(),
+ new Class[] { interruptibleClass },
+ new InterruptibleInvocationHandler()));
+ } catch (final Exception e) {
+ LogManager.instance().log(this, Level.WARNING, "Unable to disable channel close on interrupt: %s", e.getMessage());
+ }
+ }
}
diff --git a/engine/src/main/java/com/arcadedb/exception/EncryptionException.java b/engine/src/main/java/com/arcadedb/exception/EncryptionException.java
new file mode 100644
index 0000000000..9ed4c65746
--- /dev/null
+++ b/engine/src/main/java/com/arcadedb/exception/EncryptionException.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright © 2024-present Arcade Data Ltd (info@arcadedata.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-FileCopyrightText: 2024-present Arcade Data Ltd (info@arcadedata.com)
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package com.arcadedb.exception;
+
+public class EncryptionException extends ArcadeDBException {
+ public EncryptionException(final String message) {
+ super(message);
+ }
+
+ public EncryptionException(final String message, final Throwable cause) {
+ super(message, cause);
+ }
+
+ public EncryptionException(final Throwable cause) {
+ super(cause);
+ }
+}
diff --git a/engine/src/main/java/com/arcadedb/query/sql/method/string/SQLMethodFormat.java b/engine/src/main/java/com/arcadedb/query/sql/method/string/SQLMethodFormat.java
index 325922558d..9e26b631e3 100644
--- a/engine/src/main/java/com/arcadedb/query/sql/method/string/SQLMethodFormat.java
+++ b/engine/src/main/java/com/arcadedb/query/sql/method/string/SQLMethodFormat.java
@@ -60,7 +60,7 @@ public Object execute(final Object value, final Identifiable iRecord, final Comm
return result;
} else if (DateUtils.isDate(value)) {
- return DateUtils.format(value, format);
+ return DateUtils.format(value, format, iParams.length > 1 ? (String) iParams[1] : null);
}
return value != null ? String.format(format, value) : null;
}
diff --git a/engine/src/main/java/com/arcadedb/serializer/BinarySerializer.java b/engine/src/main/java/com/arcadedb/serializer/BinarySerializer.java
index da31de08ba..90281c855c 100644
--- a/engine/src/main/java/com/arcadedb/serializer/BinarySerializer.java
+++ b/engine/src/main/java/com/arcadedb/serializer/BinarySerializer.java
@@ -22,6 +22,7 @@
import com.arcadedb.GlobalConfiguration;
import com.arcadedb.database.BaseRecord;
import com.arcadedb.database.Binary;
+import com.arcadedb.database.DataEncryption;
import com.arcadedb.database.Database;
import com.arcadedb.database.DatabaseContext;
import com.arcadedb.database.DatabaseInternal;
@@ -65,6 +66,7 @@ public class BinarySerializer {
private final BinaryComparator comparator = new BinaryComparator();
private Class> dateImplementation;
private Class> dateTimeImplementation;
+ private DataEncryption dataEncryption;
public BinarySerializer(final ContextConfiguration configuration) throws ClassNotFoundException {
setDateImplementation(configuration.getValue(GlobalConfiguration.DATE_IMPLEMENTATION));
@@ -332,9 +334,10 @@ else if (properties == 0)
return null;
}
- public void serializeValue(final Database database, final Binary content, final byte type, Object value) {
+ public void serializeValue(final Database database, final Binary serialized, final byte type, Object value) {
if (value == null)
return;
+ Binary content = dataEncryption != null ? new Binary() : serialized;
switch (type) {
case BinaryTypes.TYPE_NULL:
@@ -393,8 +396,8 @@ else if (value instanceof LocalDate)
break;
case BinaryTypes.TYPE_COMPRESSED_RID: {
final RID rid = ((Identifiable) value).getIdentity();
- content.putNumber(rid.getBucketId());
- content.putNumber(rid.getPosition());
+ serialized.putNumber(rid.getBucketId());
+ serialized.putNumber(rid.getPosition());
break;
}
case BinaryTypes.TYPE_RID: {
@@ -403,8 +406,8 @@ else if (value instanceof LocalDate)
value = ((Result) value).getElement().get();
final RID rid = ((Identifiable) value).getIdentity();
- content.putInt(rid.getBucketId());
- content.putLong(rid.getPosition());
+ serialized.putInt(rid.getBucketId());
+ serialized.putLong(rid.getPosition());
break;
}
case BinaryTypes.TYPE_UUID: {
@@ -563,10 +566,26 @@ else if (value instanceof LocalDate)
default:
LogManager.instance().log(this, Level.INFO, "Error on serializing value '" + value + "', type not supported");
}
+
+ if (dataEncryption != null) {
+ switch (type) {
+ case BinaryTypes.TYPE_NULL:
+ case BinaryTypes.TYPE_COMPRESSED_RID:
+ case BinaryTypes.TYPE_RID:
+ break;
+ default:
+ serialized.putBytes(dataEncryption.encrypt(content.toByteArray()));
+ }
+ }
}
- public Object deserializeValue(final Database database, final Binary content, final byte type,
+ public Object deserializeValue(final Database database, final Binary deserialized, final byte type,
final EmbeddedModifier embeddedModifier) {
+ Binary content = dataEncryption != null &&
+ type != BinaryTypes.TYPE_NULL &&
+ type != BinaryTypes.TYPE_COMPRESSED_RID &&
+ type != BinaryTypes.TYPE_RID ? new Binary(dataEncryption.decrypt(deserialized.getBytes())) : deserialized;
+
final Object value;
switch (type) {
case BinaryTypes.TYPE_NULL:
@@ -626,10 +645,10 @@ public Object deserializeValue(final Database database, final Binary content, fi
value = new BigDecimal(new BigInteger(unscaledValue), scale);
break;
case BinaryTypes.TYPE_COMPRESSED_RID:
- value = new RID(database, (int) content.getNumber(), content.getNumber());
+ value = new RID(database, (int) deserialized.getNumber(), deserialized.getNumber());
break;
case BinaryTypes.TYPE_RID:
- value = new RID(database, content.getInt(), content.getLong());
+ value = new RID(database, deserialized.getInt(), deserialized.getLong());
break;
case BinaryTypes.TYPE_UUID:
value = new UUID(content.getNumber(), content.getNumber());
@@ -799,4 +818,8 @@ private void serializeDateTime(final Binary content, final Object value, final b
content.putUnsignedNumber(DateUtils.dateTimeToTimestamp(value, DateUtils.getPrecisionFromBinaryType(type)));
}
+ public void setDataEncryption(final DataEncryption dataEncryption) {
+ this.dataEncryption = dataEncryption;
+ }
+
}
diff --git a/engine/src/main/java/com/arcadedb/utility/DateUtils.java b/engine/src/main/java/com/arcadedb/utility/DateUtils.java
index f6ad883b59..2ba77632c0 100755
--- a/engine/src/main/java/com/arcadedb/utility/DateUtils.java
+++ b/engine/src/main/java/com/arcadedb/utility/DateUtils.java
@@ -369,7 +369,12 @@ else if (obj instanceof Date)
return getFormatter(format).format(millisToLocalDateTime(((Date) obj).getTime(), timeZone));
else if (obj instanceof Calendar)
return getFormatter(format).format(millisToLocalDateTime(((Calendar) obj).getTimeInMillis(), timeZone));
- else if (obj instanceof TemporalAccessor)
+ else if (obj instanceof LocalDateTime) {
+ if (timeZone != null)
+ return ((LocalDateTime) obj).atZone(ZoneId.of(timeZone)).format(getFormatter(format));
+ else
+ return getFormatter(format).format(((LocalDateTime) obj));
+ } else if (obj instanceof TemporalAccessor)
return getFormatter(format).format((TemporalAccessor) obj);
return null;
}
diff --git a/engine/src/test/java/com/arcadedb/ACIDTransactionTest.java b/engine/src/test/java/com/arcadedb/ACIDTransactionTest.java
index 7f0d22e0b0..eb45bdc402 100644
--- a/engine/src/test/java/com/arcadedb/ACIDTransactionTest.java
+++ b/engine/src/test/java/com/arcadedb/ACIDTransactionTest.java
@@ -25,15 +25,17 @@
import com.arcadedb.database.bucketselectionstrategy.ThreadBucketSelectionStrategy;
import com.arcadedb.engine.WALException;
import com.arcadedb.engine.WALFile;
+import com.arcadedb.exception.NeedRetryException;
import com.arcadedb.exception.TransactionException;
import com.arcadedb.graph.MutableVertex;
import com.arcadedb.log.LogManager;
+import com.arcadedb.query.sql.executor.Result;
import com.arcadedb.query.sql.executor.ResultSet;
import com.arcadedb.schema.DocumentType;
import com.arcadedb.schema.Schema;
import com.arcadedb.schema.Type;
import com.arcadedb.schema.VertexType;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.Test;
import java.io.*;
@@ -42,6 +44,10 @@
import java.util.concurrent.atomic.*;
import java.util.logging.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.api.Assertions.fail;
+
public class ACIDTransactionTest extends TestHelper {
@Test
public void testAsyncTX() {
@@ -75,7 +81,7 @@ public void testAsyncTX() {
}
} catch (final TransactionException e) {
- Assertions.assertTrue(e.getCause() instanceof IOException);
+ assertThat(e.getCause() instanceof IOException).isTrue();
}
((DatabaseInternal) db).kill();
@@ -84,7 +90,7 @@ public void testAsyncTX() {
verifyDatabaseWasNotClosedProperly();
- database.transaction(() -> Assertions.assertEquals(TOT, database.countType("V", true)));
+ database.transaction(() -> assertThat(database.countType("V", true)).isEqualTo(TOT));
}
@Test
@@ -106,17 +112,17 @@ public void testIndexCreationWhileAsyncMustFail() {
db.async().createRecord(v, null);
}
+ // creating the index should throw exception because there's an aync creation ongoing: sometimes it doesn't happen, the async is finished
try {
database.getSchema().getType("V").createTypeIndex(Schema.INDEX_TYPE.LSM_TREE, true, "id");
- Assertions.fail();
- } catch (Exception e) {
- // EXPECTED
+ } catch (NeedRetryException e) {
+ //no action
}
db.async().waitCompletion();
} catch (final TransactionException e) {
- Assertions.assertTrue(e.getCause() instanceof IOException);
+ assertThat(e.getCause() instanceof IOException).isTrue();
}
((DatabaseInternal) db).kill();
@@ -125,13 +131,13 @@ public void testIndexCreationWhileAsyncMustFail() {
verifyDatabaseWasNotClosedProperly();
- database.transaction(() -> Assertions.assertEquals(TOT, database.countType("V", true)));
+ database.transaction(() -> assertThat(database.countType("V", true)).isEqualTo(TOT));
}
@Test
public void testDatabaseInternals() {
- Assertions.assertNotNull(((DatabaseInternal) database).getStats());
- Assertions.assertNull(database.getCurrentUserName());
+ assertThat(((DatabaseInternal) database).getStats()).isNotNull();
+ assertThat(database.getCurrentUserName()).isNull();
}
@Test
@@ -151,7 +157,7 @@ public void testCrashDuringTx() {
verifyDatabaseWasNotClosedProperly();
- database.transaction(() -> Assertions.assertEquals(0, database.countType("V", true)));
+ database.transaction(() -> assertThat(database.countType("V", true)).isEqualTo(0));
}
@Test
@@ -174,10 +180,10 @@ public void testIOExceptionAfterWALIsWritten() {
db.commit();
- Assertions.fail("Expected commit to fail");
+ fail("Expected commit to fail");
} catch (final TransactionException e) {
- Assertions.assertTrue(e.getCause() instanceof WALException);
+ assertThat(e.getCause() instanceof WALException).isTrue();
}
((DatabaseInternal) db).kill();
@@ -185,7 +191,7 @@ public void testIOExceptionAfterWALIsWritten() {
verifyDatabaseWasNotClosedProperly();
- database.transaction(() -> Assertions.assertEquals(1, database.countType("V", true)));
+ database.transaction(() -> assertThat(database.countType("V", true)).isEqualTo(1));
((DatabaseInternal) db).unregisterCallback(DatabaseInternal.CALLBACK_EVENT.TX_AFTER_WAL_WRITE, callback);
}
@@ -236,10 +242,10 @@ public Void call() throws IOException {
// IGNORE IT
}
- Assertions.assertEquals(1, errors.get());
+ assertThat(errors.get()).isEqualTo(1);
} catch (final TransactionException e) {
- Assertions.assertTrue(e.getCause() instanceof IOException);
+ assertThat(e.getCause() instanceof IOException).isTrue();
}
((DatabaseInternal) db).kill();
@@ -247,7 +253,7 @@ public Void call() throws IOException {
verifyDatabaseWasNotClosedProperly();
- database.transaction(() -> Assertions.assertEquals(TOT, database.countType("V", true)));
+ database.transaction(() -> assertThat(database.countType("V", true)).isEqualTo(TOT));
}
@Test
@@ -260,16 +266,16 @@ public void testAsyncIOExceptionAfterWALIsWrittenManyRecords() {
final AtomicInteger errors = new AtomicInteger(0);
db.async().setTransactionSync(WALFile.FLUSH_TYPE.YES_NOMETADATA);
- Assertions.assertEquals(WALFile.FLUSH_TYPE.YES_NOMETADATA, db.async().getTransactionSync());
+ assertThat(db.async().getTransactionSync()).isEqualTo(WALFile.FLUSH_TYPE.YES_NOMETADATA);
db.async().setTransactionUseWAL(true);
- Assertions.assertTrue(db.async().isTransactionUseWAL());
+ assertThat(db.async().isTransactionUseWAL()).isTrue();
db.async().setCommitEvery(1000000);
- Assertions.assertEquals(1000000, db.async().getCommitEvery());
+ assertThat(db.async().getCommitEvery()).isEqualTo(1000000);
db.async().setBackPressure(1);
- Assertions.assertEquals(1, db.async().getBackPressure());
+ assertThat(db.async().getBackPressure()).isEqualTo(1);
db.async().onError(exception -> errors.incrementAndGet());
@@ -291,10 +297,10 @@ public void testAsyncIOExceptionAfterWALIsWrittenManyRecords() {
db.async().waitCompletion();
- Assertions.assertTrue(errors.get() > 0);
+ assertThat(errors.get() > 0).isTrue();
} catch (final TransactionException e) {
- Assertions.assertTrue(e.getCause() instanceof IOException);
+ assertThat(e.getCause() instanceof IOException).isTrue();
}
((DatabaseInternal) db).kill();
@@ -302,7 +308,7 @@ public void testAsyncIOExceptionAfterWALIsWrittenManyRecords() {
verifyDatabaseWasNotClosedProperly();
- database.transaction(() -> Assertions.assertEquals(TOT, database.countType("V", true)));
+ database.transaction(() -> assertThat(database.countType("V", true)).isEqualTo(TOT));
}
@Test
@@ -365,20 +371,21 @@ public void multiThreadConcurrentTransactions() {
database.async().waitCompletion();
- Assertions.assertEquals(0, errors.get());
+ assertThat(errors.get()).isEqualTo(0);
database.transaction(() -> {
- Assertions.assertEquals(TOT_STOCKS * TOT_DAYS, database.countType("Stock", true));
- Assertions.assertEquals(0, database.countType("Aggregate", true));
+ assertThat(database.countType("Stock", true)).isEqualTo(TOT_STOCKS * TOT_DAYS);
+ assertThat(database.countType("Aggregate", true)).isEqualTo(0);
final Calendar now = Calendar.getInstance();
now.setTimeInMillis(startingDay.getTimeInMillis());
for (int i = 0; i < TOT_DAYS; ++i) {
for (int stockId = 0; stockId < TOT_STOCKS; ++stockId) {
- final ResultSet result = database.query("sql", "select from Stock where symbol = ? and date = ?", "" + stockId, now.getTimeInMillis());
- Assertions.assertNotNull(result);
- Assertions.assertTrue(result.hasNext(), "Cannot find stock=" + stockId + " date=" + now.getTimeInMillis());
+ final ResultSet result = database.query("sql", "select from Stock where symbol = ? and date = ?", "" + stockId,
+ now.getTimeInMillis());
+ assertThat((Iterator extends Result>) result).isNotNull();
+ assertThat(result.hasNext()).withFailMessage("Cannot find stock=" + stockId + " date=" + now.getTimeInMillis()).isTrue();
}
now.add(Calendar.DAY_OF_YEAR, +1);
}
@@ -395,16 +402,16 @@ public void testAsyncEdges() {
final AtomicInteger errors = new AtomicInteger(0);
db.async().setTransactionSync(WALFile.FLUSH_TYPE.YES_NOMETADATA);
- Assertions.assertEquals(WALFile.FLUSH_TYPE.YES_NOMETADATA, db.async().getTransactionSync());
+ assertThat(db.async().getTransactionSync()).isEqualTo(WALFile.FLUSH_TYPE.YES_NOMETADATA);
db.async().setTransactionUseWAL(true);
- Assertions.assertTrue(db.async().isTransactionUseWAL());
+ assertThat(db.async().isTransactionUseWAL()).isTrue();
db.async().setCommitEvery(TOT);
- Assertions.assertEquals(TOT, db.async().getCommitEvery());
+ assertThat(db.async().getCommitEvery()).isEqualTo(TOT);
db.async().setBackPressure(1);
- Assertions.assertEquals(1, db.async().getBackPressure());
+ assertThat(db.async().getBackPressure()).isEqualTo(1);
db.async().onError(exception -> errors.incrementAndGet());
@@ -423,14 +430,14 @@ public void testAsyncEdges() {
}
db.async().waitCompletion();
- Assertions.assertEquals(0, errors.get());
+ assertThat(errors.get()).isEqualTo(0);
for (int i = 1; i < TOT; ++i) {
db.async().newEdgeByKeys("Node", "id", i, "Node", "id", i - 1, false, "Arc", true, false, null, "id", i);
}
db.async().waitCompletion();
- Assertions.assertEquals(0, errors.get());
+ assertThat(errors.get()).isEqualTo(0);
((DatabaseInternal) db).kill();
@@ -438,8 +445,8 @@ public void testAsyncEdges() {
verifyDatabaseWasNotClosedProperly();
- database.transaction(() -> Assertions.assertEquals(TOT, database.countType("Node", true)));
- database.transaction(() -> Assertions.assertEquals(TOT - 1, database.countType("Arc", true)));
+ database.transaction(() -> assertThat(database.countType("Node", true)).isEqualTo(TOT));
+ database.transaction(() -> assertThat(database.countType("Arc", true)).isEqualTo(TOT - 1));
}
private void verifyDatabaseWasNotClosedProperly() {
@@ -452,15 +459,15 @@ private void verifyDatabaseWasNotClosedProperly() {
});
database = factory.open();
- Assertions.assertTrue(dbNotClosedCaught.get());
+ assertThat(dbNotClosedCaught.get()).isTrue();
}
private void verifyWALFilesAreStillPresent() {
final File dbDir = new File(getDatabasePath());
- Assertions.assertTrue(dbDir.exists());
- Assertions.assertTrue(dbDir.isDirectory());
+ assertThat(dbDir.exists()).isTrue();
+ assertThat(dbDir.isDirectory()).isTrue();
final File[] files = dbDir.listFiles((dir, name) -> name.endsWith("wal"));
- Assertions.assertTrue(files.length > 0);
+ assertThat(files.length > 0).isTrue();
}
@Override
diff --git a/engine/src/test/java/com/arcadedb/AsyncTest.java b/engine/src/test/java/com/arcadedb/AsyncTest.java
index 1d7fbf86e4..5f35209886 100644
--- a/engine/src/test/java/com/arcadedb/AsyncTest.java
+++ b/engine/src/test/java/com/arcadedb/AsyncTest.java
@@ -25,13 +25,16 @@
import com.arcadedb.query.sql.executor.ResultSet;
import com.arcadedb.schema.DocumentType;
import com.arcadedb.schema.Schema;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.Test;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
public class AsyncTest extends TestHelper {
private static final int TOT = 10000;
private static final String TYPE_NAME = "V";
@@ -47,7 +50,7 @@ public void testScan() {
return true;
});
- Assertions.assertEquals(TOT, callbackInvoked.get());
+ assertThat(callbackInvoked.get()).isEqualTo(TOT);
database.async().waitCompletion();
database.async().waitCompletion();
@@ -79,16 +82,16 @@ public void testSyncScanAndAsyncUpdate() {
database.commit();
}
- Assertions.assertEquals(TOT, callbackInvoked.get());
- Assertions.assertEquals(TOT, updatedRecords.get());
+ assertThat(callbackInvoked.get()).isEqualTo(TOT);
+ assertThat(updatedRecords.get()).isEqualTo(TOT);
ResultSet resultSet = database.query("sql", "select from " + TYPE_NAME + " where updated <> true");
Assertions.assertFalse(resultSet.hasNext());
resultSet = database.query("sql", "select count(*) as count from " + TYPE_NAME + " where updated = true");
- Assertions.assertTrue(resultSet.hasNext());
- Assertions.assertEquals(TOT, ((Number) resultSet.next().getProperty("count")).intValue());
+ assertThat(resultSet.hasNext()).isTrue();
+ assertThat(((Number) resultSet.next().getProperty("count")).intValue()).isEqualTo(TOT);
}
@Test
@@ -106,13 +109,13 @@ public void testAsyncDelete() {
database.async().waitCompletion();
- Assertions.assertEquals(TOT, callbackInvoked.get());
- Assertions.assertEquals(TOT, deletedRecords.get());
+ assertThat(callbackInvoked.get()).isEqualTo(TOT);
+ assertThat(deletedRecords.get()).isEqualTo(TOT);
final ResultSet resultSet = database.query("sql", "select count(*) as count from " + TYPE_NAME + " where updated = true");
- Assertions.assertTrue(resultSet.hasNext());
- Assertions.assertEquals(0, ((Number) resultSet.next().getProperty("count")).intValue());
+ assertThat(resultSet.hasNext()).isTrue();
+ assertThat(((Number) resultSet.next().getProperty("count")).intValue()).isEqualTo(0);
populateDatabase();
@@ -134,7 +137,7 @@ public void testScanInterrupt() {
return callbackInvoked.getAndIncrement() < 10;
});
- Assertions.assertTrue(callbackInvoked.get() < 20);
+ assertThat(callbackInvoked.get() < 20).isTrue();
} finally {
database.commit();
@@ -162,8 +165,8 @@ public void onError(final Exception exception) {
database.async().waitCompletion(5_000);
- Assertions.assertEquals(1, completeCallbackInvoked.get());
- Assertions.assertEquals(0, errorCallbackInvoked.get());
+ assertThat(completeCallbackInvoked.get()).isEqualTo(1);
+ assertThat(errorCallbackInvoked.get()).isEqualTo(0);
} finally {
database.commit();
@@ -193,9 +196,9 @@ public void testParallelQueries() throws InterruptedException {
// WAIT INDEFINITELY
counter.await();
- Assertions.assertTrue(resultSets[0].hasNext());
- Assertions.assertTrue(resultSets[1].hasNext());
- Assertions.assertTrue(resultSets[2].hasNext());
+ assertThat(resultSets[0].hasNext()).isTrue();
+ assertThat(resultSets[1].hasNext()).isTrue();
+ assertThat(resultSets[2].hasNext()).isTrue();
} finally {
database.commit();
@@ -223,8 +226,8 @@ public void onError(final Exception exception) {
database.async().waitCompletion(5_000);
- Assertions.assertEquals(1, completeCallbackInvoked.get());
- Assertions.assertEquals(0, errorCallbackInvoked.get());
+ assertThat(completeCallbackInvoked.get()).isEqualTo(1);
+ assertThat(errorCallbackInvoked.get()).isEqualTo(0);
} finally {
database.commit();
@@ -241,9 +244,9 @@ public void testCommandFetchVarargParamsNoCallback() {
final IndexCursor resultSet = database.lookupByKey(TYPE_NAME, "id", Integer.MAX_VALUE);
- Assertions.assertTrue(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isTrue();
final Document record = resultSet.next().asDocument();
- Assertions.assertEquals(Integer.MAX_VALUE, record.get("id"));
+ assertThat(record.get("id")).isEqualTo(Integer.MAX_VALUE);
} finally {
database.commit();
@@ -272,8 +275,8 @@ public void onError(final Exception exception) {
database.async().waitCompletion(5_000);
- Assertions.assertEquals(1, completeCallbackInvoked.get());
- Assertions.assertEquals(0, errorCallbackInvoked.get());
+ assertThat(completeCallbackInvoked.get()).isEqualTo(1);
+ assertThat(errorCallbackInvoked.get()).isEqualTo(0);
} finally {
database.commit();
@@ -301,8 +304,8 @@ public void onError(final Exception exception) {
database.async().waitCompletion(5_000);
- Assertions.assertEquals(1, completeCallbackInvoked.get());
- Assertions.assertEquals(0, errorCallbackInvoked.get());
+ assertThat(completeCallbackInvoked.get()).isEqualTo(1);
+ assertThat(errorCallbackInvoked.get()).isEqualTo(0);
} finally {
database.commit();
@@ -330,8 +333,8 @@ public void onError(final Exception exception) {
database.async().waitCompletion(5_000);
- Assertions.assertEquals(0, completeCallbackInvoked.get());
- Assertions.assertEquals(1, errorCallbackInvoked.get());
+ assertThat(completeCallbackInvoked.get()).isEqualTo(0);
+ assertThat(errorCallbackInvoked.get()).isEqualTo(1);
} finally {
database.commit();
@@ -342,7 +345,7 @@ public void onError(final Exception exception) {
protected void beginTest() {
database.begin();
- Assertions.assertFalse(database.getSchema().existsType(TYPE_NAME));
+ assertThat(database.getSchema().existsType(TYPE_NAME)).isFalse();
final AtomicLong okCallbackInvoked = new AtomicLong();
@@ -350,7 +353,7 @@ protected void beginTest() {
database.async().setParallelLevel(3);
database.async().onOk(() -> okCallbackInvoked.incrementAndGet());
- database.async().onError(exception -> Assertions.fail("Error on creating async record", exception));
+ database.async().onError(exception -> fail("Error on creating async record", exception));
final DocumentType type = database.getSchema().buildDocumentType().withName(TYPE_NAME).withTotalBuckets(3).create();
type.createProperty("id", Integer.class);
@@ -362,7 +365,7 @@ protected void beginTest() {
populateDatabase();
- Assertions.assertTrue(okCallbackInvoked.get() > 0);
+ assertThat(okCallbackInvoked.get() > 0).isTrue();
}
private void populateDatabase() {
diff --git a/engine/src/test/java/com/arcadedb/BLOBTest.java b/engine/src/test/java/com/arcadedb/BLOBTest.java
index 48f04cc667..09e3d0fce1 100644
--- a/engine/src/test/java/com/arcadedb/BLOBTest.java
+++ b/engine/src/test/java/com/arcadedb/BLOBTest.java
@@ -22,9 +22,12 @@
import com.arcadedb.database.MutableDocument;
import com.arcadedb.schema.DocumentType;
import com.arcadedb.schema.Type;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class BLOBTest extends TestHelper {
@Override
public void beginTest() {
@@ -44,7 +47,7 @@ public void testWriteAndRead() {
database.transaction(() -> {
final Document blob = database.iterateType("Blob", false).next().asDocument();
- Assertions.assertEquals("This is a test", new String( blob.getBinary("binary")));
+ assertThat(new String( blob.getBinary("binary"))).isEqualTo("This is a test");
});
}
}
diff --git a/engine/src/test/java/com/arcadedb/CRUDTest.java b/engine/src/test/java/com/arcadedb/CRUDTest.java
index b4e240cb2f..cecc140b53 100644
--- a/engine/src/test/java/com/arcadedb/CRUDTest.java
+++ b/engine/src/test/java/com/arcadedb/CRUDTest.java
@@ -27,12 +27,16 @@
import com.arcadedb.log.LogManager;
import com.arcadedb.schema.Schema;
import com.arcadedb.schema.Type;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.Test;
import java.util.concurrent.atomic.*;
import java.util.logging.*;
+import org.assertj.core.api.Assertions;
+import static org.assertj.core.api.Assertions.assertThat;
+
+
public class CRUDTest extends TestHelper {
private static final int TOT = ((int) GlobalConfiguration.BUCKET_DEFAULT_PAGE_SIZE.getDefValue()) * 2;
@@ -59,11 +63,11 @@ public void testUpdate() {
db.begin();
- Assertions.assertEquals(TOT, db.countType("V", true));
+ assertThat(db.countType("V", true)).isEqualTo(TOT);
db.scanType("V", true, record -> {
- Assertions.assertEquals(true, record.get("update"));
- Assertions.assertEquals("This is a large field to force the page overlap at some point", record.get("largeField"));
+ assertThat(record.get("update")).isEqualTo(true);
+ assertThat(record.get("largeField")).isEqualTo("This is a large field to force the page overlap at some point");
return true;
});
@@ -83,16 +87,15 @@ public void testMultiUpdatesOverlap() {
final String largeField = "largeField" + i;
updateAll(largeField);
- Assertions.assertEquals(TOT, db.countType("V", true));
+ assertThat(db.countType("V", true)).isEqualTo(TOT);
- Assertions.assertEquals(TOT,
- ((Long) db.query("sql", "select count(*) as count from V where " + largeField + " is not null").nextIfAvailable()
- .getProperty("count")).intValue(), "Count not expected for field '" + largeField + "'");
+ assertThat(((Long) db.query("sql", "select count(*) as count from V where " + largeField + " is not null").nextIfAvailable()
+ .getProperty("count")).intValue()).as("Count not expected for field '" + largeField + "'").isEqualTo(TOT);
db.commit();
db.begin();
- Assertions.assertEquals(TOT, db.countType("V", true));
+ assertThat(db.countType("V", true)).isEqualTo(TOT);
LogManager.instance().log(this, Level.FINE, "Completed %d cycle of updates", i);
}
@@ -111,24 +114,23 @@ public void testMultiUpdatesOverlap() {
final String largeField = "largeField" + i;
updateAll(largeField);
- Assertions.assertEquals(TOT, db.countType("V", true));
- Assertions.assertEquals(TOT,
- ((Long) db.query("sql", "select count(*) as count from V where " + largeField + " is not null").nextIfAvailable()
- .getProperty("count")).intValue(), "Count not expected for field '" + largeField + "'");
+ assertThat(db.countType("V", true)).isEqualTo(TOT);
+ assertThat(((Long) db.query("sql", "select count(*) as count from V where " + largeField + " is not null").nextIfAvailable()
+ .getProperty("count")).intValue()).as("Count not expected for field '" + largeField + "'").isEqualTo(TOT);
db.commit();
db.begin();
- Assertions.assertEquals(TOT, db.countType("V", true));
+ assertThat(db.countType("V", true)).isEqualTo(TOT);
LogManager.instance().log(this, Level.FINE, "Completed %d cycle of updates", i);
}
db.scanType("V", true, record -> {
- Assertions.assertEquals(true, record.get("update"));
+ assertThat(record.get("update")).isEqualTo(true);
for (int i = 0; i < 10; ++i)
- Assertions.assertEquals("This is a large field to force the page overlap at some point", record.get("largeField" + i));
+ assertThat(record.get("largeField" + i)).isEqualTo("This is a large field to force the page overlap at some point");
return true;
});
@@ -184,39 +186,37 @@ public void testMultiUpdatesAndDeleteOverlap() {
db.begin();
- Assertions.assertEquals(TOT, db.countType("V", true));
+ assertThat(db.countType("V", true)).isEqualTo(TOT);
updateAll("largeField" + i);
- Assertions.assertEquals(TOT, db.countType("V", true));
+ assertThat(db.countType("V", true)).isEqualTo(TOT);
db.commit();
db.begin();
- Assertions.assertEquals(TOT, db.countType("V", true));
+ assertThat(db.countType("V", true)).isEqualTo(TOT);
db.scanType("V", true, record -> {
- Assertions.assertEquals(true, record.get("update"));
-
- Assertions.assertEquals("This is a large field to force the page overlap at some point",
- record.get("largeField" + counter), "Unexpected content in record " + record.getIdentity());
+ assertThat(record.get("update")).isEqualTo(true);
+ assertThat(record.get("largeField" + counter)).isEqualTo("This is a large field to force the page overlap at some point");
return true;
});
deleteAll();
- Assertions.assertEquals(0, db.countType("V", true));
+ assertThat(db.countType("V", true)).isEqualTo(0);
db.commit();
- database.transaction(() -> Assertions.assertEquals(0, db.countType("V", true)));
+ database.transaction(() -> assertThat(db.countType("V", true)).isEqualTo(0));
LogManager.instance().log(this, Level.FINE, "Completed %d cycle of updates+delete", i);
createAll();
- database.transaction(() -> Assertions.assertEquals(TOT, db.countType("V", true)));
+ database.transaction(() -> assertThat(db.countType("V", true)).isEqualTo(TOT));
}
} finally {
diff --git a/engine/src/test/java/com/arcadedb/ConcurrentWriteTest.java b/engine/src/test/java/com/arcadedb/ConcurrentWriteTest.java
index 13b586cf79..4efe970750 100644
--- a/engine/src/test/java/com/arcadedb/ConcurrentWriteTest.java
+++ b/engine/src/test/java/com/arcadedb/ConcurrentWriteTest.java
@@ -25,13 +25,14 @@
import com.arcadedb.exception.ConcurrentModificationException;
import com.arcadedb.graph.MutableVertex;
import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.*;
import java.util.concurrent.atomic.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class ConcurrentWriteTest {
private static final int TOTAL = 10_000;
private static final int BATCH_TX = 1;
@@ -84,11 +85,11 @@ public void checkConcurrentInsertWithHighConcurrencyOnSamePage() {
List allIds = checkRecordSequence(database);
- Assertions.assertEquals(TOTAL * CONCURRENT_THREADS, allIds.size());
+ assertThat(allIds.size()).isEqualTo(TOTAL * CONCURRENT_THREADS);
- Assertions.assertEquals(TOTAL * CONCURRENT_THREADS, totalRecordsOnClusters);
+ assertThat(totalRecordsOnClusters).isEqualTo(TOTAL * CONCURRENT_THREADS);
- Assertions.assertEquals(TOTAL * CONCURRENT_THREADS, database.countType("User", true));
+ assertThat(database.countType("User", true)).isEqualTo(TOTAL * CONCURRENT_THREADS);
}
private List checkRecordSequence(final Database database) {
diff --git a/engine/src/test/java/com/arcadedb/ConfigurationTest.java b/engine/src/test/java/com/arcadedb/ConfigurationTest.java
index 7236c1eaa1..8827f7be23 100644
--- a/engine/src/test/java/com/arcadedb/ConfigurationTest.java
+++ b/engine/src/test/java/com/arcadedb/ConfigurationTest.java
@@ -18,41 +18,41 @@
*/
package com.arcadedb;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.io.*;
import static com.arcadedb.GlobalConfiguration.TEST;
+import static org.assertj.core.api.Assertions.assertThat;
public class ConfigurationTest {
@Test
public void testGlobalExport2Json() {
- Assertions.assertFalse(TEST.getValueAsBoolean());
+ assertThat(TEST.getValueAsBoolean()).isFalse();
final String json = GlobalConfiguration.toJSON();
TEST.setValue(true);
- Assertions.assertTrue(TEST.getValueAsBoolean());
+ assertThat(TEST.getValueAsBoolean()).isTrue();
GlobalConfiguration.fromJSON(json);
- Assertions.assertFalse(TEST.getValueAsBoolean());
+ assertThat(TEST.getValueAsBoolean()).isFalse();
}
@Test
public void testContextExport2Json() {
final ContextConfiguration cfg = new ContextConfiguration();
cfg.setValue(TEST, false);
- Assertions.assertFalse(cfg.getValueAsBoolean(TEST));
+ assertThat(cfg.getValueAsBoolean(TEST)).isFalse();
final String json = cfg.toJSON();
cfg.setValue(TEST, true);
- Assertions.assertTrue(cfg.getValueAsBoolean(TEST));
+ assertThat(cfg.getValueAsBoolean(TEST)).isTrue();
cfg.fromJSON(json);
- Assertions.assertFalse(cfg.getValueAsBoolean(TEST));
+ assertThat(cfg.getValueAsBoolean(TEST)).isFalse();
}
@Test
public void testDump() {
final ByteArrayOutputStream out = new ByteArrayOutputStream();
GlobalConfiguration.dumpConfiguration(new PrintStream(out));
- Assertions.assertTrue(out.size() > 0);
+ assertThat(out.size() > 0).isTrue();
}
}
diff --git a/engine/src/test/java/com/arcadedb/ConstantsTest.java b/engine/src/test/java/com/arcadedb/ConstantsTest.java
index eb9f814609..3bfb31dc49 100644
--- a/engine/src/test/java/com/arcadedb/ConstantsTest.java
+++ b/engine/src/test/java/com/arcadedb/ConstantsTest.java
@@ -18,53 +18,54 @@
*/
package com.arcadedb;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+
class ConstantsTest {
@Test
void getVersionMajor() {
- Assertions.assertNotNull(Constants.getVersionMajor());
+ assertThat(Constants.getVersionMajor()).isNotNull();
}
@Test
void getVersionMinor() {
- Assertions.assertNotNull(Constants.getVersionMinor());
+ assertThat(Constants.getVersionMinor()).isNotNull();
}
@Test
void getVersionHotfix() {
- Assertions.assertNotNull(Constants.getVersionHotfix());
+ assertThat(Constants.getVersionHotfix()).isNotNull();
}
@Test
void getVersion() {
- Assertions.assertNotNull(Constants.getVersion());
+ assertThat(Constants.getVersion()).isNotNull();
}
@Test
void getRawVersion() {
- Assertions.assertNotNull(Constants.getRawVersion());
+ assertThat(Constants.getRawVersion()).isNotNull();
}
@Test
void getBranch() {
- Assertions.assertNotNull(Constants.getBranch());
+ assertThat(Constants.getBranch()).isNotNull();
}
@Test
void getBuildNumber() {
- Assertions.assertNotNull(Constants.getBuildNumber());
+ assertThat(Constants.getBuildNumber()).isNotNull();
}
@Test
void getTimestamp() {
- Assertions.assertNotNull(Constants.getTimestamp());
+ assertThat(Constants.getTimestamp()).isNotNull();
}
@Test
void isSnapshot() {
- Assertions.assertNotNull(Constants.isSnapshot());
+ assertThat(Constants.isSnapshot()).isNotNull();
}
}
diff --git a/engine/src/test/java/com/arcadedb/DocumentTest.java b/engine/src/test/java/com/arcadedb/DocumentTest.java
index 520765b349..1e0fb5f506 100644
--- a/engine/src/test/java/com/arcadedb/DocumentTest.java
+++ b/engine/src/test/java/com/arcadedb/DocumentTest.java
@@ -23,11 +23,15 @@
import com.arcadedb.database.MutableDocument;
import com.arcadedb.schema.DocumentType;
import com.arcadedb.schema.Type;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.Test;
import java.util.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
+
public class DocumentTest extends TestHelper {
@Override
public void beginTest() {
@@ -68,37 +72,37 @@ public void testDetached() {
doc.reload();
doc.detach();
- Assertions.assertEquals("Tim", detached.getString("name"));
- Assertions.assertEquals(embeddedObj, detached.get("embeddedObj"));
- Assertions.assertEquals(embeddedList, detached.get("embeddedList"));
- Assertions.assertEquals(embeddedMap, detached.get("embeddedMap"));
- Assertions.assertNull(detached.getString("lastname"));
+ assertThat(detached.getString("name")).isEqualTo("Tim");
+ assertThat(detached.get("embeddedObj")).isEqualTo(embeddedObj);
+ assertThat(detached.get("embeddedList")).isEqualTo(embeddedList);
+ assertThat(detached.get("embeddedMap")).isEqualTo(embeddedMap);
+ assertThat(detached.getString("lastname")).isNull();
final Set props = detached.getPropertyNames();
- Assertions.assertEquals(4, props.size());
- Assertions.assertTrue(props.contains("name"));
- Assertions.assertTrue(props.contains("embeddedObj"));
- Assertions.assertTrue(props.contains("embeddedList"));
- Assertions.assertTrue(props.contains("embeddedMap"));
+ assertThat(props).hasSize(4);
+ assertThat(props.contains("name")).isTrue();
+ assertThat(props.contains("embeddedObj")).isTrue();
+ assertThat(props.contains("embeddedList")).isTrue();
+ assertThat(props.contains("embeddedMap")).isTrue();
final Map map = detached.toMap();
- Assertions.assertEquals(6, map.size());
+ assertThat(map).hasSize(6);
- Assertions.assertEquals("Tim", map.get("name"));
- Assertions.assertEquals(embeddedObj, map.get("embeddedObj"));
- Assertions.assertTrue(((DetachedDocument) map.get("embeddedObj")).getBoolean("embeddedObj"));
- Assertions.assertEquals(embeddedList, map.get("embeddedList"));
- Assertions.assertTrue(((List) map.get("embeddedList")).get(0).getBoolean("embeddedList"));
- Assertions.assertEquals(embeddedMap, map.get("embeddedMap"));
- Assertions.assertTrue(((Map) map.get("embeddedMap")).get("first").getBoolean("embeddedMap"));
+ assertThat(map.get("name")).isEqualTo("Tim");
+ assertThat(map.get("embeddedObj")).isEqualTo(embeddedObj);
+ assertThat(((DetachedDocument) map.get("embeddedObj")).getBoolean("embeddedObj")).isTrue();
+ assertThat(map.get("embeddedList")).isEqualTo(embeddedList);
+ assertThat(((List) map.get("embeddedList")).get(0).getBoolean("embeddedList")).isTrue();
+ assertThat(map.get("embeddedMap")).isEqualTo(embeddedMap);
+ assertThat(((Map) map.get("embeddedMap")).get("first").getBoolean("embeddedMap")).isTrue();
- Assertions.assertEquals("Tim", detached.toJSON().get("name"));
+ assertThat(detached.toJSON().get("name")).isEqualTo("Tim");
detached.toString();
try {
detached.modify();
- Assertions.fail("modify");
+ fail("modify");
} catch (final UnsupportedOperationException e) {
}
@@ -106,12 +110,12 @@ public void testDetached() {
try {
detached.setBuffer(null);
- Assertions.fail("setBuffer");
+ fail("setBuffer");
} catch (final UnsupportedOperationException e) {
}
- Assertions.assertNull(detached.getString("name"));
- Assertions.assertNull(detached.getString("lastname"));
+ assertThat(detached.getString("name")).isNull();
+ assertThat(detached.getString("lastname")).isNull();
});
}
}
diff --git a/engine/src/test/java/com/arcadedb/GlobalConfigurationTest.java b/engine/src/test/java/com/arcadedb/GlobalConfigurationTest.java
index 2010eba7da..3be4f0fda0 100644
--- a/engine/src/test/java/com/arcadedb/GlobalConfigurationTest.java
+++ b/engine/src/test/java/com/arcadedb/GlobalConfigurationTest.java
@@ -18,26 +18,28 @@
*/
package com.arcadedb;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
public class GlobalConfigurationTest extends TestHelper {
@Test
public void testServerMode() {
final String original = GlobalConfiguration.SERVER_MODE.getValueAsString();
GlobalConfiguration.SERVER_MODE.setValue("development");
- Assertions.assertEquals("development", GlobalConfiguration.SERVER_MODE.getValueAsString());
+ assertThat(GlobalConfiguration.SERVER_MODE.getValueAsString()).isEqualTo("development");
GlobalConfiguration.SERVER_MODE.setValue("test");
- Assertions.assertEquals("test", GlobalConfiguration.SERVER_MODE.getValueAsString());
+ assertThat(GlobalConfiguration.SERVER_MODE.getValueAsString()).isEqualTo("test");
GlobalConfiguration.SERVER_MODE.setValue("production");
- Assertions.assertEquals("production", GlobalConfiguration.SERVER_MODE.getValueAsString());
+ assertThat(GlobalConfiguration.SERVER_MODE.getValueAsString()).isEqualTo("production");
try {
GlobalConfiguration.SERVER_MODE.setValue("notvalid");
- Assertions.fail();
+ fail("");
} catch (final IllegalArgumentException e) {
// EXPECTED
}
@@ -51,7 +53,7 @@ public void testTypeConversion() {
try {
GlobalConfiguration.INITIAL_PAGE_CACHE_SIZE.setValue("notvalid");
- Assertions.fail();
+ fail("");
} catch (final NumberFormatException e) {
// EXPECTED
}
@@ -64,10 +66,10 @@ public void testDefaultValue() {
GlobalConfiguration.INITIAL_PAGE_CACHE_SIZE.reset();
final int original = GlobalConfiguration.INITIAL_PAGE_CACHE_SIZE.getValueAsInteger();
- Assertions.assertEquals(original, GlobalConfiguration.INITIAL_PAGE_CACHE_SIZE.getDefValue());
- Assertions.assertFalse(GlobalConfiguration.INITIAL_PAGE_CACHE_SIZE.isChanged());
+ assertThat(GlobalConfiguration.INITIAL_PAGE_CACHE_SIZE.getDefValue()).isEqualTo(original);
+ assertThat(GlobalConfiguration.INITIAL_PAGE_CACHE_SIZE.isChanged()).isFalse();
GlobalConfiguration.INITIAL_PAGE_CACHE_SIZE.setValue(0);
- Assertions.assertTrue(GlobalConfiguration.INITIAL_PAGE_CACHE_SIZE.isChanged());
+ assertThat(GlobalConfiguration.INITIAL_PAGE_CACHE_SIZE.isChanged()).isTrue();
GlobalConfiguration.INITIAL_PAGE_CACHE_SIZE.setValue(original);
}
diff --git a/engine/src/test/java/com/arcadedb/LargeRecordsTest.java b/engine/src/test/java/com/arcadedb/LargeRecordsTest.java
index af939d771d..761043b2d5 100644
--- a/engine/src/test/java/com/arcadedb/LargeRecordsTest.java
+++ b/engine/src/test/java/com/arcadedb/LargeRecordsTest.java
@@ -21,11 +21,14 @@
import com.arcadedb.database.MutableDocument;
import com.arcadedb.engine.LocalBucket;
import com.arcadedb.schema.DocumentType;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.concurrent.atomic.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
/**
* Populate the database with records 3X the page size of buckets.
*/
@@ -47,14 +50,14 @@ public void testScan() {
final long pageOverSize = ((LocalBucket) type.getBuckets(true).get(0)).getPageSize() * 3;
database.scanType("BigRecords", true, record -> {
- Assertions.assertNotNull(record);
+ assertThat(record).isNotNull();
final String buffer = record.asDocument().getString("buffer");
- Assertions.assertEquals(pageOverSize, buffer.length());
+ assertThat(buffer.length()).isEqualTo(pageOverSize);
total.incrementAndGet();
return true;
});
- Assertions.assertEquals(TOT, total.get());
+ assertThat(total.get()).isEqualTo(TOT);
database.commit();
}
diff --git a/engine/src/test/java/com/arcadedb/LoggerTest.java b/engine/src/test/java/com/arcadedb/LoggerTest.java
index e00c786249..4663a320c5 100644
--- a/engine/src/test/java/com/arcadedb/LoggerTest.java
+++ b/engine/src/test/java/com/arcadedb/LoggerTest.java
@@ -21,11 +21,12 @@
import com.arcadedb.log.DefaultLogger;
import com.arcadedb.log.LogManager;
import com.arcadedb.log.Logger;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.logging.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class LoggerTest extends TestHelper {
private boolean logged = false;
private boolean flushed = false;
@@ -54,11 +55,11 @@ public void flush() {
LogManager.instance().log(this, Level.FINE, "This is a test");
- Assertions.assertEquals(true, logged);
+ assertThat(logged).isTrue();
LogManager.instance().flush();
- Assertions.assertEquals(true, flushed);
+ assertThat(flushed).isTrue();
} finally {
LogManager.instance().setLogger(new DefaultLogger());
}
diff --git a/engine/src/test/java/com/arcadedb/MVCCTest.java b/engine/src/test/java/com/arcadedb/MVCCTest.java
index 082a8eec74..b6efef8e11 100644
--- a/engine/src/test/java/com/arcadedb/MVCCTest.java
+++ b/engine/src/test/java/com/arcadedb/MVCCTest.java
@@ -32,7 +32,8 @@
import com.arcadedb.schema.EdgeType;
import com.arcadedb.schema.Schema;
import com.arcadedb.schema.VertexType;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import java.math.*;
@@ -40,6 +41,9 @@
import java.util.concurrent.atomic.*;
import java.util.logging.*;
+import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class MVCCTest extends TestHelper {
private static final int CYCLES = 3;
private static final int TOT_ACCOUNT = 10000;
@@ -77,8 +81,8 @@ public void testMVCC() {
database.async().transaction(() -> {
final TransactionContext tx = ((DatabaseInternal) database).getTransaction();
- Assertions.assertTrue(tx.getModifiedPages() == 0);
- Assertions.assertNull(tx.getPageCounter(1));
+ assertThat(tx.getModifiedPages()).isEqualTo(0);
+ assertThat(tx.getPageCounter(1)).isNull();
final MutableDocument doc = database.newVertex("Transaction");
doc.set("uuid", UUID.randomUUID().toString());
@@ -88,7 +92,7 @@ public void testMVCC() {
final IndexCursor accounts = database.lookupByKey("Account", new String[] { "id" }, new Object[] { 0 });
- Assertions.assertTrue(accounts.hasNext());
+ assertThat(accounts.hasNext()).isTrue();
final Identifiable account = accounts.next();
@@ -101,9 +105,9 @@ public void testMVCC() {
} finally {
new DatabaseChecker(database).setVerboseLevel(0).check();
- Assertions.assertTrue(mvccErrors.get() > 0);
- Assertions.assertEquals(0, otherErrors.get());
- Assertions.assertEquals(0, txErrors.get());
+ assertThat(mvccErrors.get() > 0).isTrue();
+ assertThat(otherErrors.get()).isEqualTo(0);
+ assertThat(txErrors.get()).isEqualTo(0);
database.drop();
database = factory.create();
@@ -138,14 +142,14 @@ public void testNoConflictOnUpdateTx() {
final long finalAccountId = accountId;
final IndexCursor accounts = database.lookupByKey("Account", new String[] { "id" }, new Object[] { finalAccountId });
- Assertions.assertTrue(accounts.hasNext());
+ assertThat(accounts.hasNext()).isTrue();
final Vertex account = accounts.next().asVertex();
final int slot = ((DatabaseAsyncExecutorImpl) database.async()).getSlot(account.getIdentity().getBucketId());
database.async().transaction(() -> {
final TransactionContext tx = ((DatabaseInternal) database).getTransaction();
- Assertions.assertTrue(tx.getModifiedPages() == 0);
+ assertThat(tx.getModifiedPages()).isEqualTo(0);
account.modify().set("updated", true).save();
}, 0, null, null, slot);
@@ -153,14 +157,13 @@ public void testNoConflictOnUpdateTx() {
database.async().waitCompletion();
- Assertions.assertEquals(TOT_ACCOUNT,
- (long) database.query("sql", "select count(*) as count from Account where updated = true").nextIfAvailable().getProperty("count"));
+ assertThat((long) database.query("sql", "select count(*) as count from Account where updated = true").nextIfAvailable().getProperty("count")).isEqualTo(TOT_ACCOUNT);
} finally {
new DatabaseChecker(database).setVerboseLevel(0).check();
- Assertions.assertEquals(0, mvccErrors.get());
- Assertions.assertEquals(0, otherErrors.get());
+ assertThat(mvccErrors.get()).isEqualTo(0);
+ assertThat(otherErrors.get()).isEqualTo(0);
database.drop();
database = factory.create();
diff --git a/engine/src/test/java/com/arcadedb/MultipleDatabasesTest.java b/engine/src/test/java/com/arcadedb/MultipleDatabasesTest.java
index 07b9d20bde..3572a4ddc9 100644
--- a/engine/src/test/java/com/arcadedb/MultipleDatabasesTest.java
+++ b/engine/src/test/java/com/arcadedb/MultipleDatabasesTest.java
@@ -24,13 +24,20 @@
import com.arcadedb.exception.DatabaseOperationException;
import com.arcadedb.graph.MutableVertex;
import com.arcadedb.utility.FileUtils;
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
-import java.io.*;
-import java.util.*;
+import java.io.File;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
public class MultipleDatabasesTest extends TestHelper {
@Test
@@ -51,7 +58,7 @@ public void testMovingRecordsAcrossDatabases() {
final MutableVertex v = database.newVertex("V1").set("db", 1).save();
try {
v.newEmbeddedDocument("V1", "embedded").set("db", 1).set("embedded", true).save();
- Assertions.fail();
+ fail();
} catch (final IllegalArgumentException e) {
// EXPECTED
}
@@ -83,17 +90,17 @@ public void testMovingRecordsAcrossDatabases() {
});
// CHECK PRESENCE OF RECORDS IN EACH DATABASE
- Assertions.assertEquals(1, database.iterateType("V1", true).next().asVertex().get("db"));
- Assertions.assertEquals(1, database.iterateType("V1", true).next().asVertex().getEmbedded("embedded").get("db"));
- Assertions.assertEquals(2, database2.iterateType("V1", true).next().asVertex().get("db"));
- Assertions.assertEquals(2, database2.iterateType("V1", true).next().asVertex().getEmbedded("embedded").get("db"));
- Assertions.assertEquals(3, database3.iterateType("V1", true).next().asVertex().get("db"));
- Assertions.assertEquals(3, database3.iterateType("V1", true).next().asVertex().getEmbedded("embedded").get("db"));
+ assertThat(database.iterateType("V1", true).next().asVertex().get("db")).isEqualTo(1);
+ assertThat(database.iterateType("V1", true).next().asVertex().getEmbedded("embedded").get("db")).isEqualTo(1);
+ assertThat(database2.iterateType("V1", true).next().asVertex().get("db")).isEqualTo(2);
+ assertThat(database2.iterateType("V1", true).next().asVertex().getEmbedded("embedded").get("db")).isEqualTo(2);
+ assertThat(database3.iterateType("V1", true).next().asVertex().get("db")).isEqualTo(3);
+ assertThat(database3.iterateType("V1", true).next().asVertex().getEmbedded("embedded").get("db")).isEqualTo(3);
// CHECK COPIED RECORDS TOO
- Assertions.assertEquals(1, database3.iterateType("V1", true).next().asVertex().getEmbedded("embedded1").get("db"));
- Assertions.assertEquals(2, ((List) database3.iterateType("V1", true).next().asVertex().get("list2")).get(0).get("db"));
- Assertions.assertEquals(2, ((Map) database3.iterateType("V1", true).next().asVertex().get("map2")).get("copied2").get("db"));
+ assertThat(database3.iterateType("V1", true).next().asVertex().getEmbedded("embedded1").get("db")).isEqualTo(1);
+ assertThat(((List) database3.iterateType("V1", true).next().asVertex().get("list2")).get(0).get("db")).isEqualTo(2);
+ assertThat(((Map) database3.iterateType("V1", true).next().asVertex().get("map2")).get("copied2").get("db")).isEqualTo(2);
database.close();
database2.close();
@@ -106,7 +113,7 @@ public void testMovingRecordsAcrossDatabases() {
public void testErrorMultipleDatabaseInstancesSamePath() {
try {
new DatabaseFactory(getDatabasePath()).open();
- Assertions.fail();
+ fail("");
} catch (final DatabaseOperationException e) {
// EXPECTED
}
diff --git a/engine/src/test/java/com/arcadedb/PageManagerStressTest.java b/engine/src/test/java/com/arcadedb/PageManagerStressTest.java
index 4c6b4ec28a..53cfc75662 100644
--- a/engine/src/test/java/com/arcadedb/PageManagerStressTest.java
+++ b/engine/src/test/java/com/arcadedb/PageManagerStressTest.java
@@ -26,12 +26,13 @@
import com.arcadedb.engine.WALFile;
import com.arcadedb.schema.DocumentType;
import com.arcadedb.schema.Schema;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import performance.PerformanceTest;
import java.util.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class PageManagerStressTest {
private static final int TOT = 1_000_000;
private static final String TYPE_NAME = "Device";
@@ -100,8 +101,8 @@ public void stressPageManagerFlush() {
}
final PageManager.PPageManagerStats stats = ((DatabaseInternal) database).getPageManager().getStats();
- Assertions.assertTrue(stats.evictionRuns > 0);
- Assertions.assertTrue(stats.pagesEvicted > 0);
+ assertThat(stats.evictionRuns > 0).isTrue();
+ assertThat(stats.pagesEvicted > 0).isTrue();
} finally {
database.close();
diff --git a/engine/src/test/java/com/arcadedb/PolymorphicTest.java b/engine/src/test/java/com/arcadedb/PolymorphicTest.java
index e853405a6f..13a171e4c5 100644
--- a/engine/src/test/java/com/arcadedb/PolymorphicTest.java
+++ b/engine/src/test/java/com/arcadedb/PolymorphicTest.java
@@ -23,10 +23,15 @@
import com.arcadedb.exception.ValidationException;
import com.arcadedb.graph.MutableVertex;
import com.arcadedb.schema.VertexType;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
-import java.util.concurrent.atomic.*;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
public class PolymorphicTest extends TestHelper {
@@ -45,26 +50,26 @@ protected void beginTest() {
try {
motorcycle.createProperty("brand", String.class);
- Assertions.fail("Expected to fail by creating the same property name as the parent type");
+ fail("Expected to fail by creating the same property name as the parent type");
} catch (final SchemaException e) {
}
- Assertions.assertTrue(database.getSchema().getType("Motorcycle").instanceOf("Vehicle"));
+ assertThat(database.getSchema().getType("Motorcycle").instanceOf("Vehicle")).isTrue();
database.getSchema().buildVertexType().withName("Car").withTotalBuckets(3).create().addSuperType("Vehicle");
- Assertions.assertTrue(database.getSchema().getType("Car").instanceOf("Vehicle"));
+ assertThat(database.getSchema().getType("Car").instanceOf("Vehicle")).isTrue();
database.getSchema().buildVertexType().withName("Supercar").withTotalBuckets(3).create().addSuperType("Car");
- Assertions.assertTrue(database.getSchema().getType("Supercar").instanceOf("Car"));
- Assertions.assertTrue(database.getSchema().getType("Supercar").instanceOf("Vehicle"));
+ assertThat(database.getSchema().getType("Supercar").instanceOf("Car")).isTrue();
+ assertThat(database.getSchema().getType("Supercar").instanceOf("Vehicle")).isTrue();
//------------
// PEOPLE VERTICES
//------------
final VertexType person = database.getSchema().createVertexType("Person");
database.getSchema().createVertexType("Client").addSuperType(person);
- Assertions.assertTrue(database.getSchema().getType("Client").instanceOf("Person"));
- Assertions.assertFalse(database.getSchema().getType("Client").instanceOf("Vehicle"));
+ assertThat(database.getSchema().getType("Client").instanceOf("Person")).isTrue();
+ assertThat(database.getSchema().getType("Client").instanceOf("Vehicle")).isFalse();
//------------
// EDGES
@@ -72,8 +77,8 @@ protected void beginTest() {
database.getSchema().createEdgeType("Drives");
database.getSchema().createEdgeType("Owns").addSuperType("Drives");
- Assertions.assertTrue(database.getSchema().getType("Owns").instanceOf("Drives"));
- Assertions.assertFalse(database.getSchema().getType("Owns").instanceOf("Vehicle"));
+ assertThat(database.getSchema().getType("Owns").instanceOf("Drives")).isTrue();
+ assertThat(database.getSchema().getType("Owns").instanceOf("Vehicle")).isFalse();
});
final Database db = database;
@@ -114,35 +119,33 @@ public void count() throws Exception {
database.begin();
try {
// NON POLYMORPHIC COUNTING
- Assertions.assertEquals(0, database.countType("Vehicle", false));
- Assertions.assertEquals(1, database.countType("Car", false));
- Assertions.assertEquals(1, database.countType("Supercar", false));
- Assertions.assertEquals(1, database.countType("Motorcycle", false));
+ assertThat(database.countType("Vehicle", false)).isEqualTo(0);
+ assertThat(database.countType("Car", false)).isEqualTo(1);
+ assertThat(database.countType("Supercar", false)).isEqualTo(1);
+ assertThat(database.countType("Motorcycle", false)).isEqualTo(1);
- Assertions.assertEquals(0, database.countType("Person", false));
- Assertions.assertEquals(1, database.countType("Client", false));
+ assertThat(database.countType("Person", false)).isEqualTo(0);
+ assertThat(database.countType("Client", false)).isEqualTo(1);
- Assertions.assertEquals(1, database.countType("Drives", false));
- Assertions.assertEquals(2, database.countType("Owns", false));
+ assertThat(database.countType("Drives", false)).isEqualTo(1);
+ assertThat(database.countType("Owns", false)).isEqualTo(2);
// POLYMORPHIC COUNTING
- Assertions.assertEquals(3, database.countType("Vehicle", true));
- Assertions.assertEquals(2, database.countType("Car", true));
- Assertions.assertEquals(1, database.countType("Supercar", true));
- Assertions.assertEquals(1, database.countType("Motorcycle", true));
+ assertThat(database.countType("Vehicle", true)).isEqualTo(3);
+ assertThat(database.countType("Car", true)).isEqualTo(2);
+ assertThat(database.countType("Supercar", true)).isEqualTo(1);
+ assertThat(database.countType("Motorcycle", true)).isEqualTo(1);
- Assertions.assertEquals(1, database.countType("Person", true));
- Assertions.assertEquals(1, database.countType("Client", true));
+ assertThat(database.countType("Person", true)).isEqualTo(1);
+ assertThat(database.countType("Client", true)).isEqualTo(1);
- Assertions.assertEquals(3, database.countType("Drives", true));
- Assertions.assertEquals(2, database.countType("Owns", true));
+ assertThat(database.countType("Drives", true)).isEqualTo(3);
+ assertThat(database.countType("Owns", true)).isEqualTo(2);
- Assertions.assertEquals(3L,
- (long) database.query("sql", "select count(*) as count from Vehicle").nextIfAvailable().getProperty("count"));
+ assertThat((long) database.query("sql", "select count(*) as count from Vehicle").nextIfAvailable().getProperty("count")).isEqualTo(3L);
- Assertions.assertEquals(3L,
- (long) database.query("sql", "select count(*) as count from Vehicle WHERE $this INSTANCEOF Vehicle").nextIfAvailable()
- .getProperty("count"));
+ assertThat((long) database.query("sql", "select count(*) as count from Vehicle WHERE $this INSTANCEOF Vehicle").nextIfAvailable()
+ .getProperty("count")).isEqualTo(3L);
} finally {
database.commit();
@@ -153,28 +156,28 @@ public void count() throws Exception {
public void scan() {
database.begin();
try {
- Assertions.assertEquals(0, scanAndCountType(database, "Vehicle", false));
- Assertions.assertEquals(1, scanAndCountType(database, "Car", false));
- Assertions.assertEquals(1, scanAndCountType(database, "Supercar", false));
- Assertions.assertEquals(1, scanAndCountType(database, "Motorcycle", false));
+ assertThat(scanAndCountType(database, "Vehicle", false)).isEqualTo(0);
+ assertThat(scanAndCountType(database, "Car", false)).isEqualTo(1);
+ assertThat(scanAndCountType(database, "Supercar", false)).isEqualTo(1);
+ assertThat(scanAndCountType(database, "Motorcycle", false)).isEqualTo(1);
- Assertions.assertEquals(0, scanAndCountType(database, "Person", false));
- Assertions.assertEquals(1, scanAndCountType(database, "Client", false));
+ assertThat(scanAndCountType(database, "Person", false)).isEqualTo(0);
+ assertThat(scanAndCountType(database, "Client", false)).isEqualTo(1);
- Assertions.assertEquals(1, scanAndCountType(database, "Drives", false));
- Assertions.assertEquals(2, scanAndCountType(database, "Owns", false));
+ assertThat(scanAndCountType(database, "Drives", false)).isEqualTo(1);
+ assertThat(scanAndCountType(database, "Owns", false)).isEqualTo(2);
// POLYMORPHIC COUNTING
- Assertions.assertEquals(3, scanAndCountType(database, "Vehicle", true));
- Assertions.assertEquals(2, scanAndCountType(database, "Car", true));
- Assertions.assertEquals(1, scanAndCountType(database, "Supercar", true));
- Assertions.assertEquals(1, scanAndCountType(database, "Motorcycle", true));
+ assertThat(scanAndCountType(database, "Vehicle", true)).isEqualTo(3);
+ assertThat(scanAndCountType(database, "Car", true)).isEqualTo(2);
+ assertThat(scanAndCountType(database, "Supercar", true)).isEqualTo(1);
+ assertThat(scanAndCountType(database, "Motorcycle", true)).isEqualTo(1);
- Assertions.assertEquals(1, scanAndCountType(database, "Person", true));
- Assertions.assertEquals(1, scanAndCountType(database, "Client", true));
+ assertThat(scanAndCountType(database, "Person", true)).isEqualTo(1);
+ assertThat(scanAndCountType(database, "Client", true)).isEqualTo(1);
- Assertions.assertEquals(3, scanAndCountType(database, "Drives", true));
- Assertions.assertEquals(2, scanAndCountType(database, "Owns", true));
+ assertThat(scanAndCountType(database, "Drives", true)).isEqualTo(3);
+ assertThat(scanAndCountType(database, "Owns", true)).isEqualTo(2);
} finally {
database.commit();
@@ -192,7 +195,7 @@ public void testConstraintsInInheritance() {
try {
database.command("sql",
"INSERT INTO V1 SET prop2 = 'test'"); // this throws the exception as expected since I didn't set the mandatory prop1
- Assertions.fail();
+ fail("");
} catch (ValidationException e) {
// EXPECTED
}
@@ -200,7 +203,7 @@ public void testConstraintsInInheritance() {
try {
database.command("sql",
"INSERT INTO V2 SET prop2 = 'test'"); // this ignores the constraint on prop1 and insert the record although I didn't set the value
- Assertions.fail();
+ fail("");
} catch (ValidationException e) {
// EXPECTED
}
@@ -211,14 +214,14 @@ public void testConstraintsInInheritance() {
*/
@Test
public void testBrokenInheritanceAfterTypeDropLast() {
- Assertions.assertEquals(3, database.countType("Vehicle", true));
+ assertThat(database.countType("Vehicle", true)).isEqualTo(3);
database.transaction(() -> {
database.command("sql", "DELETE FROM Supercar");
database.getSchema().dropType("Supercar");
});
- Assertions.assertEquals(2, database.countType("Vehicle", true));
- Assertions.assertEquals(1, database.countType("Car", true));
- Assertions.assertEquals(1, database.countType("Motorcycle", true));
+ assertThat(database.countType("Vehicle", true)).isEqualTo(2);
+ assertThat(database.countType("Car", true)).isEqualTo(1);
+ assertThat(database.countType("Motorcycle", true)).isEqualTo(1);
}
/**
@@ -226,13 +229,13 @@ public void testBrokenInheritanceAfterTypeDropLast() {
*/
@Test
public void testBrokenInheritanceAfterTypeDropMiddle() {
- Assertions.assertEquals(3, database.countType("Vehicle", true));
+ assertThat(database.countType("Vehicle", true)).isEqualTo(3);
database.transaction(() -> {
database.command("sql", "DELETE FROM Car");
database.getSchema().dropType("Car");
});
- Assertions.assertEquals(1, database.countType("Vehicle", true));
- Assertions.assertEquals(1, database.countType("Motorcycle", true));
+ assertThat(database.countType("Vehicle", true)).isEqualTo(1);
+ assertThat(database.countType("Motorcycle", true)).isEqualTo(1);
}
/**
@@ -240,20 +243,20 @@ public void testBrokenInheritanceAfterTypeDropMiddle() {
*/
@Test
public void testBrokenInheritanceAfterTypeDropFirst() {
- Assertions.assertEquals(3, database.countType("Vehicle", true));
+ assertThat(database.countType("Vehicle", true)).isEqualTo(3);
database.transaction(() -> {
database.getSchema().dropType("Vehicle");
});
- Assertions.assertEquals(2, database.countType("Car", true));
- Assertions.assertEquals(1, database.countType("Supercar", true));
- Assertions.assertEquals(1, database.countType("Motorcycle", true));
+ assertThat(database.countType("Car", true)).isEqualTo(2);
+ assertThat(database.countType("Supercar", true)).isEqualTo(1);
+ assertThat(database.countType("Motorcycle", true)).isEqualTo(1);
}
private int scanAndCountType(final Database db, final String type, final boolean polymorphic) {
// NON POLYMORPHIC COUNTING
final AtomicInteger counter = new AtomicInteger();
db.scanType(type, polymorphic, record -> {
- Assertions.assertTrue(db.getSchema().getType(record.getTypeName()).instanceOf(type));
+ assertThat(db.getSchema().getType(record.getTypeName()).instanceOf(type)).isTrue();
counter.incrementAndGet();
return true;
});
diff --git a/engine/src/test/java/com/arcadedb/ProfilerTest.java b/engine/src/test/java/com/arcadedb/ProfilerTest.java
index 33b1640301..baa54c42f4 100644
--- a/engine/src/test/java/com/arcadedb/ProfilerTest.java
+++ b/engine/src/test/java/com/arcadedb/ProfilerTest.java
@@ -19,26 +19,27 @@
package com.arcadedb;
import com.arcadedb.serializer.json.JSONObject;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.io.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class ProfilerTest {
@Test
public void testDumpProfileMetrics() {
final ByteArrayOutputStream out = new ByteArrayOutputStream();
Profiler.INSTANCE.dumpMetrics(new PrintStream(out));
- Assertions.assertTrue(out.size() > 0);
+ assertThat(out.size() > 0).isTrue();
}
@Test
public void testMetricsToJSON() {
JSONObject json = Profiler.INSTANCE.toJSON();
- Assertions.assertTrue(json.has("diskFreeSpace"));
- Assertions.assertTrue(json.has("diskTotalSpace"));
- Assertions.assertTrue(json.has("updateRecord"));
- Assertions.assertTrue(json.has("totalDatabases"));
+ assertThat(json.has("diskFreeSpace")).isTrue();
+ assertThat(json.has("diskTotalSpace")).isTrue();
+ assertThat(json.has("updateRecord")).isTrue();
+ assertThat(json.has("totalDatabases")).isTrue();
}
}
diff --git a/engine/src/test/java/com/arcadedb/RandomTestMultiThreadsTest.java b/engine/src/test/java/com/arcadedb/RandomTestMultiThreadsTest.java
index 3ddaa8ba73..aa6e8bdf35 100644
--- a/engine/src/test/java/com/arcadedb/RandomTestMultiThreadsTest.java
+++ b/engine/src/test/java/com/arcadedb/RandomTestMultiThreadsTest.java
@@ -32,7 +32,6 @@
import com.arcadedb.schema.Schema;
import com.arcadedb.schema.VertexType;
import com.arcadedb.utility.Pair;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.math.*;
@@ -40,6 +39,8 @@
import java.util.concurrent.atomic.*;
import java.util.logging.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class RandomTestMultiThreadsTest extends TestHelper {
private static final int CYCLES = 10000;
private static final int STARTING_ACCOUNT = 10000;
@@ -106,7 +107,7 @@ public void run() {
while (result.hasNext()) {
final Result record = result.next();
record.toJSON();
- Assertions.assertEquals(randomId, (Long) record.getProperty("id"));
+ assertThat((Long) record.getProperty("id")).isEqualTo(randomId);
}
} else if (op >= 40 && op <= 59) {
@@ -123,7 +124,7 @@ public void run() {
if (randomUUID != (Long) record.getProperty("uuid")) {
System.out.printf("Looking for %d but found %d%n", randomUUID, (Long) record.getProperty("uuid"));
}
- Assertions.assertEquals(randomUUID, (Long) record.getProperty("uuid"));
+ assertThat((Long) record.getProperty("uuid")).isEqualTo(randomUUID);
}
} else if (op >= 60 && op <= 64) {
LogManager.instance().log(this, Level.FINE, "Scanning Account records (thread=%d)...", threadId);
diff --git a/engine/src/test/java/com/arcadedb/ReusingSpaceTest.java b/engine/src/test/java/com/arcadedb/ReusingSpaceTest.java
index 73633d75f7..fa108e1479 100644
--- a/engine/src/test/java/com/arcadedb/ReusingSpaceTest.java
+++ b/engine/src/test/java/com/arcadedb/ReusingSpaceTest.java
@@ -21,9 +21,10 @@
import com.arcadedb.database.Database;
import com.arcadedb.engine.DatabaseChecker;
import com.arcadedb.graph.MutableVertex;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class ReusingSpaceTest extends TestHelper {
@Test
public void testAddAndDeleteLatest() {
@@ -35,7 +36,7 @@ public void testAddAndDeleteLatest() {
db.getSchema().dropType("CreateAndDelete");
db.getSchema().getOrCreateVertexType("CreateAndDelete", 1);
}
- Assertions.assertEquals(0, db.countType("CreateAndDelete", true));
+ assertThat(db.countType("CreateAndDelete", true)).isEqualTo(0);
for (int i = 0; i < 3000; i++) {
final MutableVertex[] v = new MutableVertex[1];
@@ -53,7 +54,7 @@ public void testAddAndDeleteLatest() {
});
}
- Assertions.assertEquals(0, db.countType("CreateAndDelete", true));
+ assertThat(db.countType("CreateAndDelete", true)).isEqualTo(0);
} finally {
new DatabaseChecker(database).setVerboseLevel(0).check();
diff --git a/engine/src/test/java/com/arcadedb/TestHelper.java b/engine/src/test/java/com/arcadedb/TestHelper.java
index ab7f774bae..1ccda4d57d 100644
--- a/engine/src/test/java/com/arcadedb/TestHelper.java
+++ b/engine/src/test/java/com/arcadedb/TestHelper.java
@@ -30,13 +30,16 @@
import com.arcadedb.utility.FileUtils;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.BeforeEach;
import java.io.*;
import java.util.*;
import java.util.logging.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
public abstract class TestHelper {
protected static final int PARALLEL_LEVEL = 4;
protected final DatabaseFactory factory;
@@ -60,7 +63,7 @@ protected TestHelper(final boolean cleanBeforeTest) {
FileUtils.deleteRecursively(new File(getDatabasePath()));
factory = new DatabaseFactory(getDatabasePath());
database = factory.exists() ? factory.open() : factory.create();
- Assertions.assertEquals(database, DatabaseFactory.getActiveDatabaseInstance(database.getDatabasePath()));
+ assertThat(DatabaseFactory.getActiveDatabaseInstance(database.getDatabasePath())).isEqualTo(database);
if (autoStartTx)
database.begin();
@@ -74,11 +77,11 @@ public static void executeInNewDatabase(final DatabaseTest callback) t
try (final DatabaseFactory factory = new DatabaseFactory("./target/databases/" + UUID.randomUUID())) {
if (factory.exists()) {
factory.open().drop();
- Assertions.assertNull(DatabaseFactory.getActiveDatabaseInstance(factory.getDatabasePath()));
+ assertThat(DatabaseFactory.getActiveDatabaseInstance(factory.getDatabasePath())).isNull();
}
final Database database = factory.create();
- Assertions.assertEquals(database, DatabaseFactory.getActiveDatabaseInstance(factory.getDatabasePath()));
+ assertThat(DatabaseFactory.getActiveDatabaseInstance(factory.getDatabasePath())).isEqualTo(database);
try {
database.begin();
callback.call(database);
@@ -101,12 +104,12 @@ public static void executeInNewDatabase(final String testName, final DatabaseTes
factory.open().drop();
final DatabaseInternal database = (DatabaseInternal) factory.create();
- Assertions.assertEquals(database, DatabaseFactory.getActiveDatabaseInstance(factory.getDatabasePath()));
+ assertThat(DatabaseFactory.getActiveDatabaseInstance(factory.getDatabasePath())).isEqualTo(database);
try {
callback.call(database);
} finally {
database.drop();
- Assertions.assertNull(DatabaseFactory.getActiveDatabaseInstance(database.getDatabasePath()));
+ assertThat(DatabaseFactory.getActiveDatabaseInstance(database.getDatabasePath())).isNull();
}
}
}
@@ -119,27 +122,27 @@ public static DatabaseFactory dropDatabase(final String databaseName) {
final DatabaseFactory factory = new DatabaseFactory(databaseName);
if (factory.exists())
factory.open().drop();
- Assertions.assertNull(DatabaseFactory.getActiveDatabaseInstance(factory.getDatabasePath()));
+ assertThat(DatabaseFactory.getActiveDatabaseInstance(factory.getDatabasePath())).isNull();
return factory;
}
protected void reopenDatabase() {
if (database != null) {
database.close();
- Assertions.assertNull(DatabaseFactory.getActiveDatabaseInstance(database.getDatabasePath()));
+ assertThat(DatabaseFactory.getActiveDatabaseInstance(database.getDatabasePath())).isNull();
}
database = factory.open();
- Assertions.assertEquals(database, DatabaseFactory.getActiveDatabaseInstance(database.getDatabasePath()));
+ assertThat(DatabaseFactory.getActiveDatabaseInstance(database.getDatabasePath())).isEqualTo(database);
}
protected void reopenDatabaseInReadOnlyMode() {
if (database != null) {
database.close();
- Assertions.assertNull(DatabaseFactory.getActiveDatabaseInstance(database.getDatabasePath()));
+ assertThat(DatabaseFactory.getActiveDatabaseInstance(database.getDatabasePath())).isNull();
}
database = factory.open(ComponentFile.MODE.READ_ONLY);
- Assertions.assertEquals(database, DatabaseFactory.getActiveDatabaseInstance(database.getDatabasePath()));
+ assertThat(DatabaseFactory.getActiveDatabaseInstance(database.getDatabasePath())).isEqualTo(database);
}
protected String getDatabasePath() {
@@ -196,7 +199,7 @@ public static void expectException(final CallableNoReturn callback, final Class<
throws Exception {
try {
callback.call();
- Assertions.fail();
+ fail("");
} catch (final Throwable e) {
if (e.getClass().equals(expectedException))
// EXPECTED
@@ -214,11 +217,11 @@ protected void checkDatabaseIntegrity() {
while (result.hasNext()) {
final Result row = result.next();
- Assertions.assertEquals("check database", row.getProperty("operation"));
- Assertions.assertEquals(0, (Long) row.getProperty("autoFix"));
- Assertions.assertEquals(0, ((Collection) row.getProperty("corruptedRecords")).size());
- Assertions.assertEquals(0, (Long) row.getProperty("invalidLinks"));
- Assertions.assertEquals(0, ((Collection) row.getProperty("warnings")).size(), "Warnings" + row.getProperty("warnings"));
+ assertThat(row.getProperty("operation")).isEqualTo("check database");
+ assertThat((Long) row.getProperty("autoFix")).isEqualTo(0);
+ assertThat(((Collection>) row.getProperty("corruptedRecords")).size()).isEqualTo(0);
+ assertThat((Long) row.getProperty("invalidLinks")).isEqualTo(0);
+ assertThat(((Collection>) row.getProperty("warnings")).size()).as("Warnings" + row.getProperty("warnings")).isEqualTo(0);
}
}
@@ -232,6 +235,6 @@ public static void checkActiveDatabases() {
for (final Database db : activeDatabases)
db.close();
- Assertions.assertTrue(activeDatabases.isEmpty(), "Found active databases: " + activeDatabases);
+ assertThat(activeDatabases.isEmpty()).as("Found active databases: " + activeDatabases).isTrue();
}
}
diff --git a/engine/src/test/java/com/arcadedb/TransactionBucketTest.java b/engine/src/test/java/com/arcadedb/TransactionBucketTest.java
index 9638661d32..4e5641b22e 100644
--- a/engine/src/test/java/com/arcadedb/TransactionBucketTest.java
+++ b/engine/src/test/java/com/arcadedb/TransactionBucketTest.java
@@ -26,12 +26,18 @@
import com.arcadedb.graph.MutableEdge;
import com.arcadedb.graph.MutableVertex;
import com.arcadedb.query.sql.executor.ResultSet;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.*;
import java.util.concurrent.atomic.*;
+import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.within;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThatExceptionOfType;
+
public class TransactionBucketTest extends TestHelper {
private static final int TOT = 10000;
@@ -49,21 +55,21 @@ public void testScan() {
database.begin();
database.scanBucket("V_0", record -> {
- Assertions.assertNotNull(record);
+ assertThat(record).isNotNull();
final Set prop = new HashSet();
prop.addAll(((Document) record).getPropertyNames());
- Assertions.assertEquals(3, ((Document) record).getPropertyNames().size(), 9);
- Assertions.assertTrue(prop.contains("id"));
- Assertions.assertTrue(prop.contains("name"));
- Assertions.assertTrue(prop.contains("surname"));
+ assertThat(((Document) record).getPropertyNames().size()).isCloseTo(3, within(9));
+ assertThat(prop.contains("id")).isTrue();
+ assertThat(prop.contains("name")).isTrue();
+ assertThat(prop.contains("surname")).isTrue();
total.incrementAndGet();
return true;
});
- Assertions.assertEquals(TOT, total.get());
+ assertThat(total.get()).isEqualTo(TOT);
database.commit();
}
@@ -78,21 +84,22 @@ public void testIterator() {
while (iterator.hasNext()) {
final Document record = (Document) iterator.next();
- Assertions.assertNotNull(record);
+ assertThat(record).isNotNull();
final Set prop = new HashSet();
prop.addAll(record.getPropertyNames());
- Assertions.assertEquals(3, record.getPropertyNames().size(), 9);
- Assertions.assertTrue(prop.contains("id"));
- Assertions.assertTrue(prop.contains("name"));
- Assertions.assertTrue(prop.contains("surname"));
+
+ assertThat(record.getPropertyNames().size()).isCloseTo(3, within(9));
+ assertThat(prop.contains("id")).isTrue();
+ assertThat(prop.contains("name")).isTrue();
+ assertThat(prop.contains("surname")).isTrue();
total.incrementAndGet();
}
- Assertions.assertEquals(TOT, total.get());
+ assertThat(total.get()).isEqualTo(TOT);
database.commit();
}
@@ -105,16 +112,16 @@ public void testLookupAllRecordsByRID() {
database.scanBucket("V_0", record -> {
final Document record2 = (Document) database.lookupByRID(record.getIdentity(), false);
- Assertions.assertNotNull(record2);
- Assertions.assertEquals(record, record2);
+ assertThat(record2).isNotNull();
+ assertThat(record2).isEqualTo(record);
final Set prop = new HashSet();
prop.addAll(record2.getPropertyNames());
- Assertions.assertEquals(record2.getPropertyNames().size(), 3);
- Assertions.assertTrue(prop.contains("id"));
- Assertions.assertTrue(prop.contains("name"));
- Assertions.assertTrue(prop.contains("surname"));
+ assertThat(record2.getPropertyNames()).hasSize(3);
+ assertThat(prop.contains("id")).isTrue();
+ assertThat(prop.contains("name")).isTrue();
+ assertThat(prop.contains("surname")).isTrue();
total.incrementAndGet();
return true;
@@ -122,7 +129,7 @@ public void testLookupAllRecordsByRID() {
database.commit();
- Assertions.assertEquals(TOT, total.get());
+ assertThat(total.get()).isEqualTo(TOT);
}
@Test
@@ -140,23 +147,23 @@ public void testDeleteAllRecordsReuseSpace() {
});
} finally {
- Assertions.assertEquals(0, database.countBucket("V_0"));
+ assertThat(database.countBucket("V_0")).isEqualTo(0);
}
database.commit();
- Assertions.assertEquals(TOT, total.get());
+ assertThat(total.get()).isEqualTo(TOT);
beginTest();
- database.transaction(() -> Assertions.assertEquals(TOT, database.countBucket("V_0")));
+ database.transaction(() -> assertThat(database.countBucket("V_0")).isEqualTo(TOT));
}
@Test
public void testDeleteFail() {
reopenDatabaseInReadOnlyMode();
- Assertions.assertThrows(DatabaseIsReadOnlyException.class, () -> {
+ assertThatExceptionOfType(DatabaseIsReadOnlyException.class).isThrownBy(() -> {
database.begin();
database.scanBucket("V_0", record -> {
@@ -186,8 +193,8 @@ public void testIteratorOnEdges() {
database.scanType("testIteratorOnEdges_Edge", true, record -> {
final Edge e1 = (Edge) record;
- Assertions.assertEquals(v1.getIdentity(), e1.getOut());
- Assertions.assertEquals(v2.getIdentity(), e1.getIn());
+ assertThat(e1.getOut()).isEqualTo(v1.getIdentity());
+ assertThat(e1.getIn()).isEqualTo(v2.getIdentity());
total.incrementAndGet();
return true;
@@ -195,7 +202,7 @@ public void testIteratorOnEdges() {
database.commit();
- Assertions.assertEquals(1, total.get());
+ assertThat(total.get()).isEqualTo(1);
}
@Test
@@ -211,15 +218,15 @@ public void testScanOnEdges() {
final ResultSet result = database.query("sql", "select from testIteratorOnEdges_Edge");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Record record = result.next().getRecord().get();
- Assertions.assertNotNull(record);
+ assertThat(record).isNotNull();
final Edge e2 = (Edge) record;
- Assertions.assertEquals(v1.getIdentity(), e2.getOut());
- Assertions.assertEquals(v2.getIdentity(), e2.getIn());
+ assertThat(e2.getOut()).isEqualTo(v1.getIdentity());
+ assertThat(e2.getIn()).isEqualTo(v2.getIdentity());
database.commit();
}
@@ -238,15 +245,15 @@ public void testScanOnEdgesAfterTx() {
database.transaction(() -> {
final ResultSet result = database.query("sql", "select from testIteratorOnEdges_Edge");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Record record = result.next().getRecord().get();
- Assertions.assertNotNull(record);
+ assertThat(record).isNotNull();
final Edge e2 = (Edge) record;
- Assertions.assertNotNull(e2.getOutVertex());
- Assertions.assertNotNull(e2.getInVertex());
+ assertThat(e2.getOutVertex()).isNotNull();
+ assertThat(e2.getInVertex()).isNotNull();
});
}
diff --git a/engine/src/test/java/com/arcadedb/TransactionIsolationTest.java b/engine/src/test/java/com/arcadedb/TransactionIsolationTest.java
index 3ed3249a88..56e02aea13 100644
--- a/engine/src/test/java/com/arcadedb/TransactionIsolationTest.java
+++ b/engine/src/test/java/com/arcadedb/TransactionIsolationTest.java
@@ -1,33 +1,15 @@
-/*
- * Copyright © 2021-present Arcade Data Ltd (info@arcadedata.com)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * SPDX-FileCopyrightText: 2021-present Arcade Data Ltd (info@arcadedata.com)
- * SPDX-License-Identifier: Apache-2.0
- */
package com.arcadedb;
import com.arcadedb.database.Database;
import com.arcadedb.graph.MutableVertex;
-import org.junit.jupiter.api.Assertions;
+import com.arcadedb.query.sql.executor.ResultSet;
import org.junit.jupiter.api.Test;
-import java.util.concurrent.*;
+import java.util.concurrent.CountDownLatch;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
-/**
- * Tests the isolation of transactions based on the configured settings.
- */
public class TransactionIsolationTest extends TestHelper {
@Override
protected void beginTest() {
@@ -46,23 +28,23 @@ public void testNoDirtyReads() throws InterruptedException {
final Thread thread1 = new Thread(() -> {
database.transaction(() -> {
try {
- Assertions.assertEquals(0, database.countType("Node", true));
+ assertThat(database.countType("Node", true)).isEqualTo(0);
final MutableVertex v = database.newVertex("Node");
v.set("id", 0);
v.set("origin", "thread1");
v.save();
- Assertions.assertEquals(1, database.countType("Node", true));
+ assertThat(database.countType("Node", true)).isEqualTo(1);
sem1.countDown();
sem2.await();
- Assertions.assertEquals(1, database.countType("Node", true));
+ assertThat(database.countType("Node", true)).isEqualTo(1);
} catch (InterruptedException e) {
- Assertions.fail();
+ fail("InterruptedException occurred");
throw new RuntimeException(e);
}
});
@@ -73,19 +55,19 @@ public void testNoDirtyReads() throws InterruptedException {
try {
sem1.await();
- Assertions.assertEquals(0, database.countType("Node", true));
+ assertThat(database.countType("Node", true)).isEqualTo(0);
final MutableVertex v = database.newVertex("Node");
v.set("id", 1);
v.set("origin", "thread2");
v.save();
- Assertions.assertEquals(1, database.countType("Node", true));
+ assertThat(database.countType("Node", true)).isEqualTo(1);
sem2.countDown();
} catch (InterruptedException e) {
- Assertions.fail();
+ fail("InterruptedException occurred");
throw new RuntimeException(e);
}
});
@@ -110,7 +92,7 @@ public void testReadCommitted() throws InterruptedException {
final Thread thread1 = new Thread(() -> {
database.transaction(() -> {
database.newVertex("Node").set("id", 0, "origin", "thread1").save();
- Assertions.assertEquals(1, database.countType("Node", true));
+ assertThat(database.countType("Node", true)).isEqualTo(1);
});
sem1.countDown();
@@ -119,17 +101,17 @@ public void testReadCommitted() throws InterruptedException {
try {
sem2.await();
// CHECK THE NEW RECORD (PHANTOM READ) IS VISIBLE
- Assertions.assertEquals(2, database.countType("Node", true));
+ assertThat(database.countType("Node", true)).isEqualTo(2);
database.newVertex("Node").set("id", 3, "origin", "thread1").save();
- Assertions.assertEquals(3, database.countType("Node", true));
+ assertThat(database.countType("Node", true)).isEqualTo(3);
// MODIFY A RECORD
database.query("sql", "select from Node where id = 0").nextIfAvailable().getRecord().get().asVertex().modify().set("modified", true).save();
} catch (InterruptedException e) {
- Assertions.fail();
+ fail("InterruptedException occurred");
throw new RuntimeException(e);
}
});
@@ -143,13 +125,13 @@ public void testReadCommitted() throws InterruptedException {
sem1.await();
// CHECK THE NEW RECORD (PHANTOM READ) IS VISIBLE
- Assertions.assertEquals(1, database.countType("Node", true));
+ assertThat(database.countType("Node", true)).isEqualTo(1);
database.newVertex("Node").set("id", 1, "origin", "thread2").save();
- Assertions.assertEquals(2, database.countType("Node", true));
+ assertThat(database.countType("Node", true)).isEqualTo(2);
} catch (InterruptedException e) {
- Assertions.fail();
+ fail("InterruptedException occurred");
throw new RuntimeException(e);
}
});
@@ -160,13 +142,13 @@ public void testReadCommitted() throws InterruptedException {
try {
sem3.await();
- Assertions.assertEquals(3, database.countType("Node", true));
+ assertThat(database.countType("Node", true)).isEqualTo(3);
// CHECK THE NEW RECORD WAS MODIFIED
- Assertions.assertTrue((Boolean) database.query("sql", "select from Node where id = 0").nextIfAvailable().getProperty("modified"));
+ assertThat((Boolean) database.query("sql", "select from Node where id = 0").nextIfAvailable().getProperty("modified")).isTrue();
} catch (InterruptedException e) {
- Assertions.fail();
+ fail("InterruptedException occurred");
throw new RuntimeException(e);
}
});
@@ -194,7 +176,7 @@ public void testRepeatableRead() throws InterruptedException {
final Thread thread1 = new Thread(() -> {
database.transaction(() -> {
database.newVertex("Node").set("id", 0, "origin", "thread1").save();
- Assertions.assertEquals(1, database.countType("Node", true));
+ assertThat(database.countType("Node", true)).isEqualTo(1);
});
sem1.countDown();
@@ -203,17 +185,17 @@ public void testRepeatableRead() throws InterruptedException {
try {
sem2.await();
// CHECK THE NEW RECORD (PHANTOM READ) IS VISIBLE
- Assertions.assertEquals(2, database.countType("Node", true));
+ assertThat(database.countType("Node", true)).isEqualTo(2);
database.newVertex("Node").set("id", 3, "origin", "thread1").save();
- Assertions.assertEquals(3, database.countType("Node", true));
+ assertThat(database.countType("Node", true)).isEqualTo(3);
// MODIFY A RECORD
database.query("sql", "select from Node where id = 0").nextIfAvailable().getRecord().get().asVertex().modify().set("modified", true).save();
} catch (InterruptedException e) {
- Assertions.fail();
+ fail("InterruptedException occurred");
throw new RuntimeException(e);
}
});
@@ -227,13 +209,13 @@ public void testRepeatableRead() throws InterruptedException {
sem1.await();
// CHECK THE NEW RECORD (PHANTOM READ) IS VISIBLE
- Assertions.assertEquals(1, database.countType("Node", true));
+ assertThat(database.countType("Node", true)).isEqualTo(1);
database.newVertex("Node").set("id", 1, "origin", "thread2").save();
- Assertions.assertEquals(2, database.countType("Node", true));
+ assertThat(database.countType("Node", true)).isEqualTo(2);
} catch (InterruptedException e) {
- Assertions.fail();
+ fail("InterruptedException occurred");
throw new RuntimeException(e);
}
});
@@ -242,17 +224,25 @@ public void testRepeatableRead() throws InterruptedException {
sem2.countDown();
try {
- Assertions.assertEquals(2, database.countType("Node", true));
+ assertThat(database.countType("Node", true)).isEqualTo(2);
- Assertions.assertNull(database.query("sql", "select from Node where id = 0").nextIfAvailable().getProperty("modified"));
+ assertThat(
+ database.query("sql", "select from Node where id = 0")
+ .nextIfAvailable()
+ .getProperty("modified")
+ ).isNull();
sem3.await();
// CHECK THE NEW RECORD WAS MODIFIED
- Assertions.assertNull(database.query("sql", "select from Node where id = 0").nextIfAvailable().getProperty("modified"));
+ assertThat(
+ database.query("sql", "select from Node where id = 0")
+ .nextIfAvailable()
+ .getProperty("modified")
+ ).isNull();
} catch (InterruptedException e) {
- Assertions.fail();
+ fail("InterruptedException occurred");
throw new RuntimeException(e);
}
});
diff --git a/engine/src/test/java/com/arcadedb/TransactionTypeTest.java b/engine/src/test/java/com/arcadedb/TransactionTypeTest.java
index a092bb84b7..d7dc42ffb1 100644
--- a/engine/src/test/java/com/arcadedb/TransactionTypeTest.java
+++ b/engine/src/test/java/com/arcadedb/TransactionTypeTest.java
@@ -1,21 +1,3 @@
-/*
- * Copyright © 2021-present Arcade Data Ltd (info@arcadedata.com)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * SPDX-FileCopyrightText: 2021-present Arcade Data Ltd (info@arcadedata.com)
- * SPDX-License-Identifier: Apache-2.0
- */
package com.arcadedb;
import com.arcadedb.database.Document;
@@ -27,13 +9,15 @@
import com.arcadedb.schema.DocumentType;
import com.arcadedb.schema.Schema;
import com.arcadedb.utility.CollectionUtils;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.io.*;
import java.util.*;
import java.util.concurrent.atomic.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThatExceptionOfType;
+
public class TransactionTypeTest extends TestHelper {
private static final int TOT = 10000;
private static final String TYPE_NAME = "V";
@@ -50,21 +34,21 @@ public void testScan() {
database.begin();
database.scanType(TYPE_NAME, true, record -> {
- Assertions.assertNotNull(record);
+ assertThat(record).isNotNull();
final Set prop = new HashSet();
prop.addAll(record.getPropertyNames());
- Assertions.assertEquals(3, record.getPropertyNames().size(), 9);
- Assertions.assertTrue(prop.contains("id"));
- Assertions.assertTrue(prop.contains("name"));
- Assertions.assertTrue(prop.contains("surname"));
+ assertThat(record.getPropertyNames().size()).isEqualTo(3);
+ assertThat(prop.contains("id")).isTrue();
+ assertThat(prop.contains("name")).isTrue();
+ assertThat(prop.contains("surname")).isTrue();
total.incrementAndGet();
return true;
});
- Assertions.assertEquals(TOT, total.get());
+ assertThat(total.get()).isEqualTo(TOT);
database.commit();
}
@@ -77,16 +61,16 @@ public void testLookupAllRecordsByRID() {
database.scanType(TYPE_NAME, true, record -> {
final Document record2 = (Document) database.lookupByRID(record.getIdentity(), false);
- Assertions.assertNotNull(record2);
- Assertions.assertEquals(record, record2);
+ assertThat(record2).isNotNull();
+ assertThat(record2).isEqualTo(record);
final Set prop = new HashSet();
prop.addAll(record2.getPropertyNames());
- Assertions.assertEquals(record2.getPropertyNames().size(), 3);
- Assertions.assertTrue(prop.contains("id"));
- Assertions.assertTrue(prop.contains("name"));
- Assertions.assertTrue(prop.contains("surname"));
+ assertThat(record2.getPropertyNames().size()).isEqualTo(3);
+ assertThat(prop.contains("id")).isTrue();
+ assertThat(prop.contains("name")).isTrue();
+ assertThat(prop.contains("surname")).isTrue();
total.incrementAndGet();
return true;
@@ -94,7 +78,7 @@ public void testLookupAllRecordsByRID() {
database.commit();
- Assertions.assertEquals(TOT, total.get());
+ assertThat(total.get()).isEqualTo(TOT);
}
@Test
@@ -105,27 +89,27 @@ public void testLookupAllRecordsByKey() {
for (int i = 0; i < TOT; i++) {
final IndexCursor result = database.lookupByKey(TYPE_NAME, new String[] { "id" }, new Object[] { i });
- Assertions.assertNotNull(result);
- Assertions.assertTrue(result.hasNext());
+ assertThat(Optional.ofNullable(result)).isNotNull();
+ assertThat(result.hasNext()).isTrue();
final Document record2 = (Document) result.next().getRecord();
- Assertions.assertEquals(i, record2.get("id"));
+ assertThat(record2.get("id")).isEqualTo(i);
final Set prop = new HashSet();
prop.addAll(record2.getPropertyNames());
- Assertions.assertEquals(record2.getPropertyNames().size(), 3);
- Assertions.assertTrue(prop.contains("id"));
- Assertions.assertTrue(prop.contains("name"));
- Assertions.assertTrue(prop.contains("surname"));
+ assertThat(record2.getPropertyNames().size()).isEqualTo(3);
+ assertThat(prop.contains("id")).isTrue();
+ assertThat(prop.contains("name")).isTrue();
+ assertThat(prop.contains("surname")).isTrue();
total.incrementAndGet();
}
database.commit();
- Assertions.assertEquals(TOT, total.get());
+ assertThat(total.get()).isEqualTo(TOT);
}
@Test
@@ -142,22 +126,22 @@ public void testDeleteAllRecordsReuseSpace() throws IOException {
database.commit();
- Assertions.assertEquals(TOT, total.get());
+ assertThat(total.get()).isEqualTo(TOT);
database.begin();
- Assertions.assertEquals(0, database.countType(TYPE_NAME, true));
+ assertThat(database.countType(TYPE_NAME, true)).isEqualTo(0);
// GET EACH ITEM TO CHECK IT HAS BEEN DELETED
final Index[] indexes = database.getSchema().getIndexes();
for (int i = 0; i < TOT; ++i) {
for (final Index index : indexes)
- Assertions.assertFalse(index.get(new Object[] { i }).hasNext(), "Found item with key " + i);
+ assertThat(index.get(new Object[]{i}).hasNext()).as("Found item with key " + i).isFalse();
}
beginTest();
- database.transaction(() -> Assertions.assertEquals(TOT, database.countType(TYPE_NAME, true)));
+ database.transaction(() -> assertThat(database.countType(TYPE_NAME, true)).isEqualTo(TOT));
}
@Test
@@ -176,11 +160,11 @@ public void testDeleteRecordsCheckScanAndIterators() throws IOException {
database.commit();
- Assertions.assertEquals(1, total.get());
+ assertThat(total.get()).isEqualTo(1);
database.begin();
- Assertions.assertEquals(originalCount - 1, database.countType(TYPE_NAME, true));
+ assertThat(database.countType(TYPE_NAME, true)).isEqualTo(originalCount - 1);
// COUNT WITH SCAN
total.set(0);
@@ -188,14 +172,14 @@ public void testDeleteRecordsCheckScanAndIterators() throws IOException {
total.incrementAndGet();
return true;
});
- Assertions.assertEquals(originalCount - 1, total.get());
+ assertThat(total.get()).isEqualTo(originalCount - 1);
// COUNT WITH ITERATE TYPE
total.set(0);
for (final Iterator it = database.iterateType(TYPE_NAME, true); it.hasNext(); it.next())
total.incrementAndGet();
- Assertions.assertEquals(originalCount - 1, total.get());
+ assertThat(total.get()).isEqualTo(originalCount - 1);
}
@Test
@@ -214,11 +198,11 @@ public void testPlaceholderOnScanAndIterate() throws IOException {
database.commit();
- Assertions.assertEquals(1, total.get());
+ assertThat(total.get()).isEqualTo(1);
database.begin();
- Assertions.assertEquals(originalCount, database.countType(TYPE_NAME, true));
+ assertThat(database.countType(TYPE_NAME, true)).isEqualTo(originalCount);
// COUNT WITH SCAN
total.set(0);
@@ -226,21 +210,21 @@ public void testPlaceholderOnScanAndIterate() throws IOException {
total.incrementAndGet();
return true;
});
- Assertions.assertEquals(originalCount, total.get());
+ assertThat(total.get()).isEqualTo(originalCount);
// COUNT WITH ITERATE TYPE
total.set(0);
for (final Iterator it = database.iterateType(TYPE_NAME, true); it.hasNext(); it.next())
total.incrementAndGet();
- Assertions.assertEquals(originalCount, total.get());
+ assertThat(total.get()).isEqualTo(originalCount);
}
@Test
public void testDeleteFail() {
reopenDatabaseInReadOnlyMode();
- Assertions.assertThrows(DatabaseIsReadOnlyException.class, () -> {
+ assertThatExceptionOfType(DatabaseIsReadOnlyException.class).isThrownBy(() -> {
database.begin();
@@ -262,9 +246,9 @@ public void testNestedTx() {
database.transaction(() -> database.newDocument(TYPE_NAME).set("id", -2, "tx", 2).save());
});
- Assertions.assertEquals(0, CollectionUtils.countEntries(database.query("sql", "select from " + TYPE_NAME + " where tx = 0")));
- Assertions.assertEquals(1, CollectionUtils.countEntries(database.query("sql", "select from " + TYPE_NAME + " where tx = 1")));
- Assertions.assertEquals(1, CollectionUtils.countEntries(database.query("sql", "select from " + TYPE_NAME + " where tx = 2")));
+ assertThat(CollectionUtils.countEntries(database.query("sql", "select from " + TYPE_NAME + " where tx = 0"))).isEqualTo(0);
+ assertThat(CollectionUtils.countEntries(database.query("sql", "select from " + TYPE_NAME + " where tx = 1"))).isEqualTo(1);
+ assertThat(CollectionUtils.countEntries(database.query("sql", "select from " + TYPE_NAME + " where tx = 2"))).isEqualTo(1);
}
@Override
diff --git a/engine/src/test/java/com/arcadedb/TypeConversionTest.java b/engine/src/test/java/com/arcadedb/TypeConversionTest.java
index 45afe7dad0..50c53a9653 100644
--- a/engine/src/test/java/com/arcadedb/TypeConversionTest.java
+++ b/engine/src/test/java/com/arcadedb/TypeConversionTest.java
@@ -26,7 +26,7 @@
import com.arcadedb.schema.Type;
import com.arcadedb.utility.DateUtils;
import com.arcadedb.utility.NanoClock;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.Test;
import java.math.*;
@@ -37,6 +37,10 @@
import java.util.*;
import java.util.concurrent.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
public class TypeConversionTest extends TestHelper {
@Override
public void beginTest() {
@@ -82,21 +86,21 @@ public void testNoConversion() {
doc.set("localDate", localDate); // SCHEMALESS
doc.set("localDateTime", localDateTime); // SCHEMALESS
- Assertions.assertEquals(33, doc.get("int"));
- Assertions.assertEquals(33l, doc.get("long"));
- Assertions.assertEquals(33.33f, doc.get("float"));
- Assertions.assertEquals(33.33d, doc.get("double"));
- Assertions.assertEquals(new BigDecimal("33.33"), doc.get("decimal"));
- Assertions.assertEquals(now, doc.get("date"));
-
- Assertions.assertEquals(0, ((LocalDateTime) doc.get("datetime_second")).getNano());
- Assertions.assertEquals(now, doc.get("datetime_millis"));
- Assertions.assertEquals(ChronoUnit.MILLIS, DateUtils.getPrecision(doc.getLocalDateTime("datetime_millis").getNano()));
- Assertions.assertEquals(ChronoUnit.MILLIS, DateUtils.getPrecision(((LocalDateTime) doc.get("datetime_micros")).getNano()));
- Assertions.assertEquals(ChronoUnit.MILLIS, DateUtils.getPrecision(((LocalDateTime) doc.get("datetime_nanos")).getNano()));
-
- Assertions.assertEquals(localDate, doc.get("localDate"));
- Assertions.assertEquals(localDateTime, doc.get("localDateTime"));
+ assertThat(doc.get("int")).isEqualTo(33);
+ assertThat(doc.get("long")).isEqualTo(33l);
+ assertThat(doc.get("float")).isEqualTo(33.33f);
+ assertThat(doc.get("double")).isEqualTo(33.33d);
+ assertThat(doc.get("decimal")).isEqualTo(new BigDecimal("33.33"));
+ assertThat(doc.get("date")).isEqualTo(now);
+
+ assertThat(((LocalDateTime) doc.get("datetime_second")).getNano()).isEqualTo(0);
+ assertThat(doc.get("datetime_millis")).isEqualTo(now);
+ assertThat(DateUtils.getPrecision(doc.getLocalDateTime("datetime_millis").getNano())).isEqualTo(ChronoUnit.MILLIS);
+ assertThat(DateUtils.getPrecision(((LocalDateTime) doc.get("datetime_micros")).getNano())).isEqualTo(ChronoUnit.MILLIS);
+ assertThat(DateUtils.getPrecision(((LocalDateTime) doc.get("datetime_nanos")).getNano())).isEqualTo(ChronoUnit.MILLIS);
+
+ assertThat(doc.get("localDate")).isEqualTo(localDate);
+ assertThat(doc.get("localDateTime")).isEqualTo(localDateTime);
});
}
@@ -108,19 +112,19 @@ public void testConversionDecimals() {
final Date now = new Date();
doc.set("decimal", "33.33");
- Assertions.assertEquals(new BigDecimal("33.33"), doc.get("decimal"));
+ assertThat(doc.get("decimal")).isEqualTo(new BigDecimal("33.33"));
doc.set("decimal", 33.33f);
- Assertions.assertEquals(new BigDecimal("33.33"), doc.get("decimal"));
+ assertThat(doc.get("decimal")).isEqualTo(new BigDecimal("33.33"));
doc.set("decimal", 33.33d);
- Assertions.assertEquals(new BigDecimal("33.33"), doc.get("decimal"));
+ assertThat(doc.get("decimal")).isEqualTo(new BigDecimal("33.33"));
doc.save();
- Assertions.assertEquals(String.format("%.1f", 33.3F),
+ assertEquals(String.format("%.1f", 33.3F),
database.query("sql", "select decimal.format('%.1f') as d from " + doc.getIdentity()).nextIfAvailable().getProperty("d"));
- Assertions.assertEquals(String.format("%.2f", 33.33F),
+ assertEquals(String.format("%.2f", 33.33F),
database.query("sql", "select decimal.format('%.2f') as d from " + doc.getIdentity()).nextIfAvailable().getProperty("d"));
doc.delete();
@@ -136,30 +140,30 @@ public void testConversionDates() {
doc.set("date", now.getTime());
doc.set("datetime_millis", now.getTime());
- Assertions.assertEquals(now, doc.get("date"));
- Assertions.assertEquals(now, doc.get("datetime_millis"));
+ assertThat(doc.get("date")).isEqualTo(now);
+ assertThat(doc.get("datetime_millis")).isEqualTo(now);
doc.set("date", "" + now.getTime());
doc.set("datetime_millis", "" + now.getTime());
- Assertions.assertEquals(now, doc.get("date"));
- Assertions.assertEquals(now, doc.get("datetime_millis"));
+ assertThat(doc.get("date")).isEqualTo(now);
+ assertThat(doc.get("datetime_millis")).isEqualTo(now);
final SimpleDateFormat df = new SimpleDateFormat(database.getSchema().getDateTimeFormat());
doc.set("date", df.format(now));
doc.set("datetime_millis", df.format(now));
- Assertions.assertEquals(df.format(now), df.format(doc.get("date")));
- Assertions.assertEquals(df.format(now), df.format(doc.get("datetime_millis")));
+ assertThat(df.format(doc.get("date"))).isEqualTo(df.format(now));
+ assertThat(df.format(doc.get("datetime_millis"))).isEqualTo(df.format(now));
final LocalDate localDate = LocalDate.now();
final LocalDateTime localDateTime = LocalDateTime.now();
doc.set("date", localDate);
doc.set("datetime_nanos", localDateTime);
- Assertions.assertEquals(localDate, doc.getLocalDate("date"));
- Assertions.assertEquals(localDateTime.truncatedTo(DateUtils.getPrecision(localDateTime.getNano())),
+ assertThat(doc.getLocalDate("date")).isEqualTo(localDate);
+ assertEquals(localDateTime.truncatedTo(DateUtils.getPrecision(localDateTime.getNano())),
doc.getLocalDateTime("datetime_nanos"));
- Assertions.assertEquals(
+ assertEquals(
TimeUnit.MILLISECONDS.convert(localDateTime.toEpochSecond(ZoneOffset.UTC), TimeUnit.SECONDS) + localDateTime.getLong(
ChronoField.MILLI_OF_SECOND), doc.getCalendar("datetime_nanos").getTime().getTime());
});
@@ -170,21 +174,21 @@ public void testDateAndDateTimeSettingsAreSavedInDatabase() {
database.command("sql", "alter database `arcadedb.dateTimeImplementation` `java.time.LocalDateTime`");
database.command("sql", "alter database `arcadedb.dateImplementation` `java.time.LocalDate`");
- Assertions.assertEquals(LocalDateTime.class, ((DatabaseInternal) database).getSerializer().getDateTimeImplementation());
- Assertions.assertEquals(LocalDate.class, ((DatabaseInternal) database).getSerializer().getDateImplementation());
+ assertThat(((DatabaseInternal) database).getSerializer().getDateTimeImplementation()).isEqualTo(LocalDateTime.class);
+ assertThat(((DatabaseInternal) database).getSerializer().getDateImplementation()).isEqualTo(LocalDate.class);
database.close();
database = factory.open();
- Assertions.assertEquals(LocalDateTime.class, ((DatabaseInternal) database).getSerializer().getDateTimeImplementation());
- Assertions.assertEquals(LocalDate.class, ((DatabaseInternal) database).getSerializer().getDateImplementation());
+ assertThat(((DatabaseInternal) database).getSerializer().getDateTimeImplementation()).isEqualTo(LocalDateTime.class);
+ assertThat(((DatabaseInternal) database).getSerializer().getDateImplementation()).isEqualTo(LocalDate.class);
database.command("sql", "alter database `arcadedb.dateTimeImplementation` `java.util.Date`");
database.command("sql", "alter database `arcadedb.dateImplementation` `java.util.Date`");
- Assertions.assertEquals(Date.class, ((DatabaseInternal) database).getSerializer().getDateTimeImplementation());
- Assertions.assertEquals(Date.class, ((DatabaseInternal) database).getSerializer().getDateImplementation());
+ assertThat(((DatabaseInternal) database).getSerializer().getDateTimeImplementation()).isEqualTo(Date.class);
+ assertThat(((DatabaseInternal) database).getSerializer().getDateImplementation()).isEqualTo(Date.class);
}
@Test
@@ -202,7 +206,7 @@ public void testLocalDateTime() throws ClassNotFoundException {
});
doc.reload();
- Assertions.assertEquals(localDateTime.truncatedTo(ChronoUnit.SECONDS), doc.get("datetime_second"));
+ assertThat(doc.get("datetime_second")).isEqualTo(localDateTime.truncatedTo(ChronoUnit.SECONDS));
database.transaction(() -> {
// TEST MILLISECONDS PRECISION
@@ -211,7 +215,7 @@ public void testLocalDateTime() throws ClassNotFoundException {
});
doc.reload();
- Assertions.assertEquals(localDateTime.truncatedTo(ChronoUnit.MILLIS), doc.get("datetime_millis"));
+ assertThat(doc.get("datetime_millis")).isEqualTo(localDateTime.truncatedTo(ChronoUnit.MILLIS));
// TEST MICROSECONDS PRECISION
database.transaction(() -> {
@@ -220,7 +224,7 @@ public void testLocalDateTime() throws ClassNotFoundException {
});
doc.reload();
- Assertions.assertEquals(localDateTime.truncatedTo(ChronoUnit.MICROS), doc.get("datetime_micros"));
+ assertThat(doc.get("datetime_micros")).isEqualTo(localDateTime.truncatedTo(ChronoUnit.MICROS));
// TEST NANOSECOND PRECISION
database.transaction(() -> {
@@ -228,25 +232,21 @@ public void testLocalDateTime() throws ClassNotFoundException {
doc.save();
});
doc.reload();
- Assertions.assertEquals(localDateTime.truncatedTo(ChronoUnit.NANOS), doc.get("datetime_nanos"));
-
- Assertions.assertNotNull(
- database.query("sql", "select datetime_second.asLong() as long from ConversionTest").nextIfAvailable()
- .getProperty("long"));
- Assertions.assertNotNull(
- database.query("sql", "select datetime_millis.asLong() as long from ConversionTest").nextIfAvailable()
- .getProperty("long"));
- Assertions.assertNotNull(
- database.query("sql", "select datetime_micros.asLong() as long from ConversionTest").nextIfAvailable()
- .getProperty("long"));
- Assertions.assertNotNull(database.query("sql", "select datetime_nanos.asLong() as long from ConversionTest").nextIfAvailable()
- .getProperty("long"));
-
- Assertions.assertEquals(
- TimeUnit.MILLISECONDS.convert(localDateTime.toEpochSecond(ZoneOffset.UTC), TimeUnit.SECONDS) + localDateTime.getLong(
- ChronoField.MILLI_OF_SECOND), doc.getDate("datetime_millis").getTime());
+ assertThat(doc.get("datetime_nanos")).isEqualTo(localDateTime.truncatedTo(ChronoUnit.NANOS));
+
+ assertThat((Long) database.query("sql", "select datetime_second.asLong() as long from ConversionTest").nextIfAvailable()
+ .getProperty("long")).isNotNull();
+ assertThat((Long) database.query("sql", "select datetime_millis.asLong() as long from ConversionTest").nextIfAvailable()
+ .getProperty("long")).isNotNull();
+ assertThat((Long) database.query("sql", "select datetime_micros.asLong() as long from ConversionTest").nextIfAvailable()
+ .getProperty("long")).isNotNull();
+ assertThat((Long) database.query("sql", "select datetime_nanos.asLong() as long from ConversionTest").nextIfAvailable()
+ .getProperty("long")).isNotNull();
+
+ assertThat(doc.getDate("datetime_millis").getTime()).isEqualTo(TimeUnit.MILLISECONDS.convert(localDateTime.toEpochSecond(ZoneOffset.UTC), TimeUnit.SECONDS) + localDateTime.getLong(
+ ChronoField.MILLI_OF_SECOND));
- Assertions.assertTrue(localDateTime.isEqual(doc.getLocalDateTime("datetime_nanos")));
+ assertThat(localDateTime.isEqual(doc.getLocalDateTime("datetime_nanos"))).isTrue();
} finally {
((DatabaseInternal) database).getSerializer().setDateTimeImplementation(Date.class);
@@ -261,20 +261,20 @@ public void testSQL() throws ClassNotFoundException {
try {
database.begin();
ResultSet result = database.command("sql", "insert into ConversionTest set datetime_second = ?", localDateTime);
- Assertions.assertTrue(result.hasNext());
- Assertions.assertEquals(localDateTime.truncatedTo(ChronoUnit.SECONDS), result.next().toElement().get("datetime_second"));
+ assertThat(result.hasNext()).isTrue();
+ assertThat(result.next().toElement().get("datetime_second")).isEqualTo(localDateTime.truncatedTo(ChronoUnit.SECONDS));
result = database.command("sql", "insert into ConversionTest set datetime_millis = ?", localDateTime);
- Assertions.assertTrue(result.hasNext());
- Assertions.assertEquals(localDateTime.truncatedTo(ChronoUnit.MILLIS), result.next().toElement().get("datetime_millis"));
+ assertThat(result.hasNext()).isTrue();
+ assertThat(result.next().toElement().get("datetime_millis")).isEqualTo(localDateTime.truncatedTo(ChronoUnit.MILLIS));
result = database.command("sql", "insert into ConversionTest set datetime_micros = ?", localDateTime);
- Assertions.assertTrue(result.hasNext());
- Assertions.assertEquals(localDateTime.truncatedTo(ChronoUnit.MICROS), result.next().toElement().get("datetime_micros"));
+ assertThat(result.hasNext()).isTrue();
+ assertThat(result.next().toElement().get("datetime_micros")).isEqualTo(localDateTime.truncatedTo(ChronoUnit.MICROS));
result = database.command("sql", "insert into ConversionTest set datetime_nanos = ?", localDateTime);
- Assertions.assertTrue(result.hasNext());
- Assertions.assertEquals(localDateTime.truncatedTo(ChronoUnit.NANOS), result.next().toElement().get("datetime_nanos"));
+ assertThat(result.hasNext()).isTrue();
+ assertThat(result.next().toElement().get("datetime_nanos")).isEqualTo(localDateTime.truncatedTo(ChronoUnit.NANOS));
database.commit();
} finally {
@@ -297,8 +297,8 @@ public void testCalendar() throws ClassNotFoundException {
});
doc.reload();
- Assertions.assertEquals(calendar, doc.get("datetime_millis"));
- Assertions.assertEquals(calendar, doc.getCalendar("datetime_millis"));
+ assertThat(doc.get("datetime_millis")).isEqualTo(calendar);
+ assertThat(doc.getCalendar("datetime_millis")).isEqualTo(calendar);
} finally {
((DatabaseInternal) database).getSerializer().setDateTimeImplementation(Date.class);
@@ -320,8 +320,8 @@ public void testLocalDate() throws ClassNotFoundException {
});
doc.reload();
- Assertions.assertEquals(localDate, doc.get("date"));
- Assertions.assertTrue(localDate.isEqual(doc.getLocalDate("date")));
+ assertThat(doc.get("date")).isEqualTo(localDate);
+ assertThat(localDate.isEqual(doc.getLocalDate("date"))).isTrue();
} finally {
((DatabaseInternal) database).getSerializer().setDateImplementation(Date.class);
@@ -344,8 +344,7 @@ public void testZonedDateTime() throws ClassNotFoundException {
});
doc.reload();
- Assertions.assertTrue(
- zonedDateTime.truncatedTo(ChronoUnit.SECONDS).isEqual((ChronoZonedDateTime>) doc.get("datetime_second")));
+ assertThat(zonedDateTime.truncatedTo(ChronoUnit.SECONDS).isEqual((ChronoZonedDateTime>) doc.get("datetime_second"))).isTrue();
database.transaction(() -> {
// TEST MILLISECONDS PRECISION
@@ -354,8 +353,7 @@ public void testZonedDateTime() throws ClassNotFoundException {
});
doc.reload();
- Assertions.assertTrue(
- zonedDateTime.truncatedTo(ChronoUnit.MILLIS).isEqual((ChronoZonedDateTime>) doc.get("datetime_millis")));
+ assertThat(zonedDateTime.truncatedTo(ChronoUnit.MILLIS).isEqual((ChronoZonedDateTime>) doc.get("datetime_millis"))).isTrue();
if (!System.getProperty("os.name").startsWith("Windows")) {
// NOTE: ON WINDOWS MICROSECONDS ARE NOT HANDLED CORRECTLY
@@ -367,8 +365,7 @@ public void testZonedDateTime() throws ClassNotFoundException {
});
doc.reload();
- Assertions.assertTrue(
- zonedDateTime.truncatedTo(ChronoUnit.MICROS).isEqual((ChronoZonedDateTime>) doc.get("datetime_micros")));
+ assertThat(zonedDateTime.truncatedTo(ChronoUnit.MICROS).isEqual((ChronoZonedDateTime>) doc.get("datetime_micros"))).isTrue();
}
// TEST NANOSECOND PRECISION
@@ -377,9 +374,8 @@ public void testZonedDateTime() throws ClassNotFoundException {
doc.save();
});
doc.reload();
- Assertions.assertTrue(
- zonedDateTime.truncatedTo(ChronoUnit.NANOS).isEqual((ChronoZonedDateTime>) doc.get("datetime_nanos")));
- Assertions.assertTrue(zonedDateTime.isEqual(doc.getZonedDateTime("datetime_nanos")));
+ assertThat(zonedDateTime.truncatedTo(ChronoUnit.NANOS).isEqual((ChronoZonedDateTime>) doc.get("datetime_nanos"))).isTrue();
+ assertThat(zonedDateTime.isEqual(doc.getZonedDateTime("datetime_nanos"))).isTrue();
} finally {
((DatabaseInternal) database).getSerializer().setDateTimeImplementation(Date.class);
@@ -401,7 +397,7 @@ public void testInstant() throws ClassNotFoundException {
});
doc.reload();
- Assertions.assertEquals(instant.truncatedTo(ChronoUnit.SECONDS), doc.get("datetime_second"));
+ assertThat(doc.get("datetime_second")).isEqualTo(instant.truncatedTo(ChronoUnit.SECONDS));
database.transaction(() -> {
// TEST MILLISECONDS PRECISION
@@ -410,7 +406,7 @@ public void testInstant() throws ClassNotFoundException {
});
doc.reload();
- Assertions.assertEquals(instant.truncatedTo(ChronoUnit.MILLIS), doc.get("datetime_millis"));
+ assertThat(doc.get("datetime_millis")).isEqualTo(instant.truncatedTo(ChronoUnit.MILLIS));
// TEST MICROSECONDS PRECISION
database.transaction(() -> {
@@ -421,7 +417,7 @@ public void testInstant() throws ClassNotFoundException {
doc.reload();
if (!System.getProperty("os.name").startsWith("Windows"))
// NOTE: ON WINDOWS MICROSECONDS ARE NOT HANDLED CORRECTLY
- Assertions.assertEquals(instant.truncatedTo(ChronoUnit.MICROS), doc.get("datetime_micros"));
+ assertThat(doc.get("datetime_micros")).isEqualTo(instant.truncatedTo(ChronoUnit.MICROS));
// TEST NANOSECOND PRECISION
database.transaction(() -> {
@@ -429,8 +425,8 @@ public void testInstant() throws ClassNotFoundException {
doc.save();
});
doc.reload();
- Assertions.assertEquals(instant.truncatedTo(ChronoUnit.NANOS), doc.get("datetime_nanos"));
- Assertions.assertEquals(instant, doc.getInstant("datetime_nanos"));
+ assertThat(doc.get("datetime_nanos")).isEqualTo(instant.truncatedTo(ChronoUnit.NANOS));
+ assertThat(doc.getInstant("datetime_nanos")).isEqualTo(instant);
} finally {
((DatabaseInternal) database).getSerializer().setDateTimeImplementation(Date.class);
@@ -439,25 +435,25 @@ public void testInstant() throws ClassNotFoundException {
@Test
public void testConversion() {
- Assertions.assertEquals(10, DateUtils.convertTimestamp(10_000_000_000L, ChronoUnit.NANOS, ChronoUnit.SECONDS));
- Assertions.assertEquals(10_000, DateUtils.convertTimestamp(10_000_000_000L, ChronoUnit.NANOS, ChronoUnit.MILLIS));
- Assertions.assertEquals(10_000_000, DateUtils.convertTimestamp(10_000_000_000L, ChronoUnit.NANOS, ChronoUnit.MICROS));
- Assertions.assertEquals(10_000_000_000L, DateUtils.convertTimestamp(10_000_000_000L, ChronoUnit.NANOS, ChronoUnit.NANOS));
-
- Assertions.assertEquals(10, DateUtils.convertTimestamp(10_000_000, ChronoUnit.MICROS, ChronoUnit.SECONDS));
- Assertions.assertEquals(10_000, DateUtils.convertTimestamp(10_000_000, ChronoUnit.MICROS, ChronoUnit.MILLIS));
- Assertions.assertEquals(10_000_000, DateUtils.convertTimestamp(10_000_000, ChronoUnit.MICROS, ChronoUnit.MICROS));
- Assertions.assertEquals(10_000_000_000L, DateUtils.convertTimestamp(10_000_000, ChronoUnit.MICROS, ChronoUnit.NANOS));
-
- Assertions.assertEquals(10, DateUtils.convertTimestamp(10_000, ChronoUnit.MILLIS, ChronoUnit.SECONDS));
- Assertions.assertEquals(10_000, DateUtils.convertTimestamp(10_000, ChronoUnit.MILLIS, ChronoUnit.MILLIS));
- Assertions.assertEquals(10_000_000, DateUtils.convertTimestamp(10_000, ChronoUnit.MILLIS, ChronoUnit.MICROS));
- Assertions.assertEquals(10_000_000_000L, DateUtils.convertTimestamp(10_000, ChronoUnit.MILLIS, ChronoUnit.NANOS));
-
- Assertions.assertEquals(10, DateUtils.convertTimestamp(10, ChronoUnit.SECONDS, ChronoUnit.SECONDS));
- Assertions.assertEquals(10_000, DateUtils.convertTimestamp(10, ChronoUnit.SECONDS, ChronoUnit.MILLIS));
- Assertions.assertEquals(10_000_000, DateUtils.convertTimestamp(10, ChronoUnit.SECONDS, ChronoUnit.MICROS));
- Assertions.assertEquals(10_000_000_000L, DateUtils.convertTimestamp(10, ChronoUnit.SECONDS, ChronoUnit.NANOS));
+ assertThat(DateUtils.convertTimestamp(10_000_000_000L, ChronoUnit.NANOS, ChronoUnit.SECONDS)).isEqualTo(10);
+ assertThat(DateUtils.convertTimestamp(10_000_000_000L, ChronoUnit.NANOS, ChronoUnit.MILLIS)).isEqualTo(10_000);
+ assertThat(DateUtils.convertTimestamp(10_000_000_000L, ChronoUnit.NANOS, ChronoUnit.MICROS)).isEqualTo(10_000_000);
+ assertThat(DateUtils.convertTimestamp(10_000_000_000L, ChronoUnit.NANOS, ChronoUnit.NANOS)).isEqualTo(10_000_000_000L);
+
+ assertThat(DateUtils.convertTimestamp(10_000_000, ChronoUnit.MICROS, ChronoUnit.SECONDS)).isEqualTo(10);
+ assertThat(DateUtils.convertTimestamp(10_000_000, ChronoUnit.MICROS, ChronoUnit.MILLIS)).isEqualTo(10_000);
+ assertThat(DateUtils.convertTimestamp(10_000_000, ChronoUnit.MICROS, ChronoUnit.MICROS)).isEqualTo(10_000_000);
+ assertThat(DateUtils.convertTimestamp(10_000_000, ChronoUnit.MICROS, ChronoUnit.NANOS)).isEqualTo(10_000_000_000L);
+
+ assertThat(DateUtils.convertTimestamp(10_000, ChronoUnit.MILLIS, ChronoUnit.SECONDS)).isEqualTo(10);
+ assertThat(DateUtils.convertTimestamp(10_000, ChronoUnit.MILLIS, ChronoUnit.MILLIS)).isEqualTo(10_000);
+ assertThat(DateUtils.convertTimestamp(10_000, ChronoUnit.MILLIS, ChronoUnit.MICROS)).isEqualTo(10_000_000);
+ assertThat(DateUtils.convertTimestamp(10_000, ChronoUnit.MILLIS, ChronoUnit.NANOS)).isEqualTo(10_000_000_000L);
+
+ assertThat(DateUtils.convertTimestamp(10, ChronoUnit.SECONDS, ChronoUnit.SECONDS)).isEqualTo(10);
+ assertThat(DateUtils.convertTimestamp(10, ChronoUnit.SECONDS, ChronoUnit.MILLIS)).isEqualTo(10_000);
+ assertThat(DateUtils.convertTimestamp(10, ChronoUnit.SECONDS, ChronoUnit.MICROS)).isEqualTo(10_000_000);
+ assertThat(DateUtils.convertTimestamp(10, ChronoUnit.SECONDS, ChronoUnit.NANOS)).isEqualTo(10_000_000_000L);
}
@Test
@@ -471,20 +467,20 @@ public void testSQLMath() {
database.begin();
final LocalDateTime date1 = LocalDateTime.now();
ResultSet resultSet = database.command("sql", "insert into ConversionTest set datetime_micros = ?", date1);
- Assertions.assertTrue(resultSet.hasNext());
- Assertions.assertEquals(date1.truncatedTo(ChronoUnit.MICROS), resultSet.next().toElement().get("datetime_micros"));
+ assertThat(resultSet.hasNext()).isTrue();
+ assertThat(resultSet.next().toElement().get("datetime_micros")).isEqualTo(date1.truncatedTo(ChronoUnit.MICROS));
final LocalDateTime date2 = LocalDateTime.now().plusSeconds(1);
resultSet = database.command("sql", "insert into ConversionTest set datetime_micros = ?", date2);
- Assertions.assertTrue(resultSet.hasNext());
- Assertions.assertEquals(date2.truncatedTo(ChronoUnit.MICROS), resultSet.next().toElement().get("datetime_micros"));
+ assertThat(resultSet.hasNext()).isTrue();
+ assertThat(resultSet.next().toElement().get("datetime_micros")).isEqualTo(date2.truncatedTo(ChronoUnit.MICROS));
resultSet = database.command("sql", "select from ConversionTest where datetime_micros between ? and ?", date1, date2);
- Assertions.assertTrue(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isTrue();
resultSet.next();
- Assertions.assertTrue(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isTrue();
resultSet.next();
- Assertions.assertFalse(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isFalse();
try {
Thread.sleep(1001);
@@ -494,68 +490,68 @@ public void testSQLMath() {
resultSet = database.command("sql", "select sysdate() - datetime_micros as diff from ConversionTest");
- Assertions.assertTrue(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isTrue();
Result result = resultSet.next();
- Assertions.assertFalse(((Duration) result.getProperty("diff")).isNegative(), "Returned " + result.getProperty("diff"));
+ assertThat(((Duration) result.getProperty("diff")).isNegative()).as("Returned " + result.getProperty("diff")).isFalse();
- Assertions.assertTrue(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isTrue();
result = resultSet.next();
- Assertions.assertFalse(((Duration) result.getProperty("diff")).isNegative(), "Returned " + result.getProperty("diff"));
+ assertThat(((Duration) result.getProperty("diff")).isNegative()).as("Returned " + result.getProperty("diff")).isFalse();
- Assertions.assertFalse(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isFalse();
resultSet = database.command("sql",
"select sysdate() - datetime_micros as diff from ConversionTest where sysdate() - datetime_micros < duration(100000000000, 'nanosecond')");
- Assertions.assertTrue(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isTrue();
result = resultSet.next();
- Assertions.assertFalse(((Duration) result.getProperty("diff")).isNegative(), "Returned " + result.getProperty("diff"));
+ assertThat(((Duration) result.getProperty("diff")).isNegative()).as("Returned " + result.getProperty("diff")).isFalse();
- Assertions.assertTrue(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isTrue();
result = resultSet.next();
- Assertions.assertFalse(((Duration) result.getProperty("diff")).isNegative(), "Returned " + result.getProperty("diff"));
+ assertThat(((Duration) result.getProperty("diff")).isNegative()).as("Returned " + result.getProperty("diff")).isFalse();
- Assertions.assertFalse(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isFalse();
resultSet = database.command("sql",
"select datetime_micros - sysdate() as diff from ConversionTest where abs( datetime_micros - sysdate() ) < duration(100000000000, 'nanosecond')");
- Assertions.assertTrue(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isTrue();
result = resultSet.next();
- Assertions.assertTrue(((Duration) result.getProperty("diff")).isNegative(), "Returned " + result.getProperty("diff"));
+ assertThat(((Duration) result.getProperty("diff")).isNegative()).as("Returned " + result.getProperty("diff")).isTrue();
- Assertions.assertTrue(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isTrue();
result = resultSet.next();
- Assertions.assertTrue(((Duration) result.getProperty("diff")).isNegative(), "Returned " + result.getProperty("diff"));
+ assertThat(((Duration) result.getProperty("diff")).isNegative()).as("Returned " + result.getProperty("diff")).isTrue();
- Assertions.assertFalse(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isFalse();
resultSet = database.command("sql",
"select datetime_micros - date(?, 'yyyy-MM-dd HH:mm:ss.SSS') as diff from ConversionTest where abs( datetime_micros - sysdate() ) < duration(100000000000, 'nanosecond')",
DateUtils.getFormatter("yyyy-MM-dd HH:mm:ss.SSS").format(LocalDateTime.now()));
- Assertions.assertTrue(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isTrue();
result = resultSet.next();
- Assertions.assertTrue(((Duration) result.getProperty("diff")).isNegative(), "Returned " + result.getProperty("diff"));
+ assertThat(((Duration) result.getProperty("diff")).isNegative()).as("Returned " + result.getProperty("diff")).isTrue();
- Assertions.assertTrue(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isTrue();
result = resultSet.next();
- Assertions.assertTrue(((Duration) result.getProperty("diff")).isNegative(), "Returned " + result.getProperty("diff"));
+ assertThat(((Duration) result.getProperty("diff")).isNegative()).as("Returned " + result.getProperty("diff")).isTrue();
- Assertions.assertFalse(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isFalse();
resultSet = database.command("sql",
"select datetime_micros - date(?, 'yyyy-MM-dd HH:mm:ss.SSS') as diff from ConversionTest where abs( datetime_micros - sysdate() ) < duration(3, \"second\")",
DateUtils.getFormatter("yyyy-MM-dd HH:mm:ss.SSS").format(LocalDateTime.now()));
- Assertions.assertTrue(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isTrue();
result = resultSet.next();
- Assertions.assertTrue(((Duration) result.getProperty("diff")).isNegative(), "Returned " + result.getProperty("diff"));
+ assertThat(((Duration) result.getProperty("diff")).isNegative()).as("Returned " + result.getProperty("diff")).isTrue();
- Assertions.assertTrue(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isTrue();
result = resultSet.next();
- Assertions.assertTrue(((Duration) result.getProperty("diff")).isNegative(), "Returned " + result.getProperty("diff"));
+ assertThat(((Duration) result.getProperty("diff")).isNegative()).as("Returned " + result.getProperty("diff")).isTrue();
- Assertions.assertFalse(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isFalse();
database.commit();
} finally {
diff --git a/engine/src/test/java/com/arcadedb/compression/CompressionTest.java b/engine/src/test/java/com/arcadedb/compression/CompressionTest.java
index b45fb59dad..6b75838681 100644
--- a/engine/src/test/java/com/arcadedb/compression/CompressionTest.java
+++ b/engine/src/test/java/com/arcadedb/compression/CompressionTest.java
@@ -19,9 +19,10 @@
package com.arcadedb.compression;
import com.arcadedb.database.Binary;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class CompressionTest {
@Test
public void testCompression() {
@@ -30,7 +31,7 @@ public void testCompression() {
final Binary compressed = CompressionFactory.getDefault().compress(buffer);
final Binary decompressed = CompressionFactory.getDefault().decompress(compressed, buffer.size());
- Assertions.assertEquals(buffer, decompressed);
+ assertThat(decompressed).isEqualTo(buffer);
}
@Test
@@ -40,6 +41,6 @@ public void testEmptyCompression() {
final Binary compressed = CompressionFactory.getDefault().compress(buffer);
final Binary decompressed = CompressionFactory.getDefault().decompress(compressed, buffer.size());
- Assertions.assertEquals(buffer, decompressed);
+ assertThat(decompressed).isEqualTo(buffer);
}
}
diff --git a/engine/src/test/java/com/arcadedb/database/BucketSQLTest.java b/engine/src/test/java/com/arcadedb/database/BucketSQLTest.java
index 6adb3af4df..f88b5f6c2b 100644
--- a/engine/src/test/java/com/arcadedb/database/BucketSQLTest.java
+++ b/engine/src/test/java/com/arcadedb/database/BucketSQLTest.java
@@ -1,21 +1,3 @@
-/*
- * Copyright © 2021-present Arcade Data Ltd (info@arcadedata.com)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * SPDX-FileCopyrightText: 2021-present Arcade Data Ltd (info@arcadedata.com)
- * SPDX-License-Identifier: Apache-2.0
- */
package com.arcadedb.database;
import com.arcadedb.GlobalConfiguration;
@@ -23,11 +5,12 @@
import com.arcadedb.engine.Bucket;
import com.arcadedb.query.sql.executor.ResultSet;
import com.arcadedb.schema.DocumentType;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class BucketSQLTest extends TestHelper {
@Test
public void testPopulate() {
@@ -50,31 +33,31 @@ protected void beginTest() {
final DocumentType customer = database.getSchema().getType("Customer");
final List buckets = customer.getBuckets(true);
- Assertions.assertEquals(4, buckets.size());
+ assertThat(buckets.size()).isEqualTo(4);
ResultSet resultset = database.command("sql", "INSERT INTO BUCKET:Customer_Europe CONTENT { firstName: 'Enzo', lastName: 'Ferrari' }");
- Assertions.assertTrue(resultset.hasNext());
+ assertThat(resultset.hasNext()).isTrue();
final Document enzo = resultset.next().getRecord().get().asDocument();
- Assertions.assertFalse(resultset.hasNext());
- Assertions.assertEquals(database.getSchema().getBucketByName("Customer_Europe").getFileId(), enzo.getIdentity().bucketId);
+ assertThat(resultset.hasNext()).isFalse();
+ assertThat(enzo.getIdentity().bucketId).isEqualTo(database.getSchema().getBucketByName("Customer_Europe").getFileId());
resultset = database.command("sql", "INSERT INTO BUCKET:Customer_Americas CONTENT { firstName: 'Jack', lastName: 'Tramiel' }");
- Assertions.assertTrue(resultset.hasNext());
+ assertThat(resultset.hasNext()).isTrue();
final Document jack = resultset.next().getRecord().get().asDocument();
- Assertions.assertFalse(resultset.hasNext());
- Assertions.assertEquals(database.getSchema().getBucketByName("Customer_Americas").getFileId(), jack.getIdentity().bucketId);
+ assertThat(resultset.hasNext()).isFalse();
+ assertThat(jack.getIdentity().bucketId).isEqualTo(database.getSchema().getBucketByName("Customer_Americas").getFileId());
resultset = database.command("sql", "INSERT INTO BUCKET:Customer_Asia CONTENT { firstName: 'Bruce', lastName: 'Lee' }");
- Assertions.assertTrue(resultset.hasNext());
+ assertThat(resultset.hasNext()).isTrue();
final Document bruce = resultset.next().getRecord().get().asDocument();
- Assertions.assertFalse(resultset.hasNext());
- Assertions.assertEquals(database.getSchema().getBucketByName("Customer_Asia").getFileId(), bruce.getIdentity().bucketId);
+ assertThat(resultset.hasNext()).isFalse();
+ assertThat(bruce.getIdentity().bucketId).isEqualTo(database.getSchema().getBucketByName("Customer_Asia").getFileId());
resultset = database.command("sql", "INSERT INTO BUCKET:Customer_Other CONTENT { firstName: 'Penguin', lastName: 'Hungry' }");
- Assertions.assertTrue(resultset.hasNext());
+ assertThat(resultset.hasNext()).isTrue();
final Document penguin = resultset.next().getRecord().get().asDocument();
- Assertions.assertFalse(resultset.hasNext());
- Assertions.assertEquals(database.getSchema().getBucketByName("Customer_Other").getFileId(), penguin.getIdentity().bucketId);
+ assertThat(resultset.hasNext()).isFalse();
+ assertThat(penguin.getIdentity().bucketId).isEqualTo(database.getSchema().getBucketByName("Customer_Other").getFileId());
});
}
}
diff --git a/engine/src/test/java/com/arcadedb/database/CheckDatabaseTest.java b/engine/src/test/java/com/arcadedb/database/CheckDatabaseTest.java
index 7427060f41..2dc77ace33 100644
--- a/engine/src/test/java/com/arcadedb/database/CheckDatabaseTest.java
+++ b/engine/src/test/java/com/arcadedb/database/CheckDatabaseTest.java
@@ -31,13 +31,16 @@
import com.arcadedb.index.TypeIndex;
import com.arcadedb.query.sql.executor.Result;
import com.arcadedb.query.sql.executor.ResultSet;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import java.io.*;
import java.util.*;
import java.util.concurrent.atomic.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class CheckDatabaseTest extends TestHelper {
private static final int TOTAL = 10_000;
@@ -46,40 +49,40 @@ public class CheckDatabaseTest extends TestHelper {
@Test
public void checkDatabase() {
final ResultSet result = database.command("sql", "check database");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
while (result.hasNext()) {
final Result row = result.next();
- Assertions.assertEquals("check database", row.getProperty("operation"));
- Assertions.assertEquals(TOTAL, (Long) row.getProperty("totalActiveVertices"));
- Assertions.assertEquals(TOTAL - 1, (Long) row.getProperty("totalActiveEdges"));
- Assertions.assertEquals(0, (Long) row.getProperty("autoFix"));
+ assertThat(row.getProperty("operation")).isEqualTo("check database");
+ assertThat(row.getProperty("totalActiveVertices")).isEqualTo(TOTAL);
+ assertThat(row.getProperty("totalActiveEdges")).isEqualTo(TOTAL - 1);
+ assertThat(row.getProperty("autoFix")).isEqualTo(0L);
}
}
@Test
public void checkTypes() {
ResultSet result = database.command("sql", "check database type Person");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
while (result.hasNext()) {
final Result row = result.next();
- Assertions.assertEquals("check database", row.getProperty("operation"));
- Assertions.assertEquals(TOTAL, (Long) row.getProperty("totalActiveRecords"));
- Assertions.assertEquals(TOTAL, (Long) row.getProperty("totalActiveVertices"));
- Assertions.assertEquals(0, (Long) row.getProperty("autoFix"));
+ assertThat(row.getProperty("operation")).isEqualTo("check database");
+ assertThat((Long) row.getProperty("totalActiveRecords")).isEqualTo(TOTAL);
+ assertThat((Long) row.getProperty("totalActiveVertices")).isEqualTo(TOTAL);
+ assertThat((Long) row.getProperty("autoFix")).isEqualTo(0);
}
result = database.command("sql", "check database type Person, Knows");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
while (result.hasNext()) {
final Result row = result.next();
- Assertions.assertEquals("check database", row.getProperty("operation"));
- Assertions.assertEquals(TOTAL * 2 - 1, (Long) row.getProperty("totalActiveRecords"));
- Assertions.assertEquals(TOTAL, (Long) row.getProperty("totalActiveVertices"));
- Assertions.assertEquals(TOTAL - 1, (Long) row.getProperty("totalActiveEdges"));
- Assertions.assertEquals(0, (Long) row.getProperty("autoFix"));
+ assertThat(row.getProperty("operation")).isEqualTo("check database");
+ assertThat((Long) row.getProperty("totalActiveRecords")).isEqualTo(TOTAL * 2 - 1);
+ assertThat((Long) row.getProperty("totalActiveVertices")).isEqualTo(TOTAL);
+ assertThat((Long) row.getProperty("totalActiveEdges")).isEqualTo(TOTAL - 1);
+ assertThat((Long) row.getProperty("autoFix")).isEqualTo(0);
}
}
@@ -88,20 +91,20 @@ public void checkRegularDeleteEdges() {
database.transaction(() -> database.command("sql", "delete from Knows"));
final ResultSet result = database.command("sql", "check database");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
while (result.hasNext()) {
final Result row = result.next();
- Assertions.assertEquals("check database", row.getProperty("operation"));
- Assertions.assertEquals(0L, (Long) row.getProperty("autoFix"));
- Assertions.assertEquals(TOTAL, (Long) row.getProperty("totalActiveVertices"));
- Assertions.assertEquals(0, (Long) row.getProperty("totalAllocatedEdges"));
- Assertions.assertEquals(0L, (Long) row.getProperty("totalActiveEdges"));
- Assertions.assertEquals(0, (Long) row.getProperty("totalDeletedRecords"));
- Assertions.assertEquals(0, ((Collection) row.getProperty("corruptedRecords")).size());
- Assertions.assertEquals(0L, (Long) row.getProperty("missingReferenceBack"));
- Assertions.assertEquals(0L, (Long) row.getProperty("invalidLinks"));
- Assertions.assertEquals(0, ((Collection) row.getProperty("warnings")).size());
+ assertThat(row.getProperty("operation")).isEqualTo("check database");
+ assertThat((Long) row.getProperty("autoFix")).isEqualTo(0L);
+ assertThat((Long) row.getProperty("totalActiveVertices")).isEqualTo(TOTAL);
+ assertThat((Long) row.getProperty("totalAllocatedEdges")).isEqualTo(TOTAL - 1);
+ assertThat((Long) row.getProperty("totalActiveEdges")).isEqualTo(0L);
+ assertThat((Long) row.getProperty("totalDeletedRecords")).isEqualTo(TOTAL - 1);
+ assertThat(((Collection) row.getProperty("corruptedRecords")).size()).isEqualTo(0);
+ assertThat((Long) row.getProperty("missingReferenceBack")).isEqualTo(0L);
+ assertThat((Long) row.getProperty("invalidLinks")).isEqualTo(0L);
+ assertThat(((Collection) row.getProperty("warnings")).size()).isEqualTo(0);
}
}
@@ -111,76 +114,76 @@ public void checkBrokenDeletedEdges() {
database.transaction(() -> {
final Iterator iter = database.iterateType("Knows", false);
- Assertions.assertTrue(iter.hasNext());
+ assertThat(iter.hasNext()).isTrue();
final Record edge = iter.next();
deletedEdge.set(edge.getIdentity());
- Assertions.assertEquals(root.getIdentity(), edge.asEdge().getOut());
+ assertThat(edge.asEdge().getOut()).isEqualTo(root.getIdentity());
// DELETE THE EDGE AT LOW LEVEL
database.getSchema().getBucketById(edge.getIdentity().getBucketId()).deleteRecord(edge.getIdentity());
});
ResultSet result = database.command("sql", "check database");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
while (result.hasNext()) {
final Result row = result.next();
- Assertions.assertEquals("check database", row.getProperty("operation"));
- Assertions.assertEquals(0, (Long) row.getProperty("autoFix"));
- Assertions.assertEquals(TOTAL, (Long) row.getProperty("totalActiveVertices"));
- Assertions.assertEquals(TOTAL - 2, (Long) row.getProperty("totalAllocatedEdges"));
- Assertions.assertEquals(TOTAL - 2, (Long) row.getProperty("totalActiveEdges"));
- Assertions.assertEquals(1, (Long) row.getProperty("totalDeletedRecords"));
- Assertions.assertEquals(1, ((Collection) row.getProperty("corruptedRecords")).size());
- Assertions.assertEquals(0, (Long) row.getProperty("missingReferenceBack"));
- Assertions.assertEquals(2, (Long) row.getProperty("invalidLinks"));
- Assertions.assertEquals(1, ((Collection) row.getProperty("warnings")).size());
+ assertThat(row.getProperty("operation")).isEqualTo("check database");
+ assertThat((Long) row.getProperty("autoFix")).isEqualTo(0);
+ assertThat((Long) row.getProperty("totalActiveVertices")).isEqualTo(TOTAL);
+ assertThat((Long) row.getProperty("totalAllocatedEdges")).isEqualTo(TOTAL - 1);
+ assertThat((Long) row.getProperty("totalActiveEdges")).isEqualTo(TOTAL - 2);
+ assertThat((Long) row.getProperty("totalDeletedRecords")).isEqualTo(1);
+ assertThat(((Collection) row.getProperty("corruptedRecords")).size()).isEqualTo(1);
+ assertThat((Long) row.getProperty("missingReferenceBack")).isEqualTo(0);
+ assertThat((Long) row.getProperty("invalidLinks")).isEqualTo(2);
+ assertThat(((Collection) row.getProperty("warnings")).size()).isEqualTo(1);
}
- Assertions.assertEquals(TOTAL - 2, countEdges(root.getIdentity()));
- Assertions.assertEquals(TOTAL - 1, countEdgesSegmentList(root.getIdentity()));
+ assertThat(countEdges(root.getIdentity())).isEqualTo(TOTAL - 2);
+ assertThat(countEdgesSegmentList(root.getIdentity())).isEqualTo(TOTAL - 1);
result = database.command("sql", "check database fix");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
while (result.hasNext()) {
final Result row = result.next();
- Assertions.assertEquals("check database", row.getProperty("operation"));
- Assertions.assertEquals(1, (Long) row.getProperty("autoFix"));
- Assertions.assertEquals(TOTAL, (Long) row.getProperty("totalActiveVertices"));
- Assertions.assertEquals(TOTAL - 2, (Long) row.getProperty("totalAllocatedEdges"));
- Assertions.assertEquals(TOTAL - 2, (Long) row.getProperty("totalActiveEdges"));
- Assertions.assertEquals(1, (Long) row.getProperty("totalDeletedRecords"));
- Assertions.assertEquals(1, ((Collection) row.getProperty("corruptedRecords")).size());
- Assertions.assertEquals(0, (Long) row.getProperty("missingReferenceBack"));
- Assertions.assertEquals(2, (Long) row.getProperty("invalidLinks"));
- Assertions.assertEquals(1, ((Collection) row.getProperty("warnings")).size());
+ assertThat(row.getProperty("operation")).isEqualTo("check database");
+ assertThat((Long) row.getProperty("autoFix")).isEqualTo(1);
+ assertThat((Long) row.getProperty("totalActiveVertices")).isEqualTo(TOTAL);
+ assertThat((Long) row.getProperty("totalAllocatedEdges")).isEqualTo(TOTAL - 1);
+ assertThat((Long) row.getProperty("totalActiveEdges")).isEqualTo(TOTAL - 2);
+ assertThat((Long) row.getProperty("totalDeletedRecords")).isEqualTo(1);
+ assertThat(((Collection) row.getProperty("corruptedRecords")).size()).isEqualTo(1);
+ assertThat((Long) row.getProperty("missingReferenceBack")).isEqualTo(0);
+ assertThat((Long) row.getProperty("invalidLinks")).isEqualTo(2);
+ assertThat(((Collection) row.getProperty("warnings")).size()).isEqualTo(1);
}
- Assertions.assertEquals(TOTAL - 2, countEdges(root.getIdentity()));
- Assertions.assertEquals(TOTAL - 2, countEdgesSegmentList(root.getIdentity()));
+ assertThat(countEdges(root.getIdentity())).isEqualTo(TOTAL - 2);
+ assertThat(countEdgesSegmentList(root.getIdentity())).isEqualTo(TOTAL - 2);
result = database.command("sql", "check database fix");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
while (result.hasNext()) {
final Result row = result.next();
- Assertions.assertEquals("check database", row.getProperty("operation"));
- Assertions.assertEquals(0, (Long) row.getProperty("autoFix"));
- Assertions.assertEquals(TOTAL, (Long) row.getProperty("totalActiveVertices"));
- Assertions.assertEquals(TOTAL - 2, (Long) row.getProperty("totalAllocatedEdges"));
- Assertions.assertEquals(TOTAL - 2, (Long) row.getProperty("totalActiveEdges"));
- Assertions.assertEquals(1, (Long) row.getProperty("totalDeletedRecords"));
- Assertions.assertEquals(0, ((Collection) row.getProperty("corruptedRecords")).size());
- Assertions.assertEquals(0, (Long) row.getProperty("missingReferenceBack"));
- Assertions.assertEquals(0, (Long) row.getProperty("invalidLinks"));
- Assertions.assertEquals(0, ((Collection) row.getProperty("warnings")).size());
+ assertThat(row.getProperty("operation")).isEqualTo("check database");
+ assertThat((Long) row.getProperty("autoFix")).isEqualTo(0);
+ assertThat((Long) row.getProperty("totalActiveVertices")).isEqualTo(TOTAL);
+ assertThat((Long) row.getProperty("totalAllocatedEdges")).isEqualTo(TOTAL - 2);
+ assertThat((Long) row.getProperty("totalActiveEdges")).isEqualTo(TOTAL - 2);
+ assertThat((Long) row.getProperty("totalDeletedRecords")).isEqualTo(1);
+ assertThat(((Collection) row.getProperty("corruptedRecords")).size()).isEqualTo(0);
+ assertThat((Long) row.getProperty("missingReferenceBack")).isEqualTo(0);
+ assertThat((Long) row.getProperty("invalidLinks")).isEqualTo(0);
+ assertThat(((Collection) row.getProperty("warnings")).size()).isEqualTo(0);
}
- Assertions.assertEquals(TOTAL - 2, countEdges(root.getIdentity()));
- Assertions.assertEquals(TOTAL - 2, countEdgesSegmentList(root.getIdentity()));
+ assertThat(countEdges(root.getIdentity())).isEqualTo(TOTAL - 2);
+ assertThat(countEdgesSegmentList(root.getIdentity())).isEqualTo(TOTAL - 2);
}
@Test
@@ -191,24 +194,24 @@ public void checkBrokenDeletedVertex() {
});
ResultSet result = database.command("sql", "check database");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
while (result.hasNext()) {
final Result row = result.next();
- Assertions.assertEquals("check database", row.getProperty("operation"));
- Assertions.assertEquals(0, (Long) row.getProperty("autoFix"));
- Assertions.assertEquals(TOTAL - 1, (Long) row.getProperty("totalActiveVertices"));
- Assertions.assertEquals(TOTAL - 1, (Long) row.getProperty("totalAllocatedEdges"));
- Assertions.assertEquals(TOTAL - 1, (Long) row.getProperty("totalActiveEdges"));
- Assertions.assertEquals(1, (Long) row.getProperty("totalDeletedRecords"));
- Assertions.assertEquals(TOTAL, ((Collection) row.getProperty("corruptedRecords")).size()); // ALL THE EDGES + ROOT VERTEX
- Assertions.assertEquals(0, (Long) row.getProperty("missingReferenceBack"));
- Assertions.assertEquals((TOTAL - 1) * 2, (Long) row.getProperty("invalidLinks"));
- Assertions.assertEquals(TOTAL - 1, ((Collection) row.getProperty("warnings")).size());
+ assertThat(row.getProperty("operation")).isEqualTo("check database");
+ assertThat((Long) row.getProperty("autoFix")).isEqualTo(0);
+ assertThat((Long) row.getProperty("totalActiveVertices")).isEqualTo(TOTAL - 1);
+ assertThat((Long) row.getProperty("totalAllocatedEdges")).isEqualTo(TOTAL - 1);
+ assertThat((Long) row.getProperty("totalActiveEdges")).isEqualTo(TOTAL - 1);
+ assertThat((Long) row.getProperty("totalDeletedRecords")).isEqualTo(1);
+ assertThat(((Collection) row.getProperty("corruptedRecords")).size()).isEqualTo(TOTAL); // ALL THE EDGES + ROOT VERTEX
+ assertThat((Long) row.getProperty("missingReferenceBack")).isEqualTo(0);
+ assertThat((Long) row.getProperty("invalidLinks")).isEqualTo((TOTAL - 1) * 2);
+ assertThat(((Collection) row.getProperty("warnings")).size()).isEqualTo(TOTAL - 1);
}
result = database.command("sql", "check database fix");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
Result row = result.next();
Assertions.assertEquals("check database", row.getProperty("operation"));
@@ -223,20 +226,20 @@ public void checkBrokenDeletedVertex() {
Assertions.assertEquals((TOTAL - 1L) * 2L, ((Collection) row.getProperty("warnings")).size());
result = database.command("sql", "check database");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
row = result.next();
- Assertions.assertEquals("check database", row.getProperty("operation"));
- Assertions.assertEquals(0, (Long) row.getProperty("autoFix"));
- Assertions.assertEquals(TOTAL - 1L, (Long) row.getProperty("totalActiveVertices"));
- Assertions.assertEquals(0, (Long) row.getProperty("totalAllocatedEdges"));
- Assertions.assertEquals(0, (Long) row.getProperty("totalActiveEdges"));
- Assertions.assertEquals(1, (Long) row.getProperty("totalDeletedRecords"));
- Assertions.assertEquals(0, ((Collection) row.getProperty("corruptedRecords")).size());
- Assertions.assertEquals(0, (Long) row.getProperty("missingReferenceBack"));
- Assertions.assertEquals(0, (Long) row.getProperty("invalidLinks"));
- Assertions.assertEquals(0, ((Collection) row.getProperty("warnings")).size());
+ assertThat(row.getProperty("operation")).isEqualTo("check database");
+ assertThat((Long) row.getProperty("autoFix")).isEqualTo(0);
+ assertThat((Long) row.getProperty("totalActiveVertices")).isEqualTo(TOTAL - 1);
+ assertThat((Long) row.getProperty("totalAllocatedEdges")).isEqualTo(TOTAL - 1);
+ assertThat((Long) row.getProperty("totalActiveEdges")).isEqualTo(0);
+ assertThat((Long) row.getProperty("totalDeletedRecords")).isEqualTo(TOTAL);
+ assertThat(((Collection) row.getProperty("corruptedRecords")).size()).isEqualTo(0);
+ assertThat((Long) row.getProperty("missingReferenceBack")).isEqualTo(0);
+ assertThat((Long) row.getProperty("invalidLinks")).isEqualTo(0);
+ assertThat(((Collection) row.getProperty("warnings")).size()).isEqualTo(0);
}
@Test
@@ -256,48 +259,48 @@ public void checkBrokenPage() {
});
ResultSet result = database.command("sql", "check database");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
Result row = result.next();
- Assertions.assertEquals("check database", row.getProperty("operation"));
- Assertions.assertTrue((Long) row.getProperty("totalErrors") > 0L);
- Assertions.assertEquals(0L, (Long) row.getProperty("autoFix"));
- Assertions.assertTrue((Long) row.getProperty("totalActiveVertices") < TOTAL);
- Assertions.assertEquals(TOTAL - 1, (Long) row.getProperty("totalAllocatedEdges"));
- Assertions.assertEquals(TOTAL - 1, (Long) row.getProperty("totalActiveEdges"));
- Assertions.assertEquals(0L, (Long) row.getProperty("totalDeletedRecords"));
- Assertions.assertEquals(0L, (Long) row.getProperty("missingReferenceBack"));
- Assertions.assertTrue((Long) row.getProperty("invalidLinks") > 0L);
- Assertions.assertTrue(((Collection) row.getProperty("warnings")).size() > 0L);
- Assertions.assertEquals(1, ((Collection) row.getProperty("rebuiltIndexes")).size());
- Assertions.assertTrue(((Collection) row.getProperty("corruptedRecords")).size() > 0L);
+ assertThat(row.getProperty("operation")).isEqualTo("check database");
+ assertThat((Long) row.getProperty("totalErrors") > 0L).isTrue();
+ assertThat((Long) row.getProperty("autoFix")).isEqualTo(0L);
+ assertThat((Long) row.getProperty("totalActiveVertices") < TOTAL).isTrue();
+ assertThat((Long) row.getProperty("totalAllocatedEdges")).isEqualTo(TOTAL - 1);
+ assertThat((Long) row.getProperty("totalActiveEdges")).isEqualTo(TOTAL - 1);
+ assertThat((Long) row.getProperty("totalDeletedRecords")).isEqualTo(0L);
+ assertThat((Long) row.getProperty("missingReferenceBack")).isEqualTo(0L);
+ assertThat((Long) row.getProperty("invalidLinks") > 0L).isTrue();
+ assertThat(((Collection) row.getProperty("warnings")).size() > 0L).isTrue();
+ assertThat(((Collection) row.getProperty("rebuiltIndexes")).size()).isEqualTo(1);
+ assertThat(((Collection) row.getProperty("corruptedRecords")).size() > 0L).isTrue();
result = database.command("sql", "check database fix");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
row = result.next();
- Assertions.assertTrue((Long) row.getProperty("autoFix") > 0L);
- Assertions.assertEquals(0L, (Long) row.getProperty("totalActiveEdges"));
- Assertions.assertEquals(1, ((Collection) row.getProperty("rebuiltIndexes")).size());
- Assertions.assertTrue((Long) row.getProperty("totalActiveVertices") < TOTAL);
- Assertions.assertTrue(((Collection) row.getProperty("corruptedRecords")).size() > 0L);
+ assertThat((Long) row.getProperty("autoFix") > 0L).isTrue();
+ assertThat((Long) row.getProperty("totalActiveEdges")).isEqualTo(0L);
+ assertThat(((Collection) row.getProperty("rebuiltIndexes")).size()).isEqualTo(1);
+ assertThat((Long) row.getProperty("totalActiveVertices") < TOTAL).isTrue();
+ assertThat(((Collection) row.getProperty("corruptedRecords")).size() > 0L).isTrue();
result = database.command("sql", "check database");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
row = result.next();
- Assertions.assertEquals(0L, (Long) row.getProperty("autoFix"));
- Assertions.assertEquals(0L, (Long) row.getProperty("totalErrors"));
- Assertions.assertEquals(0L, (Long) row.getProperty("autoFix"));
- Assertions.assertEquals(0L, (Long) row.getProperty("missingReferenceBack"));
- Assertions.assertEquals(0L, (Long) row.getProperty("invalidLinks"));
- Assertions.assertEquals(0L, ((Collection) row.getProperty("warnings")).size());
- Assertions.assertEquals(0, ((Collection) row.getProperty("rebuiltIndexes")).size());
- Assertions.assertEquals(0L, ((Collection) row.getProperty("corruptedRecords")).size());
+ assertThat((Long) row.getProperty("autoFix")).isEqualTo(0L);
+ assertThat((Long) row.getProperty("totalErrors")).isEqualTo(0L);
+ assertThat((Long) row.getProperty("autoFix")).isEqualTo(0L);
+ assertThat((Long) row.getProperty("missingReferenceBack")).isEqualTo(0L);
+ assertThat((Long) row.getProperty("invalidLinks")).isEqualTo(0L);
+ assertThat(((Collection) row.getProperty("warnings")).size()).isEqualTo(0L);
+ assertThat(((Collection) row.getProperty("rebuiltIndexes")).size()).isEqualTo(0);
+ assertThat(((Collection) row.getProperty("corruptedRecords")).size()).isEqualTo(0L);
// CHECK CORRUPTED RECORD ARE NOT INDEXED ANYMORE
final List indexes = database.getSchema().getType("Person").getIndexesByProperties("id");
- Assertions.assertEquals(1, indexes.size());
+ assertThat(indexes.size()).isEqualTo(1);
- Assertions.assertEquals((Long) row.getProperty("totalActiveVertices"), indexes.get(0).countEntries());
+ assertThat(indexes.get(0).countEntries()).isEqualTo((Long) row.getProperty("totalActiveVertices"));
}
@Override
diff --git a/engine/src/test/java/com/arcadedb/database/DataEncryptionTest.java b/engine/src/test/java/com/arcadedb/database/DataEncryptionTest.java
new file mode 100644
index 0000000000..82e648e4b9
--- /dev/null
+++ b/engine/src/test/java/com/arcadedb/database/DataEncryptionTest.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright © 2024-present Arcade Data Ltd (info@arcadedata.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-FileCopyrightText: 2024-present Arcade Data Ltd (info@arcadedata.com)
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package com.arcadedb.database;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import java.security.NoSuchAlgorithmException;
+import java.security.spec.InvalidKeySpecException;
+import java.util.concurrent.atomic.AtomicReference;
+
+import javax.crypto.NoSuchPaddingException;
+
+import org.junit.jupiter.api.Test;
+
+import com.arcadedb.TestHelper;
+import com.arcadedb.graph.Vertex;
+import com.arcadedb.graph.Vertex.DIRECTION;
+
+/**
+ * @author Pawel Maslej
+ * @since 1 Jul 2024
+ */
+class DataEncryptionTest extends TestHelper {
+
+ String password = "password";
+ String salt = "salt";
+
+ @Test
+ void dataIsEncrypted() throws NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException {
+ database.setDataEncryption(DefaultDataEncryption.useDefaults(DefaultDataEncryption.getSecretKeyFromPasswordUsingDefaults(password, salt)));
+
+ database.command("sql", "create vertex type Person");
+ database.command("sql", "create property Person.id string");
+ database.command("sql", "create index on Person (id) unique");
+ database.command("sql", "create property Person.name string");
+ database.command("sql", "create edge type Knows");
+
+ var v1Id = new AtomicReference(null);
+ var v2Id = new AtomicReference(null);
+
+ database.transaction(() -> {
+ var v1 = database.newVertex("Person").set("name", "John").save();
+ var v2 = database.newVertex("Person").set("name", "Doe").save();
+ v1.newEdge("Knows", v2, false, "since", 2024);
+ verify(v1, v2, true);
+ v1Id.set(v1.getIdentity());
+ v2Id.set(v2.getIdentity());
+ });
+ verify(v1Id.get(), v2Id.get(), true);
+
+ database.setDataEncryption(null);
+ verify(v1Id.get(), v2Id.get(), false);
+
+ reopenDatabase();
+ verify(v1Id.get(), v2Id.get(), false);
+
+ database.setDataEncryption(DefaultDataEncryption.useDefaults(DefaultDataEncryption.getSecretKeyFromPasswordUsingDefaults(password, salt)));
+ verify(v1Id.get(), v2Id.get(), true);
+ }
+
+ private void verify(RID rid1, RID rid2, boolean isEquals) {
+ database.transaction(() -> {
+ var p1 = database.lookupByRID(rid1, true).asVertex();
+ var p2 = database.lookupByRID(rid2, true).asVertex();
+ verify(p1, p2, isEquals);
+ });
+ }
+
+ private void verify(Vertex p1, Vertex p2, boolean isEquals) {
+ if (isEquals) {
+ assertThat(p1.get("name")).isEqualTo("John");
+ assertThat(p2.get("name")).isEqualTo("Doe");
+ assertThat(p1.getEdges(DIRECTION.OUT, "Knows").iterator().next().get("since")).isEqualTo(2024);
+ } else {
+ assertThat(((String) p1.get("name")).contains("John")).isFalse();
+ assertThat(((String) p2.get("name")).contains("Doe")).isFalse();
+ assertThat(p1.getEdges(DIRECTION.OUT, "Knows").iterator().next().get("since").toString().contains("2024")).isFalse();
+ }
+ }
+}
diff --git a/engine/src/test/java/com/arcadedb/database/DatabaseFactoryTest.java b/engine/src/test/java/com/arcadedb/database/DatabaseFactoryTest.java
index 2095afd998..a8424b3e7f 100644
--- a/engine/src/test/java/com/arcadedb/database/DatabaseFactoryTest.java
+++ b/engine/src/test/java/com/arcadedb/database/DatabaseFactoryTest.java
@@ -21,9 +21,12 @@
import com.arcadedb.TestHelper;
import com.arcadedb.exception.DatabaseOperationException;
import com.arcadedb.security.SecurityManager;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThatExceptionOfType;
+
/**
* @author Luca Garulli (l.garulli@arcadedata.com)
**/
@@ -33,14 +36,14 @@ class DatabaseFactoryTest extends TestHelper {
void invalidFactories() {
try {
new DatabaseFactory(null);
- Assertions.fail();
+ fail("");
} catch (final IllegalArgumentException e) {
// EXPECTED
}
try {
new DatabaseFactory("");
- Assertions.fail();
+ fail("");
} catch (final IllegalArgumentException e) {
// EXPECTED
}
@@ -50,7 +53,7 @@ void invalidFactories() {
void testGetterSetter() {
final DatabaseFactory f = new DatabaseFactory("test/");
f.setAutoTransaction(true);
- Assertions.assertNotNull(f.getContextConfiguration());
+ assertThat(f.getContextConfiguration()).isNotNull();
final SecurityManager security = new SecurityManager() {
@Override
@@ -58,7 +61,7 @@ public void updateSchema(final DatabaseInternal database) {
}
};
f.setSecurity(security);
- Assertions.assertEquals(security, f.getSecurity());
+ assertThat(f.getSecurity()).isEqualTo(security);
}
@Test
@@ -68,7 +71,7 @@ void testDatabaseRegistration() {
DatabaseFactory.getActiveDatabaseInstances().contains(db);
DatabaseFactory.removeActiveDatabaseInstance(db.getDatabasePath());
- Assertions.assertNull(DatabaseFactory.getActiveDatabaseInstance(db.getDatabasePath()));
+ assertThat(DatabaseFactory.getActiveDatabaseInstance(db.getDatabasePath())).isNull();
db.drop();
f.close();
@@ -79,10 +82,10 @@ void testDatabaseRegistrationWithDifferentPathTypes() {
final DatabaseFactory f = new DatabaseFactory("target/path/to/database");
final Database db = f.exists() ? f.open() : f.create();
- Assertions.assertEquals(db, DatabaseFactory.getActiveDatabaseInstance("target/path/to/database"));
+ assertThat(DatabaseFactory.getActiveDatabaseInstance("target/path/to/database")).isEqualTo(db);
if (System.getProperty("os.name").toLowerCase().contains("windows"))
- Assertions.assertEquals(db, DatabaseFactory.getActiveDatabaseInstance("target\\path\\to\\database"));
- Assertions.assertEquals(db, DatabaseFactory.getActiveDatabaseInstance("./target/path/../../target/path/to/database"));
+ assertThat(DatabaseFactory.getActiveDatabaseInstance("target\\path\\to\\database")).isEqualTo(db);
+ assertThat(DatabaseFactory.getActiveDatabaseInstance("./target/path/../../target/path/to/database")).isEqualTo(db);
db.drop();
f.close();
@@ -97,7 +100,7 @@ void testDuplicatedDatabaseCreationWithDifferentPathTypes() {
final Database db = f1.create();
final DatabaseFactory f2 = new DatabaseFactory(".\\path\\to\\database");
- Assertions.assertThrows(DatabaseOperationException.class, () -> f2.create());
+ assertThatExceptionOfType(DatabaseOperationException.class).isThrownBy(() -> f2.create());
db.drop();
f1.close();
diff --git a/engine/src/test/java/com/arcadedb/database/DefaultDataEncryptionTest.java b/engine/src/test/java/com/arcadedb/database/DefaultDataEncryptionTest.java
new file mode 100644
index 0000000000..477e624891
--- /dev/null
+++ b/engine/src/test/java/com/arcadedb/database/DefaultDataEncryptionTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright © 2024-present Arcade Data Ltd (info@arcadedata.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-FileCopyrightText: 2024-present Arcade Data Ltd (info@arcadedata.com)
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package com.arcadedb.database;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.nio.ByteBuffer;
+import java.security.NoSuchAlgorithmException;
+import java.security.spec.InvalidKeySpecException;
+
+import javax.crypto.NoSuchPaddingException;
+import javax.crypto.SecretKey;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+/**
+ * @author Pawel Maslej
+ * @since 1 Jul 2024
+ */
+class DefaultDataEncryptionTest {
+ static SecretKey key;
+
+ @BeforeAll
+ public static void beforeAll() throws NoSuchAlgorithmException, InvalidKeySpecException {
+ String password = "password";
+ String salt = "salt";
+ key = DefaultDataEncryption.getSecretKeyFromPasswordUsingDefaults(password, salt);
+ }
+
+ @Test
+ void testEncryptionOfString() throws NoSuchAlgorithmException, NoSuchPaddingException {
+ var dde = DefaultDataEncryption.useDefaults(key);
+ String data = "data";
+ byte[] encryptedData = dde.encrypt(data.getBytes());
+ String decryptedData = new String(dde.decrypt(encryptedData));
+ assertThat(decryptedData).isEqualTo(data);
+ }
+
+ @Test
+ void testEncryptionOfDouble() throws NoSuchAlgorithmException, NoSuchPaddingException {
+ var dde = DefaultDataEncryption.useDefaults(key);
+ double data = 1000000d;
+ byte[] encryptedData = dde.encrypt(ByteBuffer.allocate(8).putLong(Double.doubleToLongBits(data)).array());
+ var decryptedData = Double.longBitsToDouble(ByteBuffer.wrap(dde.decrypt(encryptedData)).getLong());
+ assertThat(decryptedData).isEqualTo(data);
+ }
+}
diff --git a/engine/src/test/java/com/arcadedb/database/RecordFactoryTest.java b/engine/src/test/java/com/arcadedb/database/RecordFactoryTest.java
index fa689c1f1b..6fedc24ce0 100644
--- a/engine/src/test/java/com/arcadedb/database/RecordFactoryTest.java
+++ b/engine/src/test/java/com/arcadedb/database/RecordFactoryTest.java
@@ -30,9 +30,11 @@
import com.arcadedb.schema.EdgeType;
import com.arcadedb.schema.VertexType;
import com.arcadedb.serializer.BinaryTypes;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
/**
* @author Luca Garulli (l.garulli@arcadedata.com)
**/
@@ -44,27 +46,27 @@ void newImmutableRecord() {
final DocumentType documentType = database.getSchema().createDocumentType("Document");
final Record document = ((DatabaseInternal) database).getRecordFactory().newImmutableRecord(database, documentType, EMPTY_RID, Document.RECORD_TYPE);
- Assertions.assertTrue(document instanceof Document);
+ assertThat(document instanceof Document).isTrue();
final VertexType vertexType = database.getSchema().createVertexType("Vertex");
final Record vertex = ((DatabaseInternal) database).getRecordFactory().newImmutableRecord(database, vertexType, EMPTY_RID, Vertex.RECORD_TYPE);
- Assertions.assertTrue(vertex instanceof Vertex);
+ assertThat(vertex instanceof Vertex).isTrue();
final EdgeType edgeType = database.getSchema().createEdgeType("Edge");
final Record edge = ((DatabaseInternal) database).getRecordFactory().newImmutableRecord(database, edgeType, EMPTY_RID, Edge.RECORD_TYPE);
- Assertions.assertTrue(edge instanceof Edge);
+ assertThat(edge instanceof Edge).isTrue();
final Record edgeSegment = ((DatabaseInternal) database).getRecordFactory().newImmutableRecord(database, null, EMPTY_RID, EdgeSegment.RECORD_TYPE);
- Assertions.assertTrue(edgeSegment instanceof EdgeSegment);
+ assertThat(edgeSegment instanceof EdgeSegment).isTrue();
final DocumentType embeddedDocumentType = database.getSchema().createDocumentType("EmbeddedDocument");
final Record embeddedDocument = ((DatabaseInternal) database).getRecordFactory()
.newImmutableRecord(database, embeddedDocumentType, EMPTY_RID, EmbeddedDocument.RECORD_TYPE);
- Assertions.assertTrue(embeddedDocument instanceof EmbeddedDocument);
+ assertThat(embeddedDocument instanceof EmbeddedDocument).isTrue();
try {
((DatabaseInternal) database).getRecordFactory().newImmutableRecord(database, embeddedDocumentType, EMPTY_RID, (byte) 'Z');
- Assertions.fail();
+ fail("");
} catch (final DatabaseMetadataException e) {
// EXPECTED
}
@@ -80,7 +82,7 @@ void testNewImmutableRecord() {
final DocumentType documentType = database.getSchema().createDocumentType("Document");
final Record document = ((DatabaseInternal) database).getRecordFactory().newImmutableRecord(database, documentType, EMPTY_RID, binary, null);
- Assertions.assertTrue(document instanceof Document);
+ assertThat(document instanceof Document).isTrue();
binary.clear();
binary.putByte(Vertex.RECORD_TYPE);
@@ -92,7 +94,7 @@ void testNewImmutableRecord() {
final VertexType vertexType = database.getSchema().createVertexType("Vertex");
final Record vertex = ((DatabaseInternal) database).getRecordFactory().newImmutableRecord(database, vertexType, EMPTY_RID, binary, null);
- Assertions.assertTrue(vertex instanceof Vertex);
+ assertThat(vertex instanceof Vertex).isTrue();
binary.clear();
binary.putByte(Edge.RECORD_TYPE);
@@ -102,14 +104,14 @@ void testNewImmutableRecord() {
final EdgeType edgeType = database.getSchema().createEdgeType("Edge");
final Record edge = ((DatabaseInternal) database).getRecordFactory().newImmutableRecord(database, edgeType, EMPTY_RID, binary, null);
- Assertions.assertTrue(edge instanceof Edge);
+ assertThat(edge instanceof Edge).isTrue();
binary.clear();
binary.putByte(EdgeSegment.RECORD_TYPE);
binary.flip();
final Record edgeSegment = ((DatabaseInternal) database).getRecordFactory().newImmutableRecord(database, null, EMPTY_RID, binary, null);
- Assertions.assertTrue(edgeSegment instanceof EdgeSegment);
+ assertThat(edgeSegment instanceof EdgeSegment).isTrue();
binary.clear();
binary.putByte(EmbeddedDocument.RECORD_TYPE);
@@ -118,7 +120,7 @@ void testNewImmutableRecord() {
final DocumentType embeddedDocumentType = database.getSchema().createDocumentType("EmbeddedDocument");
final Record embeddedDocument = ((DatabaseInternal) database).getRecordFactory()
.newImmutableRecord(database, embeddedDocumentType, EMPTY_RID, binary, null);
- Assertions.assertTrue(embeddedDocument instanceof EmbeddedDocument);
+ assertThat(embeddedDocument instanceof EmbeddedDocument).isTrue();
binary.clear();
binary.putByte((byte) 'Z');
@@ -126,7 +128,7 @@ void testNewImmutableRecord() {
try {
((DatabaseInternal) database).getRecordFactory().newImmutableRecord(database, embeddedDocumentType, EMPTY_RID, binary, null);
- Assertions.fail();
+ fail("");
} catch (final DatabaseMetadataException e) {
// EXPECTED
}
@@ -142,7 +144,7 @@ void newMutableRecord() {
final DocumentType documentType = database.getSchema().createDocumentType("Document");
final Record document = ((DatabaseInternal) database).getRecordFactory().newMutableRecord(database, documentType, EMPTY_RID, binary, null);
- Assertions.assertTrue(document instanceof MutableDocument);
+ assertThat(document instanceof MutableDocument).isTrue();
binary.clear();
binary.putByte(Vertex.RECORD_TYPE);
@@ -154,7 +156,7 @@ void newMutableRecord() {
final VertexType vertexType = database.getSchema().createVertexType("Vertex");
final Record vertex = ((DatabaseInternal) database).getRecordFactory().newMutableRecord(database, vertexType, EMPTY_RID, binary, null);
- Assertions.assertTrue(vertex instanceof MutableVertex);
+ assertThat(vertex instanceof MutableVertex).isTrue();
binary.clear();
binary.putByte(Edge.RECORD_TYPE);
@@ -164,14 +166,14 @@ void newMutableRecord() {
final EdgeType edgeType = database.getSchema().createEdgeType("Edge");
final Record edge = ((DatabaseInternal) database).getRecordFactory().newMutableRecord(database, edgeType, EMPTY_RID, binary, null);
- Assertions.assertTrue(edge instanceof MutableEdge);
+ assertThat(edge instanceof MutableEdge).isTrue();
binary.clear();
binary.putByte(EdgeSegment.RECORD_TYPE);
binary.flip();
final Record edgeSegment = ((DatabaseInternal) database).getRecordFactory().newMutableRecord(database, null, EMPTY_RID, binary, null);
- Assertions.assertTrue(edgeSegment instanceof MutableEdgeSegment);
+ assertThat(edgeSegment instanceof MutableEdgeSegment).isTrue();
binary.clear();
binary.putByte(EmbeddedDocument.RECORD_TYPE);
@@ -179,7 +181,7 @@ void newMutableRecord() {
final DocumentType embeddedDocumentType = database.getSchema().createDocumentType("EmbeddedDocument");
final Record embeddedDocument = ((DatabaseInternal) database).getRecordFactory().newMutableRecord(database, embeddedDocumentType, EMPTY_RID, binary, null);
- Assertions.assertTrue(embeddedDocument instanceof MutableEmbeddedDocument);
+ assertThat(embeddedDocument instanceof MutableEmbeddedDocument).isTrue();
binary.clear();
binary.putByte((byte) 'Z');
@@ -187,7 +189,7 @@ void newMutableRecord() {
try {
((DatabaseInternal) database).getRecordFactory().newMutableRecord(database, embeddedDocumentType, EMPTY_RID, binary, null);
- Assertions.fail();
+ fail("");
} catch (final DatabaseMetadataException e) {
// EXPECTED
}
diff --git a/engine/src/test/java/com/arcadedb/engine/BloomFilterTest.java b/engine/src/test/java/com/arcadedb/engine/BloomFilterTest.java
index 4ee12ad845..e98fba7b4c 100644
--- a/engine/src/test/java/com/arcadedb/engine/BloomFilterTest.java
+++ b/engine/src/test/java/com/arcadedb/engine/BloomFilterTest.java
@@ -19,9 +19,10 @@
package com.arcadedb.engine;
import com.arcadedb.database.Binary;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class BloomFilterTest {
@Test
public void testBloomFilter() {
@@ -36,12 +37,12 @@ private void testValidity(final BufferBloomFilter bf, final int count) {
if (bf.mightContain(i))
++might;
- Assertions.assertTrue(might < count);
+ assertThat(might < count).isTrue();
for (int i = 0; i < count; i++)
bf.add(i);
for (int i = 0; i < count; i++)
- Assertions.assertTrue(bf.mightContain(i));
+ assertThat(bf.mightContain(i)).isTrue();
}
}
diff --git a/engine/src/test/java/com/arcadedb/engine/DeleteAllTest.java b/engine/src/test/java/com/arcadedb/engine/DeleteAllTest.java
index 0c03c14ed7..665f79e700 100644
--- a/engine/src/test/java/com/arcadedb/engine/DeleteAllTest.java
+++ b/engine/src/test/java/com/arcadedb/engine/DeleteAllTest.java
@@ -5,12 +5,14 @@
import com.arcadedb.graph.MutableVertex;
import com.arcadedb.query.sql.executor.ResultSet;
import com.arcadedb.utility.FileUtils;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.Test;
import java.io.*;
import java.util.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class DeleteAllTest {
private final static int TOT_RECORDS = 100_000;
private final static String VERTEX_TYPE = "Product";
@@ -28,10 +30,10 @@ public void testCreateAndDeleteGraph() {
db.getSchema().createEdgeType(EDGE_TYPE, 1);
for (int i = 0; i < CYCLES; i++) {
- System.out.println("Cycle " + i);
- List.of(new File(databaseFactory.getDatabasePath()).listFiles())
- .forEach(f -> System.out.println("- " + f.getName() + ": " + FileUtils.getSizeAsString(
- f.length())));
+ //System.out.println("Cycle " + i);
+// List.of(new File(databaseFactory.getDatabasePath()).listFiles())
+// .forEach(f -> System.out.println("- " + f.getName() + ": " + FileUtils.getSizeAsString(
+// f.length())));
db.transaction(() -> {
final MutableVertex root = db.newVertex(VERTEX_TYPE)//
@@ -48,18 +50,18 @@ public void testCreateAndDeleteGraph() {
});
db.transaction(() -> {
- Assertions.assertEquals(TOT_RECORDS, db.countType(VERTEX_TYPE, true));
- Assertions.assertEquals(TOT_RECORDS - 1, db.countType(EDGE_TYPE, true));
+ assertThat(db.countType(VERTEX_TYPE, true)).isEqualTo(TOT_RECORDS);
+ assertThat(db.countType(EDGE_TYPE, true)).isEqualTo(TOT_RECORDS - 1);
db.command("sql", "delete from " + VERTEX_TYPE);
- Assertions.assertEquals(0, db.countType(VERTEX_TYPE, true));
- Assertions.assertEquals(0, db.countType(EDGE_TYPE, true));
+ assertThat(db.countType(VERTEX_TYPE, true)).isEqualTo(0);
+ assertThat(db.countType(EDGE_TYPE, true)).isEqualTo(0);
});
}
final ResultSet result = db.command("sql", "check database");
- System.out.println(result.nextIfAvailable().toJSON());
+// System.out.println(result.nextIfAvailable().toJSON());
} finally {
if (databaseFactory.exists())
diff --git a/engine/src/test/java/com/arcadedb/engine/TestInsertAndSelectWithThreadBucketSelectionStrategy.java b/engine/src/test/java/com/arcadedb/engine/TestInsertAndSelectWithThreadBucketSelectionStrategy.java
index 9a442a590e..c9e530c790 100644
--- a/engine/src/test/java/com/arcadedb/engine/TestInsertAndSelectWithThreadBucketSelectionStrategy.java
+++ b/engine/src/test/java/com/arcadedb/engine/TestInsertAndSelectWithThreadBucketSelectionStrategy.java
@@ -8,12 +8,13 @@
import com.arcadedb.schema.DocumentType;
import com.arcadedb.schema.Schema;
import com.arcadedb.schema.Type;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.time.*;
import java.time.format.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class TestInsertAndSelectWithThreadBucketSelectionStrategy {
@Test
public void testInsertAndSelectWithThreadBucketSelectionStrategy() {
@@ -54,12 +55,12 @@ public void testInsertAndSelectWithThreadBucketSelectionStrategy() {
database.begin();
String sqlString = "UPDATE Product SET name = ?, type = ?, start = ?, stop = ?, v = ? UPSERT WHERE name = ?";
try (ResultSet resultSet = database.command("sql", sqlString, name1, type, validityStart, validityStop, version1, name1)) {
- Assertions.assertTrue((long) resultSet.nextIfAvailable().getProperty("count", 0) == 1);
+ assertThat((long) resultSet.nextIfAvailable().getProperty("count", 0)).isEqualTo(1);
}
// database.commit();
// database.begin();
try (ResultSet resultSet = database.command("sql", sqlString, name2, type, validityStart, validityStop, version2, name2)) {
- Assertions.assertTrue((long) resultSet.nextIfAvailable().getProperty("count", 0) == 1);
+ assertThat((long) resultSet.nextIfAvailable().getProperty("count", 0)).isEqualTo(1);
}
database.commit();
} catch (Exception e) {
@@ -73,10 +74,10 @@ public void testInsertAndSelectWithThreadBucketSelectionStrategy() {
String sqlString = "SELECT name, start, stop FROM Product WHERE type = ? AND start <= ? AND stop >= ? ORDER BY start DESC, stop DESC, v DESC LIMIT 1";
int total = 0;
try (ResultSet resultSet = database.query("sql", sqlString, type, queryStart, queryStop)) {
- Assertions.assertTrue(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isTrue();
++total;
}
- Assertions.assertEquals(1, total);
+ assertThat(total).isEqualTo(1);
} finally {
database.drop();
}
diff --git a/engine/src/test/java/com/arcadedb/event/DatabaseEventsTest.java b/engine/src/test/java/com/arcadedb/event/DatabaseEventsTest.java
index c6025af904..c9dae6355a 100644
--- a/engine/src/test/java/com/arcadedb/event/DatabaseEventsTest.java
+++ b/engine/src/test/java/com/arcadedb/event/DatabaseEventsTest.java
@@ -22,11 +22,14 @@
import com.arcadedb.graph.MutableVertex;
import com.arcadedb.schema.Schema;
import com.arcadedb.schema.Type;
+
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.concurrent.atomic.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
/**
* TODO: ADD TESTS FOR DOCUMENTS AND EDGES
*
@@ -53,16 +56,16 @@ public void testBeforeCreate() {
database.transaction(() -> {
final MutableVertex v1 = database.newVertex("Vertex").set("id", "test");
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
v1.save();
- Assertions.assertEquals(1, counter.get());
- Assertions.assertEquals(1, database.countType("Vertex", true));
+ assertThat(counter.get()).isEqualTo(1);
+ assertThat(database.countType("Vertex", true)).isEqualTo(1);
final MutableVertex v2 = database.newVertex("Vertex").set("id", "test2");
- Assertions.assertEquals(1, counter.get());
+ assertThat(counter.get()).isEqualTo(1);
v2.save();
- Assertions.assertEquals(2, counter.get());
- Assertions.assertEquals(1, database.countType("Vertex", true));
+ assertThat(counter.get()).isEqualTo(2);
+ assertThat(database.countType("Vertex", true)).isEqualTo(1);
});
} finally {
@@ -80,16 +83,16 @@ public void testAfterCreate() {
database.transaction(() -> {
final MutableVertex v1 = database.newVertex("Vertex").set("id", "test");
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
v1.save();
- Assertions.assertEquals(1, counter.get());
- Assertions.assertEquals(1, database.countType("Vertex", true));
+ assertThat(counter.get()).isEqualTo(1);
+ assertThat(database.countType("Vertex", true)).isEqualTo(1);
final MutableVertex v2 = database.newVertex("Vertex").set("id", "test2");
- Assertions.assertEquals(1, counter.get());
+ assertThat(counter.get()).isEqualTo(1);
v2.save();
- Assertions.assertEquals(2, counter.get());
- Assertions.assertEquals(2, database.countType("Vertex", true));
+ assertThat(counter.get()).isEqualTo(2);
+ assertThat(database.countType("Vertex", true)).isEqualTo(2);
});
} finally {
@@ -110,16 +113,16 @@ public void testBeforeRead() {
database.transaction(() -> {
final MutableVertex v1 = database.newVertex("Vertex").set("id", "test");
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
v1.save();
- Assertions.assertEquals(0, counter.get());
- Assertions.assertEquals(1, database.countType("Vertex", true));
+ assertThat(counter.get()).isEqualTo(0);
+ assertThat(database.countType("Vertex", true)).isEqualTo(1);
});
database.transaction(() -> {
final MutableVertex v1 = database.iterateType("Vertex", true).next().asVertex().modify();
v1.set("modified2", true);
- Assertions.assertEquals(1, counter.get());
+ assertThat(counter.get()).isEqualTo(1);
});
} finally {
@@ -140,28 +143,28 @@ public void testBeforeUpdate() {
database.transaction(() -> {
final MutableVertex v1 = database.newVertex("Vertex").set("id", "test");
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
v1.save();
- Assertions.assertEquals(0, counter.get());
- Assertions.assertEquals(1, database.countType("Vertex", true));
+ assertThat(counter.get()).isEqualTo(0);
+ assertThat(database.countType("Vertex", true)).isEqualTo(1);
v1.set("modified", true);
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
v1.save();
- Assertions.assertEquals(1, counter.get());
+ assertThat(counter.get()).isEqualTo(1);
});
database.transaction(() -> {
final MutableVertex v1 = database.iterateType("Vertex", true).next().asVertex().modify();
v1.set("modified2", true);
- Assertions.assertEquals(1, counter.get());
+ assertThat(counter.get()).isEqualTo(1);
v1.save();
- Assertions.assertEquals(2, counter.get());
+ assertThat(counter.get()).isEqualTo(2);
});
- Assertions.assertFalse(database.iterateType("Vertex", true).next().asVertex().has("modified2"));
+ assertThat(database.iterateType("Vertex", true).next().asVertex().has("modified2")).isFalse();
} finally {
database.getEvents().unregisterListener(listener);
@@ -181,16 +184,16 @@ public void testAfterRead() {
database.transaction(() -> {
final MutableVertex v1 = database.newVertex("Vertex").set("id", "test");
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
v1.save();
- Assertions.assertEquals(0, counter.get());
- Assertions.assertEquals(1, database.countType("Vertex", true));
+ assertThat(counter.get()).isEqualTo(0);
+ assertThat(database.countType("Vertex", true)).isEqualTo(1);
});
database.transaction(() -> {
final MutableVertex v1 = database.iterateType("Vertex", true).next().asVertex().modify();
v1.set("modified2", true);
- Assertions.assertEquals(1, counter.get());
+ assertThat(counter.get()).isEqualTo(1);
});
} finally {
@@ -208,16 +211,16 @@ public void testAfterUpdate() {
database.transaction(() -> {
final MutableVertex v1 = database.newVertex("Vertex").set("id", "test");
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
v1.save();
- Assertions.assertEquals(0, counter.get());
- Assertions.assertEquals(1, database.countType("Vertex", true));
+ assertThat(counter.get()).isEqualTo(0);
+ assertThat(database.countType("Vertex", true)).isEqualTo(1);
v1.set("modified", true);
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
v1.save();
- Assertions.assertEquals(1, counter.get());
+ assertThat(counter.get()).isEqualTo(1);
});
} finally {
@@ -238,29 +241,29 @@ public void testBeforeDelete() {
database.transaction(() -> {
final MutableVertex v1 = database.newVertex("Vertex").set("id", "test");
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
v1.save();
- Assertions.assertEquals(0, counter.get());
- Assertions.assertEquals(1, database.countType("Vertex", true));
+ assertThat(counter.get()).isEqualTo(0);
+ assertThat(database.countType("Vertex", true)).isEqualTo(1);
v1.set("modified", true);
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
v1.save();
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
});
database.transaction(() -> {
final MutableVertex v1 = database.iterateType("Vertex", true).next().asVertex().modify();
v1.delete();
- Assertions.assertEquals(1, counter.get());
+ assertThat(counter.get()).isEqualTo(1);
final MutableVertex v2 = database.newVertex("Vertex").set("id", "test2").save();
v2.delete();
- Assertions.assertEquals(2, counter.get());
+ assertThat(counter.get()).isEqualTo(2);
});
- Assertions.assertEquals(1, database.countType("Vertex", true));
+ assertThat(database.countType("Vertex", true)).isEqualTo(1);
} finally {
database.getEvents().unregisterListener(listener);
@@ -277,29 +280,29 @@ public void testAfterDelete() {
database.transaction(() -> {
final MutableVertex v1 = database.newVertex("Vertex").set("id", "test");
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
v1.save();
- Assertions.assertEquals(0, counter.get());
- Assertions.assertEquals(1, database.countType("Vertex", true));
+ assertThat(counter.get()).isEqualTo(0);
+ assertThat(database.countType("Vertex", true)).isEqualTo(1);
v1.set("modified", true);
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
v1.save();
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
});
database.transaction(() -> {
final MutableVertex v1 = database.iterateType("Vertex", true).next().asVertex().modify();
v1.delete();
- Assertions.assertEquals(1, counter.get());
+ assertThat(counter.get()).isEqualTo(1);
final MutableVertex v2 = database.newVertex("Vertex").set("id", "test2").save();
v2.delete();
- Assertions.assertEquals(2, counter.get());
+ assertThat(counter.get()).isEqualTo(2);
});
- Assertions.assertEquals(0, database.countType("Vertex", true));
+ assertThat(database.countType("Vertex", true)).isEqualTo(0);
} finally {
database.getEvents().unregisterListener(listener);
@@ -321,21 +324,21 @@ public void testBeforeCreateEmulateIncrement() {
database.transaction(() -> {
final MutableVertex v1 = database.newVertex("IndexedVertex").set("id", "test");
- Assertions.assertFalse(v1.has("counter"));
+ assertThat(v1.has("counter")).isFalse();
v1.save();
- Assertions.assertEquals(1, v1.get("counter"));
- Assertions.assertEquals(1, database.countType("IndexedVertex", true));
+ assertThat(v1.get("counter")).isEqualTo(1);
+ assertThat(database.countType("IndexedVertex", true)).isEqualTo(1);
// SHOULD OVERWRITE THIS
database.newVertex("IndexedVertex").set("id", "test2").set("counter", 1).save();
final MutableVertex v2 = database.newVertex("IndexedVertex").set("id", "test3");
- Assertions.assertFalse(v2.has("counter"));
+ assertThat(v2.has("counter")).isFalse();
v2.save();
- Assertions.assertEquals(3, v2.get("counter"));
- Assertions.assertEquals(3, database.countType("IndexedVertex", true));
+ assertThat(v2.get("counter")).isEqualTo(3);
+ assertThat(database.countType("IndexedVertex", true)).isEqualTo(3);
- Assertions.assertEquals("test2", database.query("SQL", "select from `IndexedVertex` where counter= 2").nextIfAvailable().getProperty("id"));
+ assertThat(database.query("SQL", "select from `IndexedVertex` where counter= 2").nextIfAvailable().getProperty("id")).isEqualTo("test2");
});
} finally {
diff --git a/engine/src/test/java/com/arcadedb/event/RecordEncryptionTest.java b/engine/src/test/java/com/arcadedb/event/RecordEncryptionTest.java
index 32a4b91b45..378a682572 100644
--- a/engine/src/test/java/com/arcadedb/event/RecordEncryptionTest.java
+++ b/engine/src/test/java/com/arcadedb/event/RecordEncryptionTest.java
@@ -24,7 +24,8 @@
import com.arcadedb.graph.MutableVertex;
import com.arcadedb.graph.Vertex;
import com.arcadedb.schema.VertexType;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import javax.crypto.BadPaddingException;
@@ -41,6 +42,9 @@
import java.util.*;
import java.util.concurrent.atomic.*;
+import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
/**
* Implements record encryption by using the database events.
*
@@ -81,30 +85,30 @@ public void testEncryption() {
.save();
});
- Assertions.assertEquals(1, creates.get());
+ assertThat(creates.get()).isEqualTo(1);
database.setTransactionIsolationLevel(Database.TRANSACTION_ISOLATION_LEVEL.REPEATABLE_READ);
database.transaction(() -> {
final Vertex v1 = database.iterateType("BackAccount", true).next().asVertex();
- Assertions.assertEquals("Nobody must know Elon and Zuck are brothers", v1.getString("secret"));
+ assertThat(v1.getString("secret")).isEqualTo("Nobody must know Elon and Zuck are brothers");
});
- Assertions.assertEquals(1, reads.get());
+ assertThat(reads.get()).isEqualTo(1);
database.transaction(() -> {
final MutableVertex v1 = database.iterateType("BackAccount", true).next().asVertex().modify();
v1.set("secret", "Tool late, everybody knows it").save();
});
- Assertions.assertEquals(1, updates.get());
- Assertions.assertEquals(2, reads.get());
+ assertThat(updates.get()).isEqualTo(1);
+ assertThat(reads.get()).isEqualTo(2);
database.transaction(() -> {
final Vertex v1 = database.iterateType("BackAccount", true).next().asVertex();
- Assertions.assertEquals("Tool late, everybody knows it", v1.getString("secret"));
+ assertThat(v1.getString("secret")).isEqualTo("Tool late, everybody knows it");
});
- Assertions.assertEquals(3, reads.get());
+ assertThat(reads.get()).isEqualTo(3);
}
@Override
diff --git a/engine/src/test/java/com/arcadedb/event/TypeEventsTest.java b/engine/src/test/java/com/arcadedb/event/TypeEventsTest.java
index 76e81f3c61..476a05dff5 100644
--- a/engine/src/test/java/com/arcadedb/event/TypeEventsTest.java
+++ b/engine/src/test/java/com/arcadedb/event/TypeEventsTest.java
@@ -20,11 +20,14 @@
import com.arcadedb.TestHelper;
import com.arcadedb.graph.MutableVertex;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.concurrent.atomic.*;
+import org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Luca Garulli (l.garulli@arcadedata.com)
*/
@@ -49,16 +52,16 @@ public void testBeforeCreate() {
database.transaction(() -> {
final MutableVertex v1 = database.newVertex("Vertex").set("id", "test");
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
v1.save();
- Assertions.assertEquals(1, counter.get());
- Assertions.assertEquals(1, database.countType("Vertex", true));
+ assertThat(counter.get()).isEqualTo(1);
+ assertThat(database.countType("Vertex", true)).isEqualTo(1);
final MutableVertex v2 = database.newVertex("Vertex").set("id", "test2");
- Assertions.assertEquals(1, counter.get());
+ assertThat(counter.get()).isEqualTo(1);
v2.save();
- Assertions.assertEquals(2, counter.get());
- Assertions.assertEquals(1, database.countType("Vertex", true));
+ assertThat(counter.get()).isEqualTo(2);
+ assertThat(database.countType("Vertex", true)).isEqualTo(1);
});
} finally {
@@ -76,16 +79,16 @@ public void testAfterCreate() {
database.transaction(() -> {
final MutableVertex v1 = database.newVertex("Vertex").set("id", "test");
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
v1.save();
- Assertions.assertEquals(1, counter.get());
- Assertions.assertEquals(1, database.countType("Vertex", true));
+ assertThat(counter.get()).isEqualTo(1);
+ assertThat(database.countType("Vertex", true)).isEqualTo(1);
final MutableVertex v2 = database.newVertex("Vertex").set("id", "test2");
- Assertions.assertEquals(1, counter.get());
+ assertThat(counter.get()).isEqualTo(1);
v2.save();
- Assertions.assertEquals(2, counter.get());
- Assertions.assertEquals(2, database.countType("Vertex", true));
+ assertThat(counter.get()).isEqualTo(2);
+ assertThat(database.countType("Vertex", true)).isEqualTo(2);
});
} finally {
@@ -106,28 +109,28 @@ public void testBeforeUpdate() {
database.transaction(() -> {
final MutableVertex v1 = database.newVertex("Vertex").set("id", "test");
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
v1.save();
- Assertions.assertEquals(0, counter.get());
- Assertions.assertEquals(1, database.countType("Vertex", true));
+ assertThat(counter.get()).isEqualTo(0);
+ assertThat(database.countType("Vertex", true)).isEqualTo(1);
v1.set("modified", true);
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
v1.save();
- Assertions.assertEquals(1, counter.get());
+ assertThat(counter.get()).isEqualTo(1);
});
database.transaction(() -> {
final MutableVertex v1 = database.iterateType("Vertex", true).next().asVertex().modify();
v1.set("modified2", true);
- Assertions.assertEquals(1, counter.get());
+ assertThat(counter.get()).isEqualTo(1);
v1.save();
- Assertions.assertEquals(2, counter.get());
+ assertThat(counter.get()).isEqualTo(2);
});
- Assertions.assertFalse(database.iterateType("Vertex", true).next().asVertex().has("modified2"));
+ assertThat(database.iterateType("Vertex", true).next().asVertex().has("modified2")).isFalse();
} finally {
database.getSchema().getType("Vertex").getEvents().unregisterListener(listener);
@@ -144,16 +147,16 @@ public void testAfterUpdate() {
database.transaction(() -> {
final MutableVertex v1 = database.newVertex("Vertex").set("id", "test");
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
v1.save();
- Assertions.assertEquals(0, counter.get());
- Assertions.assertEquals(1, database.countType("Vertex", true));
+ assertThat(counter.get()).isEqualTo(0);
+ assertThat(database.countType("Vertex", true)).isEqualTo(1);
v1.set("modified", true);
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
v1.save();
- Assertions.assertEquals(1, counter.get());
+ assertThat(counter.get()).isEqualTo(1);
});
} finally {
@@ -174,29 +177,29 @@ public void testBeforeDelete() {
database.transaction(() -> {
final MutableVertex v1 = database.newVertex("Vertex").set("id", "test");
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
v1.save();
- Assertions.assertEquals(0, counter.get());
- Assertions.assertEquals(1, database.countType("Vertex", true));
+ assertThat(counter.get()).isEqualTo(0);
+ assertThat(database.countType("Vertex", true)).isEqualTo(1);
v1.set("modified", true);
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
v1.save();
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
});
database.transaction(() -> {
final MutableVertex v1 = database.iterateType("Vertex", true).next().asVertex().modify();
v1.delete();
- Assertions.assertEquals(1, counter.get());
+ assertThat(counter.get()).isEqualTo(1);
final MutableVertex v2 = database.newVertex("Vertex").set("id", "test2").save();
v2.delete();
- Assertions.assertEquals(2, counter.get());
+ assertThat(counter.get()).isEqualTo(2);
});
- Assertions.assertEquals(1, database.countType("Vertex", true));
+ assertThat(database.countType("Vertex", true)).isEqualTo(1);
} finally {
database.getSchema().getType("Vertex").getEvents().unregisterListener(listener);
@@ -213,29 +216,29 @@ public void testAfterDelete() {
database.transaction(() -> {
final MutableVertex v1 = database.newVertex("Vertex").set("id", "test");
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
v1.save();
- Assertions.assertEquals(0, counter.get());
- Assertions.assertEquals(1, database.countType("Vertex", true));
+ assertThat(counter.get()).isEqualTo(0);
+ assertThat(database.countType("Vertex", true)).isEqualTo(1);
v1.set("modified", true);
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
v1.save();
- Assertions.assertEquals(0, counter.get());
+ assertThat(counter.get()).isEqualTo(0);
});
database.transaction(() -> {
final MutableVertex v1 = database.iterateType("Vertex", true).next().asVertex().modify();
v1.delete();
- Assertions.assertEquals(1, counter.get());
+ assertThat(counter.get()).isEqualTo(1);
final MutableVertex v2 = database.newVertex("Vertex").set("id", "test2").save();
v2.delete();
- Assertions.assertEquals(2, counter.get());
+ assertThat(counter.get()).isEqualTo(2);
});
- Assertions.assertEquals(0, database.countType("Vertex", true));
+ assertThat(database.countType("Vertex", true)).isEqualTo(0);
} finally {
database.getSchema().getType("Vertex").getEvents().unregisterListener(listener);
diff --git a/engine/src/test/java/com/arcadedb/function/java/JavaFunctionTest.java b/engine/src/test/java/com/arcadedb/function/java/JavaFunctionTest.java
index 017c3de975..03f2e7417e 100644
--- a/engine/src/test/java/com/arcadedb/function/java/JavaFunctionTest.java
+++ b/engine/src/test/java/com/arcadedb/function/java/JavaFunctionTest.java
@@ -4,10 +4,12 @@
import com.arcadedb.function.FunctionExecutionException;
import com.arcadedb.query.sql.executor.Result;
import com.arcadedb.query.sql.executor.ResultSet;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
-import java.lang.reflect.*;
+import java.lang.reflect.InvocationTargetException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
public class JavaFunctionTest extends TestHelper {
@@ -23,13 +25,13 @@ public static int SUM(final int a, final int b) {
@Test
public void testRegistration()
- throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
+ throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
// TEST REGISTRATION HERE
registerClass();
try {
registerClass();
- Assertions.fail();
+ fail("");
} catch (final IllegalArgumentException e) {
// EXPECTED
}
@@ -40,13 +42,13 @@ public void testRegistration()
@Test
public void testRegistrationByClassInstance()
- throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
+ throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
// TEST REGISTRATION HERE
database.getSchema().registerFunctionLibrary(new JavaClassFunctionLibraryDefinition("math", JavaFunctionTest.Sum.class));
try {
database.getSchema().registerFunctionLibrary(new JavaClassFunctionLibraryDefinition("math", JavaFunctionTest.Sum.class));
- Assertions.fail();
+ fail("");
} catch (final IllegalArgumentException e) {
// EXPECTED
}
@@ -57,29 +59,29 @@ public void testRegistrationByClassInstance()
@Test
public void testRegistrationSingleMethods()
- throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
+ throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
// TEST REGISTRATION HERE
database.getSchema()
- .registerFunctionLibrary(new JavaMethodFunctionLibraryDefinition("math", JavaFunctionTest.Sum.class.getMethod("sum", Integer.TYPE, Integer.TYPE)));
+ .registerFunctionLibrary(new JavaMethodFunctionLibraryDefinition("math", JavaFunctionTest.Sum.class.getMethod("sum", Integer.TYPE, Integer.TYPE)));
try {
database.getSchema()
- .registerFunctionLibrary(new JavaMethodFunctionLibraryDefinition("math", JavaFunctionTest.Sum.class.getMethod("sum", Integer.TYPE, Integer.TYPE)));
- Assertions.fail();
+ .registerFunctionLibrary(new JavaMethodFunctionLibraryDefinition("math", JavaFunctionTest.Sum.class.getMethod("sum", Integer.TYPE, Integer.TYPE)));
+ fail("");
} catch (final IllegalArgumentException e) {
// EXPECTED
}
database.getSchema().unregisterFunctionLibrary("math");
database.getSchema()
- .registerFunctionLibrary(new JavaMethodFunctionLibraryDefinition("math", JavaFunctionTest.Sum.class.getMethod("sum", Integer.TYPE, Integer.TYPE)));
+ .registerFunctionLibrary(new JavaMethodFunctionLibraryDefinition("math", JavaFunctionTest.Sum.class.getMethod("sum", Integer.TYPE, Integer.TYPE)));
}
@Test
public void testFunctionNotFound() {
try {
database.getSchema().getFunction("math", "sum");
- Assertions.fail();
+ fail("");
} catch (final IllegalArgumentException e) {
// EXPECTED
}
@@ -87,35 +89,35 @@ public void testFunctionNotFound() {
@Test
public void testMethodParameterByPosition()
- throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
+ throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
// TEST REGISTRATION HERE
registerClass();
final Integer result = (Integer) database.getSchema().getFunction("math", "sum").execute(3, 5);
- Assertions.assertEquals(8, result);
+ assertThat(result).isEqualTo(8);
}
@Test
public void testStaticMethodParameterByPosition()
- throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
+ throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
registerClass();
final Integer result = (Integer) database.getSchema().getFunction("math", "SUM").execute(3, 5);
- Assertions.assertEquals(8, result);
+ assertThat(result).isEqualTo(8);
}
@Test
public void testExecuteFromSQL()
- throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
+ throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
registerClass();
database.transaction(() -> {
final ResultSet rs = database.command("SQL", "SELECT `math.sum`(20,7) as sum");
- Assertions.assertTrue(rs.hasNext());
+ assertThat(rs.hasNext()).isTrue();
final Result record = rs.next();
- Assertions.assertNotNull(record);
- Assertions.assertFalse(record.getIdentity().isPresent());
- Assertions.assertEquals(27, ((Number) record.getProperty("sum")).intValue());
+ assertThat(record).isNotNull();
+ assertThat(record.getIdentity()).isNotPresent();
+ assertThat(((Number) record.getProperty("sum")).intValue()).isEqualTo(27);
});
}
@@ -124,7 +126,7 @@ public void testNotFound() throws ClassNotFoundException, InvocationTargetExcept
registerClass();
try {
database.getSchema().getFunction("math", "NOT_found").execute(3, 5);
- Assertions.fail();
+ fail("");
} catch (IllegalArgumentException e) {
// EXPECTED
}
@@ -132,11 +134,11 @@ public void testNotFound() throws ClassNotFoundException, InvocationTargetExcept
@Test
public void testExecutionError()
- throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
+ throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
registerClass();
try {
database.getSchema().getFunction("math", "SUM").execute("invalid", 5);
- Assertions.fail();
+ fail("");
} catch (FunctionExecutionException e) {
// EXPECTED
}
diff --git a/engine/src/test/java/com/arcadedb/function/polyglot/PolyglotFunctionTest.java b/engine/src/test/java/com/arcadedb/function/polyglot/PolyglotFunctionTest.java
index 36fc6d77dc..fd5356ef54 100644
--- a/engine/src/test/java/com/arcadedb/function/polyglot/PolyglotFunctionTest.java
+++ b/engine/src/test/java/com/arcadedb/function/polyglot/PolyglotFunctionTest.java
@@ -2,17 +2,19 @@
import com.arcadedb.TestHelper;
import com.arcadedb.function.FunctionExecutionException;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
-import java.lang.reflect.*;
+import java.lang.reflect.InvocationTargetException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
public class PolyglotFunctionTest extends TestHelper {
@Test
public void testEmbeddedFunction() {
registerFunctions();
final Integer result = (Integer) database.getSchema().getFunction("math", "sum").execute(3, 5);
- Assertions.assertEquals(8, result);
+ assertThat(result).isEqualTo(8);
}
@Test
@@ -20,10 +22,10 @@ public void testReuseSameQueryEngine() {
registerFunctions();
Integer result = (Integer) database.getSchema().getFunction("math", "sum").execute(3, 5);
- Assertions.assertEquals(8, result);
+ assertThat(result).isEqualTo(8);
result = (Integer) database.getSchema().getFunction("math", "sum").execute(3, 5);
- Assertions.assertEquals(8, result);
+ assertThat(result).isEqualTo(8);
}
@Test
@@ -31,11 +33,11 @@ public void testRedefineFunction() {
registerFunctions();
Integer result = (Integer) database.getSchema().getFunction("math", "sum").execute(100, 50);
- Assertions.assertEquals(150, result);
+ assertThat(result).isEqualTo(150);
try {
database.getSchema().getFunctionLibrary("math").registerFunction(new JavascriptFunctionDefinition("sum", "return a - b;", "a", "b"));
- Assertions.fail();
+ fail("");
} catch (final IllegalArgumentException e) {
// EXPECTED
}
@@ -44,7 +46,7 @@ public void testRedefineFunction() {
database.getSchema().getFunctionLibrary("math").registerFunction(new JavascriptFunctionDefinition("sum", "return a - b;", "a", "b"));
result = (Integer) database.getSchema().getFunction("math", "sum").execute(50, 100);
- Assertions.assertEquals(-50, result);
+ assertThat(result).isEqualTo(-50);
}
@Test
@@ -52,7 +54,7 @@ public void testNotFound() throws ClassNotFoundException, InvocationTargetExcept
registerFunctions();
try {
database.getSchema().getFunction("math", "NOT_found").execute(3, 5);
- Assertions.fail();
+ fail("");
} catch (IllegalArgumentException e) {
// EXPECTED
}
@@ -66,7 +68,7 @@ public void testExecutionError() {
.registerFunction(new JavascriptFunctionDefinition("sum", "return a ++++ b;", "a", "b")));
database.getSchema().getFunction("math", "sum").execute("invalid", 5);
- Assertions.fail();
+ fail("");
} catch (FunctionExecutionException e) {
// EXPECTED
}
diff --git a/engine/src/test/java/com/arcadedb/function/polyglot/SQLDefinedJavascriptFunctionTest.java b/engine/src/test/java/com/arcadedb/function/polyglot/SQLDefinedJavascriptFunctionTest.java
index 5c1d7d3e7f..cdf778222b 100644
--- a/engine/src/test/java/com/arcadedb/function/polyglot/SQLDefinedJavascriptFunctionTest.java
+++ b/engine/src/test/java/com/arcadedb/function/polyglot/SQLDefinedJavascriptFunctionTest.java
@@ -3,22 +3,24 @@
import com.arcadedb.TestHelper;
import com.arcadedb.function.FunctionLibraryDefinition;
import com.arcadedb.query.sql.executor.ResultSet;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
public class SQLDefinedJavascriptFunctionTest extends TestHelper {
@Test
public void testEmbeddedFunction() {
registerFunctions();
final Integer result = (Integer) database.getSchema().getFunction("math", "sum").execute(3, 5);
- Assertions.assertEquals(8, result);
+ assertThat(result).isEqualTo(8);
}
@Test
public void testCallFromSQL() {
registerFunctions();
final ResultSet result = database.command("sql", "select `math.sum`(?,?) as result", 3, 5);
- Assertions.assertEquals(8, (Integer) result.next().getProperty("result"));
+ assertThat((Integer) result.next().getProperty("result")).isEqualTo(8);
}
@Test
@@ -26,16 +28,16 @@ public void testReuseSameQueryEngine() {
registerFunctions();
Integer result = (Integer) database.getSchema().getFunction("math", "sum").execute(3, 5);
- Assertions.assertEquals(8, result);
+ assertThat(result).isEqualTo(8);
result = (Integer) database.getSchema().getFunction("math", "sum").execute(3, 5);
- Assertions.assertEquals(8, result);
+ assertThat(result).isEqualTo(8);
result = (Integer) database.getSchema().getFunction("util", "sum").execute(3, 5);
- Assertions.assertEquals(8, result);
+ assertThat(result).isEqualTo(8);
result = (Integer) database.getSchema().getFunction("util", "sum").execute(3, 5);
- Assertions.assertEquals(8, result);
+ assertThat(result).isEqualTo(8);
}
@Test
@@ -43,11 +45,11 @@ public void testRedefineFunction() {
registerFunctions();
Integer result = (Integer) database.getSchema().getFunction("math", "sum").execute(100, 50);
- Assertions.assertEquals(150, result);
+ assertThat(result).isEqualTo(150);
try {
database.getSchema().getFunctionLibrary("math").registerFunction(new JavascriptFunctionDefinition("sum", "return a - b;", "a", "b"));
- Assertions.fail();
+ fail("");
} catch (final IllegalArgumentException e) {
// EXPECTED
}
@@ -56,7 +58,7 @@ public void testRedefineFunction() {
database.getSchema().getFunctionLibrary("math").registerFunction(new JavascriptFunctionDefinition("sum", "return a - b;", "a", "b"));
result = (Integer) database.getSchema().getFunction("math", "sum").execute(50, 100);
- Assertions.assertEquals(-50, result);
+ assertThat(result).isEqualTo(-50);
}
private void registerFunctions() {
@@ -64,6 +66,6 @@ private void registerFunctions() {
database.command("sql", "define function util.sum \"return a + b\" parameters [a,b] language js");
final FunctionLibraryDefinition flib = database.getSchema().getFunctionLibrary("math");
- Assertions.assertNotNull(flib);
+ assertThat(flib).isNotNull();
}
}
diff --git a/engine/src/test/java/com/arcadedb/function/sql/SQLDefinedSQLFunctionTest.java b/engine/src/test/java/com/arcadedb/function/sql/SQLDefinedSQLFunctionTest.java
index 654b7a39d1..22ce2d4a26 100644
--- a/engine/src/test/java/com/arcadedb/function/sql/SQLDefinedSQLFunctionTest.java
+++ b/engine/src/test/java/com/arcadedb/function/sql/SQLDefinedSQLFunctionTest.java
@@ -4,36 +4,39 @@
import com.arcadedb.exception.CommandSQLParsingException;
import com.arcadedb.function.FunctionLibraryDefinition;
import com.arcadedb.query.sql.executor.ResultSet;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
public class SQLDefinedSQLFunctionTest extends TestHelper {
@Test
public void testEmbeddedFunction() {
registerFunctions();
final Integer result = (Integer) database.getSchema().getFunction("math", "sum").execute(3, 5);
- Assertions.assertEquals(8, result);
+ assertThat(result).isEqualTo(8);
}
@Test
public void testCallFromSQLWithParams() {
registerFunctions();
final ResultSet result = database.command("sql", "select `math.sum`(?,?) as result", 3, 5);
- Assertions.assertEquals(8, (Integer) result.next().getProperty("result"));
+ assertThat((Integer) result.next().getProperty("result")).isEqualTo(8);
}
@Test
public void testCallFromSQLNoParams() {
database.command("sql", "define function math.hello \"select 'hello'\" language sql");
final ResultSet result = database.command("sql", "select `math.hello`() as result");
- Assertions.assertEquals("hello", result.next().getProperty("result"));
+ assertThat(result.next().getProperty("result")).isEqualTo("hello");
}
@Test
public void errorTestCallFromSQLEmptyParams() {
try {
database.command("sql", "define function math.hello \"select 'hello'\" parameters [] language sql");
- Assertions.fail();
+ fail("");
} catch (CommandSQLParsingException e) {
// EXPECTED
}
@@ -44,16 +47,16 @@ public void testReuseSameQueryEngine() {
registerFunctions();
Integer result = (Integer) database.getSchema().getFunction("math", "sum").execute(3, 5);
- Assertions.assertEquals(8, result);
+ assertThat(result).isEqualTo(8);
result = (Integer) database.getSchema().getFunction("math", "sum").execute(3, 5);
- Assertions.assertEquals(8, result);
+ assertThat(result).isEqualTo(8);
result = (Integer) database.getSchema().getFunction("util", "sum").execute(3, 5);
- Assertions.assertEquals(8, result);
+ assertThat(result).isEqualTo(8);
result = (Integer) database.getSchema().getFunction("util", "sum").execute(3, 5);
- Assertions.assertEquals(8, result);
+ assertThat(result).isEqualTo(8);
}
@Test
@@ -61,11 +64,11 @@ public void testRedefineFunction() {
registerFunctions();
Integer result = (Integer) database.getSchema().getFunction("math", "sum").execute(100, 50);
- Assertions.assertEquals(150, result);
+ assertThat(result).isEqualTo(150);
try {
database.command("sql", "define function math.sum \"select :a + :b;\" parameters [a,b] language sql");
- Assertions.fail();
+ fail("");
} catch (final IllegalArgumentException e) {
// EXPECTED
}
@@ -74,7 +77,7 @@ public void testRedefineFunction() {
database.command("sql", "define function math.sum \"select :a + :b;\" parameters [a,b] language sql");
result = (Integer) database.getSchema().getFunction("math", "sum").execute(-350, 150);
- Assertions.assertEquals(-200, result);
+ assertThat(result).isEqualTo(-200);
}
private void registerFunctions() {
@@ -82,6 +85,6 @@ private void registerFunctions() {
database.command("sql", "define function util.sum \"select :a + :b;\" parameters [a,b] language sql");
final FunctionLibraryDefinition flib = database.getSchema().getFunctionLibrary("math");
- Assertions.assertNotNull(flib);
+ assertThat(flib).isNotNull();
}
}
diff --git a/engine/src/test/java/com/arcadedb/graph/BaseGraphTest.java b/engine/src/test/java/com/arcadedb/graph/BaseGraphTest.java
index f2aa80b1bb..c7ec26c1ba 100644
--- a/engine/src/test/java/com/arcadedb/graph/BaseGraphTest.java
+++ b/engine/src/test/java/com/arcadedb/graph/BaseGraphTest.java
@@ -23,11 +23,15 @@
import com.arcadedb.database.Database;
import com.arcadedb.database.RID;
import com.arcadedb.utility.FileUtils;
-import org.junit.jupiter.api.Assertions;
+import org.assertj.core.api.Assertions;
+
import java.io.*;
import java.util.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
public abstract class BaseGraphTest extends TestHelper {
protected static final String VERTEX1_TYPE_NAME = "V1";
protected static final String VERTEX2_TYPE_NAME = "V2";
@@ -43,10 +47,10 @@ public void beginTest() {
FileUtils.deleteRecursively(new File(DB_PATH));
database.transaction(() -> {
- Assertions.assertFalse(database.getSchema().existsType(VERTEX1_TYPE_NAME));
+ assertThat(database.getSchema().existsType(VERTEX1_TYPE_NAME)).isFalse();
database.getSchema().buildVertexType().withName(VERTEX1_TYPE_NAME).withTotalBuckets(3).create();
- Assertions.assertFalse(database.getSchema().existsType(VERTEX2_TYPE_NAME));
+ assertThat(database.getSchema().existsType(VERTEX2_TYPE_NAME)).isFalse();
database.getSchema().buildVertexType().withName(VERTEX2_TYPE_NAME).withTotalBuckets(3).create();
database.getSchema().buildEdgeType().withName(EDGE1_TYPE_NAME).create();
@@ -66,24 +70,24 @@ public void beginTest() {
// CREATION OF EDGE PASSING PARAMS AS VARARGS
final MutableEdge e1 = v1.newEdge(EDGE1_TYPE_NAME, v2, true, "name", "E1");
- Assertions.assertEquals(e1.getOut(), v1);
- Assertions.assertEquals(e1.getIn(), v2);
+ assertThat(v1).isEqualTo(e1.getOut());
+ assertThat(v2).isEqualTo(e1.getIn());
final MutableVertex v3 = db.newVertex(VERTEX2_TYPE_NAME);
v3.set("name", "V3");
v3.save();
- Assertions.assertEquals(v3, v3.asVertex());
- Assertions.assertEquals(v3, v3.asVertex(true));
+ assertThat(v3.asVertex()).isEqualTo(v3);
+ assertThat(v3.asVertex(true)).isEqualTo(v3);
try {
- Assertions.assertNotNull(v3.asEdge());
- Assertions.fail();
+ assertThat(v3.asEdge()).isNotNull();
+ fail("");
} catch (final ClassCastException e) {
// EXPECTED
}
try {
- Assertions.assertNotNull(v3.asEdge(true));
- Assertions.fail();
+ assertThat(v3.asEdge(true)).isNotNull();
+ fail("");
} catch (final ClassCastException e) {
// EXPECTED
}
@@ -93,28 +97,28 @@ public void beginTest() {
// CREATION OF EDGE PASSING PARAMS AS MAP
final MutableEdge e2 = v2.newEdge(EDGE2_TYPE_NAME, v3, true, params);
- Assertions.assertEquals(e2.getOut(), v2);
- Assertions.assertEquals(e2.getIn(), v3);
+ assertThat(v2).isEqualTo(e2.getOut());
+ assertThat(v3).isEqualTo(e2.getIn());
- Assertions.assertEquals(e2, e2.asEdge());
- Assertions.assertEquals(e2, e2.asEdge(true));
+ assertThat(e2.asEdge()).isEqualTo(e2);
+ assertThat(e2.asEdge(true)).isEqualTo(e2);
try {
- Assertions.assertNotNull(e2.asVertex());
- Assertions.fail();
+ assertThat(e2.asVertex()).isNotNull();
+ fail("");
} catch (final ClassCastException e) {
// EXPECTED
}
try {
- Assertions.assertNotNull(e2.asVertex(true));
- Assertions.fail();
+ assertThat(e2.asVertex(true)).isNotNull();
+ fail("");
} catch (final ClassCastException e) {
// EXPECTED
}
final ImmutableLightEdge e3 = v1.newLightEdge(EDGE2_TYPE_NAME, v3, true);
- Assertions.assertEquals(e3.getOut(), v1);
- Assertions.assertEquals(e3.getIn(), v3);
+ assertThat(v1).isEqualTo(e3.getOut());
+ assertThat(v3).isEqualTo(e3.getIn());
db.commit();
diff --git a/engine/src/test/java/com/arcadedb/graph/BasicGraphTest.java b/engine/src/test/java/com/arcadedb/graph/BasicGraphTest.java
index a5af1c2cfc..a3e5bc08fc 100644
--- a/engine/src/test/java/com/arcadedb/graph/BasicGraphTest.java
+++ b/engine/src/test/java/com/arcadedb/graph/BasicGraphTest.java
@@ -32,65 +32,70 @@
import com.arcadedb.query.sql.function.SQLFunctionAbstract;
import com.arcadedb.schema.EdgeType;
import com.arcadedb.schema.Schema;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.*;
import java.util.concurrent.atomic.*;
+import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
public class BasicGraphTest extends BaseGraphTest {
@Test
public void checkVertices() {
database.begin();
try {
- Assertions.assertEquals(1, database.countType(VERTEX1_TYPE_NAME, false));
- Assertions.assertEquals(2, database.countType(VERTEX2_TYPE_NAME, false));
+ assertThat(database.countType(VERTEX1_TYPE_NAME, false)).isEqualTo(1);
+ assertThat(database.countType(VERTEX2_TYPE_NAME, false)).isEqualTo(2);
final Vertex v1 = (Vertex) database.lookupByRID(root, false);
- Assertions.assertNotNull(v1);
+ assertThat(v1).isNotNull();
// TEST CONNECTED VERTICES
- Assertions.assertEquals(VERTEX1_TYPE_NAME, v1.getTypeName());
- Assertions.assertEquals(VERTEX1_TYPE_NAME, v1.get("name"));
+ assertThat(v1.getTypeName()).isEqualTo(VERTEX1_TYPE_NAME);
+ assertThat(v1.get("name")).isEqualTo(VERTEX1_TYPE_NAME);
final Iterator vertices2level = v1.getVertices(Vertex.DIRECTION.OUT, new String[] { EDGE1_TYPE_NAME }).iterator();
- Assertions.assertNotNull(vertices2level);
- Assertions.assertTrue(vertices2level.hasNext());
+ assertThat(vertices2level).isNotNull();
+ assertThat(vertices2level.hasNext()).isTrue();
final Vertex v2 = vertices2level.next();
- Assertions.assertNotNull(v2);
- Assertions.assertEquals(VERTEX2_TYPE_NAME, v2.getTypeName());
- Assertions.assertEquals(VERTEX2_TYPE_NAME, v2.get("name"));
+ assertThat(v2).isNotNull();
+ assertThat(v2.getTypeName()).isEqualTo(VERTEX2_TYPE_NAME);
+ assertThat(v2.get("name")).isEqualTo(VERTEX2_TYPE_NAME);
final Iterator vertices2level2 = v1.getVertices(Vertex.DIRECTION.OUT, new String[] { EDGE2_TYPE_NAME }).iterator();
- Assertions.assertTrue(vertices2level2.hasNext());
+ assertThat(vertices2level2.hasNext()).isTrue();
final Vertex v3 = vertices2level2.next();
- Assertions.assertNotNull(v3);
+ assertThat(v3).isNotNull();
- Assertions.assertEquals(VERTEX2_TYPE_NAME, v3.getTypeName());
- Assertions.assertEquals("V3", v3.get("name"));
+ assertThat(v3.getTypeName()).isEqualTo(VERTEX2_TYPE_NAME);
+ assertThat(v3.get("name")).isEqualTo("V3");
final Iterator vertices3level = v2.getVertices(Vertex.DIRECTION.OUT, new String[] { EDGE2_TYPE_NAME }).iterator();
- Assertions.assertNotNull(vertices3level);
- Assertions.assertTrue(vertices3level.hasNext());
+ assertThat(vertices3level).isNotNull();
+ assertThat(vertices3level.hasNext()).isTrue();
final Vertex v32 = vertices3level.next();
- Assertions.assertNotNull(v32);
- Assertions.assertEquals(VERTEX2_TYPE_NAME, v32.getTypeName());
- Assertions.assertEquals("V3", v32.get("name"));
+ assertThat(v32).isNotNull();
+ assertThat(v32.getTypeName()).isEqualTo(VERTEX2_TYPE_NAME);
+ assertThat(v32.get("name")).isEqualTo("V3");
- Assertions.assertTrue(v1.isConnectedTo(v2));
- Assertions.assertTrue(v2.isConnectedTo(v1));
- Assertions.assertTrue(v1.isConnectedTo(v3));
- Assertions.assertTrue(v3.isConnectedTo(v1));
- Assertions.assertTrue(v2.isConnectedTo(v3));
+ assertThat(v1.isConnectedTo(v2)).isTrue();
+ assertThat(v2.isConnectedTo(v1)).isTrue();
+ assertThat(v1.isConnectedTo(v3)).isTrue();
+ assertThat(v3.isConnectedTo(v1)).isTrue();
+ assertThat(v2.isConnectedTo(v3)).isTrue();
- Assertions.assertFalse(v3.isConnectedTo(v1, Vertex.DIRECTION.OUT));
- Assertions.assertFalse(v3.isConnectedTo(v2, Vertex.DIRECTION.OUT));
+ assertThat(v3.isConnectedTo(v1, Vertex.DIRECTION.OUT)).isFalse();
+ assertThat(v3.isConnectedTo(v2, Vertex.DIRECTION.OUT)).isFalse();
} finally {
database.commit();
@@ -103,19 +108,19 @@ public void autoPersistLightWeightEdge() {
database.begin();
try {
final Vertex v1 = (Vertex) database.lookupByRID(root, false);
- Assertions.assertNotNull(v1);
+ assertThat(v1).isNotNull();
final Iterator edges3 = v1.getEdges(Vertex.DIRECTION.OUT, new String[] { EDGE2_TYPE_NAME }).iterator();
- Assertions.assertNotNull(edges3);
- Assertions.assertTrue(edges3.hasNext());
+ assertThat(edges3).isNotNull();
+ assertThat(edges3.hasNext()).isTrue();
try {
final MutableEdge edge = edges3.next().modify();
- Assertions.fail("Cannot modify lightweight edges");
+ fail("Cannot modify lightweight edges");
// edge.set("upgraded", true);
// edge.save();
//
-// Assertions.assertTrue(edge.getIdentity().getPosition() > -1);
+// Assertions.assertThat(edge.getIdentity().getPosition() > -1).isTrue();
} catch (final IllegalStateException e) {
}
@@ -129,50 +134,50 @@ public void checkEdges() {
database.begin();
try {
- Assertions.assertEquals(1, database.countType(EDGE1_TYPE_NAME, false));
- Assertions.assertEquals(1, database.countType(EDGE2_TYPE_NAME, false));
+ assertThat(database.countType(EDGE1_TYPE_NAME, false)).isEqualTo(1);
+ assertThat(database.countType(EDGE2_TYPE_NAME, false)).isEqualTo(1);
final Vertex v1 = (Vertex) database.lookupByRID(root, false);
- Assertions.assertNotNull(v1);
+ assertThat(v1).isNotNull();
// TEST CONNECTED EDGES
final Iterator edges1 = v1.getEdges(Vertex.DIRECTION.OUT, new String[] { EDGE1_TYPE_NAME }).iterator();
- Assertions.assertNotNull(edges1);
- Assertions.assertTrue(edges1.hasNext());
+ assertThat(edges1).isNotNull();
+ assertThat(edges1.hasNext()).isTrue();
final Edge e1 = edges1.next();
- Assertions.assertNotNull(e1);
- Assertions.assertEquals(EDGE1_TYPE_NAME, e1.getTypeName());
- Assertions.assertEquals(v1, e1.getOut());
- Assertions.assertEquals("E1", e1.get("name"));
+ assertThat(e1).isNotNull();
+ assertThat(e1.getTypeName()).isEqualTo(EDGE1_TYPE_NAME);
+ assertThat(e1.getOut()).isEqualTo(v1);
+ assertThat(e1.get("name")).isEqualTo("E1");
final Vertex v2 = e1.getInVertex();
- Assertions.assertEquals(VERTEX2_TYPE_NAME, v2.get("name"));
+ assertThat(v2.get("name")).isEqualTo(VERTEX2_TYPE_NAME);
final Iterator edges2 = v2.getEdges(Vertex.DIRECTION.OUT, new String[] { EDGE2_TYPE_NAME }).iterator();
- Assertions.assertTrue(edges2.hasNext());
+ assertThat(edges2.hasNext()).isTrue();
final Edge e2 = edges2.next();
- Assertions.assertNotNull(e2);
+ assertThat(e2).isNotNull();
- Assertions.assertEquals(EDGE2_TYPE_NAME, e2.getTypeName());
- Assertions.assertEquals(v2, e2.getOut());
- Assertions.assertEquals("E2", e2.get("name"));
+ assertThat(e2.getTypeName()).isEqualTo(EDGE2_TYPE_NAME);
+ assertThat(e2.getOut()).isEqualTo(v2);
+ assertThat(e2.get("name")).isEqualTo("E2");
final Vertex v3 = e2.getInVertex();
- Assertions.assertEquals("V3", v3.get("name"));
+ assertThat(v3.get("name")).isEqualTo("V3");
final Iterator edges3 = v1.getEdges(Vertex.DIRECTION.OUT, new String[] { EDGE2_TYPE_NAME }).iterator();
- Assertions.assertNotNull(edges3);
- Assertions.assertTrue(edges3.hasNext());
+ assertThat(edges3).isNotNull();
+ assertThat(edges3.hasNext()).isTrue();
final Edge e3 = edges3.next();
- Assertions.assertNotNull(e3);
- Assertions.assertEquals(EDGE2_TYPE_NAME, e3.getTypeName());
- Assertions.assertEquals(v1, e3.getOutVertex());
- Assertions.assertEquals(v3, e3.getInVertex());
+ assertThat(e3).isNotNull();
+ assertThat(e3.getTypeName()).isEqualTo(EDGE2_TYPE_NAME);
+ assertThat(e3.getOutVertex()).isEqualTo(v1);
+ assertThat(e3.getInVertex()).isEqualTo(v3);
v2.getEdges();
@@ -186,11 +191,11 @@ public void updateVerticesAndEdges() {
database.begin();
try {
- Assertions.assertEquals(1, database.countType(EDGE1_TYPE_NAME, false));
- Assertions.assertEquals(1, database.countType(EDGE2_TYPE_NAME, false));
+ assertThat(database.countType(EDGE1_TYPE_NAME, false)).isEqualTo(1);
+ assertThat(database.countType(EDGE2_TYPE_NAME, false)).isEqualTo(1);
final Vertex v1 = (Vertex) database.lookupByRID(root, false);
- Assertions.assertNotNull(v1);
+ assertThat(v1).isNotNull();
final MutableVertex v1Copy = v1.modify();
v1Copy.set("newProperty1", "TestUpdate1");
@@ -198,12 +203,12 @@ public void updateVerticesAndEdges() {
// TEST CONNECTED EDGES
final Iterator edges1 = v1.getEdges(Vertex.DIRECTION.OUT, new String[] { EDGE1_TYPE_NAME }).iterator();
- Assertions.assertNotNull(edges1);
- Assertions.assertTrue(edges1.hasNext());
+ assertThat(edges1).isNotNull();
+ assertThat(edges1.hasNext()).isTrue();
final Edge e1 = edges1.next();
- Assertions.assertNotNull(e1);
+ assertThat(e1).isNotNull();
final MutableEdge e1Copy = e1.modify();
e1Copy.set("newProperty2", "TestUpdate2");
@@ -212,9 +217,9 @@ public void updateVerticesAndEdges() {
database.commit();
final Vertex v1CopyReloaded = (Vertex) database.lookupByRID(v1Copy.getIdentity(), true);
- Assertions.assertEquals("TestUpdate1", v1CopyReloaded.get("newProperty1"));
+ assertThat(v1CopyReloaded.get("newProperty1")).isEqualTo("TestUpdate1");
final Edge e1CopyReloaded = (Edge) database.lookupByRID(e1Copy.getIdentity(), true);
- Assertions.assertEquals("TestUpdate2", e1CopyReloaded.get("newProperty2"));
+ assertThat(e1CopyReloaded.get("newProperty2")).isEqualTo("TestUpdate2");
} finally {
new DatabaseChecker(database).setVerboseLevel(0).check();
@@ -227,16 +232,16 @@ public void deleteVertices() {
try {
final Vertex v1 = (Vertex) database.lookupByRID(root, false);
- Assertions.assertNotNull(v1);
+ assertThat(v1).isNotNull();
Iterator vertices = v1.getVertices(Vertex.DIRECTION.OUT).iterator();
- Assertions.assertTrue(vertices.hasNext());
+ assertThat(vertices.hasNext()).isTrue();
Vertex v3 = vertices.next();
- Assertions.assertNotNull(v3);
+ assertThat(v3).isNotNull();
- Assertions.assertTrue(vertices.hasNext());
+ assertThat(vertices.hasNext()).isTrue();
Vertex v2 = vertices.next();
- Assertions.assertNotNull(v2);
+ assertThat(v2).isNotNull();
final long totalVertices = database.countType(v1.getTypeName(), true);
@@ -244,41 +249,41 @@ public void deleteVertices() {
// -----------------------
database.deleteRecord(v1);
- Assertions.assertEquals(totalVertices - 1, database.countType(v1.getTypeName(), true));
+ assertThat(database.countType(v1.getTypeName(), true)).isEqualTo(totalVertices - 1);
vertices = v2.getVertices(Vertex.DIRECTION.IN).iterator();
- Assertions.assertFalse(vertices.hasNext());
+ assertThat(vertices.hasNext()).isFalse();
vertices = v2.getVertices(Vertex.DIRECTION.OUT).iterator();
- Assertions.assertTrue(vertices.hasNext());
+ assertThat(vertices.hasNext()).isTrue();
// Expecting 1 edge only: V2 is still connected to V3
vertices = v3.getVertices(Vertex.DIRECTION.IN).iterator();
- Assertions.assertTrue(vertices.hasNext());
+ assertThat(vertices.hasNext()).isTrue();
vertices.next();
- Assertions.assertFalse(vertices.hasNext());
+ assertThat(vertices.hasNext()).isFalse();
// RELOAD AND CHECK AGAIN
// -----------------------
v2 = (Vertex) database.lookupByRID(v2.getIdentity(), true);
vertices = v2.getVertices(Vertex.DIRECTION.IN).iterator();
- Assertions.assertFalse(vertices.hasNext());
+ assertThat(vertices.hasNext()).isFalse();
vertices = v2.getVertices(Vertex.DIRECTION.OUT).iterator();
- Assertions.assertTrue(vertices.hasNext());
+ assertThat(vertices.hasNext()).isTrue();
v3 = (Vertex) database.lookupByRID(v3.getIdentity(), true);
// Expecting 1 edge only: V2 is still connected to V3
vertices = v3.getVertices(Vertex.DIRECTION.IN).iterator();
- Assertions.assertTrue(vertices.hasNext());
+ assertThat(vertices.hasNext()).isTrue();
vertices.next();
- Assertions.assertFalse(vertices.hasNext());
+ assertThat(vertices.hasNext()).isFalse();
try {
database.lookupByRID(root, true);
- Assertions.fail("Expected deleted record");
+ fail("Expected deleted record");
} catch (final RecordNotFoundException e) {
}
@@ -294,16 +299,16 @@ public void deleteEdges() {
try {
final Vertex v1 = (Vertex) database.lookupByRID(root, false);
- Assertions.assertNotNull(v1);
+ assertThat(v1).isNotNull();
Iterator edges = v1.getEdges(Vertex.DIRECTION.OUT).iterator();
- Assertions.assertTrue(edges.hasNext());
+ assertThat(edges.hasNext()).isTrue();
final Edge e3 = edges.next();
- Assertions.assertNotNull(e3);
+ assertThat(e3).isNotNull();
- Assertions.assertTrue(edges.hasNext());
+ assertThat(edges.hasNext()).isTrue();
final Edge e2 = edges.next();
- Assertions.assertNotNull(e2);
+ assertThat(e2).isNotNull();
// DELETE THE EDGE
// -----------------------
@@ -311,33 +316,33 @@ public void deleteEdges() {
Vertex vOut = e2.getOutVertex();
edges = vOut.getEdges(Vertex.DIRECTION.OUT).iterator();
- Assertions.assertTrue(edges.hasNext());
+ assertThat(edges.hasNext()).isTrue();
edges.next();
- Assertions.assertFalse(edges.hasNext());
+ assertThat(edges.hasNext()).isFalse();
Vertex vIn = e2.getInVertex();
edges = vIn.getEdges(Vertex.DIRECTION.IN).iterator();
- Assertions.assertFalse(edges.hasNext());
+ assertThat(edges.hasNext()).isFalse();
// RELOAD AND CHECK AGAIN
// -----------------------
try {
database.lookupByRID(e2.getIdentity(), true);
- Assertions.fail("Expected deleted record");
+ fail("Expected deleted record");
} catch (final RecordNotFoundException e) {
}
vOut = e2.getOutVertex();
edges = vOut.getEdges(Vertex.DIRECTION.OUT).iterator();
- Assertions.assertTrue(edges.hasNext());
+ assertThat(edges.hasNext()).isTrue();
edges.next();
- Assertions.assertFalse(edges.hasNext());
+ assertThat(edges.hasNext()).isFalse();
vIn = e2.getInVertex();
edges = vIn.getEdges(Vertex.DIRECTION.IN).iterator();
- Assertions.assertFalse(edges.hasNext());
+ assertThat(edges.hasNext()).isFalse();
} finally {
database.commit();
@@ -351,34 +356,34 @@ public void deleteEdgesFromEdgeIterator() {
try {
final Vertex v1 = (Vertex) database.lookupByRID(root, false);
- Assertions.assertNotNull(v1);
+ assertThat(v1).isNotNull();
Iterator edges = v1.getEdges(Vertex.DIRECTION.OUT).iterator();
- Assertions.assertTrue(edges.hasNext());
+ assertThat(edges.hasNext()).isTrue();
final Edge e3 = edges.next();
- Assertions.assertNotNull(e3);
+ assertThat(e3).isNotNull();
- Assertions.assertTrue(edges.hasNext());
+ assertThat(edges.hasNext()).isTrue();
final Edge e2 = edges.next();
- Assertions.assertNotNull(e2);
+ assertThat(e2).isNotNull();
// DELETE THE EDGE
// -----------------------
edges.remove();
- Assertions.assertFalse(edges.hasNext());
+ assertThat(edges.hasNext()).isFalse();
try {
e2.getOutVertex();
- Assertions.fail();
+ fail("");
} catch (RecordNotFoundException e) {
// EXPECTED
}
try {
e2.getInVertex();
- Assertions.fail();
+ fail("");
} catch (RecordNotFoundException e) {
// EXPECTED
}
@@ -387,7 +392,7 @@ public void deleteEdgesFromEdgeIterator() {
// -----------------------
try {
database.lookupByRID(e2.getIdentity(), true);
- Assertions.fail("Expected deleted record");
+ fail("Expected deleted record");
} catch (final RecordNotFoundException e) {
// EXPECTED
}
@@ -408,36 +413,36 @@ public void selfLoopEdges() {
database.command("sql", "create edge " + EDGE1_TYPE_NAME + " from ? to ? unidirectional", v1, v1);
- Assertions.assertTrue(v1.getVertices(Vertex.DIRECTION.OUT).iterator().hasNext());
- Assertions.assertEquals(v1, v1.getVertices(Vertex.DIRECTION.OUT).iterator().next());
- Assertions.assertFalse(v1.getVertices(Vertex.DIRECTION.IN).iterator().hasNext());
+ assertThat(v1.getVertices(Vertex.DIRECTION.OUT).iterator().hasNext()).isTrue();
+ assertThat(v1.getVertices(Vertex.DIRECTION.OUT).iterator().next()).isEqualTo(v1);
+ assertThat(v1.getVertices(Vertex.DIRECTION.IN).iterator().hasNext()).isFalse();
// BIDIRECTIONAL EDGE
final Vertex v2 = database.newVertex(VERTEX1_TYPE_NAME).save();
v2.newEdge(EDGE1_TYPE_NAME, v2, true).save();
- Assertions.assertTrue(v2.getVertices(Vertex.DIRECTION.OUT).iterator().hasNext());
- Assertions.assertEquals(v2, v2.getVertices(Vertex.DIRECTION.OUT).iterator().next());
+ assertThat(v2.getVertices(Vertex.DIRECTION.OUT).iterator().hasNext()).isTrue();
+ assertThat(v2.getVertices(Vertex.DIRECTION.OUT).iterator().next()).isEqualTo(v2);
- Assertions.assertTrue(v2.getVertices(Vertex.DIRECTION.IN).iterator().hasNext());
- Assertions.assertEquals(v2, v2.getVertices(Vertex.DIRECTION.IN).iterator().next());
+ assertThat(v2.getVertices(Vertex.DIRECTION.IN).iterator().hasNext()).isTrue();
+ assertThat(v2.getVertices(Vertex.DIRECTION.IN).iterator().next()).isEqualTo(v2);
database.commit();
// UNIDIRECTIONAL EDGE
final Vertex v1reloaded = (Vertex) database.lookupByRID(v1.getIdentity(), true);
- Assertions.assertTrue(v1reloaded.getVertices(Vertex.DIRECTION.OUT).iterator().hasNext());
- Assertions.assertEquals(v1reloaded, v1reloaded.getVertices(Vertex.DIRECTION.OUT).iterator().next());
- Assertions.assertFalse(v1reloaded.getVertices(Vertex.DIRECTION.IN).iterator().hasNext());
+ assertThat(v1reloaded.getVertices(Vertex.DIRECTION.OUT).iterator().hasNext()).isTrue();
+ assertThat(v1reloaded.getVertices(Vertex.DIRECTION.OUT).iterator().next()).isEqualTo(v1reloaded);
+ assertThat(v1reloaded.getVertices(Vertex.DIRECTION.IN).iterator().hasNext()).isFalse();
// BIDIRECTIONAL EDGE
final Vertex v2reloaded = (Vertex) database.lookupByRID(v2.getIdentity(), true);
- Assertions.assertTrue(v2reloaded.getVertices(Vertex.DIRECTION.OUT).iterator().hasNext());
- Assertions.assertEquals(v2reloaded, v2reloaded.getVertices(Vertex.DIRECTION.OUT).iterator().next());
+ assertThat(v2reloaded.getVertices(Vertex.DIRECTION.OUT).iterator().hasNext()).isTrue();
+ assertThat(v2reloaded.getVertices(Vertex.DIRECTION.OUT).iterator().next()).isEqualTo(v2reloaded);
- Assertions.assertTrue(v2reloaded.getVertices(Vertex.DIRECTION.IN).iterator().hasNext());
- Assertions.assertEquals(v2reloaded, v2reloaded.getVertices(Vertex.DIRECTION.IN).iterator().next());
+ assertThat(v2reloaded.getVertices(Vertex.DIRECTION.IN).iterator().hasNext()).isTrue();
+ assertThat(v2reloaded.getVertices(Vertex.DIRECTION.IN).iterator().next()).isEqualTo(v2reloaded);
} finally {
new DatabaseChecker(database).setVerboseLevel(0).check();
@@ -460,15 +465,17 @@ public void shortestPath() {
final Record v2 = v2Iterator.next();
final ResultSet result = database.query("sql", "select shortestPath(?,?) as sp", v1, v2);
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result line = result.next();
- Assertions.assertNotNull(line);
- Assertions.assertTrue(line.getPropertyNames().contains("sp"));
- Assertions.assertNotNull(line.getProperty("sp"));
- Assertions.assertEquals(2, ((List) line.getProperty("sp")).size());
- Assertions.assertEquals(v1, ((List) line.getProperty("sp")).get(0));
- Assertions.assertEquals(v2, ((List) line.getProperty("sp")).get(1));
+ assertThat(line).isNotNull();
+ assertThat(line.getPropertyNames().contains("sp")).isTrue();
+ List sp = line.>getProperty("sp");
+ assertThat(sp).isNotNull();
+ assertThat(sp).hasSize(2);
+
+ assertThat(sp.get(0)).isEqualTo(v1);
+ assertThat(sp.get(1)).isEqualTo(v2);
}
}
@@ -495,12 +502,12 @@ public String getSyntax() {
});
final ResultSet result = database.query("sql", "select ciao() as ciao");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result line = result.next();
- Assertions.assertNotNull(line);
- Assertions.assertTrue(line.getPropertyNames().contains("ciao"));
- Assertions.assertEquals("Ciao", line.getProperty("ciao"));
+ assertThat(line).isNotNull();
+ assertThat(line.getPropertyNames().contains("ciao")).isTrue();
+ assertThat(line.getProperty("ciao")).isEqualTo("Ciao");
} finally {
new DatabaseChecker(database).setVerboseLevel(0).check();
@@ -518,12 +525,12 @@ public void customReflectionFunction() {
((SQLQueryEngine) database.getQueryEngine("sql")).getFunctionFactory().getReflectionFactory().register("test_", getClass());
final ResultSet result = database.query("sql", "select test_testReflectionMethod() as testReflectionMethod");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result line = result.next();
- Assertions.assertNotNull(line);
- Assertions.assertTrue(line.getPropertyNames().contains("testReflectionMethod"));
- Assertions.assertEquals("reflect on this", line.getProperty("testReflectionMethod"));
+ assertThat(line).isNotNull();
+ assertThat(line.getPropertyNames().contains("testReflectionMethod")).isTrue();
+ assertThat(line.getProperty("testReflectionMethod")).isEqualTo("reflect on this");
} finally {
new DatabaseChecker(database).setVerboseLevel(0).check();
@@ -563,7 +570,7 @@ public void rollbackEdge() {
v2.set("rid", v1RID.get());
v2.save();
- Assertions.assertFalse(v1a.isConnectedTo(v2));
+ assertThat(v1a.isConnectedTo(v2)).isFalse();
});
}
@@ -589,13 +596,13 @@ public void reuseRollbackedTx() {
v2.set("rid", v1RID.get());
v2.save();
- Assertions.fail();
+ fail("");
} catch (final RuntimeException e) {
// EXPECTED
}
- Assertions.assertFalse(v1a.isConnectedTo(v2));
+ assertThat(v1a.isConnectedTo(v2)).isFalse();
}
@Test
@@ -613,7 +620,7 @@ public void edgeUnivocity() {
try {
database.transaction(() -> v1[0].newEdge("OnlyOneBetweenVertices", v2[0], true));
- Assertions.fail();
+ fail("");
} catch (final DuplicatedKeyException ex) {
// EXPECTED
}
@@ -649,19 +656,19 @@ public void edgeUnivocitySQL() {
v1[0] = database.newVertex(VERTEX1_TYPE_NAME).set("id", 1001).save();
v2[0] = database.newVertex(VERTEX1_TYPE_NAME).set("id", 1002).save();
final ResultSet result = database.command("sql", "create edge OnlyOneBetweenVertices from ? to ?", v1[0], v2[0]);
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
});
try {
database.transaction(() -> v1[0].newEdge("OnlyOneBetweenVertices", v2[0], true));
- Assertions.fail();
+ fail("");
} catch (final DuplicatedKeyException ex) {
// EXPECTED
}
try {
database.transaction(() -> database.command("sql", "create edge OnlyOneBetweenVertices from ? to ?", v1[0], v2[0]));
- Assertions.fail();
+ fail("");
} catch (final DuplicatedKeyException ex) {
// EXPECTED
}
@@ -681,19 +688,19 @@ public void edgeConstraints() {
v1[0] = database.newVertex(VERTEX1_TYPE_NAME).set("id", 1001).save();
v2[0] = database.newVertex(VERTEX2_TYPE_NAME).set("id", 1002).save();
final ResultSet result = database.command("sql", "create edge EdgeConstraint from ? to ?", v1[0], v2[0]);
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
});
try {
database.transaction(() -> v2[0].newEdge("EdgeConstraint", v1[0], true));
- Assertions.fail();
+ fail("");
} catch (final ValidationException ex) {
// EXPECTED
}
try {
database.transaction(() -> database.command("sql", "create edge EdgeConstraint from ? to ?", v2[0], v1[0]));
- Assertions.fail();
+ fail("");
} catch (final ValidationException ex) {
// EXPECTED
}
@@ -711,7 +718,7 @@ public void testEdgeTypeNotFromVertex() {
try {
final Edge e1 = v1.newEdge("a-vertex", v2, /*= bidirectional */ true); // <-- expect IllegalArgumentException
- Assertions.fail("Created an edge of vertex type");
+ fail("Created an edge of vertex type");
} catch (final ClassCastException e) {
// EXPECTED
}
@@ -732,7 +739,7 @@ public void testEdgeDescendantOrder() {
final Iterator vertices = v1.getVertices(Vertex.DIRECTION.OUT).iterator();
for (int i = 10000 - 1; vertices.hasNext(); --i) {
- Assertions.assertEquals(i, vertices.next().get("id"));
+ assertThat(vertices.next().get("id")).isEqualTo(i);
}
});
}
diff --git a/engine/src/test/java/com/arcadedb/graph/InsertGraphIndexTest.java b/engine/src/test/java/com/arcadedb/graph/InsertGraphIndexTest.java
index c0497dc4f9..370d5149d9 100644
--- a/engine/src/test/java/com/arcadedb/graph/InsertGraphIndexTest.java
+++ b/engine/src/test/java/com/arcadedb/graph/InsertGraphIndexTest.java
@@ -26,11 +26,12 @@
import com.arcadedb.log.LogManager;
import com.arcadedb.schema.Schema;
import com.arcadedb.schema.VertexType;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.logging.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class InsertGraphIndexTest extends TestHelper {
private static final int VERTICES = 1_000;
private static final int EDGES_PER_VERTEX = 1_000;
@@ -125,7 +126,7 @@ private Vertex[] loadVertices() {
}
});
- Assertions.assertEquals(VERTICES, cachedVertices.length);
+ assertThat(cachedVertices.length).isEqualTo(VERTICES);
return cachedVertices;
}
@@ -162,7 +163,7 @@ public void call(final Throwable exception) {
database.async().waitCompletion();
- Assertions.assertEquals(VERTICES, database.countType(VERTEX_TYPE_NAME, true));
+ assertThat(database.countType(VERTEX_TYPE_NAME, true)).isEqualTo(VERTICES);
} finally {
final long elapsed = System.currentTimeMillis() - startOfTest;
@@ -175,7 +176,7 @@ private void createSchema() {
vertex.createProperty("id", Integer.class);
database.getSchema().createTypeIndex(Schema.INDEX_TYPE.LSM_TREE, true, VERTEX_TYPE_NAME, "id");
- Assertions.assertEquals("round-robin", vertex.getBucketSelectionStrategy().getName());
+ assertThat(vertex.getBucketSelectionStrategy().getName()).isEqualTo("round-robin");
database.getSchema().buildEdgeType().withName(EDGE_TYPE_NAME).withTotalBuckets(PARALLEL).create();
@@ -183,10 +184,10 @@ private void createSchema() {
vertexNotInUse.createProperty("id", Integer.class);
database.getSchema().createTypeIndex(Schema.INDEX_TYPE.LSM_TREE, true, "NotInUse", "id");
- Assertions.assertEquals("round-robin", vertexNotInUse.getBucketSelectionStrategy().getName());
+ assertThat(vertexNotInUse.getBucketSelectionStrategy().getName()).isEqualTo("round-robin");
vertexNotInUse.setBucketSelectionStrategy("partitioned('id')");
- Assertions.assertEquals("partitioned", vertexNotInUse.getBucketSelectionStrategy().getName());
+ assertThat(vertexNotInUse.getBucketSelectionStrategy().getName()).isEqualTo("partitioned");
}
@@ -202,10 +203,10 @@ private void checkGraph(final Vertex[] cachedVertices) {
for (; i < VERTICES; ++i) {
int edges = 0;
final long outEdges = cachedVertices[i].countEdges(Vertex.DIRECTION.OUT, EDGE_TYPE_NAME);
- Assertions.assertEquals(expectedEdges, outEdges);
+ assertThat(outEdges).isEqualTo(expectedEdges);
final long inEdges = cachedVertices[i].countEdges(Vertex.DIRECTION.IN, EDGE_TYPE_NAME);
- Assertions.assertEquals(expectedEdges, inEdges);
+ assertThat(inEdges).isEqualTo(expectedEdges);
if (++edges > EDGES_PER_VERTEX)
break;
diff --git a/engine/src/test/java/com/arcadedb/graph/TestVertexDelete.java b/engine/src/test/java/com/arcadedb/graph/TestVertexDelete.java
index a9fcb52761..23dc9a8191 100644
--- a/engine/src/test/java/com/arcadedb/graph/TestVertexDelete.java
+++ b/engine/src/test/java/com/arcadedb/graph/TestVertexDelete.java
@@ -2,13 +2,15 @@
import com.arcadedb.database.Database;
import com.arcadedb.database.DatabaseFactory;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.Test;
import java.io.*;
import java.nio.file.*;
import java.util.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class TestVertexDelete {
public static class DeleteOnClose implements AutoCloseable {
public DeleteOnClose(Path p) {
@@ -58,8 +60,8 @@ public void testFullEdgeDeletion() throws IOException, InterruptedException {
db.transaction(() -> {
var v1c = db.countType("v1", false);
var pc = db.countType("hasParent", false);
- Assertions.assertEquals(0, v1c);
- Assertions.assertEquals(0, pc);
+ assertThat(v1c).isEqualTo(0);
+ assertThat(pc).isEqualTo(0);
});
}
}
diff --git a/engine/src/test/java/com/arcadedb/graph/TxGraphTest.java b/engine/src/test/java/com/arcadedb/graph/TxGraphTest.java
index bbe190ceaf..afb20aae2a 100644
--- a/engine/src/test/java/com/arcadedb/graph/TxGraphTest.java
+++ b/engine/src/test/java/com/arcadedb/graph/TxGraphTest.java
@@ -22,9 +22,14 @@
import com.arcadedb.database.RID;
import com.arcadedb.query.sql.executor.Result;
import com.arcadedb.query.sql.executor.ResultSet;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
+import java.util.Date;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
public class TxGraphTest extends TestHelper {
protected static final String DB_PATH = "target/databases/graph";
@@ -50,38 +55,38 @@ public void testEdgeChunkIsLoadedFromCurrentTx() {
commodore[0].asVertex(false).newEdge("SELLS", vic20, true).set("date", System.currentTimeMillis()).save();
- Assertions.assertEquals(2, commodore[0].asVertex().countEdges(Vertex.DIRECTION.OUT, "SELLS"));
+ assertThat(commodore[0].asVertex().countEdges(Vertex.DIRECTION.OUT,"SELLS")).isEqualTo(2);
ResultSet result = database.query("sql", "select expand( in().include('name') ) from Good");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
while (result.hasNext()) {
final Result next = result.next();
- Assertions.assertNotNull(next.getProperty("name"));
- Assertions.assertNull(next.getProperty("date"));
+ assertThat(next.getProperty("name")).isNotNull();
+ assertThat(next.getProperty("date")).isNull();
}
result = database.query("sql", "select expand( in().include('date') ) from Good");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
while (result.hasNext()) {
final Result next = result.next();
- Assertions.assertNotNull(next.getProperty("date"));
- Assertions.assertNull(next.getProperty("name"));
+ assertThat(next.getProperty("date")).isNotNull();
+ assertThat(next.getProperty("name")).isNull();
}
result = database.query("sql", "select expand( in().exclude('name') ) from Good");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
while (result.hasNext()) {
final Result next = result.next();
- Assertions.assertNotNull(next.getProperty("date"));
- Assertions.assertNull(next.getProperty("name"));
+ assertThat(next.getProperty("date")).isNotNull();
+ assertThat(next.getProperty("name")).isNull();
}
result = database.query("sql", "select expand( in().exclude('date') ) from Good");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
while (result.hasNext()) {
final Result next = result.next();
- Assertions.assertNotNull(next.getProperty("name"));
- Assertions.assertNull(next.getProperty("date"));
+ assertThat(next.getProperty("date")).isNull();
+ assertThat(next.getProperty("name")).isNotNull();
}
});
}
diff --git a/engine/src/test/java/com/arcadedb/index/CompressedRID2RIDIndexTest.java b/engine/src/test/java/com/arcadedb/index/CompressedRID2RIDIndexTest.java
index 27253125cc..8242e1d9c4 100644
--- a/engine/src/test/java/com/arcadedb/index/CompressedRID2RIDIndexTest.java
+++ b/engine/src/test/java/com/arcadedb/index/CompressedRID2RIDIndexTest.java
@@ -20,9 +20,10 @@
import com.arcadedb.TestHelper;
import com.arcadedb.database.RID;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class CompressedRID2RIDIndexTest extends TestHelper {
private static final int TOT = 10_000_000;
@@ -34,21 +35,21 @@ public void testIndexPutAndGet() throws ClassNotFoundException {
index.put(new RID(database, 3, i), new RID(database, 4, i));
for (int i = 0; i < TOT; i++)
- Assertions.assertEquals(new RID(database, 4, i), index.get(new RID(database, 3, i)));
+ assertThat(index.get(new RID(database, 3, i))).isEqualTo(new RID(database, 4, i));
int found = 0;
for (CompressedRID2RIDIndex.EntryIterator it = index.entryIterator(); it.hasNext(); ) {
final RID key = it.getKeyRID();
final RID value = it.getValueRID();
- Assertions.assertEquals(3, key.getBucketId());
- Assertions.assertEquals(4, value.getBucketId());
- Assertions.assertEquals(key.getPosition(), value.getPosition());
+ assertThat(key.getBucketId()).isEqualTo(3);
+ assertThat(value.getBucketId()).isEqualTo(4);
+ assertThat(value.getPosition()).isEqualTo(key.getPosition());
++found;
it.moveNext();
}
- Assertions.assertEquals(TOT, found);
+ assertThat(found).isEqualTo(TOT);
}
}
diff --git a/engine/src/test/java/com/arcadedb/index/DropIndexTest.java b/engine/src/test/java/com/arcadedb/index/DropIndexTest.java
index cec5322066..14c4924ed0 100644
--- a/engine/src/test/java/com/arcadedb/index/DropIndexTest.java
+++ b/engine/src/test/java/com/arcadedb/index/DropIndexTest.java
@@ -26,11 +26,14 @@
import com.arcadedb.index.lsm.LSMTreeIndexAbstract;
import com.arcadedb.schema.DocumentType;
import com.arcadedb.schema.Schema;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class DropIndexTest extends TestHelper {
private static final int TOT = 10;
private static final String TYPE_NAME = "V";
@@ -40,7 +43,7 @@ public class DropIndexTest extends TestHelper {
@Test
public void testDropAndRecreate() {
- Assertions.assertFalse(database.getSchema().existsType(TYPE_NAME));
+ assertThat(database.getSchema().existsType(TYPE_NAME)).isFalse();
final DocumentType type = database.getSchema().buildDocumentType().withName(TYPE_NAME).withTotalBuckets(3).create();
final DocumentType type2 = database.getSchema().buildDocumentType().withName(TYPE_NAME2).withTotalBuckets(3).create();
@@ -70,9 +73,9 @@ public void testDropAndRecreate() {
database.commit();
- Assertions.assertEquals(TOT + 1, database.countType(TYPE_NAME, true));
- Assertions.assertEquals(TOT, database.countType(TYPE_NAME2, false));
- Assertions.assertEquals(1, database.countType(TYPE_NAME, false));
+ Assertions.assertThat(database.countType(TYPE_NAME, true)).isEqualTo(TOT + 1);
+ Assertions.assertThat(database.countType(TYPE_NAME2, false)).isEqualTo(TOT);
+ Assertions.assertThat(database.countType(TYPE_NAME, false)).isEqualTo(1);
database.begin();
@@ -98,9 +101,9 @@ public void testDropAndRecreate() {
final Index typeIndex3 = database.getSchema()
.createTypeIndex(Schema.INDEX_TYPE.LSM_TREE, true, TYPE_NAME, new String[] { "id" }, PAGE_SIZE);
- Assertions.assertEquals(TOT + 1, database.countType(TYPE_NAME, true));
- Assertions.assertEquals(TOT, database.countType(TYPE_NAME2, false));
- Assertions.assertEquals(1, database.countType(TYPE_NAME, false));
+ Assertions.assertThat(database.countType(TYPE_NAME, true)).isEqualTo(TOT + 1);
+ Assertions.assertThat(database.countType(TYPE_NAME2, false)).isEqualTo(TOT);
+ Assertions.assertThat(database.countType(TYPE_NAME, false)).isEqualTo(1);
for (int i = 0; i < TOT; ++i) {
final MutableDocument v2 = database.newDocument(TYPE_NAME2);
@@ -114,26 +117,26 @@ public void testDropAndRecreate() {
v3.set("id", TOT * 3 + 1);
v3.save();
- Assertions.assertEquals(TOT * 2 + 2, database.countType(TYPE_NAME, true));
- Assertions.assertEquals(TOT * 2, database.countType(TYPE_NAME2, false));
- Assertions.assertEquals(2, database.countType(TYPE_NAME, false));
+ Assertions.assertThat(database.countType(TYPE_NAME, true)).isEqualTo(TOT * 2 + 2);
+ Assertions.assertThat(database.countType(TYPE_NAME2, true)).isEqualTo(TOT * 2);
+ Assertions.assertThat(database.countType(TYPE_NAME, false)).isEqualTo(2);
}, false, 0);
}
@Test
public void testDropAndRecreateTypeWithIndex() {
- Assertions.assertFalse(database.getSchema().existsType(TYPE_NAME));
+ assertThat(database.getSchema().existsType(TYPE_NAME)).isFalse();
final DocumentType type = database.getSchema().buildDocumentType().withName(TYPE_NAME).withTotalBuckets(3).create();
final DocumentType type2 = database.getSchema().buildDocumentType().withName(TYPE_NAME2).withTotalBuckets(3)
.withSuperType(type.getName()).create();
- Assertions.assertEquals(type.getName(), type2.getSuperTypes().get(0).getName());
+ assertThat(type2.getSuperTypes().get(0).getName()).isEqualTo(type.getName());
final DocumentType type3 = database.getSchema().buildDocumentType().withName(TYPE_NAME3).withTotalBuckets(3)
.withSuperType(type2.getName()).create();
- Assertions.assertEquals(type.getName(), type2.getSuperTypes().get(0).getName());
+ assertThat(type2.getSuperTypes().get(0).getName()).isEqualTo(type.getName());
type.createProperty("id", Integer.class);
type.createProperty("name", String.class);
@@ -196,33 +199,33 @@ public void testDropAndRecreateTypeWithIndex() {
// CHECK TYPE HAS BEEN REMOVED FROM INHERITANCE
for (final DocumentType parent : type2.getSuperTypes())
- Assertions.assertFalse(parent.getSubTypes().contains(type2));
+ Assertions.assertThat(parent.getSubTypes().contains(type2)).isFalse();
for (final DocumentType sub : type2.getSubTypes())
- Assertions.assertFalse(sub.getSuperTypes().contains(type2));
+ Assertions.assertThat(sub.getSuperTypes().contains(type2)).isFalse();
// CHECK INHERITANCE CHAIN IS CONSISTENT
for (final DocumentType parent : type2.getSuperTypes())
- Assertions.assertTrue(parent.getSubTypes().contains(type2.getSubTypes().get(0)));
+ Assertions.assertThat(parent.getSubTypes().contains(type2.getSubTypes().get(0))).isTrue();
- Assertions.assertEquals(1, database.countType(TYPE_NAME, true));
+ Assertions.assertThat(database.countType(TYPE_NAME, true)).isEqualTo(1);
final DocumentType newType = database.getSchema().getOrCreateDocumentType(TYPE_NAME2);
- Assertions.assertEquals(1, database.countType(TYPE_NAME, true));
- Assertions.assertEquals(0, database.countType(TYPE_NAME2, true));
+ Assertions.assertThat(database.countType(TYPE_NAME, true)).isEqualTo(1);
+ Assertions.assertThat(database.countType(TYPE_NAME2, true)).isEqualTo(0);
newType.addSuperType(TYPE_NAME);
// CHECK INHERITANCE CHAIN IS CONSISTENT AGAIN
for (final DocumentType parent : newType.getSuperTypes())
- Assertions.assertTrue(parent.getSubTypes().contains(newType));
+ Assertions.assertThat(parent.getSubTypes().contains(newType)).isTrue();
for (final DocumentType sub : newType.getSubTypes())
- Assertions.assertTrue(sub.getSuperTypes().contains(newType));
+ Assertions.assertThat(sub.getSuperTypes().contains(newType)).isTrue();
- Assertions.assertEquals(1, database.countType(TYPE_NAME, true));
- Assertions.assertEquals(0, database.countType(TYPE_NAME2, true));
+ Assertions.assertThat(database.countType(TYPE_NAME, true)).isEqualTo(1);
+ Assertions.assertThat(database.countType(TYPE_NAME2, true)).isEqualTo(0);
database.begin();
@@ -242,9 +245,9 @@ public void testDropAndRecreateTypeWithIndex() {
v3.set("id", TOT);
v3.save();
- Assertions.assertEquals(TOT + 2, database.countType(TYPE_NAME, true));
- Assertions.assertEquals(TOT, database.countType(TYPE_NAME2, false));
- Assertions.assertEquals(2, database.countType(TYPE_NAME, false));
+ Assertions.assertThat(database.countType(TYPE_NAME, true)).isEqualTo(TOT + 2);
+ Assertions.assertThat(database.countType(TYPE_NAME2, false)).isEqualTo(TOT);
+ Assertions.assertThat(database.countType(TYPE_NAME, false)).isEqualTo(2);
type.setBucketSelectionStrategy(new RoundRobinBucketSelectionStrategy());
diff --git a/engine/src/test/java/com/arcadedb/index/LSMTreeFullTextIndexTest.java b/engine/src/test/java/com/arcadedb/index/LSMTreeFullTextIndexTest.java
index 2a97ee96ca..97faf65d0f 100644
--- a/engine/src/test/java/com/arcadedb/index/LSMTreeFullTextIndexTest.java
+++ b/engine/src/test/java/com/arcadedb/index/LSMTreeFullTextIndexTest.java
@@ -27,11 +27,15 @@
import com.arcadedb.query.sql.executor.ResultSet;
import com.arcadedb.schema.DocumentType;
import com.arcadedb.schema.Schema;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
public class LSMTreeFullTextIndexTest extends TestHelper {
private static final int TOT = 10000;
private static final String TYPE_NAME = "V";
@@ -39,14 +43,14 @@ public class LSMTreeFullTextIndexTest extends TestHelper {
@Test
public void testIndexing() {
- Assertions.assertFalse(database.getSchema().existsType(TYPE_NAME));
+ assertThat(database.getSchema().existsType(TYPE_NAME)).isFalse();
final DocumentType type = database.getSchema().buildDocumentType().withName(TYPE_NAME).withTotalBuckets(1).create();
type.createProperty("text", String.class);
final Index typeIndex = database.getSchema()
.createTypeIndex(Schema.INDEX_TYPE.FULL_TEXT, false, TYPE_NAME, new String[] { "text" }, PAGE_SIZE);
- Assertions.assertTrue(database.getSchema().existsType(TYPE_NAME));
+ assertThat(database.getSchema().existsType(TYPE_NAME)).isTrue();
final String text =
"Jay Glenn Miner (May 31, 1932 – June 20, 1994) was an American integrated circuit designer, known primarily for developing multimedia chips for the Atari 2600 and Atari 8-bit family and as the \"father of the Amiga\". He received a BS in EECS from UC Berkeley in 1959.[2]\n"
@@ -77,7 +81,7 @@ public void testIndexing() {
final List keywords = ((LSMTreeFullTextIndex) ((TypeIndex) typeIndex).getIndexesOnBuckets()[0]).analyzeText(
((LSMTreeFullTextIndex) ((TypeIndex) typeIndex).getIndexesOnBuckets()[0]).getAnalyzer(), new Object[] { text });
- Assertions.assertFalse(keywords.isEmpty());
+ assertThat(keywords.isEmpty()).isFalse();
for (final String k : keywords) {
int totalPerKeyword = 0;
@@ -94,24 +98,24 @@ public void testIndexing() {
++totalPerIndex;
}
- Assertions.assertEquals(result.estimateSize(), totalPerIndex);
+ assertThat(totalPerIndex).isEqualTo(result.estimateSize());
totalPerKeyword += totalPerIndex;
}
- Assertions.assertEquals(TOT, totalPerKeyword);
+ assertThat(totalPerKeyword).isEqualTo(TOT);
}
});
reopenDatabase();
- Assertions.assertEquals(Schema.INDEX_TYPE.FULL_TEXT, database.getSchema().getIndexes()[0].getType());
+ assertThat(database.getSchema().getIndexes()[0].getType()).isEqualTo(Schema.INDEX_TYPE.FULL_TEXT);
database.getSchema().dropIndex(typeIndex.getName());
}
@Test
public void testIndexingComposite() {
- Assertions.assertFalse(database.getSchema().existsType(TYPE_NAME));
+ assertThat(database.getSchema().existsType(TYPE_NAME)).isFalse();
final DocumentType type = database.getSchema().buildDocumentType().withName(TYPE_NAME).withTotalBuckets(1).create();
type.createProperty("text", String.class);
@@ -119,7 +123,7 @@ public void testIndexingComposite() {
try {
database.getSchema()
.createTypeIndex(Schema.INDEX_TYPE.FULL_TEXT, false, TYPE_NAME, new String[] { "text", "type" }, PAGE_SIZE);
- Assertions.fail();
+ fail("");
} catch (IndexException e) {
// EXPECTED
}
@@ -128,14 +132,14 @@ public void testIndexingComposite() {
@Test
public void testQuery() {
database.transaction(() -> {
- Assertions.assertFalse(database.getSchema().existsType("Docs"));
+ assertThat(database.getSchema().existsType("Docs")).isFalse();
final DocumentType type = database.getSchema().createDocumentType("Docs");
type.createProperty("text", String.class);
final Index typeIndex = database.getSchema()
.createTypeIndex(Schema.INDEX_TYPE.FULL_TEXT, false, "Docs", new String[] { "text" });
- Assertions.assertTrue(database.getSchema().existsType("Docs"));
+ assertThat(database.getSchema().existsType("Docs")).isTrue();
final String text =
"Jay Glenn Miner (May 31, 1932 – June 20, 1994) was an American integrated circuit designer, known primarily for developing multimedia chips for the Atari 2600 and Atari 8-bit family and as the \"father of the Amiga\". He received a BS in EECS from UC Berkeley in 1959.[2]\n"
@@ -178,13 +182,17 @@ public void testQuery() {
continue;
final ResultSet result = database.query("sql", "select from Docs where text = '" + toFind + "'", toFind);
- Assertions.assertTrue(result.hasNext(), "Cannot find key '" + toFind + "'");
+ assertThat(result.hasNext())
+ .isTrue()
+ .withFailMessage("Cannot find key '" + toFind + "'");
final Result res = result.next();
- Assertions.assertNotNull(res);
+ assertThat(res).isNotNull();
final String content = res.getProperty("text").toString().toLowerCase();
- Assertions.assertTrue(content.contains(toFind), "Cannot find the word '" + toFind + "' in indexed text '" + content + "'");
+ assertThat(content.contains(toFind))
+ .isTrue()
+ .withFailMessage("Cannot find the word '" + toFind + "' in indexed text '" + content + "'");
}
});
}
@@ -198,7 +206,7 @@ public void testNullValuesViaSQL() {
database.command("sql", "CREATE INDEX ON doc (str) FULL_TEXT null_strategy error");
database.command("sql", "INSERT INTO doc (str) VALUES ('a'), ('b'), (null)");
});
- Assertions.fail();
+ fail("");
} catch (TransactionException e) {
}
diff --git a/engine/src/test/java/com/arcadedb/index/LSMTreeIndexCompactionTest.java b/engine/src/test/java/com/arcadedb/index/LSMTreeIndexCompactionTest.java
index ab7b099164..db57d889e1 100644
--- a/engine/src/test/java/com/arcadedb/index/LSMTreeIndexCompactionTest.java
+++ b/engine/src/test/java/com/arcadedb/index/LSMTreeIndexCompactionTest.java
@@ -29,13 +29,16 @@
import com.arcadedb.log.LogManager;
import com.arcadedb.schema.DocumentType;
import com.arcadedb.schema.Schema;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.Test;
import java.util.*;
import java.util.concurrent.*;
import java.util.logging.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
/**
* This test stresses the index compaction by forcing using only 1MB of RAM for compaction causing multiple page compacted index.
*
@@ -110,7 +113,7 @@ public void run() {
checkRanges(1, 3);
} catch (final InterruptedException e) {
- Assertions.fail(e);
+ fail("", e);
} finally {
GlobalConfiguration.INDEX_COMPACTION_RAM_MB.setValue(300);
GlobalConfiguration.INDEX_COMPACTION_MIN_PAGES_SCHEDULE.setValue(10);
@@ -125,7 +128,7 @@ private void compaction() {
((IndexInternal) index).scheduleCompaction();
((IndexInternal) index).compact();
} catch (final Exception e) {
- Assertions.fail(e);
+ fail("", e);
}
}
}
@@ -161,7 +164,7 @@ private void insertData() {
public void call(final Throwable exception) {
LogManager.instance().log(this, Level.SEVERE, "TEST: ERROR: ", exception);
exception.printStackTrace();
- Assertions.fail(exception);
+ fail(exception);
}
});
@@ -209,7 +212,7 @@ public void execute() {
}
private void checkLookups(final int step, final int expectedItemsPerSameKey) {
- database.transaction(() -> Assertions.assertEquals(TOT * expectedItemsPerSameKey, database.countType(TYPE_NAME, false)));
+ database.transaction(() -> assertThat(database.countType(TYPE_NAME,false)).isEqualTo(TOT * expectedItemsPerSameKey));
LogManager.instance().log(this, Level.FINE, "TEST: Lookup all the keys...");
@@ -220,20 +223,20 @@ private void checkLookups(final int step, final int expectedItemsPerSameKey) {
for (long id = 0; id < TOT; id += step) {
try {
final IndexCursor records = database.lookupByKey(TYPE_NAME, new String[] { "id" }, new Object[] { id });
- Assertions.assertNotNull(records);
+ assertThat(Optional.ofNullable(records)).isNotNull();
int count = 0;
for (final Iterator it = records.iterator(); it.hasNext(); ) {
final Identifiable rid = it.next();
final Document record = (Document) rid.getRecord();
- Assertions.assertEquals("" + id, record.get("id"));
+ assertThat(record.get("id")).isEqualTo("" + id);
++count;
}
if (count != expectedItemsPerSameKey)
LogManager.instance().log(this, Level.FINE, "Cannot find key '%s'", null, id);
- Assertions.assertEquals(expectedItemsPerSameKey, count, "Wrong result for lookup of key " + id);
+ assertThat(count).as("Wrong result for lookup of key " + id).isEqualTo(expectedItemsPerSameKey);
checked++;
@@ -245,14 +248,14 @@ private void checkLookups(final int step, final int expectedItemsPerSameKey) {
begin = System.currentTimeMillis();
}
} catch (final Exception e) {
- Assertions.fail("Error on lookup key " + id, e);
+ fail("Error on lookup key " + id, e);
}
}
LogManager.instance().log(this, Level.FINE, "TEST: Lookup finished in " + (System.currentTimeMillis() - begin) + "ms");
}
private void checkRanges(final int step, final int expectedItemsPerSameKey) {
- database.transaction(() -> Assertions.assertEquals(TOT * expectedItemsPerSameKey, database.countType(TYPE_NAME, false)));
+ database.transaction(() -> assertThat(database.countType(TYPE_NAME,false)).isEqualTo(TOT * expectedItemsPerSameKey));
LogManager.instance().log(this, Level.FINE, "TEST: Range pair of keys...");
@@ -265,14 +268,14 @@ private void checkRanges(final int step, final int expectedItemsPerSameKey) {
for (long number = 0; number < TOT - 1; number += step) {
try {
final IndexCursor records = ((RangeIndex) index).range(true, new Object[] { number }, true, new Object[] { number + 1 }, true);
- Assertions.assertNotNull(records);
+ assertThat(Optional.ofNullable(records)).isNotNull();
int count = 0;
for (final Iterator it = records.iterator(); it.hasNext(); ) {
for (int i = 0; i < expectedItemsPerSameKey; i++) {
final Identifiable rid = it.next();
final Document record = (Document) rid.getRecord();
- Assertions.assertEquals(number + count, record.getLong("number"));
+ assertThat(record.getLong("number")).isEqualTo(number + count);
}
++count;
}
@@ -280,7 +283,7 @@ private void checkRanges(final int step, final int expectedItemsPerSameKey) {
if (count != 2)
LogManager.instance().log(this, Level.FINE, "Cannot find key '%s'", null, number);
- Assertions.assertEquals(2, count, "Wrong result for lookup of key " + number);
+ assertThat(count).as("Wrong result for lookup of key " + number).isEqualTo(2);
checked++;
@@ -292,7 +295,7 @@ private void checkRanges(final int step, final int expectedItemsPerSameKey) {
begin = System.currentTimeMillis();
}
} catch (final Exception e) {
- Assertions.fail("Error on lookup key " + number, e);
+ fail("Error on lookup key " + number, e);
}
}
LogManager.instance().log(this, Level.FINE, "TEST: Lookup finished in " + (System.currentTimeMillis() - begin) + "ms");
diff --git a/engine/src/test/java/com/arcadedb/index/LSMTreeIndexCompositeTest.java b/engine/src/test/java/com/arcadedb/index/LSMTreeIndexCompositeTest.java
index 69c2f1fc0f..32e6c2112f 100644
--- a/engine/src/test/java/com/arcadedb/index/LSMTreeIndexCompositeTest.java
+++ b/engine/src/test/java/com/arcadedb/index/LSMTreeIndexCompositeTest.java
@@ -24,11 +24,13 @@
import com.arcadedb.graph.Vertex;
import com.arcadedb.schema.DocumentType;
import com.arcadedb.schema.Schema;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.Test;
import java.util.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class LSMTreeIndexCompositeTest extends TestHelper {
private static final int TOT = 100;
@@ -38,8 +40,8 @@ public void testGetAbsoluteId() {
final TypeIndex index = database.getSchema().getType("File").getIndexesByProperties("absoluteId").get(0);
for (int i = 0; i < TOT * TOT; ++i) {
final IndexCursor value = index.get(new Object[] { i });
- Assertions.assertTrue(value.hasNext());
- Assertions.assertEquals(i, value.next().asVertex().get("absoluteId"));
+ assertThat(value.hasNext()).isTrue();
+ assertThat(value.next().asVertex().get("absoluteId")).isEqualTo(i);
}
});
}
@@ -51,11 +53,11 @@ public void testGetRelative() {
for (int i = 0; i < TOT; ++i) {
for (int k = 0; k < TOT; ++k) {
final IndexCursor value = index.get(new Object[] { i, k });
- Assertions.assertTrue(value.hasNext(), "id[" + i + "," + k + "]");
+ assertThat(value.hasNext()).withFailMessage("id[" + i + "," + k + "]").isTrue();
final Vertex v = value.next().asVertex();
- Assertions.assertEquals(i, v.get("directoryId"));
- Assertions.assertEquals(k, v.get("fileId"));
+ assertThat(v.get("directoryId")).isEqualTo(i);
+ assertThat(v.get("fileId")).isEqualTo(k);
}
}
});
@@ -67,10 +69,10 @@ public void testPartialNullGet() {
final TypeIndex index = database.getSchema().getType("File").getIndexesByProperties("directoryId", "fileId").get(0);
for (int i = 0; i < TOT; ++i) {
final IndexCursor value = index.get(new Object[] { i, null });
- Assertions.assertTrue(value.hasNext(), "id[" + i + "]");
+ assertThat(value.hasNext()).withFailMessage( "id[" + i + "]").isTrue();
final Vertex v = value.next().asVertex();
- Assertions.assertEquals(i, v.get("directoryId"));
+ assertThat(v.get("directoryId")).isEqualTo(i);
}
});
}
@@ -78,7 +80,7 @@ public void testPartialNullGet() {
protected void beginTest() {
// CREATE SIMPLE GRAPH OF 2 LEVELS DIRECTORY FILE SYSTEM
database.transaction(() -> {
- Assertions.assertFalse(database.getSchema().existsType("File"));
+ assertThat(database.getSchema().existsType("File")).isFalse();
final DocumentType file = database.getSchema().createVertexType("File");
file.createProperty("absoluteId", Integer.class);
file.createProperty("directoryId", Integer.class);
@@ -88,7 +90,7 @@ protected void beginTest() {
file.setBucketSelectionStrategy(new RoundRobinBucketSelectionStrategy());
- Assertions.assertFalse(database.getSchema().existsType("HasChildren"));
+ assertThat(database.getSchema().existsType("HasChildren")).isFalse();
database.getSchema().createEdgeType("HasChildren");
database.getSchema().createTypeIndex(Schema.INDEX_TYPE.LSM_TREE, true, "HasChildren", "@out", "@in");
diff --git a/engine/src/test/java/com/arcadedb/index/LSMTreeIndexPolymorphicTest.java b/engine/src/test/java/com/arcadedb/index/LSMTreeIndexPolymorphicTest.java
index 3394f0de8d..faff86c9f2 100644
--- a/engine/src/test/java/com/arcadedb/index/LSMTreeIndexPolymorphicTest.java
+++ b/engine/src/test/java/com/arcadedb/index/LSMTreeIndexPolymorphicTest.java
@@ -26,10 +26,16 @@
import com.arcadedb.schema.DocumentType;
import com.arcadedb.schema.Schema;
import com.arcadedb.schema.Type;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
-import java.util.*;
+import java.util.Arrays;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
public class LSMTreeIndexPolymorphicTest extends TestHelper {
@@ -44,11 +50,11 @@ public void testPolymorphic() {
final MutableDocument docChildDuplicated = database.newDocument("TestChild");
database.transaction(() -> {
docChildDuplicated.set("name", "Root");
- Assertions.assertEquals("Root", docChildDuplicated.get("name"));
+ assertThat(docChildDuplicated.get("name")).isEqualTo("Root");
docChildDuplicated.save();
}, true, 0);
- Assertions.fail("Duplicated shouldn't be allowed by unique index on sub type");
+ fail("Duplicated shouldn't be allowed by unique index on sub type");
} catch (final DuplicatedKeyException e) {
// EXPECTED
@@ -76,15 +82,15 @@ public void testDocumentAfterCreation2() {
testChild2.setSuperTypes(Arrays.asList(typeRoot2));
final MutableDocument doc = database.newDocument("TestChild2");
doc.set("name", "Document Name");
- Assertions.assertEquals("Document Name", doc.get("name"));
+ assertThat(doc.get("name")).isEqualTo("Document Name");
doc.save();
- Assertions.assertEquals("Document Name", doc.get("name"));
+ assertThat(doc.get("name")).isEqualTo("Document Name");
try (final ResultSet rs = database.query("sql", "select from TestChild2 where name = :name",
Map.of("arg0", "Test2", "name", "Document Name"))) {
- Assertions.assertTrue(rs.hasNext());
+ assertThat(rs.hasNext()).isTrue();
final Document docRetrieved = rs.next().getElement().orElse(null);
- Assertions.assertEquals("Document Name", docRetrieved.get("name"));
- Assertions.assertFalse(rs.hasNext());
+ assertThat(docRetrieved.get("name")).isEqualTo("Document Name");
+ assertThat(rs.hasNext()).isFalse();
}
database.commit();
}
@@ -103,15 +109,15 @@ public void testDocumentAfterCreation2AutoTx() {
database.setAutoTransaction(true);
final MutableDocument doc = database.newDocument("TestChild2");
doc.set("name", "Document Name");
- Assertions.assertEquals("Document Name", doc.get("name"));
+ assertThat(doc.get("name")).isEqualTo("Document Name");
doc.save();
- Assertions.assertEquals("Document Name", doc.get("name"));
+ assertThat(doc.get("name")).isEqualTo("Document Name");
try (final ResultSet rs = database.query("sql", "select from TestChild2 where name = :name",
Map.of("arg0", "Test2", "name", "Document Name"))) {
- Assertions.assertTrue(rs.hasNext()); //<<<<<<----------FAILING HERE
+ assertThat(rs.hasNext()).isTrue(); //<<<<<<----------FAILING HERE
final Document docRetrieved = rs.next().getElement().orElse(null);
- Assertions.assertEquals("Document Name", docRetrieved.get("name"));
- Assertions.assertFalse(rs.hasNext());
+ assertThat(docRetrieved.get("name")).isEqualTo("Document Name");
+ assertThat(rs.hasNext()).isFalse();
}
}
@@ -127,62 +133,62 @@ private void populate(final Schema.INDEX_TYPE indexType) {
final MutableDocument docRoot = database.newDocument("TestRoot");
database.transaction(() -> {
docRoot.set("name", "Root");
- Assertions.assertEquals("Root", docRoot.get("name"));
+ assertThat(docRoot.get("name")).isEqualTo("Root");
docRoot.save();
});
- Assertions.assertEquals("Root", docRoot.get("name"));
+ assertThat(docRoot.get("name")).isEqualTo("Root");
final MutableDocument docChild = database.newDocument("TestChild");
database.transaction(() -> {
docChild.set("name", "Child");
- Assertions.assertEquals("Child", docChild.get("name"));
+ assertThat(docChild.get("name")).isEqualTo("Child");
docChild.save();
});
- Assertions.assertEquals("Child", docChild.get("name"));
+ assertThat(docChild.get("name")).isEqualTo("Child");
}
private void checkQueries() {
try (final ResultSet rs = database.query("sql", "select from TestRoot where name <> :name",
Map.of("arg0", "Test2", "name", "Nonsense"))) {
- Assertions.assertTrue(rs.hasNext());
+ assertThat(rs.hasNext()).isTrue();
final Document doc1Retrieved = rs.next().getElement().orElse(null);
- Assertions.assertTrue(rs.hasNext());
+ assertThat(rs.hasNext()).isTrue();
final Document doc2Retrieved = rs.next().getElement().orElse(null);
if (doc1Retrieved.getTypeName().equals("TestRoot"))
- Assertions.assertEquals("Root", doc1Retrieved.get("name"));
+ assertThat(doc1Retrieved.get("name")).isEqualTo("Root");
else if (doc2Retrieved.getTypeName().equals("TestChild"))
- Assertions.assertEquals("Child", doc2Retrieved.get("name"));
+ assertThat(doc2Retrieved.get("name")).isEqualTo("Child");
else
- Assertions.fail();
+ fail("");
- Assertions.assertFalse(rs.hasNext());
+ assertThat(rs.hasNext()).isFalse();
}
try (final ResultSet rs = database.query("sql", "select from TestChild where name = :name",
Map.of("arg0", "Test2", "name", "Child"))) {
- Assertions.assertTrue(rs.hasNext());
+ assertThat(rs.hasNext()).isTrue();
final Document doc1Retrieved = rs.next().getElement().orElse(null);
- Assertions.assertEquals("Child", doc1Retrieved.get("name"));
- Assertions.assertFalse(rs.hasNext());
+ assertThat(doc1Retrieved.get("name")).isEqualTo("Child");
+ assertThat(rs.hasNext()).isFalse();
}
typeChild.removeSuperType(typeRoot);
try (final ResultSet rs = database.query("sql", "select from TestChild where name = :name",
Map.of("arg0", "Test2", "name", "Child"))) {
- Assertions.assertTrue(rs.hasNext());
+ assertThat(rs.hasNext()).isTrue();
final Document doc1Retrieved = rs.next().getElement().orElse(null);
- Assertions.assertEquals("Child", doc1Retrieved.get("name"));
- Assertions.assertFalse(rs.hasNext());
+ assertThat(doc1Retrieved.get("name")).isEqualTo("Child");
+ assertThat(rs.hasNext()).isFalse();
}
try (final ResultSet rs = database.query("sql", "select from TestRoot where name <> :name",
Map.of("arg0", "Test2", "name", "Nonsense"))) {
- Assertions.assertTrue(rs.hasNext());
+ assertThat(rs.hasNext()).isTrue();
final Document doc1Retrieved = rs.next().getElement().orElse(null);
- Assertions.assertEquals("Root", doc1Retrieved.get("name"));
- Assertions.assertFalse(rs.hasNext());
+ assertThat(doc1Retrieved.get("name")).isEqualTo("Root");
+ assertThat(rs.hasNext()).isFalse();
}
}
}
diff --git a/engine/src/test/java/com/arcadedb/index/LSMTreeIndexTest.java b/engine/src/test/java/com/arcadedb/index/LSMTreeIndexTest.java
index 205ba3256d..b6a0c89e7f 100644
--- a/engine/src/test/java/com/arcadedb/index/LSMTreeIndexTest.java
+++ b/engine/src/test/java/com/arcadedb/index/LSMTreeIndexTest.java
@@ -18,6 +18,7 @@
*/
package com.arcadedb.index;
+import com.arcadedb.GlobalConfiguration;
import com.arcadedb.TestHelper;
import com.arcadedb.database.Document;
import com.arcadedb.database.Identifiable;
@@ -30,13 +31,16 @@
import com.arcadedb.query.sql.executor.ResultSet;
import com.arcadedb.schema.DocumentType;
import com.arcadedb.schema.Schema;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.*;
import java.util.concurrent.atomic.*;
import java.util.logging.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class LSMTreeIndexTest extends TestHelper {
private static final int TOT = 100000;
private static final String TYPE_NAME = "V";
@@ -61,11 +65,11 @@ public void testGet() {
}
total++;
- Assertions.assertEquals(1, results.size());
- Assertions.assertEquals(i, (int) results.get(0));
+ assertThat(results).hasSize(1);
+ assertThat((int) results.get(0)).isEqualTo(i);
}
- Assertions.assertEquals(TOT, total);
+ assertThat(total).isEqualTo(TOT);
});
}
@@ -81,23 +85,23 @@ public void testGetAsRange() {
if (index instanceof TypeIndex)
continue;
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
final IndexCursor iterator;
try {
iterator = ((RangeIndex) index).range(true, new Object[] { i }, true, new Object[] { i }, true);
- Assertions.assertNotNull(iterator);
+ assertThat((Iterator extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
final Identifiable value = iterator.next();
- Assertions.assertNotNull(value);
+ assertThat(value).isNotNull();
final int fieldValue = (int) value.asDocument().get("id");
- Assertions.assertEquals(i, fieldValue);
+ assertThat(fieldValue).isEqualTo(i);
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
total++;
}
@@ -106,7 +110,7 @@ public void testGetAsRange() {
}
}
- Assertions.assertEquals(1, total, "Get item with id=" + i);
+ assertThat(total).withFailMessage("Get item with id=" + i).isEqualTo(1);
}
});
}
@@ -123,28 +127,28 @@ public void testRangeFromHead() {
if (index instanceof TypeIndex)
continue;
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
final IndexCursor iterator;
iterator = ((RangeIndex) index).range(true, new Object[] { i }, true, new Object[] { i + 1 }, true);
- Assertions.assertNotNull(iterator);
+ assertThat((Iterable extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
final Identifiable value = iterator.next();
- Assertions.assertNotNull(value);
+ assertThat(value).isNotNull();
final int fieldValue = (int) value.asDocument().get("id");
- Assertions.assertTrue(fieldValue >= i && fieldValue <= i + 1);
+ assertThat(fieldValue >= i && fieldValue <= i + 1).isTrue();
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
++total;
}
}
- Assertions.assertEquals(2, total, "range " + i + "-" + (i + 1));
+ assertThat(total).withFailMessage("range " + i + "-" + (i + 1)).isEqualTo(2);
}
});
}
@@ -162,28 +166,28 @@ public void testRangeFromHead() {
// for (Index index : indexes) {
// if( index instanceof TypeIndex)
// continue;
-// Assertions.assertNotNull(index);
+// Assertions.assertThat(index).isNotNull();
//
// final IndexCursor iterator;
// iterator = ((RangeIndex) index).range(new Object[] { i }, true, new Object[] { i - 1 }, true);
-// Assertions.assertNotNull(iterator);
+// Assertions.assertThat(iterator).isNotNull();
//
// while (iterator.hasNext()) {
// Identifiable value = iterator.next();
//
-// Assertions.assertNotNull(value);
+// Assertions.assertThat(value).isNotNull();
//
// int fieldValue = (int) value.asDocument().get("id");
-// Assertions.assertTrue(fieldValue >= i - 1 && fieldValue <= i);
+// Assertions.assertThat(fieldValue >= i - 1 && fieldValue <= i).isTrue();
//
-// Assertions.assertNotNull(iterator.getKeys());
-// Assertions.assertEquals(1, iterator.getKeys().length);
+// Assertions.assertThat(iterator.getKeys()).isNotNull();
+// Assertions.assertThat(iterator.getKeys().length).isEqualTo(1);
//
// ++total;
// }
// }
//
-// Assertions.assertEquals(2, total, "range " + i + "-" + (i - 1));
+// Assertions.assertThat(total).isEqualTo(2, within("range " + i + "-" + (i - 1)));
// }
// }
// });
@@ -213,17 +217,18 @@ public void testRemoveKeys() {
}
}
- Assertions.assertEquals(1, found, "Key '" + Arrays.toString(key) + "' found " + found + " times");
+ assertThat(found).isEqualTo(1).withFailMessage("Key '" + Arrays.toString(key) + "' found " + found + " times");
}
- Assertions.assertEquals(TOT, total);
+ assertThat(total).isEqualTo(TOT);
// GET EACH ITEM TO CHECK IT HAS BEEN DELETED
for (int i = 0; i < TOT; ++i) {
for (final Index index : indexes) {
if (index instanceof TypeIndex)
continue;
- Assertions.assertFalse(index.get(new Object[] { i }).hasNext(), "Found item with key " + i + " inside the TX by using get()");
+ assertThat(index.get(new Object[] { i }).hasNext()).isFalse()
+ .withFailMessage("Found item with key " + i + " inside the TX by using get()");
}
}
@@ -235,7 +240,7 @@ public void testRemoveKeys() {
// continue;
// final IndexCursor cursor = ((RangeIndex) index).range(new Object[] { i }, true, new Object[] { i }, true);
//
-// Assertions.assertFalse(cursor.hasNext() && cursor.next() != null, "Found item with key " + i + " inside the TX by using range()");
+// Assertions.assertThat(cursor.hasNext() && cursor.next().isFalse() != null, "Found item with key " + i + " inside the TX by using range()");
// }
// }
}, true, 0);
@@ -247,7 +252,9 @@ public void testRemoveKeys() {
for (final Index index : indexes) {
if (index instanceof TypeIndex)
continue;
- Assertions.assertFalse(index.get(new Object[] { i }).hasNext(), "Found item with key " + i + " after the TX was committed");
+ assertThat(index.get(new Object[] { i }).hasNext())
+ .withFailMessage("Found item with key " + i + " after the TX was committed")
+ .isFalse();
}
}
@@ -258,7 +265,9 @@ public void testRemoveKeys() {
continue;
final IndexCursor cursor = ((RangeIndex) index).range(true, new Object[] { i }, true, new Object[] { i }, true);
- Assertions.assertFalse(cursor.hasNext() && cursor.next() != null, "Found item with key " + i + " after the TX was committed by using range()");
+
+ assertThat(cursor.hasNext() && cursor.next() != null).isFalse()
+ .withFailMessage("Found item with key " + i + " after the TX was committed by using range()");
}
}
}, true, 0);
@@ -289,10 +298,12 @@ public void testRemoveEntries() {
}
}
- Assertions.assertEquals(1, found, "Key '" + Arrays.toString(key) + "' found " + found + " times");
+ assertThat(found)
+ .withFailMessage("Key '" + Arrays.toString(key) + "' found " + found + " times")
+ .isEqualTo(1);
}
- Assertions.assertEquals(TOT, total);
+ assertThat(total).isEqualTo(TOT);
// GET EACH ITEM TO CHECK IT HAS BEEN DELETED
for (int i = 0; i < TOT; ++i) {
@@ -300,7 +311,7 @@ public void testRemoveEntries() {
if (index instanceof TypeIndex)
continue;
- Assertions.assertFalse(index.get(new Object[] { i }).hasNext(), "Found item with key " + i);
+ assertThat(index.get(new Object[] { i }).hasNext()).withFailMessage("Found item with key " + i).isFalse();
}
}
@@ -311,7 +322,7 @@ public void testRemoveEntries() {
// if (index instanceof TypeIndex)
// continue;
//
-// Assertions.assertFalse(((RangeIndex) index).range(new Object[] { i }, true, new Object[] { i }, true).hasNext(),
+// Assertions.assertThat(((RangeIndex) index).isFalse().range(new Object[] { i }, true, new Object[] { i }, true).hasNext(),
// "Found item with key " + i + " inside the TX by using range()");
// }
// }
@@ -325,7 +336,9 @@ public void testRemoveEntries() {
if (index instanceof TypeIndex)
continue;
- Assertions.assertFalse(index.get(new Object[] { i }).hasNext(), "Found item with key " + i + " after the TX was committed");
+ assertThat(index.get(new Object[] { i }).hasNext())
+ .withFailMessage("Found item with key " + i + " after the TX was committed")
+ .isFalse();
}
}
@@ -336,7 +349,10 @@ public void testRemoveEntries() {
continue;
final IndexCursor cursor = ((RangeIndex) index).range(true, new Object[] { i }, true, new Object[] { i }, true);
- Assertions.assertFalse(cursor.hasNext() && cursor.next() != null, "Found item with key " + i + " after the TX was committed by using range()");
+
+ assertThat(cursor.hasNext() && cursor.next() != null)
+ .withFailMessage("Found item with key " + i + " after the TX was committed by using range()")
+ .isFalse();
}
}
}, true, 0);
@@ -369,10 +385,10 @@ public void testRemoveEntriesMultipleTimes() {
}
}
- Assertions.assertEquals(1, found, "Key '" + Arrays.toString(key) + "' found " + found + " times");
+ assertThat(found).isEqualTo(1).withFailMessage("Key '" + Arrays.toString(key) + "' found " + found + " times");
}
- Assertions.assertEquals(TOT, total);
+ assertThat(total).isEqualTo(TOT);
// GET EACH ITEM TO CHECK IT HAS BEEN DELETED
for (int i = 0; i < TOT; ++i) {
@@ -380,7 +396,7 @@ public void testRemoveEntriesMultipleTimes() {
if (index instanceof TypeIndex)
continue;
- Assertions.assertFalse(index.get(new Object[] { i }).hasNext(), "Found item with key " + i);
+ assertThat(index.get(new Object[] { i }).hasNext()).isFalse().withFailMessage("Found item with key " + i);
}
}
});
@@ -416,10 +432,10 @@ public void testRemoveAndPutEntries() {
}
}
- Assertions.assertEquals(1, found, "Key '" + Arrays.toString(key) + "' found " + found + " times");
+ assertThat(found).isEqualTo(1).withFailMessage("Key '" + Arrays.toString(key) + "' found " + found + " times");
}
- Assertions.assertEquals(TOT, total);
+ assertThat(total).isEqualTo(TOT);
// GET EACH ITEM TO CHECK IT HAS BEEN DELETED
for (int i = 0; i < TOT; ++i) {
@@ -427,7 +443,7 @@ public void testRemoveAndPutEntries() {
if (index instanceof TypeIndex)
continue;
- Assertions.assertFalse(index.get(new Object[] { i }).hasNext(), "Found item with key " + i);
+ assertThat(index.get(new Object[] { i }).hasNext()).isFalse().withFailMessage("Found item with key " + i);
}
}
});
@@ -441,7 +457,7 @@ public void testRemoveAndPutEntries() {
if (index instanceof TypeIndex)
continue;
- Assertions.assertTrue(index.get(new Object[] { i }).hasNext(), "Cannot find item with key " + i);
+ assertThat(index.get(new Object[] { i }).hasNext()).isTrue().withFailMessage("Cannot find item with key " + i);
}
}
});
@@ -452,7 +468,7 @@ public void testChangePrimaryKeySameTx() {
database.transaction(() -> {
for (int i = 0; i < 1000; ++i) {
final IndexCursor cursor = database.lookupByKey(TYPE_NAME, "id", i);
- Assertions.assertTrue(cursor.hasNext(), "Key " + i + " not found");
+ assertThat(cursor.hasNext()).isTrue().withFailMessage("Key " + i + " not found");
final Document doc = cursor.next().asDocument();
doc.modify().set("id", i + TOT).save();
@@ -465,20 +481,20 @@ public void testDeleteCreateSameKeySameTx() {
database.transaction(() -> {
for (int i = 0; i < 1000; ++i) {
final IndexCursor cursor = database.lookupByKey(TYPE_NAME, "id", i);
- Assertions.assertTrue(cursor.hasNext(), "Key " + i + " not found");
+ assertThat(cursor.hasNext()).withFailMessage("Key " + i + " not found").isTrue();
final Document doc = cursor.next().asDocument();
doc.delete();
database.newDocument(TYPE_NAME).fromMap(doc.toMap()).set("version", 2).save();
}
- }, true, 0);
+ }, true, 2);
database.transaction(() -> {
for (int i = 0; i < 1000; ++i) {
final IndexCursor cursor = database.lookupByKey(TYPE_NAME, "id", i);
- Assertions.assertTrue(cursor.hasNext(), "Key " + i + " not found");
- Assertions.assertEquals(2, cursor.next().asDocument().getInteger("version"));
+ assertThat(cursor.hasNext()).withFailMessage("Key " + i + " not found").isTrue();
+ assertThat(cursor.next().asDocument().getInteger("version")).isEqualTo(2);
}
});
}
@@ -492,7 +508,7 @@ public void testUpdateKeys() {
for (final ResultSet it = resultSet; it.hasNext(); ) {
final Result r = it.next();
- Assertions.assertNotNull(r.getElement().get().get("id"));
+ assertThat(r.getElement().get().get("id")).isNotNull();
final MutableDocument record = r.getElement().get().modify();
record.set("id", (Integer) record.get("id") + 1000000);
@@ -521,10 +537,10 @@ public void testUpdateKeys() {
}
}
- Assertions.assertEquals(0, found, "Key '" + Arrays.toString(key) + "' found " + found + " times");
+ assertThat(found).isEqualTo(0).withFailMessage("Key '" + Arrays.toString(key) + "' found " + found + " times");
}
- Assertions.assertEquals(0, total);
+ assertThat(total).isEqualTo(0);
total = 0;
@@ -549,15 +565,16 @@ public void testUpdateKeys() {
}
}
- Assertions.assertEquals(1, found, "Key '" + Arrays.toString(key) + "' found " + found + " times");
+ assertThat(found).withFailMessage("Key '" + Arrays.toString(key) + "' found " + found + " times").isEqualTo(1);
}
- Assertions.assertEquals(TOT, total);
+ assertThat(total).isEqualTo(TOT);
// GET EACH ITEM TO CHECK IT HAS BEEN DELETED
for (int i = 0; i < TOT; ++i) {
for (final Index index : indexes)
- Assertions.assertFalse(index.get(new Object[] { i }).hasNext(), "Found item with key " + i);
+ assertThat(index.get(new Object[] { i }).hasNext()).withFailMessage("Found item with key " + i).isFalse();
+ ;
}
});
@@ -594,10 +611,10 @@ public void testPutDuplicates() {
}
}
- Assertions.assertEquals(1, found, "Key '" + Arrays.toString(key) + "' found " + found + " times");
+ assertThat(found).withFailMessage("Key '" + Arrays.toString(key) + "' found " + found + " times").isEqualTo(1);
}
- Assertions.assertEquals(TOT, total);
+ assertThat(total).isEqualTo(TOT);
});
}
@@ -619,22 +636,21 @@ public void testScanIndexAscending() {
if (index instanceof TypeIndex)
continue;
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
- final IndexCursor iterator;
try {
- iterator = ((RangeIndex) index).iterator(true);
+ final IndexCursor iterator = ((RangeIndex) index).iterator(true);
// LogManager.instance()
// .log(this, Level.INFO, "*****************************************************************************\nCURSOR BEGIN%s", iterator.dumpStats());
- Assertions.assertNotNull(iterator);
+ assertThat((Iterator extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
- Assertions.assertNotNull(iterator.next());
+ assertThat(iterator.next()).isNotNull();
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
total++;
}
@@ -647,7 +663,7 @@ public void testScanIndexAscending() {
}
}
- Assertions.assertEquals(TOT, total);
+ assertThat(total).isEqualTo(TOT);
});
}
@@ -669,23 +685,23 @@ public void testScanIndexDescending() {
if (index instanceof TypeIndex)
continue;
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
- final IndexCursor iterator;
try {
- iterator = ((RangeIndex) index).iterator(false);
- Assertions.assertNotNull(iterator);
+ final IndexCursor iterator = ((RangeIndex) index).iterator(false);
+ assertThat((Iterator extends Identifiable>) iterator).isNotNull();
Object prevKey = null;
while (iterator.hasNext()) {
- Assertions.assertNotNull(iterator.next());
+ assertThat(iterator.next()).isNotNull();
final Object[] keys = iterator.getKeys();
- Assertions.assertNotNull(keys);
- Assertions.assertEquals(1, keys.length);
+ assertThat(keys).isNotNull();
+ assertThat(keys.length).isEqualTo(1);
if (prevKey != null)
- Assertions.assertTrue(((Comparable) keys[0]).compareTo(prevKey) < 0, "Key " + keys[0] + " is not minor than " + prevKey);
+ assertThat(((Comparable) keys[0]).compareTo(prevKey) < 0).withFailMessage(
+ "Key " + keys[0] + " is not minor than " + prevKey).isTrue();
prevKey = keys[0];
++total;
@@ -696,7 +712,7 @@ public void testScanIndexDescending() {
}
}
- Assertions.assertEquals(TOT, total);
+ assertThat(total).isEqualTo(TOT);
});
}
@@ -710,19 +726,19 @@ public void testScanIndexAscendingPartialInclusive() {
if (index instanceof TypeIndex)
continue;
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
final IndexCursor iterator;
try {
iterator = ((RangeIndex) index).iterator(true, new Object[] { 10 }, true);
- Assertions.assertNotNull(iterator);
+ assertThat((Iterable extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
- Assertions.assertNotNull(iterator.next());
+ assertThat(iterator.next()).isNotNull();
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
total++;
}
@@ -731,7 +747,7 @@ public void testScanIndexAscendingPartialInclusive() {
}
}
- Assertions.assertEquals(TOT - 10, total);
+ assertThat(total).isEqualTo(TOT - 10);
});
}
@@ -745,19 +761,19 @@ public void testScanIndexAscendingPartialExclusive() {
if (index instanceof TypeIndex)
continue;
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
final IndexCursor iterator;
try {
iterator = ((RangeIndex) index).iterator(true, new Object[] { 10 }, false);
- Assertions.assertNotNull(iterator);
+ assertThat((Iterable extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
- Assertions.assertNotNull(iterator.next());
+ assertThat(iterator.next()).isNotNull();
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
total++;
}
@@ -766,7 +782,7 @@ public void testScanIndexAscendingPartialExclusive() {
}
}
- Assertions.assertEquals(TOT - 11, total);
+ assertThat(total).isEqualTo(TOT - 11);
});
}
@@ -780,18 +796,18 @@ public void testScanIndexDescendingPartialInclusive() {
if (index instanceof TypeIndex)
continue;
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
final IndexCursor iterator;
try {
iterator = ((RangeIndex) index).iterator(false, new Object[] { 9 }, true);
- Assertions.assertNotNull(iterator);
+ assertThat((Iterable extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
- Assertions.assertNotNull(iterator.next());
+ assertThat(iterator.next()).isNotNull();
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
total++;
}
@@ -800,7 +816,7 @@ public void testScanIndexDescendingPartialInclusive() {
}
}
- Assertions.assertEquals(10, total);
+ assertThat(total).isEqualTo(10);
});
}
@@ -814,18 +830,18 @@ public void testScanIndexDescendingPartialExclusive() {
if (index instanceof TypeIndex)
continue;
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
final IndexCursor iterator;
try {
iterator = ((RangeIndex) index).iterator(false, new Object[] { 9 }, false);
- Assertions.assertNotNull(iterator);
+ assertThat((Iterable extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
- Assertions.assertNotNull(iterator.next());
+ assertThat(iterator.next()).isNotNull();
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
total++;
}
@@ -834,7 +850,7 @@ public void testScanIndexDescendingPartialExclusive() {
}
}
- Assertions.assertEquals(9, total);
+ assertThat(total).isEqualTo(9);
});
}
@@ -848,23 +864,23 @@ public void testScanIndexRangeInclusive2Inclusive() {
if (index instanceof TypeIndex)
continue;
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
final IndexCursor iterator;
try {
iterator = ((RangeIndex) index).range(true, new Object[] { 10 }, true, new Object[] { 19 }, true);
- Assertions.assertNotNull(iterator);
+ assertThat((Iterable extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
final Identifiable value = iterator.next();
- Assertions.assertNotNull(value);
+ assertThat(value).isNotNull();
final int fieldValue = (int) value.asDocument().get("id");
- Assertions.assertTrue(fieldValue >= 10 && fieldValue <= 19);
+ assertThat(fieldValue >= 10 && fieldValue <= 19).isTrue();
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
total++;
}
@@ -873,7 +889,7 @@ public void testScanIndexRangeInclusive2Inclusive() {
}
}
- Assertions.assertEquals(10, total);
+ assertThat(total).isEqualTo(10);
});
}
@@ -887,23 +903,23 @@ public void testScanIndexRangeInclusive2Exclusive() {
if (index instanceof TypeIndex)
continue;
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
final IndexCursor iterator;
try {
iterator = ((RangeIndex) index).range(true, new Object[] { 10 }, true, new Object[] { 19 }, false);
- Assertions.assertNotNull(iterator);
+ assertThat((Iterable extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
final Identifiable value = iterator.next();
- Assertions.assertNotNull(value);
+ assertThat(value).isNotNull();
final int fieldValue = (int) value.asDocument().get("id");
- Assertions.assertTrue(fieldValue >= 10 && fieldValue < 19);
+ assertThat(fieldValue >= 10 && fieldValue < 19).isTrue();
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
total++;
}
@@ -912,7 +928,7 @@ public void testScanIndexRangeInclusive2Exclusive() {
}
}
- Assertions.assertEquals(9, total);
+ assertThat(total).isEqualTo(9);
});
}
@@ -926,23 +942,23 @@ public void testScanIndexRangeExclusive2Inclusive() {
if (index instanceof TypeIndex)
continue;
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
final IndexCursor iterator;
try {
iterator = ((RangeIndex) index).range(true, new Object[] { 10 }, false, new Object[] { 19 }, true);
- Assertions.assertNotNull(iterator);
+ assertThat((Iterable extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
final Identifiable value = iterator.next();
- Assertions.assertNotNull(value);
+ assertThat(value).isNotNull();
final int fieldValue = (int) value.asDocument().get("id");
- Assertions.assertTrue(fieldValue > 10 && fieldValue <= 19);
+ assertThat(fieldValue > 10 && fieldValue <= 19).isTrue();
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
total++;
}
@@ -951,7 +967,7 @@ public void testScanIndexRangeExclusive2Inclusive() {
}
}
- Assertions.assertEquals(9, total);
+ assertThat(total).isEqualTo(9);
});
}
@@ -965,23 +981,23 @@ public void testScanIndexRangeExclusive2Exclusive() {
if (index instanceof TypeIndex)
continue;
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
final IndexCursor iterator;
try {
iterator = ((RangeIndex) index).range(true, new Object[] { 10 }, false, new Object[] { 19 }, false);
- Assertions.assertNotNull(iterator);
+ assertThat((Iterable extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
final Identifiable value = iterator.next();
- Assertions.assertNotNull(value);
+ assertThat(value).isNotNull();
final int fieldValue = (int) value.asDocument().get("id");
- Assertions.assertTrue(fieldValue > 10 && fieldValue < 19);
+ assertThat(fieldValue > 10 && fieldValue < 19).isTrue();
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
total++;
}
@@ -990,7 +1006,7 @@ public void testScanIndexRangeExclusive2Exclusive() {
}
}
- Assertions.assertEquals(8, total);
+ assertThat(total).isEqualTo(8);
});
}
@@ -1041,34 +1057,39 @@ public void run() {
crossThreadsInserted.incrementAndGet();
if (threadInserted % 1000 == 0)
- LogManager.instance().log(this, Level.INFO, "%s Thread %d inserted record %s, total %d records with key %d (total=%d)", null, getClass(),
- Thread.currentThread().getId(), v.getIdentity(), i, threadInserted, crossThreadsInserted.get());
+ LogManager.instance()
+ .log(this, Level.INFO, "%s Thread %d inserted record %s, total %d records with key %d (total=%d)", null,
+ getClass(),
+ Thread.currentThread().getId(), v.getIdentity(), i, threadInserted, crossThreadsInserted.get());
keyPresent = true;
} catch (final NeedRetryException e) {
needRetryExceptions.incrementAndGet();
- Assertions.assertFalse(database.isTransactionActive());
+ assertThat(database.isTransactionActive()).isFalse();
continue;
} catch (final DuplicatedKeyException e) {
duplicatedExceptions.incrementAndGet();
keyPresent = true;
- Assertions.assertFalse(database.isTransactionActive());
+ assertThat(database.isTransactionActive()).isFalse();
} catch (final Exception e) {
- LogManager.instance().log(this, Level.SEVERE, "%s Thread %d Generic Exception", e, getClass(), Thread.currentThread().getId());
- Assertions.assertFalse(database.isTransactionActive());
+ LogManager.instance()
+ .log(this, Level.SEVERE, "%s Thread %d Generic Exception", e, getClass(), Thread.currentThread().getId());
+ assertThat(database.isTransactionActive()).isFalse();
return;
}
}
if (!keyPresent)
- LogManager.instance().log(this, Level.WARNING, "%s Thread %d Cannot create key %d after %d retries! (total=%d)", null, getClass(),
- Thread.currentThread().getId(), i, maxRetries, crossThreadsInserted.get());
+ LogManager.instance()
+ .log(this, Level.WARNING, "%s Thread %d Cannot create key %d after %d retries! (total=%d)", null, getClass(),
+ Thread.currentThread().getId(), i, maxRetries, crossThreadsInserted.get());
}
LogManager.instance()
- .log(this, Level.INFO, "%s Thread %d completed (inserted=%d)", null, getClass(), Thread.currentThread().getId(), threadInserted);
+ .log(this, Level.INFO, "%s Thread %d completed (inserted=%d)", null, getClass(), Thread.currentThread().getId(),
+ threadInserted);
} catch (final Exception e) {
LogManager.instance().log(this, Level.SEVERE, "%s Thread %d Error", e, getClass(), Thread.currentThread().getId());
@@ -1090,7 +1111,8 @@ public void run() {
}
LogManager.instance()
- .log(this, Level.INFO, "%s Completed (inserted=%d needRetryExceptions=%d duplicatedExceptions=%d)", null, getClass(), crossThreadsInserted.get(),
+ .log(this, Level.INFO, "%s Completed (inserted=%d needRetryExceptions=%d duplicatedExceptions=%d)", null, getClass(),
+ crossThreadsInserted.get(),
needRetryExceptions.get(), duplicatedExceptions.get());
if (total != crossThreadsInserted.get()) {
@@ -1122,20 +1144,21 @@ public void run() {
}
}
- Assertions.assertEquals(total, crossThreadsInserted.get());
-// Assertions.assertTrue(needRetryExceptions.get() > 0);
- Assertions.assertTrue(duplicatedExceptions.get() > 0);
+ assertThat(crossThreadsInserted.get()).isEqualTo(total);
+// Assertions.assertThat(needRetryExceptions.get() > 0).isTrue();
+ assertThat(duplicatedExceptions.get() > 0).isTrue();
- Assertions.assertEquals(startingWith + total, database.countType(TYPE_NAME, true));
+ assertThat(database.countType(TYPE_NAME, true)).isEqualTo(startingWith + total);
}
protected void beginTest() {
database.transaction(() -> {
- Assertions.assertFalse(database.getSchema().existsType(TYPE_NAME));
+ assertThat(database.getSchema().existsType(TYPE_NAME)).isFalse();
final DocumentType type = database.getSchema().buildDocumentType().withName(TYPE_NAME).withTotalBuckets(3).create();
type.createProperty("id", Integer.class);
- final Index typeIndex = database.getSchema().createTypeIndex(Schema.INDEX_TYPE.LSM_TREE, true, TYPE_NAME, new String[] { "id" }, PAGE_SIZE);
+ final Index typeIndex = database.getSchema()
+ .createTypeIndex(Schema.INDEX_TYPE.LSM_TREE, true, TYPE_NAME, new String[] { "id" }, PAGE_SIZE);
for (int i = 0; i < TOT; ++i) {
final MutableDocument v = database.newDocument(TYPE_NAME);
@@ -1150,7 +1173,7 @@ protected void beginTest() {
database.begin();
for (final Index index : ((TypeIndex) typeIndex).getIndexesOnBuckets()) {
- Assertions.assertTrue(((IndexInternal) index).getStats().get("pages") > 1);
+ assertThat(((IndexInternal) index).getStats().get("pages") > 1).isTrue();
}
});
}
diff --git a/engine/src/test/java/com/arcadedb/index/MultipleTypesIndexTest.java b/engine/src/test/java/com/arcadedb/index/MultipleTypesIndexTest.java
index 8dd1922f52..9ae6968292 100644
--- a/engine/src/test/java/com/arcadedb/index/MultipleTypesIndexTest.java
+++ b/engine/src/test/java/com/arcadedb/index/MultipleTypesIndexTest.java
@@ -25,11 +25,14 @@
import com.arcadedb.schema.Schema;
import com.arcadedb.schema.Type;
import com.arcadedb.schema.VertexType;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.*;
+import static org.assertj.core.api.Assertions.*;
+
public class MultipleTypesIndexTest extends TestHelper {
private static final int TOT = 100000;
private static final String TYPE_NAME = "Profile";
@@ -40,38 +43,38 @@ public void testCollection() {
final Index index = database.getSchema().getIndexByName(TYPE_NAME + "[keywords]");
IndexCursor cursor = index.get(new Object[] { List.of("ceo", "tesla", "spacex", "boring", "neuralink", "twitter") });
- Assertions.assertTrue(cursor.hasNext());
- Assertions.assertEquals("Musk", cursor.next().asVertex().getString("lastName"));
- Assertions.assertFalse(cursor.hasNext());
+ assertThat(cursor.hasNext()).isTrue();
+ assertThat(cursor.next().asVertex().getString("lastName")).isEqualTo("Musk");
+ assertThat(cursor.hasNext()).isFalse();
ResultSet resultset = database.query("sql", "select from " + TYPE_NAME + " where keywords CONTAINS ?", "tesla");
- Assertions.assertTrue(resultset.hasNext());
- Assertions.assertEquals("Musk", resultset.next().toElement().asVertex().getString("lastName"));
- Assertions.assertFalse(resultset.hasNext());
+ assertThat(resultset.hasNext()).isTrue();
+ assertThat(resultset.next().toElement().asVertex().getString("lastName")).isEqualTo("Musk");
+ assertThat(resultset.hasNext()).isFalse();
resultset = database.query("sql", "select from " + TYPE_NAME + " where 'tesla' IN keywords");
- Assertions.assertTrue(resultset.hasNext());
- Assertions.assertEquals("Musk", resultset.next().toElement().asVertex().getString("lastName"));
- Assertions.assertFalse(resultset.hasNext());
+ assertThat(resultset.hasNext()).isTrue();
+ assertThat(resultset.next().toElement().asVertex().getString("lastName")).isEqualTo("Musk");
+ assertThat(resultset.hasNext()).isFalse();
resultset = database.query("sql", "select from " + TYPE_NAME + " where ? IN keywords", "tesla");
- Assertions.assertTrue(resultset.hasNext());
- Assertions.assertEquals("Musk", resultset.next().toElement().asVertex().getString("lastName"));
- Assertions.assertFalse(resultset.hasNext());
+ assertThat(resultset.hasNext()).isTrue();
+ assertThat(resultset.next().toElement().asVertex().getString("lastName")).isEqualTo("Musk");
+ assertThat(resultset.hasNext()).isFalse();
cursor = index.get(new Object[] { List.of("inventor", "commodore", "amiga", "atari", "80s") });
- Assertions.assertTrue(cursor.hasNext());
- Assertions.assertEquals("Jay", cursor.next().asVertex().getString("firstName"));
- Assertions.assertFalse(cursor.hasNext());
+ assertThat(cursor.hasNext()).isTrue();
+ assertThat(cursor.next().asVertex().getString("firstName")).isEqualTo("Jay");
+ assertThat(cursor.hasNext()).isFalse();
cursor = index.get(new Object[] { List.of("writer") });
- Assertions.assertTrue(cursor.hasNext());
+ assertThat(cursor.hasNext()).isTrue();
int i = 0;
for (; cursor.hasNext(); i++) {
cursor.next();
}
- Assertions.assertEquals(TOT - 2, i);
+ assertThat(i).isEqualTo(TOT - 2);
});
}
@@ -92,9 +95,9 @@ public void testNullItemInCollection() {
v.save();
IndexCursor cursor = index.get(new Object[] { list });
- Assertions.assertTrue(cursor.hasNext());
- Assertions.assertEquals("Zuck", cursor.next().asVertex().getString("lastName"));
- Assertions.assertFalse(cursor.hasNext());
+ assertThat(cursor.hasNext()).isTrue();
+ assertThat(cursor.next().asVertex().getString("lastName")).isEqualTo("Zuck");
+ assertThat(cursor.hasNext()).isFalse();
});
}
@@ -118,7 +121,7 @@ public void testUpdateCompositeKeyIndex() {
protected void beginTest() {
database.transaction(() -> {
- Assertions.assertFalse(database.getSchema().existsType(TYPE_NAME));
+ assertThat(database.getSchema().existsType(TYPE_NAME)).isFalse();
final DocumentType type = database.getSchema().buildVertexType().withName(TYPE_NAME).withTotalBuckets(3).create();
type.createProperty("id", Integer.class);
diff --git a/engine/src/test/java/com/arcadedb/index/NullValuesIndexTest.java b/engine/src/test/java/com/arcadedb/index/NullValuesIndexTest.java
index 80875d6442..ac71d226e4 100644
--- a/engine/src/test/java/com/arcadedb/index/NullValuesIndexTest.java
+++ b/engine/src/test/java/com/arcadedb/index/NullValuesIndexTest.java
@@ -26,9 +26,13 @@
import com.arcadedb.schema.DocumentType;
import com.arcadedb.schema.Schema;
import com.arcadedb.schema.VertexType;
+
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
public class NullValuesIndexTest extends TestHelper {
private static final int TOT = 10;
private static final String TYPE_NAME = "V";
@@ -36,14 +40,16 @@ public class NullValuesIndexTest extends TestHelper {
@Test
public void testNullStrategyError() {
- Assertions.assertFalse(database.getSchema().existsType(TYPE_NAME));
+ assertThat(database.getSchema().existsType(TYPE_NAME)).isFalse();
final DocumentType type = database.getSchema().buildDocumentType().withName(TYPE_NAME).withTotalBuckets(3).create();
type.createProperty("id", Integer.class);
type.createProperty("name", String.class);
- final Index indexes = database.getSchema().createTypeIndex(Schema.INDEX_TYPE.LSM_TREE, true, TYPE_NAME, new String[] { "id" }, PAGE_SIZE);
+ final Index indexes = database.getSchema()
+ .createTypeIndex(Schema.INDEX_TYPE.LSM_TREE, true, TYPE_NAME, new String[] { "id" }, PAGE_SIZE);
final Index indexes2 = database.getSchema()
- .createTypeIndex(Schema.INDEX_TYPE.LSM_TREE, false, TYPE_NAME, new String[] { "name" }, PAGE_SIZE, LSMTreeIndexAbstract.NULL_STRATEGY.ERROR, null);
+ .createTypeIndex(Schema.INDEX_TYPE.LSM_TREE, false, TYPE_NAME, new String[] { "name" }, PAGE_SIZE,
+ LSMTreeIndexAbstract.NULL_STRATEGY.ERROR, null);
try {
database.transaction(() -> {
@@ -63,26 +69,28 @@ public void testNullStrategyError() {
database.begin();
for (final Index index : ((TypeIndex) indexes).getIndexesOnBuckets()) {
- Assertions.assertTrue(((IndexInternal) index).getStats().get("pages") > 1);
+ assertThat(((IndexInternal) index).getStats().get("pages") > 1).isTrue();
}
});
- Assertions.fail();
+ fail("");
} catch (final TransactionException e) {
- Assertions.assertTrue(e.getCause() instanceof IllegalArgumentException);
- Assertions.assertTrue(e.getCause().getMessage().startsWith("Indexed key V[name] cannot be NULL"));
+ assertThat(e.getCause() instanceof IllegalArgumentException).isTrue();
+ assertThat(e.getCause().getMessage().startsWith("Indexed key V[name] cannot be NULL")).isTrue();
}
}
@Test
public void testNullStrategySkip() {
- Assertions.assertFalse(database.getSchema().existsType(TYPE_NAME));
+ assertThat(database.getSchema().existsType(TYPE_NAME)).isFalse();
final DocumentType type = database.getSchema().buildDocumentType().withName(TYPE_NAME).withTotalBuckets(3).create();
type.createProperty("id", Integer.class);
type.createProperty("name", String.class);
- final Index indexes = database.getSchema().createTypeIndex(Schema.INDEX_TYPE.LSM_TREE, true, TYPE_NAME, new String[] { "id" }, PAGE_SIZE);
+ final Index indexes = database.getSchema()
+ .createTypeIndex(Schema.INDEX_TYPE.LSM_TREE, true, TYPE_NAME, new String[] { "id" }, PAGE_SIZE);
final Index indexes2 = database.getSchema()
- .createTypeIndex(Schema.INDEX_TYPE.LSM_TREE, false, TYPE_NAME, new String[] { "name" }, PAGE_SIZE, LSMTreeIndexAbstract.NULL_STRATEGY.SKIP, null);
+ .createTypeIndex(Schema.INDEX_TYPE.LSM_TREE, false, TYPE_NAME, new String[] { "name" }, PAGE_SIZE,
+ LSMTreeIndexAbstract.NULL_STRATEGY.SKIP, null);
database.transaction(() -> {
for (int i = 0; i < TOT; ++i) {
@@ -101,14 +109,16 @@ public void testNullStrategySkip() {
database.begin();
});
- database.transaction(() -> Assertions.assertEquals(database.countType(TYPE_NAME, true), TOT + 1));
+ database.transaction(() -> assertThat(database.countType(TYPE_NAME, true)).isEqualTo(TOT + 1));
database.close();
database = factory.open();
// TRY AGAIN WITH A RE-OPEN DATABASE
database.transaction(() -> {
- Assertions.assertTrue(database.getSchema().existsType(TYPE_NAME));
+ assertThat(database.getSchema().existsType(TYPE_NAME)).isTrue();
+
+ assertThat(database.getSchema().existsType(TYPE_NAME)).isTrue();
for (int i = TOT + 2; i < TOT + TOT; ++i) {
final MutableDocument v = database.newDocument(TYPE_NAME);
@@ -125,20 +135,22 @@ public void testNullStrategySkip() {
database.commit();
database.begin();
});
-
- database.transaction(() -> Assertions.assertEquals(database.countType(TYPE_NAME, true), TOT + TOT));
+ database.transaction(() -> assertThat(database.countType(TYPE_NAME, true)).isEqualTo(TOT + TOT));
}
@Test
public void testNullStrategySkipUnique() {
- Assertions.assertFalse(database.getSchema().existsType(TYPE_NAME));
+ assertThat(database.getSchema().existsType(TYPE_NAME)).isFalse();
+
+ assertThat(database.getSchema().existsType(TYPE_NAME)).isFalse();
final VertexType type = database.getSchema().buildVertexType().withName(TYPE_NAME).withTotalBuckets(3).create();
type.createProperty("id", Integer.class);
type.createProperty("absent", String.class);
database.getSchema().createTypeIndex(Schema.INDEX_TYPE.LSM_TREE, true, TYPE_NAME, new String[] { "id" }, PAGE_SIZE);
database.getSchema()
- .createTypeIndex(Schema.INDEX_TYPE.LSM_TREE, true, TYPE_NAME, new String[] { "absent" }, PAGE_SIZE, LSMTreeIndexAbstract.NULL_STRATEGY.SKIP, null);
+ .createTypeIndex(Schema.INDEX_TYPE.LSM_TREE, true, TYPE_NAME, new String[] { "absent" }, PAGE_SIZE,
+ LSMTreeIndexAbstract.NULL_STRATEGY.SKIP, null);
database.transaction(() -> {
for (int i = 0; i < TOT; ++i) {
@@ -153,14 +165,14 @@ public void testNullStrategySkipUnique() {
database.begin();
});
- database.transaction(() -> Assertions.assertEquals(database.countType(TYPE_NAME, true), TOT));
+ database.transaction(() -> assertThat(database.countType(TYPE_NAME, true)).isEqualTo(TOT));
database.close();
database = factory.open();
// TRY AGAIN WITH A RE-OPEN DATABASE
database.transaction(() -> {
- Assertions.assertTrue(database.getSchema().existsType(TYPE_NAME));
+ assertThat(database.getSchema().existsType(TYPE_NAME)).isTrue();
for (int i = TOT; i < TOT + TOT; ++i) {
final MutableVertex v = database.newVertex(TYPE_NAME);
@@ -174,6 +186,6 @@ public void testNullStrategySkipUnique() {
database.begin();
});
- database.transaction(() -> Assertions.assertEquals(database.countType(TYPE_NAME, true), TOT + TOT));
+ database.transaction(() -> assertThat(database.countType(TYPE_NAME, true)).isEqualTo(TOT + TOT));
}
}
diff --git a/engine/src/test/java/com/arcadedb/index/PlainLuceneFullTextIndexTest.java b/engine/src/test/java/com/arcadedb/index/PlainLuceneFullTextIndexTest.java
index 95a198016b..9ec14fe62b 100644
--- a/engine/src/test/java/com/arcadedb/index/PlainLuceneFullTextIndexTest.java
+++ b/engine/src/test/java/com/arcadedb/index/PlainLuceneFullTextIndexTest.java
@@ -34,12 +34,13 @@
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.Sort;
import org.apache.lucene.store.FSDirectory;
-import org.junit.jupiter.api.Assertions;
import java.io.*;
import java.nio.file.*;
import java.util.stream.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class PlainLuceneFullTextIndexTest {
public static void main(String[] args) throws IOException, ParseException {
final Path path = Paths.get("./target/databases/testIndex");
@@ -102,7 +103,7 @@ public static void main(String[] args) throws IOException, ParseException {
final Query query = parser.parse("elec*");
final ScoreDoc[] hits = searcher.search(query, 1000, Sort.RELEVANCE).scoreDocs;
- Assertions.assertEquals(501, hits.length);
+ assertThat(hits.length).isEqualTo(501);
// Iterate through the results:
for (int i = 0; i < hits.length; i++) {
final Document hitDoc = searcher.doc(hits[i].doc);
diff --git a/engine/src/test/java/com/arcadedb/index/TypeLSMTreeIndexTest.java b/engine/src/test/java/com/arcadedb/index/TypeLSMTreeIndexTest.java
index 73e54d2ffb..0db18c6c51 100644
--- a/engine/src/test/java/com/arcadedb/index/TypeLSMTreeIndexTest.java
+++ b/engine/src/test/java/com/arcadedb/index/TypeLSMTreeIndexTest.java
@@ -32,13 +32,17 @@
import com.arcadedb.schema.Schema;
import com.arcadedb.schema.Type;
import com.arcadedb.schema.VertexType;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.*;
import java.util.concurrent.atomic.*;
import java.util.logging.*;
+import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class TypeLSMTreeIndexTest extends TestHelper {
private static final int TOT = 100000;
private static final String TYPE_NAME = "V";
@@ -61,51 +65,17 @@ public void testGet() {
}
total++;
- Assertions.assertEquals(1, results.size());
- Assertions.assertEquals(i, (int) results.get(0));
+ assertThat(results).hasSize(1);
+ assertThat((int) results.get(0)).isEqualTo(i);
}
- Assertions.assertEquals(TOT, total);
+ assertThat(total).isEqualTo(TOT);
});
}
@Test
public void testGetAsRange() {
- database.transaction(() -> {
-
- final Collection indexes = database.getSchema().getType(TYPE_NAME).getAllIndexes(false);
- for (int i = 0; i < TOT; ++i) {
- int total = 0;
-
- for (final Index index : indexes) {
- Assertions.assertNotNull(index);
-
- final IndexCursor iterator;
- try {
- iterator = ((RangeIndex) index).range(true, new Object[] { i }, true, new Object[] { i }, true);
- Assertions.assertNotNull(iterator);
-
- while (iterator.hasNext()) {
- final Identifiable value = iterator.next();
-
- Assertions.assertNotNull(value);
-
- final int fieldValue = (int) value.asDocument().get("id");
- Assertions.assertEquals(i, fieldValue);
-
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
-
- total++;
- }
- } catch (final Exception e) {
- Assertions.fail(e);
- }
- }
-
- Assertions.assertEquals(1, total, "Get item with id=" + i);
- }
- });
+ database.transaction(this::execute);
}
@Test
@@ -117,28 +87,27 @@ public void testRangeFromHead() {
int total = 0;
for (final Index index : indexes) {
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
- final IndexCursor iterator;
- iterator = ((RangeIndex) index).range(true, new Object[] { i }, true, new Object[] { i + 1 }, true);
- Assertions.assertNotNull(iterator);
+ final IndexCursor iterator = ((RangeIndex) index).range(true, new Object[] { i }, true, new Object[] { i + 1 }, true);
+ assertThat((Iterator extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
final Identifiable value = iterator.next();
- Assertions.assertNotNull(value);
+ assertThat(value).isNotNull();
final int fieldValue = (int) value.asDocument().get("id");
- Assertions.assertTrue(fieldValue >= i && fieldValue <= i + 1);
+ assertThat(fieldValue >= i && fieldValue <= i + 1).isTrue();
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
++total;
}
}
- Assertions.assertEquals(2, total, "range " + i + "-" + (i + 1));
+ assertThat(total).isEqualTo(2).withFailMessage("range " + i + "-" + (i + 1));
}
});
}
@@ -152,28 +121,28 @@ public void testRangeFromTail() {
int total = 0;
for (final Index index : indexes) {
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
final IndexCursor iterator;
iterator = ((RangeIndex) index).range(false, new Object[] { i }, true, new Object[] { i - 1 }, true);
- Assertions.assertNotNull(iterator);
+ assertThat((Iterable extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
final Identifiable value = iterator.next();
- Assertions.assertNotNull(value);
+ assertThat(value).isNotNull();
final int fieldValue = (int) value.asDocument().get("id");
- Assertions.assertTrue(fieldValue >= i - 1 && fieldValue <= i);
+ assertThat(fieldValue >= i - 1 && fieldValue <= i).isTrue();
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
++total;
}
}
- Assertions.assertEquals(2, total, "range " + i + "-" + (i - 1));
+ assertThat(total).isEqualTo(2). withFailMessage("range " + i + "-" + (i - 1));
}
});
}
@@ -184,27 +153,26 @@ public void testRangeWithSQL() {
for (int i = 0; i < TOT - 1; ++i) {
int total = 0;
- final ResultSet iterator;
try {
+ final ResultSet iterator;
iterator = database.command("sql", "select from " + TYPE_NAME + " where id >= " + i + " and id <= " + (i + 1));
- Assertions.assertNotNull(iterator);
+ assertThat((Iterator extends Result>) iterator).isNotNull();
while (iterator.hasNext()) {
final Result value = iterator.next();
- Assertions.assertNotNull(value);
+ assertThat(value).isNotNull();
final int fieldValue = (int) value.getProperty("id");
- Assertions.assertTrue(fieldValue >= i && fieldValue <= i + 1);
+ assertThat(fieldValue >= i && fieldValue <= i + 1).isTrue();
total++;
}
} catch (final Exception e) {
- Assertions.fail(e);
+ fail(e);
}
-
- Assertions.assertEquals(2, total, "For ids >= " + i + " and <= " + (i + 1));
+ assertThat(total).isEqualTo(2).withFailMessage("For ids >= " + i + " and <= " + (i + 1));
}
});
}
@@ -224,7 +192,7 @@ public void testScanIndexAscending() {
final Collection indexes = database.getSchema().getType(TYPE_NAME).getAllIndexes(false);
for (final Index index : indexes) {
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
final IndexCursor iterator;
try {
@@ -233,13 +201,13 @@ public void testScanIndexAscending() {
// LogManager.instance()
// .log(this, Level.INFO, "*****************************************************************************\nCURSOR BEGIN%s", iterator.dumpStats());
- Assertions.assertNotNull(iterator);
+ assertThat((Iterable extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
- Assertions.assertNotNull(iterator.next());
+ assertThat(iterator.next()).isNotNull();
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
total++;
}
@@ -248,11 +216,11 @@ public void testScanIndexAscending() {
// iterator.dumpStats());
} catch (final Exception e) {
- Assertions.fail(e);
+ fail(e);
}
}
- Assertions.assertEquals(TOT, total);
+ assertThat(total).isEqualTo(TOT);
});
}
@@ -271,29 +239,29 @@ public void testScanIndexDescending() {
final Collection indexes = database.getSchema().getType(TYPE_NAME).getAllIndexes(false);
for (final Index index : indexes) {
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
final IndexCursor iterator;
try {
iterator = ((RangeIndex) index).iterator(false);
- Assertions.assertNotNull(iterator);
+ assertThat((Iterable extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
- Assertions.assertNotNull(iterator.next());
+ assertThat(iterator.next()).isNotNull();
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
//LogManager.instance().log(this, Level.INFO, "Index %s Key %s", null, index, Arrays.toString(iterator.getKeys()));
total++;
}
} catch (final Exception e) {
- Assertions.fail(e);
+ fail(e);
}
}
- Assertions.assertEquals(TOT, total);
+ assertThat(total).isEqualTo(TOT);
});
}
@@ -305,28 +273,28 @@ public void testScanIndexAscendingPartialInclusive() {
final Collection indexes = database.getSchema().getType(TYPE_NAME).getAllIndexes(false);
for (final Index index : indexes) {
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
final IndexCursor iterator;
try {
iterator = ((RangeIndex) index).iterator(true, new Object[] { 10 }, true);
- Assertions.assertNotNull(iterator);
+ assertThat((Iterable extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
- Assertions.assertNotNull(iterator.next());
+ assertThat(iterator.next()).isNotNull();
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
total++;
}
} catch (final Exception e) {
- Assertions.fail(e);
+ fail(e);
}
}
- Assertions.assertEquals(TOT - 10, total);
+ assertThat(total).isEqualTo(TOT - 10);
});
}
@@ -338,28 +306,28 @@ public void testScanIndexAscendingPartialExclusive() {
final Collection indexes = database.getSchema().getType(TYPE_NAME).getAllIndexes(false);
for (final Index index : indexes) {
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
final IndexCursor iterator;
try {
iterator = ((RangeIndex) index).iterator(true, new Object[] { 10 }, false);
- Assertions.assertNotNull(iterator);
+ assertThat((Iterable extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
- Assertions.assertNotNull(iterator.next());
+ assertThat(iterator.next()).isNotNull();
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
total++;
}
} catch (final Exception e) {
- Assertions.fail(e);
+ fail(e);
}
}
- Assertions.assertEquals(TOT - 11, total);
+ assertThat(total).isEqualTo(TOT - 11);
});
}
@@ -371,27 +339,27 @@ public void testScanIndexDescendingPartialInclusive() {
final Collection indexes = database.getSchema().getType(TYPE_NAME).getAllIndexes(false);
for (final Index index : indexes) {
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
final IndexCursor iterator;
try {
iterator = ((RangeIndex) index).iterator(false, new Object[] { 9 }, true);
- Assertions.assertNotNull(iterator);
+ assertThat((Iterable extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
- Assertions.assertNotNull(iterator.next());
+ assertThat(iterator.next()).isNotNull();
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
total++;
}
} catch (final Exception e) {
- Assertions.fail(e);
+ fail(e);
}
}
- Assertions.assertEquals(10, total);
+ assertThat(total).isEqualTo(10);
});
}
@@ -403,27 +371,27 @@ public void testScanIndexDescendingPartialExclusive() {
final Collection indexes = database.getSchema().getType(TYPE_NAME).getAllIndexes(false);
for (final Index index : indexes) {
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
final IndexCursor iterator;
try {
iterator = ((RangeIndex) index).iterator(false, new Object[] { 9 }, false);
- Assertions.assertNotNull(iterator);
+ assertThat((Iterable extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
- Assertions.assertNotNull(iterator.next());
+ assertThat(iterator.next()).isNotNull();
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
total++;
}
} catch (final Exception e) {
- Assertions.fail(e);
+ fail(e);
}
}
- Assertions.assertEquals(9, total);
+ assertThat(total).isEqualTo(9);
});
}
@@ -435,32 +403,32 @@ public void testScanIndexRangeInclusive2Inclusive() {
final Collection indexes = database.getSchema().getType(TYPE_NAME).getAllIndexes(false);
for (final Index index : indexes) {
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
final IndexCursor iterator;
try {
iterator = ((RangeIndex) index).range(true, new Object[] { 10 }, true, new Object[] { 19 }, true);
- Assertions.assertNotNull(iterator);
+ assertThat((Iterable extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
final Identifiable value = iterator.next();
- Assertions.assertNotNull(value);
+ assertThat(value).isNotNull();
final int fieldValue = (int) value.asDocument().get("id");
- Assertions.assertTrue(fieldValue >= 10 && fieldValue <= 19);
+ assertThat(fieldValue >= 10 && fieldValue <= 19).isTrue();
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
total++;
}
} catch (final Exception e) {
- Assertions.fail(e);
+ fail(e);
}
}
- Assertions.assertEquals(10, total);
+ assertThat(total).isEqualTo(10);
});
}
@@ -472,32 +440,32 @@ public void testScanIndexRangeInclusive2Exclusive() {
final Collection indexes = database.getSchema().getType(TYPE_NAME).getAllIndexes(false);
for (final Index index : indexes) {
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
final IndexCursor iterator;
try {
iterator = ((RangeIndex) index).range(true, new Object[] { 10 }, true, new Object[] { 19 }, false);
- Assertions.assertNotNull(iterator);
+ assertThat((Iterable extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
final Identifiable value = iterator.next();
- Assertions.assertNotNull(value);
+ assertThat(value).isNotNull();
final int fieldValue = (int) value.asDocument().get("id");
- Assertions.assertTrue(fieldValue >= 10 && fieldValue < 19);
+ assertThat(fieldValue >= 10 && fieldValue < 19).isTrue();
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
total++;
}
} catch (final Exception e) {
- Assertions.fail(e);
+ fail(e);
}
}
- Assertions.assertEquals(9, total);
+ assertThat(total).isEqualTo(9);
});
}
@@ -509,32 +477,32 @@ public void testScanIndexRangeExclusive2Inclusive() {
final Collection indexes = database.getSchema().getType(TYPE_NAME).getAllIndexes(false);
for (final Index index : indexes) {
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
final IndexCursor iterator;
try {
iterator = ((RangeIndex) index).range(true, new Object[] { 10 }, false, new Object[] { 19 }, true);
- Assertions.assertNotNull(iterator);
+ assertThat((Iterable extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
final Identifiable value = iterator.next();
- Assertions.assertNotNull(value);
+ assertThat(value).isNotNull();
final int fieldValue = (int) value.asDocument().get("id");
- Assertions.assertTrue(fieldValue > 10 && fieldValue <= 19);
+ assertThat(fieldValue > 10 && fieldValue <= 19).isTrue();
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
total++;
}
} catch (final Exception e) {
- Assertions.fail(e);
+ fail(e);
}
}
- Assertions.assertEquals(9, total);
+ assertThat(total).isEqualTo(9);
});
}
@@ -546,32 +514,32 @@ public void testScanIndexRangeExclusive2InclusiveInverse() {
final Collection indexes = database.getSchema().getType(TYPE_NAME).getAllIndexes(false);
for (final Index index : indexes) {
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
final IndexCursor iterator;
try {
iterator = ((RangeIndex) index).range(false, new Object[] { 19 }, false, new Object[] { 10 }, true);
- Assertions.assertNotNull(iterator);
+ assertThat((Iterable extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
final Identifiable value = iterator.next();
- Assertions.assertNotNull(value);
+ assertThat(value).isNotNull();
final int fieldValue = (int) value.asDocument().get("id");
- Assertions.assertTrue(fieldValue >= 10 && fieldValue < 19);
+ assertThat(fieldValue >= 10 && fieldValue < 19).isTrue();
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
total++;
}
} catch (final Exception e) {
- Assertions.fail(e);
+ fail(e);
}
}
- Assertions.assertEquals(9, total);
+ assertThat(total).isEqualTo(9);
});
}
@@ -583,32 +551,32 @@ public void testScanIndexRangeExclusive2Exclusive() {
final Collection indexes = database.getSchema().getType(TYPE_NAME).getAllIndexes(false);
for (final Index index : indexes) {
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
final IndexCursor iterator;
try {
iterator = ((RangeIndex) index).range(true, new Object[] { 10 }, false, new Object[] { 19 }, false);
- Assertions.assertNotNull(iterator);
+ assertThat((Iterable extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
final Identifiable value = iterator.next();
- Assertions.assertNotNull(value);
+ assertThat(value).isNotNull();
final int fieldValue = (int) value.asDocument().get("id");
- Assertions.assertTrue(fieldValue > 10 && fieldValue < 19);
+ assertThat(fieldValue > 10 && fieldValue < 19).isTrue();
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
total++;
}
} catch (final Exception e) {
- Assertions.fail(e);
+ fail(e);
}
}
- Assertions.assertEquals(8, total);
+ assertThat(total).isEqualTo(8);
});
}
@@ -620,32 +588,32 @@ public void testScanIndexRangeExclusive2ExclusiveInverse() {
final Collection indexes = database.getSchema().getType(TYPE_NAME).getAllIndexes(false);
for (final Index index : indexes) {
- Assertions.assertNotNull(index);
+ assertThat(index).isNotNull();
final IndexCursor iterator;
try {
iterator = ((RangeIndex) index).range(false, new Object[] { 19 }, false, new Object[] { 10 }, false);
- Assertions.assertNotNull(iterator);
+ assertThat((Iterable extends Identifiable>) iterator).isNotNull();
while (iterator.hasNext()) {
final Identifiable value = iterator.next();
- Assertions.assertNotNull(value);
+ assertThat(value).isNotNull();
final int fieldValue = (int) value.asDocument().get("id");
- Assertions.assertTrue(fieldValue > 10 && fieldValue < 19);
+ assertThat(fieldValue > 10 && fieldValue < 19).isTrue();
- Assertions.assertNotNull(iterator.getKeys());
- Assertions.assertEquals(1, iterator.getKeys().length);
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
total++;
}
} catch (final Exception e) {
- Assertions.fail(e);
+ fail(e);
}
}
- Assertions.assertEquals(8, total);
+ assertThat(total).isEqualTo(8);
});
}
@@ -707,16 +675,16 @@ public void run() {
} catch (final NeedRetryException e) {
needRetryExceptions.incrementAndGet();
- Assertions.assertFalse(database.isTransactionActive());
+ assertThat(database.isTransactionActive()).isFalse();
continue;
} catch (final DuplicatedKeyException e) {
duplicatedExceptions.incrementAndGet();
keyPresent = true;
- Assertions.assertFalse(database.isTransactionActive());
+ assertThat(database.isTransactionActive()).isFalse();
} catch (final Exception e) {
LogManager.instance()
.log(this, Level.SEVERE, "%s Thread %d Generic Exception", e, getClass(), Thread.currentThread().getId());
- Assertions.assertFalse(database.isTransactionActive());
+ assertThat(database.isTransactionActive()).isFalse();
return;
}
}
@@ -784,29 +752,29 @@ public void run() {
}
}
- Assertions.assertEquals(total, crossThreadsInserted.get());
-// Assertions.assertTrue(needRetryExceptions.get() > 0);
- Assertions.assertTrue(duplicatedExceptions.get() > 0);
+ assertThat(crossThreadsInserted.get()).isEqualTo(total);
+// Assertions.assertThat(needRetryExceptions.get() > 0).isTrue();
+ assertThat(duplicatedExceptions.get() > 0).isTrue();
- Assertions.assertEquals(startingWith + total, database.countType(TYPE_NAME, true));
+ assertThat(database.countType(TYPE_NAME, true)).isEqualTo(startingWith + total);
}
@Test
public void testRebuildIndex() {
final Index typeIndexBefore = database.getSchema().getIndexByName(TYPE_NAME + "[id]");
- Assertions.assertNotNull(typeIndexBefore);
- Assertions.assertEquals(1, typeIndexBefore.getPropertyNames().size());
+ assertThat(typeIndexBefore).isNotNull();
+ assertThat(typeIndexBefore.getPropertyNames().size()).isEqualTo(1);
database.command("sql", "rebuild index * with batchSize = 1000");
final Index typeIndexAfter = database.getSchema().getIndexByName(TYPE_NAME + "[id]");
- Assertions.assertNotNull(typeIndexAfter);
- Assertions.assertEquals(1, typeIndexAfter.getPropertyNames().size());
+ assertThat(typeIndexAfter).isNotNull();
+ assertThat(typeIndexAfter.getPropertyNames().size()).isEqualTo(1);
- Assertions.assertEquals(typeIndexBefore.getName(), typeIndexAfter.getName());
+ assertThat(typeIndexAfter.getName()).isEqualTo(typeIndexBefore.getName());
- Assertions.assertTrue(typeIndexAfter.get(new Object[] { 0 }).hasNext());
- Assertions.assertEquals(0, typeIndexAfter.get(new Object[] { 0 }).next().asDocument().getInteger("id"));
+ assertThat(typeIndexAfter.get(new Object[] { 0 }).hasNext()).isTrue();
+ assertThat(typeIndexAfter.get(new Object[] { 0 }).next().asDocument().getInteger("id")).isEqualTo(0);
}
@Test
@@ -849,21 +817,20 @@ public void testIndexNameSpecialCharactersUsingSQL() throws InterruptedException
database = factory.exists() ? factory.open() : factory.create();
database.command("sql", "rebuild index `This.is:special[other.special:property]`");
- Assertions.assertEquals("testEncoding",
- database.query("sql", "select from `This.is:special` where `other.special:property` = 'testEncoding'").nextIfAvailable()
- .getProperty("other.special:property"));
+ assertThat(database.query("sql", "select from `This.is:special` where `other.special:property` = 'testEncoding'")
+ .nextIfAvailable().getProperty("other.special:property")).isEqualTo("testEncoding");
}
@Test
public void testSQL() {
final Index typeIndexBefore = database.getSchema().getIndexByName(TYPE_NAME + "[id]");
- Assertions.assertNotNull(typeIndexBefore);
+ assertThat(typeIndexBefore).isNotNull();
database.command("sql", "create index if not exists on " + TYPE_NAME + " (id) UNIQUE");
}
protected void beginTest() {
database.transaction(() -> {
- Assertions.assertFalse(database.getSchema().existsType(TYPE_NAME));
+ assertThat(database.getSchema().existsType(TYPE_NAME)).isFalse();
final DocumentType type = database.getSchema().buildDocumentType().withName(TYPE_NAME).withTotalBuckets(3).create();
type.createProperty("id", Integer.class);
@@ -882,9 +849,46 @@ protected void beginTest() {
database.commit();
database.begin();
- for (final Index index : ((TypeIndex) typeIndex).getIndexesOnBuckets()) {
- Assertions.assertTrue(((IndexInternal) index).getStats().get("pages") > 1);
+ for (final IndexInternal index : ((TypeIndex) typeIndex).getIndexesOnBuckets()) {
+
+ assertThat(index.getStats().get("pages")).isGreaterThan(1);
}
});
}
+
+ private void execute() {
+
+ final Collection indexes = database.getSchema().getType(TYPE_NAME).getAllIndexes(false);
+ for (int i = 0; i < TOT; ++i) {
+ int total = 0;
+
+ for (final Index index : indexes) {
+ assertThat(index).isNotNull();
+
+ try {
+ final IndexCursor iterator;
+ iterator = ((RangeIndex) index).range(true, new Object[] { i }, true, new Object[] { i }, true);
+ assertThat((Iterable extends Identifiable>) iterator).isNotNull();
+
+ while (iterator.hasNext()) {
+ final Identifiable value = iterator.next();
+
+ assertThat(value).isNotNull();
+
+ final int fieldValue = (int) value.asDocument().get("id");
+ assertThat(fieldValue).isEqualTo(i);
+
+ assertThat(iterator.getKeys()).isNotNull();
+ assertThat(iterator.getKeys().length).isEqualTo(1);
+
+ total++;
+ }
+ } catch (final Exception e) {
+ fail(e);
+ }
+ }
+
+ assertThat(total).isEqualTo(1);
+ }
+ }
}
diff --git a/engine/src/test/java/com/arcadedb/query/java/JavaQueryTest.java b/engine/src/test/java/com/arcadedb/query/java/JavaQueryTest.java
index b791c63ee9..91a61e2ffc 100644
--- a/engine/src/test/java/com/arcadedb/query/java/JavaQueryTest.java
+++ b/engine/src/test/java/com/arcadedb/query/java/JavaQueryTest.java
@@ -4,10 +4,12 @@
import com.arcadedb.exception.CommandExecutionException;
import com.arcadedb.query.QueryEngine;
import com.arcadedb.query.sql.executor.ResultSet;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
-import java.util.*;
+import java.util.HashMap;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
class JavaMethods {
public JavaMethods() {
@@ -29,13 +31,13 @@ public static void hello() {
public class JavaQueryTest extends TestHelper {
@Test
public void testRegisteredMethod() {
- Assertions.assertEquals("java", database.getQueryEngine("java").getLanguage());
+ assertThat(database.getQueryEngine("java").getLanguage()).isEqualTo("java");
database.getQueryEngine("java").registerFunctions("com.arcadedb.query.java.JavaMethods::sum");
final ResultSet result = database.command("java", "com.arcadedb.query.java.JavaMethods::sum", 5, 3);
- Assertions.assertTrue(result.hasNext());
- Assertions.assertEquals(8, (Integer) result.next().getProperty("value"));
+ assertThat(result.hasNext()).isTrue();
+ assertThat((Integer) result.next().getProperty("value")).isEqualTo(8);
}
@Test
@@ -44,12 +46,12 @@ public void testRegisteredMethods() {
database.getQueryEngine("java").registerFunctions("com.arcadedb.query.java.JavaMethods::SUM");
ResultSet result = database.command("java", "com.arcadedb.query.java.JavaMethods::sum", 5, 3);
- Assertions.assertTrue(result.hasNext());
- Assertions.assertEquals(8, (Integer) result.next().getProperty("value"));
+ assertThat(result.hasNext()).isTrue();
+ assertThat((Integer) result.next().getProperty("value")).isEqualTo(8);
result = database.command("java", "com.arcadedb.query.java.JavaMethods::SUM", 5, 3);
- Assertions.assertTrue(result.hasNext());
- Assertions.assertEquals(8, (Integer) result.next().getProperty("value"));
+ assertThat(result.hasNext()).isTrue();
+ assertThat((Integer) result.next().getProperty("value")).isEqualTo(8);
database.getQueryEngine("java").unregisterFunctions();
}
@@ -59,12 +61,12 @@ public void testRegisteredClass() {
database.getQueryEngine("java").registerFunctions("com.arcadedb.query.java.JavaMethods");
ResultSet result = database.command("java", "com.arcadedb.query.java.JavaMethods::sum", 5, 3);
- Assertions.assertTrue(result.hasNext());
- Assertions.assertEquals(8, (Integer) result.next().getProperty("value"));
+ assertThat(result.hasNext()).isTrue();
+ assertThat((Integer) result.next().getProperty("value")).isEqualTo(8);
result = database.command("java", "com.arcadedb.query.java.JavaMethods::SUM", 5, 3);
- Assertions.assertTrue(result.hasNext());
- Assertions.assertEquals(8, (Integer) result.next().getProperty("value"));
+ assertThat(result.hasNext()).isTrue();
+ assertThat((Integer) result.next().getProperty("value")).isEqualTo(8);
database.getQueryEngine("java").unregisterFunctions();
}
@@ -73,10 +75,10 @@ public void testRegisteredClass() {
public void testUnRegisteredMethod() {
try {
database.command("java", "com.arcadedb.query.java.JavaMethods::sum", 5, 3);
- Assertions.fail();
+ fail("");
} catch (final CommandExecutionException e) {
// EXPECTED
- Assertions.assertTrue(e.getCause() instanceof SecurityException);
+ assertThat(e.getCause() instanceof SecurityException).isTrue();
}
}
@@ -85,10 +87,10 @@ public void testNotExistentMethod() {
database.getQueryEngine("java").registerFunctions("com.arcadedb.query.java.JavaMethods");
try {
database.command("java", "com.arcadedb.query.java.JavaMethods::totallyInvented", 5, 3);
- Assertions.fail();
+ fail("");
} catch (final CommandExecutionException e) {
// EXPECTED
- Assertions.assertTrue(e.getCause() instanceof NoSuchMethodException);
+ assertThat(e.getCause() instanceof NoSuchMethodException).isTrue();
}
}
@@ -96,8 +98,8 @@ public void testNotExistentMethod() {
public void testAnalyzeQuery() {
database.getQueryEngine("java").registerFunctions("com.arcadedb.query.java.JavaMethods");
final QueryEngine.AnalyzedQuery analyzed = database.getQueryEngine("java").analyze("com.arcadedb.query.java.JavaMethods::totallyInvented");
- Assertions.assertFalse(analyzed.isDDL());
- Assertions.assertFalse(analyzed.isIdempotent());
+ assertThat(analyzed.isDDL()).isFalse();
+ assertThat(analyzed.isIdempotent()).isFalse();
}
@Test
@@ -105,7 +107,7 @@ public void testUnsupportedMethods() {
database.getQueryEngine("java").registerFunctions("com.arcadedb.query.java.JavaMethods");
try {
database.query("java", "com.arcadedb.query.java.JavaMethods::sum", 5, 3);
- Assertions.fail();
+ fail("");
} catch (final UnsupportedOperationException e) {
// EXPECTED
}
@@ -115,7 +117,7 @@ public void testUnsupportedMethods() {
final HashMap map = new HashMap();
map.put("name", 1);
database.getQueryEngine("java").command("com.arcadedb.query.java.JavaMethods::hello", null, map);
- Assertions.fail();
+ fail("");
} catch (final UnsupportedOperationException e) {
// EXPECTED
}
@@ -123,7 +125,7 @@ public void testUnsupportedMethods() {
database.getQueryEngine("java").registerFunctions("com.arcadedb.query.java.JavaMethods");
try {
database.getQueryEngine("java").query("com.arcadedb.query.java.JavaMethods::sum", null, new HashMap<>());
- Assertions.fail();
+ fail("");
} catch (final UnsupportedOperationException e) {
// EXPECTED
}
diff --git a/engine/src/test/java/com/arcadedb/query/polyglot/PolyglotQueryTest.java b/engine/src/test/java/com/arcadedb/query/polyglot/PolyglotQueryTest.java
index 7d904c7669..069ec452e0 100644
--- a/engine/src/test/java/com/arcadedb/query/polyglot/PolyglotQueryTest.java
+++ b/engine/src/test/java/com/arcadedb/query/polyglot/PolyglotQueryTest.java
@@ -9,19 +9,21 @@
import com.arcadedb.query.QueryEngine;
import com.arcadedb.query.sql.executor.ResultSet;
import org.graalvm.polyglot.PolyglotException;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
-import java.math.*;
-import java.util.*;
-import java.util.concurrent.*;
+import java.math.BigDecimal;
+import java.util.Collections;
+import java.util.concurrent.TimeoutException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
public class PolyglotQueryTest extends TestHelper {
@Test
public void testSum() {
final ResultSet result = database.command("js", "3 + 5");
- Assertions.assertTrue(result.hasNext());
- Assertions.assertEquals(8, (Integer) result.next().getProperty("value"));
+ assertThat(result.hasNext()).isTrue();
+ assertThat((Integer) result.next().getProperty("value")).isEqualTo(8);
}
@Test
@@ -32,11 +34,11 @@ public void testDatabaseQuery() {
});
final ResultSet result = database.command("js", "database.query('sql', 'select from Product')");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Vertex vertex = result.next().getRecord().get().asVertex();
- Assertions.assertEquals("Amiga 1200", vertex.get("name"));
- Assertions.assertEquals(900, vertex.get("price"));
+ assertThat(vertex.get("name")).isEqualTo("Amiga 1200");
+ assertThat(vertex.get("price")).isEqualTo(900);
}
@Test
@@ -44,12 +46,12 @@ public void testSandbox() {
// BY DEFAULT NO JAVA PACKAGES ARE ACCESSIBLE
try {
final ResultSet result = database.command("js", "let BigDecimal = Java.type('java.math.BigDecimal'); new BigDecimal(1)");
- Assertions.assertFalse(result.hasNext());
- Assertions.fail("It should not execute the function");
+ assertThat(result.hasNext()).isFalse();
+ fail("It should not execute the function");
} catch (final Exception e) {
- Assertions.assertTrue(e instanceof CommandExecutionException);
- Assertions.assertTrue(e.getCause() instanceof PolyglotException);
- Assertions.assertTrue(e.getCause().getMessage().contains("java.math.BigDecimal"));
+ assertThat(e instanceof CommandExecutionException).isTrue();
+ assertThat(e.getCause() instanceof PolyglotException).isTrue();
+ assertThat(e.getCause().getMessage().contains("java.math.BigDecimal")).isTrue();
}
// ALLOW ACCESSING TO BIG DECIMAL CLASS
@@ -59,8 +61,8 @@ public void testSandbox() {
final ResultSet result = database.command("js", "let BigDecimal = Java.type('java.math.BigDecimal'); new BigDecimal(1)");
- Assertions.assertTrue(result.hasNext());
- Assertions.assertEquals(new BigDecimal(1), result.next().getProperty("value"));
+ assertThat(result.hasNext()).isTrue();
+ assertThat(result.next().getProperty("value")).isEqualTo(new BigDecimal(1));
}
@Test
@@ -68,12 +70,12 @@ public void testSandboxSystem() {
// BY DEFAULT NO JAVA PACKAGES ARE ACCESSIBLE
try {
final ResultSet result = database.command("js", "let System = Java.type('java.lang.System'); System.exit(1)");
- Assertions.assertFalse(result.hasNext());
- Assertions.fail("It should not execute the function");
+ assertThat(result.hasNext()).isFalse();
+ fail("It should not execute the function");
} catch (final Exception e) {
- Assertions.assertTrue(e instanceof CommandExecutionException);
- Assertions.assertTrue(e.getCause() instanceof PolyglotException);
- Assertions.assertTrue(e.getCause().getMessage().contains("java.lang.System"));
+ assertThat(e instanceof CommandExecutionException).isTrue();
+ assertThat(e.getCause() instanceof PolyglotException).isTrue();
+ assertThat(e.getCause().getMessage().contains("java.lang.System")).isTrue();
}
}
@@ -82,10 +84,10 @@ public void testTimeout() {
GlobalConfiguration.POLYGLOT_COMMAND_TIMEOUT.setValue(2000);
try {
database.command("js", "while(true);");
- Assertions.fail("It should go in timeout");
+ fail("It should go in timeout");
} catch (final Exception e) {
- Assertions.assertTrue(e instanceof CommandExecutionException);
- Assertions.assertTrue(e.getCause() instanceof TimeoutException);
+ assertThat(e instanceof CommandExecutionException).isTrue();
+ assertThat(e.getCause() instanceof TimeoutException).isTrue();
} finally {
GlobalConfiguration.POLYGLOT_COMMAND_TIMEOUT.reset();
}
@@ -94,7 +96,7 @@ public void testTimeout() {
@Test
public void testAnalyzeQuery() {
final QueryEngine.AnalyzedQuery analyzed = database.getQueryEngine("js").analyze("3 + 5");
- Assertions.assertFalse(analyzed.isDDL());
- Assertions.assertFalse(analyzed.isIdempotent());
+ assertThat(analyzed.isDDL()).isFalse();
+ assertThat(analyzed.isIdempotent()).isFalse();
}
}
diff --git a/engine/src/test/java/com/arcadedb/query/select/SelectExecutionIT.java b/engine/src/test/java/com/arcadedb/query/select/SelectExecutionIT.java
index 6253f9da32..6ddef7f346 100644
--- a/engine/src/test/java/com/arcadedb/query/select/SelectExecutionIT.java
+++ b/engine/src/test/java/com/arcadedb/query/select/SelectExecutionIT.java
@@ -25,6 +25,7 @@
import com.arcadedb.schema.Schema;
import com.arcadedb.schema.Type;
import com.arcadedb.serializer.json.JSONObject;
+
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
@@ -32,6 +33,10 @@
import java.util.concurrent.*;
import java.util.stream.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+import static org.junit.jupiter.api.Assertions.*;
+
/**
* @author Luca Garulli (l.garulli@arcadedata.com)
*/
@@ -57,8 +62,8 @@ protected void beginTest() {
for (int i = 1; i < 100; i++) {
final Vertex root = database.select().fromType("Vertex").where().property("id").eq().value(0).vertices().nextOrNull();
- Assertions.assertNotNull(root);
- Assertions.assertEquals(0, root.getInteger("id"));
+ assertNotNull(root);
+ assertEquals(0, root.getInteger("id"));
root.newEdge("Edge", database.select().fromType("Vertex").where().property("id").eq().value(i).vertices().nextOrNull(),
true).save();
@@ -76,7 +81,7 @@ public void okFromBuckets() {
.and().property("name").eq().value("Elon").compile();
for (int i = 0; i < 100; i++)
- Assertions.assertEquals(i, select.parameter("value", i).vertices().nextOrNull().getInteger("id"));
+ assertThat(select.parameter("value", i).vertices().nextOrNull().getInteger("id")).isEqualTo(i);
}
{
@@ -87,7 +92,7 @@ public void okFromBuckets() {
.and().property("name").eq().value("Elon").compile();
for (int i = 0; i < 100; i++)
- Assertions.assertEquals(i, select.parameter("value", i).vertices().nextOrNull().getInteger("id"));
+ assertThat(select.parameter("value", i).vertices().nextOrNull().getInteger("id")).isEqualTo(i);
}
}
@@ -99,7 +104,7 @@ public void okAnd() {
.and().property("name").eq().value("Elon").compile();
for (int i = 0; i < 100; i++)
- Assertions.assertEquals(i, select.parameter("value", i).vertices().nextOrNull().getInteger("id"));
+ assertThat(select.parameter("value", i).vertices().nextOrNull().getInteger("id")).isEqualTo(i);
}
{
@@ -107,7 +112,7 @@ public void okAnd() {
.where().property("id").eq().parameter("value")//
.and().property("name").eq().value("Elon2").compile();
- Assertions.assertFalse(select.parameter("value", 3).vertices().hasNext());
+ assertThat(select.parameter("value", 3).vertices().hasNext()).isFalse();
}
{
@@ -115,7 +120,7 @@ public void okAnd() {
.where().property("id").eq().value(-1)//
.and().property("name").eq().value("Elon").compile();
- Assertions.assertFalse(select.vertices().hasNext());
+ assertThat(select.vertices().hasNext()).isFalse();
}
{
@@ -126,7 +131,7 @@ public void okAnd() {
.and().property("name").eq().value("Elon").compile();
for (int i = 0; i < 100; i++)
- Assertions.assertEquals(i, select.parameter("value", i).vertices().nextOrNull().getInteger("id"));
+ assertThat(select.parameter("value", i).vertices().nextOrNull().getInteger("id")).isEqualTo(i);
}
}
@@ -139,7 +144,7 @@ public void okOr() {
for (SelectIterator result = select.parameter("value", 3).vertices(); result.hasNext(); ) {
final Vertex v = result.next();
- Assertions.assertTrue(v.getInteger("id").equals(3) || v.getString("name").equals("Elon"));
+ assertThat(v.getInteger("id").equals(3) || v.getString("name").equals("Elon")).isTrue();
}
}
@@ -150,7 +155,7 @@ public void okOr() {
for (SelectIterator result = select.parameter("value", 3).vertices(); result.hasNext(); ) {
final Vertex v = result.next();
- Assertions.assertTrue(v.getInteger("id").equals(3) || v.getString("name").equals("Elon2"));
+ assertThat(v.getInteger("id").equals(3) || v.getString("name").equals("Elon2")).isTrue();
}
}
@@ -161,7 +166,7 @@ public void okOr() {
for (SelectIterator result = select.parameter("value", 3).vertices(); result.hasNext(); ) {
final Vertex v = result.next();
- Assertions.assertTrue(v.getInteger("id").equals(-1) || v.getString("name").equals("Elon"));
+ assertThat(v.getInteger("id").equals(-1) || v.getString("name").equals("Elon")).isTrue();
}
}
}
@@ -176,8 +181,8 @@ public void okAndOr() {
for (SelectIterator result = select.parameter("value", 3).vertices(); result.hasNext(); ) {
final Vertex v = result.next();
- Assertions.assertTrue(v.getInteger("id").equals(3) && v.getString("name").equals("Elon2") ||//
- v.getString("name").equals("Elon"));
+ assertThat(v.getInteger("id").equals(3) && v.getString("name").equals("Elon2") ||//
+ v.getString("name").equals("Elon")).isTrue();
}
}
@@ -189,8 +194,8 @@ public void okAndOr() {
for (SelectIterator result = select.parameter("value", 3).vertices(); result.hasNext(); ) {
final Vertex v = result.next();
- Assertions.assertTrue(v.getInteger("id").equals(3) ||//
- v.getString("name").equals("Elon2") && v.getString("name").equals("Elon"));
+ assertThat(v.getInteger("id").equals(3) ||//
+ v.getString("name").equals("Elon2") && v.getString("name").equals("Elon")).isTrue();
}
}
}
@@ -204,10 +209,10 @@ public void okLimit() {
final SelectIterator iter = select.vertices();
int browsed = 0;
while (iter.hasNext()) {
- Assertions.assertTrue(iter.next().getInteger("id") < 10);
+ assertThat(iter.next().getInteger("id") < 10).isTrue();
++browsed;
}
- Assertions.assertEquals(10, browsed);
+ assertThat(browsed).isEqualTo(10);
}
@Test
@@ -219,10 +224,10 @@ public void okSkip() {
SelectIterator iter = select.vertices();
int browsed = 0;
while (iter.hasNext()) {
- Assertions.assertTrue(iter.next().getInteger("id") < 10);
+ assertThat(iter.next().getInteger("id") < 10).isTrue();
++browsed;
}
- Assertions.assertEquals(0, browsed);
+ assertThat(browsed).isEqualTo(0);
select = database.select().fromType("Vertex")//
.where().property("id").lt().value(10)//
@@ -231,10 +236,10 @@ public void okSkip() {
iter = select.vertices();
browsed = 0;
while (iter.hasNext()) {
- Assertions.assertTrue(iter.next().getInteger("id") < 10);
+ assertThat(iter.next().getInteger("id") < 10).isTrue();
++browsed;
}
- Assertions.assertEquals(10, browsed);
+ assertThat(browsed).isEqualTo(10);
select = database.select().fromType("Vertex")//
.where().property("id").lt().value(10)//
@@ -243,10 +248,10 @@ public void okSkip() {
iter = select.vertices();
browsed = 0;
while (iter.hasNext()) {
- Assertions.assertTrue(iter.next().getInteger("id") < 10);
+ assertThat(iter.next().getInteger("id") < 10).isTrue();
++browsed;
}
- Assertions.assertEquals(8, browsed);
+ assertThat(browsed).isEqualTo(8);
}
@Test
@@ -262,7 +267,7 @@ public void okUpdate() {
database.select().fromType("Vertex")//
.where().property("id").lt().value(10)//
.and().property("name").eq().value("Elon").limit(10).vertices()
- .forEachRemaining(r -> Assertions.assertTrue(r.getInteger("id") < 10 && r.getBoolean("modified")));
+ .forEachRemaining(r -> assertTrue(r.getInteger("id") < 10 && r.getBoolean("modified")));
}
@Test
@@ -299,8 +304,8 @@ public void okNeq() {
final int finalI = i;
final SelectIterator result = select.parameter("value", i).vertices();
final List list = result.toList();
- Assertions.assertEquals(99, list.size());
- list.forEach(r -> Assertions.assertTrue(r.getInteger("id") != finalI));
+ assertThat(list.size()).isEqualTo(99);
+ list.forEach(r -> assertTrue(r.getInteger("id") != finalI));
}
}
@@ -327,8 +332,8 @@ public void okParallel() {
final SelectIterator result = select.vertices();
final List list = result.toList();
- Assertions.assertEquals(1_000_000, list.size());
- list.forEach(r -> Assertions.assertTrue(r.getString("name").startsWith("E")));
+ assertThat(list.size()).isEqualTo(1_000_000);
+ list.forEach(r -> assertTrue(r.getString("name").startsWith("E")));
System.out.println(i + " " + (System.currentTimeMillis() - beginTime));
}
@@ -342,8 +347,8 @@ public void okLike() {
for (int i = 0; i < 100; i++) {
final SelectIterator result = select.parameter("value", i).vertices();
final List list = result.toList();
- Assertions.assertEquals(100, list.size());
- list.forEach(r -> Assertions.assertTrue(r.getString("name").startsWith("E")));
+ assertThat(list.size()).isEqualTo(100);
+ list.forEach(r -> assertTrue(r.getString("name").startsWith("E")));
}
}
@@ -355,8 +360,8 @@ public void okILike() {
for (int i = 0; i < 100; i++) {
final SelectIterator result = select.parameter("value", i).vertices();
final List list = result.toList();
- Assertions.assertEquals(100, list.size());
- list.forEach(r -> Assertions.assertTrue(r.getString("name").startsWith("E")));
+ assertThat(list.size()).isEqualTo(100);
+ list.forEach(r -> assertTrue(r.getString("name").startsWith("E")));
}
}
@@ -373,7 +378,7 @@ public void errorMissingParameter() {
public void okReuse() {
final SelectCompiled select = database.select().fromType("Vertex").where().property("id").eq().parameter("value").compile();
for (int i = 0; i < 100; i++)
- Assertions.assertEquals(i, select.parameter("value", i).vertices().nextOrNull().getInteger("id"));
+ assertThat(select.parameter("value", i).vertices().nextOrNull().getInteger("id")).isEqualTo(i);
}
@Test
@@ -388,7 +393,7 @@ public void okJSON() {
final JSONObject json2 = database.select().json(json).compile().json();
- Assertions.assertEquals(json, json2);
+ assertThat(json2).isEqualTo(json);
}
}
@@ -402,12 +407,11 @@ private void expectingException(final Runnable callback, final Class extends T
if (!expectedException.equals(e.getClass()))
e.printStackTrace();
- Assertions.assertEquals(expectedException, e.getClass());
- Assertions.assertTrue(e.getMessage().contains(mustContains),
- "Expected '" + mustContains + "' in the error message. Error message is: " + e.getMessage());
+ assertThat(e.getClass()).isEqualTo(expectedException);
+ assertThat(e.getMessage().contains(mustContains)).as("Expected '" + mustContains + "' in the error message. Error message is: " + e.getMessage()).isTrue();
}
if (!failed)
- Assertions.fail("Expected exception " + expectedException);
+ fail("Expected exception " + expectedException);
}
}
diff --git a/engine/src/test/java/com/arcadedb/query/select/SelectIndexExecutionIT.java b/engine/src/test/java/com/arcadedb/query/select/SelectIndexExecutionIT.java
index c3f562861c..61c4f7b39d 100644
--- a/engine/src/test/java/com/arcadedb/query/select/SelectIndexExecutionIT.java
+++ b/engine/src/test/java/com/arcadedb/query/select/SelectIndexExecutionIT.java
@@ -23,11 +23,13 @@
import com.arcadedb.schema.Schema;
import com.arcadedb.schema.Type;
import com.arcadedb.schema.VertexType;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.Test;
import java.util.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
/**
* @author Luca Garulli (l.garulli@arcadedata.com)
*/
@@ -66,13 +68,13 @@ public void okOneOfTwoAvailableIndexes() {
final SelectIterator result = select.parameter("value", i).vertices();
final List list = result.toList();
- Assertions.assertEquals(i < 100 ? 1 : 0, list.size());
+ assertThat(list.size()).isEqualTo(i < 100 ? 1 : 0);
- list.forEach(r -> Assertions.assertTrue(r.getInteger("id") == finalI && r.getString("name").equals("Elon")));
+ list.forEach(r -> assertThat(r.getInteger("id") == finalI && r.getString("name").equals("Elon")).isTrue());
// CHECK 1 FOR ID = I + 100 FOR NAME = ELON (ALL OF THEM)
- Assertions.assertEquals(1L, result.getMetrics().get("evaluatedRecords"), "With id " + i);
- Assertions.assertEquals(1, result.getMetrics().get("usedIndexes"));
+ assertThat(result.getMetrics().get("evaluatedRecords")).as("With id " + i).isEqualTo(1L);
+ assertThat(result.getMetrics().get("usedIndexes")).isEqualTo(1);
}
}
}
@@ -89,11 +91,11 @@ public void okBothAvailableIndexes() {
final int finalI = i;
final SelectIterator result = select.parameter("value", i).vertices();
- result.forEachRemaining(r -> Assertions.assertTrue(r.getInteger("id") == finalI || r.getString("name").equals("Elon")));
+ result.forEachRemaining(r -> assertThat(r.getInteger("id") == finalI || r.getString("name").equals("Elon")).isTrue());
// CHECK 1 FOR ID = I + 100 FOR NAME = ELON (ALL OF THEM)
- Assertions.assertEquals(i < 100 ? 100L : 101L, result.getMetrics().get("evaluatedRecords"), "" + finalI);
- Assertions.assertEquals(2, result.getMetrics().get("usedIndexes"));
+ assertThat(result.getMetrics().get("evaluatedRecords")).as("" + finalI).isEqualTo(i < 100 ? 100L : 101L);
+ assertThat(result.getMetrics().get("usedIndexes")).isEqualTo(2);
}
}
}
@@ -110,11 +112,11 @@ public void okOneIndexUsed() {
final int finalI = i;
final SelectIterator result = select.parameter("value", i).vertices();
- result.forEachRemaining(r -> Assertions.assertEquals((int) r.getInteger("id"), finalI));
+ result.forEachRemaining(r -> assertThat((int) r.getInteger("id")).isEqualTo(finalI));
// CHECK 1 FOR ID = I + 100 FOR NAME = ELON (ALL OF THEM)
- Assertions.assertEquals(1L, result.getMetrics().get("evaluatedRecords"));
- Assertions.assertEquals(1, result.getMetrics().get("usedIndexes"));
+ assertThat(result.getMetrics().get("evaluatedRecords")).isEqualTo(1L);
+ assertThat(result.getMetrics().get("usedIndexes")).isEqualTo(1);
}
}
@@ -128,11 +130,11 @@ public void okOneIndexUsed() {
final int finalI = i;
final SelectIterator result = select.parameter("value", i).vertices();
- result.forEachRemaining(r -> Assertions.assertEquals((int) r.getInteger("id"), finalI));
+ result.forEachRemaining(r -> assertThat((int) r.getInteger("id")).isEqualTo(finalI));
// CHECK 1 FOR ID = I + 100 FOR NAME = ELON (ALL OF THEM)
- Assertions.assertEquals(1L, result.getMetrics().get("evaluatedRecords"));
- Assertions.assertEquals(1, result.getMetrics().get("usedIndexes"));
+ assertThat(result.getMetrics().get("evaluatedRecords")).isEqualTo(1L);
+ assertThat(result.getMetrics().get("usedIndexes")).isEqualTo(1);
}
}
}
@@ -150,8 +152,8 @@ public void okNoIndexUsed() {
result.toList();
// CHECK 1 FOR ID = I + 100 FOR NAME = ELON (ALL OF THEM)
- Assertions.assertEquals(110L, result.getMetrics().get("evaluatedRecords"));
- Assertions.assertEquals(0, result.getMetrics().get("usedIndexes"));
+ assertThat(result.getMetrics().get("evaluatedRecords")).isEqualTo(110L);
+ assertThat(result.getMetrics().get("usedIndexes")).isEqualTo(0);
}
}
@@ -166,8 +168,8 @@ public void okNoIndexUsed() {
result.toList();
// CHECK 1 FOR ID = I + 100 FOR NAME = ELON (ALL OF THEM)
- Assertions.assertEquals(110L, result.getMetrics().get("evaluatedRecords"));
- Assertions.assertEquals(0, result.getMetrics().get("usedIndexes"));
+ assertThat(result.getMetrics().get("evaluatedRecords")).isEqualTo(110L);
+ assertThat(result.getMetrics().get("usedIndexes")).isEqualTo(0);
}
}
@@ -183,13 +185,13 @@ public void okNoIndexUsed() {
final SelectIterator result = select.parameter("value", i).vertices();
final List list = result.toList();
- Assertions.assertEquals(1, list.size());
+ assertThat(list.size()).isEqualTo(1);
- list.forEach(r -> Assertions.assertEquals((int) r.getInteger("id"), finalI));
+ list.forEach(r -> assertThat((int) r.getInteger("id")).isEqualTo(finalI));
// CHECK 1 FOR ID = I + 100 FOR NAME = ELON (ALL OF THEM)
- Assertions.assertEquals(1L, result.getMetrics().get("evaluatedRecords"));
- Assertions.assertEquals(2, result.getMetrics().get("usedIndexes"));
+ assertThat(result.getMetrics().get("evaluatedRecords")).isEqualTo(1L);
+ assertThat(result.getMetrics().get("usedIndexes")).isEqualTo(2);
}
}
@@ -205,9 +207,9 @@ public void okRanges() {
final int finalI = i;
final SelectIterator result = select.parameter("value", i).vertices();
final List list = result.toList();
- Assertions.assertEquals(109 - i, list.size());
- list.forEach(r -> Assertions.assertTrue(r.getInteger("id") > finalI));
- Assertions.assertEquals(1, result.getMetrics().get("usedIndexes"));
+ assertThat(list.size()).isEqualTo(109 - i);
+ list.forEach(r -> assertThat(r.getInteger("id")).isGreaterThan(finalI));
+ assertThat(result.getMetrics().get("usedIndexes")).isEqualTo(1);
}
}
@@ -219,9 +221,9 @@ public void okRanges() {
final int finalI = i;
final SelectIterator result = select.parameter("value", i).vertices();
final List list = result.toList();
- Assertions.assertEquals(110 - i, list.size());
- list.forEach(r -> Assertions.assertTrue(r.getInteger("id") >= finalI));
- Assertions.assertEquals(1, result.getMetrics().get("usedIndexes"));
+ assertThat(list.size()).isEqualTo(110 - i);
+ list.forEach(r -> assertThat(r.getInteger("id")).isGreaterThanOrEqualTo(finalI));
+ assertThat(result.getMetrics().get("usedIndexes")).isEqualTo(1);
}
}
@@ -233,9 +235,9 @@ public void okRanges() {
final int finalI = i;
final SelectIterator result = select.parameter("value", i).vertices();
final List list = result.toList();
- Assertions.assertEquals(i, list.size());
- list.forEach(r -> Assertions.assertTrue(r.getInteger("id") < finalI));
- Assertions.assertEquals(1, result.getMetrics().get("usedIndexes"));
+ assertThat(list.size()).isEqualTo(i);
+ list.forEach(r -> assertThat(r.getInteger("id")).isLessThan(finalI));
+ assertThat(result.getMetrics().get("usedIndexes")).isEqualTo(1);
}
}
@@ -247,9 +249,9 @@ public void okRanges() {
final int finalI = i;
final SelectIterator result = select.parameter("value", i).vertices();
final List list = result.toList();
- Assertions.assertEquals(i + 1, list.size());
- list.forEach(r -> Assertions.assertTrue(r.getInteger("id") <= finalI));
- Assertions.assertEquals(1, result.getMetrics().get("usedIndexes"));
+ assertThat(list.size()).isEqualTo(i + 1);
+ list.forEach(r -> assertThat(r.getInteger("id")).isLessThanOrEqualTo(finalI));
+ assertThat(result.getMetrics().get("usedIndexes")).isEqualTo(1);
}
}
@@ -261,9 +263,9 @@ public void okRanges() {
final int finalI = i;
final SelectIterator result = select.parameter("value", i).vertices();
final List list = result.toList();
- Assertions.assertEquals(109, list.size());
- list.forEach(r -> Assertions.assertTrue(r.getInteger("id") != finalI));
- Assertions.assertEquals(0, result.getMetrics().get("usedIndexes"));
+ assertThat(list.size()).isEqualTo(109);
+ list.forEach(r -> assertThat(r.getInteger("id")).isNotEqualTo(finalI));
+ assertThat(result.getMetrics().get("usedIndexes")).isEqualTo(0);
}
}
}
diff --git a/engine/src/test/java/com/arcadedb/query/select/SelectOrderByIT.java b/engine/src/test/java/com/arcadedb/query/select/SelectOrderByIT.java
index c87f2c4018..618d9f79ef 100644
--- a/engine/src/test/java/com/arcadedb/query/select/SelectOrderByIT.java
+++ b/engine/src/test/java/com/arcadedb/query/select/SelectOrderByIT.java
@@ -23,9 +23,10 @@
import com.arcadedb.schema.Schema;
import com.arcadedb.schema.Type;
import com.arcadedb.schema.VertexType;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+
/**
* @author Luca Garulli (l.garulli@arcadedata.com)
*/
@@ -61,11 +62,11 @@ public void okOrderByNoIndex() {
while (result.hasNext()) {
final Integer id = result.next().getInteger("notIndexedId");
- Assertions.assertTrue(id > lastId);
+ assertThat(id > lastId).isTrue();
lastId = id;
}
- Assertions.assertEquals(0, result.getMetrics().get("usedIndexes"));
+ assertThat(result.getMetrics().get("usedIndexes")).isEqualTo(0);
}
// DESCENDING
@@ -76,11 +77,11 @@ public void okOrderByNoIndex() {
while (result.hasNext()) {
final Integer id = result.next().getInteger("notIndexedId");
- Assertions.assertTrue(id < lastId);
+ assertThat(id < lastId).isTrue();
lastId = id;
}
- Assertions.assertEquals(0, result.getMetrics().get("usedIndexes"));
+ assertThat(result.getMetrics().get("usedIndexes")).isEqualTo(0);
}
}
@@ -95,11 +96,11 @@ public void okOrderBy1Index() {
while (result.hasNext()) {
final Integer id = result.next().getInteger("id");
- Assertions.assertTrue(id > lastId);
+ assertThat(id > lastId).isTrue();
lastId = id;
}
- Assertions.assertEquals(1, result.getMetrics().get("usedIndexes"));
+ assertThat(result.getMetrics().get("usedIndexes")).isEqualTo(1);
}
// DESCENDING
@@ -110,11 +111,11 @@ public void okOrderBy1Index() {
while (result.hasNext()) {
final Integer id = result.next().getInteger("id");
- Assertions.assertTrue(id < lastId);
+ assertThat(id < lastId).isTrue();
lastId = id;
}
- Assertions.assertEquals(1, result.getMetrics().get("usedIndexes"));
+ assertThat(result.getMetrics().get("usedIndexes")).isEqualTo(1);
}
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/BatchTest.java b/engine/src/test/java/com/arcadedb/query/sql/BatchTest.java
index ef11c587ea..941a3b0984 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/BatchTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/BatchTest.java
@@ -22,25 +22,30 @@
import com.arcadedb.exception.CommandSQLParsingException;
import com.arcadedb.query.sql.executor.Result;
import com.arcadedb.query.sql.executor.ResultSet;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
public class BatchTest extends TestHelper {
@Test
public void testReturnArrayOnDeprecated() {
database.transaction(() -> {
final ResultSet rs = database.command("SQLSCRIPT", "let a = select 1 as result;let b = select 2 as result;return [$a,$b];");
- Assertions.assertTrue(rs.hasNext());
+ assertThat(rs.hasNext()).isTrue();
Result record = rs.next();
- Assertions.assertNotNull(record);
- Assertions.assertEquals("{\"value\":[{\"result\":1}]}", record.toJSON().toString());
+ assertThat(record).isNotNull();
+ assertThat(record.toJSON().toString()).isEqualTo("{\"value\":[{\"result\":1}]}");
record = rs.next();
- Assertions.assertEquals("{\"value\":[{\"result\":2}]}", record.toJSON().toString());
- Assertions.assertNotNull(record);
+ assertThat(record.toJSON().toString()).isEqualTo("{\"value\":[{\"result\":2}]}");
+ assertThat(record).isNotNull();
- Assertions.assertFalse(rs.hasNext());
+ assertThat(rs.hasNext()).isFalse();
});
}
@@ -49,16 +54,16 @@ public void testReturnArray() {
database.transaction(() -> {
final ResultSet rs = database.command("SQLScript", "let a = select 1 as result;let b = select 2 as result;return [$a,$b];");
- Assertions.assertTrue(rs.hasNext());
+ assertThat(rs.hasNext()).isTrue();
Result record = rs.next();
- Assertions.assertNotNull(record);
- Assertions.assertEquals("{\"value\":[{\"result\":1}]}", record.toJSON().toString());
+ assertThat(record).isNotNull();
+ assertThat(record.toJSON().toString()).isEqualTo("{\"value\":[{\"result\":1}]}");
record = rs.next();
- Assertions.assertEquals("{\"value\":[{\"result\":2}]}", record.toJSON().toString());
- Assertions.assertNotNull(record);
+ assertThat(record.toJSON().toString()).isEqualTo("{\"value\":[{\"result\":2}]}");
+ assertThat(record).isNotNull();
- Assertions.assertFalse(rs.hasNext());
+ assertThat(rs.hasNext()).isFalse();
});
}
@@ -79,7 +84,7 @@ public void testWhile() {
final ResultSet result = database.query("sql", "select from TestWhile order by id");
for (int i = 0; i < 10; i++) {
final Result record = result.next();
- Assertions.assertEquals(i, (int) record.getProperty("id"));
+ assertThat((int) record.getProperty("id")).isEqualTo(i);
}
}
@@ -103,9 +108,9 @@ public void testWhileWithReturn() {
final ResultSet result = database.query("sql", "select from TestWhileWithReturn order by id");
for (int i = 0; i < 5; i++) {
final Result record = result.next();
- Assertions.assertEquals(i, (int) record.getProperty("id"));
+ assertThat((int) record.getProperty("id")).isEqualTo(i);
}
- Assertions.assertFalse(result.hasNext());
+ assertThat(result.hasNext()).isFalse();
}
@Test
@@ -123,7 +128,7 @@ public void testForeach() {
final ResultSet result = database.query("sql", "select from TestForeach order by id");
for (int i = 1; i <= 3; i++) {
final Result record = result.next();
- Assertions.assertEquals(i, (int) record.getProperty("id"));
+ assertThat((int) record.getProperty("id")).isEqualTo(i);
}
}
@@ -145,9 +150,9 @@ public void testForeachWithReturn() {
final ResultSet result = database.query("sql", "select from TestForeachWithReturn order by id");
for (int i = 1; i <= 1; i++) {
final Result record = result.next();
- Assertions.assertEquals(i, (int) record.getProperty("id"));
+ assertThat((int) record.getProperty("id")).isEqualTo(i);
}
- Assertions.assertFalse(result.hasNext());
+ assertThat(result.hasNext()).isFalse();
}
/**
@@ -171,8 +176,8 @@ public void testLetUSeRightScope() {
+ "RETURN \"List is empty\";";
final ResultSet result = database.command("sqlscript", script);
- Assertions.assertTrue(result.hasNext());
- Assertions.assertEquals("List element detected", result.next().getProperty("value"));
+ assertThat(result.hasNext()).isTrue();
+ assertThat(result.next().getProperty("value")).isEqualTo("List element detected");
}
/**
@@ -191,8 +196,8 @@ public void testBreakInsideForeach() {
+ "RETURN $result;";
final ResultSet result = database.command("sqlscript", script);
- Assertions.assertTrue(result.hasNext());
- Assertions.assertEquals("Return statement 2", result.next().getProperty("value"));
+ assertThat(result.hasNext()).isTrue();
+ assertThat(result.next().getProperty("value")).isEqualTo("Return statement 2");
}
// Isue https://github.com/ArcadeData/arcadedb/issues/1673
@@ -222,8 +227,8 @@ public void testNestedBreak() {
+ "RETURN $counter;";
final ResultSet result = database.command("sqlscript", script);
- Assertions.assertTrue(result.hasNext());
- Assertions.assertEquals(7, (Integer) result.next().getProperty("value"));
+ assertThat(result.hasNext()).isTrue();
+ assertThat((Integer) result.next().getProperty("value")).isEqualTo(7);
}
@Test
@@ -243,22 +248,22 @@ public void testForeachResultSet() {
+ "RETURN $counter;";
final ResultSet result = database.command("sqlscript", script);
- Assertions.assertTrue(result.hasNext());
- Assertions.assertEquals(100, (Integer) result.next().getProperty("value"));
+ assertThat(result.hasNext()).isTrue();
+ assertThat((Integer) result.next().getProperty("value")).isEqualTo(100);
}
@Test
public void testUsingReservedVariableNames() {
try {
database.command("sqlscript", "FOREACH ($parent IN [1, 2, 3]){\nRETURN;\n}");
- Assertions.fail();
+ fail("");
} catch (CommandSQLParsingException e) {
// EXPECTED
}
try {
database.command("sqlscript", "LET parent = 33;");
- Assertions.fail();
+ fail("");
} catch (CommandSQLParsingException e) {
// EXPECTED
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/DDLTest.java b/engine/src/test/java/com/arcadedb/query/sql/DDLTest.java
index f009aa9613..76a8fc73bb 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/DDLTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/DDLTest.java
@@ -19,7 +19,7 @@
package com.arcadedb.query.sql;
import com.arcadedb.TestHelper;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.Test;
import java.util.stream.*;
@@ -62,17 +62,13 @@ void testGraphWithSql() {
database.transaction(() -> {
final Long persons = database.command("sql", "SELECT count(*) as persons FROM Person ").next().getProperty("persons");
-
- Assertions.assertEquals(numOfElements, persons);
-
+ assertThat(persons).isEqualTo(numOfElements);
final Long cars = database.command("sql", "SELECT count(*) as cars FROM Car").next().getProperty("cars");
- Assertions.assertEquals(numOfElements, cars);
-
+ assertThat(cars).isEqualTo(numOfElements);
final Long vs = database.command("sql", "SELECT count(*) as vs FROM V").next().getProperty("vs");
- Assertions.assertEquals(numOfElements * 2, vs);
-
+ assertThat(vs).isEqualTo(numOfElements * 2);
final Long edges = database.command("sql", "SELECT count(*) as edges FROM Drives").next().getProperty("edges");
});
diff --git a/engine/src/test/java/com/arcadedb/query/sql/OrderByTest.java b/engine/src/test/java/com/arcadedb/query/sql/OrderByTest.java
index a97af952b2..ea6dab579b 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/OrderByTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/OrderByTest.java
@@ -29,12 +29,15 @@
import com.arcadedb.schema.DocumentType;
import com.arcadedb.schema.Schema;
import com.arcadedb.schema.Type;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import java.time.*;
import java.time.format.*;
+import static org.assertj.core.api.Assertions.*;
+
/**
* From Issue https://github.com/ArcadeData/arcadedb/issues/839
*/
@@ -81,7 +84,7 @@ public void testLocalDateTimeOrderBy() {
stop = LocalDateTime.parse("20220320T002323", FILENAME_TIME_FORMAT);
Object[] parameters1 = { name, type, start, stop };
try (ResultSet resultSet = database.command("sql", sqlString, parameters1)) {
- Assertions.assertTrue(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isTrue();
result = resultSet.next();
} catch (Exception e) {
System.out.println(e.getMessage());
@@ -98,15 +101,17 @@ public void testLocalDateTimeOrderBy() {
try (ResultSet resultSet = database.query("sql", sqlString, parameters3)) {
- Assertions.assertTrue(resultSet.hasNext());
+ assertThat(resultSet.hasNext()).isTrue();
while (resultSet.hasNext()) {
result = resultSet.next();
start = result.getProperty("start");
- if (lastStart != null)
- Assertions.assertTrue(start.compareTo(lastStart) <= 0, "" + start + " is greater than " + lastStart);
+ if (lastStart != null) {
+ assertThat(start.compareTo(lastStart)).isLessThanOrEqualTo(0)
+ .withFailMessage("" + start + " is greater than " + lastStart);
+ }
lastStart = start;
}
@@ -116,15 +121,19 @@ public void testLocalDateTimeOrderBy() {
sqlString = "SELECT name, start, stop FROM Product WHERE type = ? AND start <= ? AND stop >= ? ORDER BY start ASC";
try (ResultSet resultSet = database.query("sql", sqlString, parameters3)) {
- Assertions.assertTrue(resultSet.hasNext());
+
+ assertThat(resultSet.hasNext()).isTrue();
while (resultSet.hasNext()) {
result = resultSet.next();
start = result.getProperty("start");
- if (lastStart != null)
- Assertions.assertTrue(start.compareTo(lastStart) >= 0, "" + start + " is smaller than " + lastStart);
+ if (lastStart != null) {
+
+ assertThat(start.compareTo(lastStart)).isGreaterThanOrEqualTo(0)
+ .withFailMessage("" + start + " is smaller than " + lastStart);
+ }
lastStart = start;
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/QueryAndIndexesTest.java b/engine/src/test/java/com/arcadedb/query/sql/QueryAndIndexesTest.java
index 500f04d5cf..ea05a696ee 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/QueryAndIndexesTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/QueryAndIndexesTest.java
@@ -24,12 +24,14 @@
import com.arcadedb.query.sql.executor.ResultSet;
import com.arcadedb.schema.Schema;
import com.arcadedb.schema.VertexType;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.Test;
import java.util.*;
import java.util.concurrent.atomic.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class QueryAndIndexesTest extends TestHelper {
private static final int TOT = 10000;
@@ -66,20 +68,20 @@ public void testEqualsFiltering() {
final AtomicInteger total = new AtomicInteger();
while (rs.hasNext()) {
final Result record = rs.next();
- Assertions.assertNotNull(record);
+ assertThat(record).isNotNull();
final Set prop = new HashSet<>();
prop.addAll(record.getPropertyNames());
- Assertions.assertEquals(3, record.getPropertyNames().size(), 9);
- Assertions.assertEquals(123, (int) record.getProperty("id"));
- Assertions.assertEquals("Jay", record.getProperty("name"));
- Assertions.assertEquals("Miner123", record.getProperty("surname"));
+ assertThat(record.getPropertyNames().size()).isEqualTo(3);
+ assertThat((int) record.getProperty("id")).isEqualTo(123);
+ assertThat(record.getProperty("name")).isEqualTo("Jay");
+ assertThat(record.getProperty("surname")).isEqualTo("Miner123");
total.incrementAndGet();
}
- Assertions.assertEquals(1, total.get());
+ assertThat(total.get()).isEqualTo(1);
});
}
@@ -95,17 +97,17 @@ public void testPartialMatchingFiltering() {
final AtomicInteger total = new AtomicInteger();
while (rs.hasNext()) {
final Result record = rs.next();
- Assertions.assertNotNull(record);
+ assertThat(record).isNotNull();
final Set prop = new HashSet<>();
prop.addAll(record.getPropertyNames());
- Assertions.assertEquals("Jay", record.getProperty("name"));
+ assertThat(record.getProperty("name")).isEqualTo("Jay");
total.incrementAndGet();
}
- Assertions.assertEquals(TOT, total.get());
+ assertThat(total.get()).isEqualTo(TOT);
});
}
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/QueryTest.java b/engine/src/test/java/com/arcadedb/query/sql/QueryTest.java
index c97fbf66a9..dc609fb607 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/QueryTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/QueryTest.java
@@ -32,6 +32,9 @@
import java.util.concurrent.atomic.*;
import java.util.logging.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Fail.fail;
+
public class QueryTest extends TestHelper {
private static final int TOT = 10000;
@@ -62,21 +65,21 @@ public void testScan() {
final AtomicInteger total = new AtomicInteger();
while (rs.hasNext()) {
final Result record = rs.next();
- Assertions.assertNotNull(record);
+ assertThat(record).isNotNull();
final Set prop = new HashSet<>();
prop.addAll(record.getPropertyNames());
- Assertions.assertEquals(3, record.getPropertyNames().size(), 9);
- Assertions.assertTrue(prop.contains("id"));
- Assertions.assertTrue(prop.contains("name"));
- Assertions.assertTrue(prop.contains("surname"));
+ assertThat(record.getPropertyNames().size()).isEqualTo(3);
+ assertThat(prop).contains("id", "name", "surname");
total.incrementAndGet();
}
- Assertions.assertEquals(TOT, total.get());
- });
+ assertThat(total.get()).isEqualTo(TOT);
+
+ }
+ );
}
@Test
@@ -91,17 +94,16 @@ public void testEqualsFiltering() {
final AtomicInteger total = new AtomicInteger();
while (rs.hasNext()) {
final Result record = rs.next();
- Assertions.assertNotNull(record);
-
- Assertions.assertEquals(3, record.getPropertyNames().size(), 9);
- Assertions.assertEquals(123, (int) record.getProperty("id"));
- Assertions.assertEquals("Jay", record.getProperty("name"));
- Assertions.assertEquals("Miner123", record.getProperty("surname"));
+ assertThat(record).isNotNull();
+ assertThat(record.getPropertyNames().size()).isEqualTo(3);
+ assertThat((int) record.getProperty("id")).isEqualTo(123);
+ assertThat(record.getProperty("name")).isEqualTo("Jay");
+ assertThat(record.getProperty("surname")).isEqualTo("Miner123");
total.incrementAndGet();
}
- Assertions.assertEquals(1, total.get());
+ assertThat(total.get()).isEqualTo(1);
});
}
@@ -116,13 +118,12 @@ public void testNullSafeEqualsFiltering() {
final AtomicInteger total = new AtomicInteger();
while (rs.hasNext()) {
final Result record = rs.next();
- Assertions.assertNotNull(record);
-
- Assertions.assertEquals(3, record.getPropertyNames().size(), 9);
+ assertThat(record).isNotNull();
+ assertThat(record.getPropertyNames().size()).isEqualTo(3);
total.incrementAndGet();
}
- Assertions.assertEquals(TOT, total.get());
+ assertThat(total.get()).isEqualTo(TOT);
});
}
@@ -138,25 +139,22 @@ public void testCachedStatementAndExecutionPlan() {
AtomicInteger total = new AtomicInteger();
while (rs.hasNext()) {
final Result record = rs.next();
- Assertions.assertNotNull(record);
-
- Assertions.assertEquals(3, record.getPropertyNames().size(), 9);
- Assertions.assertEquals(123, (int) record.getProperty("id"));
- Assertions.assertEquals("Jay", record.getProperty("name"));
- Assertions.assertEquals("Miner123", record.getProperty("surname"));
+ assertThat(record).isNotNull();
+ assertThat(record.getPropertyNames().size()).isEqualTo(3);
+ assertThat((int) record.getProperty("id")).isEqualTo(123);
+ assertThat(record.getProperty("name")).isEqualTo("Jay");
+ assertThat(record.getProperty("surname")).isEqualTo("Miner123");
total.incrementAndGet();
}
- Assertions.assertEquals(1, total.get());
+ assertThat(total.get()).isEqualTo(1);
// CHECK STATEMENT CACHE
- Assertions.assertTrue(
- ((DatabaseInternal) database).getStatementCache().contains("SELECT FROM V WHERE name = :name AND surname = :surname"));
+ assertThat(((DatabaseInternal) database).getStatementCache().contains("SELECT FROM V WHERE name = :name AND surname = :surname")).isTrue();
// CHECK EXECUTION PLAN CACHE
- Assertions.assertTrue(((DatabaseInternal) database).getExecutionPlanCache()
- .contains("SELECT FROM V WHERE name = :name AND surname = :surname"));
+ assertThat(((DatabaseInternal) database).getExecutionPlanCache().contains("SELECT FROM V WHERE name = :name AND surname = :surname")).isTrue();
// EXECUTE THE 2ND TIME
rs = database.command("SQL", "SELECT FROM V WHERE name = :name AND surname = :surname", params);
@@ -164,17 +162,17 @@ public void testCachedStatementAndExecutionPlan() {
total = new AtomicInteger();
while (rs.hasNext()) {
final Result record = rs.next();
- Assertions.assertNotNull(record);
-
- Assertions.assertEquals(3, record.getPropertyNames().size(), 9);
- Assertions.assertEquals(123, (int) record.getProperty("id"));
- Assertions.assertEquals("Jay", record.getProperty("name"));
- Assertions.assertEquals("Miner123", record.getProperty("surname"));
+ assertThat(record).isNotNull();
+assertThat(record).isNotNull();
+assertThat(record.getPropertyNames().size()).isEqualTo(3);
+assertThat((int) record.getProperty("id")).isEqualTo(123);
+assertThat(record.getProperty("name")).isEqualTo("Jay");
+assertThat(record.getProperty("surname")).isEqualTo("Miner123");
total.incrementAndGet();
}
- Assertions.assertEquals(1, total.get());
+ assertThat(total.get()).isEqualTo(1);
});
}
@@ -188,11 +186,11 @@ public void testMajorFiltering() {
final AtomicInteger total = new AtomicInteger();
while (rs.hasNext()) {
final Result record = rs.next();
- Assertions.assertNotNull(record);
- Assertions.assertTrue((int) record.getProperty("id") > TOT - 11);
+ assertThat(record).isNotNull();
+ assertThat(record.getProperty("id") > TOT - 11).isTrue();
total.incrementAndGet();
}
- Assertions.assertEquals(10, total.get());
+ assertThat(total.get()).isEqualTo(10);
});
}
@@ -206,11 +204,12 @@ public void testMajorEqualsFiltering() {
final AtomicInteger total = new AtomicInteger();
while (rs.hasNext()) {
final Result record = rs.next();
- Assertions.assertNotNull(record);
- Assertions.assertTrue((int) record.getProperty("id") >= TOT - 11);
+ assertThat(record).isNotNull();
+ assertThat(record.getProperty("id") >= TOT - 11).isTrue();
+
total.incrementAndGet();
}
- Assertions.assertEquals(11, total.get());
+ assertThat(total.get()).isEqualTo(11);
});
}
@@ -224,11 +223,11 @@ public void testMinorFiltering() {
final AtomicInteger total = new AtomicInteger();
while (rs.hasNext()) {
final Result record = rs.next();
- Assertions.assertNotNull(record);
- Assertions.assertTrue((int) record.getProperty("id") < 10);
+ assertThat(record).isNotNull();
+ assertThat( record.getProperty("id") < 10).isTrue();
total.incrementAndGet();
}
- Assertions.assertEquals(10, total.get());
+ assertThat(total.get()).isEqualTo(10);
});
}
@@ -242,11 +241,11 @@ public void testMinorEqualsFiltering() {
final AtomicInteger total = new AtomicInteger();
while (rs.hasNext()) {
final Result record = rs.next();
- Assertions.assertNotNull(record);
- Assertions.assertTrue((int) record.getProperty("id") <= 10);
+ assertThat(record).isNotNull();
+ assertThat(record.getProperty("id") <= 10).isTrue();
total.incrementAndGet();
}
- Assertions.assertEquals(11, total.get());
+ assertThat(total.get()).isEqualTo(11);
});
}
@@ -260,11 +259,11 @@ public void testNotFiltering() {
final AtomicInteger total = new AtomicInteger();
while (rs.hasNext()) {
final Result record = rs.next();
- Assertions.assertNotNull(record);
- Assertions.assertTrue((int) record.getProperty("id") <= 10);
+ assertThat(record).isNotNull();
+ assertThat(record.getProperty("id") <= 10).isTrue();
total.incrementAndGet();
}
- Assertions.assertEquals(11, total.get());
+ assertThat(total.get()).isEqualTo(11);
});
}
@@ -276,11 +275,11 @@ public void testCreateVertexType() {
database.command("SQL", "CREATE VERTEX Foo SET name = 'bar'");
final ResultSet rs = database.query("SQL", "SELECT FROM Foo");
- Assertions.assertTrue(rs.hasNext());
+ assertThat(rs.hasNext()).isTrue();
rs.next();
- Assertions.assertTrue(rs.hasNext());
+ assertThat(rs.hasNext()).isTrue();
rs.next();
- Assertions.assertFalse(rs.hasNext());
+ assertThat(rs.hasNext()).isFalse();
rs.close();
});
@@ -297,9 +296,9 @@ public void testCreateEdge() {
"CREATE EDGE TheEdge FROM (SELECT FROM Foo WHERE name ='foo') TO (SELECT FROM Foo WHERE name ='bar')");
final ResultSet rs = database.query("SQL", "SELECT FROM TheEdge");
- Assertions.assertTrue(rs.hasNext());
+ assertThat(rs.hasNext()).isTrue();
rs.next();
- Assertions.assertFalse(rs.hasNext());
+ assertThat(rs.hasNext()).isFalse();
rs.close();
});
@@ -319,18 +318,18 @@ public void testQueryEdge() {
+ " WHERE name ='bar')");
ResultSet rs = database.query("SQL", "SELECT FROM " + edgeClass);
- Assertions.assertTrue(rs.hasNext());
+ assertThat(rs.hasNext()).isTrue();
rs.next();
- Assertions.assertFalse(rs.hasNext());
+ assertThat(rs.hasNext()).isFalse();
rs.close();
rs = database.query("SQL", "SELECT out()[0].name as name from " + vertexClass + " where name = 'foo'");
- Assertions.assertTrue(rs.hasNext());
+ assertThat(rs.hasNext()).isTrue();
final Result item = rs.next();
final String name = item.getProperty("name");
- Assertions.assertTrue(name.contains("bar"));
- Assertions.assertFalse(rs.hasNext());
+ assertThat(name.contains("bar")).isTrue();
+ assertThat(rs.hasNext()).isFalse();
rs.close();
});
@@ -340,10 +339,10 @@ public void testQueryEdge() {
public void testMethod() {
database.transaction(() -> {
final ResultSet rs = database.query("SQL", "SELECT 'bar'.prefix('foo') as name");
- Assertions.assertTrue(rs.hasNext());
- Assertions.assertEquals("foobar", rs.next().getProperty("name"));
+ assertThat(rs.hasNext()).isTrue();
+ assertThat(rs.next().getProperty("name")).isEqualTo("foobar");
- Assertions.assertFalse(rs.hasNext());
+ assertThat(rs.hasNext()).isFalse();
rs.close();
});
@@ -363,17 +362,17 @@ public void testMatch() {
+ " WHERE name ='bar')");
ResultSet rs = database.query("SQL", "SELECT FROM " + edgeClass);
- Assertions.assertTrue(rs.hasNext());
+ assertThat(rs.hasNext()).isTrue();
rs.next();
- Assertions.assertFalse(rs.hasNext());
+ assertThat(rs.hasNext()).isFalse();
rs.close();
rs = database.query("SQL", "MATCH {type:" + vertexClass + ", as:a} -" + edgeClass + "->{} RETURN $patterns");
rs.getExecutionPlan().get().prettyPrint(0, 2);
- Assertions.assertTrue(rs.hasNext());
+ assertThat(rs.hasNext()).isTrue();
final Result item = rs.next();
- Assertions.assertFalse(rs.hasNext());
+ assertThat(rs.hasNext()).isFalse();
rs.close();
});
@@ -393,17 +392,17 @@ public void testAnonMatch() {
+ " WHERE name ='bar')");
ResultSet rs = database.query("SQL", "SELECT FROM " + edgeClass);
- Assertions.assertTrue(rs.hasNext());
+ assertThat(rs.hasNext()).isTrue();
rs.next();
- Assertions.assertFalse(rs.hasNext());
+ assertThat(rs.hasNext()).isFalse();
rs.close();
rs = database.query("SQL", "MATCH {type:" + vertexClass + ", as:a} --> {} RETURN $patterns");
rs.getExecutionPlan().get().prettyPrint(0, 2);
- Assertions.assertTrue(rs.hasNext());
+ assertThat(rs.hasNext()).isTrue();
final Result item = rs.next();
- Assertions.assertFalse(rs.hasNext());
+ assertThat(rs.hasNext()).isFalse();
rs.close();
});
@@ -413,19 +412,19 @@ public void testAnonMatch() {
public void testLike() {
database.transaction(() -> {
ResultSet rs = database.command("SQL", "SELECT FROM V WHERE surname LIKE '%in%' LIMIT 1");
- Assertions.assertTrue(rs.hasNext());
+ assertThat(rs.hasNext()).isTrue();
rs.next();
- Assertions.assertFalse(rs.hasNext());
+ assertThat(rs.hasNext()).isFalse();
rs.close();
rs = database.command("SQL", "SELECT FROM V WHERE surname LIKE 'Mi?er%' LIMIT 1");
- Assertions.assertTrue(rs.hasNext());
+ assertThat(rs.hasNext()).isTrue();
rs.next();
- Assertions.assertFalse(rs.hasNext());
+ assertThat(rs.hasNext()).isFalse();
rs.close();
rs = database.command("SQL", "SELECT FROM V WHERE surname LIKE 'baz' LIMIT 1");
- Assertions.assertFalse(rs.hasNext());
+ assertThat(rs.hasNext()).isFalse();
rs.close();
});
@@ -439,20 +438,20 @@ public void testLikeEncoding() {
database.command("SQL", "insert into V set age = '100%'");
ResultSet rs = database.command("SQL", "SELECT FROM V WHERE age LIKE '10\\%'");
- Assertions.assertTrue(rs.hasNext());
+ assertThat(rs.hasNext()).isTrue();
Result result = rs.next();
- Assertions.assertEquals("10%", result.getProperty("age"));
- Assertions.assertFalse(rs.hasNext());
+ assertThat(result.getProperty("age")).isEqualTo("10%");
+ assertThat(rs.hasNext()).isFalse();
rs.close();
rs = database.command("SQL", "SELECT FROM V WHERE age LIKE \"10%\" ORDER BY age");
- Assertions.assertTrue(rs.hasNext());
+ assertThat(rs.hasNext()).isTrue();
result = rs.next();
- Assertions.assertEquals("10%", result.getProperty("age"));
- Assertions.assertTrue(rs.hasNext());
+ assertThat(result.getProperty("age")).isEqualTo("10%");
+ assertThat(rs.hasNext()).isTrue();
result = rs.next();
- Assertions.assertEquals("100%", result.getProperty("age"));
- Assertions.assertFalse(rs.hasNext());
+ assertThat(result.getProperty("age")).isEqualTo("100%");
+ assertThat(rs.hasNext()).isFalse();
rs.close();
});
}
@@ -475,7 +474,7 @@ public void testTimeout() {
final Result record = rs.next();
LogManager.instance().log(this, Level.INFO, "Found record %s", null, record);
}
- Assertions.fail("Timeout should be triggered");
+ fail("Timeout should be triggered");
} catch (final TimeoutException e) {
// OK
}
@@ -493,19 +492,19 @@ public void testOrderByRID() {
final AtomicInteger total = new AtomicInteger();
while (rs.hasNext()) {
final Result record = rs.next();
- Assertions.assertNotNull(record);
+ assertThat(record).isNotNull();
final Set prop = new HashSet<>();
prop.addAll(record.getPropertyNames());
- Assertions.assertEquals(2, record.getPropertyNames().size());
- Assertions.assertTrue(prop.contains("@rid"));
- Assertions.assertTrue(prop.contains("name"));
+ assertThat(record.getPropertyNames()).hasSize(2);
+ assertThat(prop.contains("@rid")).isTrue();
+ assertThat(prop.contains("name")).isTrue();
total.incrementAndGet();
}
- Assertions.assertEquals(2, total.get());
+ assertThat(total.get()).isEqualTo(2);
});
}
@@ -522,7 +521,7 @@ public void testFlattenWhereCondition() {
query += ")";
try (ResultSet set = database.query("sql", query)) {
- Assertions.assertEquals(set.stream().count(), 0);
+ assertThat(set.stream().count()).isEqualTo(0);
}
});
}
@@ -530,11 +529,11 @@ public void testFlattenWhereCondition() {
@Test
public void testCollectionsInProjections() {
try (ResultSet set = database.query("sql", "SELECT [\"a\",\"b\",\"c\"] as coll")) {
- Collection coll = set.nextIfAvailable().getProperty("coll");
- Assertions.assertEquals(3, coll.size());
- Assertions.assertTrue(coll.contains("a"));
- Assertions.assertTrue(coll.contains("b"));
- Assertions.assertTrue(coll.contains("c"));
+ Collection coll = set.nextIfAvailable().getProperty("coll");
+ assertThat(coll.size()).isEqualTo(3);
+ assertThat(coll.contains("a")).isTrue();
+ assertThat(coll.contains("b")).isTrue();
+ assertThat(coll.contains("c")).isTrue();
}
}
@@ -542,7 +541,7 @@ public void testCollectionsInProjections() {
public void testCollectionsInProjectionsContains() {
try (ResultSet set = database.query("sql", "SELECT ([\"a\",\"b\",\"c\"] CONTAINS (@this ILIKE \"C\")) as coll")) {
final Object coll = set.nextIfAvailable().getProperty("coll");
- Assertions.assertTrue((Boolean) coll);
+ assertThat((Boolean) coll).isTrue();
}
}
@@ -551,7 +550,7 @@ public void testCollectionsOfObjectsInProjectionsContains() {
try (ResultSet set = database.query("sql",
"SELECT ([{\"x\":\"a\"},{\"x\":\"b\"},{\"x\":\"c\"}] CONTAINS (x ILIKE \"C\")) as coll")) {
final Object coll = set.nextIfAvailable().getProperty("coll");
- Assertions.assertTrue((Boolean) coll);
+ assertThat((Boolean) coll).isTrue();
}
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/SQLDeleteEdgeTest.java b/engine/src/test/java/com/arcadedb/query/sql/SQLDeleteEdgeTest.java
index 6b8fcfef4d..4d0589cd22 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/SQLDeleteEdgeTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/SQLDeleteEdgeTest.java
@@ -5,11 +5,14 @@
import com.arcadedb.database.Identifiable;
import com.arcadedb.exception.CommandExecutionException;
import com.arcadedb.utility.CollectionUtils;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.Test;
import java.util.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
public class SQLDeleteEdgeTest extends TestHelper {
@Test
public void testDeleteFromTo() {
@@ -27,12 +30,12 @@ public void testDeleteFromTo() {
database.command("sql", "CREATE EDGE testFromToTwoE from " + result.get(1).getIdentity() + " to " + result.get(0).getIdentity());
List resultTwo = CollectionUtils.resultsetToListOfDocuments(database.query("sql", "select expand(outE()) from " + result.get(1).getIdentity()));
- Assertions.assertEquals(resultTwo.size(), 2);
+ assertThat(resultTwo.size()).isEqualTo(2);
database.command("sql", "DELETE EDGE testFromToTwoE from " + result.get(1).getIdentity() + " to" + result.get(0).getIdentity());
resultTwo = CollectionUtils.resultsetToListOfDocuments(database.query("sql", "select expand(outE()) from " + result.get(1).getIdentity()));
- Assertions.assertEquals(resultTwo.size(), 1);
+ assertThat(resultTwo.size()).isEqualTo(1);
database.command("sql", "DELETE FROM testFromToOneE unsafe");
database.command("sql", "DELETE FROM testFromToTwoE unsafe");
@@ -56,12 +59,12 @@ public void testDeleteFrom() {
database.command("sql", "CREATE EDGE testFromTwoE from " + result.get(1).getIdentity() + " to " + result.get(0).getIdentity());
List resultTwo = CollectionUtils.resultsetToListOfDocuments(database.query("sql", "select expand(outE()) from " + result.get(1).getIdentity()));
- Assertions.assertEquals(2, resultTwo.size());
+ assertThat(resultTwo.size()).isEqualTo(2);
database.command("sql", "DELETE EDGE testFromTwoE from " + result.get(1).getIdentity());
resultTwo = CollectionUtils.resultsetToListOfDocuments(database.query("sql", "select expand(outE()) from " + result.get(1).getIdentity()));
- Assertions.assertEquals(1, resultTwo.size());
+ assertThat(resultTwo.size()).isEqualTo(1);
database.command("sql", "DELETE FROM testFromOneE unsafe");
database.command("sql", "DELETE FROM testFromTwoE unsafe");
@@ -85,12 +88,12 @@ public void testDeleteTo() {
database.command("sql", "CREATE EDGE testToTwoE from " + result.get(1).getIdentity() + " to " + result.get(0).getIdentity());
List resultTwo = CollectionUtils.resultsetToListOfDocuments(database.query("sql", "select expand(outE()) from " + result.get(1).getIdentity()));
- Assertions.assertEquals(resultTwo.size(), 2);
+ assertThat(resultTwo.size()).isEqualTo(2);
database.command("sql", "DELETE EDGE testToTwoE to " + result.get(0).getIdentity());
resultTwo = CollectionUtils.resultsetToListOfDocuments(database.query("sql", "select expand(outE()) from " + result.get(1).getIdentity()));
- Assertions.assertEquals(resultTwo.size(), 1);
+ assertThat(resultTwo.size()).isEqualTo(1);
database.command("sql", "DELETE FROM testToOneE unsafe");
database.command("sql", "DELETE FROM testToTwoE unsafe");
@@ -112,30 +115,30 @@ public void testDropTypeVandEwithUnsafe() {
database.transaction(() -> {
try {
database.command("sql", "DROP TYPE SuperV");
- Assertions.assertTrue(false);
+ fail("Expected CommandExecutionException");
} catch (final CommandExecutionException e) {
- Assertions.assertTrue(true);
+ assertThat(true).isTrue();
}
try {
database.command("sql", "DROP TYPE SuperE");
- Assertions.assertTrue(false);
+ fail("Expected CommandExecutionException");
} catch (final CommandExecutionException e) {
- Assertions.assertTrue(true);
+ assertThat(true).isTrue();
}
try {
database.command("sql", "DROP TYPE SuperV unsafe");
- Assertions.assertTrue(true);
+ assertThat(true).isTrue();
} catch (final CommandExecutionException e) {
- Assertions.assertTrue(false);
+ fail("Unexpected CommandExecutionException");
}
try {
database.command("sql", "DROP TYPE SuperE UNSAFE");
- Assertions.assertTrue(true);
+ assertThat(true).isTrue();
} catch (final CommandExecutionException e) {
- Assertions.assertTrue(false);
+ fail("Unexpected CommandExecutionException");
}
});
}
@@ -152,32 +155,32 @@ public void testDropTypeVandEwithDeleteElements() {
try {
database.command("sql", "DROP TYPE SuperV");
- Assertions.fail();
+ fail("Expected CommandExecutionException");
} catch (final CommandExecutionException e) {
- Assertions.assertTrue(true);
+ assertThat(true).isTrue();
}
try {
database.command("sql", "DROP TYPE SuperE");
- Assertions.fail();
+ fail("Expected CommandExecutionException");
} catch (final CommandExecutionException e) {
- Assertions.assertTrue(true);
+ assertThat(true).isTrue();
}
final long deleted = database.command("sql", "DELETE FROM SuperV").nextIfAvailable().getProperty("count", 0);
try {
database.command("sql", "DROP TYPE SuperV");
- Assertions.assertTrue(true);
+ assertThat(true).isTrue();
} catch (final CommandExecutionException e) {
- Assertions.assertTrue(false);
+ fail("Unexpected CommandExecutionException");
}
try {
database.command("sql", "DROP TYPE SuperE");
- Assertions.assertTrue(true);
+ assertThat(true).isTrue();
} catch (final CommandExecutionException e) {
- Assertions.assertTrue(false);
+ fail("Unexpected CommandExecutionException");
}
});
}
@@ -196,13 +199,13 @@ public void testFromInString() {
database.command("sql", "create edge FromInStringE from " + v1.getIdentity() + " to " + v3.getIdentity());
List result = CollectionUtils.resultsetToListOfDocuments(database.query("sql", "SELECT expand(out()[name = ' FROM ']) FROM FromInStringV"));
- Assertions.assertEquals(result.size(), 1);
+ assertThat(result.size()).isEqualTo(1);
result = CollectionUtils.resultsetToListOfDocuments(database.query("sql", "SELECT expand(in()[name = ' from ']) FROM FromInStringV"));
- Assertions.assertEquals(result.size(), 2);
+ assertThat(result.size()).isEqualTo(2);
result = CollectionUtils.resultsetToListOfDocuments(database.query("sql", "SELECT expand(out()[name = ' TO ']) FROM FromInStringV"));
- Assertions.assertEquals(result.size(), 1);
+ assertThat(result.size()).isEqualTo(1);
});
}
@@ -210,13 +213,13 @@ public void testFromInString() {
public void testDeleteVertexWithReturn() {
database.transaction(() -> {
database.command("sql", "create vertex type V");
- final Identifiable v1 = CollectionUtils.getFirstResultAsDocument(database.command("sql", "create vertex V set returning = true"));
+ final Document v1 = CollectionUtils.getFirstResultAsDocument(database.command("sql", "create vertex V set returning = true"));
final List v2s = CollectionUtils.resultsetToListOfDocuments(
- database.command("sql", "delete vertex from V return before where returning = true"));
+ database.command("sql", "delete vertex from V return before where returning = true"));
- Assertions.assertEquals(v2s.size(), 1);
- Assertions.assertTrue(v2s.contains(v1));
+ assertThat(v2s.size()).isEqualTo(1);
+ assertThat(v2s).contains(v1);
});
}
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/SQLScriptTest.java b/engine/src/test/java/com/arcadedb/query/sql/SQLScriptTest.java
index 06e7534fd6..1c304d8ff7 100755
--- a/engine/src/test/java/com/arcadedb/query/sql/SQLScriptTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/SQLScriptTest.java
@@ -7,11 +7,13 @@
import com.arcadedb.serializer.json.JSONArray;
import com.arcadedb.serializer.json.JSONObject;
import com.arcadedb.utility.CollectionUtils;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.Test;
import java.util.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class SQLScriptTest extends TestHelper {
public void beginTest() {
database.transaction(() -> {
@@ -32,7 +34,7 @@ public void testQueryOnDeprecated() {
script.append("return $a;\n");
ResultSet qResult = database.command("sqlscript", script.toString());
- Assertions.assertEquals(3, CollectionUtils.countEntries(qResult));
+ assertThat(CollectionUtils.countEntries(qResult)).isEqualTo(3);
}
@Test
@@ -44,7 +46,7 @@ public void testQuery() {
script.append("return $a;\n");
ResultSet qResult = database.command("SQLScript", script.toString());
- Assertions.assertEquals(3, CollectionUtils.countEntries(qResult));
+ assertThat(CollectionUtils.countEntries(qResult)).isEqualTo(3);
}
@Test
@@ -56,7 +58,7 @@ public void testTx() {
script.append("return $a;\n");
Document qResult = database.command("SQLScript", script.toString()).next().toElement();
- Assertions.assertNotNull(qResult);
+ assertThat(qResult).isNotNull();
}
@Test
@@ -66,8 +68,7 @@ public void testReturnExpanded() {
script.append("let $a = insert into V set test = 'sql script test';\n");
script.append("return $a.asJSON();\n");
String qResult = database.command("SQLScript", script.toString()).next().getProperty("value").toString();
- Assertions.assertNotNull(qResult);
-
+ assertThat(qResult).isNotNull();
// VALIDATE JSON
new JSONObject(qResult);
@@ -76,10 +77,10 @@ public void testReturnExpanded() {
script.append("return $a.asJSON();\n");
String result = database.command("SQLScript", script.toString()).next().getProperty("value").toString();
- Assertions.assertNotNull(result);
+
+ assertThat(result).isNotNull();
result = result.trim();
- Assertions.assertTrue(result.startsWith("{"));
- Assertions.assertTrue(result.endsWith("}"));
+ assertThat(result).startsWith("{").endsWith("}");
// VALIDATE JSON
new JSONObject(result);
@@ -95,7 +96,7 @@ public void testSleep() {
script.append("sleep 500");
database.command("SQLScript", script.toString());
- Assertions.assertTrue(System.currentTimeMillis() - begin >= 500);
+ assertThat(System.currentTimeMillis() - begin >= 500).isTrue();
}
//@Test
@@ -128,10 +129,10 @@ public void testReturnObject() {
script.append("return [{ a: 'b' }]");
ResultSet result = database.command("SQLScript", script.toString());
- Assertions.assertNotNull(result);
+ assertThat(Optional.ofNullable(result)).isNotNull();
- Assertions.assertEquals("b", result.next().getProperty("a"));
- Assertions.assertFalse(result.hasNext());
+ assertThat(result.next().getProperty("a")).isEqualTo("b");
+ assertThat(result.hasNext()).isFalse();
}
@Test
@@ -145,10 +146,9 @@ public void testIncrementAndLet() {
script.append("UPDATE TestCounter SET weight += $counter[0].count RETURN AfTER @this;\n");
ResultSet qResult = database.command("SQLScript", script.toString());
- Assertions.assertTrue(qResult.hasNext());
- final Result result = qResult.next();
-
- Assertions.assertEquals(4L, (Long) result.getProperty("weight"));
+ assertThat(qResult.hasNext()).isTrue();
+ Result result = qResult.next();
+ assertThat(result.getProperty("weight")).isEqualTo(4L);
});
}
@@ -163,8 +163,8 @@ public void testIf1() {
script.append("return 'FAIL';\n");
ResultSet qResult = database.command("SQLScript", script.toString());
- Assertions.assertNotNull(qResult);
- Assertions.assertEquals(qResult.next().getProperty("value"), "OK");
+ assertThat(Optional.ofNullable(qResult)).isNotNull();
+ assertThat(qResult.next().getProperty("value")).isEqualTo("OK");
}
@Test
@@ -178,8 +178,8 @@ public void testIf2() {
script.append("return 'FAIL';\n");
ResultSet qResult = database.command("SQLScript", script.toString());
- Assertions.assertNotNull(qResult);
- Assertions.assertEquals(qResult.next().getProperty("value"), "OK");
+ assertThat(Optional.ofNullable(qResult)).isNotNull();
+ assertThat(qResult.next().getProperty("value")).isEqualTo("OK");
}
@Test
@@ -187,8 +187,8 @@ public void testIf3() {
StringBuilder script = new StringBuilder();
script.append("let $a = select 1 as one; if($a[0].one = 1){return 'OK';}return 'FAIL';");
ResultSet qResult = database.command("SQLScript", script.toString());
- Assertions.assertNotNull(qResult);
- Assertions.assertEquals(qResult.next().getProperty("value"), "OK");
+ assertThat(Optional.ofNullable(qResult)).isNotNull();
+ assertThat(qResult.next().getProperty("value")).isEqualTo("OK");
}
@Test
@@ -205,8 +205,8 @@ public void testNestedIf2() {
script.append("return 'FAIL';\n");
ResultSet qResult = database.command("SQLScript", script.toString());
- Assertions.assertNotNull(qResult);
- Assertions.assertEquals(qResult.next().getProperty("value"), "OK");
+ assertThat(Optional.ofNullable(qResult)).isNotNull();
+ assertThat(qResult.next().getProperty("value")).isEqualTo("OK");
}
@Test
@@ -223,8 +223,8 @@ public void testNestedIf3() {
script.append("return 'OK';\n");
ResultSet qResult = database.command("SQLScript", script.toString());
- Assertions.assertNotNull(qResult);
- Assertions.assertEquals(qResult.next().getProperty("value"), "OK");
+ assertThat(Optional.ofNullable(qResult)).isNotNull();
+ assertThat(qResult.next().getProperty("value")).isEqualTo("OK");
}
@Test
@@ -238,8 +238,8 @@ public void testIfRealQuery() {
script.append("return 'FAIL';\n");
ResultSet qResult = database.command("SQLScript", script.toString());
- Assertions.assertNotNull(qResult);
- Assertions.assertEquals(3, CollectionUtils.countEntries(qResult));
+ assertThat(Optional.ofNullable(qResult)).isNotNull();
+ assertThat(CollectionUtils.countEntries(qResult)).isEqualTo(3);
}
@Test
@@ -254,8 +254,8 @@ public void testIfMultipleStatements() {
script.append("return 'FAIL';\n");
ResultSet qResult = database.command("SQLScript", script.toString());
- Assertions.assertNotNull(qResult);
- Assertions.assertEquals(qResult.next().getProperty("value"), "OK");
+ assertThat(Optional.ofNullable(qResult)).isNotNull();
+ assertThat(qResult.next().getProperty("value")).isEqualTo("OK");
}
@Test
@@ -276,8 +276,10 @@ public void testQuotedRegex() {
ResultSet result = database.query("sql", "SELECT FROM QuotedRegex2");
Document doc = result.next().toElement();
- Assertions.assertFalse(result.hasNext());
- Assertions.assertEquals("'';", doc.get("regexp"));
+
+ assertThat(result.hasNext()).isFalse();
+ assertThat(doc.get("regexp")).isEqualTo("'';");
+
});
}
@@ -299,7 +301,7 @@ public void testParameters1() {
rs = database.query("sql", "SELECT FROM " + className + " WHERE name = ?", "bozo");
- Assertions.assertTrue(rs.hasNext());
+ assertThat(rs.hasNext()).isTrue();
rs.next();
rs.close();
}
@@ -318,7 +320,7 @@ public void testPositionalParameters() {
rs = database.query("sql", "SELECT FROM " + className + " WHERE name = ?", "bozo");
- Assertions.assertTrue(rs.hasNext());
+ assertThat(rs.hasNext()).isTrue();
rs.next();
rs.close();
}
@@ -327,6 +329,7 @@ public void testPositionalParameters() {
public void testInsertJsonNewLines() {
database.transaction(() -> {
database.getSchema().createDocumentType("doc");
+
final ResultSet result = database.command("sqlscript", "INSERT INTO doc CONTENT {\n" + //
"\"head\" : {\n" + //
" \"vars\" : [ \"item\", \"itemLabel\" ]\n" + //
@@ -356,10 +359,10 @@ public void testInsertJsonNewLines() {
" }\n" + //
"}");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result res = result.next();
- Assertions.assertTrue(res.hasProperty("head"));
- Assertions.assertTrue(res.hasProperty("results"));
+ assertThat(res.hasProperty("head")).isTrue();
+ assertThat(res.hasProperty("results")).isTrue();
});
}
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/AlterDatabaseExecutionTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/AlterDatabaseExecutionTest.java
index d301ab5e9b..0dbc84c7f6 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/AlterDatabaseExecutionTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/AlterDatabaseExecutionTest.java
@@ -20,9 +20,10 @@
import com.arcadedb.GlobalConfiguration;
import com.arcadedb.TestHelper;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+
/**
* @author Luca Garulli (l.garulli@arcadedata.com)
*/
@@ -30,18 +31,18 @@ public class AlterDatabaseExecutionTest extends TestHelper {
@Test
public void testBasicCreateProperty() {
final int defPageSize = ((int) GlobalConfiguration.BUCKET_DEFAULT_PAGE_SIZE.getDefValue());
- Assertions.assertEquals(defPageSize, database.getConfiguration().getValueAsInteger(GlobalConfiguration.BUCKET_DEFAULT_PAGE_SIZE));
+ assertThat(database.getConfiguration().getValueAsInteger(GlobalConfiguration.BUCKET_DEFAULT_PAGE_SIZE)).isEqualTo(defPageSize);
database.command("sql", "ALTER DATABASE `arcadedb.bucketDefaultPageSize` 262144");
- Assertions.assertEquals(262144, database.getConfiguration().getValueAsInteger(GlobalConfiguration.BUCKET_DEFAULT_PAGE_SIZE));
+ assertThat(database.getConfiguration().getValueAsInteger(GlobalConfiguration.BUCKET_DEFAULT_PAGE_SIZE)).isEqualTo(262144);
database.command("sql", "ALTER DATABASE `arcadedb.bucketDefaultPageSize` " + defPageSize);
- Assertions.assertEquals(defPageSize, database.getConfiguration().getValueAsInteger(GlobalConfiguration.BUCKET_DEFAULT_PAGE_SIZE));
+ assertThat(database.getConfiguration().getValueAsInteger(GlobalConfiguration.BUCKET_DEFAULT_PAGE_SIZE)).isEqualTo(defPageSize);
database.command("sql", "ALTER DATABASE `arcadedb.dateTimeFormat` 'yyyy-MM-dd HH:mm:ss.SSS'");
- Assertions.assertEquals("yyyy-MM-dd HH:mm:ss.SSS", database.getSchema().getDateTimeFormat());
+ assertThat(database.getSchema().getDateTimeFormat()).isEqualTo("yyyy-MM-dd HH:mm:ss.SSS");
}
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/AlterPropertyExecutionTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/AlterPropertyExecutionTest.java
index 5214e0929c..37a3a6d929 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/AlterPropertyExecutionTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/AlterPropertyExecutionTest.java
@@ -22,12 +22,16 @@
import com.arcadedb.graph.Vertex;
import com.arcadedb.schema.Type;
import com.arcadedb.serializer.json.JSONObject;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import java.time.*;
import java.util.*;
+import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
/**
* @author Luca Garulli (l.garulli@arcadedata.com)
*/
@@ -35,39 +39,40 @@ public class AlterPropertyExecutionTest extends TestHelper {
@Test
public void sqlAlterPropertyCustom() {
database.command("sql", "CREATE VERTEX TYPE Car");
- Assertions.assertTrue(database.getSchema().getType("Car").getSuperTypes().isEmpty());
+ assertThat(database.getSchema().getType("Car").getSuperTypes().isEmpty()).isTrue();
database.command("sql", "CREATE PROPERTY Car.name STRING");
- Assertions.assertTrue(database.getSchema().getType("Car").existsProperty("name"));
- Assertions.assertEquals(Type.STRING, database.getSchema().getType("Car").getProperty("name").getType());
+ assertThat(database.getSchema().getType("Car").existsProperty("name")).isTrue();
+ assertThat(database.getSchema().getType("Car").getProperty("name").getType()).isEqualTo(Type.STRING);
database.command("sql", "ALTER PROPERTY Car.name CUSTOM description = 'test'");
- Assertions.assertEquals("test", database.getSchema().getType("Car").getProperty("name").getCustomValue("description"));
+ assertThat(database.getSchema().getType("Car").getProperty("name").getCustomValue("description")).isEqualTo("test");
database.command("sql", "ALTER PROPERTY Car.name CUSTOM age = 3");
- Assertions.assertEquals(3, database.getSchema().getType("Car").getProperty("name").getCustomValue("age"));
+ assertThat(database.getSchema().getType("Car").getProperty("name").getCustomValue("age")).isEqualTo(3);
final JSONObject cfg = database.getSchema().getEmbedded().toJSON();
- final JSONObject customMap = cfg.getJSONObject("types").getJSONObject("Car").getJSONObject("properties").getJSONObject("name").getJSONObject("custom");
- Assertions.assertEquals("test", customMap.getString("description"));
- Assertions.assertEquals(3, customMap.getInt("age"));
+ final JSONObject customMap = cfg.getJSONObject("types").getJSONObject("Car").getJSONObject("properties").getJSONObject("name")
+ .getJSONObject("custom");
+ assertThat(customMap.getString("description")).isEqualTo("test");
+ assertThat(customMap.getInt("age")).isEqualTo(3);
database.close();
database = factory.open();
- Assertions.assertEquals("test", database.getSchema().getType("Car").getProperty("name").getCustomValue("description"));
- Assertions.assertEquals(3, ((Number) database.getSchema().getType("Car").getProperty("name").getCustomValue("age")).intValue());
+ assertThat(database.getSchema().getType("Car").getProperty("name").getCustomValue("description")).isEqualTo("test");
+ assertThat(((Number) database.getSchema().getType("Car").getProperty("name").getCustomValue("age")).intValue()).isEqualTo(3);
database.command("sql", "ALTER PROPERTY Car.name CUSTOM age = null");
- Assertions.assertNull(database.getSchema().getType("Car").getProperty("name").getCustomValue("age"));
- Assertions.assertFalse(database.getSchema().getType("Car").getProperty("name").getCustomKeys().contains("age"));
+ assertThat(database.getSchema().getType("Car").getProperty("name").getCustomValue("age")).isNull();
+ assertThat(database.getSchema().getType("Car").getProperty("name").getCustomKeys().contains("age")).isFalse();
final ResultSet resultset = database.query("sql", "SELECT properties FROM schema:types");
while (resultset.hasNext()) {
final Result result = resultset.next();
final Object custom = ((Result) ((List) result.getProperty("properties")).get(0)).getProperty("custom");
- Assertions.assertTrue(custom instanceof Map);
- Assertions.assertFalse(((Map, ?>) custom).isEmpty());
+ assertThat(custom instanceof Map).isTrue();
+ assertThat(((Map, ?>) custom).isEmpty()).isFalse();
}
}
@@ -76,71 +81,73 @@ public void sqlAlterPropertyDefault() {
database.command("sql", "CREATE VERTEX TYPE Vehicle");
database.command("sql", "CREATE PROPERTY Vehicle.id STRING");
database.command("sql", "ALTER PROPERTY Vehicle.id DEFAULT \"12345\"");
- Assertions.assertTrue(database.getSchema().getType("Vehicle").getSuperTypes().isEmpty());
+ assertThat(database.getSchema().getType("Vehicle").getSuperTypes().isEmpty()).isTrue();
database.command("sql", "CREATE VERTEX TYPE Car EXTENDS Vehicle");
- Assertions.assertTrue(!database.getSchema().getType("Car").getSuperTypes().isEmpty());
+ assertThat(database.getSchema().getType("Car").getSuperTypes().isEmpty()).isFalse();
database.command("sql", "CREATE PROPERTY Car.name STRING");
- Assertions.assertTrue(database.getSchema().getType("Car").existsProperty("name"));
- Assertions.assertEquals(Type.STRING, database.getSchema().getType("Car").getProperty("name").getType());
+ assertThat(database.getSchema().getType("Car").existsProperty("name")).isTrue();
+ assertThat(database.getSchema().getType("Car").getProperty("name").getType()).isEqualTo(Type.STRING);
database.command("sql", "ALTER PROPERTY Car.name DEFAULT \"test\"");
- Assertions.assertEquals("test", database.getSchema().getType("Car").getProperty("name").getDefaultValue());
+ assertThat(database.getSchema().getType("Car").getProperty("name").getDefaultValue()).isEqualTo("test");
database.command("sql", "CREATE VERTEX TYPE Suv EXTENDS Car");
- Assertions.assertFalse(database.getSchema().getType("Suv").getSuperTypes().isEmpty());
+ assertThat(database.getSchema().getType("Suv").getSuperTypes().isEmpty()).isFalse();
database.command("sql", "CREATE PROPERTY Suv.weight float");
- Assertions.assertTrue(database.getSchema().getType("Suv").existsProperty("weight"));
- Assertions.assertEquals(Type.FLOAT, database.getSchema().getType("Suv").getProperty("weight").getType());
+ assertThat(database.getSchema().getType("Suv").existsProperty("weight")).isTrue();
+ assertThat(database.getSchema().getType("Suv").getProperty("weight").getType()).isEqualTo(Type.FLOAT);
database.command("sql", "ALTER PROPERTY Suv.weight DEFAULT 1");
- Assertions.assertEquals(1.0F, database.getSchema().getType("Suv").getProperty("weight").getDefaultValue());
+ assertThat(database.getSchema().getType("Suv").getProperty("weight").getDefaultValue()).isEqualTo(1.0F);
final JSONObject cfg = database.getSchema().getEmbedded().toJSON();
- final String def1 = cfg.getJSONObject("types").getJSONObject("Car").getJSONObject("properties").getJSONObject("name").getString("default");
- Assertions.assertEquals("\"test\"", def1);
- final Float def2 = cfg.getJSONObject("types").getJSONObject("Suv").getJSONObject("properties").getJSONObject("weight").getFloat("default");
- Assertions.assertEquals(1, def2);
+ final String def1 = cfg.getJSONObject("types").getJSONObject("Car").getJSONObject("properties").getJSONObject("name")
+ .getString("default");
+ assertThat(def1).isEqualTo("\"test\"");
+ final Float def2 = cfg.getJSONObject("types").getJSONObject("Suv").getJSONObject("properties").getJSONObject("weight")
+ .getFloat("default");
+ assertThat(def2).isEqualTo(1);
database.transaction(() -> {
database.command("sql", "CREATE VERTEX Car");
final ResultSet result = database.command("sql", "SELECT FROM Car");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Vertex v = result.next().getVertex().get();
- Assertions.assertEquals("test", v.get("name"));
+ assertThat(v.get("name")).isEqualTo("test");
});
database.transaction(() -> {
database.command("sql", "CREATE VERTEX Suv");
final ResultSet result = database.command("sql", "SELECT FROM Suv");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Vertex v = result.next().getVertex().get();
- Assertions.assertEquals("12345", v.get("id"));
- Assertions.assertEquals("test", v.get("name"));
- Assertions.assertEquals(1.0F, v.get("weight"));
+ assertThat(v.get("id")).isEqualTo("12345");
+ assertThat(v.get("name")).isEqualTo("test");
+ assertThat(v.get("weight")).isEqualTo(1.0F);
});
database.close();
database = factory.open();
- Assertions.assertEquals("test", database.getSchema().getType("Car").getProperty("name").getDefaultValue());
+ assertThat(database.getSchema().getType("Car").getProperty("name").getDefaultValue()).isEqualTo("test");
database.command("sql", "ALTER PROPERTY Car.name DEFAULT null");
- Assertions.assertNull(database.getSchema().getType("Car").getProperty("name").getDefaultValue());
+ assertThat(database.getSchema().getType("Car").getProperty("name").getDefaultValue()).isNull();
}
@Test
public void sqlAlterPropertyDefaultFunctions() {
database.command("sql", "CREATE VERTEX TYPE Log");
- Assertions.assertTrue(database.getSchema().getType("Log").getSuperTypes().isEmpty());
+ assertThat(database.getSchema().getType("Log").getSuperTypes().isEmpty()).isTrue();
database.command("sql", "CREATE PROPERTY Log.createdOn DATETIME_MICROS");
- Assertions.assertTrue(database.getSchema().getType("Log").existsProperty("createdOn"));
- Assertions.assertEquals(Type.DATETIME_MICROS, database.getSchema().getType("Log").getProperty("createdOn").getType());
+ assertThat(database.getSchema().getType("Log").existsProperty("createdOn")).isTrue();
+ assertThat(database.getSchema().getType("Log").getProperty("createdOn").getType()).isEqualTo(Type.DATETIME_MICROS);
database.command("sql", "ALTER PROPERTY Log.createdOn DEFAULT sysDate()");
@@ -156,25 +163,25 @@ public void sqlAlterPropertyDefaultFunctions() {
database.command("sql", "CREATE VERTEX Log");
ResultSet result = database.command("sql", "SELECT FROM Log");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
Vertex v = result.next().getVertex().get();
final LocalDateTime createdOn1 = v.getLocalDateTime("createdOn");
- Assertions.assertNotNull(createdOn1);
+ assertThat(createdOn1).isNotNull();
v = result.next().getVertex().get();
final LocalDateTime createdOn2 = v.getLocalDateTime("createdOn");
- Assertions.assertNotNull(createdOn2);
+ assertThat(createdOn2).isNotNull();
- Assertions.assertNotEquals(createdOn1, createdOn2);
+ assertThat(createdOn1).isNotEqualTo(createdOn2);
v.modify().set("lastUpdateOn", LocalDateTime.now()).save();
result = database.command("sql", "SELECT FROM Log");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
v = result.next().getVertex().get();
- Assertions.assertEquals(createdOn1, v.getLocalDateTime("createdOn"));
+ assertThat(v.getLocalDateTime("createdOn")).isEqualTo(createdOn1);
});
}
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/AlterTypeExecutionTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/AlterTypeExecutionTest.java
index 0327a3a53b..cc642dc474 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/AlterTypeExecutionTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/AlterTypeExecutionTest.java
@@ -22,11 +22,12 @@
import com.arcadedb.database.bucketselectionstrategy.BucketSelectionStrategy;
import com.arcadedb.database.bucketselectionstrategy.PartitionedBucketSelectionStrategy;
import com.arcadedb.serializer.json.JSONObject;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.stream.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
/**
* @author Luca Garulli (l.garulli@arcadedata.com)
*/
@@ -35,40 +36,40 @@ public class AlterTypeExecutionTest extends TestHelper {
public void sqlAlterTypeInheritanceUsing() {
database.command("sql", "CREATE VERTEX TYPE Car");
- Assertions.assertTrue(database.getSchema().getType("Car").getSuperTypes().isEmpty());
+ assertThat(database.getSchema().getType("Car").getSuperTypes().isEmpty()).isTrue();
database.command("sql", "CREATE VERTEX TYPE Vehicle");
database.command("sql", "ALTER TYPE Car SUPERTYPE +Vehicle");
- Assertions.assertEquals(1, database.getSchema().getType("Car").getSuperTypes().size());
- Assertions.assertTrue(database.getSchema().getType("Car").getSuperTypes().stream().map(x -> x.getName()).collect(Collectors.toSet()).contains("Vehicle"));
- Assertions.assertEquals(1, database.getSchema().getType("Vehicle").getSubTypes().size());
- Assertions.assertTrue(database.getSchema().getType("Vehicle").getSubTypes().stream().map(x -> x.getName()).collect(Collectors.toSet()).contains("Car"));
- Assertions.assertTrue(database.getSchema().getType("Vehicle").isSuperTypeOf("Car"));
+ assertThat(database.getSchema().getType("Car").getSuperTypes().size()).isEqualTo(1);
+ assertThat(database.getSchema().getType("Car").getSuperTypes().stream().map(x -> x.getName()).collect(Collectors.toSet()).contains("Vehicle")).isTrue();
+ assertThat(database.getSchema().getType("Vehicle").getSubTypes().size()).isEqualTo(1);
+ assertThat(database.getSchema().getType("Vehicle").getSubTypes().stream().map(x -> x.getName()).collect(Collectors.toSet()).contains("Car")).isTrue();
+ assertThat(database.getSchema().getType("Vehicle").isSuperTypeOf("Car")).isTrue();
database.command("sql", "CREATE VERTEX TYPE Suv");
- Assertions.assertTrue(database.getSchema().getType("Suv").getSuperTypes().isEmpty());
+ assertThat(database.getSchema().getType("Suv").getSuperTypes().isEmpty()).isTrue();
database.command("sql", "ALTER TYPE Suv SUPERTYPE +Car");
- Assertions.assertEquals(1, database.getSchema().getType("Suv").getSuperTypes().size());
- Assertions.assertTrue(database.getSchema().getType("Car").isSuperTypeOf("Suv"));
- Assertions.assertEquals(1, database.getSchema().getType("Car").getSubTypes().size());
- Assertions.assertTrue(database.getSchema().getType("Car").getSubTypes().stream().map(x -> x.getName()).collect(Collectors.toSet()).contains("Suv"));
- Assertions.assertTrue(database.getSchema().getType("Car").isSuperTypeOf("Suv"));
+ assertThat(database.getSchema().getType("Suv").getSuperTypes().size()).isEqualTo(1);
+ assertThat(database.getSchema().getType("Car").isSuperTypeOf("Suv")).isTrue();
+ assertThat(database.getSchema().getType("Car").getSubTypes().size()).isEqualTo(1);
+ assertThat(database.getSchema().getType("Car").getSubTypes().stream().map(x -> x.getName()).collect(Collectors.toSet()).contains("Suv")).isTrue();
+ assertThat(database.getSchema().getType("Car").isSuperTypeOf("Suv")).isTrue();
database.command("sql", "ALTER TYPE Car SUPERTYPE -Vehicle");
- Assertions.assertTrue(database.getSchema().getType("Car").getSuperTypes().isEmpty());
- Assertions.assertTrue(database.getSchema().getType("Vehicle").getSubTypes().isEmpty());
+ assertThat(database.getSchema().getType("Car").getSuperTypes().isEmpty()).isTrue();
+ assertThat(database.getSchema().getType("Vehicle").getSubTypes().isEmpty()).isTrue();
database.command("sql", "ALTER TYPE Suv SUPERTYPE +Vehicle, +Car");
- Assertions.assertEquals(2, database.getSchema().getType("Suv").getSuperTypes().size());
- Assertions.assertTrue(database.getSchema().getType("Car").isSuperTypeOf("Suv"));
- Assertions.assertTrue(database.getSchema().getType("Vehicle").isSuperTypeOf("Suv"));
- Assertions.assertEquals(1, database.getSchema().getType("Car").getSubTypes().size());
- Assertions.assertEquals(1, database.getSchema().getType("Vehicle").getSubTypes().size());
- Assertions.assertTrue(database.getSchema().getType("Car").getSubTypes().stream().map(x -> x.getName()).collect(Collectors.toSet()).contains("Suv"));
- Assertions.assertTrue(database.getSchema().getType("Car").isSuperTypeOf("Suv"));
- Assertions.assertTrue(database.getSchema().getType("Vehicle").isSuperTypeOf("Suv"));
+ assertThat(database.getSchema().getType("Suv").getSuperTypes().size()).isEqualTo(2);
+ assertThat(database.getSchema().getType("Car").isSuperTypeOf("Suv")).isTrue();
+ assertThat(database.getSchema().getType("Vehicle").isSuperTypeOf("Suv")).isTrue();
+ assertThat(database.getSchema().getType("Car").getSubTypes().size()).isEqualTo(1);
+ assertThat(database.getSchema().getType("Vehicle").getSubTypes().size()).isEqualTo(1);
+ assertThat(database.getSchema().getType("Car").getSubTypes().stream().map(x -> x.getName()).collect(Collectors.toSet()).contains("Suv")).isTrue();
+ assertThat(database.getSchema().getType("Car").isSuperTypeOf("Suv")).isTrue();
+ assertThat(database.getSchema().getType("Vehicle").isSuperTypeOf("Suv")).isTrue();
}
@Test
@@ -79,8 +80,8 @@ public void sqlAlterTypeBucketSelectionStrategy() {
database.command("sql", "ALTER TYPE Account BucketSelectionStrategy `partitioned('id')`");
final BucketSelectionStrategy strategy = database.getSchema().getType("Account").getBucketSelectionStrategy();
- Assertions.assertEquals("partitioned", strategy.getName());
- Assertions.assertEquals("id", ((PartitionedBucketSelectionStrategy) strategy).getProperties().get(0));
+ assertThat(strategy.getName()).isEqualTo("partitioned");
+ assertThat(((PartitionedBucketSelectionStrategy) strategy).getProperties().get(0)).isEqualTo("id");
}
@Test
@@ -88,18 +89,18 @@ public void sqlAlterTypeCustom() {
database.command("sql", "CREATE VERTEX TYPE Suv");
database.command("sql", "ALTER TYPE Suv CUSTOM description = 'test'");
- Assertions.assertEquals("test", database.getSchema().getType("Suv").getCustomValue("description"));
+ assertThat(database.getSchema().getType("Suv").getCustomValue("description")).isEqualTo("test");
database.command("sql", "ALTER TYPE Suv CUSTOM age = 3");
- Assertions.assertEquals(3, database.getSchema().getType("Suv").getCustomValue("age"));
+ assertThat(database.getSchema().getType("Suv").getCustomValue("age")).isEqualTo(3);
final JSONObject cfg = database.getSchema().getEmbedded().toJSON();
final JSONObject customMap = cfg.getJSONObject("types").getJSONObject("Suv").getJSONObject("custom");
- Assertions.assertEquals("test", customMap.getString("description"));
- Assertions.assertEquals(3, customMap.getInt("age"));
+ assertThat(customMap.getString("description")).isEqualTo("test");
+ assertThat(customMap.getInt("age")).isEqualTo(3);
database.command("sql", "ALTER TYPE Suv CUSTOM age = null");
- Assertions.assertNull(database.getSchema().getType("Suv").getCustomValue("age"));
- Assertions.assertFalse(database.getSchema().getType("Suv").getCustomKeys().contains("age"));
+ assertThat(database.getSchema().getType("Suv").getCustomValue("age")).isNull();
+ assertThat(database.getSchema().getType("Suv").getCustomKeys().contains("age")).isFalse();
}
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/BeginStatementExecutionTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/BeginStatementExecutionTest.java
index be1eac6713..ce3e42c268 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/BeginStatementExecutionTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/BeginStatementExecutionTest.java
@@ -19,9 +19,13 @@
package com.arcadedb.query.sql.executor;
import com.arcadedb.TestHelper;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.Test;
+import java.util.*;
+
+import static org.assertj.core.api.Assertions.*;
+
/**
* @author Luigi Dell'Aquila (l.dellaquila-(at)-orientdb.com)
*/
@@ -29,15 +33,15 @@ public class BeginStatementExecutionTest {
@Test
public void testBegin() throws Exception {
TestHelper.executeInNewDatabase("OCommitStatementExecutionTest", (db) -> {
- Assertions.assertTrue(db.getTransaction() == null || !db.getTransaction().isActive());
+ assertThat(db.getTransaction() == null || !db.getTransaction().isActive()).isTrue();
final ResultSet result = db.command("sql", "begin");
//printExecutionPlan(null, result);
- Assertions.assertNotNull(result);
- Assertions.assertTrue(result.hasNext());
+ assertThat((Iterator extends Result>) result).isNotNull();
+ assertThat(result.hasNext()).isTrue();
final Result item = result.next();
- Assertions.assertEquals("begin", item.getProperty("operation"));
- Assertions.assertFalse(result.hasNext());
- Assertions.assertFalse(db.getTransaction() == null || !db.getTransaction().isActive());
+ assertThat(item.getProperty("operation")).isEqualTo("begin");
+ assertThat(result.hasNext()).isFalse();
+ assertThat(db.getTransaction() == null || !db.getTransaction().isActive()).isFalse();
db.commit();
});
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/CheckClusterTypeStepTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/CheckClusterTypeStepTest.java
index 90b56cd167..85d9e5a160 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/CheckClusterTypeStepTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/CheckClusterTypeStepTest.java
@@ -21,9 +21,13 @@
import com.arcadedb.TestHelper;
import com.arcadedb.exception.CommandExecutionException;
import com.arcadedb.schema.DocumentType;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.Assertions.fail;
+
public class CheckClusterTypeStepTest {
private static final String CLASS_CLUSTER_NAME = "ClassClusterName";
@@ -39,7 +43,8 @@ public void shouldCheckClusterType() throws Exception {
final CheckClusterTypeStep step = new CheckClusterTypeStep(CLASS_CLUSTER_NAME, clazz.getName(), context);
final ResultSet result = step.syncPull(context, 20);
- Assertions.assertEquals(0, result.stream().count());
+
+ assertThat(result.stream().count()).isEqualTo(0);
});
}
@@ -53,7 +58,7 @@ public void shouldThrowExceptionWhenClusterIsWrong() throws Exception {
step.syncPull(context, 20);
});
- Assertions.fail("Expected CommandExecutionException");
+ fail("Expected CommandExecutionException");
} catch (final CommandExecutionException e) {
// OK
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/CheckRecordTypeStepTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/CheckRecordTypeStepTest.java
index 03e8293fe7..b5f52adde3 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/CheckRecordTypeStepTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/CheckRecordTypeStepTest.java
@@ -22,9 +22,13 @@
import com.arcadedb.exception.CommandExecutionException;
import com.arcadedb.exception.TimeoutException;
import com.arcadedb.schema.DocumentType;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.Assertions.fail;
+
public class CheckRecordTypeStepTest {
@Test
@@ -54,8 +58,8 @@ public ResultSet syncPull(final CommandContext ctx, final int nRecords) throws T
step.setPrevious(previous);
final ResultSet result = step.syncPull(context, 20);
- Assertions.assertEquals(10, result.stream().count());
- Assertions.assertFalse(result.hasNext());
+ assertThat(result.stream().count()).isEqualTo(10);
+ assertThat(result.hasNext()).isFalse();
});
}
@@ -86,8 +90,8 @@ public ResultSet syncPull(final CommandContext ctx, final int nRecords) throws T
step.setPrevious(previous);
final ResultSet result = step.syncPull(context, 20);
- Assertions.assertEquals(10, result.stream().count());
- Assertions.assertFalse(result.hasNext());
+ assertThat(result.stream().count()).isEqualTo(10);
+ assertThat(result.hasNext()).isFalse();
});
}
@@ -123,7 +127,7 @@ public ResultSet syncPull(final CommandContext ctx, final int nRecords) throws T
result.next();
}
});
- Assertions.fail("Expected CommandExecutionException");
+ fail("Expected CommandExecutionException");
} catch (final CommandExecutionException e) {
// OK
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/CheckSafeDeleteStepTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/CheckSafeDeleteStepTest.java
index 79b0b1c582..5aaa466117 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/CheckSafeDeleteStepTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/CheckSafeDeleteStepTest.java
@@ -20,9 +20,11 @@
import com.arcadedb.TestHelper;
import com.arcadedb.exception.TimeoutException;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class CheckSafeDeleteStepTest {
@Test
@@ -50,8 +52,8 @@ public ResultSet syncPull(final CommandContext ctx, final int nRecords) throws T
step.setPrevious(previous);
final ResultSet result = step.syncPull(context, 10);
- Assertions.assertEquals(10, result.stream().count());
- Assertions.assertFalse(result.hasNext());
+ assertThat(result.stream().count()).isEqualTo(10);
+ assertThat(result.hasNext()).isFalse();
});
}
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/CheckTypeTypeStepTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/CheckTypeTypeStepTest.java
index 7bd6de237e..47125168bc 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/CheckTypeTypeStepTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/CheckTypeTypeStepTest.java
@@ -21,9 +21,13 @@
import com.arcadedb.TestHelper;
import com.arcadedb.exception.CommandExecutionException;
import com.arcadedb.schema.DocumentType;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.Assertions.fail;
+
public class CheckTypeTypeStepTest {
@Test
@@ -36,7 +40,7 @@ public void shouldCheckSubclasses() throws Exception {
final CheckTypeTypeStep step = new CheckTypeTypeStep(childClass.getName(), parentClass.getName(), context);
final ResultSet result = step.syncPull(context, 20);
- Assertions.assertEquals(0, result.stream().count());
+ assertThat(result.stream().count()).isEqualTo(0);
});
}
@@ -49,7 +53,7 @@ public void shouldCheckOneType() throws Exception {
final CheckTypeTypeStep step = new CheckTypeTypeStep(className, className, context);
final ResultSet result = step.syncPull(context, 20);
- Assertions.assertEquals(0, result.stream().count());
+ assertThat(result.stream().count()).isEqualTo(0);
});
}
@@ -64,7 +68,7 @@ public void shouldThrowExceptionWhenClassIsNotParent() throws Exception {
step.syncPull(context, 20);
});
- Assertions.fail("Expected CommandExecutionException");
+ fail("Expected CommandExecutionException");
} catch (final CommandExecutionException e) {
// OK
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/ConsoleStatementExecutionTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/ConsoleStatementExecutionTest.java
index 59e390de43..1240ec6e84 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/ConsoleStatementExecutionTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/ConsoleStatementExecutionTest.java
@@ -2,9 +2,14 @@
import com.arcadedb.TestHelper;
import com.arcadedb.exception.CommandExecutionException;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.Test;
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
/**
* @author Luigi Dell'Aquila (l.dellaquila-(at)-orientdatabase.com)
*/
@@ -13,34 +18,34 @@ public class ConsoleStatementExecutionTest extends TestHelper {
@Test
public void testError() {
ResultSet result = database.command("sqlscript", "console.`error` 'foo bar'");
- Assertions.assertNotNull(result);
- Assertions.assertTrue(result.hasNext());
+ assertThat(Optional.ofNullable(result)).isNotNull();
+ assertThat(result.hasNext()).isTrue();
Result item = result.next();
- Assertions.assertNotNull(item);
- Assertions.assertEquals("error", item.getProperty("level"));
- Assertions.assertEquals("foo bar", item.getProperty("message"));
+ assertThat(item).isNotNull();
+ assertThat(item.getProperty("level")).isEqualTo("error");
+ assertThat(item.getProperty("message")).isEqualTo("foo bar");
}
@Test
public void testLog() {
ResultSet result = database.command("sqlscript", "console.log 'foo bar'");
- Assertions.assertNotNull(result);
- Assertions.assertTrue(result.hasNext());
+ assertThat(Optional.ofNullable(result)).isNotNull();
+ assertThat(result.hasNext()).isTrue();
Result item = result.next();
- Assertions.assertNotNull(item);
- Assertions.assertEquals("log", item.getProperty("level"));
- Assertions.assertEquals("foo bar", item.getProperty("message"));
+ assertThat(item).isNotNull();
+ assertThat(item.getProperty("level")).isEqualTo("log");
+ assertThat(item.getProperty("message")).isEqualTo("foo bar");
}
@Test
public void testInvalidLevel() {
try {
database.command("sqlscript", "console.bla 'foo bar'");
- Assertions.fail();
+ fail("");
} catch (CommandExecutionException x) {
// EXPECTED
} catch (Exception x2) {
- Assertions.fail();
+ fail("");
}
}
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/ConvertToResultInternalStepTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/ConvertToResultInternalStepTest.java
index 02afc400e7..d210fdea10 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/ConvertToResultInternalStepTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/ConvertToResultInternalStepTest.java
@@ -22,11 +22,14 @@
import com.arcadedb.database.Document;
import com.arcadedb.database.MutableDocument;
import com.arcadedb.exception.TimeoutException;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.*;
+import static org.assertj.core.api.Assertions.*;
+
public class ConvertToResultInternalStepTest {
private static final String STRING_PROPERTY = "stringPropertyName";
@@ -68,13 +71,13 @@ public ResultSet syncPull(final CommandContext ctx, final int nRecords) throws T
while (result.hasNext()) {
final Result currentItem = result.next();
if (!(currentItem.getClass().equals(ResultInternal.class))) {
- Assertions.fail("There is an item in result set that is not an instance of ResultInternal");
+ fail("There is an item in result set that is not an instance of ResultInternal");
}
if (!currentItem.getElement().get().get(STRING_PROPERTY).equals(documents.get(counter).get(STRING_PROPERTY))) {
- Assertions.fail("String Document property inside Result instance is not preserved");
+ fail("String Document property inside Result instance is not preserved");
}
if (!currentItem.getElement().get().get(INTEGER_PROPERTY).equals(documents.get(counter).get(INTEGER_PROPERTY))) {
- Assertions.fail("Integer Document property inside Result instance is not preserved");
+ fail("Integer Document property inside Result instance is not preserved");
}
counter++;
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/ConvertToUpdatableResultStepTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/ConvertToUpdatableResultStepTest.java
index 104322192a..54b792fac6 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/ConvertToUpdatableResultStepTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/ConvertToUpdatableResultStepTest.java
@@ -22,11 +22,14 @@
import com.arcadedb.database.Document;
import com.arcadedb.database.MutableDocument;
import com.arcadedb.exception.TimeoutException;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.*;
+import static org.assertj.core.api.Assertions.*;
+
public class ConvertToUpdatableResultStepTest {
private static final String STRING_PROPERTY = "stringPropertyName";
@@ -69,13 +72,13 @@ public ResultSet syncPull(final CommandContext ctx, final int nRecords) throws T
while (result.hasNext()) {
final Result currentItem = result.next();
if (!(currentItem.getClass().equals(UpdatableResult.class))) {
- Assertions.fail("There is an item in result set that is not an instance of OUpdatableResult");
+ fail("There is an item in result set that is not an instance of OUpdatableResult");
}
if (!currentItem.getElement().get().get(STRING_PROPERTY).equals(documents.get(counter).get(STRING_PROPERTY))) {
- Assertions.fail("String Document property inside Result instance is not preserved");
+ fail("String Document property inside Result instance is not preserved");
}
if (!currentItem.getElement().get().get(INTEGER_PROPERTY).equals(documents.get(counter).get(INTEGER_PROPERTY))) {
- Assertions.fail("Integer Document property inside Result instance is not preserved");
+ fail("Integer Document property inside Result instance is not preserved");
}
counter++;
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/CountFromIndexStepTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/CountFromIndexStepTest.java
index c6fd9fae66..83de0e6d7a 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/CountFromIndexStepTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/CountFromIndexStepTest.java
@@ -25,11 +25,14 @@
import com.arcadedb.schema.DocumentType;
import com.arcadedb.schema.Schema;
import com.arcadedb.schema.Type;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.*;
+import static org.assertj.core.api.Assertions.*;
+
public class CountFromIndexStepTest {
private static final String PROPERTY_NAME = "testPropertyName";
@@ -75,8 +78,8 @@ public void shouldCountRecordsOfIndex() throws Exception {
final CountFromIndexStep step = new CountFromIndexStep(identifier, ALIAS, context);
final ResultSet result = step.syncPull(context, 20);
- Assertions.assertEquals(20, (long) result.next().getProperty(ALIAS));
- Assertions.assertFalse(result.hasNext());
+ assertThat((long) result.next().getProperty(ALIAS)).isEqualTo(20);
+ assertThat(result.hasNext()).isFalse();
});
}
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/CountFromTypeStepTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/CountFromTypeStepTest.java
index 4754160a4d..c9509d06ff 100755
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/CountFromTypeStepTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/CountFromTypeStepTest.java
@@ -20,9 +20,12 @@
import com.arcadedb.TestHelper;
import com.arcadedb.database.MutableDocument;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.*;
+
public class CountFromTypeStepTest {
private static final String ALIAS = "size";
@@ -41,8 +44,8 @@ public void shouldCountRecordsOfClass() throws Exception {
final CountFromTypeStep step = new CountFromTypeStep(className, ALIAS, context);
final ResultSet result = step.syncPull(context, 20);
- Assertions.assertEquals(20, (long) result.next().getProperty(ALIAS));
- Assertions.assertFalse(result.hasNext());
+ assertThat((long) result.next().getProperty(ALIAS)).isEqualTo(20);
+ assertThat(result.hasNext()).isFalse();
});
}
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/CountStepTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/CountStepTest.java
index 63152fe169..3d5f8e1242 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/CountStepTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/CountStepTest.java
@@ -19,9 +19,10 @@
package com.arcadedb.query.sql.executor;
import com.arcadedb.exception.TimeoutException;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class CountStepTest {
@@ -55,7 +56,7 @@ public ResultSet syncPull(final CommandContext ctx, final int nRecords) throws T
step.setPrevious(previous);
final ResultSet result = step.syncPull(context, 100);
- Assertions.assertEquals(100, (long) result.next().getProperty(COUNT_PROPERTY_NAME));
- Assertions.assertFalse(result.hasNext());
+ assertThat((long) result.next().getProperty(COUNT_PROPERTY_NAME)).isEqualTo(100);
+ assertThat(result.hasNext()).isFalse();
}
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/CreateDocumentTypeStatementExecutionTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/CreateDocumentTypeStatementExecutionTest.java
index 36d32aa5a8..0c238f38ca 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/CreateDocumentTypeStatementExecutionTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/CreateDocumentTypeStatementExecutionTest.java
@@ -21,9 +21,12 @@
import com.arcadedb.TestHelper;
import com.arcadedb.schema.DocumentType;
import com.arcadedb.schema.Schema;
-import org.junit.jupiter.api.Assertions;
+
+import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.*;
+
/**
* @author Luigi Dell'Aquila (l.dellaquila-(at)-orientdb.com)
*/
@@ -35,7 +38,7 @@ public void testPlain() throws Exception {
final ResultSet result = db.command("sql", "create document type " + className);
final Schema schema = db.getSchema();
final DocumentType clazz = schema.getType(className);
- Assertions.assertNotNull(clazz);
+ assertThat(clazz).isNotNull();
result.close();
});
}
@@ -47,8 +50,8 @@ public void testClusters() throws Exception {
final ResultSet result = db.command("sql", "create document type " + className + " buckets 32");
final Schema schema = db.getSchema();
final DocumentType clazz = schema.getType(className);
- Assertions.assertNotNull(clazz);
- Assertions.assertEquals(32, clazz.getBuckets(false).size());
+ assertThat(clazz).isNotNull();
+ assertThat(clazz.getBuckets(false)).hasSize(32);
result.close();
});
}
@@ -60,12 +63,12 @@ public void testIfNotExists() throws Exception {
ResultSet result = db.command("sql", "create document type " + className + " if not exists");
final Schema schema = db.getSchema();
DocumentType clazz = schema.getType(className);
- Assertions.assertNotNull(clazz);
+ assertThat(clazz).isNotNull();
result.close();
result = db.command("sql", "create document type " + className + " if not exists");
clazz = schema.getType(className);
- Assertions.assertNotNull(clazz);
+ assertThat(clazz).isNotNull();
result.close();
});
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/CreateEdgeStatementExecutionTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/CreateEdgeStatementExecutionTest.java
index ff70a57670..70ba2975e8 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/CreateEdgeStatementExecutionTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/CreateEdgeStatementExecutionTest.java
@@ -22,9 +22,11 @@
import com.arcadedb.exception.CommandSQLParsingException;
import com.arcadedb.graph.Edge;
import com.arcadedb.graph.MutableVertex;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
/**
* @author Luca Garulli (l.garulli@arcadedata.com)
*/
@@ -56,17 +58,17 @@ public void okEdgesContentJsonArray() {
int count = 0;
while (result.hasNext()) {
final Result r = result.next();
- Assertions.assertTrue(r.isEdge());
+ assertThat(r.isEdge()).isTrue();
Edge edge = r.getEdge().get();
- Assertions.assertEquals(count, edge.getInteger("x"));
+ assertThat(edge.getInteger("x")).isEqualTo(count);
++count;
}
result.close();
- Assertions.assertEquals(1, count);
+ assertThat(count).isEqualTo(1);
}
@Test
@@ -89,7 +91,7 @@ public void errorEdgesContentJsonArray() {
try {
ResultSet result = database.command("sql", "create edge " + edgeClassName + " from ? to ? CONTENT " + array, v1, v2);
- Assertions.fail();
+ fail("");
} catch (CommandSQLParsingException e) {
// EXPECTED
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/CreatePropertyStatementExecutionTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/CreatePropertyStatementExecutionTest.java
index a60ef917af..4e1a3fba3d 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/CreatePropertyStatementExecutionTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/CreatePropertyStatementExecutionTest.java
@@ -25,11 +25,14 @@
import com.arcadedb.schema.DocumentType;
import com.arcadedb.schema.Property;
import com.arcadedb.schema.Type;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.Test;
import java.util.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
/**
* @author Luigi Dell'Aquila (l.dellaquila-(at)-orientdb.com)
*/
@@ -47,8 +50,8 @@ public void testBasicCreateProperty() {
final DocumentType companyClass = database.getSchema().getType("testBasicCreateProperty");
final Property nameProperty = companyClass.getProperty(PROP_NAME);
- Assertions.assertEquals(nameProperty.getName(), PROP_NAME);
- Assertions.assertEquals(nameProperty.getType(), Type.STRING);
+ assertThat(nameProperty.getName()).isEqualTo(PROP_NAME);
+ assertThat(nameProperty.getType()).isEqualTo(Type.STRING);
}
@Test
@@ -59,8 +62,8 @@ public void testCreateMandatoryPropertyWithEmbeddedType() {
final DocumentType companyClass = database.getSchema().getType("testCreateMandatoryPropertyWithEmbeddedType");
final Property nameProperty = companyClass.getProperty(PROP_OFFICERS);
- Assertions.assertEquals(nameProperty.getName(), PROP_OFFICERS);
- Assertions.assertEquals(nameProperty.getType(), Type.LIST);
+ assertThat(nameProperty.getName()).isEqualTo(PROP_OFFICERS);
+ assertThat(nameProperty.getType()).isEqualTo(Type.LIST);
}
@Test
@@ -71,8 +74,8 @@ public void testCreateUnsafePropertyWithEmbeddedType() {
final DocumentType companyClass = database.getSchema().getType("testCreateUnsafePropertyWithEmbeddedType");
final Property nameProperty = companyClass.getProperty(PROP_OFFICERS);
- Assertions.assertEquals(nameProperty.getName(), PROP_OFFICERS);
- Assertions.assertEquals(nameProperty.getType(), Type.LIST);
+ assertThat(nameProperty.getName()).isEqualTo(PROP_OFFICERS);
+ assertThat(nameProperty.getType()).isEqualTo(Type.LIST);
}
@Test
@@ -83,8 +86,8 @@ public void testExtraSpaces() {
final DocumentType companyClass = database.getSchema().getType("testExtraSpaces");
final Property idProperty = companyClass.getProperty(PROP_ID);
- Assertions.assertEquals(idProperty.getName(), PROP_ID);
- Assertions.assertEquals(idProperty.getType(), Type.INTEGER);
+ assertThat(idProperty.getName()).isEqualTo(PROP_ID);
+ assertThat(idProperty.getType()).isEqualTo(Type.INTEGER);
}
@Test
@@ -92,7 +95,7 @@ public void testInvalidAttributeName() {
try {
database.command("sql", "create document type CommandExecutionException").close();
database.command("sql", "CREATE PROPERTY CommandExecutionException.id INTEGER (MANDATORY, INVALID, NOTNULL) UNSAFE").close();
- Assertions.fail("Expected CommandSQLParsingException");
+ fail("Expected CommandSQLParsingException");
} catch (final CommandSQLParsingException e) {
// OK
}
@@ -112,29 +115,29 @@ public void testLinkedTypeConstraint() {
final DocumentType invoiceType = database.getSchema().getType("Invoice");
final Property productsProperty = invoiceType.getProperty("products");
- Assertions.assertEquals(productsProperty.getName(), "products");
- Assertions.assertEquals(productsProperty.getType(), Type.LIST);
- Assertions.assertEquals(productsProperty.getOfType(), "Product");
+ assertThat(productsProperty.getName()).isEqualTo("products");
+ assertThat(productsProperty.getType()).isEqualTo(Type.LIST);
+ assertThat(productsProperty.getOfType()).isEqualTo("Product");
final Property tagsProperty = invoiceType.getProperty("tags");
- Assertions.assertEquals(tagsProperty.getName(), "tags");
- Assertions.assertEquals(tagsProperty.getType(), Type.LIST);
- Assertions.assertEquals(tagsProperty.getOfType(), "STRING");
+ assertThat(tagsProperty.getName()).isEqualTo("tags");
+ assertThat(tagsProperty.getType()).isEqualTo(Type.LIST);
+ assertThat(tagsProperty.getOfType()).isEqualTo("STRING");
final Property settingsProperty = invoiceType.getProperty("settings");
- Assertions.assertEquals(settingsProperty.getName(), "settings");
- Assertions.assertEquals(settingsProperty.getType(), Type.MAP);
- Assertions.assertEquals(settingsProperty.getOfType(), "STRING");
+ assertThat(settingsProperty.getName()).isEqualTo("settings");
+ assertThat(settingsProperty.getType()).isEqualTo(Type.MAP);
+ assertThat(settingsProperty.getOfType()).isEqualTo("STRING");
final Property mainProductProperty = invoiceType.getProperty("mainProduct");
- Assertions.assertEquals(mainProductProperty.getName(), "mainProduct");
- Assertions.assertEquals(mainProductProperty.getType(), Type.LINK);
- Assertions.assertEquals(mainProductProperty.getOfType(), "Product");
+ assertThat(mainProductProperty.getName()).isEqualTo("mainProduct");
+ assertThat(mainProductProperty.getType()).isEqualTo(Type.LINK);
+ assertThat(mainProductProperty.getOfType()).isEqualTo("Product");
final Property embeddedProperty = invoiceType.getProperty("embedded");
- Assertions.assertEquals(embeddedProperty.getName(), "embedded");
- Assertions.assertEquals(embeddedProperty.getType(), Type.EMBEDDED);
- Assertions.assertEquals(embeddedProperty.getOfType(), "Product");
+ assertThat(embeddedProperty.getName()).isEqualTo("embedded");
+ assertThat(embeddedProperty.getType()).isEqualTo(Type.EMBEDDED);
+ assertThat(embeddedProperty.getOfType()).isEqualTo("Product");
final MutableDocument[] validInvoice = new MutableDocument[1];
database.transaction(() -> {
@@ -153,21 +156,21 @@ public void testLinkedTypeConstraint() {
database.newDocument("Invoice").set("products",//
List.of(database.newDocument("Invoice").save())).save();
});
- Assertions.fail();
+ fail("");
} catch (ValidationException e) {
// EXPECTED
}
try {
validInvoice[0].set("tags", List.of(3, "hard to close")).save();
- Assertions.fail();
+ fail("");
} catch (ValidationException e) {
// EXPECTED
}
try {
validInvoice[0].set("settings", Map.of("test", 10F)).save();
- Assertions.fail();
+ fail("");
} catch (ValidationException e) {
// EXPECTED
}
@@ -176,7 +179,7 @@ public void testLinkedTypeConstraint() {
database.transaction(() -> {
validInvoice[0].set("mainProduct", database.newDocument("Invoice").save()).save();
});
- Assertions.fail();
+ fail("");
} catch (ValidationException e) {
// EXPECTED
}
@@ -185,7 +188,7 @@ public void testLinkedTypeConstraint() {
database.transaction(() -> {
validInvoice[0].newEmbeddedDocument("Invoice", "embedded").save();
});
- Assertions.fail();
+ fail("");
} catch (ValidationException e) {
// EXPECTED
}
@@ -199,15 +202,15 @@ public void testIfNotExists() {
DocumentType clazz = database.getSchema().getType("testIfNotExists");
Property nameProperty = clazz.getProperty(PROP_NAME);
- Assertions.assertEquals(nameProperty.getName(), PROP_NAME);
- Assertions.assertEquals(nameProperty.getType(), Type.STRING);
+ assertThat(nameProperty.getName()).isEqualTo(PROP_NAME);
+ assertThat(nameProperty.getType()).isEqualTo(Type.STRING);
database.command("sql", "CREATE property testIfNotExists.name if not exists STRING").close();
clazz = database.getSchema().getType("testIfNotExists");
nameProperty = clazz.getProperty(PROP_NAME);
- Assertions.assertEquals(nameProperty.getName(), PROP_NAME);
- Assertions.assertEquals(nameProperty.getType(), Type.STRING);
+ assertThat(nameProperty.getName()).isEqualTo(PROP_NAME);
+ assertThat(nameProperty.getType()).isEqualTo(Type.STRING);
}
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/CreateVertexStatementExecutionTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/CreateVertexStatementExecutionTest.java
index 68309b0946..e0af3143b9 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/CreateVertexStatementExecutionTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/CreateVertexStatementExecutionTest.java
@@ -21,11 +21,14 @@
import com.arcadedb.TestHelper;
import com.arcadedb.exception.CommandExecutionException;
import com.arcadedb.schema.Schema;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.Test;
import java.util.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
/**
* @author Luigi Dell'Aquila (l.dellaquila-(at)-orientdb.com)
*/
@@ -50,25 +53,25 @@ public void testVerticesContentJsonArray() {
ResultSet result = database.command("sql", "create vertex " + className + " content " + array);
for (int i = 0; i < 1000; i++) {
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result item = result.next();
- Assertions.assertNotNull(item);
- Assertions.assertEquals("name" + i, item.getProperty("name").toString());
- Assertions.assertEquals("surname" + i, item.getProperty("surname").toString());
+ assertThat(item).isNotNull();
+ assertThat(item.getProperty("name").toString()).isEqualTo("name" + i);
+ assertThat(item.getProperty("surname").toString()).isEqualTo("surname" + i);
}
- Assertions.assertFalse(result.hasNext());
+ assertThat(result.hasNext()).isFalse();
result = database.query("sql", "select from " + className);
for (int i = 0; i < 1000; i++) {
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
Result item = result.next();
- Assertions.assertNotNull(item);
- Assertions.assertEquals("name" + i, item.getProperty("name").toString());
- Assertions.assertEquals("surname" + i, item.getProperty("surname").toString());
+ assertThat(item).isNotNull();
+ assertThat(item.getProperty("name").toString()).isEqualTo("name" + i);
+ assertThat(item.getProperty("surname").toString()).isEqualTo("surname" + i);
}
- Assertions.assertFalse(result.hasNext());
+ assertThat(result.hasNext()).isFalse();
result.close();
}
@@ -81,21 +84,21 @@ public void testInsertSet() {
ResultSet result = database.command("sql", "create vertex " + className + " set name = 'name1'");
for (int i = 0; i < 1; i++) {
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result item = result.next();
- Assertions.assertNotNull(item);
- Assertions.assertEquals("name1", item.getProperty("name"));
+ assertThat(item).isNotNull();
+ assertThat(item.getProperty("name")).isEqualTo("name1");
}
- Assertions.assertFalse(result.hasNext());
+ assertThat(result.hasNext()).isFalse();
result = database.query("sql", "select from " + className);
for (int i = 0; i < 1; i++) {
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result item = result.next();
- Assertions.assertNotNull(item);
- Assertions.assertEquals("name1", item.getProperty("name"));
+ assertThat(item).isNotNull();
+ assertThat(item.getProperty("name")).isEqualTo("name1");
}
- Assertions.assertFalse(result.hasNext());
+ assertThat(result.hasNext()).isFalse();
result.close();
}
@@ -107,10 +110,10 @@ public void testInsertSetNoVertex() {
try {
final ResultSet result = database.command("sql", "create vertex " + className + " set name = 'name1'");
- Assertions.fail();
+ fail("");
} catch (final CommandExecutionException e1) {
} catch (final Exception e2) {
- Assertions.fail();
+ fail("");
}
}
@@ -123,22 +126,22 @@ public void testInsertValue() {
ResultSet result = database.command("sql", "create vertex " + className + " (name, surname) values ('name1', 'surname1')");
for (int i = 0; i < 1; i++) {
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result item = result.next();
- Assertions.assertNotNull(item);
- Assertions.assertEquals("name1", item.getProperty("name"));
- Assertions.assertEquals("surname1", item.getProperty("surname"));
+ assertThat(item).isNotNull();
+ assertThat(item.getProperty("name")).isEqualTo("name1");
+ assertThat(item.getProperty("surname")).isEqualTo("surname1");
}
- Assertions.assertFalse(result.hasNext());
+ assertThat(result.hasNext()).isFalse();
result = database.query("sql", "select from " + className);
for (int i = 0; i < 1; i++) {
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result item = result.next();
- Assertions.assertNotNull(item);
- Assertions.assertEquals("name1", item.getProperty("name"));
+ assertThat(item).isNotNull();
+ assertThat(item.getProperty("name")).isEqualTo("name1");
}
- Assertions.assertFalse(result.hasNext());
+ assertThat(result.hasNext()).isFalse();
result.close();
}
@@ -152,28 +155,28 @@ public void testInsertValue2() {
"create vertex " + className + " (name, surname) values ('name1', 'surname1'), ('name2', 'surname2')");
for (int i = 0; i < 2; i++) {
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result item = result.next();
- Assertions.assertNotNull(item);
- Assertions.assertEquals("name" + (i + 1), item.getProperty("name"));
- Assertions.assertEquals("surname" + (i + 1), item.getProperty("surname"));
+ assertThat(item).isNotNull();
+ assertThat(item.getProperty("name")).isEqualTo("name" + (i + 1));
+ assertThat(item.getProperty("surname")).isEqualTo("surname" + (i + 1));
}
- Assertions.assertFalse(result.hasNext());
+ assertThat(result.hasNext()).isFalse();
final Set names = new HashSet<>();
names.add("name1");
names.add("name2");
result = database.query("sql", "select from " + className);
for (int i = 0; i < 2; i++) {
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result item = result.next();
- Assertions.assertNotNull(item);
- Assertions.assertNotNull(item.getProperty("name"));
- names.remove(item.getProperty("name"));
- Assertions.assertNotNull(item.getProperty("surname"));
+ assertThat(item).isNotNull();
+ assertThat(item.getProperty("name")).isNotNull();
+ names.remove(item.getProperty("name"));
+ assertThat(item.getProperty("surname")).isNotNull();
}
- Assertions.assertFalse(result.hasNext());
- Assertions.assertTrue(names.isEmpty());
+ assertThat(result.hasNext()).isFalse();
+ assertThat(names.isEmpty()).isTrue();
result.close();
}
@@ -186,22 +189,22 @@ public void testContent() {
ResultSet result = database.command("sql", "create vertex " + className + " content {'name':'name1', 'surname':'surname1'}");
for (int i = 0; i < 1; i++) {
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result item = result.next();
- Assertions.assertNotNull(item);
- Assertions.assertEquals("name1", item.getProperty("name"));
+ assertThat(item).isNotNull();
+ assertThat(item.getProperty("name")).isEqualTo("name1");
}
- Assertions.assertFalse(result.hasNext());
+ assertThat(result.hasNext()).isFalse();
result = database.query("sql", "select from " + className);
for (int i = 0; i < 1; i++) {
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result item = result.next();
- Assertions.assertNotNull(item);
- Assertions.assertEquals("name1", item.getProperty("name"));
- Assertions.assertEquals("surname1", item.getProperty("surname"));
+ assertThat(item).isNotNull();
+ assertThat(item.getProperty("name")).isEqualTo("name1");
+ assertThat(item.getProperty("surname")).isEqualTo("surname1");
}
- Assertions.assertFalse(result.hasNext());
+ assertThat(result.hasNext()).isFalse();
result.close();
}
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/DistinctExecutionStepTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/DistinctExecutionStepTest.java
index 1e998618c3..cb857c69ca 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/DistinctExecutionStepTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/DistinctExecutionStepTest.java
@@ -19,9 +19,10 @@
package com.arcadedb.query.sql.executor;
import com.arcadedb.exception.TimeoutException;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+
/**
* Created by luigidellaquila on 26/07/16.
*/
@@ -52,10 +53,10 @@ public ResultSet syncPull(final CommandContext ctx, final int nRecords) throws T
step.setPrevious(prev);
final ResultSet res = step.syncPull(ctx, 10);
- Assertions.assertTrue(res.hasNext());
+ assertThat(res.hasNext()).isTrue();
res.next();
- Assertions.assertTrue(res.hasNext());
+ assertThat(res.hasNext()).isTrue();
res.next();
- Assertions.assertFalse(res.hasNext());
+ assertThat(res.hasNext()).isFalse();
}
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/DropBucketStatementExecutionTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/DropBucketStatementExecutionTest.java
index 0cca3dff91..8b97f1b2af 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/DropBucketStatementExecutionTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/DropBucketStatementExecutionTest.java
@@ -22,9 +22,12 @@
import com.arcadedb.engine.Bucket;
import com.arcadedb.exception.CommandExecutionException;
import com.arcadedb.schema.Schema;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
/**
* @author Luca Garulli (l.garulli@arcadedata.com)
*/
@@ -35,12 +38,12 @@ public void testDropBucketWithExistentType() {
final Schema schema = database.getSchema();
schema.createDocumentType(className);
- Assertions.assertNotNull(schema.getType(className));
+ assertThat(schema.getType(className)).isNotNull();
for (Bucket bucket : database.getSchema().getType(className).getBuckets(false)) {
try {
database.command("sql", "drop bucket " + bucket.getName());
- Assertions.fail();
+ fail("");
} catch (CommandExecutionException e) {
// EXPECTED
}
@@ -48,13 +51,13 @@ public void testDropBucketWithExistentType() {
database.command("sql", "alter type " + className + " bucket -" + bucket.getName());
final ResultSet result = database.command("sql", "drop bucket " + bucket.getName());
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result next = result.next();
- Assertions.assertEquals("drop bucket", next.getProperty("operation"));
- Assertions.assertFalse(result.hasNext());
+ assertThat(next.getProperty("operation")).isEqualTo("drop bucket");
+ assertThat(result.hasNext()).isFalse();
result.close();
- Assertions.assertFalse(schema.existsBucket(bucket.getName()));
+ assertThat(schema.existsBucket(bucket.getName())).isFalse();
}
}
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/DropTypeStatementExecutionTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/DropTypeStatementExecutionTest.java
index 28c2c09d8e..961ef7340e 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/DropTypeStatementExecutionTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/DropTypeStatementExecutionTest.java
@@ -20,9 +20,10 @@
import com.arcadedb.TestHelper;
import com.arcadedb.schema.Schema;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+
/**
* @author Luigi Dell'Aquila (l.dellaquila-(at)-orientdb.com)
*/
@@ -33,16 +34,16 @@ public void testPlain() {
final Schema schema = database.getSchema();
schema.createDocumentType(className);
- Assertions.assertNotNull(schema.getType(className));
+ assertThat(schema.getType(className)).isNotNull();
final ResultSet result = database.command("sql", "drop type " + className);
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result next = result.next();
- Assertions.assertEquals("drop type", next.getProperty("operation"));
- Assertions.assertFalse(result.hasNext());
+ assertThat(next.getProperty("operation")).isEqualTo("drop type");
+ assertThat(result.hasNext()).isFalse();
result.close();
- Assertions.assertFalse(schema.existsType(className));
+ assertThat(schema.existsType(className)).isFalse();
}
@Test
@@ -51,21 +52,21 @@ public void testIfExists() {
final Schema schema = database.getSchema();
schema.createDocumentType(className);
- Assertions.assertNotNull(schema.getType(className));
+ assertThat(schema.getType(className)).isNotNull();
ResultSet result = database.command("sql", "drop type " + className + " if exists");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result next = result.next();
- Assertions.assertEquals("drop type", next.getProperty("operation"));
- Assertions.assertFalse(result.hasNext());
+ assertThat(next.getProperty("operation")).isEqualTo("drop type");
+ assertThat(result.hasNext()).isFalse();
result.close();
- Assertions.assertFalse(schema.existsType(className));
+ assertThat(schema.existsType(className)).isFalse();
result = database.command("sql", "drop type " + className + " if exists");
result.close();
- Assertions.assertFalse(schema.existsType(className));
+ assertThat(schema.existsType(className)).isFalse();
}
@Test
@@ -74,15 +75,15 @@ public void testParam() {
final Schema schema = database.getSchema();
schema.createDocumentType(className);
- Assertions.assertNotNull(schema.getType(className));
+ assertThat(schema.getType(className)).isNotNull();
final ResultSet result = database.command("sql", "drop type ?", className);
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result next = result.next();
- Assertions.assertEquals("drop type", next.getProperty("operation"));
- Assertions.assertFalse(result.hasNext());
+ assertThat(next.getProperty("operation")).isEqualTo("drop type");
+ assertThat(result.hasNext()).isFalse();
result.close();
- Assertions.assertFalse(schema.existsType(className));
+ assertThat(schema.existsType(className)).isFalse();
}
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/ExplainStatementExecutionTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/ExplainStatementExecutionTest.java
index c59b9ac089..3dfe313063 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/ExplainStatementExecutionTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/ExplainStatementExecutionTest.java
@@ -19,11 +19,12 @@
package com.arcadedb.query.sql.executor;
import com.arcadedb.TestHelper;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
/**
* @author Luigi Dell'Aquila (l.dellaquila-(at)-orientdb.com)
*/
@@ -31,14 +32,14 @@ public class ExplainStatementExecutionTest extends TestHelper {
@Test
public void testExplainSelectNoTarget() {
final ResultSet result = database.query("sql", "explain select 1 as one, 2 as two, 2+3");
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result next = result.next();
- Assertions.assertNotNull(next.getProperty("executionPlan"));
- Assertions.assertNotNull(next.getProperty("executionPlanAsString"));
+ assertThat(next.getProperty("executionPlan")).isNotNull();
+ assertThat(next.getProperty("executionPlanAsString")).isNotNull();
final Optional plan = result.getExecutionPlan();
- Assertions.assertTrue(plan.isPresent());
- Assertions.assertTrue(plan.get() instanceof SelectExecutionPlan);
+ assertThat(plan.isPresent()).isTrue();
+ assertThat(plan.get() instanceof SelectExecutionPlan).isTrue();
result.close();
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/GroupByExecutionTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/GroupByExecutionTest.java
index 7ee889c093..3479019da2 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/GroupByExecutionTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/GroupByExecutionTest.java
@@ -19,11 +19,12 @@
package com.arcadedb.query.sql.executor;
import com.arcadedb.TestHelper;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
/**
* @author Luca Garulli (l.garulli@arcadedata.com)
*/
@@ -50,8 +51,8 @@ public void testGroupByCount() {
final ResultSet result = database.query("sql", "select address, count(*) as occurrences from InputTx where address is not null group by address limit 10");
while (result.hasNext()) {
final Result row = result.next();
- Assertions.assertNotNull(row.getProperty("address"));
- Assertions.assertNotNull(row.getProperty("occurrences"));
+ assertThat(row.getProperty("address")).isNotNull();
+ assertThat(row.getProperty("occurrences")).isNotNull();
}
result.close();
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/IfStatementExecutionTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/IfStatementExecutionTest.java
index 1eb2bbac5e..da52f3c71c 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/IfStatementExecutionTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/IfStatementExecutionTest.java
@@ -19,7 +19,6 @@
package com.arcadedb.query.sql.executor;
import com.arcadedb.TestHelper;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
@@ -32,26 +31,26 @@ public class IfStatementExecutionTest extends TestHelper {
@Test
public void testPositive() {
final ResultSet results = database.command("sql", "if(1=1){ select 1 as a; }");
- Assertions.assertTrue(results.hasNext());
+ assertThat(results.hasNext()).isTrue();
final Result result = results.next();
assertThat((Integer) result.getProperty("a")).isEqualTo(1);
- Assertions.assertFalse(results.hasNext());
+ assertThat(results.hasNext()).isFalse();
results.close();
}
@Test
public void testNegative() {
final ResultSet results = database.command("sql", "if(1=2){ select 1 as a; }");
- Assertions.assertFalse(results.hasNext());
+ assertThat(results.hasNext()).isFalse();
results.close();
}
@Test
public void testIfReturn() {
final ResultSet results = database.command("sql", "if(1=1){ return 'yes'; }");
- Assertions.assertTrue(results.hasNext());
- Assertions.assertEquals("yes", results.next().getProperty("value"));
- Assertions.assertFalse(results.hasNext());
+ assertThat(results.hasNext()).isTrue();
+ assertThat(results.next().getProperty("value")).isEqualTo("yes");
+ assertThat(results.hasNext()).isFalse();
results.close();
}
}
diff --git a/engine/src/test/java/com/arcadedb/query/sql/executor/InsertStatementExecutionTest.java b/engine/src/test/java/com/arcadedb/query/sql/executor/InsertStatementExecutionTest.java
index 9cd0fd6864..d4ac135708 100644
--- a/engine/src/test/java/com/arcadedb/query/sql/executor/InsertStatementExecutionTest.java
+++ b/engine/src/test/java/com/arcadedb/query/sql/executor/InsertStatementExecutionTest.java
@@ -22,11 +22,14 @@
import com.arcadedb.database.EmbeddedDocument;
import com.arcadedb.database.Identifiable;
import com.arcadedb.database.MutableDocument;
-import org.junit.jupiter.api.Assertions;
+
import org.junit.jupiter.api.Test;
import java.util.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
/**
* @author Luigi Dell'Aquila (l.dellaquila-(at)-orientdb.com)
*/
@@ -43,21 +46,21 @@ public void testInsertSet() {
ResultSet result = database.command("sql", "insert into " + className + " set name = 'name1'");
for (int i = 0; i < 1; i++) {
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result item = result.next();
- Assertions.assertNotNull(item);
- Assertions.assertEquals("name1", item.getProperty("name"));
+ assertThat(item).isNotNull();
+ assertThat(item.getProperty("name")).isEqualTo("name1");
}
- Assertions.assertFalse(result.hasNext());
+ assertThat(result.hasNext()).isFalse();
result = database.query("sql", "select from " + className);
for (int i = 0; i < 1; i++) {
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result item = result.next();
- Assertions.assertNotNull(item);
- Assertions.assertEquals("name1", item.getProperty("name"));
+ assertThat(item).isNotNull();
+ assertThat(item.getProperty("name")).isEqualTo("name1");
}
- Assertions.assertFalse(result.hasNext());
+ assertThat(result.hasNext()).isFalse();
result.close();
}
@@ -69,22 +72,22 @@ public void testInsertValue() {
ResultSet result = database.command("sql", "insert into " + className + " (name, surname) values ('name1', 'surname1')");
for (int i = 0; i < 1; i++) {
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result item = result.next();
- Assertions.assertNotNull(item);
- Assertions.assertEquals("name1", item.getProperty("name"));
- Assertions.assertEquals("surname1", item.getProperty("surname"));
+ assertThat(item).isNotNull();
+ assertThat(item.getProperty("name")).isEqualTo("name1");
+ assertThat(item.getProperty("surname")).isEqualTo("surname1");
}
- Assertions.assertFalse(result.hasNext());
+ assertThat(result.hasNext()).isFalse();
result = database.query("sql", "select from " + className);
for (int i = 0; i < 1; i++) {
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result item = result.next();
- Assertions.assertNotNull(item);
- Assertions.assertEquals("name1", item.getProperty("name"));
+ assertThat(item).isNotNull();
+ assertThat(item.getProperty("name")).isEqualTo("name1");
}
- Assertions.assertFalse(result.hasNext());
+ assertThat(result.hasNext()).isFalse();
result.close();
}
@@ -97,28 +100,28 @@ public void testInsertValue2() {
"insert into " + className + " (name, surname) values ('name1', 'surname1'), ('name2', 'surname2')");
for (int i = 0; i < 2; i++) {
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result item = result.next();
- Assertions.assertNotNull(item);
- Assertions.assertEquals("name" + (i + 1), item.getProperty("name"));
- Assertions.assertEquals("surname" + (i + 1), item.getProperty("surname"));
+ assertThat(item).isNotNull();
+ assertThat(item.getProperty("name")).isEqualTo("name" + (i + 1));
+ assertThat(item.getProperty("surname")).isEqualTo("surname" + (i + 1));
}
- Assertions.assertFalse(result.hasNext());
+ assertThat(result.hasNext()).isFalse();
final Set names = new HashSet<>();
names.add("name1");
names.add("name2");
result = database.query("sql", "select from " + className);
for (int i = 0; i < 2; i++) {
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result item = result.next();
- Assertions.assertNotNull(item);
- Assertions.assertNotNull(item.getProperty("name"));
- names.remove(item.getProperty("name"));
- Assertions.assertNotNull(item.getProperty("surname"));
+ assertThat(item).isNotNull();
+ assertThat(item.getProperty("name")).isNotNull();
+ names.remove(item.getProperty("name"));
+ assertThat(item.getProperty("surname")).isNotNull();
}
- Assertions.assertFalse(result.hasNext());
- Assertions.assertTrue(names.isEmpty());
+ assertThat(result.hasNext()).isFalse();
+ assertThat(names.isEmpty()).isTrue();
result.close();
}
@@ -138,13 +141,13 @@ public void testInsertFromSelect1() {
ResultSet result = database.command("sql", "insert into " + className2 + " from select from " + className1);
for (int i = 0; i < 10; i++) {
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result item = result.next();
- Assertions.assertNotNull(item);
- Assertions.assertNotNull(item.getProperty("name"));
- Assertions.assertNotNull(item.getProperty("surname"));
+ assertThat(item).isNotNull();
+ assertThat(item.getProperty("name")).isNotNull();
+ assertThat(item.getProperty("surname")).isNotNull();
}
- Assertions.assertFalse(result.hasNext());
+ assertThat(result.hasNext()).isFalse();
final Set names = new HashSet<>();
for (int i = 0; i < 10; i++) {
@@ -152,15 +155,15 @@ public void testInsertFromSelect1() {
}
result = database.query("sql", "select from " + className2);
for (int i = 0; i < 10; i++) {
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result item = result.next();
- Assertions.assertNotNull(item);
- Assertions.assertNotNull(item.getProperty("name"));
- names.remove(item.getProperty("name"));
- Assertions.assertNotNull(item.getProperty("surname"));
+ assertThat(item).isNotNull();
+ assertThat(item.getProperty("name")).isNotNull();
+ names.remove(item.getProperty("name"));
+ assertThat(item.getProperty("surname")).isNotNull();
}
- Assertions.assertFalse(result.hasNext());
- Assertions.assertTrue(names.isEmpty());
+ assertThat(result.hasNext()).isFalse();
+ assertThat(names.isEmpty()).isTrue();
result.close();
}
@@ -180,13 +183,13 @@ public void testInsertFromSelect2() {
ResultSet result = database.command("sql", "insert into " + className2 + " ( select from " + className1 + ")");
for (int i = 0; i < 10; i++) {
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result item = result.next();
- Assertions.assertNotNull(item);
- Assertions.assertNotNull(item.getProperty("name"));
- Assertions.assertNotNull(item.getProperty("surname"));
+ assertThat(item).isNotNull();
+ assertThat(item.getProperty("name")).isNotNull();
+ assertThat(item.getProperty("surname")).isNotNull();
}
- Assertions.assertFalse(result.hasNext());
+ assertThat(result.hasNext()).isFalse();
final Set names = new HashSet<>();
for (int i = 0; i < 10; i++) {
@@ -194,15 +197,15 @@ public void testInsertFromSelect2() {
}
result = database.query("sql", "select from " + className2);
for (int i = 0; i < 10; i++) {
- Assertions.assertTrue(result.hasNext());
+ assertThat(result.hasNext()).isTrue();
final Result item = result.next();
- Assertions.assertNotNull(item);
- Assertions.assertNotNull(item.getProperty("name"));
- names.remove(item.getProperty("name"));
- Assertions.assertNotNull(item.getProperty("surname"));
+ assertThat(item).isNotNull();
+ assertThat(item.