diff --git a/flight/flight-sql/pom.xml b/flight/flight-sql/pom.xml
index 5f06a5e9eb..15d00e3e18 100644
--- a/flight/flight-sql/pom.xml
+++ b/flight/flight-sql/pom.xml
@@ -116,16 +116,16 @@ under the License.
       <version>1.13.1</version>
       <scope>test</scope>
     </dependency>
-    <dependency>
-      <groupId>org.hamcrest</groupId>
-      <artifactId>hamcrest</artifactId>
-      <scope>test</scope>
-    </dependency>
     <dependency>
       <groupId>commons-cli</groupId>
       <artifactId>commons-cli</artifactId>
       <version>1.9.0</version>
       <optional>true</optional>
     </dependency>
+    <dependency>
+      <groupId>org.assertj</groupId>
+      <artifactId>assertj-core</artifactId>
+      <scope>test</scope>
+    </dependency>
   </dependencies>
 </project>
diff --git a/flight/flight-sql/src/test/java/org/apache/arrow/flight/sql/test/TestFlightSql.java b/flight/flight-sql/src/test/java/org/apache/arrow/flight/sql/test/TestFlightSql.java
index 3f769363fb..e2934ab1e9 100644
--- a/flight/flight-sql/src/test/java/org/apache/arrow/flight/sql/test/TestFlightSql.java
+++ b/flight/flight-sql/src/test/java/org/apache/arrow/flight/sql/test/TestFlightSql.java
@@ -21,10 +21,7 @@
 import static java.util.Collections.singletonList;
 import static org.apache.arrow.flight.sql.util.FlightStreamUtils.getResults;
 import static org.apache.arrow.util.AutoCloseables.close;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.notNullValue;
-import static org.hamcrest.CoreMatchers.nullValue;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertAll;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -40,6 +37,7 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.stream.IntStream;
 import org.apache.arrow.flight.CancelFlightInfoRequest;
@@ -76,8 +74,7 @@
 import org.apache.arrow.vector.types.pojo.Schema;
 import org.apache.arrow.vector.util.Text;
 import org.apache.arrow.vector.util.VectorBatchAppender;
-import org.hamcrest.Matcher;
-import org.hamcrest.MatcherAssert;
+import org.assertj.core.api.Condition;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -247,16 +244,15 @@ private static List<List<String>> getNonConformingResultsForGetSqlInfo(
   @Test
   public void testGetTablesSchema() {
     final FlightInfo info = sqlClient.getTables(null, null, null, null, true);
-    MatcherAssert.assertThat(
-        info.getSchemaOptional(), is(Optional.of(FlightSqlProducer.Schemas.GET_TABLES_SCHEMA)));
+    assertThat(info.getSchemaOptional())
+        .isEqualTo(Optional.of(FlightSqlProducer.Schemas.GET_TABLES_SCHEMA));
   }
 
   @Test
   public void testGetTablesSchemaExcludeSchema() {
     final FlightInfo info = sqlClient.getTables(null, null, null, null, false);
-    MatcherAssert.assertThat(
-        info.getSchemaOptional(),
-        is(Optional.of(FlightSqlProducer.Schemas.GET_TABLES_SCHEMA_NO_SCHEMA)));
+    assertThat(info.getSchemaOptional())
+        .isEqualTo(Optional.of(FlightSqlProducer.Schemas.GET_TABLES_SCHEMA_NO_SCHEMA));
   }
 
   @Test
@@ -266,8 +262,8 @@ public void testGetTablesResultNoSchema() throws Exception {
             sqlClient.getTables(null, null, null, null, false).getEndpoints().get(0).getTicket())) {
       assertAll(
           () -> {
-            MatcherAssert.assertThat(
-                stream.getSchema(), is(FlightSqlProducer.Schemas.GET_TABLES_SCHEMA_NO_SCHEMA));
+            assertThat(stream.getSchema())
+                .isEqualTo(FlightSqlProducer.Schemas.GET_TABLES_SCHEMA_NO_SCHEMA);
           },
           () -> {
             final List<List<String>> results = getResults(stream);
@@ -301,7 +297,7 @@ public void testGetTablesResultNoSchema() throws Exception {
                     asList(null /* TODO No catalog yet */, "SYSIBM", "SYSDUMMY1", "SYSTEM TABLE"),
                     asList(null /* TODO No catalog yet */, "APP", "FOREIGNTABLE", "TABLE"),
                     asList(null /* TODO No catalog yet */, "APP", "INTTABLE", "TABLE"));
-            MatcherAssert.assertThat(results, is(expectedResults));
+            assertThat(results).isEqualTo(expectedResults);
           });
     }
   }
