You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iceberg.apache.org by et...@apache.org on 2024/06/18 09:52:45 UTC
(iceberg) branch main updated: Spark: Import Assertions statically (#10531)
This is an automated email from the ASF dual-hosted git repository.
etudenhoefner pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/iceberg.git
The following commit(s) were added to refs/heads/main by this push:
new 316f0a11bf Spark: Import Assertions statically (#10531)
316f0a11bf is described below
commit 316f0a11bf5aa3d24cf7cb0c649960e42c312b36
Author: Piotr Findeisen <pi...@gmail.com>
AuthorDate: Tue Jun 18 11:52:40 2024 +0200
Spark: Import Assertions statically (#10531)
---
.../spark/extensions/TestAddFilesProcedure.java | 14 +--
.../extensions/TestAlterTablePartitionFields.java | 27 ++---
.../spark/extensions/TestAlterTableSchema.java | 17 ++-
.../spark/extensions/TestAncestorsOfProcedure.java | 10 +-
.../iceberg/spark/extensions/TestBranchDDL.java | 65 ++++++------
.../spark/extensions/TestCallStatementParser.java | 5 +-
.../spark/extensions/TestChangelogTable.java | 5 +-
.../TestCherrypickSnapshotProcedure.java | 17 ++-
.../spark/extensions/TestConflictValidation.java | 21 ++--
.../spark/extensions/TestCopyOnWriteDelete.java | 4 +-
.../spark/extensions/TestCopyOnWriteMerge.java | 4 +-
.../spark/extensions/TestCopyOnWriteUpdate.java | 4 +-
.../iceberg/spark/extensions/TestDelete.java | 25 +++--
.../extensions/TestExpireSnapshotsProcedure.java | 45 ++++----
.../apache/iceberg/spark/extensions/TestMerge.java | 87 ++++++++--------
.../spark/extensions/TestMergeOnReadDelete.java | 5 +-
.../TestMetaColumnProjectionWithStageScan.java | 5 +-
.../extensions/TestMigrateTableProcedure.java | 12 +--
.../extensions/TestPublishChangesProcedure.java | 13 ++-
.../extensions/TestRemoveOrphanFilesProcedure.java | 55 +++++-----
.../spark/extensions/TestReplaceBranch.java | 7 +-
.../TestRequiredDistributionAndOrdering.java | 5 +-
.../extensions/TestRewriteDataFilesProcedure.java | 35 +++----
.../extensions/TestRewriteManifestsProcedure.java | 16 ++-
.../TestRewritePositionDeleteFilesProcedure.java | 6 +-
.../TestRollbackToSnapshotProcedure.java | 24 ++---
.../TestRollbackToTimestampProcedure.java | 20 ++--
.../TestSetCurrentSnapshotProcedure.java | 25 ++---
.../TestSetWriteDistributionAndOrdering.java | 7 +-
.../extensions/TestSnapshotTableProcedure.java | 13 +--
.../iceberg/spark/extensions/TestTagDDL.java | 28 +++--
.../iceberg/spark/extensions/TestUpdate.java | 37 +++----
.../iceberg/spark/extensions/TestWriteAborts.java | 5 +-
.../apache/iceberg/TestDataFileSerialization.java | 6 +-
.../iceberg/TestManifestFileSerialization.java | 6 +-
.../apache/iceberg/TestScanTaskSerialization.java | 14 +--
.../java/org/apache/iceberg/ValidationHelpers.java | 5 +-
.../apache/iceberg/spark/TestFunctionCatalog.java | 18 ++--
.../apache/iceberg/spark/TestSparkTableUtil.java | 7 +-
.../actions/TestDeleteReachableFilesAction.java | 7 +-
.../spark/actions/TestExpireSnapshotsAction.java | 7 +-
.../spark/actions/TestRemoveOrphanFilesAction.java | 19 ++--
.../spark/actions/TestRewriteDataFilesAction.java | 26 ++---
.../spark/actions/TestRewriteManifestsAction.java | 4 +-
.../spark/actions/TestSparkFileRewriter.java | 47 ++++-----
.../apache/iceberg/spark/data/GenericsHelpers.java | 100 +++++++-----------
.../org/apache/iceberg/spark/data/TestHelpers.java | 110 ++++++++------------
.../iceberg/spark/data/TestSparkParquetReader.java | 4 +-
.../vectorized/TestParquetVectorizedReads.java | 7 +-
.../spark/source/TestDataFrameWriterV2.java | 7 +-
.../iceberg/spark/source/TestDataFrameWrites.java | 5 +-
.../spark/source/TestDataSourceOptions.java | 13 +--
.../iceberg/spark/source/TestFilteredScan.java | 4 +-
.../spark/source/TestForwardCompatibility.java | 6 +-
.../spark/source/TestIcebergSourceTablesBase.java | 9 +-
.../iceberg/spark/source/TestIcebergSpark.java | 9 +-
.../TestMetadataTablesWithPartitionEvolution.java | 4 +-
.../iceberg/spark/source/TestPathIdentifier.java | 7 +-
.../iceberg/spark/source/TestReadProjection.java | 5 +-
.../TestRequiredDistributionAndOrdering.java | 7 +-
.../spark/source/TestSnapshotSelection.java | 23 +++--
.../source/TestSparkCatalogCacheExpiration.java | 24 ++---
.../iceberg/spark/source/TestSparkDataWrite.java | 7 +-
.../spark/source/TestSparkMetadataColumns.java | 6 +-
.../spark/source/TestStructuredStreaming.java | 4 +-
.../spark/source/TestStructuredStreamingRead3.java | 38 +++----
.../spark/source/TestTimestampWithoutZone.java | 6 +-
.../spark/source/TestWriteMetricsConfig.java | 5 +-
.../iceberg/spark/sql/TestAggregatePushDown.java | 17 ++-
.../apache/iceberg/spark/sql/TestAlterTable.java | 12 +--
.../apache/iceberg/spark/sql/TestCreateTable.java | 21 ++--
.../apache/iceberg/spark/sql/TestDeleteFrom.java | 6 +-
.../apache/iceberg/spark/sql/TestDropTable.java | 5 +-
.../iceberg/spark/sql/TestFilterPushDown.java | 11 +-
.../apache/iceberg/spark/sql/TestNamespaceSQL.java | 5 +-
.../sql/TestPartitionedWritesToWapBranch.java | 8 +-
.../org/apache/iceberg/spark/sql/TestSelect.java | 21 ++--
.../iceberg/spark/sql/TestSparkBucketFunction.java | 61 +++++------
.../iceberg/spark/sql/TestSparkDaysFunction.java | 11 +-
.../iceberg/spark/sql/TestSparkHoursFunction.java | 11 +-
.../iceberg/spark/sql/TestSparkMonthsFunction.java | 16 +--
.../spark/sql/TestSparkTruncateFunction.java | 53 +++++-----
.../iceberg/spark/sql/TestSparkYearsFunction.java | 16 +--
.../spark/sql/TestTimestampWithoutZone.java | 6 +-
.../spark/sql/TestUnpartitionedWritesToBranch.java | 5 +-
.../spark/sql/UnpartitionedWritesTestBase.java | 7 +-
.../spark/extensions/TestAddFilesProcedure.java | 14 +--
.../extensions/TestAlterTablePartitionFields.java | 27 ++---
.../spark/extensions/TestAlterTableSchema.java | 17 ++-
.../spark/extensions/TestAncestorsOfProcedure.java | 10 +-
.../iceberg/spark/extensions/TestBranchDDL.java | 65 ++++++------
.../spark/extensions/TestCallStatementParser.java | 5 +-
.../spark/extensions/TestChangelogTable.java | 5 +-
.../TestCherrypickSnapshotProcedure.java | 17 ++-
.../spark/extensions/TestConflictValidation.java | 21 ++--
.../spark/extensions/TestCopyOnWriteDelete.java | 4 +-
.../spark/extensions/TestCopyOnWriteMerge.java | 4 +-
.../spark/extensions/TestCopyOnWriteUpdate.java | 4 +-
.../iceberg/spark/extensions/TestDelete.java | 33 +++---
.../extensions/TestExpireSnapshotsProcedure.java | 45 ++++----
.../apache/iceberg/spark/extensions/TestMerge.java | 91 ++++++++--------
.../spark/extensions/TestMergeOnReadDelete.java | 5 +-
.../TestMetaColumnProjectionWithStageScan.java | 5 +-
.../extensions/TestMigrateTableProcedure.java | 17 +--
.../extensions/TestPublishChangesProcedure.java | 13 ++-
.../extensions/TestRemoveOrphanFilesProcedure.java | 55 +++++-----
.../spark/extensions/TestReplaceBranch.java | 7 +-
.../TestRequiredDistributionAndOrdering.java | 5 +-
.../extensions/TestRewriteDataFilesProcedure.java | 35 +++----
.../extensions/TestRewriteManifestsProcedure.java | 16 ++-
.../TestRewritePositionDeleteFilesProcedure.java | 6 +-
.../TestRollbackToSnapshotProcedure.java | 24 ++---
.../TestRollbackToTimestampProcedure.java | 20 ++--
.../TestSetCurrentSnapshotProcedure.java | 29 +++---
.../TestSetWriteDistributionAndOrdering.java | 4 +-
.../extensions/TestSnapshotTableProcedure.java | 13 +--
...toragePartitionedJoinsInRowLevelOperations.java | 10 +-
.../extensions/TestSystemFunctionPushDownDQL.java | 28 ++---
.../iceberg/spark/extensions/TestTagDDL.java | 28 +++--
.../iceberg/spark/extensions/TestUpdate.java | 42 ++++----
.../iceberg/spark/extensions/TestWriteAborts.java | 5 +-
.../java/org/apache/iceberg/spark/SmokeTest.java | 5 +-
.../apache/iceberg/TestDataFileSerialization.java | 6 +-
.../iceberg/TestManifestFileSerialization.java | 6 +-
.../apache/iceberg/TestScanTaskSerialization.java | 14 +--
.../java/org/apache/iceberg/ValidationHelpers.java | 5 +-
.../apache/iceberg/spark/TestFunctionCatalog.java | 18 ++--
.../org/apache/iceberg/spark/TestSpark3Util.java | 19 ++--
.../apache/iceberg/spark/TestSparkTableUtil.java | 7 +-
.../apache/iceberg/spark/TestSparkV2Filters.java | 32 +++---
.../actions/TestDeleteReachableFilesAction.java | 7 +-
.../spark/actions/TestExpireSnapshotsAction.java | 7 +-
.../spark/actions/TestRemoveOrphanFilesAction.java | 19 ++--
.../spark/actions/TestRewriteDataFilesAction.java | 28 ++---
.../spark/actions/TestRewriteManifestsAction.java | 10 +-
.../spark/actions/TestSparkFileRewriter.java | 47 ++++-----
.../apache/iceberg/spark/data/GenericsHelpers.java | 104 ++++++++-----------
.../org/apache/iceberg/spark/data/TestHelpers.java | 114 ++++++++-------------
.../iceberg/spark/data/TestSparkParquetReader.java | 4 +-
.../vectorized/TestParquetVectorizedReads.java | 7 +-
.../spark/functions/TestSparkFunctions.java | 9 +-
.../spark/source/TestCompressionSettings.java | 8 +-
.../spark/source/TestDataFrameWriterV2.java | 8 +-
.../iceberg/spark/source/TestDataFrameWrites.java | 5 +-
.../spark/source/TestDataSourceOptions.java | 13 +--
.../iceberg/spark/source/TestFilteredScan.java | 4 +-
.../spark/source/TestForwardCompatibility.java | 6 +-
.../spark/source/TestIcebergSourceTablesBase.java | 9 +-
.../iceberg/spark/source/TestIcebergSpark.java | 9 +-
.../TestMetadataTablesWithPartitionEvolution.java | 4 +-
.../iceberg/spark/source/TestPathIdentifier.java | 7 +-
.../iceberg/spark/source/TestReadProjection.java | 5 +-
.../TestRequiredDistributionAndOrdering.java | 5 +-
.../spark/source/TestSnapshotSelection.java | 23 +++--
.../source/TestSparkCatalogCacheExpiration.java | 24 ++---
.../iceberg/spark/source/TestSparkDataWrite.java | 7 +-
.../spark/source/TestSparkMetadataColumns.java | 6 +-
.../iceberg/spark/source/TestSparkReadMetrics.java | 98 +++++++++---------
.../apache/iceberg/spark/source/TestSparkScan.java | 92 ++++++++---------
.../spark/source/TestStructuredStreaming.java | 4 +-
.../spark/source/TestStructuredStreamingRead3.java | 38 +++----
.../spark/source/TestWriteMetricsConfig.java | 5 +-
.../iceberg/spark/sql/TestAggregatePushDown.java | 17 ++-
.../apache/iceberg/spark/sql/TestCreateTable.java | 21 ++--
.../iceberg/spark/sql/TestCreateTableAsSelect.java | 4 +-
.../apache/iceberg/spark/sql/TestDeleteFrom.java | 6 +-
.../apache/iceberg/spark/sql/TestDropTable.java | 5 +-
.../iceberg/spark/sql/TestFilterPushDown.java | 10 +-
.../apache/iceberg/spark/sql/TestNamespaceSQL.java | 5 +-
.../sql/TestPartitionedWritesToWapBranch.java | 8 +-
.../org/apache/iceberg/spark/sql/TestSelect.java | 21 ++--
.../iceberg/spark/sql/TestSparkBucketFunction.java | 61 +++++------
.../iceberg/spark/sql/TestSparkDaysFunction.java | 11 +-
.../iceberg/spark/sql/TestSparkHoursFunction.java | 11 +-
.../iceberg/spark/sql/TestSparkMonthsFunction.java | 16 +--
.../spark/sql/TestSparkTruncateFunction.java | 53 +++++-----
.../iceberg/spark/sql/TestSparkYearsFunction.java | 16 +--
.../spark/sql/TestTimestampWithoutZone.java | 13 +--
.../spark/sql/TestUnpartitionedWritesToBranch.java | 5 +-
.../spark/sql/UnpartitionedWritesTestBase.java | 7 +-
.../spark/extensions/TestAddFilesProcedure.java | 14 +--
.../spark/extensions/TestAlterTableSchema.java | 16 ++-
.../spark/extensions/TestAncestorsOfProcedure.java | 10 +-
.../iceberg/spark/extensions/TestBranchDDL.java | 25 ++---
.../spark/extensions/TestCallStatementParser.java | 4 +-
.../spark/extensions/TestChangelogTable.java | 5 +-
.../TestCherrypickSnapshotProcedure.java | 17 ++-
.../spark/extensions/TestConflictValidation.java | 21 ++--
.../spark/extensions/TestCopyOnWriteDelete.java | 4 +-
.../spark/extensions/TestCopyOnWriteMerge.java | 4 +-
.../spark/extensions/TestCopyOnWriteUpdate.java | 4 +-
.../iceberg/spark/extensions/TestDelete.java | 13 ++-
.../extensions/TestExpireSnapshotsProcedure.java | 26 ++---
.../apache/iceberg/spark/extensions/TestMerge.java | 94 ++++++++---------
.../spark/extensions/TestMergeOnReadDelete.java | 5 +-
.../extensions/TestMigrateTableProcedure.java | 11 +-
.../extensions/TestPublishChangesProcedure.java | 13 ++-
.../extensions/TestRemoveOrphanFilesProcedure.java | 30 +++---
.../spark/extensions/TestReplaceBranch.java | 6 +-
.../TestRequiredDistributionAndOrdering.java | 5 +-
.../extensions/TestRewriteDataFilesProcedure.java | 35 +++----
.../extensions/TestRewriteManifestsProcedure.java | 16 ++-
.../TestRollbackToSnapshotProcedure.java | 23 ++---
.../TestRollbackToTimestampProcedure.java | 19 ++--
.../TestSetCurrentSnapshotProcedure.java | 29 +++---
.../TestSetWriteDistributionAndOrdering.java | 4 +-
.../extensions/TestSnapshotTableProcedure.java | 12 +--
.../iceberg/spark/extensions/TestTagDDL.java | 28 +++--
.../iceberg/spark/extensions/TestUpdate.java | 45 ++++----
.../iceberg/spark/extensions/TestWriteAborts.java | 5 +-
.../java/org/apache/iceberg/spark/SmokeTest.java | 37 +++----
.../apache/iceberg/spark/SparkTestHelperBase.java | 17 ++-
.../spark/actions/TestRewriteDataFilesAction.java | 3 +-
.../spark/actions/TestSparkFileRewriter.java | 74 +++++++------
.../spark/functions/TestSparkFunctions.java | 9 +-
.../iceberg/spark/sql/TestAggregatePushDown.java | 15 +--
.../apache/iceberg/spark/sql/TestCreateTable.java | 19 ++--
.../apache/iceberg/spark/sql/TestDeleteFrom.java | 5 +-
.../apache/iceberg/spark/sql/TestDropTable.java | 4 +-
.../apache/iceberg/spark/sql/TestNamespaceSQL.java | 4 +-
.../sql/TestPartitionedWritesToWapBranch.java | 8 +-
.../iceberg/spark/sql/TestSparkBucketFunction.java | 59 +++++------
.../spark/sql/UnpartitionedWritesTestBase.java | 6 +-
223 files changed, 1968 insertions(+), 2238 deletions(-)
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAddFilesProcedure.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAddFilesProcedure.java
index aab2ae65d0..b17ffddf82 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAddFilesProcedure.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAddFilesProcedure.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.extensions;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.File;
import java.io.IOException;
@@ -47,7 +48,6 @@ import org.apache.spark.sql.types.DataTypes;
import org.apache.spark.sql.types.Metadata;
import org.apache.spark.sql.types.StructField;
import org.apache.spark.sql.types.StructType;
-import org.assertj.core.api.Assertions;
import org.joda.time.DateTime;
import org.junit.After;
import org.junit.Assert;
@@ -688,7 +688,7 @@ public class TestAddFilesProcedure extends SparkExtensionsTestBase {
createIcebergTable("id Integer, name String, dept String, subdept String");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
scalarSql(
"CALL %s.system.add_files('%s', '`parquet`.`%s`', map('id', 1))",
@@ -697,7 +697,7 @@ public class TestAddFilesProcedure extends SparkExtensionsTestBase {
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Cannot use partition filter with an unpartitioned table");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
scalarSql(
"CALL %s.system.add_files('%s', '`parquet`.`%s`')",
@@ -714,7 +714,7 @@ public class TestAddFilesProcedure extends SparkExtensionsTestBase {
createIcebergTable(
"id Integer, name String, dept String, subdept String", "PARTITIONED BY (id)");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
scalarSql(
"CALL %s.system.add_files('%s', '`parquet`.`%s`', map('x', '1', 'y', '2'))",
@@ -723,7 +723,7 @@ public class TestAddFilesProcedure extends SparkExtensionsTestBase {
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("is greater than the number of partitioned columns");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
scalarSql(
"CALL %s.system.add_files('%s', '`parquet`.`%s`', map('dept', '2'))",
@@ -783,7 +783,7 @@ public class TestAddFilesProcedure extends SparkExtensionsTestBase {
+ "partition_filter => map('id', 1))",
catalogName, tableName, sourceTableName);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
scalarSql(
"CALL %s.system.add_files("
@@ -843,7 +843,7 @@ public class TestAddFilesProcedure extends SparkExtensionsTestBase {
sql("CALL %s.system.add_files('%s', '%s')", catalogName, tableName, sourceTableName);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
scalarSql(
"CALL %s.system.add_files('%s', '%s')",
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAlterTablePartitionFields.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAlterTablePartitionFields.java
index 948fc462de..2c109f1007 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAlterTablePartitionFields.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAlterTablePartitionFields.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThat;
+
import org.apache.iceberg.PartitionSpec;
import org.apache.iceberg.Table;
import org.apache.iceberg.TableProperties;
@@ -27,7 +29,6 @@ import org.apache.iceberg.spark.source.SparkTable;
import org.apache.spark.sql.connector.catalog.CatalogManager;
import org.apache.spark.sql.connector.catalog.Identifier;
import org.apache.spark.sql.connector.catalog.TableCatalog;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
@@ -185,9 +186,7 @@ public class TestAlterTablePartitionFields extends SparkExtensionsTestBase {
createTable("id bigint NOT NULL, category string, ts timestamp, data string");
Table table = validationCatalog.loadTable(tableIdent);
- Assertions.assertThat(table.spec().isUnpartitioned())
- .as("Table should start unpartitioned")
- .isTrue();
+ assertThat(table.spec().isUnpartitioned()).as("Table should start unpartitioned").isTrue();
sql("ALTER TABLE %s ADD PARTITION FIELD year(ts)", tableName);
@@ -196,7 +195,7 @@ public class TestAlterTablePartitionFields extends SparkExtensionsTestBase {
PartitionSpec expected =
PartitionSpec.builderFor(table.schema()).withSpecId(1).year("ts").build();
- Assertions.assertThat(table.spec()).as("Should have new spec field").isEqualTo(expected);
+ assertThat(table.spec()).as("Should have new spec field").isEqualTo(expected);
}
@Test
@@ -204,9 +203,7 @@ public class TestAlterTablePartitionFields extends SparkExtensionsTestBase {
createTable("id bigint NOT NULL, category string, ts timestamp, data string");
Table table = validationCatalog.loadTable(tableIdent);
- Assertions.assertThat(table.spec().isUnpartitioned())
- .as("Table should start unpartitioned")
- .isTrue();
+ assertThat(table.spec().isUnpartitioned()).as("Table should start unpartitioned").isTrue();
sql("ALTER TABLE %s ADD PARTITION FIELD month(ts)", tableName);
@@ -215,7 +212,7 @@ public class TestAlterTablePartitionFields extends SparkExtensionsTestBase {
PartitionSpec expected =
PartitionSpec.builderFor(table.schema()).withSpecId(1).month("ts").build();
- Assertions.assertThat(table.spec()).as("Should have new spec field").isEqualTo(expected);
+ assertThat(table.spec()).as("Should have new spec field").isEqualTo(expected);
}
@Test
@@ -223,9 +220,7 @@ public class TestAlterTablePartitionFields extends SparkExtensionsTestBase {
createTable("id bigint NOT NULL, category string, ts timestamp, data string");
Table table = validationCatalog.loadTable(tableIdent);
- Assertions.assertThat(table.spec().isUnpartitioned())
- .as("Table should start unpartitioned")
- .isTrue();
+ assertThat(table.spec().isUnpartitioned()).as("Table should start unpartitioned").isTrue();
sql("ALTER TABLE %s ADD PARTITION FIELD day(ts)", tableName);
@@ -234,7 +229,7 @@ public class TestAlterTablePartitionFields extends SparkExtensionsTestBase {
PartitionSpec expected =
PartitionSpec.builderFor(table.schema()).withSpecId(1).day("ts").build();
- Assertions.assertThat(table.spec()).as("Should have new spec field").isEqualTo(expected);
+ assertThat(table.spec()).as("Should have new spec field").isEqualTo(expected);
}
@Test
@@ -242,9 +237,7 @@ public class TestAlterTablePartitionFields extends SparkExtensionsTestBase {
createTable("id bigint NOT NULL, category string, ts timestamp, data string");
Table table = validationCatalog.loadTable(tableIdent);
- Assertions.assertThat(table.spec().isUnpartitioned())
- .as("Table should start unpartitioned")
- .isTrue();
+ assertThat(table.spec().isUnpartitioned()).as("Table should start unpartitioned").isTrue();
sql("ALTER TABLE %s ADD PARTITION FIELD hour(ts)", tableName);
@@ -253,7 +246,7 @@ public class TestAlterTablePartitionFields extends SparkExtensionsTestBase {
PartitionSpec expected =
PartitionSpec.builderFor(table.schema()).withSpecId(1).hour("ts").build();
- Assertions.assertThat(table.spec()).as("Should have new spec field").isEqualTo(expected);
+ assertThat(table.spec()).as("Should have new spec field").isEqualTo(expected);
}
@Test
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAlterTableSchema.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAlterTableSchema.java
index acbf5c7a63..da1b652e8a 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAlterTableSchema.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAlterTableSchema.java
@@ -18,10 +18,11 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.util.Map;
import org.apache.iceberg.Table;
import org.apache.iceberg.relocated.com.google.common.collect.Sets;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
@@ -77,13 +78,12 @@ public class TestAlterTableSchema extends SparkExtensionsTestBase {
Table table = validationCatalog.loadTable(tableIdent);
Assert.assertTrue(
"Table should start without identifier", table.schema().identifierFieldIds().isEmpty());
- Assertions.assertThatThrownBy(
- () -> sql("ALTER TABLE %s SET IDENTIFIER FIELDS unknown", tableName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s SET IDENTIFIER FIELDS unknown", tableName))
.as("should not allow setting unknown fields")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("not found in current schema or added columns");
- Assertions.assertThatThrownBy(() -> sql("ALTER TABLE %s SET IDENTIFIER FIELDS id2", tableName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s SET IDENTIFIER FIELDS id2", tableName))
.as("should not allow setting optional fields")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("not a required field");
@@ -139,21 +139,18 @@ public class TestAlterTableSchema extends SparkExtensionsTestBase {
Table table = validationCatalog.loadTable(tableIdent);
Assert.assertTrue(
"Table should start without identifier", table.schema().identifierFieldIds().isEmpty());
- Assertions.assertThatThrownBy(
- () -> sql("ALTER TABLE %s DROP IDENTIFIER FIELDS unknown", tableName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s DROP IDENTIFIER FIELDS unknown", tableName))
.as("should not allow dropping unknown fields")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("field unknown not found");
sql("ALTER TABLE %s SET IDENTIFIER FIELDS id", tableName);
- Assertions.assertThatThrownBy(
- () -> sql("ALTER TABLE %s DROP IDENTIFIER FIELDS data", tableName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s DROP IDENTIFIER FIELDS data", tableName))
.as("should not allow dropping a field that is not an identifier")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("data is not an identifier field");
- Assertions.assertThatThrownBy(
- () -> sql("ALTER TABLE %s DROP IDENTIFIER FIELDS location.lon", tableName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s DROP IDENTIFIER FIELDS location.lon", tableName))
.as("should not allow dropping a nested field that is not an identifier")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("location.lon is not an identifier field");
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAncestorsOfProcedure.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAncestorsOfProcedure.java
index 13fa96d1e0..d111cdb01b 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAncestorsOfProcedure.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAncestorsOfProcedure.java
@@ -18,12 +18,13 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.util.List;
import java.util.Map;
import org.apache.iceberg.Table;
import org.apache.iceberg.relocated.com.google.common.collect.ImmutableList;
import org.apache.spark.sql.AnalysisException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Test;
@@ -147,18 +148,17 @@ public class TestAncestorsOfProcedure extends SparkExtensionsTestBase {
@Test
public void testInvalidAncestorOfCases() {
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.ancestors_of()", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.ancestors_of()", catalogName))
.as("Should reject calls without all required args")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Missing required parameters");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.ancestors_of('')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.ancestors_of('')", catalogName))
.as("Should reject calls with empty table identifier")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Cannot handle an empty identifier for parameter 'table'");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.ancestors_of('%s', 1.1)", catalogName, tableIdent))
+ assertThatThrownBy(() -> sql("CALL %s.system.ancestors_of('%s', 1.1)", catalogName, tableIdent))
.as("Should reject calls with invalid arg types")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Wrong arg type for snapshot_id: cannot cast");
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestBranchDDL.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestBranchDDL.java
index 8f3e88f3c8..762ade9465 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestBranchDDL.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestBranchDDL.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.extensions;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.List;
import java.util.Map;
@@ -33,7 +34,6 @@ import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
import org.apache.spark.sql.catalyst.parser.extensions.IcebergParseException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
@@ -85,8 +85,7 @@ public class TestBranchDDL extends SparkExtensionsTestBase {
Assert.assertEquals(TimeUnit.DAYS.toMillis(maxSnapshotAge), ref.maxSnapshotAgeMs().longValue());
Assert.assertEquals(TimeUnit.DAYS.toMillis(maxRefAge), ref.maxRefAgeMs().longValue());
- Assertions.assertThatThrownBy(
- () -> sql("ALTER TABLE %s CREATE BRANCH %s", tableName, branchName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s CREATE BRANCH %s", tableName, branchName))
.as("Cannot create an existing branch")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Ref b1 already exists");
@@ -99,20 +98,20 @@ public class TestBranchDDL extends SparkExtensionsTestBase {
Table table = validationCatalog.loadTable(tableIdent);
SnapshotRef mainRef = table.refs().get(SnapshotRef.MAIN_BRANCH);
- Assertions.assertThat(mainRef).isNull();
+ assertThat(mainRef).isNull();
SnapshotRef ref = table.refs().get(branchName);
- Assertions.assertThat(ref).isNotNull();
- Assertions.assertThat(ref.minSnapshotsToKeep()).isNull();
- Assertions.assertThat(ref.maxSnapshotAgeMs()).isNull();
- Assertions.assertThat(ref.maxRefAgeMs()).isNull();
+ assertThat(ref).isNotNull();
+ assertThat(ref.minSnapshotsToKeep()).isNull();
+ assertThat(ref.maxSnapshotAgeMs()).isNull();
+ assertThat(ref.maxRefAgeMs()).isNull();
Snapshot snapshot = table.snapshot(ref.snapshotId());
- Assertions.assertThat(snapshot.parentId()).isNull();
- Assertions.assertThat(snapshot.addedDataFiles(table.io())).isEmpty();
- Assertions.assertThat(snapshot.removedDataFiles(table.io())).isEmpty();
- Assertions.assertThat(snapshot.addedDeleteFiles(table.io())).isEmpty();
- Assertions.assertThat(snapshot.removedDeleteFiles(table.io())).isEmpty();
+ assertThat(snapshot.parentId()).isNull();
+ assertThat(snapshot.addedDataFiles(table.io())).isEmpty();
+ assertThat(snapshot.removedDataFiles(table.io())).isEmpty();
+ assertThat(snapshot.addedDeleteFiles(table.io())).isEmpty();
+ assertThat(snapshot.removedDeleteFiles(table.io())).isEmpty();
}
@Test
@@ -195,7 +194,7 @@ public class TestBranchDDL extends SparkExtensionsTestBase {
Assert.assertEquals(TimeUnit.DAYS.toMillis(maxSnapshotAge), ref.maxSnapshotAgeMs().longValue());
Assert.assertNull(ref.maxRefAgeMs());
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"ALTER TABLE %s CREATE BRANCH %s WITH SNAPSHOT RETENTION",
@@ -218,20 +217,19 @@ public class TestBranchDDL extends SparkExtensionsTestBase {
Assert.assertNull(ref.maxSnapshotAgeMs());
Assert.assertEquals(TimeUnit.DAYS.toMillis(maxRefAge), ref.maxRefAgeMs().longValue());
- Assertions.assertThatThrownBy(
- () -> sql("ALTER TABLE %s CREATE BRANCH %s RETAIN", tableName, branchName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s CREATE BRANCH %s RETAIN", tableName, branchName))
.as("Illegal statement")
.isInstanceOf(IcebergParseException.class)
.hasMessageContaining("mismatched input");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql("ALTER TABLE %s CREATE BRANCH %s RETAIN %s DAYS", tableName, branchName, "abc"))
.as("Illegal statement")
.isInstanceOf(IcebergParseException.class)
.hasMessageContaining("mismatched input");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"ALTER TABLE %s CREATE BRANCH %s RETAIN %d SECONDS",
@@ -260,8 +258,7 @@ public class TestBranchDDL extends SparkExtensionsTestBase {
@Test
public void testDropBranchDoesNotExist() {
- Assertions.assertThatThrownBy(
- () -> sql("ALTER TABLE %s DROP BRANCH %s", tableName, "nonExistingBranch"))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s DROP BRANCH %s", tableName, "nonExistingBranch"))
.as("Cannot perform drop branch on branch which does not exist")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Branch does not exist: nonExistingBranch");
@@ -273,7 +270,7 @@ public class TestBranchDDL extends SparkExtensionsTestBase {
Table table = insertRows();
table.manageSnapshots().createTag(tagName, table.currentSnapshot().snapshotId()).commit();
- Assertions.assertThatThrownBy(() -> sql("ALTER TABLE %s DROP BRANCH %s", tableName, tagName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s DROP BRANCH %s", tableName, tagName))
.as("Cannot perform drop branch on tag")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Ref b1 is a tag not a branch");
@@ -281,7 +278,7 @@ public class TestBranchDDL extends SparkExtensionsTestBase {
@Test
public void testDropBranchNonConformingName() {
- Assertions.assertThatThrownBy(() -> sql("ALTER TABLE %s DROP BRANCH %s", tableName, "123"))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s DROP BRANCH %s", tableName, "123"))
.as("Non-conforming branch name")
.isInstanceOf(IcebergParseException.class)
.hasMessageContaining("mismatched input '123'");
@@ -289,7 +286,7 @@ public class TestBranchDDL extends SparkExtensionsTestBase {
@Test
public void testDropMainBranchFails() {
- Assertions.assertThatThrownBy(() -> sql("ALTER TABLE %s DROP BRANCH main", tableName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s DROP BRANCH main", tableName))
.as("Cannot drop the main branch")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Cannot remove main branch");
@@ -331,20 +328,20 @@ public class TestBranchDDL extends SparkExtensionsTestBase {
Table table = validationCatalog.loadTable(tableIdent);
SnapshotRef mainRef = table.refs().get(SnapshotRef.MAIN_BRANCH);
- Assertions.assertThat(mainRef).isNull();
+ assertThat(mainRef).isNull();
SnapshotRef ref = table.refs().get(branchName);
- Assertions.assertThat(ref).isNotNull();
- Assertions.assertThat(ref.minSnapshotsToKeep()).isNull();
- Assertions.assertThat(ref.maxSnapshotAgeMs()).isNull();
- Assertions.assertThat(ref.maxRefAgeMs()).isNull();
+ assertThat(ref).isNotNull();
+ assertThat(ref.minSnapshotsToKeep()).isNull();
+ assertThat(ref.maxSnapshotAgeMs()).isNull();
+ assertThat(ref.maxRefAgeMs()).isNull();
Snapshot snapshot = table.snapshot(ref.snapshotId());
- Assertions.assertThat(snapshot.parentId()).isNull();
- Assertions.assertThat(snapshot.addedDataFiles(table.io())).isEmpty();
- Assertions.assertThat(snapshot.removedDataFiles(table.io())).isEmpty();
- Assertions.assertThat(snapshot.addedDeleteFiles(table.io())).isEmpty();
- Assertions.assertThat(snapshot.removedDeleteFiles(table.io())).isEmpty();
+ assertThat(snapshot.parentId()).isNull();
+ assertThat(snapshot.addedDataFiles(table.io())).isEmpty();
+ assertThat(snapshot.removedDataFiles(table.io())).isEmpty();
+ assertThat(snapshot.addedDeleteFiles(table.io())).isEmpty();
+ assertThat(snapshot.removedDeleteFiles(table.io())).isEmpty();
}
@Test
@@ -387,7 +384,7 @@ public class TestBranchDDL extends SparkExtensionsTestBase {
public void replaceBranchDoesNotExist() throws NoSuchTableException {
Table table = insertRows();
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"ALTER TABLE %s REPLACE BRANCH %s AS OF VERSION %d",
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCallStatementParser.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCallStatementParser.java
index c0f7ff1f8f..42f29c28c1 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCallStatementParser.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCallStatementParser.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.math.BigDecimal;
import java.sql.Timestamp;
import java.time.Instant;
@@ -37,7 +39,6 @@ import org.apache.spark.sql.catalyst.plans.logical.NamedArgument;
import org.apache.spark.sql.catalyst.plans.logical.PositionalArgument;
import org.apache.spark.sql.types.DataType;
import org.apache.spark.sql.types.DataTypes;
-import org.assertj.core.api.Assertions;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
@@ -144,7 +145,7 @@ public class TestCallStatementParser {
@Test
public void testCallParseError() {
- Assertions.assertThatThrownBy(() -> parser.parsePlan("CALL cat.system radish kebab"))
+ assertThatThrownBy(() -> parser.parsePlan("CALL cat.system radish kebab"))
.as("Should fail with a sensible parse error")
.isInstanceOf(IcebergParseException.class)
.hasMessageContaining("missing '(' at 'radish'");
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestChangelogTable.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestChangelogTable.java
index 3b6ac57cc0..cf9ee47bbb 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestChangelogTable.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestChangelogTable.java
@@ -21,6 +21,7 @@ package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.TableProperties.FORMAT_VERSION;
import static org.apache.iceberg.TableProperties.MANIFEST_MERGE_ENABLED;
import static org.apache.iceberg.TableProperties.MANIFEST_MIN_MERGE_COUNT;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.List;
import java.util.Map;
@@ -34,7 +35,6 @@ import org.apache.iceberg.spark.SparkReadOptions;
import org.apache.iceberg.spark.source.SparkChangelogTable;
import org.apache.spark.sql.DataFrameReader;
import org.apache.spark.sql.Row;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
@@ -202,8 +202,7 @@ public class TestChangelogTable extends SparkExtensionsTestBase {
Snapshot snap3 = table.currentSnapshot();
long rightAfterSnap3 = waitUntilAfter(snap3.timestampMillis());
- Assertions.assertThatThrownBy(
- () -> changelogRecords(snap3.timestampMillis(), snap2.timestampMillis()))
+ assertThatThrownBy(() -> changelogRecords(snap3.timestampMillis(), snap2.timestampMillis()))
.as("Should fail if start time is after end time")
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Cannot set start-timestamp to be greater than end-timestamp for changelogs");
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCherrypickSnapshotProcedure.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCherrypickSnapshotProcedure.java
index cbecfcef3e..b489cf76f1 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCherrypickSnapshotProcedure.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCherrypickSnapshotProcedure.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.TableProperties.WRITE_AUDIT_PUBLISH_ENABLED;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.List;
import java.util.Map;
@@ -31,7 +32,6 @@ import org.apache.spark.sql.AnalysisException;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchProcedureException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Test;
@@ -161,7 +161,7 @@ public class TestCherrypickSnapshotProcedure extends SparkExtensionsTestBase {
public void testCherrypickInvalidSnapshot() {
sql("CREATE TABLE %s (id bigint NOT NULL, data string) USING iceberg", tableName);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.cherrypick_snapshot('%s', -1L)", catalogName, tableIdent))
.as("Should reject invalid snapshot id")
.isInstanceOf(ValidationException.class)
@@ -170,31 +170,28 @@ public class TestCherrypickSnapshotProcedure extends SparkExtensionsTestBase {
@Test
public void testInvalidCherrypickSnapshotCases() {
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.cherrypick_snapshot('n', table => 't', 1L)", catalogName))
.as("Should not allow mixed args")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Named and positional arguments cannot be mixed");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.custom.cherrypick_snapshot('n', 't', 1L)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.custom.cherrypick_snapshot('n', 't', 1L)", catalogName))
.as("Should not resolve procedures in arbitrary namespaces")
.isInstanceOf(NoSuchProcedureException.class)
.hasMessageContaining("not found");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.cherrypick_snapshot('t')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.cherrypick_snapshot('t')", catalogName))
.as("Should reject calls without all required args")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Missing required parameters");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.cherrypick_snapshot('', 1L)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.cherrypick_snapshot('', 1L)", catalogName))
.as("Should reject calls with empty table identifier")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Cannot handle an empty identifier");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.cherrypick_snapshot('t', 2.2)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.cherrypick_snapshot('t', 2.2)", catalogName))
.as("Should reject calls with invalid arg types")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Wrong arg type for snapshot_id: cannot cast");
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestConflictValidation.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestConflictValidation.java
index 7d18316757..a5e3a4bf33 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestConflictValidation.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestConflictValidation.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.util.List;
import java.util.Map;
import org.apache.iceberg.IsolationLevel;
@@ -30,7 +32,6 @@ import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
import org.apache.spark.sql.functions;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -69,7 +70,7 @@ public class TestConflictValidation extends SparkExtensionsTestBase {
// Validating from previous snapshot finds conflicts
Dataset<Row> conflictingDf = spark.createDataFrame(records, SimpleRecord.class);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
try {
conflictingDf
@@ -114,7 +115,7 @@ public class TestConflictValidation extends SparkExtensionsTestBase {
// Validating from previous snapshot finds conflicts
List<SimpleRecord> conflictingRecords = Lists.newArrayList(new SimpleRecord(1, "a"));
Dataset<Row> conflictingDf = spark.createDataFrame(conflictingRecords, SimpleRecord.class);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
try {
conflictingDf
@@ -154,7 +155,7 @@ public class TestConflictValidation extends SparkExtensionsTestBase {
// Validating from previous snapshot finds conflicts
List<SimpleRecord> conflictingRecords = Lists.newArrayList(new SimpleRecord(1, "a"));
Dataset<Row> conflictingDf = spark.createDataFrame(conflictingRecords, SimpleRecord.class);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
try {
conflictingDf
@@ -192,7 +193,7 @@ public class TestConflictValidation extends SparkExtensionsTestBase {
// Validating from no snapshot id defaults to beginning snapshot id and finds conflicts
Dataset<Row> conflictingDf = spark.createDataFrame(records, SimpleRecord.class);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
try {
conflictingDf
@@ -236,7 +237,7 @@ public class TestConflictValidation extends SparkExtensionsTestBase {
// Validating from previous snapshot finds conflicts
List<SimpleRecord> conflictingRecords = Lists.newArrayList(new SimpleRecord(1, "a"));
Dataset<Row> conflictingDf = spark.createDataFrame(conflictingRecords, SimpleRecord.class);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
try {
conflictingDf
@@ -291,7 +292,7 @@ public class TestConflictValidation extends SparkExtensionsTestBase {
// Validating from previous snapshot finds conflicts
Dataset<Row> conflictingDf = spark.createDataFrame(records, SimpleRecord.class);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
try {
conflictingDf
@@ -334,7 +335,7 @@ public class TestConflictValidation extends SparkExtensionsTestBase {
// Validating from previous snapshot finds conflicts
Dataset<Row> conflictingDf = spark.createDataFrame(records, SimpleRecord.class);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
try {
conflictingDf
@@ -375,7 +376,7 @@ public class TestConflictValidation extends SparkExtensionsTestBase {
spark.createDataFrame(records, SimpleRecord.class).coalesce(1).writeTo(tableName).append();
Dataset<Row> conflictingDf = spark.createDataFrame(records, SimpleRecord.class);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
try {
conflictingDf
@@ -429,7 +430,7 @@ public class TestConflictValidation extends SparkExtensionsTestBase {
// Validating from null snapshot is equivalent to validating from beginning
Dataset<Row> conflictingDf = spark.createDataFrame(records, SimpleRecord.class);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
try {
conflictingDf
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCopyOnWriteDelete.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCopyOnWriteDelete.java
index 53177340da..d0151ea402 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCopyOnWriteDelete.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCopyOnWriteDelete.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.TableProperties.DELETE_ISOLATION_LEVEL;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.Collections;
import java.util.Map;
@@ -47,7 +48,6 @@ import org.apache.iceberg.util.SnapshotUtil;
import org.apache.spark.sql.Encoders;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
import org.apache.spark.sql.internal.SQLConf;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Assume;
import org.junit.Test;
@@ -144,7 +144,7 @@ public class TestCopyOnWriteDelete extends TestDelete {
});
try {
- Assertions.assertThatThrownBy(deleteFuture::get)
+ assertThatThrownBy(deleteFuture::get)
.isInstanceOf(ExecutionException.class)
.cause()
.isInstanceOf(IllegalStateException.class)
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCopyOnWriteMerge.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCopyOnWriteMerge.java
index ed1e05f822..3f56d82d9b 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCopyOnWriteMerge.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCopyOnWriteMerge.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.TableProperties.MERGE_ISOLATION_LEVEL;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.Collections;
import java.util.Map;
@@ -45,7 +46,6 @@ import org.apache.iceberg.spark.SparkSQLProperties;
import org.apache.iceberg.util.SnapshotUtil;
import org.apache.spark.sql.Encoders;
import org.apache.spark.sql.internal.SQLConf;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Assume;
import org.junit.Test;
@@ -142,7 +142,7 @@ public class TestCopyOnWriteMerge extends TestMerge {
});
try {
- Assertions.assertThatThrownBy(mergeFuture::get)
+ assertThatThrownBy(mergeFuture::get)
.isInstanceOf(ExecutionException.class)
.cause()
.isInstanceOf(IllegalStateException.class)
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCopyOnWriteUpdate.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCopyOnWriteUpdate.java
index f9f48e8f41..a36787477a 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCopyOnWriteUpdate.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCopyOnWriteUpdate.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.TableProperties.UPDATE_ISOLATION_LEVEL;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.Map;
import java.util.concurrent.ExecutionException;
@@ -44,7 +45,6 @@ import org.apache.iceberg.spark.Spark3Util;
import org.apache.iceberg.spark.SparkSQLProperties;
import org.apache.iceberg.util.SnapshotUtil;
import org.apache.spark.sql.internal.SQLConf;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Assume;
import org.junit.Test;
@@ -140,7 +140,7 @@ public class TestCopyOnWriteUpdate extends TestUpdate {
});
try {
- Assertions.assertThatThrownBy(updateFuture::get)
+ assertThatThrownBy(updateFuture::get)
.isInstanceOf(ExecutionException.class)
.cause()
.isInstanceOf(IllegalStateException.class)
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestDelete.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestDelete.java
index af66df5a9f..beb3b01059 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestDelete.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestDelete.java
@@ -28,6 +28,7 @@ import static org.apache.iceberg.TableProperties.PARQUET_ROW_GROUP_SIZE_BYTES;
import static org.apache.iceberg.TableProperties.SPLIT_SIZE;
import static org.apache.spark.sql.functions.lit;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assumptions.assumeThat;
import java.util.Arrays;
@@ -73,7 +74,6 @@ import org.apache.spark.sql.catalyst.plans.logical.DeleteFromIcebergTable;
import org.apache.spark.sql.catalyst.plans.logical.LogicalPlan;
import org.apache.spark.sql.execution.datasources.v2.OptimizeMetadataOnlyDeleteFromIcebergTable;
import org.apache.spark.sql.internal.SQLConf;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Assume;
@@ -240,7 +240,7 @@ public abstract class TestDelete extends SparkRowLevelOperationsTestBase {
Assume.assumeTrue("Test only applicable to custom branch", "test".equals(branch));
createAndInitUnpartitionedTable();
- Assertions.assertThatThrownBy(() -> sql("DELETE FROM %s WHERE id IN (1)", commitTarget()))
+ assertThatThrownBy(() -> sql("DELETE FROM %s WHERE id IN (1)", commitTarget()))
.isInstanceOf(ValidationException.class)
.hasMessage("Cannot use branch (does not exist): test");
}
@@ -447,8 +447,7 @@ public abstract class TestDelete extends SparkRowLevelOperationsTestBase {
sql("INSERT INTO TABLE %s VALUES (1, 'hr'), (2, 'hardware')", tableName);
createBranchIfNeeded();
- Assertions.assertThatThrownBy(
- () -> sql("DELETE FROM %s WHERE id = 1 AND rand() > 0.5", commitTarget()))
+ assertThatThrownBy(() -> sql("DELETE FROM %s WHERE id = 1 AND rand() > 0.5", commitTarget()))
.as("Should complain about non-deterministic expressions")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("nondeterministic expressions are only allowed");
@@ -736,7 +735,7 @@ public abstract class TestDelete extends SparkRowLevelOperationsTestBase {
public void testDeleteOnNonIcebergTableNotSupported() {
createOrReplaceView("testtable", "{ \"c1\": -100, \"c2\": -200 }");
- Assertions.assertThatThrownBy(() -> sql("DELETE FROM %s WHERE c1 = -100", "testtable"))
+ assertThatThrownBy(() -> sql("DELETE FROM %s WHERE c1 = -100", "testtable"))
.as("Delete is supported only for Iceberg tables")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("DELETE is only supported with v2 tables.");
@@ -942,7 +941,7 @@ public abstract class TestDelete extends SparkRowLevelOperationsTestBase {
});
try {
- Assertions.assertThatThrownBy(deleteFuture::get)
+ assertThatThrownBy(deleteFuture::get)
.isInstanceOf(ExecutionException.class)
.cause()
.isInstanceOf(SparkException.class)
@@ -1184,7 +1183,7 @@ public abstract class TestDelete extends SparkRowLevelOperationsTestBase {
withSQLConf(
ImmutableMap.of(SparkSQLProperties.WAP_BRANCH, "wap"),
() ->
- Assertions.assertThatThrownBy(() -> sql("DELETE FROM %s t WHERE id=0", commitTarget()))
+ assertThatThrownBy(() -> sql("DELETE FROM %s t WHERE id=0", commitTarget()))
.isInstanceOf(ValidationException.class)
.hasMessage(
String.format(
@@ -1210,9 +1209,9 @@ public abstract class TestDelete extends SparkRowLevelOperationsTestBase {
ImmutableMap.of(SparkSQLProperties.WAP_BRANCH, branch),
() -> {
sql("DELETE FROM %s t WHERE id=1", tableName);
- Assertions.assertThat(spark.table(tableName).count()).isEqualTo(2L);
- Assertions.assertThat(spark.table(tableName + ".branch_" + branch).count()).isEqualTo(2L);
- Assertions.assertThat(spark.table(tableName + ".branch_main").count())
+ assertThat(spark.table(tableName).count()).isEqualTo(2L);
+ assertThat(spark.table(tableName + ".branch_" + branch).count()).isEqualTo(2L);
+ assertThat(spark.table(tableName + ".branch_main").count())
.as("Should not modify main branch")
.isEqualTo(3L);
});
@@ -1220,9 +1219,9 @@ public abstract class TestDelete extends SparkRowLevelOperationsTestBase {
ImmutableMap.of(SparkSQLProperties.WAP_BRANCH, branch),
() -> {
sql("DELETE FROM %s t", tableName);
- Assertions.assertThat(spark.table(tableName).count()).isEqualTo(0L);
- Assertions.assertThat(spark.table(tableName + ".branch_" + branch).count()).isEqualTo(0L);
- Assertions.assertThat(spark.table(tableName + ".branch_main").count())
+ assertThat(spark.table(tableName).count()).isEqualTo(0L);
+ assertThat(spark.table(tableName + ".branch_" + branch).count()).isEqualTo(0L);
+ assertThat(spark.table(tableName + ".branch_main").count())
.as("Should not modify main branch")
.isEqualTo(3L);
});
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestExpireSnapshotsProcedure.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestExpireSnapshotsProcedure.java
index f677facb99..e9f42f5e01 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestExpireSnapshotsProcedure.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestExpireSnapshotsProcedure.java
@@ -19,6 +19,8 @@
package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.TableProperties.GC_ENABLED;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.File;
import java.io.IOException;
@@ -51,7 +53,6 @@ import org.apache.iceberg.spark.source.SimpleRecord;
import org.apache.spark.sql.AnalysisException;
import org.apache.spark.sql.Encoders;
import org.apache.spark.sql.catalyst.analysis.NoSuchProcedureException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
@@ -162,8 +163,7 @@ public class TestExpireSnapshotsProcedure extends SparkExtensionsTestBase {
sql("ALTER TABLE %s SET TBLPROPERTIES ('%s' 'false')", tableName, GC_ENABLED);
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.expire_snapshots('%s')", catalogName, tableIdent))
+ assertThatThrownBy(() -> sql("CALL %s.system.expire_snapshots('%s')", catalogName, tableIdent))
.as("Should reject call")
.isInstanceOf(ValidationException.class)
.hasMessageContaining("Cannot expire snapshots: GC is disabled");
@@ -171,30 +171,27 @@ public class TestExpireSnapshotsProcedure extends SparkExtensionsTestBase {
@Test
public void testInvalidExpireSnapshotsCases() {
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.expire_snapshots('n', table => 't')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.expire_snapshots('n', table => 't')", catalogName))
.as("Should not allow mixed args")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Named and positional arguments cannot be mixed");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.custom.expire_snapshots('n', 't')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.custom.expire_snapshots('n', 't')", catalogName))
.as("Should not resolve procedures in arbitrary namespaces")
.isInstanceOf(NoSuchProcedureException.class)
.hasMessageContaining("not found");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.expire_snapshots()", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.expire_snapshots()", catalogName))
.as("Should reject calls without all required args")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Missing required parameters");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.expire_snapshots('n', 2.2)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.expire_snapshots('n', 2.2)", catalogName))
.as("Should reject calls with invalid arg types")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Wrong arg type");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.expire_snapshots('')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.expire_snapshots('')", catalogName))
.as("Should reject calls with empty table identifier")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Cannot handle an empty identifier");
@@ -215,7 +212,7 @@ public class TestExpireSnapshotsProcedure extends SparkExtensionsTestBase {
"CREATE TABLE %s.%s (id bigint NOT NULL, data string) USING iceberg",
anotherCatalog, tableIdent);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.expire_snapshots('%s')",
@@ -252,7 +249,7 @@ public class TestExpireSnapshotsProcedure extends SparkExtensionsTestBase {
public void testConcurrentExpireSnapshotsWithInvalidInput() {
sql("CREATE TABLE %s (id bigint NOT NULL, data string) USING iceberg", tableName);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.expire_snapshots(table => '%s', max_concurrent_deletes => %s)",
@@ -261,7 +258,7 @@ public class TestExpireSnapshotsProcedure extends SparkExtensionsTestBase {
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("max_concurrent_deletes should have value > 0");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.expire_snapshots(table => '%s', max_concurrent_deletes => %s)",
@@ -401,7 +398,7 @@ public class TestExpireSnapshotsProcedure extends SparkExtensionsTestBase {
Table table = validationCatalog.loadTable(tableIdent);
Assert.assertEquals("Should be 2 snapshots", 2, Iterables.size(table.snapshots()));
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.expire_snapshots("
@@ -481,21 +478,21 @@ public class TestExpireSnapshotsProcedure extends SparkExtensionsTestBase {
sql(
"CALL %s.system.expire_snapshots(older_than => TIMESTAMP '%s',table => '%s')",
catalogName, currentTimestamp, tableIdent);
- Assertions.assertThat(output.get(0)[5]).as("should be 1 deleted statistics file").isEqualTo(1L);
+ assertThat(output.get(0)[5]).as("should be 1 deleted statistics file").isEqualTo(1L);
table.refresh();
- Assertions.assertThat(table.statisticsFiles())
+ assertThat(table.statisticsFiles())
.as(
"Statistics file entry in TableMetadata should be present only for the snapshot %s",
statisticsFile2.snapshotId())
.extracting(StatisticsFile::snapshotId)
.containsExactly(statisticsFile2.snapshotId());
- Assertions.assertThat(new File(statsFileLocation1))
+ assertThat(new File(statsFileLocation1))
.as("Statistics file should not exist for snapshot %s", statisticsFile1.snapshotId())
.doesNotExist();
- Assertions.assertThat(new File(statsFileLocation2))
+ assertThat(new File(statsFileLocation2))
.as("Statistics file should exist for snapshot %s", statisticsFile2.snapshotId())
.exists();
}
@@ -526,25 +523,23 @@ public class TestExpireSnapshotsProcedure extends SparkExtensionsTestBase {
sql(
"CALL %s.system.expire_snapshots(older_than => TIMESTAMP '%s',table => '%s')",
catalogName, currentTimestamp, tableIdent);
- Assertions.assertThat(output.get(0)[5])
- .as("should be 1 deleted partition statistics file")
- .isEqualTo(1L);
+ assertThat(output.get(0)[5]).as("should be 1 deleted partition statistics file").isEqualTo(1L);
table.refresh();
- Assertions.assertThat(table.partitionStatisticsFiles())
+ assertThat(table.partitionStatisticsFiles())
.as(
"partition statistics file entry in TableMetadata should be present only for the snapshot %s",
partitionStatisticsFile2.snapshotId())
.extracting(PartitionStatisticsFile::snapshotId)
.containsExactly(partitionStatisticsFile2.snapshotId());
- Assertions.assertThat(new File(partitionStatsFileLocation1))
+ assertThat(new File(partitionStatsFileLocation1))
.as(
"partition statistics file should not exist for snapshot %s",
partitionStatisticsFile1.snapshotId())
.doesNotExist();
- Assertions.assertThat(new File(partitionStatsFileLocation2))
+ assertThat(new File(partitionStatsFileLocation2))
.as(
"partition statistics file should exist for snapshot %s",
partitionStatisticsFile2.snapshotId())
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMerge.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMerge.java
index ead477d71b..39f316655e 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMerge.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMerge.java
@@ -26,6 +26,8 @@ import static org.apache.iceberg.TableProperties.PARQUET_ROW_GROUP_SIZE_BYTES;
import static org.apache.iceberg.TableProperties.SPLIT_SIZE;
import static org.apache.iceberg.TableProperties.WRITE_DISTRIBUTION_MODE;
import static org.apache.spark.sql.functions.lit;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.Arrays;
import java.util.Collections;
@@ -63,7 +65,6 @@ import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
import org.apache.spark.sql.execution.SparkPlan;
import org.apache.spark.sql.internal.SQLConf;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Assume;
@@ -583,7 +584,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
ds.union(ds).createOrReplaceTempView("source");
String errorMsg = "a single row from the target table with multiple rows of the source table";
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s AS t USING source AS s "
@@ -626,7 +627,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
() -> {
String errorMsg =
"a single row from the target table with multiple rows of the source table";
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s AS t USING source AS s "
@@ -667,7 +668,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
() -> {
String errorMsg =
"a single row from the target table with multiple rows of the source table";
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s AS t USING source AS s "
@@ -706,7 +707,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
ds.union(ds).createOrReplaceTempView("source");
String errorMsg = "a single row from the target table with multiple rows of the source table";
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s AS t USING source AS s "
@@ -741,7 +742,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
ds.union(ds).createOrReplaceTempView("source");
String errorMsg = "a single row from the target table with multiple rows of the source table";
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s AS t USING source AS s "
@@ -778,7 +779,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
+ "{ \"id\": 6, \"dep\": \"emp-id-6\" }");
String errorMsg = "a single row from the target table with multiple rows of the source table";
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s AS t USING source AS s "
@@ -850,7 +851,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
+ "{ \"id\": 6, \"dep\": \"emp-id-6\" }");
String errorMsg = "a single row from the target table with multiple rows of the source table";
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s AS t USING source AS s "
@@ -1255,7 +1256,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
});
try {
- Assertions.assertThatThrownBy(mergeFuture::get)
+ assertThatThrownBy(mergeFuture::get)
.isInstanceOf(ExecutionException.class)
.cause()
.isInstanceOf(SparkException.class)
@@ -1991,7 +1992,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
"{ \"id\": 1, \"c\": { \"n1\": 2, \"n2\": { \"dn1\": 3, \"dn2\": 4 } } }");
createOrReplaceView("source", "{ \"c1\": -100, \"c2\": -200 }");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2004,7 +2005,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("cannot resolve t.invalid_col");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2017,7 +2018,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("No such struct field invalid_col");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2040,7 +2041,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
"{ \"id\": 1, \"c\": { \"n1\": 2, \"n2\": { \"dn1\": 3, \"dn2\": 4 } } }");
createOrReplaceView("source", "{ \"c1\": -100, \"c2\": -200 }");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2055,7 +2056,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Nested fields are not supported inside INSERT clauses");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2070,7 +2071,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Duplicate column names inside INSERT clause");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2091,7 +2092,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
"{ \"id\": 1, \"a\": [ { \"c1\": 2, \"c2\": 3 } ], \"m\": { \"k\": \"v\"} }");
createOrReplaceView("source", "{ \"c1\": -100, \"c2\": -200 }");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2104,7 +2105,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Updating nested fields is only supported for structs");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2125,7 +2126,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
"{ \"id\": 1, \"c\": { \"n1\": 2, \"n2\": { \"dn1\": 3, \"dn2\": 4 } } }");
createOrReplaceView("source", "{ \"c1\": -100, \"c2\": -200 }");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2138,7 +2139,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Updates are in conflict");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2151,7 +2152,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Updates are in conflict for these columns");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2179,7 +2180,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
withSQLConf(
ImmutableMap.of("spark.sql.storeAssignmentPolicy", policy),
() -> {
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2192,7 +2193,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Cannot write nullable values to non-null column");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2205,7 +2206,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Cannot write nullable values to non-null column");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2218,7 +2219,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("missing fields");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2231,7 +2232,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Cannot safely cast");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2254,7 +2255,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
"{ \"id\": 1, \"c\": { \"n1\": 2, \"n2\": { \"dn1\": 3, \"dn2\": 4 } } }");
createOrReplaceView("source", "{ \"c1\": -100, \"c2\": -200 }");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2267,7 +2268,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Non-deterministic functions are not supported");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2280,7 +2281,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Non-deterministic functions are not supported");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2293,7 +2294,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Non-deterministic functions are not supported");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2314,7 +2315,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
"{ \"id\": 1, \"c\": { \"n1\": 2, \"n2\": { \"dn1\": 3, \"dn2\": 4 } } }");
createOrReplaceView("source", "{ \"c1\": -100, \"c2\": -200 }");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2327,7 +2328,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Agg functions are not supported");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2340,7 +2341,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Agg functions are not supported");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2353,7 +2354,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Agg functions are not supported");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2374,7 +2375,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
"{ \"id\": 1, \"c\": { \"n1\": 2, \"n2\": { \"dn1\": 3, \"dn2\": 4 } } }");
createOrReplaceView("source", "{ \"c1\": -100, \"c2\": -200 }");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2387,7 +2388,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Subqueries are not supported in conditions");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2400,7 +2401,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Subqueries are not supported in conditions");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2413,7 +2414,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Subqueries are not supported in conditions");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2432,7 +2433,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
createAndInitTable("id INT, c2 INT", "{ \"id\": 1, \"c2\": 2 }");
createOrReplaceView("source", "{ \"id\": 1, \"value\": 11 }");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO %s t USING source s "
@@ -2451,7 +2452,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
createOrReplaceView("target", "{ \"c1\": -100, \"c2\": -200 }");
createOrReplaceView("source", "{ \"c1\": -100, \"c2\": -200 }");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"MERGE INTO target t USING source s "
@@ -2517,7 +2518,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
// Coalesce forces our source into a SinglePartition distribution
spark.range(0, 5).coalesce(1).createOrReplaceTempView("source");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s ON t.id = s.id "
@@ -2604,7 +2605,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
withSQLConf(
ImmutableMap.of(SparkSQLProperties.WAP_BRANCH, "wap"),
() ->
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s ON t.id = s.id "
@@ -2626,9 +2627,9 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
SparkPlan sparkPlan = executeAndKeepPlan(() -> sql(query));
String planAsString = sparkPlan.toString().replaceAll("#(\\d+L?)", "");
- Assertions.assertThat(planAsString).as("Join should match").contains(join + "\n");
+ assertThat(planAsString).as("Join should match").contains(join + "\n");
- Assertions.assertThat(planAsString)
+ assertThat(planAsString)
.as("Pushed filters must match")
.contains("[filters=" + icebergFilters + ",");
});
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMergeOnReadDelete.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMergeOnReadDelete.java
index c156e4c777..9010b7890f 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMergeOnReadDelete.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMergeOnReadDelete.java
@@ -18,6 +18,7 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
@@ -37,7 +38,6 @@ import org.apache.iceberg.spark.source.SparkTable;
import org.apache.iceberg.spark.source.TestSparkCatalog;
import org.apache.spark.SparkException;
import org.apache.spark.sql.connector.catalog.Identifier;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runners.Parameterized;
@@ -115,8 +115,7 @@ public class TestMergeOnReadDelete extends TestDelete {
TestSparkCatalog.setTable(ident, sparkTable);
// Although an exception is thrown here, write and commit have succeeded
- Assertions.assertThatThrownBy(
- () -> sql("DELETE FROM %s WHERE id = 2", "dummy_catalog.default.table"))
+ assertThatThrownBy(() -> sql("DELETE FROM %s WHERE id = 2", "dummy_catalog.default.table"))
.as("Should throw a Commit State Unknown Exception")
.isInstanceOf(SparkException.class)
.hasMessageContaining("Writing job aborted")
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMetaColumnProjectionWithStageScan.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMetaColumnProjectionWithStageScan.java
index e9013848cf..17ed003f6a 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMetaColumnProjectionWithStageScan.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMetaColumnProjectionWithStageScan.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThat;
+
import java.util.List;
import java.util.Map;
import java.util.UUID;
@@ -34,7 +36,6 @@ import org.apache.iceberg.spark.source.SimpleRecord;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Encoders;
import org.apache.spark.sql.Row;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Test;
import org.junit.runners.Parameterized;
@@ -103,7 +104,7 @@ public class TestMetaColumnProjectionWithStageScan extends SparkExtensionsTestBa
.option(SparkReadOptions.SCAN_TASK_SET_ID, fileSetID)
.load(tableLocation);
- Assertions.assertThat(scanDF2.columns().length).isEqualTo(2);
+ assertThat(scanDF2.columns().length).isEqualTo(2);
}
try (CloseableIterable<ScanTask> tasks = table.newBatchScan().planFiles()) {
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMigrateTableProcedure.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMigrateTableProcedure.java
index 3a51e87be8..347a81f0d9 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMigrateTableProcedure.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMigrateTableProcedure.java
@@ -18,13 +18,14 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.io.IOException;
import java.util.Map;
import org.apache.iceberg.Table;
import org.apache.iceberg.exceptions.ValidationException;
import org.apache.iceberg.relocated.com.google.common.collect.ImmutableList;
import org.apache.spark.sql.AnalysisException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Assume;
@@ -131,7 +132,7 @@ public class TestMigrateTableProcedure extends SparkExtensionsTestBase {
"CREATE TABLE %s (id bigint NOT NULL, data string) USING parquet LOCATION '%s'",
tableName, location);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
String props = "map('write.metadata.metrics.column.x', 'X')";
sql("CALL %s.system.migrate('%s', %s)", catalogName, tableName, props);
@@ -166,18 +167,17 @@ public class TestMigrateTableProcedure extends SparkExtensionsTestBase {
@Test
public void testInvalidMigrateCases() {
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.migrate()", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.migrate()", catalogName))
.as("Should reject calls without all required args")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Missing required parameters");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.migrate(map('foo','bar'))", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.migrate(map('foo','bar'))", catalogName))
.as("Should reject calls with invalid arg types")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Wrong arg type");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.migrate('')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.migrate('')", catalogName))
.as("Should reject calls with empty table identifier")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Cannot handle an empty identifier");
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestPublishChangesProcedure.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestPublishChangesProcedure.java
index 19a065234e..e71ad68729 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestPublishChangesProcedure.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestPublishChangesProcedure.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.TableProperties.WRITE_AUDIT_PUBLISH_ENABLED;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.List;
import java.util.Map;
@@ -31,7 +32,6 @@ import org.apache.spark.sql.AnalysisException;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchProcedureException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Test;
@@ -157,7 +157,7 @@ public class TestPublishChangesProcedure extends SparkExtensionsTestBase {
public void testApplyInvalidWapId() {
sql("CREATE TABLE %s (id bigint NOT NULL, data string) USING iceberg", tableName);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.publish_changes('%s', 'not_valid')", catalogName, tableIdent))
.as("Should reject invalid wap id")
.isInstanceOf(ValidationException.class)
@@ -166,26 +166,25 @@ public class TestPublishChangesProcedure extends SparkExtensionsTestBase {
@Test
public void testInvalidApplyWapChangesCases() {
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql("CALL %s.system.publish_changes('n', table => 't', 'not_valid')", catalogName))
.as("Should not allow mixed args")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Named and positional arguments cannot be mixed");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.custom.publish_changes('n', 't', 'not_valid')", catalogName))
.as("Should not resolve procedures in arbitrary namespaces")
.isInstanceOf(NoSuchProcedureException.class)
.hasMessageContaining("not found");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.publish_changes('t')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.publish_changes('t')", catalogName))
.as("Should reject calls without all required args")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Missing required parameters");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.publish_changes('', 'not_valid')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.publish_changes('', 'not_valid')", catalogName))
.as("Should reject calls with empty table identifier")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Cannot handle an empty identifier");
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRemoveOrphanFilesProcedure.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRemoveOrphanFilesProcedure.java
index 4151419686..1701faf378 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRemoveOrphanFilesProcedure.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRemoveOrphanFilesProcedure.java
@@ -20,6 +20,8 @@ package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.TableProperties.GC_ENABLED;
import static org.apache.iceberg.TableProperties.WRITE_AUDIT_PUBLISH_ENABLED;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.File;
import java.io.IOException;
@@ -64,7 +66,6 @@ import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchProcedureException;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
import org.apache.spark.sql.catalyst.parser.ParseException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Rule;
@@ -226,7 +227,7 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
sql("ALTER TABLE %s SET TBLPROPERTIES ('%s' 'false')", tableName, GC_ENABLED);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.remove_orphan_files('%s')", catalogName, tableIdent))
.as("Should reject call")
.isInstanceOf(ValidationException.class)
@@ -257,30 +258,28 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
@Test
public void testInvalidRemoveOrphanFilesCases() {
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.remove_orphan_files('n', table => 't')", catalogName))
.as("Should not allow mixed args")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Named and positional arguments cannot be mixed");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.custom.remove_orphan_files('n', 't')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.custom.remove_orphan_files('n', 't')", catalogName))
.as("Should not resolve procedures in arbitrary namespaces")
.isInstanceOf(NoSuchProcedureException.class)
.hasMessageContaining("not found");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.remove_orphan_files()", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.remove_orphan_files()", catalogName))
.as("Should reject calls without all required args")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Missing required parameters");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.remove_orphan_files('n', 2.2)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.remove_orphan_files('n', 2.2)", catalogName))
.as("Should reject calls with invalid arg types")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Wrong arg type");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.remove_orphan_files('')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.remove_orphan_files('')", catalogName))
.as("Should reject calls with empty table identifier")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Cannot handle an empty identifier");
@@ -348,7 +347,7 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
public void testConcurrentRemoveOrphanFilesWithInvalidInput() {
sql("CREATE TABLE %s (id bigint NOT NULL, data string) USING iceberg", tableName);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.remove_orphan_files(table => '%s', max_concurrent_deletes => %s)",
@@ -357,7 +356,7 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("max_concurrent_deletes should have value > 0");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.remove_orphan_files(table => '%s', max_concurrent_deletes => %s)",
@@ -369,7 +368,7 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
String tempViewName = "file_list_test";
spark.emptyDataFrame().createOrReplaceTempView(tempViewName);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.remove_orphan_files(table => '%s', file_list_view => '%s')",
@@ -383,7 +382,7 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
.toDF("file_path", "last_modified")
.createOrReplaceTempView(tempViewName);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.remove_orphan_files(table => '%s', file_list_view => '%s')",
@@ -397,7 +396,7 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
.toDF("file_path", "last_modified")
.createOrReplaceTempView(tempViewName);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.remove_orphan_files(table => '%s', file_list_view => '%s')",
@@ -515,10 +514,10 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
+ "table => '%s',"
+ "older_than => TIMESTAMP '%s')",
catalogName, tableIdent, currentTimestamp);
- Assertions.assertThat(output).as("Should be no orphan files").isEmpty();
+ assertThat(output).as("Should be no orphan files").isEmpty();
- Assertions.assertThat(statsLocation.exists()).as("stats file should exist").isTrue();
- Assertions.assertThat(statsLocation.length())
+ assertThat(statsLocation.exists()).as("stats file should exist").isTrue();
+ assertThat(statsLocation.length())
.as("stats file length")
.isEqualTo(statisticsFile.fileSizeInBytes());
@@ -532,11 +531,11 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
+ "table => '%s',"
+ "older_than => TIMESTAMP '%s')",
catalogName, tableIdent, currentTimestamp);
- Assertions.assertThat(output).as("Should be orphan files").hasSize(1);
- Assertions.assertThat(Iterables.getOnlyElement(output))
+ assertThat(output).as("Should be orphan files").hasSize(1);
+ assertThat(Iterables.getOnlyElement(output))
.as("Deleted files")
.containsExactly(statsLocation.toURI().toString());
- Assertions.assertThat(statsLocation.exists()).as("stats file should be deleted").isFalse();
+ assertThat(statsLocation.exists()).as("stats file should be deleted").isFalse();
}
@Test
@@ -565,11 +564,9 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
+ "table => '%s',"
+ "older_than => TIMESTAMP '%s')",
catalogName, tableIdent, currentTimestamp);
- Assertions.assertThat(output).as("Should be no orphan files").isEmpty();
+ assertThat(output).as("Should be no orphan files").isEmpty();
- Assertions.assertThat(new File(partitionStatsLocation))
- .as("partition stats file should exist")
- .exists();
+ assertThat(new File(partitionStatsLocation)).as("partition stats file should exist").exists();
removePartitionStatsTxn(table, partitionStatisticsFile);
@@ -579,11 +576,11 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
+ "table => '%s',"
+ "older_than => TIMESTAMP '%s')",
catalogName, tableIdent, currentTimestamp);
- Assertions.assertThat(output).as("Should be orphan files").hasSize(1);
- Assertions.assertThat(Iterables.getOnlyElement(output))
+ assertThat(output).as("Should be orphan files").hasSize(1);
+ assertThat(Iterables.getOnlyElement(output))
.as("Deleted files")
.containsExactly("file:" + partitionStatsLocation);
- Assertions.assertThat(new File(partitionStatsLocation))
+ assertThat(new File(partitionStatsLocation))
.as("partition stats file should be deleted")
.doesNotExist();
}
@@ -676,7 +673,7 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
Assert.assertEquals(0, orphanFiles.size());
// Test with no equal schemes
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.remove_orphan_files("
@@ -760,7 +757,7 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
Assert.assertEquals(0, orphanFiles.size());
// Test with no equal authorities
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.remove_orphan_files("
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestReplaceBranch.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestReplaceBranch.java
index ed428310b8..7cab771c00 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestReplaceBranch.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestReplaceBranch.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
@@ -29,7 +31,6 @@ import org.apache.iceberg.spark.source.SimpleRecord;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
@@ -74,7 +75,7 @@ public class TestReplaceBranch extends SparkExtensionsTestBase {
df.writeTo(tableName).append();
long second = table.currentSnapshot().snapshotId();
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"ALTER TABLE %s REPLACE BRANCH %s AS OF VERSION %d",
@@ -129,7 +130,7 @@ public class TestReplaceBranch extends SparkExtensionsTestBase {
df.writeTo(tableName).append();
Table table = validationCatalog.loadTable(tableIdent);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"ALTER TABLE %s REPLACE BRANCH %s AS OF VERSION %d",
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRequiredDistributionAndOrdering.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRequiredDistributionAndOrdering.java
index b459f3c248..29fb193fe4 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRequiredDistributionAndOrdering.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRequiredDistributionAndOrdering.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.math.BigDecimal;
import java.util.List;
import java.util.Map;
@@ -28,7 +30,6 @@ import org.apache.spark.SparkException;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Test;
@@ -187,7 +188,7 @@ public class TestRequiredDistributionAndOrdering extends SparkExtensionsTestBase
Dataset<Row> inputDF = ds.coalesce(1).sortWithinPartitions("c1");
// should fail if ordering is disabled
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
try {
inputDF
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRewriteDataFilesProcedure.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRewriteDataFilesProcedure.java
index 4a4e4d7dfd..1418d82ceb 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRewriteDataFilesProcedure.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRewriteDataFilesProcedure.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.extensions;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.Arrays;
import java.util.List;
@@ -40,7 +41,6 @@ import org.apache.spark.sql.AnalysisException;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchProcedureException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Assume;
@@ -454,7 +454,7 @@ public class TestRewriteDataFilesProcedure extends SparkExtensionsTestBase {
insertData(2);
// Test for invalid strategy
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_data_files(table => '%s', options => map('min-input-files','2'), "
@@ -465,7 +465,7 @@ public class TestRewriteDataFilesProcedure extends SparkExtensionsTestBase {
.hasMessageContaining("unsupported strategy: temp. Only binpack or sort is supported");
// Test for sort_order with binpack strategy
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_data_files(table => '%s', strategy => 'binpack', "
@@ -476,7 +476,7 @@ public class TestRewriteDataFilesProcedure extends SparkExtensionsTestBase {
.hasMessageContaining("Must use only one rewriter type (bin-pack, sort, zorder)");
// Test for sort strategy without any (default/user defined) sort_order
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_data_files(table => '%s', strategy => 'sort')",
@@ -486,7 +486,7 @@ public class TestRewriteDataFilesProcedure extends SparkExtensionsTestBase {
.hasMessageContaining("Cannot sort data without a valid sort order");
// Test for sort_order with invalid null order
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_data_files(table => '%s', strategy => 'sort', "
@@ -497,7 +497,7 @@ public class TestRewriteDataFilesProcedure extends SparkExtensionsTestBase {
.hasMessageContaining("Unable to parse sortOrder:");
// Test for sort_order with invalid sort direction
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_data_files(table => '%s', strategy => 'sort', "
@@ -508,7 +508,7 @@ public class TestRewriteDataFilesProcedure extends SparkExtensionsTestBase {
.hasMessageContaining("Unable to parse sortOrder:");
// Test for sort_order with invalid column name
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_data_files(table => '%s', strategy => 'sort', "
@@ -521,7 +521,7 @@ public class TestRewriteDataFilesProcedure extends SparkExtensionsTestBase {
+ " struct<1: c1: optional int, 2: c2: optional string, 3: c3: optional string>");
// Test with invalid filter column col1
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_data_files(table => '%s', " + "where => 'col1 = 3')",
@@ -531,7 +531,7 @@ public class TestRewriteDataFilesProcedure extends SparkExtensionsTestBase {
.hasMessageContaining("Cannot parse predicates in where option: col1 = 3");
// Test for z_order with invalid column name
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_data_files(table => '%s', strategy => 'sort', "
@@ -544,7 +544,7 @@ public class TestRewriteDataFilesProcedure extends SparkExtensionsTestBase {
+ "struct<1: c1: optional int, 2: c2: optional string, 3: c3: optional string>");
// Test for z_order with sort_order
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_data_files(table => '%s', strategy => 'sort', "
@@ -558,30 +558,29 @@ public class TestRewriteDataFilesProcedure extends SparkExtensionsTestBase {
@Test
public void testInvalidCasesForRewriteDataFiles() {
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.rewrite_data_files('n', table => 't')", catalogName))
.as("Should not allow mixed args")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Named and positional arguments cannot be mixed");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.custom.rewrite_data_files('n', 't')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.custom.rewrite_data_files('n', 't')", catalogName))
.as("Should not resolve procedures in arbitrary namespaces")
.isInstanceOf(NoSuchProcedureException.class)
.hasMessageContaining("not found");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.rewrite_data_files()", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rewrite_data_files()", catalogName))
.as("Should reject calls without all required args")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Missing required parameters");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.rewrite_data_files(table => 't', table => 't')", catalogName))
.as("Should reject duplicate arg names name")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Duplicate procedure argument: table");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.rewrite_data_files('')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rewrite_data_files('')", catalogName))
.as("Should reject calls with empty table identifier")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Cannot handle an empty identifier");
@@ -738,7 +737,7 @@ public class TestRewriteDataFilesProcedure extends SparkExtensionsTestBase {
@Test
public void testRewriteWithUntranslatedOrUnconvertedFilter() {
createTable();
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_data_files(table => '%s', where => 'lower(c2) = \"fo\"')",
@@ -746,7 +745,7 @@ public class TestRewriteDataFilesProcedure extends SparkExtensionsTestBase {
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Cannot translate Spark expression");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_data_files(table => '%s', where => 'c2 like \"%%fo\"')",
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRewriteManifestsProcedure.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRewriteManifestsProcedure.java
index 3afad8a7b8..591d88e83f 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRewriteManifestsProcedure.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRewriteManifestsProcedure.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.TableProperties.SNAPSHOT_ID_INHERITANCE_ENABLED;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.sql.Date;
import java.sql.Timestamp;
@@ -31,7 +32,6 @@ import org.apache.spark.sql.AnalysisException;
import org.apache.spark.sql.RowFactory;
import org.apache.spark.sql.catalyst.analysis.NoSuchProcedureException;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
@@ -276,36 +276,34 @@ public class TestRewriteManifestsProcedure extends SparkExtensionsTestBase {
@Test
public void testInvalidRewriteManifestsCases() {
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.rewrite_manifests('n', table => 't')", catalogName))
.as("Should not allow mixed args")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Named and positional arguments cannot be mixed");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.custom.rewrite_manifests('n', 't')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.custom.rewrite_manifests('n', 't')", catalogName))
.as("Should not resolve procedures in arbitrary namespaces")
.isInstanceOf(NoSuchProcedureException.class)
.hasMessageContaining("not found");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.rewrite_manifests()", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rewrite_manifests()", catalogName))
.as("Should reject calls without all required args")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Missing required parameters");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.rewrite_manifests('n', 2.2)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rewrite_manifests('n', 2.2)", catalogName))
.as("Should reject calls with invalid arg types")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Wrong arg type");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.rewrite_manifests(table => 't', tAbLe => 't')", catalogName))
.as("Should reject duplicate arg names name")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Duplicate procedure argument: table");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.rewrite_manifests('')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rewrite_manifests('')", catalogName))
.as("Should reject calls with empty table identifier")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Cannot handle an empty identifier");
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRewritePositionDeleteFilesProcedure.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRewritePositionDeleteFilesProcedure.java
index 481e2f01f2..6f39031d14 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRewritePositionDeleteFilesProcedure.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRewritePositionDeleteFilesProcedure.java
@@ -20,6 +20,7 @@ package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.SnapshotSummary.ADDED_FILE_SIZE_PROP;
import static org.apache.iceberg.SnapshotSummary.REMOVED_FILE_SIZE_PROP;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.List;
import java.util.Map;
@@ -29,7 +30,6 @@ import org.apache.iceberg.relocated.com.google.common.collect.Lists;
import org.apache.iceberg.spark.data.TestHelpers;
import org.apache.iceberg.spark.source.SimpleRecord;
import org.apache.spark.sql.Encoders;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
@@ -206,7 +206,7 @@ public class TestRewritePositionDeleteFilesProcedure extends SparkExtensionsTest
@Test
public void testRewriteWithUntranslatedOrUnconvertedFilter() throws Exception {
createTable();
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_position_delete_files(table => '%s', where => 'lower(data) = \"fo\"')",
@@ -214,7 +214,7 @@ public class TestRewritePositionDeleteFilesProcedure extends SparkExtensionsTest
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Cannot translate Spark expression");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_position_delete_files(table => '%s', where => 'data like \"%%fo\"')",
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRollbackToSnapshotProcedure.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRollbackToSnapshotProcedure.java
index 95d03a0104..b60a769f9f 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRollbackToSnapshotProcedure.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRollbackToSnapshotProcedure.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.util.List;
import java.util.Map;
import org.apache.iceberg.Snapshot;
@@ -28,7 +30,6 @@ import org.apache.spark.sql.AnalysisException;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchProcedureException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assume;
import org.junit.Test;
@@ -240,7 +241,7 @@ public class TestRollbackToSnapshotProcedure extends SparkExtensionsTestBase {
public void testRollbackToInvalidSnapshot() {
sql("CREATE TABLE %s (id bigint NOT NULL, data string) USING iceberg", tableName);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.rollback_to_snapshot('%s', -1L)", catalogName, tableIdent))
.as("Should reject invalid snapshot id")
.isInstanceOf(ValidationException.class)
@@ -249,7 +250,7 @@ public class TestRollbackToSnapshotProcedure extends SparkExtensionsTestBase {
@Test
public void testInvalidRollbackToSnapshotCases() {
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rollback_to_snapshot(namespace => 'n1', table => 't', 1L)",
@@ -258,37 +259,32 @@ public class TestRollbackToSnapshotProcedure extends SparkExtensionsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Named and positional arguments cannot be mixed");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.custom.rollback_to_snapshot('n', 't', 1L)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.custom.rollback_to_snapshot('n', 't', 1L)", catalogName))
.as("Should not resolve procedures in arbitrary namespaces")
.isInstanceOf(NoSuchProcedureException.class)
.hasMessageContaining("not found");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.rollback_to_snapshot('t')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rollback_to_snapshot('t')", catalogName))
.as("Should reject calls without all required args")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Missing required parameters");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.rollback_to_snapshot(1L)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rollback_to_snapshot(1L)", catalogName))
.as("Should reject calls without all required args")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Missing required parameters");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.rollback_to_snapshot(table => 't')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rollback_to_snapshot(table => 't')", catalogName))
.as("Should reject calls without all required args")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Missing required parameters");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.rollback_to_snapshot('t', 2.2)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rollback_to_snapshot('t', 2.2)", catalogName))
.as("Should reject calls with invalid arg types")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Wrong arg type for snapshot_id: cannot cast");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.rollback_to_snapshot('', 1L)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rollback_to_snapshot('', 1L)", catalogName))
.as("Should reject calls with empty table identifier")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Cannot handle an empty identifier");
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRollbackToTimestampProcedure.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRollbackToTimestampProcedure.java
index c11c7ab7e4..281bfbf7ad 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRollbackToTimestampProcedure.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRollbackToTimestampProcedure.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
@@ -28,7 +30,6 @@ import org.apache.spark.sql.AnalysisException;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchProcedureException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assume;
import org.junit.Test;
@@ -255,7 +256,7 @@ public class TestRollbackToTimestampProcedure extends SparkExtensionsTestBase {
public void testInvalidRollbackToTimestampCases() {
String timestamp = "TIMESTAMP '2007-12-03T10:15:30'";
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rollback_to_timestamp(namespace => 'n1', 't', %s)",
@@ -264,19 +265,18 @@ public class TestRollbackToTimestampProcedure extends SparkExtensionsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Named and positional arguments cannot be mixed");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.custom.rollback_to_timestamp('n', 't', %s)", catalogName, timestamp))
.as("Should not resolve procedures in arbitrary namespaces")
.isInstanceOf(NoSuchProcedureException.class)
.hasMessageContaining("not found");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.rollback_to_timestamp('t')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rollback_to_timestamp('t')", catalogName))
.as("Should reject calls without all required args")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Missing required parameters");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rollback_to_timestamp(timestamp => %s)",
@@ -285,13 +285,12 @@ public class TestRollbackToTimestampProcedure extends SparkExtensionsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Missing required parameters");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.rollback_to_timestamp(table => 't')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rollback_to_timestamp(table => 't')", catalogName))
.as("Should reject calls without all required args")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Missing required parameters");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rollback_to_timestamp('n', 't', %s, 1L)",
@@ -300,8 +299,7 @@ public class TestRollbackToTimestampProcedure extends SparkExtensionsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Too many arguments");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.rollback_to_timestamp('t', 2.2)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rollback_to_timestamp('t', 2.2)", catalogName))
.as("Should reject calls with invalid arg types")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Wrong arg type for timestamp: cannot cast");
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSetCurrentSnapshotProcedure.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSetCurrentSnapshotProcedure.java
index d996e4b5c8..55bda0df1b 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSetCurrentSnapshotProcedure.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSetCurrentSnapshotProcedure.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.TableProperties.WRITE_AUDIT_PUBLISH_ENABLED;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.List;
import java.util.Map;
@@ -30,7 +31,6 @@ import org.apache.iceberg.relocated.com.google.common.collect.ImmutableList;
import org.apache.iceberg.relocated.com.google.common.collect.Iterables;
import org.apache.spark.sql.AnalysisException;
import org.apache.spark.sql.catalyst.analysis.NoSuchProcedureException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assume;
import org.junit.Test;
@@ -193,7 +193,7 @@ public class TestSetCurrentSnapshotProcedure extends SparkExtensionsTestBase {
Namespace namespace = tableIdent.namespace();
String tableName = tableIdent.name();
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.set_current_snapshot('%s', -1L)", catalogName, tableIdent))
.as("Should reject invalid snapshot id")
.isInstanceOf(ValidationException.class)
@@ -202,7 +202,7 @@ public class TestSetCurrentSnapshotProcedure extends SparkExtensionsTestBase {
@Test
public void testInvalidRollbackToSnapshotCases() {
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.set_current_snapshot(namespace => 'n1', table => 't', 1L)",
@@ -211,43 +211,38 @@ public class TestSetCurrentSnapshotProcedure extends SparkExtensionsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Named and positional arguments cannot be mixed");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.custom.set_current_snapshot('n', 't', 1L)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.custom.set_current_snapshot('n', 't', 1L)", catalogName))
.as("Should not resolve procedures in arbitrary namespaces")
.isInstanceOf(NoSuchProcedureException.class)
.hasMessageContaining("not found");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.set_current_snapshot('t')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.set_current_snapshot('t')", catalogName))
.as("Should reject calls without all required args")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Missing required parameters");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.set_current_snapshot(1L)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.set_current_snapshot(1L)", catalogName))
.as("Should reject calls without all required args")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Missing required parameters");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.set_current_snapshot(snapshot_id => 1L)", catalogName))
.as("Should reject calls without all required args")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Missing required parameters");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.set_current_snapshot(table => 't')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.set_current_snapshot(table => 't')", catalogName))
.as("Should reject calls without all required args")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Missing required parameters");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.set_current_snapshot('t', 2.2)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.set_current_snapshot('t', 2.2)", catalogName))
.as("Should reject calls with invalid arg types")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Wrong arg type for snapshot_id: cannot cast");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.set_current_snapshot('', 1L)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.set_current_snapshot('', 1L)", catalogName))
.as("Should reject calls with empty table identifier")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Cannot handle an empty identifier");
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSetWriteDistributionAndOrdering.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSetWriteDistributionAndOrdering.java
index d39e08beab..8c096ab32d 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSetWriteDistributionAndOrdering.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSetWriteDistributionAndOrdering.java
@@ -19,6 +19,8 @@
package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.expressions.Expressions.bucket;
+import static org.assertj.core.api.Assertions.assertThatNoException;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.Map;
import org.apache.iceberg.NullOrder;
@@ -27,7 +29,6 @@ import org.apache.iceberg.Table;
import org.apache.iceberg.TableProperties;
import org.apache.iceberg.exceptions.ValidationException;
import org.apache.spark.sql.internal.SQLConf;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
@@ -75,14 +76,14 @@ public class TestSetWriteDistributionAndOrdering extends SparkExtensionsTestBase
Table table = validationCatalog.loadTable(tableIdent);
Assert.assertTrue("Table should start unsorted", table.sortOrder().isUnsorted());
sql("SET %s=true", SQLConf.CASE_SENSITIVE().key());
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql("ALTER TABLE %s WRITE ORDERED BY category, id", tableName);
})
.isInstanceOf(ValidationException.class);
sql("SET %s=false", SQLConf.CASE_SENSITIVE().key());
- Assertions.assertThatNoException()
+ assertThatNoException()
.isThrownBy(
() -> {
sql("ALTER TABLE %s WRITE ORDERED BY category, id", tableName);
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSnapshotTableProcedure.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSnapshotTableProcedure.java
index d44f8d3721..cf297e7fc0 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSnapshotTableProcedure.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSnapshotTableProcedure.java
@@ -18,13 +18,14 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.io.IOException;
import java.util.Map;
import org.apache.iceberg.Table;
import org.apache.iceberg.TableProperties;
import org.apache.iceberg.relocated.com.google.common.collect.ImmutableList;
import org.apache.spark.sql.AnalysisException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Assume;
@@ -195,18 +196,18 @@ public class TestSnapshotTableProcedure extends SparkExtensionsTestBase {
"CREATE TABLE %s (id bigint NOT NULL, data string) USING parquet LOCATION '%s'",
sourceName, location);
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.snapshot('foo')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.snapshot('foo')", catalogName))
.as("Should reject calls without all required args")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Missing required parameters");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.snapshot('n', 't', map('foo', 'bar'))", catalogName))
.as("Should reject calls with invalid arg types")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Wrong arg type");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.snapshot('%s', 'fable', 'loc', map(2, 1, 1))",
@@ -215,12 +216,12 @@ public class TestSnapshotTableProcedure extends SparkExtensionsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("cannot resolve 'map");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.snapshot('', 'dest')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.snapshot('', 'dest')", catalogName))
.as("Should reject calls with empty table identifier")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Cannot handle an empty identifier");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.snapshot('src', '')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.snapshot('src', '')", catalogName))
.as("Should reject calls with empty table identifier")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Cannot handle an empty identifier");
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestTagDDL.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestTagDDL.java
index 3dadadd9c4..6c1418b7a7 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestTagDDL.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestTagDDL.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.extensions;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.List;
import java.util.Locale;
@@ -34,7 +35,6 @@ import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
import org.apache.spark.sql.catalyst.parser.extensions.IcebergParseException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
@@ -96,7 +96,7 @@ public class TestTagDDL extends SparkExtensionsTestBase {
}
String tagName = "t1";
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"ALTER TABLE %s CREATE TAG %s AS OF VERSION %d RETAIN",
@@ -105,13 +105,13 @@ public class TestTagDDL extends SparkExtensionsTestBase {
.isInstanceOf(IcebergParseException.class)
.hasMessageContaining("mismatched input");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("ALTER TABLE %s CREATE TAG %s RETAIN %s DAYS", tableName, tagName, "abc"))
.as("Illegal statement")
.isInstanceOf(IcebergParseException.class)
.hasMessageContaining("mismatched input");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"ALTER TABLE %s CREATE TAG %s AS OF VERSION %d RETAIN %d SECONDS",
@@ -123,7 +123,7 @@ public class TestTagDDL extends SparkExtensionsTestBase {
@Test
public void testCreateTagOnEmptyTable() {
- Assertions.assertThatThrownBy(() -> sql("ALTER TABLE %s CREATE TAG %s", tableName, "abc"))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s CREATE TAG %s", tableName, "abc"))
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining(
"Cannot complete create or replace tag operation on %s, main has no snapshot",
@@ -136,7 +136,7 @@ public class TestTagDDL extends SparkExtensionsTestBase {
long snapshotId = table.currentSnapshot().snapshotId();
String tagName = "t1";
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("ALTER TABLE %s CREATE TAG %s AS OF VERSION %d", tableName, tagName, -1))
.as("unknown snapshot")
.isInstanceOf(ValidationException.class)
@@ -150,12 +150,12 @@ public class TestTagDDL extends SparkExtensionsTestBase {
Assert.assertNull(
"The tag needs to have the default max ref age, which is null.", ref.maxRefAgeMs());
- Assertions.assertThatThrownBy(() -> sql("ALTER TABLE %s CREATE TAG %s", tableName, tagName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s CREATE TAG %s", tableName, tagName))
.as("Cannot create an exist tag")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("already exists");
- Assertions.assertThatThrownBy(() -> sql("ALTER TABLE %s CREATE TAG %s", tableName, "123"))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s CREATE TAG %s", tableName, "123"))
.as("Non-conforming tag name")
.isInstanceOf(IcebergParseException.class)
.hasMessageContaining("mismatched input '123'");
@@ -204,8 +204,7 @@ public class TestTagDDL extends SparkExtensionsTestBase {
insertRows();
long second = table.currentSnapshot().snapshotId();
- Assertions.assertThatThrownBy(
- () -> sql("ALTER TABLE %s REPLACE Tag %s", tableName, branchName, second))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s REPLACE Tag %s", tableName, branchName, second))
.as("Cannot perform replace tag on branches")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Ref branch1 is a branch not a tag");
@@ -241,7 +240,7 @@ public class TestTagDDL extends SparkExtensionsTestBase {
public void testReplaceTagDoesNotExist() throws NoSuchTableException {
Table table = insertRows();
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"ALTER TABLE %s REPLACE Tag %s AS OF VERSION %d",
@@ -313,7 +312,7 @@ public class TestTagDDL extends SparkExtensionsTestBase {
@Test
public void testDropTagNonConformingName() {
- Assertions.assertThatThrownBy(() -> sql("ALTER TABLE %s DROP TAG %s", tableName, "123"))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s DROP TAG %s", tableName, "123"))
.as("Non-conforming tag name")
.isInstanceOf(IcebergParseException.class)
.hasMessageContaining("mismatched input '123'");
@@ -321,8 +320,7 @@ public class TestTagDDL extends SparkExtensionsTestBase {
@Test
public void testDropTagDoesNotExist() {
- Assertions.assertThatThrownBy(
- () -> sql("ALTER TABLE %s DROP TAG %s", tableName, "nonExistingTag"))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s DROP TAG %s", tableName, "nonExistingTag"))
.as("Cannot perform drop tag on tag which does not exist")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Tag does not exist: nonExistingTag");
@@ -334,7 +332,7 @@ public class TestTagDDL extends SparkExtensionsTestBase {
Table table = insertRows();
table.manageSnapshots().createBranch(branchName, table.currentSnapshot().snapshotId()).commit();
- Assertions.assertThatThrownBy(() -> sql("ALTER TABLE %s DROP TAG %s", tableName, branchName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s DROP TAG %s", tableName, branchName))
.as("Cannot perform drop tag on branch")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Ref b1 is a branch not a tag");
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestUpdate.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestUpdate.java
index 76c7a171f6..63af42ff4c 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestUpdate.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestUpdate.java
@@ -29,6 +29,7 @@ import static org.apache.iceberg.TableProperties.UPDATE_ISOLATION_LEVEL;
import static org.apache.iceberg.TableProperties.UPDATE_MODE;
import static org.apache.iceberg.TableProperties.UPDATE_MODE_DEFAULT;
import static org.apache.spark.sql.functions.lit;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.Arrays;
import java.util.List;
@@ -65,7 +66,6 @@ import org.apache.spark.sql.Encoders;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
import org.apache.spark.sql.internal.SQLConf;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Assume;
@@ -140,8 +140,7 @@ public abstract class TestUpdate extends SparkRowLevelOperationsTestBase {
Assume.assumeTrue("Test only applicable to custom branch", "test".equals(branch));
createAndInitTable("id INT, dep STRING");
- Assertions.assertThatThrownBy(
- () -> sql("UPDATE %s SET dep = 'invalid' WHERE id IN (1)", commitTarget()))
+ assertThatThrownBy(() -> sql("UPDATE %s SET dep = 'invalid' WHERE id IN (1)", commitTarget()))
.isInstanceOf(ValidationException.class)
.hasMessage("Cannot use branch (does not exist): test");
}
@@ -527,7 +526,7 @@ public abstract class TestUpdate extends SparkRowLevelOperationsTestBase {
});
try {
- Assertions.assertThatThrownBy(updateFuture::get)
+ assertThatThrownBy(updateFuture::get)
.isInstanceOf(ExecutionException.class)
.cause()
.isInstanceOf(SparkException.class)
@@ -1148,12 +1147,12 @@ public abstract class TestUpdate extends SparkRowLevelOperationsTestBase {
"id INT, a ARRAY<STRUCT<c1:INT,c2:INT>>, m MAP<STRING,STRING>",
"{ \"id\": 0, \"a\": null, \"m\": null }");
- Assertions.assertThatThrownBy(() -> sql("UPDATE %s SET a.c1 = 1", commitTarget()))
+ assertThatThrownBy(() -> sql("UPDATE %s SET a.c1 = 1", commitTarget()))
.as("Should complain about updating an array column")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Updating nested fields is only supported for structs");
- Assertions.assertThatThrownBy(() -> sql("UPDATE %s SET m.key = 'new_key'", commitTarget()))
+ assertThatThrownBy(() -> sql("UPDATE %s SET m.key = 'new_key'", commitTarget()))
.as("Should complain about updating a map column")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Updating nested fields is only supported for structs");
@@ -1164,19 +1163,18 @@ public abstract class TestUpdate extends SparkRowLevelOperationsTestBase {
createAndInitTable(
"id INT, c STRUCT<n1:INT,n2:STRUCT<dn1:INT,dn2:INT>>", "{ \"id\": 0, \"s\": null }");
- Assertions.assertThatThrownBy(
- () -> sql("UPDATE %s t SET t.id = 1, t.c.n1 = 2, t.id = 2", commitTarget()))
+ assertThatThrownBy(() -> sql("UPDATE %s t SET t.id = 1, t.c.n1 = 2, t.id = 2", commitTarget()))
.as("Should complain about conflicting updates to a top-level column")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Updates are in conflict");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("UPDATE %s t SET t.c.n1 = 1, t.id = 2, t.c.n1 = 2", commitTarget()))
.as("Should complain about conflicting updates to a nested column")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Updates are in conflict for these columns");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"UPDATE %s SET c.n1 = 1, c = named_struct('n1', 1, 'n2', named_struct('dn1', 1, 'dn2', 2))",
@@ -1197,30 +1195,28 @@ public abstract class TestUpdate extends SparkRowLevelOperationsTestBase {
withSQLConf(
ImmutableMap.of("spark.sql.storeAssignmentPolicy", policy),
() -> {
- Assertions.assertThatThrownBy(() -> sql("UPDATE %s t SET t.id = NULL", commitTarget()))
+ assertThatThrownBy(() -> sql("UPDATE %s t SET t.id = NULL", commitTarget()))
.as("Should complain about writing nulls to a top-level column")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Cannot write nullable values to non-null column");
- Assertions.assertThatThrownBy(
- () -> sql("UPDATE %s t SET t.s.n1 = NULL", commitTarget()))
+ assertThatThrownBy(() -> sql("UPDATE %s t SET t.s.n1 = NULL", commitTarget()))
.as("Should complain about writing nulls to a nested column")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Cannot write nullable values to non-null column");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("UPDATE %s t SET t.s = named_struct('n1', 1)", commitTarget()))
.as("Should complain about writing missing fields in structs")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("missing fields");
- Assertions.assertThatThrownBy(
- () -> sql("UPDATE %s t SET t.s.n1 = 'str'", commitTarget()))
+ assertThatThrownBy(() -> sql("UPDATE %s t SET t.s.n1 = 'str'", commitTarget()))
.as("Should complain about writing invalid data types")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Cannot safely cast");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"UPDATE %s t SET t.s.n2 = named_struct('dn2', 1, 'dn1', 2)",
@@ -1236,7 +1232,7 @@ public abstract class TestUpdate extends SparkRowLevelOperationsTestBase {
public void testUpdateWithNonDeterministicCondition() {
createAndInitTable("id INT, dep STRING", "{ \"id\": 1, \"dep\": \"hr\" }");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("UPDATE %s SET id = -1 WHERE id = 1 AND rand() > 0.5", commitTarget()))
.as("Should complain about non-deterministic expressions")
.isInstanceOf(AnalysisException.class)
@@ -1247,7 +1243,7 @@ public abstract class TestUpdate extends SparkRowLevelOperationsTestBase {
public void testUpdateOnNonIcebergTableNotSupported() {
createOrReplaceView("testtable", "{ \"c1\": -100, \"c2\": -200 }");
- Assertions.assertThatThrownBy(() -> sql("UPDATE %s SET c1 = -1 WHERE c2 = 1", "testtable"))
+ assertThatThrownBy(() -> sql("UPDATE %s SET c1 = -1 WHERE c2 = 1", "testtable"))
.as("UPDATE is not supported for non iceberg table")
.isInstanceOf(UnsupportedOperationException.class)
.hasMessageContaining("not supported temporarily");
@@ -1312,8 +1308,7 @@ public abstract class TestUpdate extends SparkRowLevelOperationsTestBase {
withSQLConf(
ImmutableMap.of(SparkSQLProperties.WAP_BRANCH, "wap"),
() ->
- Assertions.assertThatThrownBy(
- () -> sql("UPDATE %s SET dep='hr' WHERE dep='a'", commitTarget()))
+ assertThatThrownBy(() -> sql("UPDATE %s SET dep='hr' WHERE dep='a'", commitTarget()))
.isInstanceOf(ValidationException.class)
.hasMessage(
String.format(
diff --git a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestWriteAborts.java b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestWriteAborts.java
index 2966e95fa3..3db2265cf9 100644
--- a/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestWriteAborts.java
+++ b/spark/v3.3/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestWriteAborts.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.util.List;
import java.util.Map;
import org.apache.hadoop.conf.Configuration;
@@ -38,7 +40,6 @@ import org.apache.spark.SparkException;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Rule;
import org.junit.Test;
@@ -105,7 +106,7 @@ public class TestWriteAborts extends SparkExtensionsTestBase {
new SimpleRecord(4, "b"));
Dataset<Row> inputDF = spark.createDataFrame(records, SimpleRecord.class);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
try {
// incoming records are not ordered by partitions so the job must fail
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/TestDataFileSerialization.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/TestDataFileSerialization.java
index 33b5316b72..2a7d3d4c33 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/TestDataFileSerialization.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/TestDataFileSerialization.java
@@ -21,6 +21,7 @@ package org.apache.iceberg;
import static org.apache.iceberg.TaskCheckHelper.assertEquals;
import static org.apache.iceberg.types.Types.NestedField.optional;
import static org.apache.iceberg.types.Types.NestedField.required;
+import static org.assertj.core.api.Assertions.assertThat;
import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
@@ -48,7 +49,6 @@ import org.apache.iceberg.types.Types;
import org.apache.spark.SparkConf;
import org.apache.spark.serializer.KryoSerializer;
import org.apache.spark.sql.catalyst.InternalRow;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Rule;
import org.junit.Test;
@@ -118,7 +118,7 @@ public class TestDataFileSerialization {
try (Input in = new Input(new FileInputStream(data))) {
for (int i = 0; i < 2; i += 1) {
Object obj = kryo.readClassAndObject(in);
- Assertions.assertThat(obj).as("Should be a DataFile").isInstanceOf(DataFile.class);
+ assertThat(obj).as("Should be a DataFile").isInstanceOf(DataFile.class);
assertEquals(DATA_FILE, (DataFile) obj);
}
}
@@ -136,7 +136,7 @@ public class TestDataFileSerialization {
new ObjectInputStream(new ByteArrayInputStream(bytes.toByteArray()))) {
for (int i = 0; i < 2; i += 1) {
Object obj = in.readObject();
- Assertions.assertThat(obj).as("Should be a DataFile").isInstanceOf(DataFile.class);
+ assertThat(obj).as("Should be a DataFile").isInstanceOf(DataFile.class);
assertEquals(DATA_FILE, (DataFile) obj);
}
}
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/TestManifestFileSerialization.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/TestManifestFileSerialization.java
index 92a646d386..a42781f952 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/TestManifestFileSerialization.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/TestManifestFileSerialization.java
@@ -20,6 +20,7 @@ package org.apache.iceberg;
import static org.apache.iceberg.types.Types.NestedField.optional;
import static org.apache.iceberg.types.Types.NestedField.required;
+import static org.assertj.core.api.Assertions.assertThat;
import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
@@ -43,7 +44,6 @@ import org.apache.iceberg.relocated.com.google.common.collect.ImmutableMap;
import org.apache.iceberg.types.Types;
import org.apache.spark.SparkConf;
import org.apache.spark.serializer.KryoSerializer;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Rule;
import org.junit.Test;
@@ -119,7 +119,7 @@ public class TestManifestFileSerialization {
try (Input in = new Input(new FileInputStream(data))) {
for (int i = 0; i < 3; i += 1) {
Object obj = kryo.readClassAndObject(in);
- Assertions.assertThat(obj).as("Should be a ManifestFile").isInstanceOf(ManifestFile.class);
+ assertThat(obj).as("Should be a ManifestFile").isInstanceOf(ManifestFile.class);
checkManifestFile(manifest, (ManifestFile) obj);
}
}
@@ -141,7 +141,7 @@ public class TestManifestFileSerialization {
new ObjectInputStream(new ByteArrayInputStream(bytes.toByteArray()))) {
for (int i = 0; i < 3; i += 1) {
Object obj = in.readObject();
- Assertions.assertThat(obj).as("Should be a ManifestFile").isInstanceOf(ManifestFile.class);
+ assertThat(obj).as("Should be a ManifestFile").isInstanceOf(ManifestFile.class);
checkManifestFile(manifest, (ManifestFile) obj);
}
}
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/TestScanTaskSerialization.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/TestScanTaskSerialization.java
index 14e9e7f605..f37d58c664 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/TestScanTaskSerialization.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/TestScanTaskSerialization.java
@@ -19,6 +19,7 @@
package org.apache.iceberg;
import static org.apache.iceberg.types.Types.NestedField.optional;
+import static org.assertj.core.api.Assertions.assertThat;
import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
@@ -46,7 +47,6 @@ import org.apache.spark.SparkConf;
import org.apache.spark.serializer.KryoSerializer;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
@@ -86,7 +86,7 @@ public class TestScanTaskSerialization extends SparkTestBase {
try (Input in = new Input(new FileInputStream(data))) {
Object obj = kryo.readClassAndObject(in);
- Assertions.assertThat(obj)
+ assertThat(obj)
.as("Should be a BaseCombinedScanTask")
.isInstanceOf(BaseCombinedScanTask.class);
TaskCheckHelper.assertEquals(scanTask, (BaseCombinedScanTask) obj);
@@ -105,7 +105,7 @@ public class TestScanTaskSerialization extends SparkTestBase {
try (ObjectInputStream in =
new ObjectInputStream(new ByteArrayInputStream(bytes.toByteArray()))) {
Object obj = in.readObject();
- Assertions.assertThat(obj)
+ assertThat(obj)
.as("Should be a BaseCombinedScanTask")
.isInstanceOf(BaseCombinedScanTask.class);
TaskCheckHelper.assertEquals(scanTask, (BaseCombinedScanTask) obj);
@@ -129,9 +129,7 @@ public class TestScanTaskSerialization extends SparkTestBase {
try (Input in = new Input(Files.newInputStream(data.toPath()))) {
Object obj = kryo.readClassAndObject(in);
- Assertions.assertThat(obj)
- .as("should be a BaseScanTaskGroup")
- .isInstanceOf(BaseScanTaskGroup.class);
+ assertThat(obj).as("should be a BaseScanTaskGroup").isInstanceOf(BaseScanTaskGroup.class);
TaskCheckHelper.assertEquals(taskGroup, (BaseScanTaskGroup<FileScanTask>) obj);
}
}
@@ -151,9 +149,7 @@ public class TestScanTaskSerialization extends SparkTestBase {
try (ObjectInputStream in =
new ObjectInputStream(new ByteArrayInputStream(bytes.toByteArray()))) {
Object obj = in.readObject();
- Assertions.assertThat(obj)
- .as("should be a BaseScanTaskGroup")
- .isInstanceOf(BaseScanTaskGroup.class);
+ assertThat(obj).as("should be a BaseScanTaskGroup").isInstanceOf(BaseScanTaskGroup.class);
TaskCheckHelper.assertEquals(taskGroup, (BaseScanTaskGroup<FileScanTask>) obj);
}
}
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/ValidationHelpers.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/ValidationHelpers.java
index 70ab04f0a0..b0b3085dca 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/ValidationHelpers.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/ValidationHelpers.java
@@ -18,11 +18,12 @@
*/
package org.apache.iceberg;
+import static org.assertj.core.api.Assertions.assertThat;
+
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import org.apache.iceberg.relocated.com.google.common.collect.Lists;
-import org.assertj.core.api.Assertions;
public class ValidationHelpers {
@@ -72,6 +73,6 @@ public class ValidationHelpers {
private static <T> void assertSameElements(String context, List<T> actual, List<T> expected) {
String errorMessage = String.format("%s must match", context);
- Assertions.assertThat(actual).as(errorMessage).hasSameElementsAs(expected);
+ assertThat(actual).as(errorMessage).hasSameElementsAs(expected);
}
}
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/TestFunctionCatalog.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/TestFunctionCatalog.java
index d224e175d3..cacb85147f 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/TestFunctionCatalog.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/TestFunctionCatalog.java
@@ -18,6 +18,9 @@
*/
package org.apache.iceberg.spark;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import org.apache.iceberg.IcebergBuild;
import org.apache.iceberg.relocated.com.google.common.collect.ImmutableList;
import org.apache.iceberg.spark.functions.IcebergVersionFunction;
@@ -27,7 +30,6 @@ import org.apache.spark.sql.catalyst.analysis.NoSuchNamespaceException;
import org.apache.spark.sql.connector.catalog.FunctionCatalog;
import org.apache.spark.sql.connector.catalog.Identifier;
import org.apache.spark.sql.connector.catalog.functions.UnboundFunction;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
@@ -56,10 +58,10 @@ public class TestFunctionCatalog extends SparkTestBaseWithCatalog {
@Test
public void testListFunctionsViaCatalog() throws NoSuchNamespaceException {
- Assertions.assertThat(asFunctionCatalog.listFunctions(EMPTY_NAMESPACE))
+ assertThat(asFunctionCatalog.listFunctions(EMPTY_NAMESPACE))
.anyMatch(func -> "iceberg_version".equals(func.name()));
- Assertions.assertThat(asFunctionCatalog.listFunctions(SYSTEM_NAMESPACE))
+ assertThat(asFunctionCatalog.listFunctions(SYSTEM_NAMESPACE))
.anyMatch(func -> "iceberg_version".equals(func.name()));
Assert.assertArrayEquals(
@@ -67,7 +69,7 @@ public class TestFunctionCatalog extends SparkTestBaseWithCatalog {
new Identifier[0],
asFunctionCatalog.listFunctions(DEFAULT_NAMESPACE));
- Assertions.assertThatThrownBy(() -> asFunctionCatalog.listFunctions(DB_NAMESPACE))
+ assertThatThrownBy(() -> asFunctionCatalog.listFunctions(DB_NAMESPACE))
.as("Listing functions in a namespace that does not exist should throw")
.isInstanceOf(NoSuchNamespaceException.class)
.hasMessageContaining("Namespace 'db' not found");
@@ -79,13 +81,13 @@ public class TestFunctionCatalog extends SparkTestBaseWithCatalog {
Identifier identifier = Identifier.of(namespace, "iceberg_version");
UnboundFunction func = asFunctionCatalog.loadFunction(identifier);
- Assertions.assertThat(func)
+ assertThat(func)
.isNotNull()
.isInstanceOf(UnboundFunction.class)
.isExactlyInstanceOf(IcebergVersionFunction.class);
}
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
asFunctionCatalog.loadFunction(Identifier.of(DEFAULT_NAMESPACE, "iceberg_version")))
.as(
@@ -94,12 +96,12 @@ public class TestFunctionCatalog extends SparkTestBaseWithCatalog {
.hasMessageContaining("Undefined function: default.iceberg_version");
Identifier undefinedFunction = Identifier.of(SYSTEM_NAMESPACE, "undefined_function");
- Assertions.assertThatThrownBy(() -> asFunctionCatalog.loadFunction(undefinedFunction))
+ assertThatThrownBy(() -> asFunctionCatalog.loadFunction(undefinedFunction))
.as("Cannot load a function that does not exist")
.isInstanceOf(NoSuchFunctionException.class)
.hasMessageContaining("Undefined function: system.undefined_function");
- Assertions.assertThatThrownBy(() -> sql("SELECT undefined_function(1, 2)"))
+ assertThatThrownBy(() -> sql("SELECT undefined_function(1, 2)"))
.as("Using an undefined function from SQL should fail analysis")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Undefined function");
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/TestSparkTableUtil.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/TestSparkTableUtil.java
index 1e51caadd0..51c8d9643c 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/TestSparkTableUtil.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/TestSparkTableUtil.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark;
+import static org.assertj.core.api.Assertions.assertThat;
+
import java.io.IOException;
import java.util.Map;
import org.apache.iceberg.KryoHelpers;
@@ -27,7 +29,6 @@ import org.apache.iceberg.TableProperties;
import org.apache.iceberg.TestHelpers;
import org.apache.iceberg.relocated.com.google.common.collect.ImmutableMap;
import org.apache.iceberg.spark.SparkTableUtil.SparkPartition;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Test;
@@ -40,7 +41,7 @@ public class TestSparkTableUtil {
SparkPartition sparkPartition = new SparkPartition(values, uri, format);
SparkPartition deserialized = KryoHelpers.roundTripSerialize(sparkPartition);
- Assertions.assertThat(sparkPartition).isEqualTo(deserialized);
+ assertThat(sparkPartition).isEqualTo(deserialized);
}
@Test
@@ -51,7 +52,7 @@ public class TestSparkTableUtil {
SparkPartition sparkPartition = new SparkPartition(values, uri, format);
SparkPartition deserialized = TestHelpers.roundTripSerialize(sparkPartition);
- Assertions.assertThat(sparkPartition).isEqualTo(deserialized);
+ assertThat(sparkPartition).isEqualTo(deserialized);
}
@Test
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/actions/TestDeleteReachableFilesAction.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/actions/TestDeleteReachableFilesAction.java
index 5b1cf82817..6d1bbc2c18 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/actions/TestDeleteReachableFilesAction.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/actions/TestDeleteReachableFilesAction.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.actions;
import static org.apache.iceberg.types.Types.NestedField.optional;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.File;
import java.util.Set;
@@ -50,7 +51,6 @@ import org.apache.iceberg.relocated.com.google.common.collect.Maps;
import org.apache.iceberg.relocated.com.google.common.collect.Sets;
import org.apache.iceberg.spark.SparkTestBase;
import org.apache.iceberg.types.Types;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
@@ -362,7 +362,7 @@ public class TestDeleteReachableFilesAction extends SparkTestBase {
public void testEmptyIOThrowsException() {
DeleteReachableFiles baseRemoveFilesSparkAction =
sparkActions().deleteReachableFiles(metadataLocation(table)).io(null);
- Assertions.assertThatThrownBy(baseRemoveFilesSparkAction::execute)
+ assertThatThrownBy(baseRemoveFilesSparkAction::execute)
.as("FileIO can't be null in DeleteReachableFiles action")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("File IO cannot be null");
@@ -372,8 +372,7 @@ public class TestDeleteReachableFilesAction extends SparkTestBase {
public void testRemoveFilesActionWhenGarbageCollectionDisabled() {
table.updateProperties().set(TableProperties.GC_ENABLED, "false").commit();
- Assertions.assertThatThrownBy(
- () -> sparkActions().deleteReachableFiles(metadataLocation(table)).execute())
+ assertThatThrownBy(() -> sparkActions().deleteReachableFiles(metadataLocation(table)).execute())
.as("Should complain about removing files when GC is disabled")
.isInstanceOf(ValidationException.class)
.hasMessageContaining(
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/actions/TestExpireSnapshotsAction.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/actions/TestExpireSnapshotsAction.java
index a3580bd2d9..71339b3242 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/actions/TestExpireSnapshotsAction.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/actions/TestExpireSnapshotsAction.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.actions;
import static org.apache.iceberg.types.Types.NestedField.optional;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.File;
import java.io.IOException;
@@ -56,7 +57,6 @@ import org.apache.iceberg.spark.SparkTestBase;
import org.apache.iceberg.spark.data.TestHelpers;
import org.apache.iceberg.types.Types;
import org.apache.spark.sql.Dataset;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
@@ -447,7 +447,7 @@ public class TestExpireSnapshotsAction extends SparkTestBase {
table.newAppend().appendFile(FILE_A).commit();
- Assertions.assertThatThrownBy(() -> SparkActions.get().expireSnapshots(table))
+ assertThatThrownBy(() -> SparkActions.get().expireSnapshots(table))
.as("Should complain about expiring snapshots")
.isInstanceOf(ValidationException.class)
.hasMessageContaining("Cannot expire snapshots: GC is disabled");
@@ -528,8 +528,7 @@ public class TestExpireSnapshotsAction extends SparkTestBase {
@Test
public void testRetainZeroSnapshots() {
- Assertions.assertThatThrownBy(
- () -> SparkActions.get().expireSnapshots(table).retainLast(0).execute())
+ assertThatThrownBy(() -> SparkActions.get().expireSnapshots(table).retainLast(0).execute())
.as(
"Should fail retain 0 snapshots "
+ "because number of snapshots to retain cannot be zero")
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/actions/TestRemoveOrphanFilesAction.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/actions/TestRemoveOrphanFilesAction.java
index 10af2454fa..0757286449 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/actions/TestRemoveOrphanFilesAction.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/actions/TestRemoveOrphanFilesAction.java
@@ -19,6 +19,8 @@
package org.apache.iceberg.spark.actions;
import static org.apache.iceberg.types.Types.NestedField.optional;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.File;
import java.io.IOException;
@@ -78,7 +80,6 @@ import org.apache.spark.sql.Row;
import org.apache.spark.sql.RowFactory;
import org.apache.spark.sql.types.DataTypes;
import org.apache.spark.sql.types.StructType;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
@@ -754,7 +755,7 @@ public abstract class TestRemoveOrphanFilesAction extends SparkTestBase {
table.updateProperties().set(TableProperties.GC_ENABLED, "false").commit();
- Assertions.assertThatThrownBy(() -> SparkActions.get().deleteOrphanFiles(table).execute())
+ assertThatThrownBy(() -> SparkActions.get().deleteOrphanFiles(table).execute())
.as("Should complain about removing orphan files")
.isInstanceOf(ValidationException.class)
.hasMessageContaining("Cannot delete orphan files: GC is disabled");
@@ -942,8 +943,8 @@ public abstract class TestRemoveOrphanFilesAction extends SparkTestBase {
.olderThan(System.currentTimeMillis() + 1000)
.execute();
- Assertions.assertThat(statsLocation.exists()).as("stats file should exist").isTrue();
- Assertions.assertThat(statsLocation.length())
+ assertThat(statsLocation.exists()).as("stats file should exist").isTrue();
+ assertThat(statsLocation.length())
.as("stats file length")
.isEqualTo(statisticsFile.fileSizeInBytes());
@@ -957,11 +958,11 @@ public abstract class TestRemoveOrphanFilesAction extends SparkTestBase {
.olderThan(System.currentTimeMillis() + 1000)
.execute();
Iterable<String> orphanFileLocations = result.orphanFileLocations();
- Assertions.assertThat(orphanFileLocations).as("Should be orphan files").hasSize(1);
- Assertions.assertThat(Iterables.getOnlyElement(orphanFileLocations))
+ assertThat(orphanFileLocations).as("Should be orphan files").hasSize(1);
+ assertThat(Iterables.getOnlyElement(orphanFileLocations))
.as("Deleted file")
.isEqualTo(statsLocation.toURI().toString());
- Assertions.assertThat(statsLocation.exists()).as("stats file should be deleted").isFalse();
+ assertThat(statsLocation.exists()).as("stats file should be deleted").isFalse();
}
@Test
@@ -989,7 +990,7 @@ public abstract class TestRemoveOrphanFilesAction extends SparkTestBase {
public void testPathsWithEqualSchemes() {
List<String> validFiles = Lists.newArrayList("scheme1://bucket1/dir1/dir2/file1");
List<String> actualFiles = Lists.newArrayList("scheme2://bucket1/dir1/dir2/file1");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
executeTest(
validFiles,
@@ -1018,7 +1019,7 @@ public abstract class TestRemoveOrphanFilesAction extends SparkTestBase {
public void testPathsWithEqualAuthorities() {
List<String> validFiles = Lists.newArrayList("hdfs://servicename1/dir1/dir2/file1");
List<String> actualFiles = Lists.newArrayList("hdfs://servicename2/dir1/dir2/file1");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
executeTest(
validFiles,
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/actions/TestRewriteDataFilesAction.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/actions/TestRewriteDataFilesAction.java
index 5e8865dff2..2934494bba 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/actions/TestRewriteDataFilesAction.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/actions/TestRewriteDataFilesAction.java
@@ -25,6 +25,7 @@ import static org.apache.spark.sql.functions.current_date;
import static org.apache.spark.sql.functions.date_add;
import static org.apache.spark.sql.functions.expr;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.doAnswer;
@@ -105,7 +106,6 @@ import org.apache.iceberg.util.Pair;
import org.apache.iceberg.util.StructLikeMap;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
@@ -642,7 +642,7 @@ public class TestRewriteDataFilesAction extends SparkTestBase {
.when(spyRewrite)
.rewriteFiles(any(), argThat(failGroup));
- Assertions.assertThatThrownBy(() -> spyRewrite.execute())
+ assertThatThrownBy(() -> spyRewrite.execute())
.as("Should fail entire rewrite if part fails")
.isInstanceOf(RuntimeException.class)
.hasMessage("Rewrite Failed");
@@ -677,7 +677,7 @@ public class TestRewriteDataFilesAction extends SparkTestBase {
doReturn(util).when(spyRewrite).commitManager(table.currentSnapshot().snapshotId());
- Assertions.assertThatThrownBy(() -> spyRewrite.execute())
+ assertThatThrownBy(() -> spyRewrite.execute())
.as("Should fail entire rewrite if commit fails")
.isInstanceOf(RuntimeException.class)
.hasMessage("Commit Failure");
@@ -713,7 +713,7 @@ public class TestRewriteDataFilesAction extends SparkTestBase {
.when(spyRewrite)
.rewriteFiles(any(), argThat(failGroup));
- Assertions.assertThatThrownBy(() -> spyRewrite.execute())
+ assertThatThrownBy(() -> spyRewrite.execute())
.as("Should fail entire rewrite if part fails")
.isInstanceOf(RuntimeException.class)
.hasMessage("Rewrite Failed");
@@ -858,7 +858,7 @@ public class TestRewriteDataFilesAction extends SparkTestBase {
public void testInvalidOptions() {
Table table = createTable(20);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
basicRewrite(table)
.option(RewriteDataFiles.PARTIAL_PROGRESS_ENABLED, "true")
@@ -870,7 +870,7 @@ public class TestRewriteDataFilesAction extends SparkTestBase {
"Cannot set partial-progress.max-commits to -5, "
+ "the value must be positive when partial-progress.enabled is true");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
basicRewrite(table)
.option(RewriteDataFiles.MAX_CONCURRENT_FILE_GROUP_REWRITES, "-5")
@@ -880,13 +880,13 @@ public class TestRewriteDataFilesAction extends SparkTestBase {
.hasMessage(
"Cannot set max-concurrent-file-group-rewrites to -5, the value must be positive.");
- Assertions.assertThatThrownBy(() -> basicRewrite(table).option("foobarity", "-5").execute())
+ assertThatThrownBy(() -> basicRewrite(table).option("foobarity", "-5").execute())
.as("No unknown options allowed")
.isInstanceOf(IllegalArgumentException.class)
.hasMessage(
"Cannot use options [foobarity], they are not supported by the action or the rewriter BIN-PACK");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> basicRewrite(table).option(RewriteDataFiles.REWRITE_JOB_ORDER, "foo").execute())
.as("Cannot set rewrite-job-order to foo")
.isInstanceOf(IllegalArgumentException.class)
@@ -1126,7 +1126,7 @@ public class TestRewriteDataFilesAction extends SparkTestBase {
doReturn(util).when(spyAction).commitManager(table.currentSnapshot().snapshotId());
- Assertions.assertThatThrownBy(() -> spyAction.execute())
+ assertThatThrownBy(() -> spyAction.execute())
.as("Should propagate CommitStateUnknown Exception")
.isInstanceOf(CommitStateUnknownException.class)
.hasMessageStartingWith(
@@ -1246,17 +1246,17 @@ public class TestRewriteDataFilesAction extends SparkTestBase {
SortOrder sortOrder = SortOrder.builderFor(table.schema()).asc("c2").build();
- Assertions.assertThatThrownBy(() -> actions().rewriteDataFiles(table).binPack().sort())
+ assertThatThrownBy(() -> actions().rewriteDataFiles(table).binPack().sort())
.as("Should be unable to set Strategy more than once")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Must use only one rewriter type");
- Assertions.assertThatThrownBy(() -> actions().rewriteDataFiles(table).sort(sortOrder).binPack())
+ assertThatThrownBy(() -> actions().rewriteDataFiles(table).sort(sortOrder).binPack())
.as("Should be unable to set Strategy more than once")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Must use only one rewriter type");
- Assertions.assertThatThrownBy(() -> actions().rewriteDataFiles(table).sort(sortOrder).binPack())
+ assertThatThrownBy(() -> actions().rewriteDataFiles(table).sort(sortOrder).binPack())
.as("Should be unable to set Strategy more than once")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Must use only one rewriter type");
@@ -1439,7 +1439,7 @@ public class TestRewriteDataFilesAction extends SparkTestBase {
public void testBinpackRewriteWithInvalidOutputSpecId() {
Table table = createTable(10);
shouldHaveFiles(table, 10);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
actions()
.rewriteDataFiles(table)
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/actions/TestRewriteManifestsAction.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/actions/TestRewriteManifestsAction.java
index 339bb1db32..f8e6abffb4 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/actions/TestRewriteManifestsAction.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/actions/TestRewriteManifestsAction.java
@@ -25,6 +25,7 @@ import static org.apache.iceberg.ValidationHelpers.snapshotIds;
import static org.apache.iceberg.ValidationHelpers.validateDataManifest;
import static org.apache.iceberg.types.Types.NestedField.optional;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assumptions.assumeThat;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.spy;
@@ -58,7 +59,6 @@ import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Encoders;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.TableIdentifier;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
@@ -231,7 +231,7 @@ public class TestRewriteManifestsAction extends SparkTestBase {
Table spyTable = spy(table);
when(spyTable.rewriteManifests()).thenReturn(spyNewRewriteManifests);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> actions.rewriteManifests(spyTable).rewriteIf(manifest -> true).execute())
.as("Should throw a Commit State Unknown Exception")
.cause()
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/actions/TestSparkFileRewriter.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/actions/TestSparkFileRewriter.java
index 6800ffd404..eef8fb4346 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/actions/TestSparkFileRewriter.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/actions/TestSparkFileRewriter.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.actions;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.util.List;
import java.util.Map;
import org.apache.iceberg.FileScanTask;
@@ -37,7 +39,6 @@ import org.apache.iceberg.spark.SparkTestBase;
import org.apache.iceberg.types.Types.IntegerType;
import org.apache.iceberg.types.Types.NestedField;
import org.apache.iceberg.types.Types.StringType;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
@@ -199,16 +200,15 @@ public class TestSparkFileRewriter extends SparkTestBase {
public void testInvalidConstructorUsagesSortData() {
Table table = catalog.createTable(TABLE_IDENT, SCHEMA);
- Assertions.assertThatThrownBy(() -> new SparkSortDataRewriter(spark, table))
+ assertThatThrownBy(() -> new SparkSortDataRewriter(spark, table))
.hasMessageContaining("Cannot sort data without a valid sort order")
.hasMessageContaining("is unsorted and no sort order is provided");
- Assertions.assertThatThrownBy(() -> new SparkSortDataRewriter(spark, table, null))
+ assertThatThrownBy(() -> new SparkSortDataRewriter(spark, table, null))
.hasMessageContaining("Cannot sort data without a valid sort order")
.hasMessageContaining("the provided sort order is null or empty");
- Assertions.assertThatThrownBy(
- () -> new SparkSortDataRewriter(spark, table, SortOrder.unsorted()))
+ assertThatThrownBy(() -> new SparkSortDataRewriter(spark, table, SortOrder.unsorted()))
.hasMessageContaining("Cannot sort data without a valid sort order")
.hasMessageContaining("the provided sort order is null or empty");
}
@@ -217,20 +217,17 @@ public class TestSparkFileRewriter extends SparkTestBase {
public void testInvalidConstructorUsagesZOrderData() {
Table table = catalog.createTable(TABLE_IDENT, SCHEMA, SPEC);
- Assertions.assertThatThrownBy(() -> new SparkZOrderDataRewriter(spark, table, null))
+ assertThatThrownBy(() -> new SparkZOrderDataRewriter(spark, table, null))
.hasMessageContaining("Cannot ZOrder when no columns are specified");
- Assertions.assertThatThrownBy(
- () -> new SparkZOrderDataRewriter(spark, table, ImmutableList.of()))
+ assertThatThrownBy(() -> new SparkZOrderDataRewriter(spark, table, ImmutableList.of()))
.hasMessageContaining("Cannot ZOrder when no columns are specified");
- Assertions.assertThatThrownBy(
- () -> new SparkZOrderDataRewriter(spark, table, ImmutableList.of("dep")))
+ assertThatThrownBy(() -> new SparkZOrderDataRewriter(spark, table, ImmutableList.of("dep")))
.hasMessageContaining("Cannot ZOrder")
.hasMessageContaining("all columns provided were identity partition columns");
- Assertions.assertThatThrownBy(
- () -> new SparkZOrderDataRewriter(spark, table, ImmutableList.of("DeP")))
+ assertThatThrownBy(() -> new SparkZOrderDataRewriter(spark, table, ImmutableList.of("DeP")))
.hasMessageContaining("Cannot ZOrder")
.hasMessageContaining("all columns provided were identity partition columns");
}
@@ -303,7 +300,7 @@ public class TestSparkFileRewriter extends SparkTestBase {
Map<String, String> invalidDeleteThresholdOptions =
ImmutableMap.of(SizeBasedDataRewriter.DELETE_FILE_THRESHOLD, "-1");
- Assertions.assertThatThrownBy(() -> rewriter.init(invalidDeleteThresholdOptions))
+ assertThatThrownBy(() -> rewriter.init(invalidDeleteThresholdOptions))
.hasMessageContaining("'delete-file-threshold' is set to -1 but must be >= 0");
}
@@ -316,12 +313,12 @@ public class TestSparkFileRewriter extends SparkTestBase {
Map<String, String> invalidDeleteThresholdOptions =
ImmutableMap.of(SizeBasedDataRewriter.DELETE_FILE_THRESHOLD, "-1");
- Assertions.assertThatThrownBy(() -> rewriter.init(invalidDeleteThresholdOptions))
+ assertThatThrownBy(() -> rewriter.init(invalidDeleteThresholdOptions))
.hasMessageContaining("'delete-file-threshold' is set to -1 but must be >= 0");
Map<String, String> invalidCompressionFactorOptions =
ImmutableMap.of(SparkShufflingDataRewriter.COMPRESSION_FACTOR, "0");
- Assertions.assertThatThrownBy(() -> rewriter.init(invalidCompressionFactorOptions))
+ assertThatThrownBy(() -> rewriter.init(invalidCompressionFactorOptions))
.hasMessageContaining("'compression-factor' is set to 0.0 but must be > 0");
}
@@ -335,23 +332,23 @@ public class TestSparkFileRewriter extends SparkTestBase {
Map<String, String> invalidDeleteThresholdOptions =
ImmutableMap.of(SizeBasedDataRewriter.DELETE_FILE_THRESHOLD, "-1");
- Assertions.assertThatThrownBy(() -> rewriter.init(invalidDeleteThresholdOptions))
+ assertThatThrownBy(() -> rewriter.init(invalidDeleteThresholdOptions))
.hasMessageContaining("'delete-file-threshold' is set to -1 but must be >= 0");
Map<String, String> invalidCompressionFactorOptions =
ImmutableMap.of(SparkShufflingDataRewriter.COMPRESSION_FACTOR, "0");
- Assertions.assertThatThrownBy(() -> rewriter.init(invalidCompressionFactorOptions))
+ assertThatThrownBy(() -> rewriter.init(invalidCompressionFactorOptions))
.hasMessageContaining("'compression-factor' is set to 0.0 but must be > 0");
Map<String, String> invalidMaxOutputOptions =
ImmutableMap.of(SparkZOrderDataRewriter.MAX_OUTPUT_SIZE, "0");
- Assertions.assertThatThrownBy(() -> rewriter.init(invalidMaxOutputOptions))
+ assertThatThrownBy(() -> rewriter.init(invalidMaxOutputOptions))
.hasMessageContaining("Cannot have the interleaved ZOrder value use less than 1 byte")
.hasMessageContaining("'max-output-size' was set to 0");
Map<String, String> invalidVarLengthContributionOptions =
ImmutableMap.of(SparkZOrderDataRewriter.VAR_LENGTH_CONTRIBUTION, "0");
- Assertions.assertThatThrownBy(() -> rewriter.init(invalidVarLengthContributionOptions))
+ assertThatThrownBy(() -> rewriter.init(invalidVarLengthContributionOptions))
.hasMessageContaining("Cannot use less than 1 byte for variable length types with ZOrder")
.hasMessageContaining("'var-length-contribution' was set to 0");
}
@@ -359,19 +356,19 @@ public class TestSparkFileRewriter extends SparkTestBase {
private void validateSizeBasedRewriterOptions(SizeBasedFileRewriter<?, ?> rewriter) {
Map<String, String> invalidTargetSizeOptions =
ImmutableMap.of(SizeBasedFileRewriter.TARGET_FILE_SIZE_BYTES, "0");
- Assertions.assertThatThrownBy(() -> rewriter.init(invalidTargetSizeOptions))
+ assertThatThrownBy(() -> rewriter.init(invalidTargetSizeOptions))
.hasMessageContaining("'target-file-size-bytes' is set to 0 but must be > 0");
Map<String, String> invalidMinSizeOptions =
ImmutableMap.of(SizeBasedFileRewriter.MIN_FILE_SIZE_BYTES, "-1");
- Assertions.assertThatThrownBy(() -> rewriter.init(invalidMinSizeOptions))
+ assertThatThrownBy(() -> rewriter.init(invalidMinSizeOptions))
.hasMessageContaining("'min-file-size-bytes' is set to -1 but must be >= 0");
Map<String, String> invalidTargetMinSizeOptions =
ImmutableMap.of(
SizeBasedFileRewriter.TARGET_FILE_SIZE_BYTES, "3",
SizeBasedFileRewriter.MIN_FILE_SIZE_BYTES, "5");
- Assertions.assertThatThrownBy(() -> rewriter.init(invalidTargetMinSizeOptions))
+ assertThatThrownBy(() -> rewriter.init(invalidTargetMinSizeOptions))
.hasMessageContaining("'target-file-size-bytes' (3) must be > 'min-file-size-bytes' (5)")
.hasMessageContaining("all new files will be smaller than the min threshold");
@@ -379,18 +376,18 @@ public class TestSparkFileRewriter extends SparkTestBase {
ImmutableMap.of(
SizeBasedFileRewriter.TARGET_FILE_SIZE_BYTES, "5",
SizeBasedFileRewriter.MAX_FILE_SIZE_BYTES, "3");
- Assertions.assertThatThrownBy(() -> rewriter.init(invalidTargetMaxSizeOptions))
+ assertThatThrownBy(() -> rewriter.init(invalidTargetMaxSizeOptions))
.hasMessageContaining("'target-file-size-bytes' (5) must be < 'max-file-size-bytes' (3)")
.hasMessageContaining("all new files will be larger than the max threshold");
Map<String, String> invalidMinInputFilesOptions =
ImmutableMap.of(SizeBasedFileRewriter.MIN_INPUT_FILES, "0");
- Assertions.assertThatThrownBy(() -> rewriter.init(invalidMinInputFilesOptions))
+ assertThatThrownBy(() -> rewriter.init(invalidMinInputFilesOptions))
.hasMessageContaining("'min-input-files' is set to 0 but must be > 0");
Map<String, String> invalidMaxFileGroupSizeOptions =
ImmutableMap.of(SizeBasedFileRewriter.MAX_FILE_GROUP_SIZE_BYTES, "0");
- Assertions.assertThatThrownBy(() -> rewriter.init(invalidMaxFileGroupSizeOptions))
+ assertThatThrownBy(() -> rewriter.init(invalidMaxFileGroupSizeOptions))
.hasMessageContaining("'max-file-group-size-bytes' is set to 0 but must be > 0");
}
}
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/data/GenericsHelpers.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/data/GenericsHelpers.java
index a96e3b1f57..256f287474 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/data/GenericsHelpers.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/data/GenericsHelpers.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.data;
import static org.apache.iceberg.spark.SparkSchemaUtil.convert;
+import static org.assertj.core.api.Assertions.assertThat;
import static scala.collection.JavaConverters.mapAsJavaMapConverter;
import static scala.collection.JavaConverters.seqAsJavaListConverter;
@@ -47,7 +48,6 @@ import org.apache.spark.sql.catalyst.util.ArrayData;
import org.apache.spark.sql.catalyst.util.MapData;
import org.apache.spark.sql.types.Decimal;
import org.apache.spark.unsafe.types.UTF8String;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import scala.collection.Seq;
@@ -119,79 +119,69 @@ public class GenericsHelpers {
Assert.assertEquals("Primitive value should be equal to expected", expected, actual);
break;
case DATE:
- Assertions.assertThat(expected)
- .as("Should expect a LocalDate")
- .isInstanceOf(LocalDate.class);
- Assertions.assertThat(actual).as("Should be a Date").isInstanceOf(Date.class);
+ assertThat(expected).as("Should expect a LocalDate").isInstanceOf(LocalDate.class);
+ assertThat(actual).as("Should be a Date").isInstanceOf(Date.class);
Assert.assertEquals(
"ISO-8601 date should be equal", expected.toString(), actual.toString());
break;
case TIMESTAMP:
- Assertions.assertThat(actual).as("Should be a Timestamp").isInstanceOf(Timestamp.class);
+ assertThat(actual).as("Should be a Timestamp").isInstanceOf(Timestamp.class);
Timestamp ts = (Timestamp) actual;
// milliseconds from nanos has already been added by getTime
OffsetDateTime actualTs =
EPOCH.plusNanos((ts.getTime() * 1_000_000) + (ts.getNanos() % 1_000_000));
Types.TimestampType timestampType = (Types.TimestampType) type;
if (timestampType.shouldAdjustToUTC()) {
- Assertions.assertThat(expected)
+ assertThat(expected)
.as("Should expect an OffsetDateTime")
.isInstanceOf(OffsetDateTime.class);
Assert.assertEquals("Timestamp should be equal", expected, actualTs);
} else {
- Assertions.assertThat(expected)
+ assertThat(expected)
.as("Should expect an LocalDateTime")
.isInstanceOf(LocalDateTime.class);
Assert.assertEquals("Timestamp should be equal", expected, actualTs.toLocalDateTime());
}
break;
case STRING:
- Assertions.assertThat(actual).as("Should be a String").isInstanceOf(String.class);
+ assertThat(actual).as("Should be a String").isInstanceOf(String.class);
Assert.assertEquals("Strings should be equal", String.valueOf(expected), actual);
break;
case UUID:
- Assertions.assertThat(expected).as("Should expect a UUID").isInstanceOf(UUID.class);
- Assertions.assertThat(actual).as("Should be a String").isInstanceOf(String.class);
+ assertThat(expected).as("Should expect a UUID").isInstanceOf(UUID.class);
+ assertThat(actual).as("Should be a String").isInstanceOf(String.class);
Assert.assertEquals("UUID string representation should match", expected.toString(), actual);
break;
case FIXED:
- Assertions.assertThat(expected).as("Should expect a byte[]").isInstanceOf(byte[].class);
- Assertions.assertThat(actual).as("Should be a byte[]").isInstanceOf(byte[].class);
+ assertThat(expected).as("Should expect a byte[]").isInstanceOf(byte[].class);
+ assertThat(actual).as("Should be a byte[]").isInstanceOf(byte[].class);
Assert.assertArrayEquals("Bytes should match", (byte[]) expected, (byte[]) actual);
break;
case BINARY:
- Assertions.assertThat(expected)
- .as("Should expect a ByteBuffer")
- .isInstanceOf(ByteBuffer.class);
- Assertions.assertThat(actual).as("Should be a byte[]").isInstanceOf(byte[].class);
+ assertThat(expected).as("Should expect a ByteBuffer").isInstanceOf(ByteBuffer.class);
+ assertThat(actual).as("Should be a byte[]").isInstanceOf(byte[].class);
Assert.assertArrayEquals(
"Bytes should match", ((ByteBuffer) expected).array(), (byte[]) actual);
break;
case DECIMAL:
- Assertions.assertThat(expected)
- .as("Should expect a BigDecimal")
- .isInstanceOf(BigDecimal.class);
- Assertions.assertThat(actual).as("Should be a BigDecimal").isInstanceOf(BigDecimal.class);
+ assertThat(expected).as("Should expect a BigDecimal").isInstanceOf(BigDecimal.class);
+ assertThat(actual).as("Should be a BigDecimal").isInstanceOf(BigDecimal.class);
Assert.assertEquals("BigDecimals should be equal", expected, actual);
break;
case STRUCT:
- Assertions.assertThat(expected).as("Should expect a Record").isInstanceOf(Record.class);
- Assertions.assertThat(actual).as("Should be a Row").isInstanceOf(Row.class);
+ assertThat(expected).as("Should expect a Record").isInstanceOf(Record.class);
+ assertThat(actual).as("Should be a Row").isInstanceOf(Row.class);
assertEqualsSafe(type.asNestedType().asStructType(), (Record) expected, (Row) actual);
break;
case LIST:
- Assertions.assertThat(expected)
- .as("Should expect a Collection")
- .isInstanceOf(Collection.class);
- Assertions.assertThat(actual).as("Should be a Seq").isInstanceOf(Seq.class);
+ assertThat(expected).as("Should expect a Collection").isInstanceOf(Collection.class);
+ assertThat(actual).as("Should be a Seq").isInstanceOf(Seq.class);
List<?> asList = seqAsJavaListConverter((Seq<?>) actual).asJava();
assertEqualsSafe(type.asNestedType().asListType(), (Collection<?>) expected, asList);
break;
case MAP:
- Assertions.assertThat(expected).as("Should expect a Collection").isInstanceOf(Map.class);
- Assertions.assertThat(actual)
- .as("Should be a Map")
- .isInstanceOf(scala.collection.Map.class);
+ assertThat(expected).as("Should expect a Collection").isInstanceOf(Map.class);
+ assertThat(actual).as("Should be a Map").isInstanceOf(scala.collection.Map.class);
Map<String, ?> asMap =
mapAsJavaMapConverter((scala.collection.Map<String, ?>) actual).asJava();
assertEqualsSafe(type.asNestedType().asMapType(), (Map<?, ?>) expected, asMap);
@@ -259,23 +249,21 @@ public class GenericsHelpers {
Assert.assertEquals("Primitive value should be equal to expected", expected, actual);
break;
case DATE:
- Assertions.assertThat(expected)
- .as("Should expect a LocalDate")
- .isInstanceOf(LocalDate.class);
+ assertThat(expected).as("Should expect a LocalDate").isInstanceOf(LocalDate.class);
int expectedDays = (int) ChronoUnit.DAYS.between(EPOCH_DAY, (LocalDate) expected);
Assert.assertEquals("Primitive value should be equal to expected", expectedDays, actual);
break;
case TIMESTAMP:
Types.TimestampType timestampType = (Types.TimestampType) type;
if (timestampType.shouldAdjustToUTC()) {
- Assertions.assertThat(expected)
+ assertThat(expected)
.as("Should expect an OffsetDateTime")
.isInstanceOf(OffsetDateTime.class);
long expectedMicros = ChronoUnit.MICROS.between(EPOCH, (OffsetDateTime) expected);
Assert.assertEquals(
"Primitive value should be equal to expected", expectedMicros, actual);
} else {
- Assertions.assertThat(expected)
+ assertThat(expected)
.as("Should expect an LocalDateTime")
.isInstanceOf(LocalDateTime.class);
long expectedMicros =
@@ -285,57 +273,47 @@ public class GenericsHelpers {
}
break;
case STRING:
- Assertions.assertThat(actual).as("Should be a UTF8String").isInstanceOf(UTF8String.class);
+ assertThat(actual).as("Should be a UTF8String").isInstanceOf(UTF8String.class);
Assert.assertEquals("Strings should be equal", expected, actual.toString());
break;
case UUID:
- Assertions.assertThat(expected).as("Should expect a UUID").isInstanceOf(UUID.class);
- Assertions.assertThat(actual).as("Should be a UTF8String").isInstanceOf(UTF8String.class);
+ assertThat(expected).as("Should expect a UUID").isInstanceOf(UUID.class);
+ assertThat(actual).as("Should be a UTF8String").isInstanceOf(UTF8String.class);
Assert.assertEquals(
"UUID string representation should match", expected.toString(), actual.toString());
break;
case FIXED:
- Assertions.assertThat(expected).as("Should expect a byte[]").isInstanceOf(byte[].class);
- Assertions.assertThat(actual).as("Should be a byte[]").isInstanceOf(byte[].class);
+ assertThat(expected).as("Should expect a byte[]").isInstanceOf(byte[].class);
+ assertThat(actual).as("Should be a byte[]").isInstanceOf(byte[].class);
Assert.assertArrayEquals("Bytes should match", (byte[]) expected, (byte[]) actual);
break;
case BINARY:
- Assertions.assertThat(expected)
- .as("Should expect a ByteBuffer")
- .isInstanceOf(ByteBuffer.class);
- Assertions.assertThat(actual).as("Should be a byte[]").isInstanceOf(byte[].class);
+ assertThat(expected).as("Should expect a ByteBuffer").isInstanceOf(ByteBuffer.class);
+ assertThat(actual).as("Should be a byte[]").isInstanceOf(byte[].class);
Assert.assertArrayEquals(
"Bytes should match", ((ByteBuffer) expected).array(), (byte[]) actual);
break;
case DECIMAL:
- Assertions.assertThat(expected)
- .as("Should expect a BigDecimal")
- .isInstanceOf(BigDecimal.class);
- Assertions.assertThat(actual).as("Should be a Decimal").isInstanceOf(Decimal.class);
+ assertThat(expected).as("Should expect a BigDecimal").isInstanceOf(BigDecimal.class);
+ assertThat(actual).as("Should be a Decimal").isInstanceOf(Decimal.class);
Assert.assertEquals(
"BigDecimals should be equal", expected, ((Decimal) actual).toJavaBigDecimal());
break;
case STRUCT:
- Assertions.assertThat(expected).as("Should expect a Record").isInstanceOf(Record.class);
- Assertions.assertThat(actual)
- .as("Should be an InternalRow")
- .isInstanceOf(InternalRow.class);
+ assertThat(expected).as("Should expect a Record").isInstanceOf(Record.class);
+ assertThat(actual).as("Should be an InternalRow").isInstanceOf(InternalRow.class);
assertEqualsUnsafe(
type.asNestedType().asStructType(), (Record) expected, (InternalRow) actual);
break;
case LIST:
- Assertions.assertThat(expected)
- .as("Should expect a Collection")
- .isInstanceOf(Collection.class);
- Assertions.assertThat(actual).as("Should be an ArrayData").isInstanceOf(ArrayData.class);
+ assertThat(expected).as("Should expect a Collection").isInstanceOf(Collection.class);
+ assertThat(actual).as("Should be an ArrayData").isInstanceOf(ArrayData.class);
assertEqualsUnsafe(
type.asNestedType().asListType(), (Collection<?>) expected, (ArrayData) actual);
break;
case MAP:
- Assertions.assertThat(expected).as("Should expect a Map").isInstanceOf(Map.class);
- Assertions.assertThat(actual)
- .as("Should be an ArrayBasedMapData")
- .isInstanceOf(MapData.class);
+ assertThat(expected).as("Should expect a Map").isInstanceOf(Map.class);
+ assertThat(actual).as("Should be an ArrayBasedMapData").isInstanceOf(MapData.class);
assertEqualsUnsafe(type.asNestedType().asMapType(), (Map<?, ?>) expected, (MapData) actual);
break;
case TIME:
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/data/TestHelpers.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/data/TestHelpers.java
index f2633fc676..4bd3531ab9 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/data/TestHelpers.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/data/TestHelpers.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.data;
import static org.apache.iceberg.spark.SparkSchemaUtil.convert;
+import static org.assertj.core.api.Assertions.assertThat;
import static scala.collection.JavaConverters.mapAsJavaMapConverter;
import static scala.collection.JavaConverters.seqAsJavaListConverter;
@@ -76,7 +77,6 @@ import org.apache.spark.sql.types.StructField;
import org.apache.spark.sql.types.StructType;
import org.apache.spark.sql.vectorized.ColumnarBatch;
import org.apache.spark.unsafe.types.UTF8String;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import scala.collection.Seq;
@@ -165,70 +165,60 @@ public class TestHelpers {
Assert.assertEquals("Primitive value should be equal to expected", expected, actual);
break;
case DATE:
- Assertions.assertThat(expected).as("Should be an int").isInstanceOf(Integer.class);
- Assertions.assertThat(actual).as("Should be a Date").isInstanceOf(Date.class);
+ assertThat(expected).as("Should be an int").isInstanceOf(Integer.class);
+ assertThat(actual).as("Should be a Date").isInstanceOf(Date.class);
int daysFromEpoch = (Integer) expected;
LocalDate date = ChronoUnit.DAYS.addTo(EPOCH_DAY, daysFromEpoch);
Assert.assertEquals("ISO-8601 date should be equal", date.toString(), actual.toString());
break;
case TIMESTAMP:
- Assertions.assertThat(expected).as("Should be a long").isInstanceOf(Long.class);
- Assertions.assertThat(actual).as("Should be a Timestamp").isInstanceOf(Timestamp.class);
+ assertThat(expected).as("Should be a long").isInstanceOf(Long.class);
+ assertThat(actual).as("Should be a Timestamp").isInstanceOf(Timestamp.class);
Timestamp ts = (Timestamp) actual;
// milliseconds from nanos has already been added by getTime
long tsMicros = (ts.getTime() * 1000) + ((ts.getNanos() / 1000) % 1000);
Assert.assertEquals("Timestamp micros should be equal", expected, tsMicros);
break;
case STRING:
- Assertions.assertThat(actual).as("Should be a String").isInstanceOf(String.class);
+ assertThat(actual).as("Should be a String").isInstanceOf(String.class);
Assert.assertEquals("Strings should be equal", String.valueOf(expected), actual);
break;
case UUID:
- Assertions.assertThat(expected).as("Should expect a UUID").isInstanceOf(UUID.class);
- Assertions.assertThat(actual).as("Should be a String").isInstanceOf(String.class);
+ assertThat(expected).as("Should expect a UUID").isInstanceOf(UUID.class);
+ assertThat(actual).as("Should be a String").isInstanceOf(String.class);
Assert.assertEquals("UUID string representation should match", expected.toString(), actual);
break;
case FIXED:
- Assertions.assertThat(expected)
- .as("Should expect a Fixed")
- .isInstanceOf(GenericData.Fixed.class);
- Assertions.assertThat(actual).as("Should be a byte[]").isInstanceOf(byte[].class);
+ assertThat(expected).as("Should expect a Fixed").isInstanceOf(GenericData.Fixed.class);
+ assertThat(actual).as("Should be a byte[]").isInstanceOf(byte[].class);
Assert.assertArrayEquals(
"Bytes should match", ((GenericData.Fixed) expected).bytes(), (byte[]) actual);
break;
case BINARY:
- Assertions.assertThat(expected)
- .as("Should expect a ByteBuffer")
- .isInstanceOf(ByteBuffer.class);
- Assertions.assertThat(actual).as("Should be a byte[]").isInstanceOf(byte[].class);
+ assertThat(expected).as("Should expect a ByteBuffer").isInstanceOf(ByteBuffer.class);
+ assertThat(actual).as("Should be a byte[]").isInstanceOf(byte[].class);
Assert.assertArrayEquals(
"Bytes should match", ((ByteBuffer) expected).array(), (byte[]) actual);
break;
case DECIMAL:
- Assertions.assertThat(expected)
- .as("Should expect a BigDecimal")
- .isInstanceOf(BigDecimal.class);
- Assertions.assertThat(actual).as("Should be a BigDecimal").isInstanceOf(BigDecimal.class);
+ assertThat(expected).as("Should expect a BigDecimal").isInstanceOf(BigDecimal.class);
+ assertThat(actual).as("Should be a BigDecimal").isInstanceOf(BigDecimal.class);
Assert.assertEquals("BigDecimals should be equal", expected, actual);
break;
case STRUCT:
- Assertions.assertThat(expected).as("Should expect a Record").isInstanceOf(Record.class);
- Assertions.assertThat(actual).as("Should be a Row").isInstanceOf(Row.class);
+ assertThat(expected).as("Should expect a Record").isInstanceOf(Record.class);
+ assertThat(actual).as("Should be a Row").isInstanceOf(Row.class);
assertEqualsSafe(type.asNestedType().asStructType(), (Record) expected, (Row) actual);
break;
case LIST:
- Assertions.assertThat(expected)
- .as("Should expect a Collection")
- .isInstanceOf(Collection.class);
- Assertions.assertThat(actual).as("Should be a Seq").isInstanceOf(Seq.class);
+ assertThat(expected).as("Should expect a Collection").isInstanceOf(Collection.class);
+ assertThat(actual).as("Should be a Seq").isInstanceOf(Seq.class);
List<?> asList = seqAsJavaListConverter((Seq<?>) actual).asJava();
assertEqualsSafe(type.asNestedType().asListType(), (Collection) expected, asList);
break;
case MAP:
- Assertions.assertThat(expected).as("Should expect a Collection").isInstanceOf(Map.class);
- Assertions.assertThat(actual)
- .as("Should be a Map")
- .isInstanceOf(scala.collection.Map.class);
+ assertThat(expected).as("Should expect a Collection").isInstanceOf(Map.class);
+ assertThat(actual).as("Should be a Map").isInstanceOf(scala.collection.Map.class);
Map<String, ?> asMap =
mapAsJavaMapConverter((scala.collection.Map<String, ?>) actual).asJava();
assertEqualsSafe(type.asNestedType().asMapType(), (Map<String, ?>) expected, asMap);
@@ -288,7 +278,7 @@ public class TestHelpers {
switch (type.typeId()) {
case LONG:
- Assertions.assertThat(actual).as("Should be a long").isInstanceOf(Long.class);
+ assertThat(actual).as("Should be a long").isInstanceOf(Long.class);
if (expected instanceof Integer) {
Assert.assertEquals("Values didn't match", ((Number) expected).longValue(), actual);
} else {
@@ -296,7 +286,7 @@ public class TestHelpers {
}
break;
case DOUBLE:
- Assertions.assertThat(actual).as("Should be a double").isInstanceOf(Double.class);
+ assertThat(actual).as("Should be a double").isInstanceOf(Double.class);
if (expected instanceof Float) {
Assert.assertEquals(
"Values didn't match",
@@ -314,60 +304,48 @@ public class TestHelpers {
Assert.assertEquals("Primitive value should be equal to expected", expected, actual);
break;
case STRING:
- Assertions.assertThat(actual).as("Should be a UTF8String").isInstanceOf(UTF8String.class);
+ assertThat(actual).as("Should be a UTF8String").isInstanceOf(UTF8String.class);
Assert.assertEquals("Strings should be equal", expected, actual.toString());
break;
case UUID:
- Assertions.assertThat(expected).as("Should expect a UUID").isInstanceOf(UUID.class);
- Assertions.assertThat(actual).as("Should be a UTF8String").isInstanceOf(UTF8String.class);
+ assertThat(expected).as("Should expect a UUID").isInstanceOf(UUID.class);
+ assertThat(actual).as("Should be a UTF8String").isInstanceOf(UTF8String.class);
Assert.assertEquals(
"UUID string representation should match", expected.toString(), actual.toString());
break;
case FIXED:
- Assertions.assertThat(expected)
- .as("Should expect a Fixed")
- .isInstanceOf(GenericData.Fixed.class);
- Assertions.assertThat(actual).as("Should be a byte[]").isInstanceOf(byte[].class);
+ assertThat(expected).as("Should expect a Fixed").isInstanceOf(GenericData.Fixed.class);
+ assertThat(actual).as("Should be a byte[]").isInstanceOf(byte[].class);
Assert.assertArrayEquals(
"Bytes should match", ((GenericData.Fixed) expected).bytes(), (byte[]) actual);
break;
case BINARY:
- Assertions.assertThat(expected)
- .as("Should expect a ByteBuffer")
- .isInstanceOf(ByteBuffer.class);
- Assertions.assertThat(actual).as("Should be a byte[]").isInstanceOf(byte[].class);
+ assertThat(expected).as("Should expect a ByteBuffer").isInstanceOf(ByteBuffer.class);
+ assertThat(actual).as("Should be a byte[]").isInstanceOf(byte[].class);
Assert.assertArrayEquals(
"Bytes should match", ((ByteBuffer) expected).array(), (byte[]) actual);
break;
case DECIMAL:
- Assertions.assertThat(expected)
- .as("Should expect a BigDecimal")
- .isInstanceOf(BigDecimal.class);
- Assertions.assertThat(actual).as("Should be a Decimal").isInstanceOf(Decimal.class);
+ assertThat(expected).as("Should expect a BigDecimal").isInstanceOf(BigDecimal.class);
+ assertThat(actual).as("Should be a Decimal").isInstanceOf(Decimal.class);
Assert.assertEquals(
"BigDecimals should be equal", expected, ((Decimal) actual).toJavaBigDecimal());
break;
case STRUCT:
- Assertions.assertThat(expected).as("Should expect a Record").isInstanceOf(Record.class);
- Assertions.assertThat(actual)
- .as("Should be an InternalRow")
- .isInstanceOf(InternalRow.class);
+ assertThat(expected).as("Should expect a Record").isInstanceOf(Record.class);
+ assertThat(actual).as("Should be an InternalRow").isInstanceOf(InternalRow.class);
assertEqualsUnsafe(
type.asNestedType().asStructType(), (Record) expected, (InternalRow) actual);
break;
case LIST:
- Assertions.assertThat(expected)
- .as("Should expect a Collection")
- .isInstanceOf(Collection.class);
- Assertions.assertThat(actual).as("Should be an ArrayData").isInstanceOf(ArrayData.class);
+ assertThat(expected).as("Should expect a Collection").isInstanceOf(Collection.class);
+ assertThat(actual).as("Should be an ArrayData").isInstanceOf(ArrayData.class);
assertEqualsUnsafe(
type.asNestedType().asListType(), (Collection) expected, (ArrayData) actual);
break;
case MAP:
- Assertions.assertThat(expected).as("Should expect a Map").isInstanceOf(Map.class);
- Assertions.assertThat(actual)
- .as("Should be an ArrayBasedMapData")
- .isInstanceOf(MapData.class);
+ assertThat(expected).as("Should expect a Map").isInstanceOf(Map.class);
+ assertThat(actual).as("Should be an ArrayBasedMapData").isInstanceOf(MapData.class);
assertEqualsUnsafe(type.asNestedType().asMapType(), (Map) expected, (MapData) actual);
break;
case TIME:
@@ -688,30 +666,28 @@ public class TestHelpers {
}
if (type instanceof StructType) {
- Assertions.assertThat(expected)
+ assertThat(expected)
.as("Expected should be an InternalRow: " + context)
.isInstanceOf(InternalRow.class);
- Assertions.assertThat(actual)
+ assertThat(actual)
.as("Actual should be an InternalRow: " + context)
.isInstanceOf(InternalRow.class);
assertEquals(context, (StructType) type, (InternalRow) expected, (InternalRow) actual);
} else if (type instanceof ArrayType) {
- Assertions.assertThat(expected)
+ assertThat(expected)
.as("Expected should be an ArrayData: " + context)
.isInstanceOf(ArrayData.class);
- Assertions.assertThat(actual)
+ assertThat(actual)
.as("Actual should be an ArrayData: " + context)
.isInstanceOf(ArrayData.class);
assertEquals(context, (ArrayType) type, (ArrayData) expected, (ArrayData) actual);
} else if (type instanceof MapType) {
- Assertions.assertThat(expected)
+ assertThat(expected)
.as("Expected should be a MapData: " + context)
.isInstanceOf(MapData.class);
- Assertions.assertThat(actual)
- .as("Actual should be a MapData: " + context)
- .isInstanceOf(MapData.class);
+ assertThat(actual).as("Actual should be a MapData: " + context).isInstanceOf(MapData.class);
assertEquals(context, (MapType) type, (MapData) expected, (MapData) actual);
} else if (type instanceof BinaryType) {
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/data/TestSparkParquetReader.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/data/TestSparkParquetReader.java
index 024ce3a60c..77ad638542 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/data/TestSparkParquetReader.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/data/TestSparkParquetReader.java
@@ -20,6 +20,7 @@ package org.apache.iceberg.spark.data;
import static org.apache.iceberg.spark.data.TestHelpers.assertEqualsUnsafe;
import static org.apache.iceberg.types.Types.NestedField.required;
+import static org.assertj.core.api.Assertions.assertThat;
import java.io.File;
import java.io.IOException;
@@ -56,7 +57,6 @@ import org.apache.spark.sql.types.DataTypes;
import org.apache.spark.sql.types.Metadata;
import org.apache.spark.sql.types.StructField;
import org.apache.spark.sql.types.StructType;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Assume;
import org.junit.Test;
@@ -158,7 +158,7 @@ public class TestSparkParquetReader extends AvroDataTest {
InputFile parquetInputFile = Files.localInput(outputFilePath);
List<InternalRow> readRows = rowsFromFile(parquetInputFile, schema);
Assert.assertEquals(rows.size(), readRows.size());
- Assertions.assertThat(readRows).isEqualTo(rows);
+ assertThat(readRows).isEqualTo(rows);
// Now we try to import that file as an Iceberg table to make sure Iceberg can read
// Int96 end to end.
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/data/parquet/vectorized/TestParquetVectorizedReads.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/data/parquet/vectorized/TestParquetVectorizedReads.java
index 866bbd240a..aca6202870 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/data/parquet/vectorized/TestParquetVectorizedReads.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/data/parquet/vectorized/TestParquetVectorizedReads.java
@@ -20,6 +20,7 @@ package org.apache.iceberg.spark.data.parquet.vectorized;
import static org.apache.iceberg.types.Types.NestedField.optional;
import static org.apache.iceberg.types.Types.NestedField.required;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.File;
import java.io.IOException;
@@ -48,7 +49,6 @@ import org.apache.parquet.schema.GroupType;
import org.apache.parquet.schema.MessageType;
import org.apache.parquet.schema.Type;
import org.apache.spark.sql.vectorized.ColumnarBatch;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Assume;
import org.junit.Ignore;
@@ -255,7 +255,7 @@ public class TestParquetVectorizedReads extends AvroDataTest {
@Test
@Override
public void testNestedStruct() {
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
VectorizedSparkParquetReaders.buildReader(
TypeUtil.assignIncreasingFreshIds(
@@ -390,8 +390,7 @@ public class TestParquetVectorizedReads extends AvroDataTest {
try (FileAppender<GenericData.Record> writer = parquetV2Writer(schema, dataFile)) {
writer.addAll(data);
}
- Assertions.assertThatThrownBy(
- () -> assertRecordsMatch(schema, 30000, data, dataFile, true, BATCH_SIZE))
+ assertThatThrownBy(() -> assertRecordsMatch(schema, 30000, data, dataFile, true, BATCH_SIZE))
.as("Vectorized reads not supported")
.isInstanceOf(UnsupportedOperationException.class)
.hasMessageContaining("Cannot support vectorized reads for column");
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestDataFrameWriterV2.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestDataFrameWriterV2.java
index f57c87e8b8..59a32bd239 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestDataFrameWriterV2.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestDataFrameWriterV2.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.source;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.util.List;
import org.apache.iceberg.TableProperties;
import org.apache.iceberg.relocated.com.google.common.collect.ImmutableList;
@@ -32,7 +34,6 @@ import org.apache.spark.sql.SparkSession;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
import org.apache.spark.sql.catalyst.parser.ParseException;
import org.apache.spark.sql.internal.SQLConf;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
@@ -76,7 +77,7 @@ public class TestDataFrameWriterV2 extends SparkTestBaseWithCatalog {
// this has a different error message than the case without accept-any-schema because it uses
// Iceberg checks
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
try {
threeColDF.writeTo(tableName).append();
@@ -111,7 +112,7 @@ public class TestDataFrameWriterV2 extends SparkTestBaseWithCatalog {
"{ \"id\": 3, \"data\": \"c\", \"new_col\": 12.06 }",
"{ \"id\": 4, \"data\": \"d\", \"new_col\": 14.41 }");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
try {
threeColDF.writeTo(tableName).option("merge-schema", "true").append();
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestDataFrameWrites.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestDataFrameWrites.java
index 310e69b827..a5a3da39ad 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestDataFrameWrites.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestDataFrameWrites.java
@@ -21,6 +21,7 @@ package org.apache.iceberg.spark.source;
import static org.apache.iceberg.spark.SparkSchemaUtil.convert;
import static org.apache.iceberg.spark.data.TestHelpers.assertEqualsSafe;
import static org.apache.iceberg.spark.data.TestHelpers.assertEqualsUnsafe;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.File;
import java.io.IOException;
@@ -63,7 +64,6 @@ import org.apache.spark.sql.SaveMode;
import org.apache.spark.sql.SparkSession;
import org.apache.spark.sql.catalyst.InternalRow;
import org.apache.spark.sql.catalyst.encoders.RowEncoder;
-import org.assertj.core.api.Assertions;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Assume;
@@ -408,8 +408,7 @@ public class TestDataFrameWrites extends AvroDataTest {
Iterable<Record> records2 = RandomData.generate(schema, 100, 0L);
- Assertions.assertThatThrownBy(
- () -> writeDataWithFailOnPartition(records2, schema, location.toString()))
+ assertThatThrownBy(() -> writeDataWithFailOnPartition(records2, schema, location.toString()))
.isInstanceOf(SparkException.class);
table.refresh();
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestDataSourceOptions.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestDataSourceOptions.java
index 2c3a7aba59..9cee255603 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestDataSourceOptions.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestDataSourceOptions.java
@@ -19,6 +19,8 @@
package org.apache.iceberg.spark.source;
import static org.apache.iceberg.types.Types.NestedField.optional;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.IOException;
import java.math.RoundingMode;
@@ -54,7 +56,6 @@ import org.apache.spark.sql.Row;
import org.apache.spark.sql.SaveMode;
import org.apache.spark.sql.SparkSession;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
-import org.assertj.core.api.Assertions;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
@@ -245,7 +246,7 @@ public class TestDataSourceOptions extends SparkTestBaseWithCatalog {
List<Long> snapshotIds = SnapshotUtil.currentAncestorIds(table);
// start-snapshot-id and snapshot-id are both configured.
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
spark
.read()
@@ -261,7 +262,7 @@ public class TestDataSourceOptions extends SparkTestBaseWithCatalog {
"Cannot set start-snapshot-id and end-snapshot-id for incremental scans");
// end-snapshot-id and as-of-timestamp are both configured.
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
spark
.read()
@@ -279,7 +280,7 @@ public class TestDataSourceOptions extends SparkTestBaseWithCatalog {
"Cannot set start-snapshot-id and end-snapshot-id for incremental scans");
// only end-snapshot-id is configured.
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
spark
.read()
@@ -455,7 +456,7 @@ public class TestDataSourceOptions extends SparkTestBaseWithCatalog {
List<Snapshot> snapshots = Lists.newArrayList(table.snapshots());
Assert.assertEquals(2, snapshots.size());
Assert.assertNull(snapshots.get(0).summary().get("writer-thread"));
- Assertions.assertThat(snapshots.get(1).summary())
+ assertThat(snapshots.get(1).summary())
.containsEntry("writer-thread", "test-extra-commit-message-writer-thread")
.containsEntry("extra-key", "someValue")
.containsEntry("another-key", "anotherValue");
@@ -498,7 +499,7 @@ public class TestDataSourceOptions extends SparkTestBaseWithCatalog {
List<Snapshot> snapshots = Lists.newArrayList(table.snapshots());
Assert.assertEquals(2, snapshots.size());
Assert.assertNull(snapshots.get(0).summary().get("writer-thread"));
- Assertions.assertThat(snapshots.get(1).summary())
+ assertThat(snapshots.get(1).summary())
.containsEntry("writer-thread", "test-extra-commit-message-delete-thread")
.containsEntry("extra-key", "someValue")
.containsEntry("another-key", "anotherValue");
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestFilteredScan.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestFilteredScan.java
index a616b764a6..9f3432d256 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestFilteredScan.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestFilteredScan.java
@@ -22,6 +22,7 @@ import static org.apache.iceberg.Files.localOutput;
import static org.apache.spark.sql.catalyst.util.DateTimeUtils.fromJavaTimestamp;
import static org.apache.spark.sql.functions.callUDF;
import static org.apache.spark.sql.functions.column;
+import static org.assertj.core.api.Assertions.assertThat;
import java.io.File;
import java.io.IOException;
@@ -71,7 +72,6 @@ import org.apache.spark.sql.types.IntegerType$;
import org.apache.spark.sql.types.LongType$;
import org.apache.spark.sql.types.StringType$;
import org.apache.spark.sql.util.CaseInsensitiveStringMap;
-import org.assertj.core.api.Assertions;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Before;
@@ -601,7 +601,7 @@ public class TestFilteredScan {
}
private void pushFilters(ScanBuilder scan, Filter... filters) {
- Assertions.assertThat(scan).isInstanceOf(SupportsPushDownFilters.class);
+ assertThat(scan).isInstanceOf(SupportsPushDownFilters.class);
SupportsPushDownFilters filterable = (SupportsPushDownFilters) scan;
filterable.pushFilters(filters);
}
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestForwardCompatibility.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestForwardCompatibility.java
index 8630c50151..e180d1a53b 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestForwardCompatibility.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestForwardCompatibility.java
@@ -20,6 +20,7 @@ package org.apache.iceberg.spark.source;
import static org.apache.iceberg.Files.localInput;
import static org.apache.iceberg.Files.localOutput;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.File;
import java.io.IOException;
@@ -54,7 +55,6 @@ import org.apache.spark.sql.SparkSession;
import org.apache.spark.sql.execution.streaming.MemoryStream;
import org.apache.spark.sql.streaming.StreamingQuery;
import org.apache.spark.sql.streaming.StreamingQueryException;
-import org.assertj.core.api.Assertions;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
@@ -120,7 +120,7 @@ public class TestForwardCompatibility {
Dataset<Row> df = spark.createDataFrame(expected, SimpleRecord.class);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
df.select("id", "data")
.write()
@@ -159,7 +159,7 @@ public class TestForwardCompatibility {
List<Integer> batch1 = Lists.newArrayList(1, 2);
send(batch1, inputStream);
- Assertions.assertThatThrownBy(query::processAllAvailable)
+ assertThatThrownBy(query::processAllAvailable)
.as("Should reject streaming write with unsupported transform")
.isInstanceOf(StreamingQueryException.class)
.hasMessageContaining("Cannot write using unsupported transforms: zero");
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestIcebergSourceTablesBase.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestIcebergSourceTablesBase.java
index 079ca5f77f..32b96a580d 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestIcebergSourceTablesBase.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestIcebergSourceTablesBase.java
@@ -22,6 +22,8 @@ import static org.apache.iceberg.ManifestContent.DATA;
import static org.apache.iceberg.ManifestContent.DELETES;
import static org.apache.iceberg.types.Types.NestedField.optional;
import static org.apache.iceberg.types.Types.NestedField.required;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.File;
import java.io.IOException;
@@ -91,7 +93,6 @@ import org.apache.spark.sql.catalyst.InternalRow;
import org.apache.spark.sql.functions;
import org.apache.spark.sql.internal.SQLConf;
import org.apache.spark.sql.types.StructType;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Rule;
@@ -1118,7 +1119,7 @@ public abstract class TestIcebergSourceTablesBase extends SparkTestBase {
if (!spark.version().startsWith("2")) {
// Spark 2 isn't able to actually push down nested struct projections so this will not break
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
spark
.read()
@@ -2176,9 +2177,7 @@ public abstract class TestIcebergSourceTablesBase extends SparkTestBase {
.select("tmp_col")
.filter(filterExpr)
.collectAsList();
- Assertions.assertThat(actual)
- .as("Rows must match")
- .containsExactlyInAnyOrderElementsOf(expected);
+ assertThat(actual).as("Rows must match").containsExactlyInAnyOrderElementsOf(expected);
}
private GenericData.Record manifestRecord(
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestIcebergSpark.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestIcebergSpark.java
index 37e329a8b9..0154506f86 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestIcebergSpark.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestIcebergSpark.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.source;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.math.BigDecimal;
import java.nio.ByteBuffer;
import java.sql.Date;
@@ -33,7 +35,6 @@ import org.apache.spark.sql.types.CharType;
import org.apache.spark.sql.types.DataTypes;
import org.apache.spark.sql.types.DecimalType;
import org.apache.spark.sql.types.VarcharType;
-import org.assertj.core.api.Assertions;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
@@ -181,7 +182,7 @@ public class TestIcebergSpark {
@Test
public void testRegisterBooleanBucketUDF() {
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
IcebergSpark.registerBucketUDF(
spark, "iceberg_bucket_boolean_16", DataTypes.BooleanType, 16))
@@ -191,7 +192,7 @@ public class TestIcebergSpark {
@Test
public void testRegisterDoubleBucketUDF() {
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
IcebergSpark.registerBucketUDF(
spark, "iceberg_bucket_double_16", DataTypes.DoubleType, 16))
@@ -201,7 +202,7 @@ public class TestIcebergSpark {
@Test
public void testRegisterFloatBucketUDF() {
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
IcebergSpark.registerBucketUDF(
spark, "iceberg_bucket_float_16", DataTypes.FloatType, 16))
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestMetadataTablesWithPartitionEvolution.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestMetadataTablesWithPartitionEvolution.java
index 9c5d48e1de..37a4cbf2e1 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestMetadataTablesWithPartitionEvolution.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestMetadataTablesWithPartitionEvolution.java
@@ -29,6 +29,7 @@ import static org.apache.iceberg.MetadataTableType.PARTITIONS;
import static org.apache.iceberg.TableProperties.DEFAULT_FILE_FORMAT;
import static org.apache.iceberg.TableProperties.FORMAT_VERSION;
import static org.apache.iceberg.TableProperties.MANIFEST_MERGE_ENABLED;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.Arrays;
import java.util.List;
@@ -53,7 +54,6 @@ import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.parser.ParseException;
import org.apache.spark.sql.types.DataType;
import org.apache.spark.sql.types.StructType;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Assume;
@@ -641,7 +641,7 @@ public class TestMetadataTablesWithPartitionEvolution extends SparkCatalogTestBa
sql("REFRESH TABLE %s", tableName);
for (MetadataTableType tableType : Arrays.asList(FILES, ALL_DATA_FILES, ENTRIES, ALL_ENTRIES)) {
- Assertions.assertThatThrownBy(() -> loadMetadataTable(tableType))
+ assertThatThrownBy(() -> loadMetadataTable(tableType))
.as("Should complain about the partition type")
.isInstanceOf(ValidationException.class)
.hasMessageContaining("Cannot build table partition type, unknown transforms");
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestPathIdentifier.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestPathIdentifier.java
index 5baf607123..e18c4d3241 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestPathIdentifier.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestPathIdentifier.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.source;
import static org.apache.iceberg.types.Types.NestedField.required;
+import static org.assertj.core.api.Assertions.assertThat;
import java.io.File;
import java.io.IOException;
@@ -35,7 +36,6 @@ import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
import org.apache.spark.sql.catalyst.analysis.TableAlreadyExistsException;
import org.apache.spark.sql.connector.expressions.Transform;
import org.apache.spark.sql.util.CaseInsensitiveStringMap;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
@@ -76,9 +76,8 @@ public class TestPathIdentifier extends SparkTestBase {
identifier, SparkSchemaUtil.convert(SCHEMA), new Transform[0], ImmutableMap.of());
Assert.assertEquals(table.table().location(), tableLocation.getAbsolutePath());
- Assertions.assertThat(table.table()).isInstanceOf(BaseTable.class);
- Assertions.assertThat(((BaseTable) table.table()).operations())
- .isInstanceOf(HadoopTableOperations.class);
+ assertThat(table.table()).isInstanceOf(BaseTable.class);
+ assertThat(((BaseTable) table.table()).operations()).isInstanceOf(HadoopTableOperations.class);
Assert.assertEquals(sparkCatalog.loadTable(identifier), table);
Assert.assertTrue(sparkCatalog.dropTable(identifier));
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestReadProjection.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestReadProjection.java
index eecc405b1a..38c8425fd9 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestReadProjection.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestReadProjection.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.source;
import static org.apache.avro.Schema.Type.UNION;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.IOException;
import java.util.List;
@@ -33,7 +34,6 @@ import org.apache.iceberg.relocated.com.google.common.collect.Maps;
import org.apache.iceberg.relocated.com.google.common.collect.Sets;
import org.apache.iceberg.types.Comparators;
import org.apache.iceberg.types.Types;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Rule;
import org.junit.Test;
@@ -141,8 +141,7 @@ public abstract class TestReadProjection {
Assert.assertNotNull("Should read a non-null record", projected);
// this is expected because there are no values
- Assertions.assertThatThrownBy(() -> projected.get(0))
- .isInstanceOf(ArrayIndexOutOfBoundsException.class);
+ assertThatThrownBy(() -> projected.get(0)).isInstanceOf(ArrayIndexOutOfBoundsException.class);
}
@Test
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestRequiredDistributionAndOrdering.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestRequiredDistributionAndOrdering.java
index e8e402ac44..427546fc1d 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestRequiredDistributionAndOrdering.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestRequiredDistributionAndOrdering.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.source;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.util.List;
import java.util.Map;
import org.apache.iceberg.Table;
@@ -29,7 +31,6 @@ import org.apache.spark.SparkException;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Test;
@@ -163,7 +164,7 @@ public class TestRequiredDistributionAndOrdering extends SparkCatalogTestBase {
Dataset<Row> inputDF = ds.coalesce(1).sortWithinPartitions("c1");
// should fail if ordering is disabled
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
try {
inputDF
@@ -233,7 +234,7 @@ public class TestRequiredDistributionAndOrdering extends SparkCatalogTestBase {
Dataset<Row> inputDF = ds.coalesce(1).sortWithinPartitions("c1");
// should fail by default as extensions are disabled
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
try {
inputDF.writeTo(tableName).append();
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestSnapshotSelection.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestSnapshotSelection.java
index a161224275..64541e7831 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestSnapshotSelection.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestSnapshotSelection.java
@@ -19,6 +19,8 @@
package org.apache.iceberg.spark.source;
import static org.apache.iceberg.types.Types.NestedField.optional;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.IOException;
import java.util.List;
@@ -38,7 +40,6 @@ import org.apache.spark.sql.Encoders;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.RowFactory;
import org.apache.spark.sql.SparkSession;
-import org.assertj.core.api.Assertions;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
@@ -174,7 +175,7 @@ public class TestSnapshotSelection {
Dataset<Row> df = spark.read().format("iceberg").option("snapshot-id", -10).load(tableLocation);
- Assertions.assertThatThrownBy(df::collectAsList)
+ assertThatThrownBy(df::collectAsList)
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Cannot find snapshot with ID -10");
}
@@ -188,7 +189,7 @@ public class TestSnapshotSelection {
PartitionSpec spec = PartitionSpec.unpartitioned();
tables.create(SCHEMA, spec, tableLocation);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
spark
.read()
@@ -216,7 +217,7 @@ public class TestSnapshotSelection {
long timestamp = System.currentTimeMillis();
long snapshotId = table.currentSnapshot().snapshotId();
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
spark
.read()
@@ -319,7 +320,7 @@ public class TestSnapshotSelection {
table.manageSnapshots().createBranch("branch", table.currentSnapshot().snapshotId()).commit();
table.manageSnapshots().createTag("tag", table.currentSnapshot().snapshotId()).commit();
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
spark
.read()
@@ -350,7 +351,7 @@ public class TestSnapshotSelection {
table.manageSnapshots().createBranch("branch", table.currentSnapshot().snapshotId()).commit();
table.manageSnapshots().createTag("tag", table.currentSnapshot().snapshotId()).commit();
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
spark
.read()
@@ -362,7 +363,7 @@ public class TestSnapshotSelection {
.isInstanceOf(IllegalArgumentException.class)
.hasMessageStartingWith("Can specify only one of snapshot-id");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
spark
.read()
@@ -405,7 +406,7 @@ public class TestSnapshotSelection {
table.updateSchema().deleteColumn("data").commit();
// The data should not have the deleted column
- Assertions.assertThat(
+ assertThat(
spark
.read()
.format("iceberg")
@@ -418,7 +419,7 @@ public class TestSnapshotSelection {
// re-introducing the column should not let the data re-appear
table.updateSchema().addColumn("data", Types.StringType.get()).commit();
- Assertions.assertThat(
+ assertThat(
spark
.read()
.format("iceberg")
@@ -460,7 +461,7 @@ public class TestSnapshotSelection {
// Deleting and add a new column of the same type to indicate schema change
table.updateSchema().deleteColumn("data").addColumn("zip", Types.IntegerType.get()).commit();
- Assertions.assertThat(
+ assertThat(
spark
.read()
.format("iceberg")
@@ -491,7 +492,7 @@ public class TestSnapshotSelection {
.mode("append")
.save(tableLocation);
- Assertions.assertThat(
+ assertThat(
spark
.read()
.format("iceberg")
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestSparkCatalogCacheExpiration.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestSparkCatalogCacheExpiration.java
index 3d668197fd..abe70f94fe 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestSparkCatalogCacheExpiration.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestSparkCatalogCacheExpiration.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.source;
+import static org.assertj.core.api.Assertions.assertThat;
+
import java.util.Map;
import org.apache.iceberg.CachingCatalog;
import org.apache.iceberg.CatalogProperties;
@@ -27,7 +29,6 @@ import org.apache.iceberg.spark.SparkCatalog;
import org.apache.iceberg.spark.SparkSessionCatalog;
import org.apache.iceberg.spark.SparkTestBaseWithCatalog;
import org.apache.spark.sql.connector.catalog.TableCatalog;
-import org.assertj.core.api.Assertions;
import org.junit.BeforeClass;
import org.junit.Test;
@@ -93,18 +94,18 @@ public class TestSparkCatalogCacheExpiration extends SparkTestBaseWithCatalog {
@Test
public void testSparkSessionCatalogWithExpirationEnabled() {
SparkSessionCatalog<?> sparkCatalog = sparkSessionCatalog();
- Assertions.assertThat(sparkCatalog)
+ assertThat(sparkCatalog)
.extracting("icebergCatalog")
.extracting("cacheEnabled")
.isEqualTo(true);
- Assertions.assertThat(sparkCatalog)
+ assertThat(sparkCatalog)
.extracting("icebergCatalog")
.extracting("icebergCatalog")
.isInstanceOfSatisfying(
Catalog.class,
icebergCatalog -> {
- Assertions.assertThat(icebergCatalog)
+ assertThat(icebergCatalog)
.isExactlyInstanceOf(CachingCatalog.class)
.extracting("expirationIntervalMillis")
.isEqualTo(3000L);
@@ -114,30 +115,27 @@ public class TestSparkCatalogCacheExpiration extends SparkTestBaseWithCatalog {
@Test
public void testCacheEnabledAndExpirationDisabled() {
SparkCatalog sparkCatalog = getSparkCatalog("expiration_disabled");
- Assertions.assertThat(sparkCatalog).extracting("cacheEnabled").isEqualTo(true);
+ assertThat(sparkCatalog).extracting("cacheEnabled").isEqualTo(true);
- Assertions.assertThat(sparkCatalog)
+ assertThat(sparkCatalog)
.extracting("icebergCatalog")
.isInstanceOfSatisfying(
CachingCatalog.class,
icebergCatalog -> {
- Assertions.assertThat(icebergCatalog)
- .extracting("expirationIntervalMillis")
- .isEqualTo(-1L);
+ assertThat(icebergCatalog).extracting("expirationIntervalMillis").isEqualTo(-1L);
});
}
@Test
public void testCacheDisabledImplicitly() {
SparkCatalog sparkCatalog = getSparkCatalog("cache_disabled_implicitly");
- Assertions.assertThat(sparkCatalog).extracting("cacheEnabled").isEqualTo(false);
+ assertThat(sparkCatalog).extracting("cacheEnabled").isEqualTo(false);
- Assertions.assertThat(sparkCatalog)
+ assertThat(sparkCatalog)
.extracting("icebergCatalog")
.isInstanceOfSatisfying(
Catalog.class,
- icebergCatalog ->
- Assertions.assertThat(icebergCatalog).isNotInstanceOf(CachingCatalog.class));
+ icebergCatalog -> assertThat(icebergCatalog).isNotInstanceOf(CachingCatalog.class));
}
private SparkSessionCatalog<?> sparkSessionCatalog() {
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestSparkDataWrite.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestSparkDataWrite.java
index 3d759759f6..a0de190e4b 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestSparkDataWrite.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestSparkDataWrite.java
@@ -20,6 +20,8 @@ package org.apache.iceberg.spark.source;
import static org.apache.iceberg.TableProperties.SPARK_WRITE_PARTITIONED_FANOUT_ENABLED;
import static org.apache.iceberg.types.Types.NestedField.optional;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
@@ -53,7 +55,6 @@ import org.apache.spark.sql.Encoders;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.SaveMode;
import org.apache.spark.sql.SparkSession;
-import org.assertj.core.api.Assertions;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Assume;
@@ -690,7 +691,7 @@ public class TestSparkDataWrite {
ManualSource.setTable(manualTableName, sparkTable);
// Although an exception is thrown here, write and commit have succeeded
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
df2.select("id", "data")
.sort("data")
@@ -712,7 +713,7 @@ public class TestSparkDataWrite {
result.orderBy("id").as(Encoders.bean(SimpleRecord.class)).collectAsList();
Assert.assertEquals(
"Number of rows should match", records.size() + records2.size(), actual.size());
- Assertions.assertThat(actual)
+ assertThat(actual)
.describedAs("Result rows should match")
.containsExactlyInAnyOrder(
ImmutableList.<SimpleRecord>builder()
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestSparkMetadataColumns.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestSparkMetadataColumns.java
index 2b0033fdcb..e24e74383b 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestSparkMetadataColumns.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestSparkMetadataColumns.java
@@ -25,6 +25,7 @@ import static org.apache.iceberg.TableProperties.PARQUET_BATCH_SIZE;
import static org.apache.iceberg.TableProperties.PARQUET_ROW_GROUP_SIZE_BYTES;
import static org.apache.iceberg.TableProperties.PARQUET_VECTORIZATION_ENABLED;
import static org.apache.spark.sql.functions.lit;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.IOException;
import java.util.List;
@@ -52,7 +53,6 @@ import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Encoders;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Assume;
@@ -224,7 +224,7 @@ public class TestSparkMetadataColumns extends SparkTestBase {
TableMetadata base = ops.current();
ops.commit(base, base.updatePartitionSpec(UNKNOWN_SPEC));
- Assertions.assertThatThrownBy(() -> sql("SELECT _partition FROM %s", TABLE_NAME))
+ assertThatThrownBy(() -> sql("SELECT _partition FROM %s", TABLE_NAME))
.as("Should fail to query the partition metadata column")
.isInstanceOf(ValidationException.class)
.hasMessageContaining("Cannot build table partition type, unknown transforms");
@@ -245,7 +245,7 @@ public class TestSparkMetadataColumns extends SparkTestBase {
ImmutableList.of(row(1L, "a1")),
sql("SELECT id, category FROM %s", TABLE_NAME));
- Assertions.assertThatThrownBy(() -> sql("SELECT * FROM %s", TABLE_NAME))
+ assertThatThrownBy(() -> sql("SELECT * FROM %s", TABLE_NAME))
.as("Should fail to query conflicting columns")
.isInstanceOf(ValidationException.class)
.hasMessageContaining("column names conflict");
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestStructuredStreaming.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestStructuredStreaming.java
index 464f1f5922..bd20a628ca 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestStructuredStreaming.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestStructuredStreaming.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.source;
import static org.apache.iceberg.types.Types.NestedField.optional;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.File;
import java.util.List;
@@ -40,7 +41,6 @@ import org.apache.spark.sql.execution.streaming.MemoryStream;
import org.apache.spark.sql.streaming.DataStreamWriter;
import org.apache.spark.sql.streaming.StreamingQuery;
import org.apache.spark.sql.streaming.StreamingQueryException;
-import org.assertj.core.api.Assertions;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
@@ -283,7 +283,7 @@ public class TestStructuredStreaming {
List<Integer> batch1 = Lists.newArrayList(1, 2);
send(batch1, inputStream);
- Assertions.assertThatThrownBy(query::processAllAvailable)
+ assertThatThrownBy(query::processAllAvailable)
.isInstanceOf(StreamingQueryException.class)
.hasMessageContaining("does not support Update mode");
} finally {
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestStructuredStreamingRead3.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestStructuredStreamingRead3.java
index c8e37d9322..a525b5cdb2 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestStructuredStreamingRead3.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestStructuredStreamingRead3.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.source;
import static org.apache.iceberg.expressions.Expressions.ref;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.File;
@@ -57,7 +58,6 @@ import org.apache.spark.sql.Row;
import org.apache.spark.sql.streaming.DataStreamWriter;
import org.apache.spark.sql.streaming.OutputMode;
import org.apache.spark.sql.streaming.StreamingQuery;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
@@ -144,7 +144,7 @@ public final class TestStructuredStreamingRead3 extends SparkCatalogTestBase {
StreamingQuery query = startStream();
List<SimpleRecord> actual = rowsAvailable(query);
- Assertions.assertThat(actual).containsExactlyInAnyOrderElementsOf(Iterables.concat(expected));
+ assertThat(actual).containsExactlyInAnyOrderElementsOf(Iterables.concat(expected));
}
@Test
@@ -183,7 +183,7 @@ public final class TestStructuredStreamingRead3 extends SparkCatalogTestBase {
// check answer correctness only 1 record read the micro-batch will be stuck
List<SimpleRecord> actual = rowsAvailable(query);
- Assertions.assertThat(actual)
+ assertThat(actual)
.containsExactlyInAnyOrderElementsOf(
Lists.newArrayList(TEST_DATA_MULTIPLE_SNAPSHOTS.get(0).get(0)));
}
@@ -207,7 +207,7 @@ public final class TestStructuredStreamingRead3 extends SparkCatalogTestBase {
appendDataAsMultipleSnapshots(expected);
List<SimpleRecord> actual = rowsAvailable(query);
- Assertions.assertThat(actual).containsExactlyInAnyOrderElementsOf(Iterables.concat(expected));
+ assertThat(actual).containsExactlyInAnyOrderElementsOf(Iterables.concat(expected));
}
@Test
@@ -227,14 +227,14 @@ public final class TestStructuredStreamingRead3 extends SparkCatalogTestBase {
startStream(SparkReadOptions.STREAM_FROM_TIMESTAMP, Long.toString(streamStartTimestamp));
List<SimpleRecord> empty = rowsAvailable(query);
- Assertions.assertThat(empty.isEmpty()).isTrue();
+ assertThat(empty.isEmpty()).isTrue();
List<List<SimpleRecord>> expected = TEST_DATA_MULTIPLE_SNAPSHOTS;
appendDataAsMultipleSnapshots(expected);
List<SimpleRecord> actual = rowsAvailable(query);
- Assertions.assertThat(actual).containsExactlyInAnyOrderElementsOf(Iterables.concat(expected));
+ assertThat(actual).containsExactlyInAnyOrderElementsOf(Iterables.concat(expected));
}
@Test
@@ -245,7 +245,7 @@ public final class TestStructuredStreamingRead3 extends SparkCatalogTestBase {
startStream(SparkReadOptions.STREAM_FROM_TIMESTAMP, Long.toString(futureTimestamp));
List<SimpleRecord> actual = rowsAvailable(query);
- Assertions.assertThat(actual.isEmpty()).isTrue();
+ assertThat(actual.isEmpty()).isTrue();
List<SimpleRecord> data =
Lists.newArrayList(
@@ -258,7 +258,7 @@ public final class TestStructuredStreamingRead3 extends SparkCatalogTestBase {
.forEach(
x -> {
appendData(data);
- Assertions.assertThat(rowsAvailable(query).isEmpty()).isTrue();
+ assertThat(rowsAvailable(query).isEmpty()).isTrue();
});
waitUntilAfter(futureTimestamp);
@@ -266,7 +266,7 @@ public final class TestStructuredStreamingRead3 extends SparkCatalogTestBase {
// Data appended after the timestamp should appear
appendData(data);
actual = rowsAvailable(query);
- Assertions.assertThat(actual).containsExactlyInAnyOrderElementsOf(data);
+ assertThat(actual).containsExactlyInAnyOrderElementsOf(data);
}
@Test
@@ -288,7 +288,7 @@ public final class TestStructuredStreamingRead3 extends SparkCatalogTestBase {
waitUntilAfter(streamStartTimestamp);
List<List<SimpleRecord>> expected = TEST_DATA_MULTIPLE_SNAPSHOTS;
appendDataAsMultipleSnapshots(expected);
- Assertions.assertThat(rowsAvailable(query))
+ assertThat(rowsAvailable(query))
.containsExactlyInAnyOrderElementsOf(Iterables.concat(expected));
}
@@ -311,7 +311,7 @@ public final class TestStructuredStreamingRead3 extends SparkCatalogTestBase {
}
List<SimpleRecord> actual = rowsAvailable(stream);
- Assertions.assertThat(actual).containsExactlyInAnyOrderElementsOf(Iterables.concat(expected));
+ assertThat(actual).containsExactlyInAnyOrderElementsOf(Iterables.concat(expected));
}
@Test
@@ -340,7 +340,7 @@ public final class TestStructuredStreamingRead3 extends SparkCatalogTestBase {
startStream(
SparkReadOptions.STREAM_FROM_TIMESTAMP, String.valueOf(firstSnapshotCommitTime));
List<SimpleRecord> actual = rowsAvailable(query);
- Assertions.assertThat(actual).containsExactlyInAnyOrderElementsOf(expectedRecordList);
+ assertThat(actual).containsExactlyInAnyOrderElementsOf(expectedRecordList);
}
@Test
@@ -379,7 +379,7 @@ public final class TestStructuredStreamingRead3 extends SparkCatalogTestBase {
// Read data added by the stream
List<SimpleRecord> actual =
spark.read().load(output.getPath()).as(Encoders.bean(SimpleRecord.class)).collectAsList();
- Assertions.assertThat(actual).containsExactlyInAnyOrderElementsOf(Iterables.concat(expected));
+ assertThat(actual).containsExactlyInAnyOrderElementsOf(Iterables.concat(expected));
}
}
@@ -440,7 +440,7 @@ public final class TestStructuredStreamingRead3 extends SparkCatalogTestBase {
appendData(avroFileRecords, "avro");
StreamingQuery query = startStream();
- Assertions.assertThat(rowsAvailable(query))
+ assertThat(rowsAvailable(query))
.containsExactlyInAnyOrderElementsOf(
Iterables.concat(parquetFileRecords, orcFileRecords, avroFileRecords));
}
@@ -494,7 +494,7 @@ public final class TestStructuredStreamingRead3 extends SparkCatalogTestBase {
StreamingQuery query = startStream();
- Assertions.assertThatThrownBy(() -> query.processAllAvailable())
+ assertThatThrownBy(() -> query.processAllAvailable())
.as(
"Streaming should fail with IllegalStateException, as the snapshot is not of type APPEND")
.cause()
@@ -516,7 +516,7 @@ public final class TestStructuredStreamingRead3 extends SparkCatalogTestBase {
StreamingQuery query = startStream();
List<SimpleRecord> actual = rowsAvailable(query);
- Assertions.assertThat(actual).containsExactlyInAnyOrderElementsOf(Iterables.concat(expected));
+ assertThat(actual).containsExactlyInAnyOrderElementsOf(Iterables.concat(expected));
}
@Test
@@ -536,7 +536,7 @@ public final class TestStructuredStreamingRead3 extends SparkCatalogTestBase {
StreamingQuery query = startStream();
- Assertions.assertThatThrownBy(() -> query.processAllAvailable())
+ assertThatThrownBy(() -> query.processAllAvailable())
.as(
"Streaming should fail with IllegalStateException, as the snapshot is not of type APPEND")
.cause()
@@ -560,7 +560,7 @@ public final class TestStructuredStreamingRead3 extends SparkCatalogTestBase {
Assert.assertEquals(DataOperations.DELETE, table.currentSnapshot().operation());
StreamingQuery query = startStream(SparkReadOptions.STREAMING_SKIP_DELETE_SNAPSHOTS, "true");
- Assertions.assertThat(rowsAvailable(query))
+ assertThat(rowsAvailable(query))
.containsExactlyInAnyOrderElementsOf(Iterables.concat(dataAcrossSnapshots));
}
@@ -592,7 +592,7 @@ public final class TestStructuredStreamingRead3 extends SparkCatalogTestBase {
Assert.assertEquals(DataOperations.OVERWRITE, table.currentSnapshot().operation());
StreamingQuery query = startStream(SparkReadOptions.STREAMING_SKIP_OVERWRITE_SNAPSHOTS, "true");
- Assertions.assertThat(rowsAvailable(query))
+ assertThat(rowsAvailable(query))
.containsExactlyInAnyOrderElementsOf(Iterables.concat(dataAcrossSnapshots));
}
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestTimestampWithoutZone.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestTimestampWithoutZone.java
index d85e195495..4f035aff93 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestTimestampWithoutZone.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestTimestampWithoutZone.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.source;
import static org.apache.iceberg.Files.localOutput;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.File;
import java.io.IOException;
@@ -52,7 +53,6 @@ import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.SaveMode;
import org.apache.spark.sql.SparkSession;
-import org.assertj.core.api.Assertions;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Before;
@@ -159,7 +159,7 @@ public class TestTimestampWithoutZone extends SparkTestBase {
@Test
public void testUnpartitionedTimestampWithoutZoneError() {
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
spark
.read()
@@ -218,7 +218,7 @@ public class TestTimestampWithoutZone extends SparkTestBase {
.mode(SaveMode.Append)
.save(unpartitioned.toString());
- Assertions.assertThatThrownBy(writeOperation::run)
+ assertThatThrownBy(writeOperation::run)
.as(errorMessage)
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining(SparkUtil.TIMESTAMP_WITHOUT_TIMEZONE_ERROR);
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestWriteMetricsConfig.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestWriteMetricsConfig.java
index fd88eb2c90..c2b396bdb9 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestWriteMetricsConfig.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/source/TestWriteMetricsConfig.java
@@ -21,6 +21,7 @@ package org.apache.iceberg.spark.source;
import static org.apache.iceberg.spark.SparkSchemaUtil.convert;
import static org.apache.iceberg.types.Types.NestedField.optional;
import static org.apache.iceberg.types.Types.NestedField.required;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.IOException;
import java.nio.ByteBuffer;
@@ -48,7 +49,6 @@ import org.apache.spark.sql.Row;
import org.apache.spark.sql.SaveMode;
import org.apache.spark.sql.SparkSession;
import org.apache.spark.sql.catalyst.InternalRow;
-import org.assertj.core.api.Assertions;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
@@ -231,8 +231,7 @@ public class TestWriteMetricsConfig {
properties.put(TableProperties.DEFAULT_WRITE_METRICS_MODE, "counts");
properties.put("write.metadata.metrics.column.ids", "full");
- Assertions.assertThatThrownBy(
- () -> tables.create(SIMPLE_SCHEMA, spec, properties, tableLocation))
+ assertThatThrownBy(() -> tables.create(SIMPLE_SCHEMA, spec, properties, tableLocation))
.as("Creating a table with invalid metrics should fail")
.isInstanceOf(ValidationException.class)
.hasMessageStartingWith(
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestAggregatePushDown.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestAggregatePushDown.java
index 9ea1a563ef..2579d61468 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestAggregatePushDown.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestAggregatePushDown.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.sql;
+import static org.assertj.core.api.Assertions.assertThat;
+
import java.math.BigDecimal;
import java.sql.Date;
import java.sql.Timestamp;
@@ -36,7 +38,6 @@ import org.apache.iceberg.relocated.com.google.common.collect.Lists;
import org.apache.iceberg.spark.SparkCatalogTestBase;
import org.apache.iceberg.spark.SparkTestBase;
import org.apache.spark.sql.SparkSession;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.BeforeClass;
@@ -571,15 +572,9 @@ public class TestAggregatePushDown extends SparkCatalogTestBase {
Object actualMax = actual.get(0)[1];
Object actualMin = actual.get(0)[2];
- Assertions.assertThat(actualCount)
- .as("Expected and actual count should equal")
- .isEqualTo(expectedCount);
- Assertions.assertThat(actualMax)
- .as("Expected and actual max should equal")
- .isEqualTo(expectedMax);
- Assertions.assertThat(actualMin)
- .as("Expected and actual min should equal")
- .isEqualTo(expectedMin);
+ assertThat(actualCount).as("Expected and actual count should equal").isEqualTo(expectedCount);
+ assertThat(actualMax).as("Expected and actual max should equal").isEqualTo(expectedMax);
+ assertThat(actualMin).as("Expected and actual min should equal").isEqualTo(expectedMin);
}
private void assertExplainContains(List<Object[]> explain, String... expectedFragments) {
@@ -587,7 +582,7 @@ public class TestAggregatePushDown extends SparkCatalogTestBase {
Arrays.stream(expectedFragments)
.forEach(
fragment ->
- Assertions.assertThat(explainString)
+ assertThat(explainString)
.as("Expected to find plan fragment in explain plan")
.contains(fragment));
}
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestAlterTable.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestAlterTable.java
index 901a7c15e7..2570d4b819 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestAlterTable.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestAlterTable.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.sql;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.util.Map;
import org.apache.iceberg.catalog.Namespace;
import org.apache.iceberg.catalog.TableIdentifier;
@@ -27,7 +29,6 @@ import org.apache.iceberg.types.Types;
import org.apache.iceberg.types.Types.NestedField;
import org.apache.spark.SparkException;
import org.apache.spark.sql.AnalysisException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Assume;
@@ -55,7 +56,7 @@ public class TestAlterTable extends SparkCatalogTestBase {
@Test
public void testAddColumnNotNull() {
- Assertions.assertThatThrownBy(() -> sql("ALTER TABLE %s ADD COLUMN c3 INT NOT NULL", tableName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s ADD COLUMN c3 INT NOT NULL", tableName))
.as("Should reject adding NOT NULL column")
.isInstanceOf(SparkException.class)
.hasMessageContaining("Incompatible change: cannot add required column");
@@ -155,7 +156,7 @@ public class TestAlterTable extends SparkCatalogTestBase {
validationCatalog.loadTable(tableIdent).schema().asStruct());
// should not allow changing map key column
- Assertions.assertThatThrownBy(() -> sql("ALTER TABLE %s ADD COLUMN data2.key.y int", tableName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s ADD COLUMN data2.key.y int", tableName))
.as("Should reject changing key of the map column")
.isInstanceOf(SparkException.class)
.hasMessageContaining("Unsupported table change: Cannot add fields to map keys:");
@@ -251,8 +252,7 @@ public class TestAlterTable extends SparkCatalogTestBase {
expectedSchema,
validationCatalog.loadTable(tableIdent).schema().asStruct());
- Assertions.assertThatThrownBy(
- () -> sql("ALTER TABLE %s ALTER COLUMN data SET NOT NULL", tableName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s ALTER COLUMN data SET NOT NULL", tableName))
.as("Should reject adding NOT NULL constraint to an optional column")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Cannot change nullable column to non-nullable: data");
@@ -321,7 +321,7 @@ public class TestAlterTable extends SparkCatalogTestBase {
"Should not have the removed table property",
validationCatalog.loadTable(tableIdent).properties().get("prop"));
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("ALTER TABLE %s SET TBLPROPERTIES ('sort-order'='value')", tableName))
.as("Cannot specify the 'sort-order' because it's a reserved table property")
.isInstanceOf(UnsupportedOperationException.class)
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestCreateTable.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestCreateTable.java
index f4bef9cec1..bf22000042 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestCreateTable.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestCreateTable.java
@@ -18,6 +18,9 @@
*/
package org.apache.iceberg.spark.sql;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.io.File;
import java.util.Map;
import java.util.UUID;
@@ -33,7 +36,6 @@ import org.apache.iceberg.types.Types;
import org.apache.iceberg.types.Types.NestedField;
import org.apache.iceberg.types.Types.StructType;
import org.apache.spark.sql.connector.catalog.TableCatalog;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Assume;
@@ -107,27 +109,24 @@ public class TestCreateTable extends SparkCatalogTestBase {
@Test
public void testCreateTablePartitionedByUUID() {
- Assertions.assertThat(validationCatalog.tableExists(tableIdent)).isFalse();
+ assertThat(validationCatalog.tableExists(tableIdent)).isFalse();
Schema schema = new Schema(1, Types.NestedField.optional(1, "uuid", Types.UUIDType.get()));
PartitionSpec spec = PartitionSpec.builderFor(schema).bucket("uuid", 16).build();
validationCatalog.createTable(tableIdent, schema, spec);
Table table = validationCatalog.loadTable(tableIdent);
- Assertions.assertThat(table).isNotNull();
+ assertThat(table).isNotNull();
StructType expectedSchema =
StructType.of(Types.NestedField.optional(1, "uuid", Types.UUIDType.get()));
- Assertions.assertThat(table.schema().asStruct()).isEqualTo(expectedSchema);
- Assertions.assertThat(table.spec().fields()).hasSize(1);
+ assertThat(table.schema().asStruct()).isEqualTo(expectedSchema);
+ assertThat(table.spec().fields()).hasSize(1);
String uuid = UUID.randomUUID().toString();
sql("INSERT INTO %s VALUES('%s')", tableName, uuid);
- Assertions.assertThat(sql("SELECT uuid FROM %s", tableName))
- .hasSize(1)
- .element(0)
- .isEqualTo(row(uuid));
+ assertThat(sql("SELECT uuid FROM %s", tableName)).hasSize(1).element(0).isEqualTo(row(uuid));
}
@Test
@@ -167,7 +166,7 @@ public class TestCreateTable extends SparkCatalogTestBase {
"parquet",
table.properties().get(TableProperties.DEFAULT_FILE_FORMAT));
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CREATE TABLE %s.default.fail (id BIGINT NOT NULL, data STRING) USING crocodile",
@@ -381,7 +380,7 @@ public class TestCreateTable extends SparkCatalogTestBase {
TableOperations ops = ((BaseTable) table).operations();
Assert.assertEquals("should create table using format v2", 2, ops.refresh().formatVersion());
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("ALTER TABLE %s SET TBLPROPERTIES ('format-version'='1')", tableName))
.as("should fail to downgrade to v1")
.cause()
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestDeleteFrom.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestDeleteFrom.java
index 5503118845..e1c228be10 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestDeleteFrom.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestDeleteFrom.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.sql;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.util.List;
import java.util.Map;
import org.apache.iceberg.Table;
@@ -29,7 +31,6 @@ import org.apache.iceberg.spark.source.SimpleRecord;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
@@ -86,8 +87,7 @@ public class TestDeleteFrom extends SparkCatalogTestBase {
long snapshotId = validationCatalog.loadTable(tableIdent).currentSnapshot().snapshotId();
String prefix = "snapshot_id_";
- Assertions.assertThatThrownBy(
- () -> sql("DELETE FROM %s.%s WHERE id < 4", tableName, prefix + snapshotId))
+ assertThatThrownBy(() -> sql("DELETE FROM %s.%s WHERE id < 4", tableName, prefix + snapshotId))
.as("Should not be able to delete from a table at a specific snapshot")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Cannot delete from table at a specific snapshot");
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestDropTable.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestDropTable.java
index c5c39e5d78..e2fd0dd812 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestDropTable.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestDropTable.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.sql;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.io.IOException;
import java.util.List;
import java.util.Map;
@@ -29,7 +31,6 @@ import org.apache.iceberg.exceptions.ValidationException;
import org.apache.iceberg.relocated.com.google.common.collect.ImmutableList;
import org.apache.iceberg.relocated.com.google.common.collect.Streams;
import org.apache.iceberg.spark.SparkCatalogTestBase;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
@@ -116,7 +117,7 @@ public class TestDropTable extends SparkCatalogTestBase {
"There totally should have 2 files for manifests and files", 2, manifestAndFiles.size());
Assert.assertTrue("All files should be existed", checkFilesExist(manifestAndFiles, true));
- Assertions.assertThatThrownBy(() -> sql("DROP TABLE %s PURGE", tableName))
+ assertThatThrownBy(() -> sql("DROP TABLE %s PURGE", tableName))
.as("Purge table is not allowed when GC is disabled")
.isInstanceOf(ValidationException.class)
.hasMessageContaining(
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestFilterPushDown.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestFilterPushDown.java
index f1e2169af4..98112acb6e 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestFilterPushDown.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestFilterPushDown.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.sql;
+import static org.assertj.core.api.Assertions.assertThat;
+
import java.math.BigDecimal;
import java.sql.Timestamp;
import java.time.Instant;
@@ -27,7 +29,6 @@ import org.apache.iceberg.expressions.Expressions;
import org.apache.iceberg.relocated.com.google.common.collect.ImmutableList;
import org.apache.iceberg.spark.SparkTestBaseWithCatalog;
import org.apache.spark.sql.execution.SparkPlan;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Test;
@@ -555,16 +556,14 @@ public class TestFilterPushDown extends SparkTestBaseWithCatalog {
String planAsString = sparkPlan.toString().replaceAll("#(\\d+L?)", "");
if (sparkFilter != null) {
- Assertions.assertThat(planAsString)
+ assertThat(planAsString)
.as("Post scan filter should match")
.contains("Filter (" + sparkFilter + ")");
} else {
- Assertions.assertThat(planAsString)
- .as("Should be no post scan filter")
- .doesNotContain("Filter (");
+ assertThat(planAsString).as("Should be no post scan filter").doesNotContain("Filter (");
}
- Assertions.assertThat(planAsString)
+ assertThat(planAsString)
.as("Pushed filters must match")
.contains("[filters=" + icebergFilters + ",");
}
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestNamespaceSQL.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestNamespaceSQL.java
index 77b564cd00..cdfe3d856e 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestNamespaceSQL.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestNamespaceSQL.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.sql;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.io.File;
import java.util.List;
import java.util.Map;
@@ -29,7 +31,6 @@ import org.apache.iceberg.exceptions.NamespaceNotEmptyException;
import org.apache.iceberg.relocated.com.google.common.collect.ImmutableSet;
import org.apache.iceberg.relocated.com.google.common.collect.Iterables;
import org.apache.iceberg.spark.SparkCatalogTestBase;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Assume;
@@ -103,7 +104,7 @@ public class TestNamespaceSQL extends SparkCatalogTestBase {
Assert.assertTrue(
"Table should exist", validationCatalog.tableExists(TableIdentifier.of(NS, "table")));
- Assertions.assertThatThrownBy(() -> sql("DROP NAMESPACE %s", fullNamespace))
+ assertThatThrownBy(() -> sql("DROP NAMESPACE %s", fullNamespace))
.as("Should fail if trying to delete a non-empty namespace")
.isInstanceOf(NamespaceNotEmptyException.class)
.hasMessageContaining("Namespace db is not empty.");
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestPartitionedWritesToWapBranch.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestPartitionedWritesToWapBranch.java
index 5dde5f33d9..064ad0f178 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestPartitionedWritesToWapBranch.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestPartitionedWritesToWapBranch.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.sql;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.util.List;
import java.util.Map;
import java.util.UUID;
@@ -25,7 +27,6 @@ import org.apache.iceberg.Table;
import org.apache.iceberg.TableProperties;
import org.apache.iceberg.exceptions.ValidationException;
import org.apache.iceberg.spark.SparkSQLProperties;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -72,8 +73,7 @@ public class TestPartitionedWritesToWapBranch extends PartitionedWritesTestBase
Table table = validationCatalog.loadTable(tableIdent);
table.manageSnapshots().createBranch("test2", table.refs().get(BRANCH).snapshotId()).commit();
sql("REFRESH TABLE " + tableName);
- Assertions.assertThatThrownBy(
- () -> sql("INSERT INTO %s.branch_test2 VALUES (4, 'd')", tableName))
+ assertThatThrownBy(() -> sql("INSERT INTO %s.branch_test2 VALUES (4, 'd')", tableName))
.isInstanceOf(ValidationException.class)
.hasMessage(
"Cannot write to both branch and WAP branch, but got branch [test2] and WAP branch [%s]",
@@ -84,7 +84,7 @@ public class TestPartitionedWritesToWapBranch extends PartitionedWritesTestBase
public void testWapIdAndWapBranchCannotBothBeSetForWrite() {
String wapId = UUID.randomUUID().toString();
spark.conf().set(SparkSQLProperties.WAP_ID, wapId);
- Assertions.assertThatThrownBy(() -> sql("INSERT INTO %s VALUES (4, 'd')", tableName))
+ assertThatThrownBy(() -> sql("INSERT INTO %s VALUES (4, 'd')", tableName))
.isInstanceOf(ValidationException.class)
.hasMessage(
"Cannot set both WAP ID and branch, but got ID [%s] and branch [%s]", wapId, BRANCH);
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSelect.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSelect.java
index ea97949d13..f585797399 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSelect.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSelect.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.sql;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
@@ -34,7 +36,6 @@ import org.apache.iceberg.spark.SparkCatalogTestBase;
import org.apache.iceberg.spark.SparkReadOptions;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Assume;
@@ -327,8 +328,7 @@ public class TestSelect extends SparkCatalogTestBase {
@Test
public void testUnknownReferenceAsOf() {
- Assertions.assertThatThrownBy(
- () -> sql("SELECT * FROM %s VERSION AS OF 'test_unknown'", tableName))
+ assertThatThrownBy(() -> sql("SELECT * FROM %s VERSION AS OF 'test_unknown'", tableName))
.hasMessageContaining("Cannot find matching snapshot ID or reference name for version")
.isInstanceOf(ValidationException.class);
}
@@ -395,7 +395,7 @@ public class TestSelect extends SparkCatalogTestBase {
sql("INSERT INTO %s VALUES (4, 'd', 4.0), (5, 'e', 5.0)", tableName);
// using snapshot in table identifier and VERSION AS OF
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"SELECT * FROM %s.%s VERSION AS OF %s",
@@ -406,7 +406,7 @@ public class TestSelect extends SparkCatalogTestBase {
.hasMessageContaining("Cannot do time-travel based on both table identifier and AS OF");
// using snapshot in table identifier and TIMESTAMP AS OF
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"SELECT * FROM %s.%s VERSION AS OF %s",
@@ -417,7 +417,7 @@ public class TestSelect extends SparkCatalogTestBase {
.hasMessageContaining("Cannot do time-travel based on both table identifier and AS OF");
// using timestamp in table identifier and VERSION AS OF
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"SELECT * FROM %s.%s TIMESTAMP AS OF %s",
@@ -428,7 +428,7 @@ public class TestSelect extends SparkCatalogTestBase {
.hasMessageContaining("Cannot do time-travel based on both table identifier and AS OF");
// using timestamp in table identifier and TIMESTAMP AS OF
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql(
"SELECT * FROM %s.%s TIMESTAMP AS OF %s",
@@ -448,14 +448,13 @@ public class TestSelect extends SparkCatalogTestBase {
sql("INSERT INTO %s VALUES (4, 'd', 4.0), (5, 'e', 5.0)", tableName);
// using branch_b1 in the table identifier and VERSION AS OF
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("SELECT * FROM %s.branch_b1 VERSION AS OF %s", tableName, snapshotId))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Cannot do time-travel based on both table identifier and AS OF");
// using branch_b1 in the table identifier and TIMESTAMP AS OF
- Assertions.assertThatThrownBy(
- () -> sql("SELECT * FROM %s.branch_b1 TIMESTAMP AS OF now()", tableName))
+ assertThatThrownBy(() -> sql("SELECT * FROM %s.branch_b1 TIMESTAMP AS OF now()", tableName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Cannot do time-travel based on both table identifier and AS OF");
}
@@ -471,7 +470,7 @@ public class TestSelect extends SparkCatalogTestBase {
// create a second snapshot
sql("INSERT INTO %s VALUES (4, 'd', 4.0), (5, 'e', 5.0)", tableName);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
spark
.read()
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSparkBucketFunction.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSparkBucketFunction.java
index 2cf2865fe8..250e3004b8 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSparkBucketFunction.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSparkBucketFunction.java
@@ -18,6 +18,9 @@
*/
package org.apache.iceberg.spark.sql;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.math.BigDecimal;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
@@ -28,7 +31,6 @@ import org.apache.iceberg.spark.functions.BucketFunction;
import org.apache.iceberg.types.Types;
import org.apache.spark.sql.AnalysisException;
import org.apache.spark.sql.types.DataTypes;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@@ -190,19 +192,19 @@ public class TestSparkBucketFunction extends SparkTestBaseWithCatalog {
@Test
public void testWrongNumberOfArguments() {
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.bucket()"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.bucket()"))
.as("Function resolution should not work with zero arguments")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
"Function 'bucket' cannot process input: (): Wrong number of inputs (expected numBuckets and value)");
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.bucket(1)"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.bucket(1)"))
.as("Function resolution should not work with only one argument")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
"Function 'bucket' cannot process input: (int): Wrong number of inputs (expected numBuckets and value)");
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.bucket(1, 1L, 1)"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.bucket(1, 1L, 1)"))
.as("Function resolution should not work with more than two arguments")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
@@ -211,33 +213,31 @@ public class TestSparkBucketFunction extends SparkTestBaseWithCatalog {
@Test
public void testInvalidTypesCannotBeUsedForNumberOfBuckets() {
- Assertions.assertThatThrownBy(
- () -> scalarSql("SELECT system.bucket(CAST('12.34' as DECIMAL(9, 2)), 10)"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.bucket(CAST('12.34' as DECIMAL(9, 2)), 10)"))
.as("Decimal type should not be coercible to the number of buckets")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
"Function 'bucket' cannot process input: (decimal(9,2), int): Expected number of buckets to be tinyint, shortint or int");
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.bucket(12L, 10)"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.bucket(12L, 10)"))
.as("Long type should not be coercible to the number of buckets")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
"Function 'bucket' cannot process input: (bigint, int): Expected number of buckets to be tinyint, shortint or int");
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.bucket('5', 10)"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.bucket('5', 10)"))
.as("String type should not be coercible to the number of buckets")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
"Function 'bucket' cannot process input: (string, int): Expected number of buckets to be tinyint, shortint or int");
- Assertions.assertThatThrownBy(
- () -> scalarSql("SELECT system.bucket(INTERVAL '100-00' YEAR TO MONTH, 10)"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.bucket(INTERVAL '100-00' YEAR TO MONTH, 10)"))
.as("Interval year to month type should not be coercible to the number of buckets")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
"Function 'bucket' cannot process input: (interval year to month, int): Expected number of buckets to be tinyint, shortint or int");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
scalarSql("SELECT system.bucket(CAST('11 23:4:0' AS INTERVAL DAY TO SECOND), 10)"))
.as("Interval day-time type should not be coercible to the number of buckets")
@@ -248,43 +248,40 @@ public class TestSparkBucketFunction extends SparkTestBaseWithCatalog {
@Test
public void testInvalidTypesForBucketColumn() {
- Assertions.assertThatThrownBy(
- () -> scalarSql("SELECT system.bucket(10, cast(12.3456 as float))"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.bucket(10, cast(12.3456 as float))"))
.as("Double type should not be bucketable")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
"Function 'bucket' cannot process input: (int, float): Expected column to be date, tinyint, smallint, int, bigint, decimal, timestamp, string, or binary");
- Assertions.assertThatThrownBy(
- () -> scalarSql("SELECT system.bucket(10, cast(12.3456 as double))"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.bucket(10, cast(12.3456 as double))"))
.as("Double type should not be bucketable")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
"Function 'bucket' cannot process input: (int, double): Expected column to be date, tinyint, smallint, int, bigint, decimal, timestamp, string, or binary");
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.bucket(10, true)"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.bucket(10, true)"))
.as("Boolean type should not be bucketable")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Function 'bucket' cannot process input: (int, boolean)");
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.bucket(10, map(1, 1))"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.bucket(10, map(1, 1))"))
.as("Map types should not be bucketable")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Function 'bucket' cannot process input: (int, map<int,int>)");
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.bucket(10, array(1L))"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.bucket(10, array(1L))"))
.as("Array types should not be bucketable")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Function 'bucket' cannot process input: (int, array<bigint>)");
- Assertions.assertThatThrownBy(
- () -> scalarSql("SELECT system.bucket(10, INTERVAL '100-00' YEAR TO MONTH)"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.bucket(10, INTERVAL '100-00' YEAR TO MONTH)"))
.as("Interval year-to-month type should not be bucketable")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
"Function 'bucket' cannot process input: (int, interval year to month)");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
scalarSql("SELECT system.bucket(10, CAST('11 23:4:0' AS INTERVAL DAY TO SECOND))"))
.as("Interval day-time type should not be bucketable")
@@ -296,63 +293,59 @@ public class TestSparkBucketFunction extends SparkTestBaseWithCatalog {
@Test
public void testThatMagicFunctionsAreInvoked() {
// TinyInt
- Assertions.assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.bucket(5, 6Y)"))
+ assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.bucket(5, 6Y)"))
.asString()
.isNotNull()
.contains("staticinvoke(class org.apache.iceberg.spark.functions.BucketFunction$BucketInt");
// SmallInt
- Assertions.assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.bucket(5, 6S)"))
+ assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.bucket(5, 6S)"))
.asString()
.isNotNull()
.contains("staticinvoke(class org.apache.iceberg.spark.functions.BucketFunction$BucketInt");
// Int
- Assertions.assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.bucket(5, 6)"))
+ assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.bucket(5, 6)"))
.asString()
.isNotNull()
.contains("staticinvoke(class org.apache.iceberg.spark.functions.BucketFunction$BucketInt");
// Date
- Assertions.assertThat(
- scalarSql("EXPLAIN EXTENDED SELECT system.bucket(100, DATE '2022-08-08')"))
+ assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.bucket(100, DATE '2022-08-08')"))
.asString()
.isNotNull()
.contains("staticinvoke(class org.apache.iceberg.spark.functions.BucketFunction$BucketInt");
// Long
- Assertions.assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.bucket(5, 6L)"))
+ assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.bucket(5, 6L)"))
.asString()
.isNotNull()
.contains(
"staticinvoke(class org.apache.iceberg.spark.functions.BucketFunction$BucketLong");
// Timestamp
- Assertions.assertThat(
- scalarSql("EXPLAIN EXTENDED SELECT system.bucket(100, TIMESTAMP '2022-08-08')"))
+ assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.bucket(100, TIMESTAMP '2022-08-08')"))
.asString()
.isNotNull()
.contains(
"staticinvoke(class org.apache.iceberg.spark.functions.BucketFunction$BucketLong");
// String
- Assertions.assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.bucket(5, 'abcdefg')"))
+ assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.bucket(5, 'abcdefg')"))
.asString()
.isNotNull()
.contains(
"staticinvoke(class org.apache.iceberg.spark.functions.BucketFunction$BucketString");
// Decimal
- Assertions.assertThat(
- scalarSql("EXPLAIN EXTENDED SELECT system.bucket(5, CAST('12.34' AS DECIMAL))"))
+ assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.bucket(5, CAST('12.34' AS DECIMAL))"))
.asString()
.isNotNull()
.contains(
"staticinvoke(class org.apache.iceberg.spark.functions.BucketFunction$BucketDecimal");
// Binary
- Assertions.assertThat(
- scalarSql("EXPLAIN EXTENDED SELECT system.bucket(4, X'0102030405060708')"))
+ assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.bucket(4, X'0102030405060708')"))
.asString()
.isNotNull()
.contains(
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSparkDaysFunction.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSparkDaysFunction.java
index e139d3d000..c60e5ea4d8 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSparkDaysFunction.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSparkDaysFunction.java
@@ -18,10 +18,11 @@
*/
package org.apache.iceberg.spark.sql;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.sql.Date;
import org.apache.iceberg.spark.SparkTestBaseWithCatalog;
import org.apache.spark.sql.AnalysisException;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@@ -69,12 +70,12 @@ public class TestSparkDaysFunction extends SparkTestBaseWithCatalog {
@Test
public void testWrongNumberOfArguments() {
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.days()"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.days()"))
.as("Function resolution should not work with zero arguments")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Function 'days' cannot process input: (): Wrong number of inputs");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> scalarSql("SELECT system.days(date('1969-12-31'), date('1969-12-31'))"))
.as("Function resolution should not work with more than one argument")
.isInstanceOf(AnalysisException.class)
@@ -84,13 +85,13 @@ public class TestSparkDaysFunction extends SparkTestBaseWithCatalog {
@Test
public void testInvalidInputTypes() {
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.days(1)"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.days(1)"))
.as("Int type should not be coercible to date/timestamp")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
"Function 'days' cannot process input: (int): Expected value to be date or timestamp");
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.days(1L)"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.days(1L)"))
.as("Long type should not be coercible to date/timestamp")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSparkHoursFunction.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSparkHoursFunction.java
index 312299ffee..0288725737 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSparkHoursFunction.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSparkHoursFunction.java
@@ -18,9 +18,10 @@
*/
package org.apache.iceberg.spark.sql;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import org.apache.iceberg.spark.SparkTestBaseWithCatalog;
import org.apache.spark.sql.AnalysisException;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@@ -51,12 +52,12 @@ public class TestSparkHoursFunction extends SparkTestBaseWithCatalog {
@Test
public void testWrongNumberOfArguments() {
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.hours()"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.hours()"))
.as("Function resolution should not work with zero arguments")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Function 'hours' cannot process input: (): Wrong number of inputs");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> scalarSql("SELECT system.hours(date('1969-12-31'), date('1969-12-31'))"))
.as("Function resolution should not work with more than one argument")
.isInstanceOf(AnalysisException.class)
@@ -66,13 +67,13 @@ public class TestSparkHoursFunction extends SparkTestBaseWithCatalog {
@Test
public void testInvalidInputTypes() {
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.hours(1)"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.hours(1)"))
.as("Int type should not be coercible to timestamp")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
"Function 'hours' cannot process input: (int): Expected value to be timestamp");
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.hours(1L)"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.hours(1L)"))
.as("Long type should not be coercible to timestamp")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSparkMonthsFunction.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSparkMonthsFunction.java
index c95823b889..804baf5351 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSparkMonthsFunction.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSparkMonthsFunction.java
@@ -18,10 +18,12 @@
*/
package org.apache.iceberg.spark.sql;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import org.apache.iceberg.spark.SparkTestBaseWithCatalog;
import org.apache.iceberg.spark.functions.MonthsFunction;
import org.apache.spark.sql.AnalysisException;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@@ -67,12 +69,12 @@ public class TestSparkMonthsFunction extends SparkTestBaseWithCatalog {
@Test
public void testWrongNumberOfArguments() {
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.months()"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.months()"))
.as("Function resolution should not work with zero arguments")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Function 'months' cannot process input: (): Wrong number of inputs");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> scalarSql("SELECT system.months(date('1969-12-31'), date('1969-12-31'))"))
.as("Function resolution should not work with more than one argument")
.isInstanceOf(AnalysisException.class)
@@ -82,13 +84,13 @@ public class TestSparkMonthsFunction extends SparkTestBaseWithCatalog {
@Test
public void testInvalidInputTypes() {
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.months(1)"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.months(1)"))
.as("Int type should not be coercible to date/timestamp")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
"Function 'months' cannot process input: (int): Expected value to be date or timestamp");
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.months(1L)"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.months(1L)"))
.as("Long type should not be coercible to date/timestamp")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
@@ -99,14 +101,14 @@ public class TestSparkMonthsFunction extends SparkTestBaseWithCatalog {
public void testThatMagicFunctionsAreInvoked() {
String dateValue = "date('2017-12-01')";
String dateTransformClass = MonthsFunction.DateToMonthsFunction.class.getName();
- Assertions.assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.months(%s)", dateValue))
+ assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.months(%s)", dateValue))
.asString()
.isNotNull()
.contains("staticinvoke(class " + dateTransformClass);
String timestampValue = "TIMESTAMP '2017-12-01 10:12:55.038194 UTC+00:00'";
String timestampTransformClass = MonthsFunction.TimestampToMonthsFunction.class.getName();
- Assertions.assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.months(%s)", timestampValue))
+ assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.months(%s)", timestampValue))
.asString()
.isNotNull()
.contains("staticinvoke(class " + timestampTransformClass);
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSparkTruncateFunction.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSparkTruncateFunction.java
index aaf4f569b6..9000170a3e 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSparkTruncateFunction.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSparkTruncateFunction.java
@@ -18,12 +18,14 @@
*/
package org.apache.iceberg.spark.sql;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.math.BigDecimal;
import java.nio.charset.StandardCharsets;
import org.apache.iceberg.relocated.com.google.common.io.BaseEncoding;
import org.apache.iceberg.spark.SparkTestBaseWithCatalog;
import org.apache.spark.sql.AnalysisException;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@@ -297,19 +299,19 @@ public class TestSparkTruncateFunction extends SparkTestBaseWithCatalog {
@Test
public void testWrongNumberOfArguments() {
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.truncate()"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.truncate()"))
.as("Function resolution should not work with zero arguments")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
"Function 'truncate' cannot process input: (): Wrong number of inputs (expected width and value)");
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.truncate(1)"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.truncate(1)"))
.as("Function resolution should not work with only one argument")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
"Function 'truncate' cannot process input: (int): Wrong number of inputs (expected width and value)");
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.truncate(1, 1L, 1)"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.truncate(1, 1L, 1)"))
.as("Function resolution should not work with more than two arguments")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
@@ -318,27 +320,27 @@ public class TestSparkTruncateFunction extends SparkTestBaseWithCatalog {
@Test
public void testInvalidTypesCannotBeUsedForWidth() {
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> scalarSql("SELECT system.truncate(CAST('12.34' as DECIMAL(9, 2)), 10)"))
.as("Decimal type should not be coercible to the width field")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
"Function 'truncate' cannot process input: (decimal(9,2), int): Expected truncation width to be tinyint, shortint or int");
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.truncate('5', 10)"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.truncate('5', 10)"))
.as("String type should not be coercible to the width field")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
"Function 'truncate' cannot process input: (string, int): Expected truncation width to be tinyint, shortint or int");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> scalarSql("SELECT system.truncate(INTERVAL '100-00' YEAR TO MONTH, 10)"))
.as("Interval year to month type should not be coercible to the width field")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
"Function 'truncate' cannot process input: (interval year to month, int): Expected truncation width to be tinyint, shortint or int");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
scalarSql(
"SELECT system.truncate(CAST('11 23:4:0' AS INTERVAL DAY TO SECOND), 10)"))
@@ -350,46 +352,44 @@ public class TestSparkTruncateFunction extends SparkTestBaseWithCatalog {
@Test
public void testInvalidTypesForTruncationColumn() {
- Assertions.assertThatThrownBy(
- () -> scalarSql("SELECT system.truncate(10, cast(12.3456 as float))"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.truncate(10, cast(12.3456 as float))"))
.as("FLoat type should not be truncatable")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
"Function 'truncate' cannot process input: (int, float): Expected truncation col to be tinyint, shortint, int, bigint, decimal, string, or binary");
- Assertions.assertThatThrownBy(
- () -> scalarSql("SELECT system.truncate(10, cast(12.3456 as double))"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.truncate(10, cast(12.3456 as double))"))
.as("Double type should not be truncatable")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
"Function 'truncate' cannot process input: (int, double): Expected truncation col to be tinyint, shortint, int, bigint, decimal, string, or binary");
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.truncate(10, true)"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.truncate(10, true)"))
.as("Boolean type should not be truncatable")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
"Function 'truncate' cannot process input: (int, boolean): Expected truncation col to be tinyint, shortint, int, bigint, decimal, string, or binary");
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.truncate(10, map(1, 1))"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.truncate(10, map(1, 1))"))
.as("Map types should not be truncatable")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
"Function 'truncate' cannot process input: (int, map<int,int>): Expected truncation col to be tinyint, shortint, int, bigint, decimal, string, or binary");
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.truncate(10, array(1L))"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.truncate(10, array(1L))"))
.as("Array types should not be truncatable")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
"Function 'truncate' cannot process input: (int, array<bigint>): Expected truncation col to be tinyint, shortint, int, bigint, decimal, string, or binary");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> scalarSql("SELECT system.truncate(10, INTERVAL '100-00' YEAR TO MONTH)"))
.as("Interval year-to-month type should not be truncatable")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
"Function 'truncate' cannot process input: (int, interval year to month): Expected truncation col to be tinyint, shortint, int, bigint, decimal, string, or binary");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
scalarSql(
"SELECT system.truncate(10, CAST('11 23:4:0' AS INTERVAL DAY TO SECOND))"))
@@ -405,13 +405,13 @@ public class TestSparkTruncateFunction extends SparkTestBaseWithCatalog {
// applyfunctionexpression instead.
String tinyIntWidthExplain =
(String) scalarSql("EXPLAIN EXTENDED SELECT system.truncate(1Y, 6)");
- Assertions.assertThat(tinyIntWidthExplain)
+ assertThat(tinyIntWidthExplain)
.contains("cast(1 as int)")
.contains(
"staticinvoke(class org.apache.iceberg.spark.functions.TruncateFunction$TruncateInt");
String smallIntWidth = (String) scalarSql("EXPLAIN EXTENDED SELECT system.truncate(5S, 6L)");
- Assertions.assertThat(smallIntWidth)
+ assertThat(smallIntWidth)
.contains("cast(5 as int)")
.contains(
"staticinvoke(class org.apache.iceberg.spark.functions.TruncateFunction$TruncateBigInt");
@@ -423,50 +423,49 @@ public class TestSparkTruncateFunction extends SparkTestBaseWithCatalog {
// Non-magic calls have `applyfunctionexpression` instead.
// TinyInt
- Assertions.assertThat(scalarSql("EXPLAIN EXTENDED select system.truncate(5, 6Y)"))
+ assertThat(scalarSql("EXPLAIN EXTENDED select system.truncate(5, 6Y)"))
.asString()
.isNotNull()
.contains(
"staticinvoke(class org.apache.iceberg.spark.functions.TruncateFunction$TruncateTinyInt");
// SmallInt
- Assertions.assertThat(scalarSql("EXPLAIN EXTENDED select system.truncate(5, 6S)"))
+ assertThat(scalarSql("EXPLAIN EXTENDED select system.truncate(5, 6S)"))
.asString()
.isNotNull()
.contains(
"staticinvoke(class org.apache.iceberg.spark.functions.TruncateFunction$TruncateSmallInt");
// Int
- Assertions.assertThat(scalarSql("EXPLAIN EXTENDED select system.truncate(5, 6)"))
+ assertThat(scalarSql("EXPLAIN EXTENDED select system.truncate(5, 6)"))
.asString()
.isNotNull()
.contains(
"staticinvoke(class org.apache.iceberg.spark.functions.TruncateFunction$TruncateInt");
// Long
- Assertions.assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.truncate(5, 6L)"))
+ assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.truncate(5, 6L)"))
.asString()
.isNotNull()
.contains(
"staticinvoke(class org.apache.iceberg.spark.functions.TruncateFunction$TruncateBigInt");
// String
- Assertions.assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.truncate(5, 'abcdefg')"))
+ assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.truncate(5, 'abcdefg')"))
.asString()
.isNotNull()
.contains(
"staticinvoke(class org.apache.iceberg.spark.functions.TruncateFunction$TruncateString");
// Decimal
- Assertions.assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.truncate(5, 12.34)"))
+ assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.truncate(5, 12.34)"))
.asString()
.isNotNull()
.contains(
"staticinvoke(class org.apache.iceberg.spark.functions.TruncateFunction$TruncateDecimal");
// Binary
- Assertions.assertThat(
- scalarSql("EXPLAIN EXTENDED SELECT system.truncate(4, X'0102030405060708')"))
+ assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.truncate(4, X'0102030405060708')"))
.asString()
.isNotNull()
.contains(
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSparkYearsFunction.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSparkYearsFunction.java
index 600b6ac0c1..3d2611c45f 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSparkYearsFunction.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestSparkYearsFunction.java
@@ -18,10 +18,12 @@
*/
package org.apache.iceberg.spark.sql;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import org.apache.iceberg.spark.SparkTestBaseWithCatalog;
import org.apache.iceberg.spark.functions.YearsFunction;
import org.apache.spark.sql.AnalysisException;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@@ -69,12 +71,12 @@ public class TestSparkYearsFunction extends SparkTestBaseWithCatalog {
@Test
public void testWrongNumberOfArguments() {
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.years()"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.years()"))
.as("Function resolution should not work with zero arguments")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Function 'years' cannot process input: (): Wrong number of inputs");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> scalarSql("SELECT system.years(date('1969-12-31'), date('1969-12-31'))"))
.as("Function resolution should not work with more than one argument")
.isInstanceOf(AnalysisException.class)
@@ -84,13 +86,13 @@ public class TestSparkYearsFunction extends SparkTestBaseWithCatalog {
@Test
public void testInvalidInputTypes() {
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.years(1)"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.years(1)"))
.as("Int type should not be coercible to date/timestamp")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
"Function 'years' cannot process input: (int): Expected value to be date or timestamp");
- Assertions.assertThatThrownBy(() -> scalarSql("SELECT system.years(1L)"))
+ assertThatThrownBy(() -> scalarSql("SELECT system.years(1L)"))
.as("Long type should not be coercible to date/timestamp")
.isInstanceOf(AnalysisException.class)
.hasMessageContaining(
@@ -101,14 +103,14 @@ public class TestSparkYearsFunction extends SparkTestBaseWithCatalog {
public void testThatMagicFunctionsAreInvoked() {
String dateValue = "date('2017-12-01')";
String dateTransformClass = YearsFunction.DateToYearsFunction.class.getName();
- Assertions.assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.years(%s)", dateValue))
+ assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.years(%s)", dateValue))
.asString()
.isNotNull()
.contains("staticinvoke(class " + dateTransformClass);
String timestampValue = "TIMESTAMP '2017-12-01 10:12:55.038194 UTC+00:00'";
String timestampTransformClass = YearsFunction.TimestampToYearsFunction.class.getName();
- Assertions.assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.years(%s)", timestampValue))
+ assertThat(scalarSql("EXPLAIN EXTENDED SELECT system.years(%s)", timestampValue))
.asString()
.isNotNull()
.contains("staticinvoke(class " + timestampTransformClass);
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestTimestampWithoutZone.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestTimestampWithoutZone.java
index 5a8c5736a6..ba20a1e7bf 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestTimestampWithoutZone.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestTimestampWithoutZone.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.sql;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.sql.Timestamp;
import java.util.Arrays;
import java.util.List;
@@ -36,7 +38,6 @@ import org.apache.iceberg.spark.SparkUtil;
import org.apache.iceberg.types.Type;
import org.apache.iceberg.types.Types;
import org.apache.spark.sql.util.CaseInsensitiveStringMap;
-import org.assertj.core.api.Assertions;
import org.joda.time.DateTime;
import org.junit.After;
import org.junit.Assert;
@@ -95,8 +96,7 @@ public class TestTimestampWithoutZone extends SparkCatalogTestBase {
@Test
public void testWriteTimestampWithoutZoneError() {
- Assertions.assertThatThrownBy(
- () -> sql("INSERT INTO %s VALUES %s", tableName, rowToSqlValues(values)))
+ assertThatThrownBy(() -> sql("INSERT INTO %s VALUES %s", tableName, rowToSqlValues(values)))
.as(
String.format(
"Write operation performed on a timestamp without timezone field while "
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestUnpartitionedWritesToBranch.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestUnpartitionedWritesToBranch.java
index 1f5bee42af..891813e381 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestUnpartitionedWritesToBranch.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/TestUnpartitionedWritesToBranch.java
@@ -18,10 +18,11 @@
*/
package org.apache.iceberg.spark.sql;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.util.Map;
import org.apache.iceberg.Table;
import org.apache.iceberg.exceptions.ValidationException;
-import org.assertj.core.api.Assertions;
import org.junit.Test;
public class TestUnpartitionedWritesToBranch extends UnpartitionedWritesTestBase {
@@ -53,7 +54,7 @@ public class TestUnpartitionedWritesToBranch extends UnpartitionedWritesTestBase
@Test
public void testInsertIntoNonExistingBranchFails() {
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("INSERT INTO %s.branch_not_exist VALUES (4, 'd'), (5, 'e')", tableName))
.isInstanceOf(ValidationException.class)
.hasMessage("Cannot use branch (does not exist): not_exist");
diff --git a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/UnpartitionedWritesTestBase.java b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/UnpartitionedWritesTestBase.java
index 813e442c66..06f5ba273b 100644
--- a/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/UnpartitionedWritesTestBase.java
+++ b/spark/v3.3/spark/src/test/java/org/apache/iceberg/spark/sql/UnpartitionedWritesTestBase.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.sql;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.util.List;
import java.util.Map;
import org.apache.iceberg.relocated.com.google.common.collect.ImmutableList;
@@ -27,7 +29,6 @@ import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
import org.apache.spark.sql.functions;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Assume;
@@ -97,7 +98,7 @@ public abstract class UnpartitionedWritesTestBase extends SparkCatalogTestBase {
Assume.assumeTrue(tableName.equals(commitTarget()));
long snapshotId = validationCatalog.loadTable(tableIdent).currentSnapshot().snapshotId();
String prefix = "snapshot_id_";
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql("INSERT INTO %s.%s VALUES (4, 'd'), (5, 'e')", tableName, prefix + snapshotId))
.as("Should not be able to insert into a table at a specific snapshot")
@@ -110,7 +111,7 @@ public abstract class UnpartitionedWritesTestBase extends SparkCatalogTestBase {
Assume.assumeTrue(tableName.equals(commitTarget()));
long snapshotId = validationCatalog.loadTable(tableIdent).currentSnapshot().snapshotId();
String prefix = "snapshot_id_";
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"INSERT OVERWRITE %s.%s VALUES (4, 'd'), (5, 'e')",
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAddFilesProcedure.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAddFilesProcedure.java
index 3ed99da249..676f7637cd 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAddFilesProcedure.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAddFilesProcedure.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.extensions;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.File;
import java.io.IOException;
@@ -47,7 +48,6 @@ import org.apache.spark.sql.types.DataTypes;
import org.apache.spark.sql.types.Metadata;
import org.apache.spark.sql.types.StructField;
import org.apache.spark.sql.types.StructType;
-import org.assertj.core.api.Assertions;
import org.joda.time.DateTime;
import org.junit.After;
import org.junit.Assert;
@@ -688,7 +688,7 @@ public class TestAddFilesProcedure extends SparkExtensionsTestBase {
createIcebergTable("id Integer, name String, dept String, subdept String");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
scalarSql(
"CALL %s.system.add_files('%s', '`parquet`.`%s`', map('id', 1))",
@@ -696,7 +696,7 @@ public class TestAddFilesProcedure extends SparkExtensionsTestBase {
.isInstanceOf(IllegalArgumentException.class)
.hasMessageStartingWith("Cannot use partition filter with an unpartitioned table");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
scalarSql(
"CALL %s.system.add_files('%s', '`parquet`.`%s`')",
@@ -712,7 +712,7 @@ public class TestAddFilesProcedure extends SparkExtensionsTestBase {
createIcebergTable(
"id Integer, name String, dept String, subdept String", "PARTITIONED BY (id)");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
scalarSql(
"CALL %s.system.add_files('%s', '`parquet`.`%s`', map('x', '1', 'y', '2'))",
@@ -721,7 +721,7 @@ public class TestAddFilesProcedure extends SparkExtensionsTestBase {
.hasMessageStartingWith("Cannot add data files to target table")
.hasMessageContaining("is greater than the number of partitioned columns");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
scalarSql(
"CALL %s.system.add_files('%s', '`parquet`.`%s`', map('dept', '2'))",
@@ -781,7 +781,7 @@ public class TestAddFilesProcedure extends SparkExtensionsTestBase {
+ "partition_filter => map('id', 1))",
catalogName, tableName, sourceTableName);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
scalarSql(
"CALL %s.system.add_files("
@@ -840,7 +840,7 @@ public class TestAddFilesProcedure extends SparkExtensionsTestBase {
sql("CALL %s.system.add_files('%s', '%s')", catalogName, tableName, sourceTableName);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
scalarSql(
"CALL %s.system.add_files('%s', '%s')",
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAlterTablePartitionFields.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAlterTablePartitionFields.java
index 948fc462de..2c109f1007 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAlterTablePartitionFields.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAlterTablePartitionFields.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThat;
+
import org.apache.iceberg.PartitionSpec;
import org.apache.iceberg.Table;
import org.apache.iceberg.TableProperties;
@@ -27,7 +29,6 @@ import org.apache.iceberg.spark.source.SparkTable;
import org.apache.spark.sql.connector.catalog.CatalogManager;
import org.apache.spark.sql.connector.catalog.Identifier;
import org.apache.spark.sql.connector.catalog.TableCatalog;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
@@ -185,9 +186,7 @@ public class TestAlterTablePartitionFields extends SparkExtensionsTestBase {
createTable("id bigint NOT NULL, category string, ts timestamp, data string");
Table table = validationCatalog.loadTable(tableIdent);
- Assertions.assertThat(table.spec().isUnpartitioned())
- .as("Table should start unpartitioned")
- .isTrue();
+ assertThat(table.spec().isUnpartitioned()).as("Table should start unpartitioned").isTrue();
sql("ALTER TABLE %s ADD PARTITION FIELD year(ts)", tableName);
@@ -196,7 +195,7 @@ public class TestAlterTablePartitionFields extends SparkExtensionsTestBase {
PartitionSpec expected =
PartitionSpec.builderFor(table.schema()).withSpecId(1).year("ts").build();
- Assertions.assertThat(table.spec()).as("Should have new spec field").isEqualTo(expected);
+ assertThat(table.spec()).as("Should have new spec field").isEqualTo(expected);
}
@Test
@@ -204,9 +203,7 @@ public class TestAlterTablePartitionFields extends SparkExtensionsTestBase {
createTable("id bigint NOT NULL, category string, ts timestamp, data string");
Table table = validationCatalog.loadTable(tableIdent);
- Assertions.assertThat(table.spec().isUnpartitioned())
- .as("Table should start unpartitioned")
- .isTrue();
+ assertThat(table.spec().isUnpartitioned()).as("Table should start unpartitioned").isTrue();
sql("ALTER TABLE %s ADD PARTITION FIELD month(ts)", tableName);
@@ -215,7 +212,7 @@ public class TestAlterTablePartitionFields extends SparkExtensionsTestBase {
PartitionSpec expected =
PartitionSpec.builderFor(table.schema()).withSpecId(1).month("ts").build();
- Assertions.assertThat(table.spec()).as("Should have new spec field").isEqualTo(expected);
+ assertThat(table.spec()).as("Should have new spec field").isEqualTo(expected);
}
@Test
@@ -223,9 +220,7 @@ public class TestAlterTablePartitionFields extends SparkExtensionsTestBase {
createTable("id bigint NOT NULL, category string, ts timestamp, data string");
Table table = validationCatalog.loadTable(tableIdent);
- Assertions.assertThat(table.spec().isUnpartitioned())
- .as("Table should start unpartitioned")
- .isTrue();
+ assertThat(table.spec().isUnpartitioned()).as("Table should start unpartitioned").isTrue();
sql("ALTER TABLE %s ADD PARTITION FIELD day(ts)", tableName);
@@ -234,7 +229,7 @@ public class TestAlterTablePartitionFields extends SparkExtensionsTestBase {
PartitionSpec expected =
PartitionSpec.builderFor(table.schema()).withSpecId(1).day("ts").build();
- Assertions.assertThat(table.spec()).as("Should have new spec field").isEqualTo(expected);
+ assertThat(table.spec()).as("Should have new spec field").isEqualTo(expected);
}
@Test
@@ -242,9 +237,7 @@ public class TestAlterTablePartitionFields extends SparkExtensionsTestBase {
createTable("id bigint NOT NULL, category string, ts timestamp, data string");
Table table = validationCatalog.loadTable(tableIdent);
- Assertions.assertThat(table.spec().isUnpartitioned())
- .as("Table should start unpartitioned")
- .isTrue();
+ assertThat(table.spec().isUnpartitioned()).as("Table should start unpartitioned").isTrue();
sql("ALTER TABLE %s ADD PARTITION FIELD hour(ts)", tableName);
@@ -253,7 +246,7 @@ public class TestAlterTablePartitionFields extends SparkExtensionsTestBase {
PartitionSpec expected =
PartitionSpec.builderFor(table.schema()).withSpecId(1).hour("ts").build();
- Assertions.assertThat(table.spec()).as("Should have new spec field").isEqualTo(expected);
+ assertThat(table.spec()).as("Should have new spec field").isEqualTo(expected);
}
@Test
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAlterTableSchema.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAlterTableSchema.java
index 7a6eb9aa38..81bc1a59e1 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAlterTableSchema.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAlterTableSchema.java
@@ -18,10 +18,11 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.util.Map;
import org.apache.iceberg.Table;
import org.apache.iceberg.relocated.com.google.common.collect.Sets;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
@@ -77,12 +78,11 @@ public class TestAlterTableSchema extends SparkExtensionsTestBase {
Table table = validationCatalog.loadTable(tableIdent);
Assert.assertTrue(
"Table should start without identifier", table.schema().identifierFieldIds().isEmpty());
- Assertions.assertThatThrownBy(
- () -> sql("ALTER TABLE %s SET IDENTIFIER FIELDS unknown", tableName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s SET IDENTIFIER FIELDS unknown", tableName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessageEndingWith("not found in current schema or added columns");
- Assertions.assertThatThrownBy(() -> sql("ALTER TABLE %s SET IDENTIFIER FIELDS id2", tableName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s SET IDENTIFIER FIELDS id2", tableName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessageEndingWith("not a required field");
}
@@ -137,20 +137,17 @@ public class TestAlterTableSchema extends SparkExtensionsTestBase {
Table table = validationCatalog.loadTable(tableIdent);
Assert.assertTrue(
"Table should start without identifier", table.schema().identifierFieldIds().isEmpty());
- Assertions.assertThatThrownBy(
- () -> sql("ALTER TABLE %s DROP IDENTIFIER FIELDS unknown", tableName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s DROP IDENTIFIER FIELDS unknown", tableName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Cannot complete drop identifier fields operation: field unknown not found");
sql("ALTER TABLE %s SET IDENTIFIER FIELDS id", tableName);
- Assertions.assertThatThrownBy(
- () -> sql("ALTER TABLE %s DROP IDENTIFIER FIELDS data", tableName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s DROP IDENTIFIER FIELDS data", tableName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage(
"Cannot complete drop identifier fields operation: data is not an identifier field");
- Assertions.assertThatThrownBy(
- () -> sql("ALTER TABLE %s DROP IDENTIFIER FIELDS location.lon", tableName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s DROP IDENTIFIER FIELDS location.lon", tableName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage(
"Cannot complete drop identifier fields operation: location.lon is not an identifier field");
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAncestorsOfProcedure.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAncestorsOfProcedure.java
index 3282cdf381..1aa3e17fce 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAncestorsOfProcedure.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestAncestorsOfProcedure.java
@@ -18,12 +18,13 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.util.List;
import java.util.Map;
import org.apache.iceberg.Table;
import org.apache.iceberg.relocated.com.google.common.collect.ImmutableList;
import org.apache.spark.sql.AnalysisException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Test;
@@ -147,16 +148,15 @@ public class TestAncestorsOfProcedure extends SparkExtensionsTestBase {
@Test
public void testInvalidAncestorOfCases() {
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.ancestors_of()", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.ancestors_of()", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Missing required parameters: [table]");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.ancestors_of('')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.ancestors_of('')", catalogName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Cannot handle an empty identifier for parameter 'table'");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.ancestors_of('%s', 1.1)", catalogName, tableIdent))
+ assertThatThrownBy(() -> sql("CALL %s.system.ancestors_of('%s', 1.1)", catalogName, tableIdent))
.isInstanceOf(AnalysisException.class)
.hasMessageStartingWith("Wrong arg type for snapshot_id: cannot cast");
}
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestBranchDDL.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestBranchDDL.java
index a6bf194b3d..6302c7d3f4 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestBranchDDL.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestBranchDDL.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.extensions;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.List;
import java.util.Map;
@@ -33,7 +34,6 @@ import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
import org.apache.spark.sql.catalyst.parser.extensions.IcebergParseException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
@@ -85,8 +85,7 @@ public class TestBranchDDL extends SparkExtensionsTestBase {
Assert.assertEquals(TimeUnit.DAYS.toMillis(maxSnapshotAge), ref.maxSnapshotAgeMs().longValue());
Assert.assertEquals(TimeUnit.DAYS.toMillis(maxRefAge), ref.maxRefAgeMs().longValue());
- Assertions.assertThatThrownBy(
- () -> sql("ALTER TABLE %s CREATE BRANCH %s", tableName, branchName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s CREATE BRANCH %s", tableName, branchName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Ref b1 already exists");
}
@@ -98,20 +97,20 @@ public class TestBranchDDL extends SparkExtensionsTestBase {
Table table = validationCatalog.loadTable(tableIdent);
SnapshotRef mainRef = table.refs().get(SnapshotRef.MAIN_BRANCH);
- Assertions.assertThat(mainRef).isNull();
+ assertThat(mainRef).isNull();
SnapshotRef ref = table.refs().get(branchName);
- Assertions.assertThat(ref).isNotNull();
- Assertions.assertThat(ref.minSnapshotsToKeep()).isNull();
- Assertions.assertThat(ref.maxSnapshotAgeMs()).isNull();
- Assertions.assertThat(ref.maxRefAgeMs()).isNull();
+ assertThat(ref).isNotNull();
+ assertThat(ref.minSnapshotsToKeep()).isNull();
+ assertThat(ref.maxSnapshotAgeMs()).isNull();
+ assertThat(ref.maxRefAgeMs()).isNull();
Snapshot snapshot = table.snapshot(ref.snapshotId());
- Assertions.assertThat(snapshot.parentId()).isNull();
- Assertions.assertThat(snapshot.addedDataFiles(table.io())).isEmpty();
- Assertions.assertThat(snapshot.removedDataFiles(table.io())).isEmpty();
- Assertions.assertThat(snapshot.addedDeleteFiles(table.io())).isEmpty();
- Assertions.assertThat(snapshot.removedDeleteFiles(table.io())).isEmpty();
+ assertThat(snapshot.parentId()).isNull();
+ assertThat(snapshot.addedDataFiles(table.io())).isEmpty();
+ assertThat(snapshot.removedDataFiles(table.io())).isEmpty();
+ assertThat(snapshot.addedDeleteFiles(table.io())).isEmpty();
+ assertThat(snapshot.removedDeleteFiles(table.io())).isEmpty();
}
@Test
@@ -194,7 +193,7 @@ public class TestBranchDDL extends SparkExtensionsTestBase {
Assert.assertEquals(TimeUnit.DAYS.toMillis(maxSnapshotAge), ref.maxSnapshotAgeMs().longValue());
Assert.assertNull(ref.maxRefAgeMs());
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"ALTER TABLE %s CREATE BRANCH %s WITH SNAPSHOT RETENTION",
@@ -216,18 +215,17 @@ public class TestBranchDDL extends SparkExtensionsTestBase {
Assert.assertNull(ref.maxSnapshotAgeMs());
Assert.assertEquals(TimeUnit.DAYS.toMillis(maxRefAge), ref.maxRefAgeMs().longValue());
- Assertions.assertThatThrownBy(
- () -> sql("ALTER TABLE %s CREATE BRANCH %s RETAIN", tableName, branchName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s CREATE BRANCH %s RETAIN", tableName, branchName))
.isInstanceOf(IcebergParseException.class)
.hasMessageContaining("mismatched input");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql("ALTER TABLE %s CREATE BRANCH %s RETAIN %s DAYS", tableName, branchName, "abc"))
.isInstanceOf(IcebergParseException.class)
.hasMessageContaining("mismatched input");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"ALTER TABLE %s CREATE BRANCH %s RETAIN %d SECONDS",
@@ -255,8 +253,7 @@ public class TestBranchDDL extends SparkExtensionsTestBase {
@Test
public void testDropBranchDoesNotExist() {
- Assertions.assertThatThrownBy(
- () -> sql("ALTER TABLE %s DROP BRANCH %s", tableName, "nonExistingBranch"))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s DROP BRANCH %s", tableName, "nonExistingBranch"))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Branch does not exist: nonExistingBranch");
}
@@ -267,21 +264,21 @@ public class TestBranchDDL extends SparkExtensionsTestBase {
Table table = insertRows();
table.manageSnapshots().createTag(tagName, table.currentSnapshot().snapshotId()).commit();
- Assertions.assertThatThrownBy(() -> sql("ALTER TABLE %s DROP BRANCH %s", tableName, tagName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s DROP BRANCH %s", tableName, tagName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Ref b1 is a tag not a branch");
}
@Test
public void testDropBranchNonConformingName() {
- Assertions.assertThatThrownBy(() -> sql("ALTER TABLE %s DROP BRANCH %s", tableName, "123"))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s DROP BRANCH %s", tableName, "123"))
.isInstanceOf(IcebergParseException.class)
.hasMessageContaining("mismatched input '123'");
}
@Test
public void testDropMainBranchFails() {
- Assertions.assertThatThrownBy(() -> sql("ALTER TABLE %s DROP BRANCH main", tableName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s DROP BRANCH main", tableName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Cannot remove main branch");
}
@@ -330,20 +327,20 @@ public class TestBranchDDL extends SparkExtensionsTestBase {
Table table = validationCatalog.loadTable(tableIdent);
SnapshotRef mainRef = table.refs().get(SnapshotRef.MAIN_BRANCH);
- Assertions.assertThat(mainRef).isNull();
+ assertThat(mainRef).isNull();
SnapshotRef ref = table.refs().get(branchName);
- Assertions.assertThat(ref).isNotNull();
- Assertions.assertThat(ref.minSnapshotsToKeep()).isNull();
- Assertions.assertThat(ref.maxSnapshotAgeMs()).isNull();
- Assertions.assertThat(ref.maxRefAgeMs()).isNull();
+ assertThat(ref).isNotNull();
+ assertThat(ref.minSnapshotsToKeep()).isNull();
+ assertThat(ref.maxSnapshotAgeMs()).isNull();
+ assertThat(ref.maxRefAgeMs()).isNull();
Snapshot snapshot = table.snapshot(ref.snapshotId());
- Assertions.assertThat(snapshot.parentId()).isNull();
- Assertions.assertThat(snapshot.addedDataFiles(table.io())).isEmpty();
- Assertions.assertThat(snapshot.removedDataFiles(table.io())).isEmpty();
- Assertions.assertThat(snapshot.addedDeleteFiles(table.io())).isEmpty();
- Assertions.assertThat(snapshot.removedDeleteFiles(table.io())).isEmpty();
+ assertThat(snapshot.parentId()).isNull();
+ assertThat(snapshot.addedDataFiles(table.io())).isEmpty();
+ assertThat(snapshot.removedDataFiles(table.io())).isEmpty();
+ assertThat(snapshot.addedDeleteFiles(table.io())).isEmpty();
+ assertThat(snapshot.removedDeleteFiles(table.io())).isEmpty();
}
@Test
@@ -386,7 +383,7 @@ public class TestBranchDDL extends SparkExtensionsTestBase {
public void replaceBranchDoesNotExist() throws NoSuchTableException {
Table table = insertRows();
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"ALTER TABLE %s REPLACE BRANCH %s AS OF VERSION %d",
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCallStatementParser.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCallStatementParser.java
index 5c41604afa..a4630ab279 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCallStatementParser.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCallStatementParser.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.math.BigDecimal;
import java.sql.Timestamp;
import java.time.Instant;
@@ -37,7 +39,6 @@ import org.apache.spark.sql.catalyst.plans.logical.NamedArgument;
import org.apache.spark.sql.catalyst.plans.logical.PositionalArgument;
import org.apache.spark.sql.types.DataType;
import org.apache.spark.sql.types.DataTypes;
-import org.assertj.core.api.Assertions;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
@@ -144,7 +145,7 @@ public class TestCallStatementParser {
@Test
public void testCallParseError() {
- Assertions.assertThatThrownBy(() -> parser.parsePlan("CALL cat.system radish kebab"))
+ assertThatThrownBy(() -> parser.parsePlan("CALL cat.system radish kebab"))
.isInstanceOf(IcebergParseException.class)
.hasMessageContaining("missing '(' at 'radish'");
}
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestChangelogTable.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestChangelogTable.java
index d82ed11455..01523180b0 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestChangelogTable.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestChangelogTable.java
@@ -21,6 +21,7 @@ package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.TableProperties.FORMAT_VERSION;
import static org.apache.iceberg.TableProperties.MANIFEST_MERGE_ENABLED;
import static org.apache.iceberg.TableProperties.MANIFEST_MIN_MERGE_COUNT;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.List;
import java.util.Map;
@@ -34,7 +35,6 @@ import org.apache.iceberg.spark.SparkReadOptions;
import org.apache.iceberg.spark.source.SparkChangelogTable;
import org.apache.spark.sql.DataFrameReader;
import org.apache.spark.sql.Row;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
@@ -202,8 +202,7 @@ public class TestChangelogTable extends SparkExtensionsTestBase {
Snapshot snap3 = table.currentSnapshot();
long rightAfterSnap3 = waitUntilAfter(snap3.timestampMillis());
- Assertions.assertThatThrownBy(
- () -> changelogRecords(snap3.timestampMillis(), snap2.timestampMillis()))
+ assertThatThrownBy(() -> changelogRecords(snap3.timestampMillis(), snap2.timestampMillis()))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Cannot set start-timestamp to be greater than end-timestamp for changelogs");
}
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCherrypickSnapshotProcedure.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCherrypickSnapshotProcedure.java
index c9af319f5c..51762335a0 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCherrypickSnapshotProcedure.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCherrypickSnapshotProcedure.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.TableProperties.WRITE_AUDIT_PUBLISH_ENABLED;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.List;
import java.util.Map;
@@ -31,7 +32,6 @@ import org.apache.spark.sql.AnalysisException;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchProcedureException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Test;
@@ -161,7 +161,7 @@ public class TestCherrypickSnapshotProcedure extends SparkExtensionsTestBase {
public void testCherrypickInvalidSnapshot() {
sql("CREATE TABLE %s (id bigint NOT NULL, data string) USING iceberg", tableName);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.cherrypick_snapshot('%s', -1L)", catalogName, tableIdent))
.isInstanceOf(ValidationException.class)
.hasMessage("Cannot cherry-pick unknown snapshot ID: -1");
@@ -169,27 +169,24 @@ public class TestCherrypickSnapshotProcedure extends SparkExtensionsTestBase {
@Test
public void testInvalidCherrypickSnapshotCases() {
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.cherrypick_snapshot('n', table => 't', 1L)", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Named and positional arguments cannot be mixed");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.custom.cherrypick_snapshot('n', 't', 1L)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.custom.cherrypick_snapshot('n', 't', 1L)", catalogName))
.isInstanceOf(NoSuchProcedureException.class)
.hasMessage("Procedure custom.cherrypick_snapshot not found");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.cherrypick_snapshot('t')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.cherrypick_snapshot('t')", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Missing required parameters: [snapshot_id]");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.cherrypick_snapshot('', 1L)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.cherrypick_snapshot('', 1L)", catalogName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Cannot handle an empty identifier for argument table");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.cherrypick_snapshot('t', 2.2)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.cherrypick_snapshot('t', 2.2)", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessageStartingWith("Wrong arg type for snapshot_id: cannot cast");
}
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestConflictValidation.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestConflictValidation.java
index aaa275db9c..b4366d93c7 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestConflictValidation.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestConflictValidation.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.util.List;
import java.util.Map;
import org.apache.iceberg.IsolationLevel;
@@ -29,7 +31,6 @@ import org.apache.iceberg.spark.source.SimpleRecord;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.functions;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -68,7 +69,7 @@ public class TestConflictValidation extends SparkExtensionsTestBase {
// Validating from previous snapshot finds conflicts
Dataset<Row> conflictingDf = spark.createDataFrame(records, SimpleRecord.class);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
conflictingDf
.writeTo(tableName)
@@ -106,7 +107,7 @@ public class TestConflictValidation extends SparkExtensionsTestBase {
// Validating from previous snapshot finds conflicts
List<SimpleRecord> conflictingRecords = Lists.newArrayList(new SimpleRecord(1, "a"));
Dataset<Row> conflictingDf = spark.createDataFrame(conflictingRecords, SimpleRecord.class);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
conflictingDf
.writeTo(tableName)
@@ -139,7 +140,7 @@ public class TestConflictValidation extends SparkExtensionsTestBase {
// Validating from previous snapshot finds conflicts
List<SimpleRecord> conflictingRecords = Lists.newArrayList(new SimpleRecord(1, "a"));
Dataset<Row> conflictingDf = spark.createDataFrame(conflictingRecords, SimpleRecord.class);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
conflictingDf
.writeTo(tableName)
@@ -171,7 +172,7 @@ public class TestConflictValidation extends SparkExtensionsTestBase {
// Validating from no snapshot id defaults to beginning snapshot id and finds conflicts
Dataset<Row> conflictingDf = spark.createDataFrame(records, SimpleRecord.class);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
conflictingDf
.writeTo(tableName)
@@ -208,7 +209,7 @@ public class TestConflictValidation extends SparkExtensionsTestBase {
// Validating from previous snapshot finds conflicts
List<SimpleRecord> conflictingRecords = Lists.newArrayList(new SimpleRecord(1, "a"));
Dataset<Row> conflictingDf = spark.createDataFrame(conflictingRecords, SimpleRecord.class);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
conflictingDf
.writeTo(tableName)
@@ -256,7 +257,7 @@ public class TestConflictValidation extends SparkExtensionsTestBase {
// Validating from previous snapshot finds conflicts
Dataset<Row> conflictingDf = spark.createDataFrame(records, SimpleRecord.class);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
conflictingDf
.writeTo(tableName)
@@ -292,7 +293,7 @@ public class TestConflictValidation extends SparkExtensionsTestBase {
// Validating from previous snapshot finds conflicts
Dataset<Row> conflictingDf = spark.createDataFrame(records, SimpleRecord.class);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
conflictingDf
.writeTo(tableName)
@@ -326,7 +327,7 @@ public class TestConflictValidation extends SparkExtensionsTestBase {
spark.createDataFrame(records, SimpleRecord.class).coalesce(1).writeTo(tableName).append();
Dataset<Row> conflictingDf = spark.createDataFrame(records, SimpleRecord.class);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
conflictingDf
.writeTo(tableName)
@@ -373,7 +374,7 @@ public class TestConflictValidation extends SparkExtensionsTestBase {
// Validating from null snapshot is equivalent to validating from beginning
Dataset<Row> conflictingDf = spark.createDataFrame(records, SimpleRecord.class);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
conflictingDf
.writeTo(tableName)
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCopyOnWriteDelete.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCopyOnWriteDelete.java
index 9ebe73da33..f42769ce3c 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCopyOnWriteDelete.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCopyOnWriteDelete.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.TableProperties.DELETE_ISOLATION_LEVEL;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.Collections;
import java.util.Map;
@@ -48,7 +49,6 @@ import org.apache.iceberg.util.SnapshotUtil;
import org.apache.spark.sql.Encoders;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
import org.apache.spark.sql.internal.SQLConf;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Assume;
import org.junit.Test;
@@ -156,7 +156,7 @@ public class TestCopyOnWriteDelete extends TestDelete {
});
try {
- Assertions.assertThatThrownBy(deleteFuture::get)
+ assertThatThrownBy(deleteFuture::get)
.isInstanceOf(ExecutionException.class)
.cause()
.isInstanceOf(IllegalStateException.class)
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCopyOnWriteMerge.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCopyOnWriteMerge.java
index 6b6819a924..62aa3fefea 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCopyOnWriteMerge.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCopyOnWriteMerge.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.TableProperties.MERGE_ISOLATION_LEVEL;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.Collections;
import java.util.Map;
@@ -46,7 +47,6 @@ import org.apache.iceberg.spark.SparkSQLProperties;
import org.apache.iceberg.util.SnapshotUtil;
import org.apache.spark.sql.Encoders;
import org.apache.spark.sql.internal.SQLConf;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Assume;
import org.junit.Test;
@@ -154,7 +154,7 @@ public class TestCopyOnWriteMerge extends TestMerge {
});
try {
- Assertions.assertThatThrownBy(mergeFuture::get)
+ assertThatThrownBy(mergeFuture::get)
.isInstanceOf(ExecutionException.class)
.cause()
.isInstanceOf(IllegalStateException.class)
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCopyOnWriteUpdate.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCopyOnWriteUpdate.java
index 4354a1019c..d90fde8a9a 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCopyOnWriteUpdate.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestCopyOnWriteUpdate.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.TableProperties.UPDATE_ISOLATION_LEVEL;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.Map;
import java.util.concurrent.ExecutionException;
@@ -45,7 +46,6 @@ import org.apache.iceberg.spark.Spark3Util;
import org.apache.iceberg.spark.SparkSQLProperties;
import org.apache.iceberg.util.SnapshotUtil;
import org.apache.spark.sql.internal.SQLConf;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Assume;
import org.junit.Test;
@@ -152,7 +152,7 @@ public class TestCopyOnWriteUpdate extends TestUpdate {
});
try {
- Assertions.assertThatThrownBy(updateFuture::get)
+ assertThatThrownBy(updateFuture::get)
.isInstanceOf(ExecutionException.class)
.cause()
.isInstanceOf(IllegalStateException.class)
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestDelete.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestDelete.java
index e6114d4abc..bd70243fa0 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestDelete.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestDelete.java
@@ -30,6 +30,7 @@ import static org.apache.iceberg.TableProperties.SPLIT_OPEN_FILE_COST;
import static org.apache.iceberg.TableProperties.SPLIT_SIZE;
import static org.apache.spark.sql.functions.lit;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assumptions.assumeThat;
import java.util.Arrays;
@@ -79,7 +80,6 @@ import org.apache.spark.sql.catalyst.plans.logical.RowLevelWrite;
import org.apache.spark.sql.execution.SparkPlan;
import org.apache.spark.sql.execution.datasources.v2.OptimizeMetadataOnlyDeleteFromTable;
import org.apache.spark.sql.internal.SQLConf;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Assume;
@@ -189,7 +189,7 @@ public abstract class TestDelete extends SparkRowLevelOperationsTestBase {
() -> {
SparkPlan plan =
executeAndKeepPlan("DELETE FROM %s WHERE mod(id, 2) = 0", commitTarget());
- Assertions.assertThat(plan.toString()).contains("REBALANCE_PARTITIONS_BY_COL");
+ assertThat(plan.toString()).contains("REBALANCE_PARTITIONS_BY_COL");
});
Table table = validationCatalog.loadTable(tableIdent);
@@ -250,7 +250,7 @@ public abstract class TestDelete extends SparkRowLevelOperationsTestBase {
() -> {
SparkPlan plan =
executeAndKeepPlan("DELETE FROM %s WHERE mod(id, 2) = 0", commitTarget());
- Assertions.assertThat(plan.toString()).contains("REBALANCE_PARTITIONS_BY_COL");
+ assertThat(plan.toString()).contains("REBALANCE_PARTITIONS_BY_COL");
});
Table table = validationCatalog.loadTable(tableIdent);
@@ -297,10 +297,10 @@ public abstract class TestDelete extends SparkRowLevelOperationsTestBase {
LogicalPlan parsed = parsePlan("DELETE FROM %s WHERE dep = 'hr'", commitTarget());
LogicalPlan analyzed = spark.sessionState().analyzer().execute(parsed);
- Assertions.assertThat(analyzed).isInstanceOf(RowLevelWrite.class);
+ assertThat(analyzed).isInstanceOf(RowLevelWrite.class);
LogicalPlan optimized = OptimizeMetadataOnlyDeleteFromTable.apply(analyzed);
- Assertions.assertThat(optimized).isInstanceOf(DeleteFromTableWithFilters.class);
+ assertThat(optimized).isInstanceOf(DeleteFromTableWithFilters.class);
});
sql("DELETE FROM %s WHERE dep = 'hr'", commitTarget());
@@ -409,7 +409,7 @@ public abstract class TestDelete extends SparkRowLevelOperationsTestBase {
Assume.assumeTrue("Test only applicable to custom branch", "test".equals(branch));
createAndInitUnpartitionedTable();
- Assertions.assertThatThrownBy(() -> sql("DELETE FROM %s WHERE id IN (1)", commitTarget()))
+ assertThatThrownBy(() -> sql("DELETE FROM %s WHERE id IN (1)", commitTarget()))
.isInstanceOf(ValidationException.class)
.hasMessage("Cannot use branch (does not exist): test");
}
@@ -616,8 +616,7 @@ public abstract class TestDelete extends SparkRowLevelOperationsTestBase {
sql("INSERT INTO TABLE %s VALUES (1, 'hr'), (2, 'hardware')", tableName);
createBranchIfNeeded();
- Assertions.assertThatThrownBy(
- () -> sql("DELETE FROM %s WHERE id = 1 AND rand() > 0.5", commitTarget()))
+ assertThatThrownBy(() -> sql("DELETE FROM %s WHERE id = 1 AND rand() > 0.5", commitTarget()))
.isInstanceOf(AnalysisException.class)
.hasMessageStartingWith("nondeterministic expressions are only allowed");
}
@@ -906,7 +905,7 @@ public abstract class TestDelete extends SparkRowLevelOperationsTestBase {
sql("CREATE TABLE parquet_table (c1 INT, c2 INT) USING parquet");
- Assertions.assertThatThrownBy(() -> sql("DELETE FROM parquet_table WHERE c1 = -100"))
+ assertThatThrownBy(() -> sql("DELETE FROM parquet_table WHERE c1 = -100"))
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("does not support DELETE");
}
@@ -1114,7 +1113,7 @@ public abstract class TestDelete extends SparkRowLevelOperationsTestBase {
});
try {
- Assertions.assertThatThrownBy(deleteFuture::get)
+ assertThatThrownBy(deleteFuture::get)
.isInstanceOf(ExecutionException.class)
.cause()
.isInstanceOf(ValidationException.class)
@@ -1357,7 +1356,7 @@ public abstract class TestDelete extends SparkRowLevelOperationsTestBase {
withSQLConf(
ImmutableMap.of(SparkSQLProperties.WAP_BRANCH, "wap"),
() ->
- Assertions.assertThatThrownBy(() -> sql("DELETE FROM %s t WHERE id=0", commitTarget()))
+ assertThatThrownBy(() -> sql("DELETE FROM %s t WHERE id=0", commitTarget()))
.isInstanceOf(ValidationException.class)
.hasMessage(
String.format(
@@ -1383,9 +1382,9 @@ public abstract class TestDelete extends SparkRowLevelOperationsTestBase {
ImmutableMap.of(SparkSQLProperties.WAP_BRANCH, branch),
() -> {
sql("DELETE FROM %s t WHERE id=1", tableName);
- Assertions.assertThat(spark.table(tableName).count()).isEqualTo(2L);
- Assertions.assertThat(spark.table(tableName + ".branch_" + branch).count()).isEqualTo(2L);
- Assertions.assertThat(spark.table(tableName + ".branch_main").count())
+ assertThat(spark.table(tableName).count()).isEqualTo(2L);
+ assertThat(spark.table(tableName + ".branch_" + branch).count()).isEqualTo(2L);
+ assertThat(spark.table(tableName + ".branch_main").count())
.as("Should not modify main branch")
.isEqualTo(3L);
});
@@ -1393,9 +1392,9 @@ public abstract class TestDelete extends SparkRowLevelOperationsTestBase {
ImmutableMap.of(SparkSQLProperties.WAP_BRANCH, branch),
() -> {
sql("DELETE FROM %s t", tableName);
- Assertions.assertThat(spark.table(tableName).count()).isEqualTo(0L);
- Assertions.assertThat(spark.table(tableName + ".branch_" + branch).count()).isEqualTo(0L);
- Assertions.assertThat(spark.table(tableName + ".branch_main").count())
+ assertThat(spark.table(tableName).count()).isEqualTo(0L);
+ assertThat(spark.table(tableName + ".branch_" + branch).count()).isEqualTo(0L);
+ assertThat(spark.table(tableName + ".branch_main").count())
.as("Should not modify main branch")
.isEqualTo(3L);
});
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestExpireSnapshotsProcedure.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestExpireSnapshotsProcedure.java
index 7dacce5487..913d70f1ca 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestExpireSnapshotsProcedure.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestExpireSnapshotsProcedure.java
@@ -19,6 +19,8 @@
package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.TableProperties.GC_ENABLED;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.File;
import java.io.IOException;
@@ -51,7 +53,6 @@ import org.apache.iceberg.spark.source.SimpleRecord;
import org.apache.spark.sql.AnalysisException;
import org.apache.spark.sql.Encoders;
import org.apache.spark.sql.catalyst.analysis.NoSuchProcedureException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
@@ -162,34 +163,30 @@ public class TestExpireSnapshotsProcedure extends SparkExtensionsTestBase {
sql("ALTER TABLE %s SET TBLPROPERTIES ('%s' 'false')", tableName, GC_ENABLED);
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.expire_snapshots('%s')", catalogName, tableIdent))
+ assertThatThrownBy(() -> sql("CALL %s.system.expire_snapshots('%s')", catalogName, tableIdent))
.isInstanceOf(ValidationException.class)
.hasMessageStartingWith("Cannot expire snapshots: GC is disabled");
}
@Test
public void testInvalidExpireSnapshotsCases() {
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.expire_snapshots('n', table => 't')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.expire_snapshots('n', table => 't')", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Named and positional arguments cannot be mixed");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.custom.expire_snapshots('n', 't')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.custom.expire_snapshots('n', 't')", catalogName))
.isInstanceOf(NoSuchProcedureException.class)
.hasMessage("Procedure custom.expire_snapshots not found");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.expire_snapshots()", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.expire_snapshots()", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Missing required parameters: [table]");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.expire_snapshots('n', 2.2)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.expire_snapshots('n', 2.2)", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Wrong arg type for older_than: cannot cast DecimalType(2,1) to TimestampType");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.expire_snapshots('')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.expire_snapshots('')", catalogName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Cannot handle an empty identifier for argument table");
}
@@ -209,7 +206,7 @@ public class TestExpireSnapshotsProcedure extends SparkExtensionsTestBase {
"CREATE TABLE %s.%s (id bigint NOT NULL, data string) USING iceberg",
anotherCatalog, tableIdent);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.expire_snapshots('%s')",
@@ -245,7 +242,7 @@ public class TestExpireSnapshotsProcedure extends SparkExtensionsTestBase {
public void testConcurrentExpireSnapshotsWithInvalidInput() {
sql("CREATE TABLE %s (id bigint NOT NULL, data string) USING iceberg", tableName);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.expire_snapshots(table => '%s', max_concurrent_deletes => %s)",
@@ -253,7 +250,7 @@ public class TestExpireSnapshotsProcedure extends SparkExtensionsTestBase {
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("max_concurrent_deletes should have value > 0, value: 0");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.expire_snapshots(table => '%s', max_concurrent_deletes => %s)",
@@ -392,7 +389,7 @@ public class TestExpireSnapshotsProcedure extends SparkExtensionsTestBase {
Table table = validationCatalog.loadTable(tableIdent);
Assert.assertEquals("Should be 2 snapshots", 2, Iterables.size(table.snapshots()));
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.expire_snapshots("
@@ -471,21 +468,21 @@ public class TestExpireSnapshotsProcedure extends SparkExtensionsTestBase {
sql(
"CALL %s.system.expire_snapshots(older_than => TIMESTAMP '%s',table => '%s')",
catalogName, currentTimestamp, tableIdent);
- Assertions.assertThat(output.get(0)[5]).as("should be 1 deleted statistics file").isEqualTo(1L);
+ assertThat(output.get(0)[5]).as("should be 1 deleted statistics file").isEqualTo(1L);
table.refresh();
- Assertions.assertThat(table.statisticsFiles())
+ assertThat(table.statisticsFiles())
.as(
"Statistics file entry in TableMetadata should be present only for the snapshot %s",
statisticsFile2.snapshotId())
.extracting(StatisticsFile::snapshotId)
.containsExactly(statisticsFile2.snapshotId());
- Assertions.assertThat(new File(statsFileLocation1))
+ assertThat(new File(statsFileLocation1))
.as("Statistics file should not exist for snapshot %s", statisticsFile1.snapshotId())
.doesNotExist();
- Assertions.assertThat(new File(statsFileLocation2))
+ assertThat(new File(statsFileLocation2))
.as("Statistics file should exist for snapshot %s", statisticsFile2.snapshotId())
.exists();
}
@@ -516,25 +513,23 @@ public class TestExpireSnapshotsProcedure extends SparkExtensionsTestBase {
sql(
"CALL %s.system.expire_snapshots(older_than => TIMESTAMP '%s',table => '%s')",
catalogName, currentTimestamp, tableIdent);
- Assertions.assertThat(output.get(0)[5])
- .as("should be 1 deleted partition statistics file")
- .isEqualTo(1L);
+ assertThat(output.get(0)[5]).as("should be 1 deleted partition statistics file").isEqualTo(1L);
table.refresh();
- Assertions.assertThat(table.partitionStatisticsFiles())
+ assertThat(table.partitionStatisticsFiles())
.as(
"partition statistics file entry in TableMetadata should be present only for the snapshot %s",
partitionStatisticsFile2.snapshotId())
.extracting(PartitionStatisticsFile::snapshotId)
.containsExactly(partitionStatisticsFile2.snapshotId());
- Assertions.assertThat(new File(partitionStatsFileLocation1))
+ assertThat(new File(partitionStatsFileLocation1))
.as(
"partition statistics file should not exist for snapshot %s",
partitionStatisticsFile1.snapshotId())
.doesNotExist();
- Assertions.assertThat(new File(partitionStatsFileLocation2))
+ assertThat(new File(partitionStatsFileLocation2))
.as(
"partition statistics file should exist for snapshot %s",
partitionStatisticsFile2.snapshotId())
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMerge.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMerge.java
index bded60b956..e3e6e9700d 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMerge.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMerge.java
@@ -28,6 +28,8 @@ import static org.apache.iceberg.TableProperties.SPLIT_OPEN_FILE_COST;
import static org.apache.iceberg.TableProperties.SPLIT_SIZE;
import static org.apache.iceberg.TableProperties.WRITE_DISTRIBUTION_MODE;
import static org.apache.spark.sql.functions.lit;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assumptions.assumeThat;
import java.util.Arrays;
@@ -67,7 +69,6 @@ import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
import org.apache.spark.sql.execution.SparkPlan;
import org.apache.spark.sql.internal.SQLConf;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Assume;
@@ -266,7 +267,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
+ "WHEN MATCHED THEN "
+ " UPDATE SET salary = -1 ",
commitTarget());
- Assertions.assertThat(plan.toString()).contains("REBALANCE_PARTITIONS_BY_COL");
+ assertThat(plan.toString()).contains("REBALANCE_PARTITIONS_BY_COL");
});
Table table = validationCatalog.loadTable(tableIdent);
@@ -786,7 +787,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
String errorMsg =
"MERGE statement matched a single row from the target table with multiple rows of the source table.";
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s AS t USING source AS s "
@@ -821,7 +822,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
String errorMsg =
"MERGE statement matched a single row from the target table with multiple rows of the source table.";
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s AS t USING source AS s "
@@ -862,7 +863,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
() -> {
String errorMsg =
"MERGE statement matched a single row from the target table with multiple rows of the source table.";
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s AS t USING source AS s "
@@ -901,7 +902,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
() -> {
String errorMsg =
"MERGE statement matched a single row from the target table with multiple rows of the source table.";
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s AS t USING source AS s "
@@ -939,7 +940,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
String errorMsg =
"MERGE statement matched a single row from the target table with multiple rows of the source table.";
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s AS t USING source AS s "
@@ -973,7 +974,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
String errorMsg =
"MERGE statement matched a single row from the target table with multiple rows of the source table.";
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s AS t USING source AS s "
@@ -1009,7 +1010,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
String errorMsg =
"MERGE statement matched a single row from the target table with multiple rows of the source table.";
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s AS t USING source AS s "
@@ -1080,7 +1081,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
String errorMsg =
"MERGE statement matched a single row from the target table with multiple rows of the source table.";
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s AS t USING source AS s "
@@ -1486,7 +1487,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
});
try {
- Assertions.assertThatThrownBy(mergeFuture::get)
+ assertThatThrownBy(mergeFuture::get)
.isInstanceOf(ExecutionException.class)
.cause()
.isInstanceOf(ValidationException.class)
@@ -2223,7 +2224,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
"{ \"id\": 1, \"c\": { \"n1\": 2, \"n2\": { \"dn1\": 3, \"dn2\": 4 } } }");
createOrReplaceView("source", "{ \"c1\": -100, \"c2\": -200 }");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2234,7 +2235,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("cannot resolve t.invalid_col in MERGE command");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2245,7 +2246,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("No such struct field `invalid_col`");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2266,7 +2267,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
"{ \"id\": 1, \"c\": { \"n1\": 2, \"n2\": { \"dn1\": 3, \"dn2\": 4 } } }");
createOrReplaceView("source", "{ \"c1\": -100, \"c2\": -200 }");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2279,7 +2280,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Nested fields are not supported inside INSERT clauses");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2292,7 +2293,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Duplicate column names inside INSERT clause");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2311,7 +2312,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
"{ \"id\": 1, \"a\": [ { \"c1\": 2, \"c2\": 3 } ], \"m\": { \"k\": \"v\"} }");
createOrReplaceView("source", "{ \"c1\": -100, \"c2\": -200 }");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2322,7 +2323,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Updating nested fields is only supported for structs");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2341,7 +2342,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
"{ \"id\": 1, \"c\": { \"n1\": 2, \"n2\": { \"dn1\": 3, \"dn2\": 4 } } }");
createOrReplaceView("source", "{ \"c1\": -100, \"c2\": -200 }");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2352,7 +2353,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Updates are in conflict");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2363,7 +2364,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Updates are in conflict for these columns");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2389,7 +2390,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
withSQLConf(
ImmutableMap.of("spark.sql.storeAssignmentPolicy", policy),
() -> {
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2400,7 +2401,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Cannot write nullable values to non-null column");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2411,7 +2412,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Cannot write nullable values to non-null column");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2422,7 +2423,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("missing fields");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2433,7 +2434,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessageEndingWith("Cannot safely cast 'n1': string to int");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2454,7 +2455,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
"{ \"id\": 1, \"c\": { \"n1\": 2, \"n2\": { \"dn1\": 3, \"dn2\": 4 } } }");
createOrReplaceView("source", "{ \"c1\": -100, \"c2\": -200 }");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2466,7 +2467,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.hasMessageContaining(
"Non-deterministic functions are not supported in SEARCH conditions of MERGE operations");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2478,7 +2479,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.hasMessageContaining(
"Non-deterministic functions are not supported in UPDATE conditions of MERGE operations");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2490,7 +2491,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.hasMessageContaining(
"Non-deterministic functions are not supported in DELETE conditions of MERGE operations");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2510,7 +2511,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
"{ \"id\": 1, \"c\": { \"n1\": 2, \"n2\": { \"dn1\": 3, \"dn2\": 4 } } }");
createOrReplaceView("source", "{ \"c1\": -100, \"c2\": -200 }");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2522,7 +2523,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.hasMessageContaining(
"Agg functions are not supported in SEARCH conditions of MERGE operations");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2534,7 +2535,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.hasMessageContaining(
"Agg functions are not supported in UPDATE conditions of MERGE operations");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2546,7 +2547,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.hasMessageContaining(
"Agg functions are not supported in DELETE conditions of MERGE operations");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2566,7 +2567,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
"{ \"id\": 1, \"c\": { \"n1\": 2, \"n2\": { \"dn1\": 3, \"dn2\": 4 } } }");
createOrReplaceView("source", "{ \"c1\": -100, \"c2\": -200 }");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2578,7 +2579,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.hasMessageContaining(
"Subqueries are not supported in conditions of MERGE operations. Found a subquery in the SEARCH condition");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2590,7 +2591,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.hasMessageContaining(
"Subqueries are not supported in conditions of MERGE operations. Found a subquery in the UPDATE condition");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2602,7 +2603,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
.hasMessageContaining(
"Subqueries are not supported in conditions of MERGE operations. Found a subquery in the DELETE condition");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2620,7 +2621,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
createAndInitTable("id INT, c2 INT", "{ \"id\": 1, \"c2\": 2 }");
createOrReplaceView("source", "{ \"id\": 1, \"value\": 11 }");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s "
@@ -2637,7 +2638,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
createOrReplaceView("target", "{ \"c1\": -100, \"c2\": -200 }");
createOrReplaceView("source", "{ \"c1\": -100, \"c2\": -200 }");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO target t USING source s "
@@ -2701,7 +2702,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
// Coalesce forces our source into a SinglePartition distribution
spark.range(0, 5).coalesce(1).createOrReplaceTempView("source");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s ON t.id = s.id "
@@ -2788,7 +2789,7 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
withSQLConf(
ImmutableMap.of(SparkSQLProperties.WAP_BRANCH, "wap"),
() ->
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"MERGE INTO %s t USING source s ON t.id = s.id "
@@ -2810,9 +2811,9 @@ public abstract class TestMerge extends SparkRowLevelOperationsTestBase {
SparkPlan sparkPlan = executeAndKeepPlan(() -> sql(query));
String planAsString = sparkPlan.toString().replaceAll("#(\\d+L?)", "");
- Assertions.assertThat(planAsString).as("Join should match").contains(join + "\n");
+ assertThat(planAsString).as("Join should match").contains(join + "\n");
- Assertions.assertThat(planAsString)
+ assertThat(planAsString)
.as("Pushed filters must match")
.contains("[filters=" + icebergFilters + ",");
});
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMergeOnReadDelete.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMergeOnReadDelete.java
index 91600d4df0..5bec21392e 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMergeOnReadDelete.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMergeOnReadDelete.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.extensions;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
@@ -43,7 +44,6 @@ import org.apache.iceberg.spark.source.TestSparkCatalog;
import org.apache.iceberg.util.SnapshotUtil;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
import org.apache.spark.sql.connector.catalog.Identifier;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runners.Parameterized;
@@ -196,8 +196,7 @@ public class TestMergeOnReadDelete extends TestDelete {
TestSparkCatalog.setTable(ident, sparkTable);
// Although an exception is thrown here, write and commit have succeeded
- Assertions.assertThatThrownBy(
- () -> sql("DELETE FROM %s WHERE id = 2", "dummy_catalog.default.table"))
+ assertThatThrownBy(() -> sql("DELETE FROM %s WHERE id = 2", "dummy_catalog.default.table"))
.isInstanceOf(CommitStateUnknownException.class)
.hasMessageStartingWith("Datacenter on Fire");
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMetaColumnProjectionWithStageScan.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMetaColumnProjectionWithStageScan.java
index e9013848cf..17ed003f6a 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMetaColumnProjectionWithStageScan.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMetaColumnProjectionWithStageScan.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThat;
+
import java.util.List;
import java.util.Map;
import java.util.UUID;
@@ -34,7 +36,6 @@ import org.apache.iceberg.spark.source.SimpleRecord;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Encoders;
import org.apache.spark.sql.Row;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Test;
import org.junit.runners.Parameterized;
@@ -103,7 +104,7 @@ public class TestMetaColumnProjectionWithStageScan extends SparkExtensionsTestBa
.option(SparkReadOptions.SCAN_TASK_SET_ID, fileSetID)
.load(tableLocation);
- Assertions.assertThat(scanDF2.columns().length).isEqualTo(2);
+ assertThat(scanDF2.columns().length).isEqualTo(2);
}
try (CloseableIterable<ScanTask> tasks = table.newBatchScan().planFiles()) {
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMigrateTableProcedure.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMigrateTableProcedure.java
index 0d23e4bbf0..7365f7a6df 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMigrateTableProcedure.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestMigrateTableProcedure.java
@@ -18,13 +18,15 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.io.IOException;
import java.util.Map;
import org.apache.iceberg.Table;
import org.apache.iceberg.exceptions.ValidationException;
import org.apache.iceberg.relocated.com.google.common.collect.ImmutableList;
import org.apache.spark.sql.AnalysisException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Assume;
@@ -137,9 +139,9 @@ public class TestMigrateTableProcedure extends SparkExtensionsTestBase {
"CALL %s.system.migrate(table => '%s', backup_table_name => '%s')",
catalogName, tableName, backupTableName);
- Assertions.assertThat(result).isEqualTo(1L);
+ assertThat(result).isEqualTo(1L);
String dbName = tableName.split("\\.")[0];
- Assertions.assertThat(spark.catalog().tableExists(dbName + "." + backupTableName)).isTrue();
+ assertThat(spark.catalog().tableExists(dbName + "." + backupTableName)).isTrue();
}
@Test
@@ -151,7 +153,7 @@ public class TestMigrateTableProcedure extends SparkExtensionsTestBase {
"CREATE TABLE %s (id bigint NOT NULL, data string) USING parquet LOCATION '%s'",
tableName, location);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
String props = "map('write.metadata.metrics.column.x', 'X')";
sql("CALL %s.system.migrate('%s', %s)", catalogName, tableName, props);
@@ -185,16 +187,15 @@ public class TestMigrateTableProcedure extends SparkExtensionsTestBase {
@Test
public void testInvalidMigrateCases() {
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.migrate()", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.migrate()", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Missing required parameters: [table]");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.migrate(map('foo','bar'))", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.migrate(map('foo','bar'))", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessageStartingWith("Wrong arg type for table");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.migrate('')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.migrate('')", catalogName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Cannot handle an empty identifier for argument table");
}
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestPublishChangesProcedure.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestPublishChangesProcedure.java
index 94c4af3ad5..fe0f12a9d0 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestPublishChangesProcedure.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestPublishChangesProcedure.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.TableProperties.WRITE_AUDIT_PUBLISH_ENABLED;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.List;
import java.util.Map;
@@ -31,7 +32,6 @@ import org.apache.spark.sql.AnalysisException;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchProcedureException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Test;
@@ -157,7 +157,7 @@ public class TestPublishChangesProcedure extends SparkExtensionsTestBase {
public void testApplyInvalidWapId() {
sql("CREATE TABLE %s (id bigint NOT NULL, data string) USING iceberg", tableName);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.publish_changes('%s', 'not_valid')", catalogName, tableIdent))
.isInstanceOf(ValidationException.class)
.hasMessage("Cannot apply unknown WAP ID 'not_valid'");
@@ -165,23 +165,22 @@ public class TestPublishChangesProcedure extends SparkExtensionsTestBase {
@Test
public void testInvalidApplyWapChangesCases() {
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql("CALL %s.system.publish_changes('n', table => 't', 'not_valid')", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Named and positional arguments cannot be mixed");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.custom.publish_changes('n', 't', 'not_valid')", catalogName))
.isInstanceOf(NoSuchProcedureException.class)
.hasMessage("Procedure custom.publish_changes not found");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.publish_changes('t')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.publish_changes('t')", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Missing required parameters: [wap_id]");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.publish_changes('', 'not_valid')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.publish_changes('', 'not_valid')", catalogName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Cannot handle an empty identifier for argument table");
}
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRemoveOrphanFilesProcedure.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRemoveOrphanFilesProcedure.java
index 56854c561f..46d37ce205 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRemoveOrphanFilesProcedure.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRemoveOrphanFilesProcedure.java
@@ -20,6 +20,8 @@ package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.TableProperties.GC_ENABLED;
import static org.apache.iceberg.TableProperties.WRITE_AUDIT_PUBLISH_ENABLED;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.File;
import java.io.IOException;
@@ -64,7 +66,6 @@ import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchProcedureException;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
import org.apache.spark.sql.catalyst.parser.ParseException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Rule;
@@ -226,7 +227,7 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
sql("ALTER TABLE %s SET TBLPROPERTIES ('%s' 'false')", tableName, GC_ENABLED);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.remove_orphan_files('%s')", catalogName, tableIdent))
.isInstanceOf(ValidationException.class)
.hasMessage(
@@ -257,26 +258,24 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
@Test
public void testInvalidRemoveOrphanFilesCases() {
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.remove_orphan_files('n', table => 't')", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Named and positional arguments cannot be mixed");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.custom.remove_orphan_files('n', 't')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.custom.remove_orphan_files('n', 't')", catalogName))
.isInstanceOf(NoSuchProcedureException.class)
.hasMessage("Procedure custom.remove_orphan_files not found");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.remove_orphan_files()", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.remove_orphan_files()", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Missing required parameters: [table]");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.remove_orphan_files('n', 2.2)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.remove_orphan_files('n', 2.2)", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessageStartingWith("Wrong arg type for older_than");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.remove_orphan_files('')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.remove_orphan_files('')", catalogName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Cannot handle an empty identifier for argument table");
}
@@ -343,7 +342,7 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
public void testConcurrentRemoveOrphanFilesWithInvalidInput() {
sql("CREATE TABLE %s (id bigint NOT NULL, data string) USING iceberg", tableName);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.remove_orphan_files(table => '%s', max_concurrent_deletes => %s)",
@@ -351,7 +350,7 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("max_concurrent_deletes should have value > 0, value: 0");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.remove_orphan_files(table => '%s', max_concurrent_deletes => %s)",
@@ -362,7 +361,7 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
String tempViewName = "file_list_test";
spark.emptyDataFrame().createOrReplaceTempView(tempViewName);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.remove_orphan_files(table => '%s', file_list_view => '%s')",
@@ -375,7 +374,7 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
.toDF("file_path", "last_modified")
.createOrReplaceTempView(tempViewName);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.remove_orphan_files(table => '%s', file_list_view => '%s')",
@@ -388,7 +387,7 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
.toDF("file_path", "last_modified")
.createOrReplaceTempView(tempViewName);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.remove_orphan_files(table => '%s', file_list_view => '%s')",
@@ -505,10 +504,10 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
+ "table => '%s',"
+ "older_than => TIMESTAMP '%s')",
catalogName, tableIdent, currentTimestamp);
- Assertions.assertThat(output).as("Should be no orphan files").isEmpty();
+ assertThat(output).as("Should be no orphan files").isEmpty();
- Assertions.assertThat(statsLocation.exists()).as("stats file should exist").isTrue();
- Assertions.assertThat(statsLocation.length())
+ assertThat(statsLocation.exists()).as("stats file should exist").isTrue();
+ assertThat(statsLocation.length())
.as("stats file length")
.isEqualTo(statisticsFile.fileSizeInBytes());
@@ -522,11 +521,11 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
+ "table => '%s',"
+ "older_than => TIMESTAMP '%s')",
catalogName, tableIdent, currentTimestamp);
- Assertions.assertThat(output).as("Should be orphan files").hasSize(1);
- Assertions.assertThat(Iterables.getOnlyElement(output))
+ assertThat(output).as("Should be orphan files").hasSize(1);
+ assertThat(Iterables.getOnlyElement(output))
.as("Deleted files")
.containsExactly(statsLocation.toURI().toString());
- Assertions.assertThat(statsLocation.exists()).as("stats file should be deleted").isFalse();
+ assertThat(statsLocation.exists()).as("stats file should be deleted").isFalse();
}
@Test
@@ -555,11 +554,9 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
+ "table => '%s',"
+ "older_than => TIMESTAMP '%s')",
catalogName, tableIdent, currentTimestamp);
- Assertions.assertThat(output).as("Should be no orphan files").isEmpty();
+ assertThat(output).as("Should be no orphan files").isEmpty();
- Assertions.assertThat(new File(partitionStatsLocation))
- .as("partition stats file should exist")
- .exists();
+ assertThat(new File(partitionStatsLocation)).as("partition stats file should exist").exists();
removePartitionStatsTxn(table, partitionStatisticsFile);
@@ -569,11 +566,11 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
+ "table => '%s',"
+ "older_than => TIMESTAMP '%s')",
catalogName, tableIdent, currentTimestamp);
- Assertions.assertThat(output).as("Should be orphan files").hasSize(1);
- Assertions.assertThat(Iterables.getOnlyElement(output))
+ assertThat(output).as("Should be orphan files").hasSize(1);
+ assertThat(Iterables.getOnlyElement(output))
.as("Deleted files")
.containsExactly("file:" + partitionStatsLocation);
- Assertions.assertThat(new File(partitionStatsLocation))
+ assertThat(new File(partitionStatsLocation))
.as("partition stats file should be deleted")
.doesNotExist();
}
@@ -666,7 +663,7 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
Assert.assertEquals(0, orphanFiles.size());
// Test with no equal schemes
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.remove_orphan_files("
@@ -749,7 +746,7 @@ public class TestRemoveOrphanFilesProcedure extends SparkExtensionsTestBase {
Assert.assertEquals(0, orphanFiles.size());
// Test with no equal authorities
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.remove_orphan_files("
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestReplaceBranch.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestReplaceBranch.java
index eb167ed25b..443f299a49 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestReplaceBranch.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestReplaceBranch.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
@@ -29,7 +31,6 @@ import org.apache.iceberg.spark.source.SimpleRecord;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
@@ -74,7 +75,7 @@ public class TestReplaceBranch extends SparkExtensionsTestBase {
df.writeTo(tableName).append();
long second = table.currentSnapshot().snapshotId();
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"ALTER TABLE %s REPLACE BRANCH %s AS OF VERSION %d",
@@ -128,7 +129,7 @@ public class TestReplaceBranch extends SparkExtensionsTestBase {
df.writeTo(tableName).append();
Table table = validationCatalog.loadTable(tableIdent);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"ALTER TABLE %s REPLACE BRANCH %s AS OF VERSION %d",
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRequiredDistributionAndOrdering.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRequiredDistributionAndOrdering.java
index 4c678ce9b7..6e5671bb18 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRequiredDistributionAndOrdering.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRequiredDistributionAndOrdering.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.math.BigDecimal;
import java.util.List;
import java.util.Map;
@@ -27,7 +29,6 @@ import org.apache.iceberg.spark.source.ThreeColumnRecord;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Test;
@@ -186,7 +187,7 @@ public class TestRequiredDistributionAndOrdering extends SparkExtensionsTestBase
Dataset<Row> inputDF = ds.coalesce(1).sortWithinPartitions("c1");
// should fail if ordering is disabled
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
inputDF
.writeTo(tableName)
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRewriteDataFilesProcedure.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRewriteDataFilesProcedure.java
index 009ab41228..24230d80b0 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRewriteDataFilesProcedure.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRewriteDataFilesProcedure.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.extensions;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.Arrays;
import java.util.List;
@@ -42,7 +43,6 @@ import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchProcedureException;
import org.apache.spark.sql.internal.SQLConf;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Assume;
@@ -598,7 +598,7 @@ public class TestRewriteDataFilesProcedure extends SparkExtensionsTestBase {
insertData(2);
// Test for invalid strategy
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_data_files(table => '%s', options => map('min-input-files','2'), "
@@ -608,7 +608,7 @@ public class TestRewriteDataFilesProcedure extends SparkExtensionsTestBase {
.hasMessage("unsupported strategy: temp. Only binpack or sort is supported");
// Test for sort_order with binpack strategy
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_data_files(table => '%s', strategy => 'binpack', "
@@ -618,7 +618,7 @@ public class TestRewriteDataFilesProcedure extends SparkExtensionsTestBase {
.hasMessage("Must use only one rewriter type (bin-pack, sort, zorder)");
// Test for sort strategy without any (default/user defined) sort_order
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_data_files(table => '%s', strategy => 'sort')",
@@ -627,7 +627,7 @@ public class TestRewriteDataFilesProcedure extends SparkExtensionsTestBase {
.hasMessageStartingWith("Cannot sort data without a valid sort order");
// Test for sort_order with invalid null order
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_data_files(table => '%s', strategy => 'sort', "
@@ -637,7 +637,7 @@ public class TestRewriteDataFilesProcedure extends SparkExtensionsTestBase {
.hasMessage("Unable to parse sortOrder: c1 ASC none");
// Test for sort_order with invalid sort direction
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_data_files(table => '%s', strategy => 'sort', "
@@ -647,7 +647,7 @@ public class TestRewriteDataFilesProcedure extends SparkExtensionsTestBase {
.hasMessage("Unable to parse sortOrder: c1 none NULLS FIRST");
// Test for sort_order with invalid column name
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_data_files(table => '%s', strategy => 'sort', "
@@ -657,7 +657,7 @@ public class TestRewriteDataFilesProcedure extends SparkExtensionsTestBase {
.hasMessageStartingWith("Cannot find field 'col1' in struct:");
// Test with invalid filter column col1
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_data_files(table => '%s', " + "where => 'col1 = 3')",
@@ -666,7 +666,7 @@ public class TestRewriteDataFilesProcedure extends SparkExtensionsTestBase {
.hasMessage("Cannot parse predicates in where option: col1 = 3");
// Test for z_order with invalid column name
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_data_files(table => '%s', strategy => 'sort', "
@@ -678,7 +678,7 @@ public class TestRewriteDataFilesProcedure extends SparkExtensionsTestBase {
+ "struct<1: c1: optional int, 2: c2: optional string, 3: c3: optional string>");
// Test for z_order with sort_order
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_data_files(table => '%s', strategy => 'sort', "
@@ -691,26 +691,25 @@ public class TestRewriteDataFilesProcedure extends SparkExtensionsTestBase {
@Test
public void testInvalidCasesForRewriteDataFiles() {
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.rewrite_data_files('n', table => 't')", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Named and positional arguments cannot be mixed");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.custom.rewrite_data_files('n', 't')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.custom.rewrite_data_files('n', 't')", catalogName))
.isInstanceOf(NoSuchProcedureException.class)
.hasMessage("Procedure custom.rewrite_data_files not found");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.rewrite_data_files()", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rewrite_data_files()", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Missing required parameters: [table]");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.rewrite_data_files(table => 't', table => 't')", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessageEndingWith("Duplicate procedure argument: table");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.rewrite_data_files('')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rewrite_data_files('')", catalogName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Cannot handle an empty identifier for parameter 'table'");
}
@@ -866,7 +865,7 @@ public class TestRewriteDataFilesProcedure extends SparkExtensionsTestBase {
@Test
public void testRewriteWithUntranslatedOrUnconvertedFilter() {
createTable();
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_data_files(table => '%s', where => 'substr(encode(c2, \"utf-8\"), 2) = \"fo\"')",
@@ -874,7 +873,7 @@ public class TestRewriteDataFilesProcedure extends SparkExtensionsTestBase {
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Cannot translate Spark expression");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_data_files(table => '%s', where => 'substr(c2, 2) = \"fo\"')",
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRewriteManifestsProcedure.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRewriteManifestsProcedure.java
index 8e64eaad44..3b8650de34 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRewriteManifestsProcedure.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRewriteManifestsProcedure.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.TableProperties.SNAPSHOT_ID_INHERITANCE_ENABLED;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.sql.Date;
import java.sql.Timestamp;
@@ -31,7 +32,6 @@ import org.apache.spark.sql.AnalysisException;
import org.apache.spark.sql.RowFactory;
import org.apache.spark.sql.catalyst.analysis.NoSuchProcedureException;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
@@ -276,31 +276,29 @@ public class TestRewriteManifestsProcedure extends SparkExtensionsTestBase {
@Test
public void testInvalidRewriteManifestsCases() {
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.rewrite_manifests('n', table => 't')", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Named and positional arguments cannot be mixed");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.custom.rewrite_manifests('n', 't')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.custom.rewrite_manifests('n', 't')", catalogName))
.isInstanceOf(NoSuchProcedureException.class)
.hasMessage("Procedure custom.rewrite_manifests not found");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.rewrite_manifests()", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rewrite_manifests()", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Missing required parameters: [table]");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.rewrite_manifests('n', 2.2)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rewrite_manifests('n', 2.2)", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessageStartingWith("Wrong arg type for use_caching");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.rewrite_manifests(table => 't', tAbLe => 't')", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Could not build name to arg map: Duplicate procedure argument: table");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.rewrite_manifests('')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rewrite_manifests('')", catalogName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Cannot handle an empty identifier for argument table");
}
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRewritePositionDeleteFilesProcedure.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRewritePositionDeleteFilesProcedure.java
index 5dde5d698e..261dbcf7b7 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRewritePositionDeleteFilesProcedure.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRewritePositionDeleteFilesProcedure.java
@@ -20,6 +20,7 @@ package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.SnapshotSummary.ADDED_FILE_SIZE_PROP;
import static org.apache.iceberg.SnapshotSummary.REMOVED_FILE_SIZE_PROP;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.List;
import java.util.Map;
@@ -29,7 +30,6 @@ import org.apache.iceberg.relocated.com.google.common.collect.Lists;
import org.apache.iceberg.spark.data.TestHelpers;
import org.apache.iceberg.spark.source.SimpleRecord;
import org.apache.spark.sql.Encoders;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
@@ -206,7 +206,7 @@ public class TestRewritePositionDeleteFilesProcedure extends SparkExtensionsTest
@Test
public void testRewriteWithUntranslatedOrUnconvertedFilter() throws Exception {
createTable();
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_position_delete_files(table => '%s', where => 'substr(encode(data, \"utf-8\"), 2) = \"fo\"')",
@@ -214,7 +214,7 @@ public class TestRewritePositionDeleteFilesProcedure extends SparkExtensionsTest
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Cannot translate Spark expression");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rewrite_position_delete_files(table => '%s', where => 'substr(data, 2) = \"fo\"')",
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRollbackToSnapshotProcedure.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRollbackToSnapshotProcedure.java
index 1b4cd2b4a3..3e9b324df7 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRollbackToSnapshotProcedure.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRollbackToSnapshotProcedure.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.util.List;
import java.util.Map;
import org.apache.iceberg.Snapshot;
@@ -28,7 +30,6 @@ import org.apache.spark.sql.AnalysisException;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchProcedureException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assume;
import org.junit.Test;
@@ -240,7 +241,7 @@ public class TestRollbackToSnapshotProcedure extends SparkExtensionsTestBase {
public void testRollbackToInvalidSnapshot() {
sql("CREATE TABLE %s (id bigint NOT NULL, data string) USING iceberg", tableName);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.rollback_to_snapshot('%s', -1L)", catalogName, tableIdent))
.isInstanceOf(ValidationException.class)
.hasMessage("Cannot roll back to unknown snapshot id: -1");
@@ -248,7 +249,7 @@ public class TestRollbackToSnapshotProcedure extends SparkExtensionsTestBase {
@Test
public void testInvalidRollbackToSnapshotCases() {
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rollback_to_snapshot(namespace => 'n1', table => 't', 1L)",
@@ -256,32 +257,27 @@ public class TestRollbackToSnapshotProcedure extends SparkExtensionsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessage("Named and positional arguments cannot be mixed");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.custom.rollback_to_snapshot('n', 't', 1L)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.custom.rollback_to_snapshot('n', 't', 1L)", catalogName))
.isInstanceOf(NoSuchProcedureException.class)
.hasMessage("Procedure custom.rollback_to_snapshot not found");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.rollback_to_snapshot('t')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rollback_to_snapshot('t')", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Missing required parameters: [snapshot_id]");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.rollback_to_snapshot(1L)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rollback_to_snapshot(1L)", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Missing required parameters: [snapshot_id]");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.rollback_to_snapshot(table => 't')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rollback_to_snapshot(table => 't')", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Missing required parameters: [snapshot_id]");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.rollback_to_snapshot('t', 2.2)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rollback_to_snapshot('t', 2.2)", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Wrong arg type for snapshot_id: cannot cast DecimalType(2,1) to LongType");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.rollback_to_snapshot('', 1L)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rollback_to_snapshot('', 1L)", catalogName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Cannot handle an empty identifier for argument table");
}
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRollbackToTimestampProcedure.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRollbackToTimestampProcedure.java
index 80af6e7f5f..82df7567fc 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRollbackToTimestampProcedure.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestRollbackToTimestampProcedure.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
@@ -28,7 +30,6 @@ import org.apache.spark.sql.AnalysisException;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchProcedureException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assume;
import org.junit.Test;
@@ -255,7 +256,7 @@ public class TestRollbackToTimestampProcedure extends SparkExtensionsTestBase {
public void testInvalidRollbackToTimestampCases() {
String timestamp = "TIMESTAMP '2007-12-03T10:15:30'";
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rollback_to_timestamp(namespace => 'n1', 't', %s)",
@@ -263,17 +264,16 @@ public class TestRollbackToTimestampProcedure extends SparkExtensionsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessage("Named and positional arguments cannot be mixed");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.custom.rollback_to_timestamp('n', 't', %s)", catalogName, timestamp))
.isInstanceOf(NoSuchProcedureException.class)
.hasMessage("Procedure custom.rollback_to_timestamp not found");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.rollback_to_timestamp('t')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rollback_to_timestamp('t')", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Missing required parameters: [timestamp]");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rollback_to_timestamp(timestamp => %s)",
@@ -281,12 +281,11 @@ public class TestRollbackToTimestampProcedure extends SparkExtensionsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessage("Missing required parameters: [table]");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.rollback_to_timestamp(table => 't')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rollback_to_timestamp(table => 't')", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Missing required parameters: [timestamp]");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.rollback_to_timestamp('n', 't', %s, 1L)",
@@ -294,8 +293,7 @@ public class TestRollbackToTimestampProcedure extends SparkExtensionsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessage("Too many arguments for procedure");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.rollback_to_timestamp('t', 2.2)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.rollback_to_timestamp('t', 2.2)", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Wrong arg type for timestamp: cannot cast DecimalType(2,1) to TimestampType");
}
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSetCurrentSnapshotProcedure.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSetCurrentSnapshotProcedure.java
index e894ba4ff0..65db75f608 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSetCurrentSnapshotProcedure.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSetCurrentSnapshotProcedure.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.TableProperties.WRITE_AUDIT_PUBLISH_ENABLED;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.List;
import java.util.Map;
@@ -29,7 +30,6 @@ import org.apache.iceberg.relocated.com.google.common.collect.ImmutableList;
import org.apache.iceberg.relocated.com.google.common.collect.Iterables;
import org.apache.spark.sql.AnalysisException;
import org.apache.spark.sql.catalyst.analysis.NoSuchProcedureException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assume;
import org.junit.Test;
@@ -189,7 +189,7 @@ public class TestSetCurrentSnapshotProcedure extends SparkExtensionsTestBase {
public void testSetCurrentSnapshotToInvalidSnapshot() {
sql("CREATE TABLE %s (id bigint NOT NULL, data string) USING iceberg", tableName);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.set_current_snapshot('%s', -1L)", catalogName, tableIdent))
.isInstanceOf(ValidationException.class)
.hasMessage("Cannot roll back to unknown snapshot id: -1");
@@ -197,7 +197,7 @@ public class TestSetCurrentSnapshotProcedure extends SparkExtensionsTestBase {
@Test
public void testInvalidRollbackToSnapshotCases() {
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.set_current_snapshot(namespace => 'n1', table => 't', 1L)",
@@ -205,41 +205,36 @@ public class TestSetCurrentSnapshotProcedure extends SparkExtensionsTestBase {
.isInstanceOf(AnalysisException.class)
.hasMessage("Named and positional arguments cannot be mixed");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.custom.set_current_snapshot('n', 't', 1L)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.custom.set_current_snapshot('n', 't', 1L)", catalogName))
.isInstanceOf(NoSuchProcedureException.class)
.hasMessage("Procedure custom.set_current_snapshot not found");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.set_current_snapshot('t')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.set_current_snapshot('t')", catalogName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Either snapshot_id or ref must be provided, not both");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.set_current_snapshot(1L)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.set_current_snapshot(1L)", catalogName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Cannot parse identifier for arg table: 1");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.set_current_snapshot(snapshot_id => 1L)", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Missing required parameters: [table]");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.set_current_snapshot(table => 't')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.set_current_snapshot(table => 't')", catalogName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Either snapshot_id or ref must be provided, not both");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.set_current_snapshot('t', 2.2)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.set_current_snapshot('t', 2.2)", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Wrong arg type for snapshot_id: cannot cast DecimalType(2,1) to LongType");
- Assertions.assertThatThrownBy(
- () -> sql("CALL %s.system.set_current_snapshot('', 1L)", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.set_current_snapshot('', 1L)", catalogName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Cannot handle an empty identifier for argument table");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.set_current_snapshot(table => 't', snapshot_id => 1L, ref => 's1')",
@@ -284,7 +279,7 @@ public class TestSetCurrentSnapshotProcedure extends SparkExtensionsTestBase {
sql("SELECT * FROM %s ORDER BY id", tableName));
String notExistRef = "s2";
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.set_current_snapshot(table => '%s', ref => '%s')",
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSetWriteDistributionAndOrdering.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSetWriteDistributionAndOrdering.java
index caa9752004..4eaef55b69 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSetWriteDistributionAndOrdering.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSetWriteDistributionAndOrdering.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.expressions.Expressions.bucket;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.Map;
import org.apache.iceberg.NullOrder;
@@ -27,7 +28,6 @@ import org.apache.iceberg.Table;
import org.apache.iceberg.TableProperties;
import org.apache.iceberg.exceptions.ValidationException;
import org.apache.spark.sql.internal.SQLConf;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
@@ -75,7 +75,7 @@ public class TestSetWriteDistributionAndOrdering extends SparkExtensionsTestBase
Table table = validationCatalog.loadTable(tableIdent);
Assert.assertTrue("Table should start unsorted", table.sortOrder().isUnsorted());
sql("SET %s=true", SQLConf.CASE_SENSITIVE().key());
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> {
sql("ALTER TABLE %s WRITE ORDERED BY category, id", tableName);
})
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSnapshotTableProcedure.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSnapshotTableProcedure.java
index 367d95d8f6..bd4e1fb2f8 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSnapshotTableProcedure.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSnapshotTableProcedure.java
@@ -18,13 +18,14 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.io.IOException;
import java.util.Map;
import org.apache.iceberg.Table;
import org.apache.iceberg.TableProperties;
import org.apache.iceberg.relocated.com.google.common.collect.ImmutableList;
import org.apache.spark.sql.AnalysisException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Assume;
@@ -195,16 +196,16 @@ public class TestSnapshotTableProcedure extends SparkExtensionsTestBase {
"CREATE TABLE %s (id bigint NOT NULL, data string) USING parquet LOCATION '%s'",
sourceName, location);
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.snapshot('foo')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.snapshot('foo')", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessage("Missing required parameters: [table]");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("CALL %s.system.snapshot('n', 't', map('foo', 'bar'))", catalogName))
.isInstanceOf(AnalysisException.class)
.hasMessageStartingWith("Wrong arg type for location");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"CALL %s.system.snapshot('%s', 'fable', 'loc', map(2, 1, 1))",
@@ -213,11 +214,11 @@ public class TestSnapshotTableProcedure extends SparkExtensionsTestBase {
.hasMessageContaining(
"The `map` requires 2n (n > 0) parameters but the actual number is 3");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.snapshot('', 'dest')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.snapshot('', 'dest')", catalogName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Cannot handle an empty identifier for argument source_table");
- Assertions.assertThatThrownBy(() -> sql("CALL %s.system.snapshot('src', '')", catalogName))
+ assertThatThrownBy(() -> sql("CALL %s.system.snapshot('src', '')", catalogName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Cannot handle an empty identifier for argument table");
}
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestStoragePartitionedJoinsInRowLevelOperations.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestStoragePartitionedJoinsInRowLevelOperations.java
index 9b9609ebb0..7b22fffb0b 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestStoragePartitionedJoinsInRowLevelOperations.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestStoragePartitionedJoinsInRowLevelOperations.java
@@ -20,6 +20,7 @@ package org.apache.iceberg.spark.extensions;
import static org.apache.iceberg.RowLevelOperationMode.COPY_ON_WRITE;
import static org.apache.iceberg.RowLevelOperationMode.MERGE_ON_READ;
+import static org.assertj.core.api.Assertions.assertThat;
import java.util.Map;
import org.apache.commons.lang3.StringUtils;
@@ -31,7 +32,6 @@ import org.apache.iceberg.spark.SparkCatalogConfig;
import org.apache.iceberg.spark.SparkSQLProperties;
import org.apache.spark.sql.execution.SparkPlan;
import org.apache.spark.sql.internal.SQLConf;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
@@ -138,7 +138,7 @@ public class TestStoragePartitionedJoinsInRowLevelOperations extends SparkExtens
+ "dep = 'hr'",
tableName, tableName(OTHER_TABLE_NAME));
String planAsString = plan.toString();
- Assertions.assertThat(planAsString).doesNotContain("Exchange");
+ assertThat(planAsString).doesNotContain("Exchange");
});
ImmutableList<Object[]> expectedRows =
@@ -201,7 +201,7 @@ public class TestStoragePartitionedJoinsInRowLevelOperations extends SparkExtens
+ "dep = 'hr'",
tableName, tableName(OTHER_TABLE_NAME));
String planAsString = plan.toString();
- Assertions.assertThat(planAsString).doesNotContain("Exchange");
+ assertThat(planAsString).doesNotContain("Exchange");
});
ImmutableList<Object[]> expectedRows =
@@ -285,9 +285,9 @@ public class TestStoragePartitionedJoinsInRowLevelOperations extends SparkExtens
if (mode == COPY_ON_WRITE) {
int actualNumShuffles = StringUtils.countMatches(planAsString, "Exchange");
Assert.assertEquals("Should be 1 shuffle with SPJ", 1, actualNumShuffles);
- Assertions.assertThat(planAsString).contains("Exchange hashpartitioning(_file");
+ assertThat(planAsString).contains("Exchange hashpartitioning(_file");
} else {
- Assertions.assertThat(planAsString).doesNotContain("Exchange");
+ assertThat(planAsString).doesNotContain("Exchange");
}
});
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSystemFunctionPushDownDQL.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSystemFunctionPushDownDQL.java
index 7f2857cce0..a63a3b6582 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSystemFunctionPushDownDQL.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestSystemFunctionPushDownDQL.java
@@ -37,6 +37,7 @@ import static org.apache.iceberg.spark.SystemFunctionPushDownHelper.timestampStr
import static org.apache.iceberg.spark.SystemFunctionPushDownHelper.timestampStrToHourOrdinal;
import static org.apache.iceberg.spark.SystemFunctionPushDownHelper.timestampStrToMonthOrdinal;
import static org.apache.iceberg.spark.SystemFunctionPushDownHelper.timestampStrToYearOrdinal;
+import static org.assertj.core.api.Assertions.assertThat;
import java.util.List;
import java.util.Map;
@@ -49,7 +50,6 @@ import org.apache.spark.sql.catalyst.expressions.ApplyFunctionExpression;
import org.apache.spark.sql.catalyst.expressions.Expression;
import org.apache.spark.sql.catalyst.expressions.objects.StaticInvoke;
import org.apache.spark.sql.catalyst.plans.logical.LogicalPlan;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -107,7 +107,7 @@ public class TestSystemFunctionPushDownDQL extends SparkExtensionsTestBase {
checkPushedFilters(optimizedPlan, equal(year("ts"), targetYears));
List<Object[]> actual = rowsToJava(df.collectAsList());
- Assertions.assertThat(actual.size()).isEqualTo(5);
+ assertThat(actual.size()).isEqualTo(5);
}
@Test
@@ -135,7 +135,7 @@ public class TestSystemFunctionPushDownDQL extends SparkExtensionsTestBase {
checkPushedFilters(optimizedPlan, greaterThan(month("ts"), targetMonths));
List<Object[]> actual = rowsToJava(df.collectAsList());
- Assertions.assertThat(actual.size()).isEqualTo(5);
+ assertThat(actual.size()).isEqualTo(5);
}
@Test
@@ -165,7 +165,7 @@ public class TestSystemFunctionPushDownDQL extends SparkExtensionsTestBase {
checkPushedFilters(optimizedPlan, lessThan(day("ts"), targetDays));
List<Object[]> actual = rowsToJava(df.collectAsList());
- Assertions.assertThat(actual.size()).isEqualTo(5);
+ assertThat(actual.size()).isEqualTo(5);
}
@Test
@@ -193,7 +193,7 @@ public class TestSystemFunctionPushDownDQL extends SparkExtensionsTestBase {
checkPushedFilters(optimizedPlan, greaterThanOrEqual(hour("ts"), targetHours));
List<Object[]> actual = rowsToJava(df.collectAsList());
- Assertions.assertThat(actual.size()).isEqualTo(8);
+ assertThat(actual.size()).isEqualTo(8);
}
@Test
@@ -221,7 +221,7 @@ public class TestSystemFunctionPushDownDQL extends SparkExtensionsTestBase {
checkPushedFilters(optimizedPlan, lessThanOrEqual(bucket("id", 5), target));
List<Object[]> actual = rowsToJava(df.collectAsList());
- Assertions.assertThat(actual.size()).isEqualTo(5);
+ assertThat(actual.size()).isEqualTo(5);
}
@Test
@@ -249,7 +249,7 @@ public class TestSystemFunctionPushDownDQL extends SparkExtensionsTestBase {
checkPushedFilters(optimizedPlan, notEqual(bucket("data", 5), target));
List<Object[]> actual = rowsToJava(df.collectAsList());
- Assertions.assertThat(actual.size()).isEqualTo(8);
+ assertThat(actual.size()).isEqualTo(8);
}
@Test
@@ -278,7 +278,7 @@ public class TestSystemFunctionPushDownDQL extends SparkExtensionsTestBase {
checkPushedFilters(optimizedPlan, equal(truncate("data", 4), target));
List<Object[]> actual = rowsToJava(df.collectAsList());
- Assertions.assertThat(actual.size()).isEqualTo(5);
+ assertThat(actual.size()).isEqualTo(5);
}
private void checkExpressions(
@@ -286,18 +286,18 @@ public class TestSystemFunctionPushDownDQL extends SparkExtensionsTestBase {
List<Expression> staticInvokes =
PlanUtils.collectSparkExpressions(
optimizedPlan, expression -> expression instanceof StaticInvoke);
- Assertions.assertThat(staticInvokes).isEmpty();
+ assertThat(staticInvokes).isEmpty();
List<Expression> applyExpressions =
PlanUtils.collectSparkExpressions(
optimizedPlan, expression -> expression instanceof ApplyFunctionExpression);
if (partitioned) {
- Assertions.assertThat(applyExpressions).isEmpty();
+ assertThat(applyExpressions).isEmpty();
} else {
- Assertions.assertThat(applyExpressions.size()).isEqualTo(1);
+ assertThat(applyExpressions.size()).isEqualTo(1);
ApplyFunctionExpression expression = (ApplyFunctionExpression) applyExpressions.get(0);
- Assertions.assertThat(expression.name()).isEqualTo(expectedFunctionName);
+ assertThat(expression.name()).isEqualTo(expectedFunctionName);
}
}
@@ -305,9 +305,9 @@ public class TestSystemFunctionPushDownDQL extends SparkExtensionsTestBase {
LogicalPlan optimizedPlan, org.apache.iceberg.expressions.Expression expected) {
List<org.apache.iceberg.expressions.Expression> pushedFilters =
PlanUtils.collectPushDownFilters(optimizedPlan);
- Assertions.assertThat(pushedFilters.size()).isEqualTo(1);
+ assertThat(pushedFilters.size()).isEqualTo(1);
org.apache.iceberg.expressions.Expression actual = pushedFilters.get(0);
- Assertions.assertThat(ExpressionUtil.equivalent(expected, actual, STRUCT, true))
+ assertThat(ExpressionUtil.equivalent(expected, actual, STRUCT, true))
.as("Pushed filter should match")
.isTrue();
}
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestTagDDL.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestTagDDL.java
index 52b9134089..b8673d0ae3 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestTagDDL.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestTagDDL.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.extensions;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.List;
import java.util.Locale;
@@ -34,7 +35,6 @@ import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
import org.apache.spark.sql.catalyst.parser.extensions.IcebergParseException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
@@ -96,7 +96,7 @@ public class TestTagDDL extends SparkExtensionsTestBase {
}
String tagName = "t1";
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"ALTER TABLE %s CREATE TAG %s AS OF VERSION %d RETAIN",
@@ -104,12 +104,12 @@ public class TestTagDDL extends SparkExtensionsTestBase {
.isInstanceOf(IcebergParseException.class)
.hasMessageContaining("mismatched input");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("ALTER TABLE %s CREATE TAG %s RETAIN %s DAYS", tableName, tagName, "abc"))
.isInstanceOf(IcebergParseException.class)
.hasMessageContaining("mismatched input");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"ALTER TABLE %s CREATE TAG %s AS OF VERSION %d RETAIN %d SECONDS",
@@ -120,7 +120,7 @@ public class TestTagDDL extends SparkExtensionsTestBase {
@Test
public void testCreateTagOnEmptyTable() {
- Assertions.assertThatThrownBy(() -> sql("ALTER TABLE %s CREATE TAG %s", tableName, "abc"))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s CREATE TAG %s", tableName, "abc"))
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining(
"Cannot complete create or replace tag operation on %s, main has no snapshot",
@@ -133,7 +133,7 @@ public class TestTagDDL extends SparkExtensionsTestBase {
long snapshotId = table.currentSnapshot().snapshotId();
String tagName = "t1";
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("ALTER TABLE %s CREATE TAG %s AS OF VERSION %d", tableName, tagName, -1))
.isInstanceOf(ValidationException.class)
.hasMessage("Cannot set " + tagName + " to unknown snapshot: -1");
@@ -146,11 +146,11 @@ public class TestTagDDL extends SparkExtensionsTestBase {
Assert.assertNull(
"The tag needs to have the default max ref age, which is null.", ref.maxRefAgeMs());
- Assertions.assertThatThrownBy(() -> sql("ALTER TABLE %s CREATE TAG %s", tableName, tagName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s CREATE TAG %s", tableName, tagName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("already exists");
- Assertions.assertThatThrownBy(() -> sql("ALTER TABLE %s CREATE TAG %s", tableName, "123"))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s CREATE TAG %s", tableName, "123"))
.isInstanceOf(IcebergParseException.class)
.hasMessageContaining("mismatched input '123'");
@@ -198,8 +198,7 @@ public class TestTagDDL extends SparkExtensionsTestBase {
insertRows();
long second = table.currentSnapshot().snapshotId();
- Assertions.assertThatThrownBy(
- () -> sql("ALTER TABLE %s REPLACE Tag %s", tableName, branchName, second))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s REPLACE Tag %s", tableName, branchName, second))
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Ref branch1 is a branch not a tag");
}
@@ -234,7 +233,7 @@ public class TestTagDDL extends SparkExtensionsTestBase {
public void testReplaceTagDoesNotExist() throws NoSuchTableException {
Table table = insertRows();
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"ALTER TABLE %s REPLACE Tag %s AS OF VERSION %d",
@@ -305,15 +304,14 @@ public class TestTagDDL extends SparkExtensionsTestBase {
@Test
public void testDropTagNonConformingName() {
- Assertions.assertThatThrownBy(() -> sql("ALTER TABLE %s DROP TAG %s", tableName, "123"))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s DROP TAG %s", tableName, "123"))
.isInstanceOf(IcebergParseException.class)
.hasMessageContaining("mismatched input '123'");
}
@Test
public void testDropTagDoesNotExist() {
- Assertions.assertThatThrownBy(
- () -> sql("ALTER TABLE %s DROP TAG %s", tableName, "nonExistingTag"))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s DROP TAG %s", tableName, "nonExistingTag"))
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Tag does not exist: nonExistingTag");
}
@@ -324,7 +322,7 @@ public class TestTagDDL extends SparkExtensionsTestBase {
Table table = insertRows();
table.manageSnapshots().createBranch(branchName, table.currentSnapshot().snapshotId()).commit();
- Assertions.assertThatThrownBy(() -> sql("ALTER TABLE %s DROP TAG %s", tableName, branchName))
+ assertThatThrownBy(() -> sql("ALTER TABLE %s DROP TAG %s", tableName, branchName))
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("Ref b1 is a branch not a tag");
}
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestUpdate.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestUpdate.java
index 8b5e1cd1d4..e84789de7a 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestUpdate.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestUpdate.java
@@ -31,6 +31,8 @@ import static org.apache.iceberg.TableProperties.UPDATE_ISOLATION_LEVEL;
import static org.apache.iceberg.TableProperties.UPDATE_MODE;
import static org.apache.iceberg.TableProperties.UPDATE_MODE_DEFAULT;
import static org.apache.spark.sql.functions.lit;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assumptions.assumeThat;
import java.util.Arrays;
@@ -70,7 +72,6 @@ import org.apache.spark.sql.Row;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
import org.apache.spark.sql.execution.SparkPlan;
import org.apache.spark.sql.internal.SQLConf;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Assume;
@@ -169,7 +170,7 @@ public abstract class TestUpdate extends SparkRowLevelOperationsTestBase {
() -> {
SparkPlan plan =
executeAndKeepPlan("UPDATE %s SET id = -1 WHERE mod(id, 2) = 0", commitTarget());
- Assertions.assertThat(plan.toString()).contains("REBALANCE_PARTITIONS_BY_COL");
+ assertThat(plan.toString()).contains("REBALANCE_PARTITIONS_BY_COL");
});
Table table = validationCatalog.loadTable(tableIdent);
@@ -233,7 +234,7 @@ public abstract class TestUpdate extends SparkRowLevelOperationsTestBase {
() -> {
SparkPlan plan =
executeAndKeepPlan("UPDATE %s SET id = -1 WHERE mod(id, 2) = 0", commitTarget());
- Assertions.assertThat(plan.toString()).contains("REBALANCE_PARTITIONS_BY_COL");
+ assertThat(plan.toString()).contains("REBALANCE_PARTITIONS_BY_COL");
});
Table table = validationCatalog.loadTable(tableIdent);
@@ -303,8 +304,7 @@ public abstract class TestUpdate extends SparkRowLevelOperationsTestBase {
Assume.assumeTrue("Test only applicable to custom branch", "test".equals(branch));
createAndInitTable("id INT, dep STRING");
- Assertions.assertThatThrownBy(
- () -> sql("UPDATE %s SET dep = 'invalid' WHERE id IN (1)", commitTarget()))
+ assertThatThrownBy(() -> sql("UPDATE %s SET dep = 'invalid' WHERE id IN (1)", commitTarget()))
.isInstanceOf(ValidationException.class)
.hasMessage("Cannot use branch (does not exist): test");
}
@@ -693,7 +693,7 @@ public abstract class TestUpdate extends SparkRowLevelOperationsTestBase {
});
try {
- Assertions.assertThatThrownBy(updateFuture::get)
+ assertThatThrownBy(updateFuture::get)
.isInstanceOf(ExecutionException.class)
.cause()
.isInstanceOf(ValidationException.class)
@@ -1315,11 +1315,11 @@ public abstract class TestUpdate extends SparkRowLevelOperationsTestBase {
"id INT, a ARRAY<STRUCT<c1:INT,c2:INT>>, m MAP<STRING,STRING>",
"{ \"id\": 0, \"a\": null, \"m\": null }");
- Assertions.assertThatThrownBy(() -> sql("UPDATE %s SET a.c1 = 1", commitTarget()))
+ assertThatThrownBy(() -> sql("UPDATE %s SET a.c1 = 1", commitTarget()))
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Updating nested fields is only supported for structs");
- Assertions.assertThatThrownBy(() -> sql("UPDATE %s SET m.key = 'new_key'", commitTarget()))
+ assertThatThrownBy(() -> sql("UPDATE %s SET m.key = 'new_key'", commitTarget()))
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Updating nested fields is only supported for structs");
}
@@ -1329,17 +1329,16 @@ public abstract class TestUpdate extends SparkRowLevelOperationsTestBase {
createAndInitTable(
"id INT, c STRUCT<n1:INT,n2:STRUCT<dn1:INT,dn2:INT>>", "{ \"id\": 0, \"s\": null }");
- Assertions.assertThatThrownBy(
- () -> sql("UPDATE %s t SET t.id = 1, t.c.n1 = 2, t.id = 2", commitTarget()))
+ assertThatThrownBy(() -> sql("UPDATE %s t SET t.id = 1, t.c.n1 = 2, t.id = 2", commitTarget()))
.isInstanceOf(AnalysisException.class)
.hasMessageStartingWith("Updates are in conflict for these columns");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("UPDATE %s t SET t.c.n1 = 1, t.id = 2, t.c.n1 = 2", commitTarget()))
.isInstanceOf(AnalysisException.class)
.hasMessageStartingWith("Updates are in conflict for these columns");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"UPDATE %s SET c.n1 = 1, c = named_struct('n1', 1, 'n2', named_struct('dn1', 1, 'dn2', 2))",
@@ -1358,26 +1357,24 @@ public abstract class TestUpdate extends SparkRowLevelOperationsTestBase {
withSQLConf(
ImmutableMap.of("spark.sql.storeAssignmentPolicy", policy),
() -> {
- Assertions.assertThatThrownBy(() -> sql("UPDATE %s t SET t.id = NULL", commitTarget()))
+ assertThatThrownBy(() -> sql("UPDATE %s t SET t.id = NULL", commitTarget()))
.isInstanceOf(AnalysisException.class)
.hasMessageStartingWith("Cannot write nullable values to non-null column");
- Assertions.assertThatThrownBy(
- () -> sql("UPDATE %s t SET t.s.n1 = NULL", commitTarget()))
+ assertThatThrownBy(() -> sql("UPDATE %s t SET t.s.n1 = NULL", commitTarget()))
.isInstanceOf(AnalysisException.class)
.hasMessageStartingWith("Cannot write nullable values to non-null column");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("UPDATE %s t SET t.s = named_struct('n1', 1)", commitTarget()))
.isInstanceOf(AnalysisException.class)
.hasMessageStartingWith("Cannot write incompatible data:");
- Assertions.assertThatThrownBy(
- () -> sql("UPDATE %s t SET t.s.n1 = 'str'", commitTarget()))
+ assertThatThrownBy(() -> sql("UPDATE %s t SET t.s.n1 = 'str'", commitTarget()))
.isInstanceOf(AnalysisException.class)
.hasMessageContaining("Cannot safely cast");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
sql(
"UPDATE %s t SET t.s.n2 = named_struct('dn3', 1, 'dn1', 2)",
@@ -1392,7 +1389,7 @@ public abstract class TestUpdate extends SparkRowLevelOperationsTestBase {
public void testUpdateWithNonDeterministicCondition() {
createAndInitTable("id INT, dep STRING", "{ \"id\": 1, \"dep\": \"hr\" }");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() -> sql("UPDATE %s SET id = -1 WHERE id = 1 AND rand() > 0.5", commitTarget()))
.isInstanceOf(AnalysisException.class)
.hasMessageStartingWith(
@@ -1403,7 +1400,7 @@ public abstract class TestUpdate extends SparkRowLevelOperationsTestBase {
public void testUpdateOnNonIcebergTableNotSupported() {
createOrReplaceView("testtable", "{ \"c1\": -100, \"c2\": -200 }");
- Assertions.assertThatThrownBy(() -> sql("UPDATE %s SET c1 = -1 WHERE c2 = 1", "testtable"))
+ assertThatThrownBy(() -> sql("UPDATE %s SET c1 = -1 WHERE c2 = 1", "testtable"))
.isInstanceOf(UnsupportedOperationException.class)
.hasMessage("UPDATE TABLE is not supported temporarily.");
}
@@ -1467,8 +1464,7 @@ public abstract class TestUpdate extends SparkRowLevelOperationsTestBase {
withSQLConf(
ImmutableMap.of(SparkSQLProperties.WAP_BRANCH, "wap"),
() ->
- Assertions.assertThatThrownBy(
- () -> sql("UPDATE %s SET dep='hr' WHERE dep='a'", commitTarget()))
+ assertThatThrownBy(() -> sql("UPDATE %s SET dep='hr' WHERE dep='a'", commitTarget()))
.isInstanceOf(ValidationException.class)
.hasMessage(
String.format(
diff --git a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestWriteAborts.java b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestWriteAborts.java
index 15484f45f8..a58dcb5d5e 100644
--- a/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestWriteAborts.java
+++ b/spark/v3.4/spark-extensions/src/test/java/org/apache/iceberg/spark/extensions/TestWriteAborts.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark.extensions;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.util.List;
import java.util.Map;
import org.apache.hadoop.conf.Configuration;
@@ -37,7 +39,6 @@ import org.apache.iceberg.spark.source.SimpleRecord;
import org.apache.spark.SparkException;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Rule;
import org.junit.Test;
@@ -104,7 +105,7 @@ public class TestWriteAborts extends SparkExtensionsTestBase {
new SimpleRecord(4, "b"));
Dataset<Row> inputDF = spark.createDataFrame(records, SimpleRecord.class);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
// incoming records are not ordered by partitions so the job must fail
inputDF
diff --git a/spark/v3.4/spark-runtime/src/integration/java/org/apache/iceberg/spark/SmokeTest.java b/spark/v3.4/spark-runtime/src/integration/java/org/apache/iceberg/spark/SmokeTest.java
index 4704bcbbda..59bc70854c 100644
--- a/spark/v3.4/spark-runtime/src/integration/java/org/apache/iceberg/spark/SmokeTest.java
+++ b/spark/v3.4/spark-runtime/src/integration/java/org/apache/iceberg/spark/SmokeTest.java
@@ -18,13 +18,14 @@
*/
package org.apache.iceberg.spark;
+import static org.assertj.core.api.Assertions.assertThat;
+
import java.io.IOException;
import java.util.Map;
import org.apache.iceberg.Table;
import org.apache.iceberg.catalog.TableIdentifier;
import org.apache.iceberg.spark.extensions.SparkExtensionsTestBase;
import org.apache.spark.sql.catalyst.analysis.NoSuchTableException;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@@ -170,7 +171,7 @@ public class SmokeTest extends SparkExtensionsTestBase {
public void showView() {
sql("DROP VIEW IF EXISTS %s", "test");
sql("CREATE VIEW %s AS SELECT 1 AS id", "test");
- Assertions.assertThat(sql("SHOW VIEWS")).contains(row("default", "test", false));
+ assertThat(sql("SHOW VIEWS")).contains(row("default", "test", false));
}
private Table getTable(String name) {
diff --git a/spark/v3.4/spark/src/test/java/org/apache/iceberg/TestDataFileSerialization.java b/spark/v3.4/spark/src/test/java/org/apache/iceberg/TestDataFileSerialization.java
index 33b5316b72..2a7d3d4c33 100644
--- a/spark/v3.4/spark/src/test/java/org/apache/iceberg/TestDataFileSerialization.java
+++ b/spark/v3.4/spark/src/test/java/org/apache/iceberg/TestDataFileSerialization.java
@@ -21,6 +21,7 @@ package org.apache.iceberg;
import static org.apache.iceberg.TaskCheckHelper.assertEquals;
import static org.apache.iceberg.types.Types.NestedField.optional;
import static org.apache.iceberg.types.Types.NestedField.required;
+import static org.assertj.core.api.Assertions.assertThat;
import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
@@ -48,7 +49,6 @@ import org.apache.iceberg.types.Types;
import org.apache.spark.SparkConf;
import org.apache.spark.serializer.KryoSerializer;
import org.apache.spark.sql.catalyst.InternalRow;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Rule;
import org.junit.Test;
@@ -118,7 +118,7 @@ public class TestDataFileSerialization {
try (Input in = new Input(new FileInputStream(data))) {
for (int i = 0; i < 2; i += 1) {
Object obj = kryo.readClassAndObject(in);
- Assertions.assertThat(obj).as("Should be a DataFile").isInstanceOf(DataFile.class);
+ assertThat(obj).as("Should be a DataFile").isInstanceOf(DataFile.class);
assertEquals(DATA_FILE, (DataFile) obj);
}
}
@@ -136,7 +136,7 @@ public class TestDataFileSerialization {
new ObjectInputStream(new ByteArrayInputStream(bytes.toByteArray()))) {
for (int i = 0; i < 2; i += 1) {
Object obj = in.readObject();
- Assertions.assertThat(obj).as("Should be a DataFile").isInstanceOf(DataFile.class);
+ assertThat(obj).as("Should be a DataFile").isInstanceOf(DataFile.class);
assertEquals(DATA_FILE, (DataFile) obj);
}
}
diff --git a/spark/v3.4/spark/src/test/java/org/apache/iceberg/TestManifestFileSerialization.java b/spark/v3.4/spark/src/test/java/org/apache/iceberg/TestManifestFileSerialization.java
index 92a646d386..a42781f952 100644
--- a/spark/v3.4/spark/src/test/java/org/apache/iceberg/TestManifestFileSerialization.java
+++ b/spark/v3.4/spark/src/test/java/org/apache/iceberg/TestManifestFileSerialization.java
@@ -20,6 +20,7 @@ package org.apache.iceberg;
import static org.apache.iceberg.types.Types.NestedField.optional;
import static org.apache.iceberg.types.Types.NestedField.required;
+import static org.assertj.core.api.Assertions.assertThat;
import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
@@ -43,7 +44,6 @@ import org.apache.iceberg.relocated.com.google.common.collect.ImmutableMap;
import org.apache.iceberg.types.Types;
import org.apache.spark.SparkConf;
import org.apache.spark.serializer.KryoSerializer;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Rule;
import org.junit.Test;
@@ -119,7 +119,7 @@ public class TestManifestFileSerialization {
try (Input in = new Input(new FileInputStream(data))) {
for (int i = 0; i < 3; i += 1) {
Object obj = kryo.readClassAndObject(in);
- Assertions.assertThat(obj).as("Should be a ManifestFile").isInstanceOf(ManifestFile.class);
+ assertThat(obj).as("Should be a ManifestFile").isInstanceOf(ManifestFile.class);
checkManifestFile(manifest, (ManifestFile) obj);
}
}
@@ -141,7 +141,7 @@ public class TestManifestFileSerialization {
new ObjectInputStream(new ByteArrayInputStream(bytes.toByteArray()))) {
for (int i = 0; i < 3; i += 1) {
Object obj = in.readObject();
- Assertions.assertThat(obj).as("Should be a ManifestFile").isInstanceOf(ManifestFile.class);
+ assertThat(obj).as("Should be a ManifestFile").isInstanceOf(ManifestFile.class);
checkManifestFile(manifest, (ManifestFile) obj);
}
}
diff --git a/spark/v3.4/spark/src/test/java/org/apache/iceberg/TestScanTaskSerialization.java b/spark/v3.4/spark/src/test/java/org/apache/iceberg/TestScanTaskSerialization.java
index 281eb2543a..b9e4b04953 100644
--- a/spark/v3.4/spark/src/test/java/org/apache/iceberg/TestScanTaskSerialization.java
+++ b/spark/v3.4/spark/src/test/java/org/apache/iceberg/TestScanTaskSerialization.java
@@ -19,6 +19,7 @@
package org.apache.iceberg;
import static org.apache.iceberg.types.Types.NestedField.optional;
+import static org.assertj.core.api.Assertions.assertThat;
import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
@@ -46,7 +47,6 @@ import org.apache.spark.SparkConf;
import org.apache.spark.serializer.KryoSerializer;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
@@ -86,7 +86,7 @@ public class TestScanTaskSerialization extends SparkTestBase {
try (Input in = new Input(new FileInputStream(data))) {
Object obj = kryo.readClassAndObject(in);
- Assertions.assertThat(obj)
+ assertThat(obj)
.as("Should be a BaseCombinedScanTask")
.isInstanceOf(BaseCombinedScanTask.class);
TaskCheckHelper.assertEquals(scanTask, (BaseCombinedScanTask) obj);
@@ -105,7 +105,7 @@ public class TestScanTaskSerialization extends SparkTestBase {
try (ObjectInputStream in =
new ObjectInputStream(new ByteArrayInputStream(bytes.toByteArray()))) {
Object obj = in.readObject();
- Assertions.assertThat(obj)
+ assertThat(obj)
.as("Should be a BaseCombinedScanTask")
.isInstanceOf(BaseCombinedScanTask.class);
TaskCheckHelper.assertEquals(scanTask, (BaseCombinedScanTask) obj);
@@ -129,9 +129,7 @@ public class TestScanTaskSerialization extends SparkTestBase {
try (Input in = new Input(Files.newInputStream(data.toPath()))) {
Object obj = kryo.readClassAndObject(in);
- Assertions.assertThat(obj)
- .as("should be a BaseScanTaskGroup")
- .isInstanceOf(BaseScanTaskGroup.class);
+ assertThat(obj).as("should be a BaseScanTaskGroup").isInstanceOf(BaseScanTaskGroup.class);
TaskCheckHelper.assertEquals(taskGroup, (BaseScanTaskGroup<FileScanTask>) obj);
}
}
@@ -151,9 +149,7 @@ public class TestScanTaskSerialization extends SparkTestBase {
try (ObjectInputStream in =
new ObjectInputStream(new ByteArrayInputStream(bytes.toByteArray()))) {
Object obj = in.readObject();
- Assertions.assertThat(obj)
- .as("should be a BaseScanTaskGroup")
- .isInstanceOf(BaseScanTaskGroup.class);
+ assertThat(obj).as("should be a BaseScanTaskGroup").isInstanceOf(BaseScanTaskGroup.class);
TaskCheckHelper.assertEquals(taskGroup, (BaseScanTaskGroup<FileScanTask>) obj);
}
}
diff --git a/spark/v3.4/spark/src/test/java/org/apache/iceberg/ValidationHelpers.java b/spark/v3.4/spark/src/test/java/org/apache/iceberg/ValidationHelpers.java
index 70ab04f0a0..b0b3085dca 100644
--- a/spark/v3.4/spark/src/test/java/org/apache/iceberg/ValidationHelpers.java
+++ b/spark/v3.4/spark/src/test/java/org/apache/iceberg/ValidationHelpers.java
@@ -18,11 +18,12 @@
*/
package org.apache.iceberg;
+import static org.assertj.core.api.Assertions.assertThat;
+
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import org.apache.iceberg.relocated.com.google.common.collect.Lists;
-import org.assertj.core.api.Assertions;
public class ValidationHelpers {
@@ -72,6 +73,6 @@ public class ValidationHelpers {
private static <T> void assertSameElements(String context, List<T> actual, List<T> expected) {
String errorMessage = String.format("%s must match", context);
- Assertions.assertThat(actual).as(errorMessage).hasSameElementsAs(expected);
+ assertThat(actual).as(errorMessage).hasSameElementsAs(expected);
}
}
diff --git a/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/TestFunctionCatalog.java b/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/TestFunctionCatalog.java
index cad3478f3e..b51861e4a2 100644
--- a/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/TestFunctionCatalog.java
+++ b/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/TestFunctionCatalog.java
@@ -18,6 +18,9 @@
*/
package org.apache.iceberg.spark;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import org.apache.iceberg.IcebergBuild;
import org.apache.iceberg.relocated.com.google.common.collect.ImmutableList;
import org.apache.iceberg.spark.functions.IcebergVersionFunction;
@@ -27,7 +30,6 @@ import org.apache.spark.sql.catalyst.analysis.NoSuchNamespaceException;
import org.apache.spark.sql.connector.catalog.FunctionCatalog;
import org.apache.spark.sql.connector.catalog.Identifier;
import org.apache.spark.sql.connector.catalog.functions.UnboundFunction;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
@@ -56,10 +58,10 @@ public class TestFunctionCatalog extends SparkTestBaseWithCatalog {
@Test
public void testListFunctionsViaCatalog() throws NoSuchNamespaceException {
- Assertions.assertThat(asFunctionCatalog.listFunctions(EMPTY_NAMESPACE))
+ assertThat(asFunctionCatalog.listFunctions(EMPTY_NAMESPACE))
.anyMatch(func -> "iceberg_version".equals(func.name()));
- Assertions.assertThat(asFunctionCatalog.listFunctions(SYSTEM_NAMESPACE))
+ assertThat(asFunctionCatalog.listFunctions(SYSTEM_NAMESPACE))
.anyMatch(func -> "iceberg_version".equals(func.name()));
Assert.assertArrayEquals(
@@ -67,7 +69,7 @@ public class TestFunctionCatalog extends SparkTestBaseWithCatalog {
new Identifier[0],
asFunctionCatalog.listFunctions(DEFAULT_NAMESPACE));
- Assertions.assertThatThrownBy(() -> asFunctionCatalog.listFunctions(DB_NAMESPACE))
+ assertThatThrownBy(() -> asFunctionCatalog.listFunctions(DB_NAMESPACE))
.isInstanceOf(NoSuchNamespaceException.class)
.hasMessageStartingWith("[SCHEMA_NOT_FOUND] The schema `db` cannot be found.");
}
@@ -78,13 +80,13 @@ public class TestFunctionCatalog extends SparkTestBaseWithCatalog {
Identifier identifier = Identifier.of(namespace, "iceberg_version");
UnboundFunction func = asFunctionCatalog.loadFunction(identifier);
- Assertions.assertThat(func)
+ assertThat(func)
.isNotNull()
.isInstanceOf(UnboundFunction.class)
.isExactlyInstanceOf(IcebergVersionFunction.class);
}
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
asFunctionCatalog.loadFunction(Identifier.of(DEFAULT_NAMESPACE, "iceberg_version")))
.isInstanceOf(NoSuchFunctionException.class)
@@ -92,12 +94,12 @@ public class TestFunctionCatalog extends SparkTestBaseWithCatalog {
String.format("Cannot load function: %s.default.iceberg_version", catalogName));
Identifier undefinedFunction = Identifier.of(SYSTEM_NAMESPACE, "undefined_function");
- Assertions.assertThatThrownBy(() -> asFunctionCatalog.loadFunction(undefinedFunction))
+ assertThatThrownBy(() -> asFunctionCatalog.loadFunction(undefinedFunction))
.isInstanceOf(NoSuchFunctionException.class)
.hasMessageStartingWith(
String.format("Cannot load function: %s.system.undefined_function", catalogName));
- Assertions.assertThatThrownBy(() -> sql("SELECT undefined_function(1, 2)"))
+ assertThatThrownBy(() -> sql("SELECT undefined_function(1, 2)"))
.isInstanceOf(AnalysisException.class)
.hasMessageStartingWith(
"[UNRESOLVED_ROUTINE] Cannot resolve function `undefined_function` on search path");
diff --git a/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/TestSpark3Util.java b/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/TestSpark3Util.java
index ce11f0c05f..7446600739 100644
--- a/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/TestSpark3Util.java
+++ b/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/TestSpark3Util.java
@@ -36,6 +36,7 @@ import static org.apache.iceberg.expressions.Expressions.truncate;
import static org.apache.iceberg.expressions.Expressions.year;
import static org.apache.iceberg.types.Types.NestedField.optional;
import static org.apache.iceberg.types.Types.NestedField.required;
+import static org.assertj.core.api.Assertions.assertThat;
import org.apache.iceberg.CachingCatalog;
import org.apache.iceberg.Schema;
@@ -45,7 +46,6 @@ import org.apache.iceberg.Table;
import org.apache.iceberg.catalog.Catalog;
import org.apache.iceberg.expressions.Expression;
import org.apache.iceberg.types.Types;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Test;
@@ -141,30 +141,29 @@ public class TestSpark3Util extends SparkTestBase {
@Test
public void testDescribeExpression() {
Expression refExpression = equal("id", 1);
- Assertions.assertThat(Spark3Util.describe(refExpression)).isEqualTo("id = 1");
+ assertThat(Spark3Util.describe(refExpression)).isEqualTo("id = 1");
Expression yearExpression = greaterThan(year("ts"), 10);
- Assertions.assertThat(Spark3Util.describe(yearExpression)).isEqualTo("year(ts) > 10");
+ assertThat(Spark3Util.describe(yearExpression)).isEqualTo("year(ts) > 10");
Expression monthExpression = greaterThanOrEqual(month("ts"), 10);
- Assertions.assertThat(Spark3Util.describe(monthExpression)).isEqualTo("month(ts) >= 10");
+ assertThat(Spark3Util.describe(monthExpression)).isEqualTo("month(ts) >= 10");
Expression dayExpression = lessThan(day("ts"), 10);
- Assertions.assertThat(Spark3Util.describe(dayExpression)).isEqualTo("day(ts) < 10");
+ assertThat(Spark3Util.describe(dayExpression)).isEqualTo("day(ts) < 10");
Expression hourExpression = lessThanOrEqual(hour("ts"), 10);
- Assertions.assertThat(Spark3Util.describe(hourExpression)).isEqualTo("hour(ts) <= 10");
+ assertThat(Spark3Util.describe(hourExpression)).isEqualTo("hour(ts) <= 10");
Expression bucketExpression = in(bucket("id", 5), 3);
- Assertions.assertThat(Spark3Util.describe(bucketExpression)).isEqualTo("bucket[5](id) IN (3)");
+ assertThat(Spark3Util.describe(bucketExpression)).isEqualTo("bucket[5](id) IN (3)");
Expression truncateExpression = notIn(truncate("name", 3), "abc");
- Assertions.assertThat(Spark3Util.describe(truncateExpression))
+ assertThat(Spark3Util.describe(truncateExpression))
.isEqualTo("truncate[3](name) NOT IN ('abc')");
Expression andExpression = and(refExpression, yearExpression);
- Assertions.assertThat(Spark3Util.describe(andExpression))
- .isEqualTo("(id = 1 AND year(ts) > 10)");
+ assertThat(Spark3Util.describe(andExpression)).isEqualTo("(id = 1 AND year(ts) > 10)");
}
private SortOrder buildSortOrder(String transform, Schema schema, int sourceId) {
diff --git a/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/TestSparkTableUtil.java b/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/TestSparkTableUtil.java
index 1e51caadd0..51c8d9643c 100644
--- a/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/TestSparkTableUtil.java
+++ b/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/TestSparkTableUtil.java
@@ -18,6 +18,8 @@
*/
package org.apache.iceberg.spark;
+import static org.assertj.core.api.Assertions.assertThat;
+
import java.io.IOException;
import java.util.Map;
import org.apache.iceberg.KryoHelpers;
@@ -27,7 +29,6 @@ import org.apache.iceberg.TableProperties;
import org.apache.iceberg.TestHelpers;
import org.apache.iceberg.relocated.com.google.common.collect.ImmutableMap;
import org.apache.iceberg.spark.SparkTableUtil.SparkPartition;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Test;
@@ -40,7 +41,7 @@ public class TestSparkTableUtil {
SparkPartition sparkPartition = new SparkPartition(values, uri, format);
SparkPartition deserialized = KryoHelpers.roundTripSerialize(sparkPartition);
- Assertions.assertThat(sparkPartition).isEqualTo(deserialized);
+ assertThat(sparkPartition).isEqualTo(deserialized);
}
@Test
@@ -51,7 +52,7 @@ public class TestSparkTableUtil {
SparkPartition sparkPartition = new SparkPartition(values, uri, format);
SparkPartition deserialized = TestHelpers.roundTripSerialize(sparkPartition);
- Assertions.assertThat(sparkPartition).isEqualTo(deserialized);
+ assertThat(sparkPartition).isEqualTo(deserialized);
}
@Test
diff --git a/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/TestSparkV2Filters.java b/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/TestSparkV2Filters.java
index 2a40e6e50f..eae8a6ec02 100644
--- a/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/TestSparkV2Filters.java
+++ b/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/TestSparkV2Filters.java
@@ -18,6 +18,9 @@
*/
package org.apache.iceberg.spark;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
import java.time.Instant;
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
@@ -49,7 +52,6 @@ import org.apache.spark.sql.types.DataType;
import org.apache.spark.sql.types.DataTypes;
import org.apache.spark.sql.types.StructType;
import org.apache.spark.unsafe.types.UTF8String;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Test;
@@ -238,23 +240,23 @@ public class TestSparkV2Filters {
new org.apache.spark.sql.connector.expressions.Expression[] {value, namedReference};
Predicate eq1 = new Predicate("=", attrAndValue);
- Assertions.assertThatThrownBy(() -> SparkV2Filters.convert(eq1))
+ assertThatThrownBy(() -> SparkV2Filters.convert(eq1))
.isInstanceOf(NullPointerException.class)
.hasMessageContaining("Expression is always false");
Predicate eq2 = new Predicate("=", valueAndAttr);
- Assertions.assertThatThrownBy(() -> SparkV2Filters.convert(eq2))
+ assertThatThrownBy(() -> SparkV2Filters.convert(eq2))
.isInstanceOf(NullPointerException.class)
.hasMessageContaining("Expression is always false");
Predicate eqNullSafe1 = new Predicate("<=>", attrAndValue);
Expression expectedEqNullSafe = Expressions.isNull(col);
Expression actualEqNullSafe1 = SparkV2Filters.convert(eqNullSafe1);
- Assertions.assertThat(actualEqNullSafe1.toString()).isEqualTo(expectedEqNullSafe.toString());
+ assertThat(actualEqNullSafe1.toString()).isEqualTo(expectedEqNullSafe.toString());
Predicate eqNullSafe2 = new Predicate("<=>", valueAndAttr);
Expression actualEqNullSafe2 = SparkV2Filters.convert(eqNullSafe2);
- Assertions.assertThat(actualEqNullSafe2.toString()).isEqualTo(expectedEqNullSafe.toString());
+ assertThat(actualEqNullSafe2.toString()).isEqualTo(expectedEqNullSafe.toString());
}
@Test
@@ -271,11 +273,11 @@ public class TestSparkV2Filters {
Predicate eqNaN1 = new Predicate("=", attrAndValue);
Expression expectedEqNaN = Expressions.isNaN(col);
Expression actualEqNaN1 = SparkV2Filters.convert(eqNaN1);
- Assertions.assertThat(actualEqNaN1.toString()).isEqualTo(expectedEqNaN.toString());
+ assertThat(actualEqNaN1.toString()).isEqualTo(expectedEqNaN.toString());
Predicate eqNaN2 = new Predicate("=", valueAndAttr);
Expression actualEqNaN2 = SparkV2Filters.convert(eqNaN2);
- Assertions.assertThat(actualEqNaN2.toString()).isEqualTo(expectedEqNaN.toString());
+ assertThat(actualEqNaN2.toString()).isEqualTo(expectedEqNaN.toString());
}
@Test
@@ -290,12 +292,12 @@ public class TestSparkV2Filters {
new org.apache.spark.sql.connector.expressions.Expression[] {value, namedReference};
Predicate notEq1 = new Predicate("<>", attrAndValue);
- Assertions.assertThatThrownBy(() -> SparkV2Filters.convert(notEq1))
+ assertThatThrownBy(() -> SparkV2Filters.convert(notEq1))
.isInstanceOf(NullPointerException.class)
.hasMessageContaining("Expression is always false");
Predicate notEq2 = new Predicate("<>", valueAndAttr);
- Assertions.assertThatThrownBy(() -> SparkV2Filters.convert(notEq2))
+ assertThatThrownBy(() -> SparkV2Filters.convert(notEq2))
.isInstanceOf(NullPointerException.class)
.hasMessageContaining("Expression is always false");
}
@@ -314,11 +316,11 @@ public class TestSparkV2Filters {
Predicate notEqNaN1 = new Predicate("<>", attrAndValue);
Expression expectedNotEqNaN = Expressions.notNaN(col);
Expression actualNotEqNaN1 = SparkV2Filters.convert(notEqNaN1);
- Assertions.assertThat(actualNotEqNaN1.toString()).isEqualTo(expectedNotEqNaN.toString());
+ assertThat(actualNotEqNaN1.toString()).isEqualTo(expectedNotEqNaN.toString());
Predicate notEqNaN2 = new Predicate("<>", valueAndAttr);
Expression actualNotEqNaN2 = SparkV2Filters.convert(notEqNaN2);
- Assertions.assertThat(actualNotEqNaN2.toString()).isEqualTo(expectedNotEqNaN.toString());
+ assertThat(actualNotEqNaN2.toString()).isEqualTo(expectedNotEqNaN.toString());
}
@Test
@@ -630,7 +632,7 @@ public class TestSparkV2Filters {
Predicate predicate = new Predicate("=", expressions(udf, literalValue));
Expression icebergExpr = SparkV2Filters.convert(predicate);
- Assertions.assertThat(icebergExpr).isNull();
+ assertThat(icebergExpr).isNull();
}
private <T> void testUDF(
@@ -746,7 +748,7 @@ public class TestSparkV2Filters {
Predicate invalid = new Predicate("<", attrAndAttr);
Predicate andWithInvalidLeft = new And(invalid, eq1);
Expression convertedAnd = SparkV2Filters.convert(andWithInvalidLeft);
- Assertions.assertThat(convertedAnd).isNull();
+ assertThat(convertedAnd).isNull();
Predicate or = new Or(lt1, eq1);
Expression expectedOr = Expressions.or(expectedLt1, expectedEq1);
@@ -755,7 +757,7 @@ public class TestSparkV2Filters {
Predicate orWithInvalidLeft = new Or(invalid, eq1);
Expression convertedOr = SparkV2Filters.convert(orWithInvalidLeft);
- Assertions.assertThat(convertedOr).isNull();
+ assertThat(convertedOr).isNull();
Predicate not = new Not(lt1);
Expression expectedNot = Expressions.not(expectedLt1);
@@ -764,7 +766,7 @@ public class TestSparkV2Filters {
}
private static void assertEquals(Expression expected, Expression actual) {
- Assertions.assertThat(ExpressionUtil.equivalent(expected, actual, STRUCT, true)).isTrue();
+ assertThat(ExpressionUtil.equivalent(expected, actual, STRUCT, true)).isTrue();
}
private org.apache.spark.sql.connector.expressions.Expression[] expressions(
diff --git a/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/actions/TestDeleteReachableFilesAction.java b/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/actions/TestDeleteReachableFilesAction.java
index 3844052655..97843c1528 100644
--- a/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/actions/TestDeleteReachableFilesAction.java
+++ b/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/actions/TestDeleteReachableFilesAction.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.actions;
import static org.apache.iceberg.types.Types.NestedField.optional;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.File;
import java.util.Set;
@@ -50,7 +51,6 @@ import org.apache.iceberg.relocated.com.google.common.collect.Maps;
import org.apache.iceberg.relocated.com.google.common.collect.Sets;
import org.apache.iceberg.spark.SparkTestBase;
import org.apache.iceberg.types.Types;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
@@ -363,7 +363,7 @@ public class TestDeleteReachableFilesAction extends SparkTestBase {
DeleteReachableFiles baseRemoveFilesSparkAction =
sparkActions().deleteReachableFiles(metadataLocation(table)).io(null);
- Assertions.assertThatThrownBy(baseRemoveFilesSparkAction::execute)
+ assertThatThrownBy(baseRemoveFilesSparkAction::execute)
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("File IO cannot be null");
}
@@ -372,8 +372,7 @@ public class TestDeleteReachableFilesAction extends SparkTestBase {
public void testRemoveFilesActionWhenGarbageCollectionDisabled() {
table.updateProperties().set(TableProperties.GC_ENABLED, "false").commit();
- Assertions.assertThatThrownBy(
- () -> sparkActions().deleteReachableFiles(metadataLocation(table)).execute())
+ assertThatThrownBy(() -> sparkActions().deleteReachableFiles(metadataLocation(table)).execute())
.isInstanceOf(ValidationException.class)
.hasMessage(
"Cannot delete files: GC is disabled (deleting files may corrupt other tables)");
diff --git a/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/actions/TestExpireSnapshotsAction.java b/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/actions/TestExpireSnapshotsAction.java
index d5ac1b8064..7a74329f35 100644
--- a/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/actions/TestExpireSnapshotsAction.java
+++ b/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/actions/TestExpireSnapshotsAction.java
@@ -19,6 +19,7 @@
package org.apache.iceberg.spark.actions;
import static org.apache.iceberg.types.Types.NestedField.optional;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.File;
import java.io.IOException;
@@ -56,7 +57,6 @@ import org.apache.iceberg.spark.SparkTestBase;
import org.apache.iceberg.spark.data.TestHelpers;
import org.apache.iceberg.types.Types;
import org.apache.spark.sql.Dataset;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
@@ -447,7 +447,7 @@ public class TestExpireSnapshotsAction extends SparkTestBase {
table.newAppend().appendFile(FILE_A).commit();
- Assertions.assertThatThrownBy(() -> SparkActions.get().expireSnapshots(table))
+ assertThatThrownBy(() -> SparkActions.get().expireSnapshots(table))
.isInstanceOf(ValidationException.class)
.hasMessage(
"Cannot expire snapshots: GC is disabled (deleting files may corrupt other tables)");
@@ -528,8 +528,7 @@ public class TestExpireSnapshotsAction extends SparkTestBase {
@Test
public void testRetainZeroSnapshots() {
- Assertions.assertThatThrownBy(
- () -> SparkActions.get().expireSnapshots(table).retainLast(0).execute())
+ assertThatThrownBy(() -> SparkActions.get().expireSnapshots(table).retainLast(0).execute())
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Number of snapshots to retain must be at least 1, cannot be: 0");
}
diff --git a/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/actions/TestRemoveOrphanFilesAction.java b/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/actions/TestRemoveOrphanFilesAction.java
index a0caacd6d2..60bc9ca60f 100644
--- a/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/actions/TestRemoveOrphanFilesAction.java
+++ b/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/actions/TestRemoveOrphanFilesAction.java
@@ -19,6 +19,8 @@
package org.apache.iceberg.spark.actions;
import static org.apache.iceberg.types.Types.NestedField.optional;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.File;
import java.io.IOException;
@@ -78,7 +80,6 @@ import org.apache.spark.sql.Row;
import org.apache.spark.sql.RowFactory;
import org.apache.spark.sql.types.DataTypes;
import org.apache.spark.sql.types.StructType;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
@@ -750,7 +751,7 @@ public abstract class TestRemoveOrphanFilesAction extends SparkTestBase {
table.updateProperties().set(TableProperties.GC_ENABLED, "false").commit();
- Assertions.assertThatThrownBy(() -> SparkActions.get().deleteOrphanFiles(table).execute())
+ assertThatThrownBy(() -> SparkActions.get().deleteOrphanFiles(table).execute())
.isInstanceOf(ValidationException.class)
.hasMessage(
"Cannot delete orphan files: GC is disabled (deleting files may corrupt other tables)");
@@ -938,8 +939,8 @@ public abstract class TestRemoveOrphanFilesAction extends SparkTestBase {
.olderThan(System.currentTimeMillis() + 1000)
.execute();
- Assertions.assertThat(statsLocation.exists()).as("stats file should exist").isTrue();
- Assertions.assertThat(statsLocation.length())
+ assertThat(statsLocation.exists()).as("stats file should exist").isTrue();
+ assertThat(statsLocation.length())
.as("stats file length")
.isEqualTo(statisticsFile.fileSizeInBytes());
@@ -953,11 +954,11 @@ public abstract class TestRemoveOrphanFilesAction extends SparkTestBase {
.olderThan(System.currentTimeMillis() + 1000)
.execute();
Iterable<String> orphanFileLocations = result.orphanFileLocations();
- Assertions.assertThat(orphanFileLocations).as("Should be orphan files").hasSize(1);
- Assertions.assertThat(Iterables.getOnlyElement(orphanFileLocations))
+ assertThat(orphanFileLocations).as("Should be orphan files").hasSize(1);
+ assertThat(Iterables.getOnlyElement(orphanFileLocations))
.as("Deleted file")
.isEqualTo(statsLocation.toURI().toString());
- Assertions.assertThat(statsLocation.exists()).as("stats file should be deleted").isFalse();
+ assertThat(statsLocation.exists()).as("stats file should be deleted").isFalse();
}
@Test
@@ -985,7 +986,7 @@ public abstract class TestRemoveOrphanFilesAction extends SparkTestBase {
public void testPathsWithEqualSchemes() {
List<String> validFiles = Lists.newArrayList("scheme1://bucket1/dir1/dir2/file1");
List<String> actualFiles = Lists.newArrayList("scheme2://bucket1/dir1/dir2/file1");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
executeTest(
validFiles,
@@ -1014,7 +1015,7 @@ public abstract class TestRemoveOrphanFilesAction extends SparkTestBase {
public void testPathsWithEqualAuthorities() {
List<String> validFiles = Lists.newArrayList("hdfs://servicename1/dir1/dir2/file1");
List<String> actualFiles = Lists.newArrayList("hdfs://servicename2/dir1/dir2/file1");
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
executeTest(
validFiles,
diff --git a/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/actions/TestRewriteDataFilesAction.java b/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/actions/TestRewriteDataFilesAction.java
index 0eea495323..66f16437f5 100644
--- a/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/actions/TestRewriteDataFilesAction.java
+++ b/spark/v3.4/spark/src/test/java/org/apache/iceberg/spark/actions/TestRewriteDataFilesAction.java
@@ -25,6 +25,7 @@ import static org.apache.spark.sql.functions.current_date;
import static org.apache.spark.sql.functions.date_add;
import static org.apache.spark.sql.functions.expr;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.doAnswer;
@@ -107,7 +108,6 @@ import org.apache.iceberg.util.StructLikeMap;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.internal.SQLConf;
-import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
@@ -677,7 +677,7 @@ public class TestRewriteDataFilesAction extends SparkTestBase {
.when(spyRewrite)
.rewriteFiles(any(), argThat(failGroup));
- Assertions.assertThatThrownBy(spyRewrite::execute)
+ assertThatThrownBy(spyRewrite::execute)
.isInstanceOf(RuntimeException.class)
.hasMessage("Rewrite Failed");
@@ -711,7 +711,7 @@ public class TestRewriteDataFilesAction extends SparkTestBase {
doReturn(util).when(spyRewrite).commitManager(table.currentSnapshot().snapshotId());
- Assertions.assertThatThrownBy(spyRewrite::execute)
+ assertThatThrownBy(spyRewrite::execute)
.isInstanceOf(RuntimeException.class)
.hasMessage("Commit Failure");
@@ -746,7 +746,7 @@ public class TestRewriteDataFilesAction extends SparkTestBase {
.when(spyRewrite)
.rewriteFiles(any(), argThat(failGroup));
- Assertions.assertThatThrownBy(spyRewrite::execute)
+ assertThatThrownBy(spyRewrite::execute)
.isInstanceOf(RuntimeException.class)
.hasMessage("Rewrite Failed");
@@ -894,7 +894,7 @@ public class TestRewriteDataFilesAction extends SparkTestBase {
public void testInvalidOptions() {
Table table = createTable(20);
- Assertions.assertThatThrownBy(
+ assertThatThrownBy(
() ->
basicRewrite(table)
... 6893 lines suppressed ...