From d01d9a26dc867b2e78192c89149626fad88a1a81 Mon Sep 17 00:00:00 2001 From: yuxiqian <34335406+yuxiqian@users.noreply.github.com> Date: Thu, 13 Jun 2024 16:55:13 +0800 Subject: [PATCH] Migrate to JUnit 5 & AssertJ --- .../cdc/common/utils/SchemaUtilsTest.java | 570 +++++++++--------- .../runtime/parser/TransformParserTest.java | 116 ++-- 2 files changed, 348 insertions(+), 338 deletions(-) diff --git a/flink-cdc-common/src/test/java/org/apache/flink/cdc/common/utils/SchemaUtilsTest.java b/flink-cdc-common/src/test/java/org/apache/flink/cdc/common/utils/SchemaUtilsTest.java index 126ef90b6c0..726e3f1c2a2 100644 --- a/flink-cdc-common/src/test/java/org/apache/flink/cdc/common/utils/SchemaUtilsTest.java +++ b/flink-cdc-common/src/test/java/org/apache/flink/cdc/common/utils/SchemaUtilsTest.java @@ -27,8 +27,8 @@ import org.apache.flink.cdc.common.types.DataType; import org.apache.flink.cdc.common.types.DataTypes; -import org.junit.Assert; -import org.junit.Test; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.Test; import java.util.ArrayList; import java.util.Arrays; @@ -55,13 +55,13 @@ public void testApplySchemaChangeEvent() { Column.physicalColumn("col3", DataTypes.STRING()))); AddColumnEvent addColumnEvent = new AddColumnEvent(tableId, addedColumns); schema = SchemaUtils.applySchemaChangeEvent(schema, addColumnEvent); - Assert.assertEquals( - schema, - Schema.newBuilder() - .physicalColumn("col1", DataTypes.STRING()) - .physicalColumn("col2", DataTypes.STRING()) - .physicalColumn("col3", DataTypes.STRING()) - .build()); + Assertions.assertThat(schema) + .isEqualTo( + Schema.newBuilder() + .physicalColumn("col1", DataTypes.STRING()) + .physicalColumn("col2", DataTypes.STRING()) + .physicalColumn("col3", DataTypes.STRING()) + .build()); // add new column before existed column addedColumns = new ArrayList<>(); @@ -72,14 +72,14 @@ public void testApplySchemaChangeEvent() { "col3")); addColumnEvent = new AddColumnEvent(tableId, addedColumns); schema = SchemaUtils.applySchemaChangeEvent(schema, addColumnEvent); - Assert.assertEquals( - schema, - Schema.newBuilder() - .physicalColumn("col1", DataTypes.STRING()) - .physicalColumn("col2", DataTypes.STRING()) - .physicalColumn("col4", DataTypes.STRING()) - .physicalColumn("col3", DataTypes.STRING()) - .build()); + Assertions.assertThat(schema) + .isEqualTo( + Schema.newBuilder() + .physicalColumn("col1", DataTypes.STRING()) + .physicalColumn("col2", DataTypes.STRING()) + .physicalColumn("col4", DataTypes.STRING()) + .physicalColumn("col3", DataTypes.STRING()) + .build()); // add new column after existed column addedColumns = new ArrayList<>(); @@ -90,15 +90,15 @@ public void testApplySchemaChangeEvent() { "col4")); addColumnEvent = new AddColumnEvent(tableId, addedColumns); schema = SchemaUtils.applySchemaChangeEvent(schema, addColumnEvent); - Assert.assertEquals( - schema, - Schema.newBuilder() - .physicalColumn("col1", DataTypes.STRING()) - .physicalColumn("col2", DataTypes.STRING()) - .physicalColumn("col4", DataTypes.STRING()) - .physicalColumn("col5", DataTypes.STRING()) - .physicalColumn("col3", DataTypes.STRING()) - .build()); + Assertions.assertThat(schema) + .isEqualTo( + Schema.newBuilder() + .physicalColumn("col1", DataTypes.STRING()) + .physicalColumn("col2", DataTypes.STRING()) + .physicalColumn("col4", DataTypes.STRING()) + .physicalColumn("col5", DataTypes.STRING()) + .physicalColumn("col3", DataTypes.STRING()) + .build()); // add column in first position addedColumns = new ArrayList<>(); @@ -109,29 +109,29 @@ public void testApplySchemaChangeEvent() { null)); addColumnEvent = new AddColumnEvent(tableId, addedColumns); schema = SchemaUtils.applySchemaChangeEvent(schema, addColumnEvent); - Assert.assertEquals( - schema, - Schema.newBuilder() - .physicalColumn("col0", DataTypes.STRING()) - .physicalColumn("col1", DataTypes.STRING()) - .physicalColumn("col2", DataTypes.STRING()) - .physicalColumn("col4", DataTypes.STRING()) - .physicalColumn("col5", DataTypes.STRING()) - .physicalColumn("col3", DataTypes.STRING()) - .build()); + Assertions.assertThat(schema) + .isEqualTo( + Schema.newBuilder() + .physicalColumn("col0", DataTypes.STRING()) + .physicalColumn("col1", DataTypes.STRING()) + .physicalColumn("col2", DataTypes.STRING()) + .physicalColumn("col4", DataTypes.STRING()) + .physicalColumn("col5", DataTypes.STRING()) + .physicalColumn("col3", DataTypes.STRING()) + .build()); // drop columns DropColumnEvent dropColumnEvent = new DropColumnEvent(tableId, Arrays.asList("col3", "col5")); schema = SchemaUtils.applySchemaChangeEvent(schema, dropColumnEvent); - Assert.assertEquals( - schema, - Schema.newBuilder() - .physicalColumn("col0", DataTypes.STRING()) - .physicalColumn("col1", DataTypes.STRING()) - .physicalColumn("col2", DataTypes.STRING()) - .physicalColumn("col4", DataTypes.STRING()) - .build()); + Assertions.assertThat(schema) + .isEqualTo( + Schema.newBuilder() + .physicalColumn("col0", DataTypes.STRING()) + .physicalColumn("col1", DataTypes.STRING()) + .physicalColumn("col2", DataTypes.STRING()) + .physicalColumn("col4", DataTypes.STRING()) + .build()); // rename columns Map nameMapping = new HashMap<>(); @@ -139,14 +139,14 @@ public void testApplySchemaChangeEvent() { nameMapping.put("col4", "newCol4"); RenameColumnEvent renameColumnEvent = new RenameColumnEvent(tableId, nameMapping); schema = SchemaUtils.applySchemaChangeEvent(schema, renameColumnEvent); - Assert.assertEquals( - schema, - Schema.newBuilder() - .physicalColumn("col0", DataTypes.STRING()) - .physicalColumn("col1", DataTypes.STRING()) - .physicalColumn("newCol2", DataTypes.STRING()) - .physicalColumn("newCol4", DataTypes.STRING()) - .build()); + Assertions.assertThat(schema) + .isEqualTo( + Schema.newBuilder() + .physicalColumn("col0", DataTypes.STRING()) + .physicalColumn("col1", DataTypes.STRING()) + .physicalColumn("newCol2", DataTypes.STRING()) + .physicalColumn("newCol4", DataTypes.STRING()) + .build()); // alter column types Map typeMapping = new HashMap<>(); @@ -154,212 +154,191 @@ public void testApplySchemaChangeEvent() { typeMapping.put("newCol4", DataTypes.VARCHAR(10)); AlterColumnTypeEvent alterColumnTypeEvent = new AlterColumnTypeEvent(tableId, typeMapping); schema = SchemaUtils.applySchemaChangeEvent(schema, alterColumnTypeEvent); - Assert.assertEquals( - schema, - Schema.newBuilder() - .physicalColumn("col0", DataTypes.STRING()) - .physicalColumn("col1", DataTypes.STRING()) - .physicalColumn("newCol2", DataTypes.VARCHAR(10)) - .physicalColumn("newCol4", DataTypes.VARCHAR(10)) - .build()); + Assertions.assertThat(schema) + .isEqualTo( + Schema.newBuilder() + .physicalColumn("col0", DataTypes.STRING()) + .physicalColumn("col1", DataTypes.STRING()) + .physicalColumn("newCol2", DataTypes.VARCHAR(10)) + .physicalColumn("newCol4", DataTypes.VARCHAR(10)) + .build()); } @Test public void testGetNumericPrecision() { - Assert.assertEquals(SchemaUtils.getNumericPrecision(DataTypes.TINYINT()), 3); - Assert.assertEquals(SchemaUtils.getNumericPrecision(DataTypes.SMALLINT()), 5); - Assert.assertEquals(SchemaUtils.getNumericPrecision(DataTypes.INT()), 10); - Assert.assertEquals(SchemaUtils.getNumericPrecision(DataTypes.BIGINT()), 19); - Assert.assertEquals(SchemaUtils.getNumericPrecision(DataTypes.DECIMAL(10, 2)), 10); - Assert.assertEquals(SchemaUtils.getNumericPrecision(DataTypes.DECIMAL(17, 0)), 17); - Assert.assertThrows( - IllegalArgumentException.class, - () -> SchemaUtils.getNumericPrecision(DataTypes.STRING())); + Assertions.assertThat(SchemaUtils.getNumericPrecision(DataTypes.TINYINT())).isEqualTo(3); + Assertions.assertThat(SchemaUtils.getNumericPrecision(DataTypes.SMALLINT())).isEqualTo(5); + Assertions.assertThat(SchemaUtils.getNumericPrecision(DataTypes.INT())).isEqualTo(10); + Assertions.assertThat(SchemaUtils.getNumericPrecision(DataTypes.BIGINT())).isEqualTo(19); + Assertions.assertThat(SchemaUtils.getNumericPrecision(DataTypes.DECIMAL(10, 2))) + .isEqualTo(10); + Assertions.assertThat(SchemaUtils.getNumericPrecision(DataTypes.DECIMAL(17, 0))) + .isEqualTo(17); + Assertions.assertThatThrownBy(() -> SchemaUtils.getNumericPrecision(DataTypes.STRING())) + .isExactlyInstanceOf(IllegalArgumentException.class) + .hasMessageContaining("Failed to get precision of non-exact decimal type"); } @Test public void testMergeDataType() { - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.BINARY(17), DataTypes.BINARY(17)), - DataTypes.BINARY(17)); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.VARBINARY(17), DataTypes.VARBINARY(17)), - DataTypes.VARBINARY(17)); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.BYTES(), DataTypes.BYTES()), DataTypes.BYTES()); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.BOOLEAN(), DataTypes.BOOLEAN()), - DataTypes.BOOLEAN()); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.INT(), DataTypes.INT()), DataTypes.INT()); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.TINYINT(), DataTypes.TINYINT()), - DataTypes.TINYINT()); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.SMALLINT(), DataTypes.SMALLINT()), - DataTypes.SMALLINT()); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.BIGINT(), DataTypes.BIGINT()), - DataTypes.BIGINT()); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.FLOAT(), DataTypes.FLOAT()), DataTypes.FLOAT()); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.DOUBLE(), DataTypes.DOUBLE()), - DataTypes.DOUBLE()); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.CHAR(17), DataTypes.CHAR(17)), - DataTypes.CHAR(17)); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.VARCHAR(17), DataTypes.VARCHAR(17)), - DataTypes.VARCHAR(17)); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.STRING(), DataTypes.STRING()), - DataTypes.STRING()); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.DECIMAL(17, 7), DataTypes.DECIMAL(17, 7)), - DataTypes.DECIMAL(17, 7)); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.DATE(), DataTypes.DATE()), DataTypes.DATE()); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.TIME(), DataTypes.TIME()), DataTypes.TIME()); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.TIME(6), DataTypes.TIME(6)), DataTypes.TIME(6)); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.TIMESTAMP(), DataTypes.TIMESTAMP()), - DataTypes.TIMESTAMP()); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.TIMESTAMP(3), DataTypes.TIMESTAMP(3)), - DataTypes.TIMESTAMP(3)); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.TIMESTAMP_TZ(), DataTypes.TIMESTAMP_TZ()), - DataTypes.TIMESTAMP_TZ()); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.TIMESTAMP_TZ(3), DataTypes.TIMESTAMP_TZ(3)), - DataTypes.TIMESTAMP_TZ(3)); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.TIMESTAMP_LTZ(), DataTypes.TIMESTAMP_LTZ()), - DataTypes.TIMESTAMP_LTZ()); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.TIMESTAMP_LTZ(3), DataTypes.TIMESTAMP_LTZ(3)), - DataTypes.TIMESTAMP_LTZ(3)); - Assert.assertEquals( - SchemaUtils.mergeDataType( - DataTypes.ARRAY(DataTypes.INT()), DataTypes.ARRAY(DataTypes.INT())), - DataTypes.ARRAY(DataTypes.INT())); - Assert.assertEquals( - SchemaUtils.mergeDataType( - DataTypes.MAP(DataTypes.INT(), DataTypes.STRING()), - DataTypes.MAP(DataTypes.INT(), DataTypes.STRING())), - DataTypes.MAP(DataTypes.INT(), DataTypes.STRING())); + Assertions.assertThat(SchemaUtils.mergeDataType(DataTypes.BINARY(17), DataTypes.BINARY(17))) + .isEqualTo(DataTypes.BINARY(17)); + Assertions.assertThat( + SchemaUtils.mergeDataType(DataTypes.VARBINARY(17), DataTypes.VARBINARY(17))) + .isEqualTo(DataTypes.VARBINARY(17)); + Assertions.assertThat(SchemaUtils.mergeDataType(DataTypes.BYTES(), DataTypes.BYTES())) + .isEqualTo(DataTypes.BYTES()); + Assertions.assertThat(SchemaUtils.mergeDataType(DataTypes.BOOLEAN(), DataTypes.BOOLEAN())) + .isEqualTo(DataTypes.BOOLEAN()); + Assertions.assertThat(SchemaUtils.mergeDataType(DataTypes.INT(), DataTypes.INT())) + .isEqualTo(DataTypes.INT()); + Assertions.assertThat(SchemaUtils.mergeDataType(DataTypes.TINYINT(), DataTypes.TINYINT())) + .isEqualTo(DataTypes.TINYINT()); + Assertions.assertThat(SchemaUtils.mergeDataType(DataTypes.SMALLINT(), DataTypes.SMALLINT())) + .isEqualTo(DataTypes.SMALLINT()); + Assertions.assertThat(SchemaUtils.mergeDataType(DataTypes.BIGINT(), DataTypes.BIGINT())) + .isEqualTo(DataTypes.BIGINT()); + Assertions.assertThat(SchemaUtils.mergeDataType(DataTypes.FLOAT(), DataTypes.FLOAT())) + .isEqualTo(DataTypes.FLOAT()); + Assertions.assertThat(SchemaUtils.mergeDataType(DataTypes.DOUBLE(), DataTypes.DOUBLE())) + .isEqualTo(DataTypes.DOUBLE()); + Assertions.assertThat(SchemaUtils.mergeDataType(DataTypes.CHAR(17), DataTypes.CHAR(17))) + .isEqualTo(DataTypes.CHAR(17)); + Assertions.assertThat( + SchemaUtils.mergeDataType(DataTypes.VARCHAR(17), DataTypes.VARCHAR(17))) + .isEqualTo(DataTypes.VARCHAR(17)); + Assertions.assertThat(SchemaUtils.mergeDataType(DataTypes.STRING(), DataTypes.STRING())) + .isEqualTo(DataTypes.STRING()); + Assertions.assertThat( + SchemaUtils.mergeDataType( + DataTypes.DECIMAL(17, 7), DataTypes.DECIMAL(17, 7))) + .isEqualTo(DataTypes.DECIMAL(17, 7)); + Assertions.assertThat(SchemaUtils.mergeDataType(DataTypes.DATE(), DataTypes.DATE())) + .isEqualTo(DataTypes.DATE()); + Assertions.assertThat(SchemaUtils.mergeDataType(DataTypes.TIME(), DataTypes.TIME())) + .isEqualTo(DataTypes.TIME()); + Assertions.assertThat(SchemaUtils.mergeDataType(DataTypes.TIME(6), DataTypes.TIME(6))) + .isEqualTo(DataTypes.TIME(6)); + Assertions.assertThat( + SchemaUtils.mergeDataType(DataTypes.TIMESTAMP(), DataTypes.TIMESTAMP())) + .isEqualTo(DataTypes.TIMESTAMP()); + Assertions.assertThat( + SchemaUtils.mergeDataType(DataTypes.TIMESTAMP(3), DataTypes.TIMESTAMP(3))) + .isEqualTo(DataTypes.TIMESTAMP(3)); + Assertions.assertThat( + SchemaUtils.mergeDataType( + DataTypes.TIMESTAMP_TZ(), DataTypes.TIMESTAMP_TZ())) + .isEqualTo(DataTypes.TIMESTAMP_TZ()); + Assertions.assertThat( + SchemaUtils.mergeDataType( + DataTypes.TIMESTAMP_TZ(3), DataTypes.TIMESTAMP_TZ(3))) + .isEqualTo(DataTypes.TIMESTAMP_TZ(3)); + Assertions.assertThat( + SchemaUtils.mergeDataType( + DataTypes.TIMESTAMP_LTZ(), DataTypes.TIMESTAMP_LTZ())) + .isEqualTo(DataTypes.TIMESTAMP_LTZ()); + Assertions.assertThat( + SchemaUtils.mergeDataType( + DataTypes.TIMESTAMP_LTZ(3), DataTypes.TIMESTAMP_LTZ(3))) + .isEqualTo(DataTypes.TIMESTAMP_LTZ(3)); + Assertions.assertThat( + SchemaUtils.mergeDataType( + DataTypes.ARRAY(DataTypes.INT()), DataTypes.ARRAY(DataTypes.INT()))) + .isEqualTo(DataTypes.ARRAY(DataTypes.INT())); + Assertions.assertThat( + SchemaUtils.mergeDataType( + DataTypes.MAP(DataTypes.INT(), DataTypes.STRING()), + DataTypes.MAP(DataTypes.INT(), DataTypes.STRING()))) + .isEqualTo(DataTypes.MAP(DataTypes.INT(), DataTypes.STRING())); // Test compatible widening cast - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.INT(), DataTypes.BIGINT()), DataTypes.BIGINT()); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.VARCHAR(17), DataTypes.STRING()), - DataTypes.STRING()); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.FLOAT(), DataTypes.DOUBLE()), - DataTypes.DOUBLE()); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.INT(), DataTypes.DECIMAL(4, 0)), - DataTypes.DECIMAL(10, 0)); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.INT(), DataTypes.DECIMAL(10, 5)), - DataTypes.DECIMAL(15, 5)); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.BIGINT(), DataTypes.DECIMAL(10, 5)), - DataTypes.DECIMAL(24, 5)); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.DECIMAL(5, 4), DataTypes.DECIMAL(10, 2)), - DataTypes.DECIMAL(12, 4)); + Assertions.assertThat(SchemaUtils.mergeDataType(DataTypes.INT(), DataTypes.BIGINT())) + .isEqualTo(DataTypes.BIGINT()); + Assertions.assertThat(SchemaUtils.mergeDataType(DataTypes.VARCHAR(17), DataTypes.STRING())) + .isEqualTo(DataTypes.STRING()); + Assertions.assertThat(SchemaUtils.mergeDataType(DataTypes.FLOAT(), DataTypes.DOUBLE())) + .isEqualTo(DataTypes.DOUBLE()); + Assertions.assertThat(SchemaUtils.mergeDataType(DataTypes.INT(), DataTypes.DECIMAL(4, 0))) + .isEqualTo(DataTypes.DECIMAL(10, 0)); + Assertions.assertThat(SchemaUtils.mergeDataType(DataTypes.INT(), DataTypes.DECIMAL(10, 5))) + .isEqualTo(DataTypes.DECIMAL(15, 5)); + Assertions.assertThat( + SchemaUtils.mergeDataType(DataTypes.BIGINT(), DataTypes.DECIMAL(10, 5))) + .isEqualTo(DataTypes.DECIMAL(24, 5)); + Assertions.assertThat( + SchemaUtils.mergeDataType( + DataTypes.DECIMAL(5, 4), DataTypes.DECIMAL(10, 2))) + .isEqualTo(DataTypes.DECIMAL(12, 4)); // Test merging with nullability - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.INT().notNull(), DataTypes.INT().notNull()), - DataTypes.INT().notNull()); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.INT().nullable(), DataTypes.INT().notNull()), - DataTypes.INT().nullable()); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.INT().notNull(), DataTypes.INT().nullable()), - DataTypes.INT().nullable()); - Assert.assertEquals( - SchemaUtils.mergeDataType(DataTypes.INT().nullable(), DataTypes.INT().nullable()), - DataTypes.INT().nullable()); + Assertions.assertThat( + SchemaUtils.mergeDataType( + DataTypes.INT().notNull(), DataTypes.INT().notNull())) + .isEqualTo(DataTypes.INT().notNull()); + Assertions.assertThat( + SchemaUtils.mergeDataType( + DataTypes.INT().nullable(), DataTypes.INT().notNull())) + .isEqualTo(DataTypes.INT().nullable()); + Assertions.assertThat( + SchemaUtils.mergeDataType( + DataTypes.INT().notNull(), DataTypes.INT().nullable())) + .isEqualTo(DataTypes.INT().nullable()); + Assertions.assertThat( + SchemaUtils.mergeDataType( + DataTypes.INT().nullable(), DataTypes.INT().nullable())) + .isEqualTo(DataTypes.INT().nullable()); // incompatible type merges test - Assert.assertThrows( - IllegalStateException.class, - () -> SchemaUtils.mergeDataType(DataTypes.INT(), DataTypes.DOUBLE())); - Assert.assertThrows( - IllegalStateException.class, - () -> SchemaUtils.mergeDataType(DataTypes.DECIMAL(17, 0), DataTypes.DOUBLE())); - Assert.assertThrows( - IllegalStateException.class, - () -> SchemaUtils.mergeDataType(DataTypes.INT(), DataTypes.STRING())); + Assertions.assertThatThrownBy( + () -> SchemaUtils.mergeDataType(DataTypes.INT(), DataTypes.DOUBLE())) + .isExactlyInstanceOf(IllegalStateException.class); + + Assertions.assertThatThrownBy( + () -> + SchemaUtils.mergeDataType( + DataTypes.DECIMAL(17, 0), DataTypes.DOUBLE())) + .isExactlyInstanceOf(IllegalStateException.class); + Assertions.assertThatThrownBy( + () -> SchemaUtils.mergeDataType(DataTypes.INT(), DataTypes.STRING())) + .isExactlyInstanceOf(IllegalStateException.class); } @Test public void testMergeColumn() { // Test normal merges - Assert.assertEquals( - SchemaUtils.mergeColumn( - Column.physicalColumn("Column1", DataTypes.INT()), - Column.physicalColumn("Column1", DataTypes.BIGINT())), - Column.physicalColumn("Column1", DataTypes.BIGINT())); + Assertions.assertThat( + SchemaUtils.mergeColumn( + Column.physicalColumn("Column1", DataTypes.INT()), + Column.physicalColumn("Column1", DataTypes.BIGINT()))) + .isEqualTo(Column.physicalColumn("Column1", DataTypes.BIGINT())); - Assert.assertEquals( - SchemaUtils.mergeColumn( - Column.physicalColumn("Column2", DataTypes.FLOAT()), - Column.physicalColumn("Column2", DataTypes.DOUBLE())), - Column.physicalColumn("Column2", DataTypes.DOUBLE())); + Assertions.assertThat( + SchemaUtils.mergeColumn( + Column.physicalColumn("Column2", DataTypes.FLOAT()), + Column.physicalColumn("Column2", DataTypes.DOUBLE()))) + .isEqualTo(Column.physicalColumn("Column2", DataTypes.DOUBLE())); // Test merging columns with incompatible types - Assert.assertThrows( - IllegalStateException.class, - () -> - SchemaUtils.mergeColumn( - Column.physicalColumn("Column3", DataTypes.INT()), - Column.physicalColumn("Column3", DataTypes.STRING()))); + Assertions.assertThatThrownBy( + () -> + SchemaUtils.mergeColumn( + Column.physicalColumn("Column3", DataTypes.INT()), + Column.physicalColumn("Column3", DataTypes.STRING()))) + .isExactlyInstanceOf(IllegalStateException.class); // Test merging with incompatible names - Assert.assertThrows( - IllegalStateException.class, - () -> - SchemaUtils.mergeColumn( - Column.physicalColumn("Column4", DataTypes.INT()), - Column.physicalColumn("AnotherColumn4", DataTypes.INT()))); + Assertions.assertThatThrownBy( + () -> + SchemaUtils.mergeColumn( + Column.physicalColumn("Column4", DataTypes.INT()), + Column.physicalColumn("AnotherColumn4", DataTypes.INT()))) + .isExactlyInstanceOf(IllegalStateException.class); } @Test public void testMergeSchema() { // Test normal merges - Assert.assertEquals( - SchemaUtils.mergeSchema( - Schema.newBuilder() - .physicalColumn("Column1", DataTypes.INT()) - .physicalColumn("Column2", DataTypes.DOUBLE()) - .primaryKey("Column1") - .partitionKey("Column2") - .build(), - Schema.newBuilder() - .physicalColumn("Column1", DataTypes.BIGINT()) - .physicalColumn("Column2", DataTypes.FLOAT()) - .primaryKey("Column1") - .partitionKey("Column2") - .build()), - Schema.newBuilder() - .physicalColumn("Column1", DataTypes.BIGINT()) - .physicalColumn("Column2", DataTypes.DOUBLE()) - .primaryKey("Column1") - .partitionKey("Column2") - .build()); - - // Test merging with incompatible types - Assert.assertThrows( - IllegalStateException.class, - () -> + Assertions.assertThat( SchemaUtils.mergeSchema( Schema.newBuilder() .physicalColumn("Column1", DataTypes.INT()) @@ -368,67 +347,92 @@ public void testMergeSchema() { .partitionKey("Column2") .build(), Schema.newBuilder() - .physicalColumn("Column1", DataTypes.STRING()) - .physicalColumn("Column2", DataTypes.STRING()) + .physicalColumn("Column1", DataTypes.BIGINT()) + .physicalColumn("Column2", DataTypes.FLOAT()) .primaryKey("Column1") .partitionKey("Column2") - .build())); + .build())) + .isEqualTo( + Schema.newBuilder() + .physicalColumn("Column1", DataTypes.BIGINT()) + .physicalColumn("Column2", DataTypes.DOUBLE()) + .primaryKey("Column1") + .partitionKey("Column2") + .build()); + + // Test merging with incompatible types + Assertions.assertThatThrownBy( + () -> + SchemaUtils.mergeSchema( + Schema.newBuilder() + .physicalColumn("Column1", DataTypes.INT()) + .physicalColumn("Column2", DataTypes.DOUBLE()) + .primaryKey("Column1") + .partitionKey("Column2") + .build(), + Schema.newBuilder() + .physicalColumn("Column1", DataTypes.STRING()) + .physicalColumn("Column2", DataTypes.STRING()) + .primaryKey("Column1") + .partitionKey("Column2") + .build())) + .isExactlyInstanceOf(IllegalStateException.class); // Test merging with incompatible column names - Assert.assertThrows( - IllegalStateException.class, - () -> - SchemaUtils.mergeSchema( - Schema.newBuilder() - .physicalColumn("Column1", DataTypes.INT()) - .physicalColumn("Column2", DataTypes.DOUBLE()) - .primaryKey("Column1") - .partitionKey("Column2") - .build(), - Schema.newBuilder() - .physicalColumn("NotColumn1", DataTypes.INT()) - .physicalColumn("NotColumn2", DataTypes.DOUBLE()) - .primaryKey("NotColumn1") - .partitionKey("NotColumn2") - .build())); + Assertions.assertThatThrownBy( + () -> + SchemaUtils.mergeSchema( + Schema.newBuilder() + .physicalColumn("Column1", DataTypes.INT()) + .physicalColumn("Column2", DataTypes.DOUBLE()) + .primaryKey("Column1") + .partitionKey("Column2") + .build(), + Schema.newBuilder() + .physicalColumn("NotColumn1", DataTypes.INT()) + .physicalColumn("NotColumn2", DataTypes.DOUBLE()) + .primaryKey("NotColumn1") + .partitionKey("NotColumn2") + .build())) + .isExactlyInstanceOf(IllegalStateException.class); // Test merging with different column counts - Assert.assertThrows( - IllegalStateException.class, - () -> - SchemaUtils.mergeSchema( - Schema.newBuilder() - .physicalColumn("Column1", DataTypes.INT()) - .physicalColumn("Column2", DataTypes.DOUBLE()) - .physicalColumn("Column3", DataTypes.STRING()) - .primaryKey("Column1") - .partitionKey("Column2") - .build(), - Schema.newBuilder() - .physicalColumn("NotColumn1", DataTypes.INT()) - .physicalColumn("NotColumn2", DataTypes.DOUBLE()) - .primaryKey("NotColumn1") - .partitionKey("NotColumn2") - .build())); + Assertions.assertThatThrownBy( + () -> + SchemaUtils.mergeSchema( + Schema.newBuilder() + .physicalColumn("Column1", DataTypes.INT()) + .physicalColumn("Column2", DataTypes.DOUBLE()) + .physicalColumn("Column3", DataTypes.STRING()) + .primaryKey("Column1") + .partitionKey("Column2") + .build(), + Schema.newBuilder() + .physicalColumn("NotColumn1", DataTypes.INT()) + .physicalColumn("NotColumn2", DataTypes.DOUBLE()) + .primaryKey("NotColumn1") + .partitionKey("NotColumn2") + .build())) + .isExactlyInstanceOf(IllegalStateException.class); // Test merging with incompatible schema metadata - Assert.assertThrows( - IllegalStateException.class, - () -> - SchemaUtils.mergeSchema( - Schema.newBuilder() - .physicalColumn("Column1", DataTypes.INT()) - .physicalColumn("Column2", DataTypes.DOUBLE()) - .primaryKey("Column1") - .partitionKey("Column2") - .option("Key1", "Value1") - .build(), - Schema.newBuilder() - .physicalColumn("Column1", DataTypes.INT()) - .physicalColumn("Column2", DataTypes.DOUBLE()) - .primaryKey("Column2") - .partitionKey("Column1") - .option("Key2", "Value2") - .build())); + Assertions.assertThatThrownBy( + () -> + SchemaUtils.mergeSchema( + Schema.newBuilder() + .physicalColumn("Column1", DataTypes.INT()) + .physicalColumn("Column2", DataTypes.DOUBLE()) + .primaryKey("Column1") + .partitionKey("Column2") + .option("Key1", "Value1") + .build(), + Schema.newBuilder() + .physicalColumn("Column1", DataTypes.INT()) + .physicalColumn("Column2", DataTypes.DOUBLE()) + .primaryKey("Column2") + .partitionKey("Column1") + .option("Key2", "Value2") + .build())) + .isExactlyInstanceOf(IllegalStateException.class); } } diff --git a/flink-cdc-runtime/src/test/java/org/apache/flink/cdc/runtime/parser/TransformParserTest.java b/flink-cdc-runtime/src/test/java/org/apache/flink/cdc/runtime/parser/TransformParserTest.java index d2e7aa74e05..a3c79fdc8cf 100644 --- a/flink-cdc-runtime/src/test/java/org/apache/flink/cdc/runtime/parser/TransformParserTest.java +++ b/flink-cdc-runtime/src/test/java/org/apache/flink/cdc/runtime/parser/TransformParserTest.java @@ -46,8 +46,8 @@ import org.apache.calcite.sql2rel.SqlToRelConverter; import org.apache.calcite.sql2rel.StandardConvertletTable; import org.apache.calcite.tools.RelBuilder; -import org.junit.Assert; -import org.junit.Test; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.Test; import java.util.Arrays; import java.util.HashMap; @@ -70,9 +70,11 @@ public void testCalciteParser() { SqlSelect parse = TransformParser.parseSelect( "select CONCAT(id, order_id) as uniq_id, * from tb where uniq_id > 10 and id is not null"); - Assert.assertEquals( - "`CONCAT`(`id`, `order_id`) AS `uniq_id`, *", parse.getSelectList().toString()); - Assert.assertEquals("`uniq_id` > 10 AND `id` IS NOT NULL", parse.getWhere().toString()); + Assertions.assertThat(parse.getSelectList().toString()) + .isEqualTo("`CONCAT`(`id`, `order_id`) AS `uniq_id`, *"); + + Assertions.assertThat(parse.getWhere().toString()) + .isEqualTo("`uniq_id` > 10 AND `id` IS NOT NULL"); } @Test @@ -105,15 +107,17 @@ public void testTransformCalciteValidate() { factory, SqlValidator.Config.DEFAULT.withIdentifierExpansion(true)); SqlNode validateSqlNode = validator.validate(parse); - Assert.assertEquals( - "SUBSTR(`tb`.`id`, 1) AS `uniq_id`, `tb`.`id`, `tb`.`order_id`", - parse.getSelectList().toString()); - Assert.assertEquals("`tb`.`id` IS NOT NULL", parse.getWhere().toString()); - Assert.assertEquals( - "SELECT SUBSTR(`tb`.`id`, 1) AS `uniq_id`, `tb`.`id`, `tb`.`order_id`\n" - + "FROM `default_schema`.`tb` AS `tb`\n" - + "WHERE `tb`.`id` IS NOT NULL", - validateSqlNode.toString().replaceAll("\r\n", "\n")); + + Assertions.assertThat(parse.getSelectList().toString()) + .isEqualTo("SUBSTR(`tb`.`id`, 1) AS `uniq_id`, `tb`.`id`, `tb`.`order_id`"); + + Assertions.assertThat(parse.getWhere().toString()).isEqualTo("`tb`.`id` IS NOT NULL"); + + Assertions.assertThat(validateSqlNode.toString().replaceAll("\r\n", "\n")) + .isEqualTo( + "SELECT SUBSTR(`tb`.`id`, 1) AS `uniq_id`, `tb`.`id`, `tb`.`order_id`\n" + + "FROM `default_schema`.`tb` AS `tb`\n" + + "WHERE `tb`.`id` IS NOT NULL"); } @Test @@ -164,29 +168,33 @@ public void testCalciteRelNode() { RelBuilder relBuilder = config.getRelBuilderFactory().create(cluster, null); relRoot = relRoot.withRel(RelDecorrelator.decorrelateQuery(relRoot.rel, relBuilder)); RelNode relNode = relRoot.rel; - Assert.assertEquals( - "SUBSTR(`tb`.`id`, 1) AS `uniq_id`, `tb`.`id`, `tb`.`order_id`", - parse.getSelectList().toString()); - Assert.assertEquals("`tb`.`id` IS NOT NULL", parse.getWhere().toString()); - Assert.assertEquals( - "SELECT SUBSTR(`tb`.`id`, 1) AS `uniq_id`, `tb`.`id`, `tb`.`order_id`\n" - + "FROM `default_schema`.`tb` AS `tb`\n" - + "WHERE `tb`.`id` IS NOT NULL", - validateSqlNode.toString().replaceAll("\r\n", "\n")); + + Assertions.assertThat(parse.getSelectList().toString()) + .isEqualTo("SUBSTR(`tb`.`id`, 1) AS `uniq_id`, `tb`.`id`, `tb`.`order_id`"); + + Assertions.assertThat(parse.getWhere().toString()).isEqualTo("`tb`.`id` IS NOT NULL"); + + Assertions.assertThat(validateSqlNode.toString().replaceAll("\r\n", "\n")) + .isEqualTo( + "SELECT SUBSTR(`tb`.`id`, 1) AS `uniq_id`, `tb`.`id`, `tb`.`order_id`\n" + + "FROM `default_schema`.`tb` AS `tb`\n" + + "WHERE `tb`.`id` IS NOT NULL"); } @Test public void testParseComputedColumnNames() { List computedColumnNames = TransformParser.parseComputedColumnNames("CONCAT(id, order_id) as uniq_id, *"); - Assert.assertEquals(new String[] {"uniq_id"}, computedColumnNames.toArray()); + + Assertions.assertThat(computedColumnNames.toArray()).isEqualTo(new String[] {"uniq_id"}); } @Test public void testParseFilterColumnNameList() { List computedColumnNames = TransformParser.parseFilterColumnNameList(" uniq_id > 10 and id is not null"); - Assert.assertEquals(new String[] {"uniq_id", "id"}, computedColumnNames.toArray()); + Assertions.assertThat(computedColumnNames.toArray()) + .isEqualTo(new String[] {"uniq_id", "id"}); } @Test @@ -292,7 +300,7 @@ public void testGenerateProjectionColumns() { "ProjectionColumn{column=`name` STRING, expression='UPPER(`TB`.`name`)', scriptExpression='upper(name)', originalColumnNames=[name], transformExpressionKey=null}", "ProjectionColumn{column=`newage` INT, expression='`TB`.`age` + 1', scriptExpression='age + 1', originalColumnNames=[age], transformExpressionKey=null}", "ProjectionColumn{column=`bmi` DOUBLE, expression='`TB`.`weight` / (`TB`.`height` * `TB`.`height`)', scriptExpression='weight / height * height', originalColumnNames=[weight, height, height], transformExpressionKey=null}"); - Assert.assertEquals(result.toString(), "[" + String.join(", ", expected) + "]"); + Assertions.assertThat(result.toString()).isEqualTo("[" + String.join(", ", expected) + "]"); List metadataResult = TransformParser.generateProjectionColumns( @@ -309,15 +317,13 @@ public void testGenerateProjectionColumns() { "ProjectionColumn{column=`__namespace_name__` STRING NOT NULL, expression='__namespace_name__', scriptExpression='__namespace_name__', originalColumnNames=[__namespace_name__], transformExpressionKey=null}", "ProjectionColumn{column=`__schema_name__` STRING NOT NULL, expression='__schema_name__', scriptExpression='__schema_name__', originalColumnNames=[__schema_name__], transformExpressionKey=null}", "ProjectionColumn{column=`__table_name__` STRING NOT NULL, expression='__table_name__', scriptExpression='__table_name__', originalColumnNames=[__table_name__], transformExpressionKey=null}"); - Assert.assertEquals( - metadataResult.toString(), "[" + String.join(", ", metadataExpected) + "]"); + Assertions.assertThat(metadataResult.toString()) + .isEqualTo("[" + String.join(", ", metadataExpected) + "]"); // calculated columns must use AS to provide an alias name - Assert.assertThrows( - ParseException.class, - () -> { - TransformParser.generateProjectionColumns("id, 1 + 1", testColumns); - }); + Assertions.assertThatThrownBy( + () -> TransformParser.generateProjectionColumns("id, 1 + 1", testColumns)) + .isExactlyInstanceOf(ParseException.class); } @Test @@ -346,38 +352,38 @@ public void testGenerateReferencedColumns() { "`address` STRING 'address'", "`weight` DOUBLE 'weight'", "`height` DOUBLE 'height'"); - Assert.assertEquals(result.toString(), "[" + String.join(", ", expected) + "]"); + Assertions.assertThat(result.toString()).isEqualTo("[" + String.join(", ", expected) + "]"); // calculated columns must use AS to provide an alias name - Assert.assertThrows( - ParseException.class, - () -> { - TransformParser.generateReferencedColumns("id, 1 + 1", null, testColumns); - }); + Assertions.assertThatThrownBy( + () -> + TransformParser.generateReferencedColumns( + "id, 1 + 1", null, testColumns)) + .isExactlyInstanceOf(ParseException.class); } @Test public void testNormalizeFilter() { - Assert.assertEquals( - TransformParser.normalizeFilter("a, b, c, d", "a > 0 and b > 0"), - "`a` > 0 AND `b` > 0"); - Assert.assertEquals(TransformParser.normalizeFilter("a, b, c, d", null), null); - Assert.assertEquals( - TransformParser.normalizeFilter( - "abs(a) as cal_a, char_length(b) as cal_b, c, d", - "a > 4 and cal_a > 8 and cal_b < 17 and c != d"), - "`a` > 4 AND ABS(`a`) > 8 AND CHAR_LENGTH(`b`) < 17 AND `c` <> `d`"); - - Assert.assertEquals( - TransformParser.normalizeFilter( - "x, y, z, 1 - x as u, 1 - y as v, 1 - z as w", - "concat(u, concat(v, concat(w, x), y), z) != 10"), - "`concat`(1 - `x`, `concat`(1 - `y`, `concat`(1 - `z`, `x`), `y`), `z`) <> 10"); + Assertions.assertThat(TransformParser.normalizeFilter("a, b, c, d", "a > 0 and b > 0")) + .isEqualTo("`a` > 0 AND `b` > 0"); + Assertions.assertThat(TransformParser.normalizeFilter("a, b, c, d", null)).isEqualTo(null); + Assertions.assertThat( + TransformParser.normalizeFilter( + "abs(a) as cal_a, char_length(b) as cal_b, c, d", + "a > 4 and cal_a > 8 and cal_b < 17 and c != d")) + .isEqualTo("`a` > 4 AND ABS(`a`) > 8 AND CHAR_LENGTH(`b`) < 17 AND `c` <> `d`"); + + Assertions.assertThat( + TransformParser.normalizeFilter( + "x, y, z, 1 - x as u, 1 - y as v, 1 - z as w", + "concat(u, concat(v, concat(w, x), y), z) != 10")) + .isEqualTo( + "`concat`(1 - `x`, `concat`(1 - `y`, `concat`(1 - `z`, `x`), `y`), `z`) <> 10"); } private void testFilterExpression(String expression, String expressionExpect) { String janinoExpression = TransformParser.translateFilterExpressionToJaninoExpression(expression); - Assert.assertEquals(expressionExpect, janinoExpression); + Assertions.assertThat(janinoExpression).isEqualTo(expressionExpect); } }