@@ -318,8 +314,8 @@ public void testGetTablesResultFilteredNoSchema() throws Exception {
 
       assertAll(
           () ->
-              MatcherAssert.assertThat(
-                  stream.getSchema(), is(FlightSqlProducer.Schemas.GET_TABLES_SCHEMA_NO_SCHEMA)),
+              assertThat(stream.getSchema())
+                  .isEqualTo(FlightSqlProducer.Schemas.GET_TABLES_SCHEMA_NO_SCHEMA),
           () -> {
             final List<List<String>> results = getResults(stream);
             final List<List<String>> expectedResults =
@@ -327,7 +323,7 @@ public void testGetTablesResultFilteredNoSchema() throws Exception {
                     // catalog_name | schema_name | table_name | table_type | table_schema
                     asList(null /* TODO No catalog yet */, "APP", "FOREIGNTABLE", "TABLE"),
                     asList(null /* TODO No catalog yet */, "APP", "INTTABLE", "TABLE"));
-            MatcherAssert.assertThat(results, is(expectedResults));
+            assertThat(results).isEqualTo(expectedResults);
           });
     }
   }
@@ -343,11 +339,9 @@ public void testGetTablesResultFilteredWithSchema() throws Exception {
                 .getTicket())) {
       assertAll(
           () ->
-              MatcherAssert.assertThat(
-                  stream.getSchema(), is(FlightSqlProducer.Schemas.GET_TABLES_SCHEMA)),
+              assertThat(stream.getSchema()).isEqualTo(FlightSqlProducer.Schemas.GET_TABLES_SCHEMA),
           () -> {
-            MatcherAssert.assertThat(
-                stream.getSchema(), is(FlightSqlProducer.Schemas.GET_TABLES_SCHEMA));
+            assertThat(stream.getSchema()).isEqualTo(FlightSqlProducer.Schemas.GET_TABLES_SCHEMA);
             final List<List<String>> results = getResults(stream);
             final List<List<String>> expectedResults =
                 ImmutableList.of(
@@ -487,7 +481,7 @@ public void testGetTablesResultFilteredWithSchema() throws Exception {
                                                 .getMetadataMap()),
                                         null)))
                             .toJson()));
-            MatcherAssert.assertThat(results, is(expectedResults));
+            assertThat(results).isEqualTo(expectedResults);
           });
     }
   }
@@ -498,11 +492,11 @@ public void testSimplePreparedStatementSchema() throws Exception {
       assertAll(
           () -> {
             final Schema actualSchema = preparedStatement.getResultSetSchema();
-            MatcherAssert.assertThat(actualSchema, is(SCHEMA_INT_TABLE));
+            assertThat(actualSchema).isEqualTo(SCHEMA_INT_TABLE);
           },
           () -> {
             final FlightInfo info = preparedStatement.execute();
-            MatcherAssert.assertThat(info.getSchemaOptional(), is(Optional.of(SCHEMA_INT_TABLE)));
+            assertThat(info.getSchemaOptional()).isEqualTo(Optional.of(SCHEMA_INT_TABLE));
           });
     }
   }
@@ -513,10 +507,8 @@ public void testSimplePreparedStatementResults() throws Exception {
         final FlightStream stream =
             sqlClient.getStream(preparedStatement.execute().getEndpoints().get(0).getTicket())) {
       assertAll(
-          () -> MatcherAssert.assertThat(stream.getSchema(), is(SCHEMA_INT_TABLE)),
-          () ->
-              MatcherAssert.assertThat(
-                  getResults(stream), is(EXPECTED_RESULTS_FOR_STAR_SELECT_QUERY)));
+          () -> assertThat(stream.getSchema()).isEqualTo(SCHEMA_INT_TABLE),
+          () -> assertThat(getResults(stream)).isEqualTo(EXPECTED_RESULTS_FOR_STAR_SELECT_QUERY));
     }
   }
 
@@ -538,10 +530,8 @@ public void testSimplePreparedStatementResultsWithParameterBinding() throws Exce
         FlightStream stream = sqlClient.getStream(flightInfo.getEndpoints().get(0).getTicket());
 
         assertAll(
-            () -> MatcherAssert.assertThat(stream.getSchema(), is(SCHEMA_INT_TABLE)),
-            () ->
-                MatcherAssert.assertThat(
-                    getResults(stream), is(EXPECTED_RESULTS_FOR_PARAMETER_BINDING)));
+            () -> assertThat(stream.getSchema()).isEqualTo(SCHEMA_INT_TABLE),
+            () -> assertThat(getResults(stream)).isEqualTo(EXPECTED_RESULTS_FOR_PARAMETER_BINDING));
       }
     }
   }
@@ -579,8 +569,8 @@ public void testSimplePreparedStatementUpdateResults() throws SQLException {
           deletedRows = deletePrepare.executeUpdate();
         }
         assertAll(
-            () -> MatcherAssert.assertThat(updatedRows, is(10L)),
-            () -> MatcherAssert.assertThat(deletedRows, is(10L)));
+            () -> assertThat(updatedRows).isEqualTo(10L),
+            () -> assertThat(deletedRows).isEqualTo(10L));
       }
     }
   }
@@ -647,7 +637,7 @@ public void testBulkIngest() throws IOException {
                     null,
                     null));
 
-        MatcherAssert.assertThat(updatedRows, is(-1L));
+        assertThat(updatedRows).isEqualTo(-1L);
 
         // Ingest directly using VectorSchemaRoot
         populateNext10RowsInIngestRootBatch(
@@ -672,7 +662,7 @@ public void testBulkIngest() throws IOException {
             deletedRows = deletePrepare.executeUpdate();
           }
 
-          MatcherAssert.assertThat(deletedRows, is(30L));
+          assertThat(deletedRows).isEqualTo(30L);
         }
       }
     }
@@ -709,8 +699,7 @@ public void testSimplePreparedStatementUpdateResultsWithoutParameters() throws S
       final long deletedRows = deletePrepare.executeUpdate();
 
       assertAll(
-          () -> MatcherAssert.assertThat(updatedRows, is(1L)),
-          () -> MatcherAssert.assertThat(deletedRows, is(1L)));
+          () -> assertThat(updatedRows).isEqualTo(1L), () -> assertThat(deletedRows).isEqualTo(1L));
     }
   }
 
@@ -719,19 +708,19 @@ public void testSimplePreparedStatementClosesProperly() {
     final PreparedStatement preparedStatement = sqlClient.prepare("SELECT * FROM intTable");
     assertAll(
         () -> {
-          MatcherAssert.assertThat(preparedStatement.isClosed(), is(false));
+          assertThat(preparedStatement.isClosed()).isEqualTo(false);
         },
         () -> {
           preparedStatement.close();
-          MatcherAssert.assertThat(preparedStatement.isClosed(), is(true));
+          assertThat(preparedStatement.isClosed()).isEqualTo(true);
         });
   }
 
   @Test
   public void testGetCatalogsSchema() {
     final FlightInfo info = sqlClient.getCatalogs();
-    MatcherAssert.assertThat(
-        info.getSchemaOptional(), is(Optional.of(FlightSqlProducer.Schemas.GET_CATALOGS_SCHEMA)));
+    assertThat(info.getSchemaOptional())
+        .isEqualTo(Optional.of(FlightSqlProducer.Schemas.GET_CATALOGS_SCHEMA));
   }
 
   @Test
@@ -740,11 +729,11 @@ public void testGetCatalogsResults() throws Exception {
         sqlClient.getStream(sqlClient.getCatalogs().getEndpoints().get(0).getTicket())) {
       assertAll(
           () ->
-              MatcherAssert.assertThat(
-                  stream.getSchema(), is(FlightSqlProducer.Schemas.GET_CATALOGS_SCHEMA)),
+              assertThat(stream.getSchema())
+                  .isEqualTo(FlightSqlProducer.Schemas.GET_CATALOGS_SCHEMA),
           () -> {
             List<List<String>> catalogs = getResults(stream);
-            MatcherAssert.assertThat(catalogs, is(emptyList()));
+            assertThat(catalogs).isEqualTo(emptyList());
           });
     }
   }
@@ -752,9 +741,8 @@ public void testGetCatalogsResults() throws Exception {
   @Test
   public void testGetTableTypesSchema() {
     final FlightInfo info = sqlClient.getTableTypes();
-    MatcherAssert.assertThat(
-        info.getSchemaOptional(),
-        is(Optional.of(FlightSqlProducer.Schemas.GET_TABLE_TYPES_SCHEMA)));
+    assertThat(info.getSchemaOptional())
+        .isEqualTo(Optional.of(FlightSqlProducer.Schemas.GET_TABLE_TYPES_SCHEMA));
   }
 
   @Test
@@ -763,8 +751,8 @@ public void testGetTableTypesResult() throws Exception {
         sqlClient.getStream(sqlClient.getTableTypes().getEndpoints().get(0).getTicket())) {
       assertAll(
           () -> {
-            MatcherAssert.assertThat(
-                stream.getSchema(), is(FlightSqlProducer.Schemas.GET_TABLE_TYPES_SCHEMA));
+            assertThat(stream.getSchema())
+                .isEqualTo(FlightSqlProducer.Schemas.GET_TABLE_TYPES_SCHEMA);
           },
           () -> {
             final List<List<String>> tableTypes = getResults(stream);
@@ -775,7 +763,7 @@ public void testGetTableTypesResult() throws Exception {
                     singletonList("SYSTEM TABLE"),
                     singletonList("TABLE"),
                     singletonList("VIEW"));
-            MatcherAssert.assertThat(tableTypes, is(expectedTableTypes));
+            assertThat(tableTypes).isEqualTo(expectedTableTypes);
           });
     }
   }
@@ -783,8 +771,8 @@ public void testGetTableTypesResult() throws Exception {
   @Test
   public void testGetSchemasSchema() {
     final FlightInfo info = sqlClient.getSchemas(null, null);
-    MatcherAssert.assertThat(
-        info.getSchemaOptional(), is(Optional.of(FlightSqlProducer.Schemas.GET_SCHEMAS_SCHEMA)));
+    assertThat(info.getSchemaOptional())
+        .isEqualTo(Optional.of(FlightSqlProducer.Schemas.GET_SCHEMAS_SCHEMA));
   }
 
   @Test
@@ -793,8 +781,7 @@ public void testGetSchemasResult() throws Exception {
         sqlClient.getStream(sqlClient.getSchemas(null, null).getEndpoints().get(0).getTicket())) {
       assertAll(
           () -> {
-            MatcherAssert.assertThat(
-                stream.getSchema(), is(FlightSqlProducer.Schemas.GET_SCHEMAS_SCHEMA));
+            assertThat(stream.getSchema()).isEqualTo(FlightSqlProducer.Schemas.GET_SCHEMAS_SCHEMA);
           },
           () -> {
             final List<List<String>> schemas = getResults(stream);
@@ -812,7 +799,7 @@ public void testGetSchemasResult() throws Exception {
                     asList(null /* TODO Add catalog. */, "SYSIBM"),
                     asList(null /* TODO Add catalog. */, "SYSPROC"),
                     asList(null /* TODO Add catalog. */, "SYSSTAT"));
-            MatcherAssert.assertThat(schemas, is(expectedSchemas));
+            assertThat(schemas).isEqualTo(expectedSchemas);
           });
     }
   }
@@ -825,24 +812,24 @@ public void testGetPrimaryKey() {
     final List<List<String>> results = getResults(stream);
 
     assertAll(
-        () -> MatcherAssert.assertThat(results.size(), is(1)),
+        () -> assertThat(results.size()).isEqualTo(1),
         () -> {
           final List<String> result = results.get(0);
           assertAll(
-              () -> MatcherAssert.assertThat(result.get(0), is("")),
-              () -> MatcherAssert.assertThat(result.get(1), is("APP")),
-              () -> MatcherAssert.assertThat(result.get(2), is("INTTABLE")),
-              () -> MatcherAssert.assertThat(result.get(3), is("ID")),
-              () -> MatcherAssert.assertThat(result.get(4), is("1")),
-              () -> MatcherAssert.assertThat(result.get(5), notNullValue()));
+              () -> assertThat(result.get(0)).isEqualTo(""),
+              () -> assertThat(result.get(1)).isEqualTo("APP"),
+              () -> assertThat(result.get(2)).isEqualTo("INTTABLE"),
+              () -> assertThat(result.get(3)).isEqualTo("ID"),
+              () -> assertThat(result.get(4)).isEqualTo("1"),
+              () -> assertThat(result.get(5)).isNotNull());
         });
   }
 
   @Test
   public void testGetSqlInfoSchema() {
     final FlightInfo info = sqlClient.getSqlInfo();
-    MatcherAssert.assertThat(
-        info.getSchemaOptional(), is(Optional.of(FlightSqlProducer.Schemas.GET_SQL_INFO_SCHEMA)));
+    assertThat(info.getSchemaOptional())
+        .isEqualTo(Optional.of(FlightSqlProducer.Schemas.GET_SQL_INFO_SCHEMA));
   }
 
   @Test
@@ -851,11 +838,11 @@ public void testGetSqlInfoResults() throws Exception {
     try (final FlightStream stream = sqlClient.getStream(info.getEndpoints().get(0).getTicket())) {
       assertAll(
           () ->
-              MatcherAssert.assertThat(
-                  stream.getSchema(), is(FlightSqlProducer.Schemas.GET_SQL_INFO_SCHEMA)),
+              assertThat(stream.getSchema())
+                  .isEqualTo(FlightSqlProducer.Schemas.GET_SQL_INFO_SCHEMA),
           () ->
-              MatcherAssert.assertThat(
-                  getNonConformingResultsForGetSqlInfo(getResults(stream)), is(emptyList())));
+              assertThat(getNonConformingResultsForGetSqlInfo(getResults(stream)))
+                  .isEqualTo(emptyList()));
     }
   }
 
@@ -866,11 +853,11 @@ public void testGetSqlInfoResultsWithSingleArg() throws Exception {
     try (final FlightStream stream = sqlClient.getStream(info.getEndpoints().get(0).getTicket())) {
       assertAll(
           () ->
-              MatcherAssert.assertThat(
-                  stream.getSchema(), is(FlightSqlProducer.Schemas.GET_SQL_INFO_SCHEMA)),
+              assertThat(stream.getSchema())
+                  .isEqualTo(FlightSqlProducer.Schemas.GET_SQL_INFO_SCHEMA),
           () ->
-              MatcherAssert.assertThat(
-                  getNonConformingResultsForGetSqlInfo(getResults(stream), arg), is(emptyList())));
+              assertThat(getNonConformingResultsForGetSqlInfo(getResults(stream), arg))
+                  .isEqualTo(emptyList()));
     }
   }
 
@@ -895,11 +882,11 @@ public void testGetSqlInfoResultsWithManyArgs() throws Exception {
     try (final FlightStream stream = sqlClient.getStream(info.getEndpoints().get(0).getTicket())) {
       assertAll(
           () ->
-              MatcherAssert.assertThat(
-                  stream.getSchema(), is(FlightSqlProducer.Schemas.GET_SQL_INFO_SCHEMA)),
+              assertThat(stream.getSchema())
+                  .isEqualTo(FlightSqlProducer.Schemas.GET_SQL_INFO_SCHEMA),
           () ->
-              MatcherAssert.assertThat(
-                  getNonConformingResultsForGetSqlInfo(getResults(stream), args), is(emptyList())));
+              assertThat(getNonConformingResultsForGetSqlInfo(getResults(stream), args))
+                  .isEqualTo(emptyList()));
     }
   }
 
@@ -915,28 +902,30 @@ public void testGetCommandExportedKeys() throws Exception {
 
       final List<List<String>> results = getResults(stream);
 
-      final List<Matcher<String>> matchers =
+      final List<Condition<String>> matchers =
           asList(
-              nullValue(String.class), // pk_catalog_name
-              is("APP"), // pk_schema_name
-              is("FOREIGNTABLE"), // pk_table_name
-              is("ID"), // pk_column_name
-              nullValue(String.class), // fk_catalog_name
-              is("APP"), // fk_schema_name
-              is("INTTABLE"), // fk_table_name
-              is("FOREIGNID"), // fk_column_name
-              is("1"), // key_sequence
-              containsString("SQL"), // fk_key_name
-              containsString("SQL"), // pk_key_name
-              is("3"), // update_rule
-              is("3")); // delete_rule
+              new Condition<>(Objects::isNull, "pk_catalog_name expected to be null"),
+              new Condition<>(c -> c.equals("APP"), "pk_schema_name expected to equal APP"),
+              new Condition<>(
+                  c -> c.equals("FOREIGNTABLE"), "pk_table_name should equal FOREIGNTABLE"),
+              new Condition<>(c -> c.equals("ID"), "pk_column_name should equal ID"),
+              new Condition<>(Objects::isNull, "fk_catalog_name expected to be null"),
+              new Condition<>(c -> c.equals("APP"), "fk_schema_name expected to be APP"),
+              new Condition<>(c -> c.equals("INTTABLE"), "fk_table_name expeced to be INTTABLE"),
+              new Condition<>(
+                  c -> c.equals("FOREIGNID"), "fk_column_name expected to equal FOREIGNID"),
+              new Condition<>(c -> c.equals("1"), "key_sequence expected to equal 1"),
+              new Condition<>(c -> c.contains("SQL"), "fk_key_name expected to contain SQL"),
+              new Condition<>(c -> c.contains("SQL"), "pk_key_name expected to contain SQL"),
+              new Condition<>(c -> c.equals("3"), "update_rule expected to equal 3"),
+              new Condition<>(c -> c.equals("3"), "delete_rule expected to equal 3"));
 
       final List<Executable> assertions = new ArrayList<>();
       assertEquals(1, results.size());
       for (int i = 0; i < matchers.size(); i++) {
         final String actual = results.get(0).get(i);
-        final Matcher<String> expected = matchers.get(i);
-        assertions.add(() -> MatcherAssert.assertThat(actual, expected));
+        final Condition<String> expected = matchers.get(i);
+        assertions.add(() -> assertThat(actual).satisfies(expected));
       }
       assertAll(assertions);
     }
@@ -954,28 +943,30 @@ public void testGetCommandImportedKeys() throws Exception {
 
       final List<List<String>> results = getResults(stream);
 
-      final List<Matcher<String>> matchers =
+      final List<Condition<String>> matchers =
           asList(
-              nullValue(String.class), // pk_catalog_name
-              is("APP"), // pk_schema_name
-              is("FOREIGNTABLE"), // pk_table_name
-              is("ID"), // pk_column_name
-              nullValue(String.class), // fk_catalog_name
-              is("APP"), // fk_schema_name
-              is("INTTABLE"), // fk_table_name
-              is("FOREIGNID"), // fk_column_name
-              is("1"), // key_sequence
-              containsString("SQL"), // fk_key_name
-              containsString("SQL"), // pk_key_name
-              is("3"), // update_rule
-              is("3")); // delete_rule
+              new Condition<>(Objects::isNull, "pk_catalog_name expected to be null"),
+              new Condition<>(c -> c.equals("APP"), "pk_schema_name expected to equal APP"),
+              new Condition<>(
+                  c -> c.equals("FOREIGNTABLE"), "pk_table_name should equal FOREIGNTABLE"),
+              new Condition<>(c -> c.equals("ID"), "pk_column_name should equal ID"),
+              new Condition<>(Objects::isNull, "fk_catalog_name expected to be null"),
+              new Condition<>(c -> c.equals("APP"), "fk_schema_name expected to be APP"),
+              new Condition<>(c -> c.equals("INTTABLE"), "fk_table_name expeced to be INTTABLE"),
+              new Condition<>(
+                  c -> c.equals("FOREIGNID"), "fk_column_name expected to equal FOREIGNID"),
+              new Condition<>(c -> c.equals("1"), "key_sequence expected to equal 1"),
+              new Condition<>(c -> c.contains("SQL"), "fk_key_name expected to contain SQL"),
+              new Condition<>(c -> c.contains("SQL"), "pk_key_name expected to contain SQL"),
+              new Condition<>(c -> c.equals("3"), "update_rule expected to equal 3"),
+              new Condition<>(c -> c.equals("3"), "delete_rule expected to equal 3"));
 
       assertEquals(1, results.size());
       final List<Executable> assertions = new ArrayList<>();
       for (int i = 0; i < matchers.size(); i++) {
         final String actual = results.get(0).get(i);
-        final Matcher<String> expected = matchers.get(i);
-        assertions.add(() -> MatcherAssert.assertThat(actual, expected));
+        final Condition<String> expected = matchers.get(i);
+        assertions.add(() -> assertThat(actual).satisfies(expected));
       }
       assertAll(assertions);
     }
@@ -1431,7 +1422,7 @@ public void testGetTypeInfo() throws Exception {
                   null,
                   null,
                   null));
-      MatcherAssert.assertThat(results, is(matchers));
+      assertThat(results).isEqualTo(matchers);
     }
   }
 
@@ -1465,7 +1456,7 @@ public void testGetTypeInfoWithFiltering() throws Exception {
                   null,
                   "10",
                   null));
-      MatcherAssert.assertThat(results, is(matchers));
+      assertThat(results).isEqualTo(matchers);
     }
   }
 
@@ -1479,28 +1470,30 @@ public void testGetCommandCrossReference() throws Exception {
 
       final List<List<String>> results = getResults(stream);
 
-      final List<Matcher<String>> matchers =
+      final List<Condition<String>> matchers =
           asList(
-              nullValue(String.class), // pk_catalog_name
-              is("APP"), // pk_schema_name
-              is("FOREIGNTABLE"), // pk_table_name
-              is("ID"), // pk_column_name
-              nullValue(String.class), // fk_catalog_name
-              is("APP"), // fk_schema_name
-              is("INTTABLE"), // fk_table_name
-              is("FOREIGNID"), // fk_column_name
-              is("1"), // key_sequence
-              containsString("SQL"), // fk_key_name
-              containsString("SQL"), // pk_key_name
-              is("3"), // update_rule
-              is("3")); // delete_rule
+              new Condition<>(Objects::isNull, "pk_catalog_name expected to be null"),
+              new Condition<>(c -> c.equals("APP"), "pk_schema_name expected to equal APP"),
+              new Condition<>(
+                  c -> c.equals("FOREIGNTABLE"), "pk_table_name should equal FOREIGNTABLE"),
+              new Condition<>(c -> c.equals("ID"), "pk_column_name should equal ID"),
+              new Condition<>(Objects::isNull, "fk_catalog_name expected to be null"),
+              new Condition<>(c -> c.equals("APP"), "fk_schema_name expected to be APP"),
+              new Condition<>(c -> c.equals("INTTABLE"), "fk_table_name expeced to be INTTABLE"),
+              new Condition<>(
+                  c -> c.equals("FOREIGNID"), "fk_column_name expected to equal FOREIGNID"),
+              new Condition<>(c -> c.equals("1"), "key_sequence expected to equal 1"),
+              new Condition<>(c -> c.contains("SQL"), "fk_key_name expected to contain SQL"),
+              new Condition<>(c -> c.contains("SQL"), "pk_key_name expected to contain SQL"),
+              new Condition<>(c -> c.equals("3"), "update_rule expected to equal 3"),
+              new Condition<>(c -> c.equals("3"), "delete_rule expected to equal 3"));
 
       assertEquals(1, results.size());
       final List<Executable> assertions = new ArrayList<>();
       for (int i = 0; i < matchers.size(); i++) {
         final String actual = results.get(0).get(i);
-        final Matcher<String> expected = matchers.get(i);
-        assertions.add(() -> MatcherAssert.assertThat(actual, expected));
+        final Condition<String> expected = matchers.get(i);
+        assertions.add(() -> assertThat(actual).satisfies(expected));
       }
       assertAll(assertions);
     }
@@ -1509,7 +1502,7 @@ public void testGetCommandCrossReference() throws Exception {
   @Test
   public void testCreateStatementSchema() throws Exception {
     final FlightInfo info = sqlClient.execute("SELECT * FROM intTable");
-    MatcherAssert.assertThat(info.getSchemaOptional(), is(Optional.of(SCHEMA_INT_TABLE)));
+    assertThat(info.getSchemaOptional()).isEqualTo(Optional.of(SCHEMA_INT_TABLE));
 
     // Consume statement to close connection before cache eviction
     try (FlightStream stream = sqlClient.getStream(info.getEndpoints().get(0).getTicket())) {
@@ -1526,11 +1519,10 @@ public void testCreateStatementResults() throws Exception {
             sqlClient.execute("SELECT * FROM intTable").getEndpoints().get(0).getTicket())) {
       assertAll(
           () -> {
-            MatcherAssert.assertThat(stream.getSchema(), is(SCHEMA_INT_TABLE));
+            assertThat(stream.getSchema()).isEqualTo(SCHEMA_INT_TABLE);
           },
           () -> {
-            MatcherAssert.assertThat(
-                getResults(stream), is(EXPECTED_RESULTS_FOR_STAR_SELECT_QUERY));
+            assertThat(getResults(stream)).isEqualTo(EXPECTED_RESULTS_FOR_STAR_SELECT_QUERY);
           });
     }
   }
@@ -1543,19 +1535,19 @@ public void testExecuteUpdate() {
               sqlClient.executeUpdate(
                   "INSERT INTO INTTABLE (keyName, value) VALUES "
                       + "('KEYNAME1', 1001), ('KEYNAME2', 1002), ('KEYNAME3', 1003)");
-          MatcherAssert.assertThat(insertedCount, is(3L));
+          assertThat(insertedCount).isEqualTo(3L);
         },
         () -> {
           long updatedCount =
               sqlClient.executeUpdate(
                   "UPDATE INTTABLE SET keyName = 'KEYNAME1' "
                       + "WHERE keyName = 'KEYNAME2' OR keyName = 'KEYNAME3'");
-          MatcherAssert.assertThat(updatedCount, is(2L));
+          assertThat(updatedCount).isEqualTo(2L);
         },
         () -> {
           long deletedCount =
               sqlClient.executeUpdate("DELETE FROM INTTABLE WHERE keyName = 'KEYNAME1'");
-          MatcherAssert.assertThat(deletedCount, is(3L));
+          assertThat(deletedCount).isEqualTo(3L);
         });
   }
 
@@ -1566,10 +1558,10 @@ public void testQueryWithNoResultsShouldNotHang() throws Exception {
         final FlightStream stream =
             sqlClient.getStream(preparedStatement.execute().getEndpoints().get(0).getTicket())) {
       assertAll(
-          () -> MatcherAssert.assertThat(stream.getSchema(), is(SCHEMA_INT_TABLE)),
+          () -> assertThat(stream.getSchema()).isEqualTo(SCHEMA_INT_TABLE),
           () -> {
             final List<List<String>> result = getResults(stream);
-            MatcherAssert.assertThat(result, is(emptyList()));
+            assertThat(result).isEqualTo(emptyList());
           });
     }
   }
diff --git a/flight/flight-sql/src/test/java/org/apache/arrow/flight/sql/test/TestFlightSqlStateless.java b/flight/flight-sql/src/test/java/org/apache/arrow/flight/sql/test/TestFlightSqlStateless.java
index 36d621ad64..ee1507b6af 100644
--- a/flight/flight-sql/src/test/java/org/apache/arrow/flight/sql/test/TestFlightSqlStateless.java
+++ b/flight/flight-sql/src/test/java/org/apache/arrow/flight/sql/test/TestFlightSqlStateless.java
@@ -18,7 +18,7 @@
 
 import static org.apache.arrow.flight.sql.util.FlightStreamUtils.getResults;
 import static org.apache.arrow.util.AutoCloseables.close;
-import static org.hamcrest.CoreMatchers.is;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertAll;
 
 import org.apache.arrow.flight.FlightClient;
@@ -34,7 +34,6 @@
 import org.apache.arrow.vector.IntVector;
 import org.apache.arrow.vector.VectorSchemaRoot;
 import org.apache.arrow.vector.types.pojo.Schema;
-import org.hamcrest.MatcherAssert;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -89,10 +88,10 @@ public void testSimplePreparedStatementResultsWithParameterBinding() throws Exce
         for (FlightEndpoint endpoint : flightInfo.getEndpoints()) {
           try (FlightStream stream = sqlClient.getStream(endpoint.getTicket())) {
             assertAll(
-                () -> MatcherAssert.assertThat(stream.getSchema(), is(SCHEMA_INT_TABLE)),
+                () -> assertThat(stream.getSchema()).isEqualTo(SCHEMA_INT_TABLE),
                 () ->
-                    MatcherAssert.assertThat(
-                        getResults(stream), is(EXPECTED_RESULTS_FOR_PARAMETER_BINDING)));
+                    assertThat(getResults(stream))
+                        .isEqualTo(EXPECTED_RESULTS_FOR_PARAMETER_BINDING));
           }
         }
       }
diff --git a/flight/flight-sql/src/test/java/org/apache/arrow/flight/sql/test/TestFlightSqlStreams.java b/flight/flight-sql/src/test/java/org/apache/arrow/flight/sql/test/TestFlightSqlStreams.java
index 71c0dc88e4..3f527f961e 100644
--- a/flight/flight-sql/src/test/java/org/apache/arrow/flight/sql/test/TestFlightSqlStreams.java
+++ b/flight/flight-sql/src/test/java/org/apache/arrow/flight/sql/test/TestFlightSqlStreams.java
@@ -22,7 +22,7 @@
 import static org.apache.arrow.flight.sql.util.FlightStreamUtils.getResults;
 import static org.apache.arrow.util.AutoCloseables.close;
 import static org.apache.arrow.vector.types.Types.MinorType.INT;
-import static org.hamcrest.CoreMatchers.is;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertAll;
 
 import com.google.common.collect.ImmutableList;
@@ -53,7 +53,6 @@
 import org.apache.arrow.vector.types.pojo.Field;
 import org.apache.arrow.vector.types.pojo.Schema;
 import org.apache.arrow.vector.util.Text;
-import org.hamcrest.MatcherAssert;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -245,15 +244,15 @@ public void testGetTablesResultNoSchema() throws Exception {
             sqlClient.getTables(null, null, null, null, false).getEndpoints().get(0).getTicket())) {
       assertAll(
           () ->
-              MatcherAssert.assertThat(
-                  stream.getSchema(), is(FlightSqlProducer.Schemas.GET_TABLES_SCHEMA_NO_SCHEMA)),
+              assertThat(stream.getSchema())
+                  .isEqualTo(FlightSqlProducer.Schemas.GET_TABLES_SCHEMA_NO_SCHEMA),
           () -> {
             final List<List<String>> results = getResults(stream);
             final List<List<String>> expectedResults =
                 ImmutableList.of(
                     // catalog_name | schema_name | table_name | table_type | table_schema
                     asList(null, null, "test_table", "TABLE"));
-            MatcherAssert.assertThat(results, is(expectedResults));
+            assertThat(results).isEqualTo(expectedResults);
           });
     }
   }
@@ -264,15 +263,15 @@ public void testGetTableTypesResult() throws Exception {
         sqlClient.getStream(sqlClient.getTableTypes().getEndpoints().get(0).getTicket())) {
       assertAll(
           () ->
-              MatcherAssert.assertThat(
-                  stream.getSchema(), is(FlightSqlProducer.Schemas.GET_TABLE_TYPES_SCHEMA)),
+              assertThat(stream.getSchema())
+                  .isEqualTo(FlightSqlProducer.Schemas.GET_TABLE_TYPES_SCHEMA),
           () -> {
             final List<List<String>> tableTypes = getResults(stream);
             final List<List<String>> expectedTableTypes =
                 ImmutableList.of(
                     // table_type
                     singletonList("TABLE"));
-            MatcherAssert.assertThat(tableTypes, is(expectedTableTypes));
+            assertThat(tableTypes).isEqualTo(expectedTableTypes);
           });
     }
   }
@@ -283,9 +282,9 @@ public void testGetSqlInfoResults() throws Exception {
     try (final FlightStream stream = sqlClient.getStream(info.getEndpoints().get(0).getTicket())) {
       assertAll(
           () ->
-              MatcherAssert.assertThat(
-                  stream.getSchema(), is(FlightSqlProducer.Schemas.GET_SQL_INFO_SCHEMA)),
-          () -> MatcherAssert.assertThat(getResults(stream), is(emptyList())));
+              assertThat(stream.getSchema())
+                  .isEqualTo(FlightSqlProducer.Schemas.GET_SQL_INFO_SCHEMA),
+          () -> assertThat(getResults(stream)).isEqualTo(emptyList()));
     }
   }
 
@@ -303,7 +302,7 @@ public void testGetTypeInfo() throws Exception {
                   "Integer", "4", "400", null, null, "3", "true", null, "true", null, "true",
                   "Integer", null, null, "4", null, "10", null));
 
-      MatcherAssert.assertThat(results, is(matchers));
+      assertThat(results).isEqualTo(matchers);
     }
   }
 
@@ -317,10 +316,8 @@ public void testExecuteQuery() throws Exception {
                 .get(0)
                 .getTicket())) {
       assertAll(
-          () ->
-              MatcherAssert.assertThat(stream.getSchema(), is(FlightSqlTestProducer.FIXED_SCHEMA)),
-          () ->
-              MatcherAssert.assertThat(getResults(stream), is(singletonList(singletonList("1")))));
+          () -> assertThat(stream.getSchema()).isEqualTo(FlightSqlTestProducer.FIXED_SCHEMA),
+          () -> assertThat(getResults(stream)).isEqualTo(singletonList(singletonList("1"))));
     }
   }
 }