Repository: strimzi/strimzi-kafka-bridge
Pull request #362 (2019-10-14 14:22:30)

Replace jupiter by hamcrest
Signed-off-by: Stanislav Knot <sknot@redhat.com>

Fixes: https://github.com/strimzi/strimzi-kafka-bridge/issues/352

stanlyDoge: It should be because of better failure messages: https://objectpartners.com/2013/09/18/the-benefits-of-using-assertthat-over-other-assert-methods-in-unit-tests/
ppatierno: About failure messages, I agree but saying that `assertEquals(expected, actual);` is " very cryptic" ... :-D
ppatierno: @Seequick1  @Frawless any more comments? 
Seequick1: Everything seems fine for me. LGTM

Patch:
diff --git a/pom.xml b/pom.xml
index 8adbf1c..651d4c4 100644
--- a/pom.xml
+++ b/pom.xml
@@ -17,8 +17,8 @@
 		<vertx.version>3.8.1</vertx.version>
 		<debezium.version>0.8.3.Final</debezium.version>
 		<maven.checkstyle.version>3.0.0</maven.checkstyle.version>
-		<jupiter.version>5.4.0</jupiter.version>
 		<junit.platform.version>1.4.0</junit.platform.version>
+		<hamcrest.version>1.3</hamcrest.version>
 		<maven-surefire-plugin.version>2.22.1</maven-surefire-plugin.version>
 		<swagger2markup.version>1.3.3</swagger2markup.version>
 		<jackson-databind.version>2.9.10</jackson-databind.version>
@@ -109,31 +109,12 @@
 		</dependency>
 
 		<!-- Testing -->
-		<dependency>
-			<groupId>org.junit.jupiter</groupId>
-			<artifactId>junit-jupiter-api</artifactId>
-			<version>${jupiter.version}</version>
-			<scope>test</scope>
-		</dependency>
 		<dependency>
 			<groupId>org.junit.platform</groupId>
 			<artifactId>junit-platform-runner</artifactId>
 			<version>${junit.platform.version}</version>
 			<scope>test</scope>
 		</dependency>
-		<dependency>
-			<groupId>org.junit.jupiter</groupId>
-			<artifactId>junit-jupiter-engine</artifactId>
-			<version>${jupiter.version}</version>
-			<scope>test</scope>
-		</dependency>
-		<dependency>
-			<groupId>org.junit.jupiter</groupId>
-			<artifactId>junit-jupiter-params</artifactId>
-			<version>${jupiter.version}</version>
-			<scope>test</scope>
-		</dependency>
-
 		<dependency>
 			<groupId>io.vertx</groupId>
 			<artifactId>vertx-unit</artifactId>
@@ -177,6 +158,12 @@
 			<version>2.12.4</version>
 			<scope>test</scope>
 		</dependency>
+		<dependency>
+			<groupId>org.hamcrest</groupId>
+			<artifactId>hamcrest-all</artifactId>
+			<version>${hamcrest.version}</version>
+			<scope>test</scope>
+		</dependency>
 	</dependencies>
 
 	<pluginRepositories>


Test patch:
diff --git a/src/test/java/io/strimzi/kafka/bridge/amqp/AmqpBridgeTest.java b/src/test/java/io/strimzi/kafka/bridge/amqp/AmqpBridgeTest.java
index 6b772a3..d79d039 100644
--- a/src/test/java/io/strimzi/kafka/bridge/amqp/AmqpBridgeTest.java
+++ b/src/test/java/io/strimzi/kafka/bridge/amqp/AmqpBridgeTest.java
@@ -52,7 +52,6 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -61,11 +60,10 @@ import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 
-import static org.junit.jupiter.api.Assertions.assertArrayEquals;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertNull;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.hamcrest.Matchers.nullValue;
 
 @ExtendWith(VertxExtension.class)
 @SuppressWarnings({"checkstyle:ClassFanOutComplexity", "ClassDataAbstractionCoupling"})
@@ -149,7 +147,7 @@ class AmqpBridgeTest {
 
                 KafkaConsumer<String, String> consumer = KafkaConsumer.create(this.vertx, config);
                 consumer.handler(record -> {
-                    context.verify(() -> assertEquals(record.value(), body));
+                    context.verify(() -> assertThat(record.value(), is(body)));
                     log.info("Message consumed topic={} partition={} offset={}, key={}, value={}",
                             record.topic(), record.partition(), record.offset(), record.key(), record.value());
                     consumer.close();
@@ -164,7 +162,7 @@ class AmqpBridgeTest {
 
                 sender.send(ProtonHelper.tag("my_tag"), message, delivery -> {
                     log.info("Message delivered {}", delivery.getRemoteState());
-                    context.verify(() -> assertEquals(Accepted.getInstance(), delivery.getRemoteState()));
+                    context.verify(() -> assertThat(Accepted.getInstance(), is(delivery.getRemoteState())));
 
                     sender.close();
                     connection.close();
@@ -173,7 +171,7 @@ class AmqpBridgeTest {
                 context.failNow(ar.cause());
             }
         });
-        assertTrue(context.awaitCompletion(60, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(60, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -209,9 +207,9 @@ class AmqpBridgeTest {
 
                 KafkaConsumer<String, String> consumer = KafkaConsumer.create(this.vertx, config);
                 consumer.handler(record -> {
-                    context.verify(() -> assertEquals(record.value(), body));
+                    context.verify(() -> assertThat(record.value(), is(body)));
                     // checking the right partition which should not be just the first one (0)
-                    context.verify(() -> assertEquals(record.partition(), 1));
+                    context.verify(() -> assertThat(record.partition(), is(1)));
                     log.info("Message consumed topic={} partition={} offset={}, key={}, value={}",
                             record.topic(), record.partition(), record.offset(), record.key(), record.value());
                     consumer.close();
@@ -231,7 +229,7 @@ class AmqpBridgeTest {
 
                 sender.send(ProtonHelper.tag("my_tag"), message, delivery -> {
                     log.info("Message delivered {}", delivery.getRemoteState());
-                    context.verify(() -> assertEquals(Accepted.getInstance(), delivery.getRemoteState()));
+                    context.verify(() -> assertThat(Accepted.getInstance(), is(delivery.getRemoteState())));
 
                     sender.close();
                     connection.close();
@@ -240,7 +238,7 @@ class AmqpBridgeTest {
                 context.failNow(ar.cause());
             }
         });
-        assertTrue(context.awaitCompletion(60, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(60, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -269,8 +267,8 @@ class AmqpBridgeTest {
 
                 KafkaConsumer<String, String> consumer = KafkaConsumer.create(this.vertx, config);
                 consumer.handler(record -> {
-                    context.verify(() -> assertEquals(record.value(), body));
-                    context.verify(() -> assertEquals(record.key(), "my_key"));
+                    context.verify(() -> assertThat(record.value(), is(body)));
+                    context.verify(() -> assertThat(record.key(), is("my_key")));
                     log.info("Message consumed topic={} partition={} offset={}, key={}, value={}",
                             record.topic(), record.partition(), record.offset(), record.key(), record.value());
                     consumer.close();
@@ -290,7 +288,7 @@ class AmqpBridgeTest {
 
                 sender.send(ProtonHelper.tag("my_tag"), message, delivery -> {
                     log.info("Message delivered {}", delivery.getRemoteState());
-                    context.verify(() -> assertEquals(Accepted.getInstance(), delivery.getRemoteState()));
+                    context.verify(() -> assertThat(Accepted.getInstance(), is(delivery.getRemoteState())));
 
                     sender.close();
                     connection.close();
@@ -299,7 +297,7 @@ class AmqpBridgeTest {
                 context.failNow(ar.cause());
             }
         });
-        assertTrue(context.awaitCompletion(60, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(60, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -327,7 +325,7 @@ class AmqpBridgeTest {
 
                 KafkaConsumer<String, byte[]> consumer = KafkaConsumer.create(this.vertx, config);
                 consumer.handler(record -> {
-                    context.verify(() -> assertArrayEquals(record.value(), value.getBytes()));
+                    context.verify(() -> assertThat(record.value(), is(value.getBytes())));
                     consumer.close();
                     consume.flag();
                 });
@@ -343,7 +341,7 @@ class AmqpBridgeTest {
 
                 sender.send(ProtonHelper.tag("my_tag"), message, delivery -> {
                     log.info("Message delivered {}", delivery.getRemoteState());
-                    context.verify(() -> assertEquals(Accepted.getInstance(), delivery.getRemoteState()));
+                    context.verify(() -> assertThat(Accepted.getInstance(), is(delivery.getRemoteState())));
 
                     sender.close();
                     connection.close();
@@ -352,7 +350,7 @@ class AmqpBridgeTest {
                 context.failNow(ar.cause());
             }
         });
-        assertTrue(context.awaitCompletion(60, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(60, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -383,7 +381,7 @@ class AmqpBridgeTest {
                 consumer.handler(record -> {
                     log.info("Message consumed topic={} partition={} offset={}, key={}, value={}",
                             record.topic(), record.partition(), record.offset(), record.key(), record.value());
-                    context.verify(() -> assertTrue(Arrays.equals(record.value(), array)));
+                    context.verify(() -> assertThat(record.value(), is(array)));
                     consumer.close();
                     consume.flag();
                 });
@@ -399,13 +397,13 @@ class AmqpBridgeTest {
 
                 sender.send(ProtonHelper.tag("my_tag"), message, delivery -> {
                     log.info("Message delivered {}", delivery.getRemoteState());
-                    context.verify(() -> assertEquals(Accepted.getInstance(), delivery.getRemoteState()));
+                    context.verify(() -> assertThat(Accepted.getInstance(), is(delivery.getRemoteState())));
                 });
             } else {
                 context.failNow(ar.cause());
             }
         });
-        assertTrue(context.awaitCompletion(60, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(60, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -438,7 +436,7 @@ class AmqpBridgeTest {
                 consumer.handler(record -> {
                     log.info("Message consumed topic={} partition={} offset={}, key={}, value={}",
                             record.topic(), record.partition(), record.offset(), record.key(), record.value());
-                    context.verify(() -> assertTrue(record.value().equals(list)));
+                    context.verify(() -> assertThat(record.value().equals(list), is(true)));
                     consumer.close();
                     consume.flag();
                 });
@@ -454,13 +452,13 @@ class AmqpBridgeTest {
 
                 sender.send(ProtonHelper.tag("my_tag"), message, delivery -> {
                     log.info("Message delivered {}", delivery.getRemoteState());
-                    context.verify(() -> assertEquals(Accepted.getInstance(), delivery.getRemoteState()));
+                    context.verify(() -> assertThat(Accepted.getInstance(), is(delivery.getRemoteState())));
                 });
             } else {
                 context.failNow(ar.cause());
             }
         });
-        assertTrue(context.awaitCompletion(60, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(60, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -493,7 +491,7 @@ class AmqpBridgeTest {
                 consumer.handler(record -> {
                     log.info("Message consumed topic={} partition={} offset={}, key={}, value={}",
                             record.topic(), record.partition(), record.offset(), record.key(), record.value());
-                    context.verify(() -> assertEquals(record.value(), map));
+                    context.verify(() -> assertThat(record.value(), is(map)));
                     consumer.close();
                     consume.flag();
                 });
@@ -509,13 +507,13 @@ class AmqpBridgeTest {
 
                 sender.send(ProtonHelper.tag("my_tag"), message, delivery -> {
                     log.info("Message delivered {}", delivery.getRemoteState());
-                    context.verify(() -> assertEquals(Accepted.getInstance(), delivery.getRemoteState()));
+                    context.verify(() -> assertThat(Accepted.getInstance(), is(delivery.getRemoteState())));
                 });
             } else {
                 context.failNow(ar.cause());
             }
         });
-        assertTrue(context.awaitCompletion(60, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(60, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -543,13 +541,13 @@ class AmqpBridgeTest {
                 consumer.batchHandler(records -> {
 
                     context.verify(() -> {
-                        assertEquals(this.count, records.size());
+                        assertThat(this.count, is(records.size()));
                         for (int i = 0; i < records.size(); i++) {
                             KafkaConsumerRecord<String, String> record = records.recordAt(i);
                             log.info("Message consumed topic={} partition={} offset={}, key={}, value={}",
                                     record.topic(), record.partition(), record.offset(), record.key(), record.value());
                             int finalI = i;
-                            assertEquals("key-" + finalI, record.key());
+                            assertThat("key-" + finalI, is(record.key()));
                         }
                     });
 
@@ -566,7 +564,7 @@ class AmqpBridgeTest {
                     if (connection.isDisconnected()) {
                         this.vertx.cancelTimer(timerId);
                         // test failed
-                        context.verify(() -> assertTrue(false));
+                        context.verify(() -> assertThat(false, is(true)));
                     } else {
 
                         if (this.count < AmqpBridgeTest.PERIODIC_MAX_MESSAGE) {
@@ -581,7 +579,7 @@ class AmqpBridgeTest {
 
                             sender.send(ProtonHelper.tag("my_tag_" + this.count), message, delivery -> {
                                 log.info("Message delivered {}", delivery.getRemoteState());
-                                context.verify(() -> assertEquals(Accepted.getInstance(), delivery.getRemoteState()));
+                                context.verify(() -> assertThat(Accepted.getInstance(), is(delivery.getRemoteState())));
                             });
 
                             this.count++;
@@ -602,7 +600,7 @@ class AmqpBridgeTest {
                 context.failNow(ar.cause());
             }
         });
-        assertTrue(context.awaitCompletion(60, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(60, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -632,7 +630,7 @@ class AmqpBridgeTest {
                         log.info("Message received {}", new String(value));
                         // default is AT_LEAST_ONCE QoS (unsettled) so we need to send disposition (settle) to sender
                         delivery.disposition(Accepted.getInstance(), true);
-                        context.verify(() -> assertEquals(sentBody, new String(value)));
+                        context.verify(() -> assertThat(sentBody, is(new String(value))));
                         consume.flag();
                     }
                 })
@@ -643,14 +641,14 @@ class AmqpBridgeTest {
 
                 sender.send(ProtonHelper.tag("my_tag"), sentMessage, delivery -> {
                     log.info("Message delivered {}", delivery.getRemoteState());
-                    context.verify(() -> assertEquals(Accepted.getInstance(), delivery.getRemoteState()));
+                    context.verify(() -> assertThat(Accepted.getInstance(), is(delivery.getRemoteState())));
                 });
 
             } else {
                 context.failNow(ar.cause());
             }
         });
-        assertTrue(context.awaitCompletion(60, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(60, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -683,22 +681,22 @@ class AmqpBridgeTest {
                         // get topic, partition, offset and key from AMQP annotations
                         MessageAnnotations annotations = message.getMessageAnnotations();
                         context.verify(() -> {
-                            assertNotNull(annotations);
+                            assertThat(annotations, notNullValue());
                             String topicAnnotation = String.valueOf(annotations.getValue().get(Symbol.valueOf(AmqpBridge.AMQP_TOPIC_ANNOTATION)));
-                            assertNotNull(topicAnnotation);
+                            assertThat(topicAnnotation, notNullValue());
                             Integer partitionAnnotation = (Integer) annotations.getValue().get(Symbol.valueOf(AmqpBridge.AMQP_PARTITION_ANNOTATION));
-                            assertNotNull(partitionAnnotation);
+                            assertThat(partitionAnnotation, notNullValue());
                             Long offsetAnnotation = (Long) annotations.getValue().get(Symbol.valueOf(AmqpBridge.AMQP_OFFSET_ANNOTATION));
-                            assertNotNull(offsetAnnotation);
+                            assertThat(offsetAnnotation, notNullValue());
                             Object keyAnnotation = annotations.getValue().get(Symbol.valueOf(AmqpBridge.AMQP_KEY_ANNOTATION));
-                            assertNull(keyAnnotation);
+                            assertThat(keyAnnotation, nullValue());
                             log.info("Message consumed topic={} partition={} offset={}, key={}, value={}",
                                     topicAnnotation, partitionAnnotation, offsetAnnotation, keyAnnotation, new String(value));
 
-                            assertEquals(topicAnnotation, topic);
-                            assertEquals(partitionAnnotation, 0);
-                            assertEquals(offsetAnnotation, 0L);
-                            assertEquals(sentBody, new String(value));
+                            assertThat(topicAnnotation, is(topic));
+                            assertThat(partitionAnnotation, is(0));
+                            assertThat(offsetAnnotation, is(0L));
+                            assertThat(sentBody, is(new String(value)));
                         });
                         consume.flag();
                     }
@@ -708,7 +706,7 @@ class AmqpBridgeTest {
                 context.failNow(ar.cause());
             }
         });
-        assertTrue(context.awaitCompletion(60, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(60, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -750,22 +748,22 @@ class AmqpBridgeTest {
 
                         // get topic, partition, offset and key from AMQP annotations
                         MessageAnnotations annotations = message.getMessageAnnotations();
-                        context.verify(() -> assertNotNull(annotations));
+                        context.verify(() -> assertThat(annotations, notNullValue()));
                         String topicAnnotation = String.valueOf(annotations.getValue().get(Symbol.valueOf(AmqpBridge.AMQP_TOPIC_ANNOTATION)));
-                        assertNotNull(topicAnnotation);
+                        assertThat(topicAnnotation, notNullValue());
                         Integer partitionAnnotation = (Integer) annotations.getValue().get(Symbol.valueOf(AmqpBridge.AMQP_PARTITION_ANNOTATION));
-                        assertNotNull(partitionAnnotation);
+                        assertThat(partitionAnnotation, notNullValue());
                         Long offsetAnnotation = (Long) annotations.getValue().get(Symbol.valueOf(AmqpBridge.AMQP_OFFSET_ANNOTATION));
-                        assertNotNull(offsetAnnotation);
+                        assertThat(offsetAnnotation, notNullValue());
                         Object keyAnnotation = annotations.getValue().get(Symbol.valueOf(AmqpBridge.AMQP_KEY_ANNOTATION));
-                        assertNull(keyAnnotation);
+                        assertThat(keyAnnotation, nullValue());
                         log.info("Message consumed topic={} partition={} offset={}, key={}, value={}",
                                 topicAnnotation, partitionAnnotation, offsetAnnotation, keyAnnotation, new String(value));
 
-                        assertEquals(topicAnnotation, topic);
-                        assertEquals(partitionAnnotation, 1);
-                        assertEquals(offsetAnnotation, 0L);
-                        assertEquals(sentBody, new String(value));
+                        assertThat(topicAnnotation, is(topic));
+                        assertThat(partitionAnnotation, is(1));
+                        assertThat(offsetAnnotation, is(0L));
+                        assertThat(sentBody, is(new String(value)));
                         consume.flag();
                     }
                 })
@@ -774,7 +772,7 @@ class AmqpBridgeTest {
                 context.failNow(ar.cause());
             }
         });
-        assertTrue(context.awaitCompletion(60, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(60, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -815,23 +813,23 @@ class AmqpBridgeTest {
 
                         // get topic, partition, offset and key from AMQP annotations
                         MessageAnnotations annotations = message.getMessageAnnotations();
-                        context.verify(() -> assertNotNull(annotations));
+                        context.verify(() -> assertThat(annotations, notNullValue()));
                         String topicAnnotation = String.valueOf(annotations.getValue().get(Symbol.valueOf(AmqpBridge.AMQP_TOPIC_ANNOTATION)));
-                        assertNotNull(topicAnnotation);
+                        assertThat(topicAnnotation, notNullValue());
                         Integer partitionAnnotation = (Integer) annotations.getValue().get(Symbol.valueOf(AmqpBridge.AMQP_PARTITION_ANNOTATION));
-                        assertNotNull(partitionAnnotation);
+                        assertThat(partitionAnnotation, notNullValue());
                         Long offsetAnnotation = (Long) annotations.getValue().get(Symbol.valueOf(AmqpBridge.AMQP_OFFSET_ANNOTATION));
-                        assertNotNull(offsetAnnotation);
+                        assertThat(offsetAnnotation, notNullValue());
                         Object keyAnnotation = annotations.getValue().get(Symbol.valueOf(AmqpBridge.AMQP_KEY_ANNOTATION));
-                        assertNotNull(keyAnnotation);
+                        assertThat(keyAnnotation, notNullValue());
                         log.info("Message consumed topic={} partition={} offset={}, key={}, value={}",
                                 topicAnnotation, partitionAnnotation, offsetAnnotation, keyAnnotation, new String(value));
 
-                        assertEquals(topicAnnotation, topic);
-                        assertEquals(partitionAnnotation, 0);
-                        assertEquals(offsetAnnotation, 10L);
-                        assertEquals(keyAnnotation, "key-10");
-                        assertEquals("value-10", new String(value));
+                        assertThat(topicAnnotation, is(topic));
+                        assertThat(partitionAnnotation, is(0));
+                        assertThat(offsetAnnotation, is(10L));
+                        assertThat(keyAnnotation, is("key-10"));
+                        assertThat(new String(value), is("value-10"));
                         consume.flag();
                     }
                 })
@@ -840,7 +838,7 @@ class AmqpBridgeTest {
                 context.failNow(ar.cause());
             }
         });
-        assertTrue(context.awaitCompletion(60, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(60, TimeUnit.SECONDS), is(true));
     }
 
     @Disabled
@@ -870,7 +868,7 @@ class AmqpBridgeTest {
                         } else {
                             ErrorCondition condition = receiver1.getRemoteCondition();
                             log.info(condition.getDescription());
-                            context.verify(() -> assertEquals(condition.getCondition(), Symbol.getSymbol(AmqpBridge.AMQP_ERROR_NO_PARTITIONS)));
+                            context.verify(() -> assertThat(condition.getCondition(), is(Symbol.getSymbol(AmqpBridge.AMQP_ERROR_NO_PARTITIONS))));
                             noPartition.flag();
                         }
                     })
@@ -882,20 +880,20 @@ class AmqpBridgeTest {
                 context.failNow(ar.cause());
             }
         });
-        assertTrue(context.awaitCompletion(60, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(60, TimeUnit.SECONDS), is(true));
     }
 
     @Test
     void defaultMessageConverterNullKeyTest(VertxTestContext context) {
         MessageConverter defaultMessageConverter = new AmqpDefaultMessageConverter();
-        context.verify(() -> assertNull(convertedMessageWithNullKey(defaultMessageConverter)));
+        context.verify(() -> assertThat(convertedMessageWithNullKey(defaultMessageConverter), nullValue()));
         context.completeNow();
     }
 
     @Test
     void jsonMessageConverterNullKeyTest(VertxTestContext context) {
         MessageConverter jsonMessageConverter = new AmqpJsonMessageConverter();
-        context.verify(() -> assertNull(convertedMessageWithNullKey(jsonMessageConverter)));
+        context.verify(() -> assertThat(convertedMessageWithNullKey(jsonMessageConverter), nullValue()));
         context.completeNow();
     }
 
@@ -903,7 +901,7 @@ class AmqpBridgeTest {
     @Test
     void rawMessageConverterNullKeyTest(VertxTestContext context) {
         MessageConverter rawMessageConverter = new AmqpRawMessageConverter();
-        context.verify(() -> assertNull(convertedMessageWithNullKey(rawMessageConverter)));
+        context.verify(() -> assertThat(convertedMessageWithNullKey(rawMessageConverter), nullValue()));
         context.completeNow();
     }
 
diff --git a/src/test/java/io/strimzi/kafka/bridge/amqp/AmqpSinkBridgeEndpointMockTest.java b/src/test/java/io/strimzi/kafka/bridge/amqp/AmqpSinkBridgeEndpointMockTest.java
index cd8f5d1..3a6f1aa 100644
--- a/src/test/java/io/strimzi/kafka/bridge/amqp/AmqpSinkBridgeEndpointMockTest.java
+++ b/src/test/java/io/strimzi/kafka/bridge/amqp/AmqpSinkBridgeEndpointMockTest.java
@@ -49,8 +49,8 @@ import java.util.Map;
 import java.util.function.Supplier;
 
 import static junit.framework.TestCase.fail;
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.Mockito.mock;
@@ -147,8 +147,8 @@ class AmqpSinkBridgeEndpointMockTest {
         ArgumentCaptor<ErrorCondition> errorCap = ArgumentCaptor.forClass(ErrorCondition.class);
         verify(mockSender).setCondition(errorCap.capture());
         verify(mockSender).close();
-        assertEquals(errorCondition, errorCap.getValue().getCondition().toString());
-        assertEquals(errorMessage, errorCap.getValue().getDescription());
+        assertThat(errorCap.getValue().getCondition().toString(), is(errorCondition));
+        assertThat(errorCap.getValue().getDescription(), is(errorMessage));
     }
 
     // Test normal flow in AT_MOST_ONCE mode.
@@ -209,12 +209,13 @@ class AmqpSinkBridgeEndpointMockTest {
         verify(mockSender).send(tagCap.capture(), messageCap.capture());
         Message message = messageCap.getValue();
         // Assert the transformed message was as expected
-        assertEquals(topic + "/group.id/my_group", message.getAddress());
-        assertArrayEquals("Hello, world".getBytes(), ((Data) message.getBody()).getValue().getArray());
+        assertThat(topic + "/group.id/my_group", is(message.getAddress()));
+
+        assertThat(((Data) message.getBody()).getValue().getArray(), is("Hello, world".getBytes()));
         MessageAnnotations messageAnnotations = message.getMessageAnnotations();
-        assertEquals(topic, messageAnnotations.getValue().get(Symbol.valueOf(AmqpBridge.AMQP_TOPIC_ANNOTATION)));
-        assertEquals(0, messageAnnotations.getValue().get(Symbol.valueOf(AmqpBridge.AMQP_PARTITION_ANNOTATION)));
-        assertEquals(0L, messageAnnotations.getValue().get(Symbol.valueOf(AmqpBridge.AMQP_OFFSET_ANNOTATION)));
+        assertThat(messageAnnotations.getValue().get(Symbol.valueOf(AmqpBridge.AMQP_TOPIC_ANNOTATION)), is(topic));
+        assertThat(messageAnnotations.getValue().get(Symbol.valueOf(AmqpBridge.AMQP_PARTITION_ANNOTATION)), is(0));
+        assertThat(messageAnnotations.getValue().get(Symbol.valueOf(AmqpBridge.AMQP_OFFSET_ANNOTATION)), is(0L));
 
         // TODO test closure (commit)
     }
@@ -260,12 +261,12 @@ class AmqpSinkBridgeEndpointMockTest {
         Message message = messageCap.getValue();
 
         // Assert the transformed message was as expected
-        assertEquals(topic + "/group.id/my_group", message.getAddress());
-        assertArrayEquals("Hello, world".getBytes(), ((Data) message.getBody()).getValue().getArray());
+        assertThat(message.getAddress(), is(topic + "/group.id/my_group"));
+        assertThat(((Data) message.getBody()).getValue().getArray(), is("Hello, world".getBytes()));
         MessageAnnotations messageAnnotations = message.getMessageAnnotations();
-        assertEquals(topic, messageAnnotations.getValue().get(Symbol.valueOf(AmqpBridge.AMQP_TOPIC_ANNOTATION)));
-        assertEquals(0, messageAnnotations.getValue().get(Symbol.valueOf(AmqpBridge.AMQP_PARTITION_ANNOTATION)));
-        assertEquals(0L, messageAnnotations.getValue().get(Symbol.valueOf(AmqpBridge.AMQP_OFFSET_ANNOTATION)));
+        assertThat(messageAnnotations.getValue().get(Symbol.valueOf(AmqpBridge.AMQP_TOPIC_ANNOTATION)), is(topic));
+        assertThat(messageAnnotations.getValue().get(Symbol.valueOf(AmqpBridge.AMQP_PARTITION_ANNOTATION)), is(0));
+        assertThat(messageAnnotations.getValue().get(Symbol.valueOf(AmqpBridge.AMQP_OFFSET_ANNOTATION)), is(0L));
 
         // Simulate Proton delivering settlement
         ProtonDelivery mockDelivery = mock(ProtonDelivery.class);
diff --git a/src/test/java/io/strimzi/kafka/bridge/http/ConsumerGeneratedNameTest.java b/src/test/java/io/strimzi/kafka/bridge/http/ConsumerGeneratedNameTest.java
index a64d983..3ae1da2 100644
--- a/src/test/java/io/strimzi/kafka/bridge/http/ConsumerGeneratedNameTest.java
+++ b/src/test/java/io/strimzi/kafka/bridge/http/ConsumerGeneratedNameTest.java
@@ -19,8 +19,8 @@ import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
 
 public class ConsumerGeneratedNameTest extends HttpBridgeTestBase {
 
@@ -54,13 +54,13 @@ public class ConsumerGeneratedNameTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonObject())
                 .sendJsonObject(json, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                         JsonObject bridgeResponse = response.body();
                         String consumerInstanceId = bridgeResponse.getString("instance_id");
                         name = consumerInstanceId;
-                        assertTrue(consumerInstanceId.startsWith("kafka-bridge-consumer-"));
+                        assertThat(consumerInstanceId.startsWith("kafka-bridge-consumer-"), is(true));
                         create.complete(true);
                     });
                 });
@@ -82,12 +82,12 @@ public class ConsumerGeneratedNameTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonObject())
                 .sendJsonObject(json, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                         JsonObject bridgeResponse = response.body();
                         String consumerInstanceId = bridgeResponse.getString("instance_id");
-                        assertTrue(consumerInstanceId.equals("consumer-1"));
+                        assertThat(consumerInstanceId, is("consumer-1"));
                         create.complete(true);
                     });
                 });
diff --git a/src/test/java/io/strimzi/kafka/bridge/http/ConsumerSubscriptionTest.java b/src/test/java/io/strimzi/kafka/bridge/http/ConsumerSubscriptionTest.java
index a4078e1..111ec25 100644
--- a/src/test/java/io/strimzi/kafka/bridge/http/ConsumerSubscriptionTest.java
+++ b/src/test/java/io/strimzi/kafka/bridge/http/ConsumerSubscriptionTest.java
@@ -20,8 +20,8 @@ import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
 
 public class ConsumerSubscriptionTest extends HttpBridgeTestBase {
 
@@ -46,12 +46,12 @@ public class ConsumerSubscriptionTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonObject())
                 .sendJsonObject(topicsRoot, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
                         HttpBridgeError error = HttpBridgeError.fromJson(response.body());
-                        assertEquals(HttpResponseStatus.NOT_FOUND.code(), response.statusCode());
-                        assertEquals(HttpResponseStatus.NOT_FOUND.code(), error.getCode());
-                        assertEquals("The specified consumer instance was not found.", error.getMessage());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.NOT_FOUND.code()));
+                        assertThat(error.getCode(), is(HttpResponseStatus.NOT_FOUND.code()));
+                        assertThat(error.getMessage(), is("The specified consumer instance was not found."));
                     });
                     unsubscribe.complete(true);
                 });
@@ -88,13 +88,12 @@ public class ConsumerSubscriptionTest extends HttpBridgeTestBase {
             .subscribeConsumerRequest(groupId, name, topicsRoot)
                 .sendJsonObject(topicsRoot, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
-                        assertEquals(HttpResponseStatus.CONFLICT.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.CONFLICT.code()));
                         HttpBridgeError error = HttpBridgeError.fromJson(response.body());
-                        assertEquals(HttpResponseStatus.CONFLICT.code(), error.getCode());
-                        assertEquals("Subscriptions to topics, partitions, and patterns are mutually exclusive.",
-                                error.getMessage());
+                        assertThat(error.getCode(), is(HttpResponseStatus.CONFLICT.code()));
+                        assertThat(error.getMessage(), is("Subscriptions to topics, partitions, and patterns are mutually exclusive."));
                     });
 
                     subscribeConflict.complete(true);
@@ -109,13 +108,12 @@ public class ConsumerSubscriptionTest extends HttpBridgeTestBase {
             .subscribeConsumerRequest(groupId, name, topicsRoot)
                 .sendJsonObject(topicsRoot, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
-                        assertEquals(HttpResponseStatus.UNPROCESSABLE_ENTITY.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.UNPROCESSABLE_ENTITY.code()));
                         HttpBridgeError error = HttpBridgeError.fromJson(response.body());
-                        assertEquals(HttpResponseStatus.UNPROCESSABLE_ENTITY.code(), error.getCode());
-                        assertEquals("A list (of Topics type) or a topic_pattern must be specified.",
-                                error.getMessage());
+                        assertThat(error.getCode(), is(HttpResponseStatus.UNPROCESSABLE_ENTITY.code()));
+                        assertThat(error.getMessage(), is("A list (of Topics type) or a topic_pattern must be specified."));
                     });
 
                     subscribeEmpty.complete(true);
@@ -124,7 +122,7 @@ public class ConsumerSubscriptionTest extends HttpBridgeTestBase {
         subscribeEmpty.get(TEST_TIMEOUT, TimeUnit.SECONDS);
 
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
         consumerService()
             .deleteConsumer(context, groupId, name);
     }
@@ -147,12 +145,12 @@ public class ConsumerSubscriptionTest extends HttpBridgeTestBase {
             .subscribeConsumerRequest(groupId, name, topicsRoot)
                 .sendJsonObject(topicsRoot, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
                         HttpBridgeError error = HttpBridgeError.fromJson(response.body());
-                        assertEquals(HttpResponseStatus.NOT_FOUND.code(), response.statusCode());
-                        assertEquals(HttpResponseStatus.NOT_FOUND.code(), error.getCode());
-                        assertEquals("The specified consumer instance was not found.", error.getMessage());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.NOT_FOUND.code()));
+                        assertThat(error.getCode(), is(HttpResponseStatus.NOT_FOUND.code()));
+                        assertThat(error.getMessage(), is("The specified consumer instance was not found."));
                     });
                     subscribe.complete(true);
                 });
@@ -200,23 +198,23 @@ public class ConsumerSubscriptionTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonObject())
                 .send(ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
 
                         HttpResponse<JsonObject> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
-                        assertEquals(response.body().getJsonArray("topics").size(), 2);
-                        assertTrue(response.body().getJsonArray("topics").contains(topic));
-                        assertTrue(response.body().getJsonArray("topics").contains(topic2));
-                        assertEquals(response.body().getJsonArray("partitions").size(), 2);
-                        assertEquals(response.body().getJsonArray("partitions").getJsonObject(0).getJsonArray(topic2).size(), 4);
-                        assertEquals(response.body().getJsonArray("partitions").getJsonObject(1).getJsonArray(topic).size(), 1);
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
+                        assertThat(response.body().getJsonArray("topics").size(), is(2));
+                        assertThat(response.body().getJsonArray("topics").contains(topic), is(true));
+                        assertThat(response.body().getJsonArray("topics").contains(topic2), is(true));
+                        assertThat(response.body().getJsonArray("partitions").size(), is(2));
+                        assertThat(response.body().getJsonArray("partitions").getJsonObject(0).getJsonArray(topic2).size(), is(4));
+                        assertThat(response.body().getJsonArray("partitions").getJsonObject(1).getJsonArray(topic).size(), is(1));
                         listSubscriptions.complete(true);
                         context.completeNow();
                     });
                 });
 
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
         consumerService()
             .deleteConsumer(context, groupId, name);
     }
-}
+}
\ No newline at end of file
diff --git a/src/test/java/io/strimzi/kafka/bridge/http/ConsumerTest.java b/src/test/java/io/strimzi/kafka/bridge/http/ConsumerTest.java
index fea3b41..3c5a91a 100644
--- a/src/test/java/io/strimzi/kafka/bridge/http/ConsumerTest.java
+++ b/src/test/java/io/strimzi/kafka/bridge/http/ConsumerTest.java
@@ -28,11 +28,9 @@ import java.util.concurrent.atomic.AtomicReference;
 
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.hamcrest.CoreMatchers.nullValue;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertNull;
-import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class ConsumerTest extends HttpBridgeTestBase {
 
@@ -58,7 +56,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService().createConsumer(context, groupId, consumerWithEarliestReset);
 
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
         consumerService()
             .deleteConsumer(context, groupId, name);
     }
@@ -74,19 +72,19 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService().createConsumerRequest(groupId, consumerJson)
                 .sendJsonObject(consumerJson, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
-                        assertEquals(HttpResponseStatus.UNPROCESSABLE_ENTITY.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.UNPROCESSABLE_ENTITY.code()));
                         HttpBridgeError error = HttpBridgeError.fromJson(response.body());
-                        assertEquals(HttpResponseStatus.UNPROCESSABLE_ENTITY.code(), error.getCode());
-                        assertEquals("Invalid format type.", error.getMessage());
+                        assertThat(error.getCode(), is(HttpResponseStatus.UNPROCESSABLE_ENTITY.code()));
+                        assertThat(error.getMessage(), is("Invalid format type."));
                     });
                     create.complete(true);
                 });
 
         create.get(TEST_TIMEOUT, TimeUnit.SECONDS);
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -98,15 +96,15 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService().createConsumerRequest(groupId, null)
                 .send(ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                         JsonObject bridgeResponse = response.body();
                         String consumerInstanceId = bridgeResponse.getString("instance_id");
                         name.set(consumerInstanceId);
                         String consumerBaseUri = bridgeResponse.getString("base_uri");
-                        assertTrue(consumerInstanceId.startsWith(config.get(BridgeConfig.BRIDGE_ID).toString()));
-                        assertEquals(Urls.consumerInstance(groupId, consumerInstanceId), consumerBaseUri);
+                        assertThat(consumerInstanceId.startsWith(config.get(BridgeConfig.BRIDGE_ID).toString()), is(true));
+                        assertThat(consumerBaseUri, is(Urls.consumerInstance(groupId, consumerInstanceId)));
                     });
                     create.complete(true);
                 });
@@ -115,7 +113,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService()
             .deleteConsumer(context, groupId, name.get());
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -146,13 +144,12 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService().createConsumerRequest(groupId, consumerJson)
                 .sendJsonObject(consumerJson, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
-                        assertEquals(HttpResponseStatus.BAD_REQUEST.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.BAD_REQUEST.code()));
                         HttpBridgeError error = HttpBridgeError.fromJson(response.body());
-                        assertEquals(HttpResponseStatus.BAD_REQUEST.code(), error.getCode());
-                        assertEquals("Validation error on: body.enable.auto.commit - $.enable.auto.commit: string found, boolean expected",
-                                error.getMessage());
+                        assertThat(error.getCode(), is(HttpResponseStatus.BAD_REQUEST.code()));
+                        assertThat(error.getMessage(), is("Validation error on: body.enable.auto.commit - $.enable.auto.commit: string found, boolean expected"));
                     });
                     create.complete(true);
                 });
@@ -161,7 +158,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService()
             .deleteConsumer(context, groupId, name);
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -201,13 +198,12 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService().createConsumerRequest(groupId, consumerJson)
                 .sendJsonObject(consumerJson, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
-                        assertEquals(HttpResponseStatus.BAD_REQUEST.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.BAD_REQUEST.code()));
                         HttpBridgeError error = HttpBridgeError.fromJson(response.body());
-                        assertEquals(HttpResponseStatus.BAD_REQUEST.code(), error.getCode());
-                        assertEquals("Validation error on: body." + param + " - $." + param + ": string found, integer expected",
-                                error.getMessage());
+                        assertThat(error.getCode(), is(HttpResponseStatus.BAD_REQUEST.code()));
+                        assertThat(error.getMessage(), is("Validation error on: body." + param + " - $." + param + ": string found, integer expected"));
                     });
                     create.complete(true);
                 });
@@ -218,7 +214,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService()
             .deleteConsumer(context, groupId, name + "-1");
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -235,14 +231,14 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 .putHeader(X_FORWARDED_PROTO, xForwardedProto)
                 .sendJsonObject(consumerWithEarliestReset, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                         JsonObject bridgeResponse = response.body();
                         String consumerInstanceId = bridgeResponse.getString("instance_id");
                         String consumerBaseUri = bridgeResponse.getString("base_uri");
-                        assertEquals(name, consumerInstanceId);
-                        assertEquals(baseUri, consumerBaseUri);
+                        assertThat(consumerInstanceId, is(name));
+                        assertThat(consumerBaseUri, is(baseUri));
                     });
                     create.complete(true);
                 });
@@ -251,7 +247,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
             .deleteConsumer(context, groupId, name);
         context.completeNow();
 
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -266,14 +262,14 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 .putHeader(FORWARDED, forwarded)
                 .sendJsonObject(consumerWithEarliestReset, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                         JsonObject bridgeResponse = response.body();
                         String consumerInstanceId = bridgeResponse.getString("instance_id");
                         String consumerBaseUri = bridgeResponse.getString("base_uri");
-                        assertEquals(name, consumerInstanceId);
-                        assertEquals(baseUri, consumerBaseUri);
+                        assertThat(consumerInstanceId, is(name));
+                        assertThat(consumerBaseUri, is(baseUri));
                     });
                     create.complete(true);
                 });
@@ -282,7 +278,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService()
             .deleteConsumer(context, groupId, name);
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -302,14 +298,14 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 .putHeaders(headers)
                 .sendJsonObject(consumerWithEarliestReset, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                         JsonObject bridgeResponse = response.body();
                         String consumerInstanceId = bridgeResponse.getString("instance_id");
                         String consumerBaseUri = bridgeResponse.getString("base_uri");
-                        assertEquals(name, consumerInstanceId);
-                        assertEquals(baseUri, consumerBaseUri);
+                        assertThat(consumerInstanceId, is(name));
+                        assertThat(consumerBaseUri, is(baseUri));
                     });
                     create.complete(true);
                 });
@@ -318,7 +314,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService()
             .deleteConsumer(context, groupId, name);
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
 
@@ -336,14 +332,14 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 .putHeader("X-Forwarded-Path", xForwardedPath)
                 .sendJsonObject(consumerWithEarliestReset, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                         JsonObject bridgeResponse = response.body();
                         String consumerInstanceId = bridgeResponse.getString("instance_id");
                         String consumerBaseUri = bridgeResponse.getString("base_uri");
-                        assertEquals(name, consumerInstanceId);
-                        assertEquals(baseUri, consumerBaseUri);
+                        assertThat(consumerInstanceId, is(name));
+                        assertThat(consumerBaseUri, is(baseUri));
                     });
                     create.complete(true);
                 });
@@ -352,7 +348,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService()
             .deleteConsumer(context, groupId, name);
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -367,14 +363,14 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 .putHeader(FORWARDED, forwarded)
                 .sendJsonObject(consumerWithEarliestReset, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                         JsonObject bridgeResponse = response.body();
                         String consumerInstanceId = bridgeResponse.getString("instance_id");
                         String consumerBaseUri = bridgeResponse.getString("base_uri");
-                        assertEquals(name, consumerInstanceId);
-                        assertEquals(baseUri, consumerBaseUri);
+                        assertThat(consumerInstanceId, is(name));
+                        assertThat(consumerBaseUri, is(baseUri));
                     });
                     create.complete(true);
                 });
@@ -383,7 +379,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService()
             .deleteConsumer(context, groupId, name);
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -395,17 +391,17 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 .putHeader(FORWARDED, forwarded)
                 .sendJsonObject(consumerWithEarliestReset, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
                         HttpBridgeError error = HttpBridgeError.fromJson(response.body());
-                        assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR.code(), response.statusCode());
-                        assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR.code(), error.getCode());
-                        assertEquals("mqtt is not a valid schema/proto.", error.getMessage());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.INTERNAL_SERVER_ERROR.code()));
+                        assertThat(error.getCode(), is(HttpResponseStatus.INTERNAL_SERVER_ERROR.code()));
+                        assertThat(error.getMessage(), is("mqtt is not a valid schema/proto."));
                     });
                     context.completeNow();
                 });
 
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -414,7 +410,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 "Invalid value foo for configuration auto.offset.reset: String must be one of: latest, earliest, none", context);
 
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -423,7 +419,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 "Validation error on: body.enable.auto.commit - $.enable.auto.commit: string found, boolean expected", context);
 
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -432,7 +428,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 "Validation error on: body.fetch.min.bytes - $.fetch.min.bytes: string found, integer expected", context);
 
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -441,7 +437,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 "Validation error on: body - $.foo: is not defined in the schema and the schema does not allow additional properties", context);
 
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -465,9 +461,9 @@ public class ConsumerTest extends HttpBridgeTestBase {
             .as(BodyCodec.jsonArray())
             .send(ar -> {
                 context.verify(() -> {
-                    assertTrue(ar.succeeded());
+                    assertThat(ar.succeeded(), is(true));
                     HttpResponse<JsonArray> response = ar.result();
-                    assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                    assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                     JsonObject jsonResponse = response.body().getJsonObject(0);
 
                     String kafkaTopic = jsonResponse.getString("topic");
@@ -476,11 +472,11 @@ public class ConsumerTest extends HttpBridgeTestBase {
                     String value = jsonResponse.getString("value");
                     long offset = jsonResponse.getLong("offset");
 
-                    assertEquals(topic, kafkaTopic);
-                    assertEquals(sentBody, value);
-                    assertEquals(0L, offset);
-                    assertNotNull(kafkaPartition);
-                    assertNull(key);
+                    assertThat(kafkaTopic, is(topic));
+                    assertThat(value, is(sentBody));
+                    assertThat(offset, is(0L));
+                    assertThat(kafkaPartition, notNullValue());
+                    assertThat(key, nullValue());
                 });
                 consume.complete(true);
             });
@@ -491,7 +487,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService()
             .deleteConsumer(context, groupId, name);
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -519,9 +515,9 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonArray())
                 .send(ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonArray> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                         JsonObject jsonResponse = response.body().getJsonObject(0);
 
                         String kafkaTopic = jsonResponse.getString("topic");
@@ -530,11 +526,11 @@ public class ConsumerTest extends HttpBridgeTestBase {
                         String value = new String(DatatypeConverter.parseBase64Binary(jsonResponse.getString("value")));
                         long offset = jsonResponse.getLong("offset");
 
-                        assertEquals(topic, kafkaTopic);
-                        assertEquals(sentBody, value);
-                        assertEquals(0L, offset);
-                        assertNotNull(kafkaPartition);
-                        assertNull(key);
+                        assertThat(kafkaTopic, is(topic));
+                        assertThat(value, is(sentBody));
+                        assertThat(offset, is(0L));
+                        assertThat(kafkaPartition, notNullValue());
+                        assertThat(key, nullValue());
                     });
                     consume.complete(true);
                 });
@@ -545,7 +541,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService()
             .deleteConsumer(context, groupId, name);
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -573,13 +569,13 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonArray())
                 .send(ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonArray> response = ar.result();
-                        assertEquals(2, response.body().size());
+                        assertThat(response.body().size(), is(2));
 
                         for (int i = 0; i < 2; i++) {
                             JsonObject jsonResponse = response.body().getJsonObject(i);
-                            assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                            assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
 
                             String kafkaTopic = jsonResponse.getString("topic");
                             int kafkaPartition = jsonResponse.getInteger("partition");
@@ -587,11 +583,11 @@ public class ConsumerTest extends HttpBridgeTestBase {
                             String value = jsonResponse.getString("value");
                             long offset = jsonResponse.getLong("offset");
 
-                            assertEquals("receiveSimpleMessage-" + (i + 1), kafkaTopic);
-                            assertEquals("Simple message-" + (i + 1), value);
-                            assertEquals(0L, offset);
-                            assertNotNull(kafkaPartition);
-                            assertNull(key);
+                            assertThat(kafkaTopic, is("receiveSimpleMessage-" + (i + 1)));
+                            assertThat(value, is("Simple message-" + (i + 1)));
+                            assertThat(offset, is(0L));
+                            assertThat(kafkaPartition, notNullValue());
+                            assertThat(key, nullValue());
                         }
                     });
                     consume.complete(true);
@@ -602,7 +598,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService()
             .deleteConsumer(context, groupId, name);
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -632,10 +628,10 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonArray())
                 .send(ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonArray> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
-                        assertEquals(2, response.body().size());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
+                        assertThat(response.body().size(), is(2));
 
                         for (int i = 0; i < 2; i++) {
                             JsonObject jsonResponse = response.body().getJsonObject(i);
@@ -646,11 +642,11 @@ public class ConsumerTest extends HttpBridgeTestBase {
                             String value = jsonResponse.getString("value");
                             long offset = jsonResponse.getLong("offset");
 
-                            assertEquals("receiveWithPattern-" + (i + 1), kafkaTopic);
-                            assertEquals("Simple message-" + (i + 1), value);
-                            assertEquals(0L, offset);
-                            assertNotNull(kafkaPartition);
-                            assertNull(key);
+                            assertThat(kafkaTopic, is("receiveWithPattern-" + (i + 1)));
+                            assertThat(value, is("Simple message-" + (i + 1)));
+                            assertThat(offset, is(0L));
+                            assertThat(kafkaPartition, notNullValue());
+                            assertThat(key, nullValue());
                         }
                     });
                     consume.complete(true);
@@ -662,7 +658,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService()
             .deleteConsumer(context, groupId, name);
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -687,9 +683,9 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonArray())
                 .send(ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonArray> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                         JsonObject jsonResponse = response.body().getJsonObject(0);
 
                         String kafkaTopic = jsonResponse.getString("topic");
@@ -698,11 +694,11 @@ public class ConsumerTest extends HttpBridgeTestBase {
                         String value = jsonResponse.getString("value");
                         long offset = jsonResponse.getLong("offset");
 
-                        assertEquals(topic, kafkaTopic);
-                        assertEquals(sentBody, value);
-                        assertEquals(partition, kafkaPartition);
-                        assertEquals(0L, offset);
-                        assertNull(key);
+                        assertThat(kafkaTopic, is(topic));
+                        assertThat(value, is(sentBody));
+                        assertThat(kafkaPartition, is(partition));
+                        assertThat(offset, is(0L));
+                        assertThat(key, nullValue());
                     });
                     consume.complete(true);
                 });
@@ -713,7 +709,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService()
             .deleteConsumer(context, groupId, name);
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -739,10 +735,10 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonArray())
                 .send(ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonArray> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
-                        assertEquals(2, response.body().size());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
+                        assertThat(response.body().size(), is(2));
 
                         for (int i = 0; i < 2; i++) {
                             JsonObject jsonResponse = response.body().getJsonObject(i);
@@ -753,12 +749,12 @@ public class ConsumerTest extends HttpBridgeTestBase {
                             String value = jsonResponse.getString("value");
                             long offset = jsonResponse.getLong("offset");
 
-                            assertEquals("receiveSimpleMessageFromMultiplePartitions", kafkaTopic);
-                            assertEquals("Simple message from partition", value);
-                            assertEquals(0L, offset);
+                            assertThat(kafkaTopic, is("receiveSimpleMessageFromMultiplePartitions"));
+                            assertThat(value, is("Simple message from partition"));
+                            assertThat(offset, is(0L));
                             //context.assertNotNull(kafkaPartition);
-                            assertEquals(i, kafkaPartition);
-                            assertNull(key);
+                            assertThat(i, is(kafkaPartition));
+                            assertThat(key, nullValue());
                         }
                     });
                     consume.complete(true);
@@ -770,7 +766,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService()
             .deleteConsumer(context, groupId, name);
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -797,9 +793,9 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonArray())
                 .send(ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonArray> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                         JsonObject jsonResponse = response.body().getJsonObject(0);
 
                         String kafkaTopic = jsonResponse.getString("topic");
@@ -808,11 +804,11 @@ public class ConsumerTest extends HttpBridgeTestBase {
                         String value = jsonResponse.getString("value");
                         long offset = jsonResponse.getLong("offset");
 
-                        assertEquals(topic, kafkaTopic);
-                        assertEquals(sentBody, value);
-                        assertEquals(0L, offset);
-                        assertNotNull(kafkaPartition);
-                        assertNull(key);
+                        assertThat(kafkaTopic, is(topic));
+                        assertThat(value, is(sentBody));
+                        assertThat(offset, is(0L));
+                        assertThat(kafkaPartition, notNullValue());
+                        assertThat(key, nullValue());
                     });
                     consume.complete(true);
                 });
@@ -834,11 +830,11 @@ public class ConsumerTest extends HttpBridgeTestBase {
             .offsetsRequest(groupId, name, root)
                 .sendJsonObject(root, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
 
                         int code = response.statusCode();
-                        assertEquals(HttpResponseStatus.NO_CONTENT.code(), code);
+                        assertThat(code, is(HttpResponseStatus.NO_CONTENT.code()));
                     });
                     commit.complete(true);
                 });
@@ -849,7 +845,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService()
             .deleteConsumer(context, groupId, name);
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -876,9 +872,9 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonArray())
                 .send(ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonArray> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                         JsonObject jsonResponse = response.body().getJsonObject(0);
 
                         String kafkaTopic = jsonResponse.getString("topic");
@@ -887,11 +883,11 @@ public class ConsumerTest extends HttpBridgeTestBase {
                         String value = jsonResponse.getString("value");
                         long offset = jsonResponse.getLong("offset");
 
-                        assertEquals(topic, kafkaTopic);
-                        assertEquals(sentBody, value);
-                        assertEquals(0L, offset);
-                        assertNotNull(kafkaPartition);
-                        assertNull(key);
+                        assertThat(kafkaTopic, is(topic));
+                        assertThat(value, is(sentBody));
+                        assertThat(offset, is(0L));
+                        assertThat(kafkaPartition, notNullValue());
+                        assertThat(key, nullValue());
                     });
                     consume.complete(true);
                 });
@@ -904,11 +900,11 @@ public class ConsumerTest extends HttpBridgeTestBase {
             .offsetsRequest(groupId, name)
                 .send(ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
 
                         int code = response.statusCode();
-                        assertEquals(HttpResponseStatus.NO_CONTENT.code(), code);
+                        assertThat(code, is(HttpResponseStatus.NO_CONTENT.code()));
                     });
                     commit.complete(true);
                 });
@@ -919,7 +915,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService()
             .deleteConsumer(context, groupId, name);
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -941,12 +937,12 @@ public class ConsumerTest extends HttpBridgeTestBase {
             .createConsumerRequest(groupId, json)
                 .sendJsonObject(json, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
                         HttpBridgeError error = HttpBridgeError.fromJson(response.body());
-                        assertEquals(HttpResponseStatus.CONFLICT.code(), response.statusCode());
-                        assertEquals(HttpResponseStatus.CONFLICT.code(), error.getCode());
-                        assertEquals("A consumer instance with the specified name already exists in the Kafka Bridge.", error.getMessage());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.CONFLICT.code()));
+                        assertThat(error.getCode(), is(HttpResponseStatus.CONFLICT.code()));
+                        assertThat(error.getMessage(), is("A consumer instance with the specified name already exists in the Kafka Bridge."));
                         context.completeNow();
                     });
                     create2Again.complete(true);
@@ -961,14 +957,14 @@ public class ConsumerTest extends HttpBridgeTestBase {
             .createConsumerRequest(groupId, json)
                 .sendJsonObject(json, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                         JsonObject bridgeResponse = response.body();
                         String consumerInstanceId = bridgeResponse.getString("instance_id");
                         String consumerBaseUri = bridgeResponse.getString("base_uri");
-                        assertEquals(name + "diff", consumerInstanceId);
-                        assertEquals(Urls.consumerInstance(groupId, name) + "diff", consumerBaseUri);
+                        assertThat(consumerInstanceId, is(name + "diff"));
+                        assertThat(consumerBaseUri, is(Urls.consumerInstance(groupId, name) + "diff"));
                     });
                     create3Again.complete(true);
                 });
@@ -989,12 +985,12 @@ public class ConsumerTest extends HttpBridgeTestBase {
             .as(BodyCodec.jsonObject())
             .send(ar -> {
                 context.verify(() -> {
-                    assertTrue(ar.succeeded());
+                    assertThat(ar.succeeded(), is(true));
                     HttpResponse<JsonObject> response = ar.result();
                     HttpBridgeError error = HttpBridgeError.fromJson(response.body());
-                    assertEquals(HttpResponseStatus.NOT_FOUND.code(), response.statusCode());
-                    assertEquals(HttpResponseStatus.NOT_FOUND.code(), error.getCode());
-                    assertEquals("The specified consumer instance was not found.", error.getMessage());
+                    assertThat(response.statusCode(), is(HttpResponseStatus.NOT_FOUND.code()));
+                    assertThat(error.getCode(), is(HttpResponseStatus.NOT_FOUND.code()));
+                    assertThat(error.getMessage(), is("The specified consumer instance was not found."));
                 });
                 context.completeNow();
             });
@@ -1017,12 +1013,12 @@ public class ConsumerTest extends HttpBridgeTestBase {
             .offsetsRequest(groupId, name, root)
                 .sendJsonObject(root, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
                         HttpBridgeError error = HttpBridgeError.fromJson(response.body());
-                        assertEquals(HttpResponseStatus.NOT_FOUND.code(), response.statusCode());
-                        assertEquals(HttpResponseStatus.NOT_FOUND.code(), error.getCode());
-                        assertEquals("The specified consumer instance was not found.", error.getMessage());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.NOT_FOUND.code()));
+                        assertThat(error.getCode(), is(HttpResponseStatus.NOT_FOUND.code()));
+                        assertThat(error.getMessage(), is("The specified consumer instance was not found."));
                     });
                     context.completeNow();
                 });
@@ -1054,13 +1050,12 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonObject())
                 .send(ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
                         HttpBridgeError error = HttpBridgeError.fromJson(response.body());
-                        assertEquals(HttpResponseStatus.UNPROCESSABLE_ENTITY.code(), response.statusCode());
-                        assertEquals(HttpResponseStatus.UNPROCESSABLE_ENTITY.code(), error.getCode());
-                        assertEquals("Response exceeds the maximum number of bytes the consumer can receive",
-                                error.getMessage());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.UNPROCESSABLE_ENTITY.code()));
+                        assertThat(error.getCode(), is(HttpResponseStatus.UNPROCESSABLE_ENTITY.code()));
+                        assertThat(error.getMessage(), is("Response exceeds the maximum number of bytes the consumer can receive"));
                     });
                     consume.complete(true);
                 });
@@ -1071,7 +1066,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService()
             .deleteConsumer(context, groupId, name);
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
 
@@ -1096,9 +1091,9 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonArray())
                 .send(ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonArray> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                         JsonObject jsonResponse = response.body().getJsonObject(0);
 
                         String kafkaTopic = jsonResponse.getString("topic");
@@ -1107,11 +1102,11 @@ public class ConsumerTest extends HttpBridgeTestBase {
                         String value = jsonResponse.getString("value");
                         long offset = jsonResponse.getLong("offset");
 
-                        assertEquals(topic, kafkaTopic);
-                        assertEquals(sentBody, value);
-                        assertEquals(0L, offset);
-                        assertNotNull(kafkaPartition);
-                        assertNull(key);
+                        assertThat(kafkaTopic, is(topic));
+                        assertThat(value, is(sentBody));
+                        assertThat(offset, is(0L));
+                        assertThat(kafkaPartition, notNullValue());
+                        assertThat(key, nullValue());
                     });
                     consume.complete(true);
                 });
@@ -1131,12 +1126,12 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonObject())
                 .send(ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
                         HttpBridgeError error = HttpBridgeError.fromJson(response.body());
-                        assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR.code(), response.statusCode());
-                        assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR.code(), error.getCode());
-                        assertEquals("Consumer is not subscribed to any topics or assigned any partitions", error.getMessage());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.INTERNAL_SERVER_ERROR.code()));
+                        assertThat(error.getCode(), is(HttpResponseStatus.INTERNAL_SERVER_ERROR.code()));
+                        assertThat(error.getMessage(), is("Consumer is not subscribed to any topics or assigned any partitions"));
                     });
                     consume2.complete(true);
                 });
@@ -1147,7 +1142,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService()
             .deleteConsumer(context, groupId, name);
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -1171,12 +1166,12 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonObject())
                 .send(ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
                         HttpBridgeError error = HttpBridgeError.fromJson(response.body());
-                        assertEquals(HttpResponseStatus.NOT_ACCEPTABLE.code(), response.statusCode());
-                        assertEquals(HttpResponseStatus.NOT_ACCEPTABLE.code(), error.getCode());
-                        assertEquals("Consumer format does not match the embedded format requested by the Accept header.", error.getMessage());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.NOT_ACCEPTABLE.code()));
+                        assertThat(error.getCode(), is(HttpResponseStatus.NOT_ACCEPTABLE.code()));
+                        assertThat(error.getMessage(), is("Consumer format does not match the embedded format requested by the Accept header."));
                     });
                     consume.complete(true);
                 });
@@ -1187,7 +1182,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService()
             .deleteConsumer(context, groupId, name);
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -1218,16 +1213,16 @@ public class ConsumerTest extends HttpBridgeTestBase {
             .sendRecordsRequest(topic, root, BridgeContentType.KAFKA_JSON_JSON)
                 .sendJsonObject(root, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                         JsonObject bridgeResponse = response.body();
 
                         JsonArray offsets = bridgeResponse.getJsonArray("offsets");
-                        assertEquals(1, offsets.size());
+                        assertThat(offsets.size(), is(1));
                         JsonObject metadata = offsets.getJsonObject(0);
-                        assertEquals(0, metadata.getInteger("partition"));
-                        assertEquals(0L, metadata.getLong("offset"));
+                        assertThat(metadata.getInteger("partition"), is(0));
+                        assertThat(metadata.getLong("offset"), is(0L));
                     });
                     produce.complete(true);
                 });
@@ -1251,9 +1246,9 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonArray())
                 .send(ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonArray> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                         JsonObject jsonResponse = response.body().getJsonObject(0);
 
                         String kafkaTopic = jsonResponse.getString("topic");
@@ -1262,11 +1257,11 @@ public class ConsumerTest extends HttpBridgeTestBase {
                         JsonObject value = jsonResponse.getJsonObject("value");
                         long offset = jsonResponse.getLong("offset");
 
-                        assertEquals(topic, kafkaTopic);
-                        assertEquals(sentValue, value);
-                        assertEquals(0L, offset);
-                        assertNotNull(kafkaPartition);
-                        assertEquals(sentKey, key);
+                        assertThat(kafkaTopic, is(topic));
+                        assertThat(value, is(sentValue));
+                        assertThat(offset, is(0L));
+                        assertThat(kafkaPartition, notNullValue());
+                        assertThat(key, is(sentKey));
                     });
                     consume.complete(true);
                 });
@@ -1277,7 +1272,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService()
             .deleteConsumer(context, groupId, name);
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -1308,12 +1303,12 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonObject())
                 .send(ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
                         HttpBridgeError error = HttpBridgeError.fromJson(response.body());
-                        assertEquals(HttpResponseStatus.NOT_ACCEPTABLE.code(), response.statusCode());
-                        assertEquals(HttpResponseStatus.NOT_ACCEPTABLE.code(), error.getCode());
-                        assertTrue(error.getMessage().startsWith("Failed to decode"));
+                        assertThat(response.statusCode(), is(HttpResponseStatus.NOT_ACCEPTABLE.code()));
+                        assertThat(error.getCode(), is(HttpResponseStatus.NOT_ACCEPTABLE.code()));
+                        assertThat(error.getMessage().startsWith("Failed to decode"), is(true));
                     });
                     consume.complete(true);
                 });
@@ -1325,7 +1320,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
             .deleteConsumer(context, groupId, name);
 
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -1339,13 +1334,13 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonObject())
                 .sendJsonObject(json, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                         JsonObject bridgeResponse = response.body();
                         String consumerInstanceId = bridgeResponse.getString("instance_id");
                         name.set(consumerInstanceId);
-                        assertTrue(consumerInstanceId.startsWith(config.get(BridgeConfig.BRIDGE_ID).toString()));
+                        assertThat(consumerInstanceId.startsWith(config.get(BridgeConfig.BRIDGE_ID).toString()), is(true));
                         create.complete(true);
                     });
                 });
@@ -1367,12 +1362,12 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonObject())
                 .sendJsonObject(json, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                         JsonObject bridgeResponse = response.body();
                         String consumerInstanceId = bridgeResponse.getString("instance_id");
-                        assertTrue(consumerInstanceId.equals("consumer-1"));
+                        assertThat(consumerInstanceId, is("consumer-1"));
                     });
                     create.complete(true);
                 });
@@ -1391,14 +1386,14 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonObject())
                 .sendJsonObject(consumerJson, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                         JsonObject bridgeResponse = response.body();
                         String consumerInstanceId = bridgeResponse.getString("instance_id");
                         String consumerBaseUri = bridgeResponse.getString("base_uri");
-                        assertEquals(name, consumerInstanceId);
-                        assertEquals(Urls.consumerInstance(groupId, name), consumerBaseUri);
+                        assertThat(consumerInstanceId, is(name));
+                        assertThat(consumerBaseUri, is(Urls.consumerInstance(groupId, name)));
 
                         vertx.setTimer(timeout * 2 * 1000L, timeouted -> {
                             CompletableFuture<Boolean> delete = new CompletableFuture<>();
@@ -1406,11 +1401,11 @@ public class ConsumerTest extends HttpBridgeTestBase {
                             consumerService()
                                 .deleteConsumerRequest(groupId, name)
                                     .send(consumerDeletedResponse -> {
-                                        context.verify(() -> assertTrue(ar.succeeded()));
+                                        context.verify(() -> assertThat(ar.succeeded(), is(true)));
 
                                         HttpResponse<JsonObject> deletionResponse = consumerDeletedResponse.result();
-                                        assertEquals(HttpResponseStatus.NOT_FOUND.code(), deletionResponse.statusCode());
-                                        assertEquals("The specified consumer instance was not found.", deletionResponse.body().getString("message"));
+                                        assertThat(deletionResponse.statusCode(), is(HttpResponseStatus.NOT_FOUND.code()));
+                                        assertThat(deletionResponse.body().getString("message"), is("The specified consumer instance was not found."));
 
                                         delete.complete(true);
                                         context.completeNow();
@@ -1430,12 +1425,12 @@ public class ConsumerTest extends HttpBridgeTestBase {
         consumerService().createConsumerRequest(groupId, json)
             .sendJsonObject(json, ar -> {
                 context.verify(() -> {
-                    assertTrue(ar.succeeded());
+                    assertThat(ar.succeeded(), is(true));
                     HttpResponse<JsonObject> response = ar.result();
-                    assertEquals(status.code(), response.statusCode());
+                    assertThat(response.statusCode(), is(status.code()));
                     HttpBridgeError error = HttpBridgeError.fromJson(response.body());
-                    assertEquals(status.code(), error.getCode());
-                    assertEquals(message, error.getMessage());
+                    assertThat(error.getCode(), is(status.code()));
+                    assertThat(error.getMessage(), is(message));
                 });
                 consumer.complete(true);
             });
@@ -1458,7 +1453,7 @@ public class ConsumerTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonObject())
                 .sendJsonObject(requestHeader, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
                         assertThat("Response status code is not '422'", response.statusCode(), is(HttpResponseStatus.UNPROCESSABLE_ENTITY.code()));
                         HttpBridgeError error = HttpBridgeError.fromJson(response.body());
diff --git a/src/test/java/io/strimzi/kafka/bridge/http/OtherServicesTest.java b/src/test/java/io/strimzi/kafka/bridge/http/OtherServicesTest.java
index f8446ae..09035c1 100644
--- a/src/test/java/io/strimzi/kafka/bridge/http/OtherServicesTest.java
+++ b/src/test/java/io/strimzi/kafka/bridge/http/OtherServicesTest.java
@@ -14,9 +14,8 @@ import org.junit.jupiter.api.Test;
 
 import java.util.Map;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
 
 public class OtherServicesTest extends HttpBridgeTestBase {
 
@@ -29,8 +28,8 @@ public class OtherServicesTest extends HttpBridgeTestBase {
                 .getRequest("/ready")
                     .send(ar -> {
                         context.verify(() -> {
-                            assertTrue(ar.succeeded());
-                            assertEquals(HttpResponseStatus.OK.code(), ar.result().statusCode());
+                            assertThat(ar.succeeded(), is(true));
+                            assertThat(ar.result().statusCode(), is(HttpResponseStatus.OK.code()));
                         });
                         if (l == iterations) {
                             context.completeNow();
@@ -49,8 +48,8 @@ public class OtherServicesTest extends HttpBridgeTestBase {
                 .getRequest("/healthy")
                     .send(ar -> {
                         context.verify(() -> {
-                            assertTrue(ar.succeeded());
-                            assertEquals(HttpResponseStatus.OK.code(), ar.result().statusCode());
+                            assertThat(ar.succeeded(), is(true));
+                            assertThat(ar.result().statusCode(), is(HttpResponseStatus.OK.code()));
                         });
                         if (l == iterations) {
                             context.completeNow();
@@ -67,46 +66,46 @@ public class OtherServicesTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonObject())
                 .send(ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                         JsonObject bridgeResponse = response.body();
 
                         Map<String, Object> paths = bridgeResponse.getJsonObject("paths").getMap();
-                        // subscribe, list subscribtions and unsubscribe are using the same endpoint but different methods
+                        // subscribe, list subscriptions and unsubscribe are using the same endpoint but different methods
                         int pathsSize = HttpOpenApiOperations.values().length - 2;
-                        assertEquals(pathsSize, paths.size());
-                        assertTrue(paths.containsKey("/consumers/{groupid}"));
-                        assertEquals(HttpOpenApiOperations.CREATE_CONSUMER.toString(), bridgeResponse.getJsonObject("paths").getJsonObject("/consumers/{groupid}").getJsonObject("post").getString("operationId"));
-                        assertTrue(paths.containsKey("/consumers/{groupid}/instances/{name}/positions"));
-                        assertEquals(HttpOpenApiOperations.SEEK.toString(), bridgeResponse.getJsonObject("paths").getJsonObject("/consumers/{groupid}/instances/{name}/positions").getJsonObject("post").getString("operationId"));
-                        assertTrue(paths.containsKey("/consumers/{groupid}/instances/{name}/positions/beginning"));
-                        assertEquals(HttpOpenApiOperations.SEEK_TO_BEGINNING.toString(), bridgeResponse.getJsonObject("paths").getJsonObject("/consumers/{groupid}/instances/{name}/positions/beginning").getJsonObject("post").getString("operationId"));
-                        assertTrue(paths.containsKey("/consumers/{groupid}/instances/{name}/positions/end"));
-                        assertEquals(HttpOpenApiOperations.SEEK_TO_END.toString(), bridgeResponse.getJsonObject("paths").getJsonObject("/consumers/{groupid}/instances/{name}/positions/end").getJsonObject("post").getString("operationId"));
-                        assertTrue(paths.containsKey("/consumers/{groupid}/instances/{name}/subscription"));
-                        assertEquals(HttpOpenApiOperations.SUBSCRIBE.toString(), bridgeResponse.getJsonObject("paths").getJsonObject("/consumers/{groupid}/instances/{name}/subscription").getJsonObject("post").getString("operationId"));
-                        assertEquals(HttpOpenApiOperations.UNSUBSCRIBE.toString(), bridgeResponse.getJsonObject("paths").getJsonObject("/consumers/{groupid}/instances/{name}/subscription").getJsonObject("delete").getString("operationId"));
-                        assertEquals(HttpOpenApiOperations.LIST_SUBSCRIPTIONS.toString(), bridgeResponse.getJsonObject("paths").getJsonObject("/consumers/{groupid}/instances/{name}/subscription").getJsonObject("get").getString("operationId"));
-                        assertTrue(paths.containsKey("/consumers/{groupid}/instances/{name}/assignments"));
-                        assertEquals(HttpOpenApiOperations.ASSIGN.toString(), bridgeResponse.getJsonObject("paths").getJsonObject("/consumers/{groupid}/instances/{name}/assignments").getJsonObject("post").getString("operationId"));
-                        assertTrue(paths.containsKey("/consumers/{groupid}/instances/{name}/records"));
-                        assertEquals(HttpOpenApiOperations.POLL.toString(), bridgeResponse.getJsonObject("paths").getJsonObject("/consumers/{groupid}/instances/{name}/records").getJsonObject("get").getString("operationId"));
-                        assertTrue(paths.containsKey("/consumers/{groupid}/instances/{name}/offsets"));
-                        assertEquals(HttpOpenApiOperations.COMMIT.toString(), bridgeResponse.getJsonObject("paths").getJsonObject("/consumers/{groupid}/instances/{name}/offsets").getJsonObject("post").getString("operationId"));
-                        assertTrue(paths.containsKey("/topics/{topicname}"));
-                        assertEquals(HttpOpenApiOperations.SEND.toString(), bridgeResponse.getJsonObject("paths").getJsonObject("/topics/{topicname}").getJsonObject("post").getString("operationId"));
-                        assertTrue(paths.containsKey("/topics/{topicname}/partitions/{partitionid}"));
-                        assertEquals(HttpOpenApiOperations.SEND_TO_PARTITION.toString(), bridgeResponse.getJsonObject("paths").getJsonObject("/topics/{topicname}/partitions/{partitionid}").getJsonObject("post").getString("operationId"));
-                        assertTrue(paths.containsKey("/healthy"));
-                        assertEquals(HttpOpenApiOperations.HEALTHY.toString(), bridgeResponse.getJsonObject("paths").getJsonObject("/healthy").getJsonObject("get").getString("operationId"));
-                        assertTrue(paths.containsKey("/ready"));
-                        assertEquals(HttpOpenApiOperations.READY.toString(), bridgeResponse.getJsonObject("paths").getJsonObject("/ready").getJsonObject("get").getString("operationId"));
-                        assertTrue(paths.containsKey("/openapi"));
-                        assertEquals(HttpOpenApiOperations.OPENAPI.toString(), bridgeResponse.getJsonObject("paths").getJsonObject("/openapi").getJsonObject("get").getString("operationId"));
-                        assertFalse(paths.containsKey("/karel"));
-                        assertEquals(18, bridgeResponse.getJsonObject("definitions").getMap().size());
-                        assertEquals(4, bridgeResponse.getJsonArray("tags").size());
+                        assertThat(paths.size(), is(pathsSize));
+                        assertThat(paths.containsKey("/consumers/{groupid}"), is(true));
+                        assertThat(bridgeResponse.getJsonObject("paths").getJsonObject("/consumers/{groupid}").getJsonObject("post").getString("operationId"), is(HttpOpenApiOperations.CREATE_CONSUMER.toString()));
+                        assertThat(paths.containsKey("/consumers/{groupid}/instances/{name}/positions"), is(true));
+                        assertThat(bridgeResponse.getJsonObject("paths").getJsonObject("/consumers/{groupid}/instances/{name}/positions").getJsonObject("post").getString("operationId"), is(HttpOpenApiOperations.SEEK.toString()));
+                        assertThat(paths.containsKey("/consumers/{groupid}/instances/{name}/positions/beginning"), is(true));
+                        assertThat(bridgeResponse.getJsonObject("paths").getJsonObject("/consumers/{groupid}/instances/{name}/positions/beginning").getJsonObject("post").getString("operationId"), is(HttpOpenApiOperations.SEEK_TO_BEGINNING.toString()));
+                        assertThat(paths.containsKey("/consumers/{groupid}/instances/{name}/positions/end"), is(true));
+                        assertThat(bridgeResponse.getJsonObject("paths").getJsonObject("/consumers/{groupid}/instances/{name}/positions/end").getJsonObject("post").getString("operationId"), is(HttpOpenApiOperations.SEEK_TO_END.toString()));
+                        assertThat(paths.containsKey("/consumers/{groupid}/instances/{name}/subscription"), is(true));
+                        assertThat(bridgeResponse.getJsonObject("paths").getJsonObject("/consumers/{groupid}/instances/{name}/subscription").getJsonObject("post").getString("operationId"), is(HttpOpenApiOperations.SUBSCRIBE.toString()));
+                        assertThat(bridgeResponse.getJsonObject("paths").getJsonObject("/consumers/{groupid}/instances/{name}/subscription").getJsonObject("delete").getString("operationId"), is(HttpOpenApiOperations.UNSUBSCRIBE.toString()));
+                        assertThat(bridgeResponse.getJsonObject("paths").getJsonObject("/consumers/{groupid}/instances/{name}/subscription").getJsonObject("get").getString("operationId"), is(HttpOpenApiOperations.LIST_SUBSCRIPTIONS.toString()));
+                        assertThat(paths.containsKey("/consumers/{groupid}/instances/{name}/assignments"), is(true));
+                        assertThat(bridgeResponse.getJsonObject("paths").getJsonObject("/consumers/{groupid}/instances/{name}/assignments").getJsonObject("post").getString("operationId"), is(HttpOpenApiOperations.ASSIGN.toString()));
+                        assertThat(paths.containsKey("/consumers/{groupid}/instances/{name}/records"), is(true));
+                        assertThat(bridgeResponse.getJsonObject("paths").getJsonObject("/consumers/{groupid}/instances/{name}/records").getJsonObject("get").getString("operationId"), is(HttpOpenApiOperations.POLL.toString()));
+                        assertThat(paths.containsKey("/consumers/{groupid}/instances/{name}/offsets"), is(true));
+                        assertThat(bridgeResponse.getJsonObject("paths").getJsonObject("/consumers/{groupid}/instances/{name}/offsets").getJsonObject("post").getString("operationId"), is(HttpOpenApiOperations.COMMIT.toString()));
+                        assertThat(paths.containsKey("/topics/{topicname}"), is(true));
+                        assertThat(bridgeResponse.getJsonObject("paths").getJsonObject("/topics/{topicname}").getJsonObject("post").getString("operationId"), is(HttpOpenApiOperations.SEND.toString()));
+                        assertThat(paths.containsKey("/topics/{topicname}/partitions/{partitionid}"), is(true));
+                        assertThat(bridgeResponse.getJsonObject("paths").getJsonObject("/topics/{topicname}/partitions/{partitionid}").getJsonObject("post").getString("operationId"), is(HttpOpenApiOperations.SEND_TO_PARTITION.toString()));
+                        assertThat(paths.containsKey("/healthy"), is(true));
+                        assertThat(bridgeResponse.getJsonObject("paths").getJsonObject("/healthy").getJsonObject("get").getString("operationId"), is(HttpOpenApiOperations.HEALTHY.toString()));
+                        assertThat(paths.containsKey("/ready"), is(true));
+                        assertThat(bridgeResponse.getJsonObject("paths").getJsonObject("/ready").getJsonObject("get").getString("operationId"), is(HttpOpenApiOperations.READY.toString()));
+                        assertThat(paths.containsKey("/openapi"), is(true));
+                        assertThat(bridgeResponse.getJsonObject("paths").getJsonObject("/openapi").getJsonObject("get").getString("operationId"), is(HttpOpenApiOperations.OPENAPI.toString()));
+                        assertThat(paths.containsKey("/karel"), is(false));
+                        assertThat(bridgeResponse.getJsonObject("definitions").getMap().size(), is(18));
+                        assertThat(bridgeResponse.getJsonArray("tags").size(), is(4));
                     });
                     context.completeNow();
                 });
@@ -119,11 +118,11 @@ public class OtherServicesTest extends HttpBridgeTestBase {
             .as(BodyCodec.jsonObject())
             .sendJsonObject(null, ar -> {
                 context.verify(() -> {
-                    assertTrue(ar.succeeded());
+                    assertThat(ar.succeeded(), is(true));
                     HttpResponse<JsonObject> response = ar.result();
                     HttpBridgeError error = HttpBridgeError.fromJson(response.body());
-                    assertEquals(HttpResponseStatus.NOT_FOUND.code(), response.statusCode());
-                    assertEquals(HttpResponseStatus.NOT_FOUND.code(), error.getCode());
+                    assertThat(response.statusCode(), is(HttpResponseStatus.NOT_FOUND.code()));
+                    assertThat(error.getCode(), is(HttpResponseStatus.NOT_FOUND.code()));
                 });
                 context.completeNow();
             });
diff --git a/src/test/java/io/strimzi/kafka/bridge/http/ProducerTest.java b/src/test/java/io/strimzi/kafka/bridge/http/ProducerTest.java
index b81c8aa..8b7a05a 100644
--- a/src/test/java/io/strimzi/kafka/bridge/http/ProducerTest.java
+++ b/src/test/java/io/strimzi/kafka/bridge/http/ProducerTest.java
@@ -28,10 +28,10 @@ import org.slf4j.LoggerFactory;
 import javax.xml.bind.DatatypeConverter;
 import java.util.Properties;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertNull;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.hamcrest.Matchers.nullValue;
 
 public class ProducerTest extends HttpBridgeTestBase {
 
@@ -62,11 +62,11 @@ public class ProducerTest extends HttpBridgeTestBase {
                 new StringDeserializer(), new KafkaJsonDeserializer<>(String.class));
         consumer.handler(record -> {
             context.verify(() -> {
-                assertEquals(value, record.value());
-                assertEquals(topic, record.topic());
-                assertEquals(0, record.partition());
-                assertEquals(0L, record.offset());
-                assertNull(record.key());
+                assertThat(record.value(), is(value));
+                assertThat(record.topic(), is(topic));
+                assertThat(record.partition(), is(0));
+                assertThat(record.offset(), is(0L));
+                assertThat(record.key(), nullValue());
             });
             LOGGER.info("Message consumed topic={} partition={} offset={}, key={}, value={}",
                     record.topic(), record.partition(), record.offset(), record.key(), record.value());
@@ -109,11 +109,11 @@ public class ProducerTest extends HttpBridgeTestBase {
                 new StringDeserializer(), new KafkaJsonDeserializer<>(String.class));
         consumer.handler(record -> {
             context.verify(() -> {
-                assertEquals(value, record.value());
-                assertEquals(topic, record.topic());
-                assertEquals(partition, record.partition());
-                assertEquals(0L, record.offset());
-                assertNull(record.key());
+                assertThat(record.value(), is(value));
+                assertThat(record.topic(), is(topic));
+                assertThat(record.partition(), is(partition));
+                assertThat(record.offset(), is(0L));
+                assertThat(record.key(), nullValue());
             });
             LOGGER.info("Message consumed topic={} partition={} offset={}, key={}, value={}",
                     record.topic(), record.partition(), record.offset(), record.key(), record.value());
@@ -155,11 +155,11 @@ public class ProducerTest extends HttpBridgeTestBase {
                 new KafkaJsonDeserializer<>(String.class), new KafkaJsonDeserializer<>(String.class));
         consumer.handler(record -> {
             context.verify(() -> {
-                assertEquals(value, record.value());
-                assertEquals(topic, record.topic());
-                assertNotNull(record.partition());
-                assertEquals(0L, record.offset());
-                assertEquals(record.key(), key);
+                assertThat(record.value(), is(value));
+                assertThat(record.topic(), is(topic));
+                assertThat(record.partition(), notNullValue());
+                assertThat(record.offset(), is(0L));
+                assertThat(record.key(), is(key));
             });
             LOGGER.info("Message consumed topic={} partition={} offset={}, key={}, value={}",
                     record.topic(), record.partition(), record.offset(), record.key(), record.value());
@@ -202,11 +202,11 @@ public class ProducerTest extends HttpBridgeTestBase {
                 new ByteArrayDeserializer(), new ByteArrayDeserializer());
         consumer.handler(record -> {
             context.verify(() -> {
-                assertEquals(value, new String(record.value()));
-                assertEquals(topic, record.topic());
-                assertNotNull(record.partition());
-                assertEquals(0L, record.offset());
-                assertEquals(key, new String(record.key()));
+                assertThat(new String(record.value()), is(value));
+                assertThat(record.topic(), is(topic));
+                assertThat(record.partition(), notNullValue());
+                assertThat(record.offset(), is(0L));
+                assertThat(new String(record.key()), is(key));
             });
 
             LOGGER.info("Message consumed topic={} partition={} offset={}, key={}, value={}",
@@ -265,16 +265,16 @@ public class ProducerTest extends HttpBridgeTestBase {
 
         consumer.batchHandler(records -> {
             context.verify(() -> {
-                assertEquals(this.count, records.size());
+                assertThat(records.size(), is(this.count));
                 for (int i = 0; i < records.size(); i++) {
                     KafkaConsumerRecord<String, String> record = records.recordAt(i);
                     LOGGER.info("Message consumed topic={} partition={} offset={}, key={}, value={}",
                             record.topic(), record.partition(), record.offset(), record.key(), record.value());
-                    assertEquals(record.value(), "Periodic message [" + i + "]");
-                    assertEquals(topic, record.topic());
-                    assertNotNull(record.partition());
-                    assertNotNull(record.offset());
-                    assertEquals(record.key(), "key-" + i);
+                    assertThat(record.value(), is("Periodic message [" + i + "]"));
+                    assertThat(record.topic(), is(topic));
+                    assertThat(record.partition(), notNullValue());
+                    assertThat(record.offset(), notNullValue());
+                    assertThat(record.key(), is("key-" + i));
                 }
             });
 
@@ -306,18 +306,18 @@ public class ProducerTest extends HttpBridgeTestBase {
         producerService()
             .sendRecordsRequest(topic, root, BridgeContentType.KAFKA_JSON_JSON)
             .sendJsonObject(root, ar -> {
-                context.verify(() -> assertTrue(ar.succeeded()));
+                context.verify(() -> assertThat(ar.succeeded(), is(true)));
 
                 HttpResponse<JsonObject> response = ar.result();
-                assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                 JsonObject bridgeResponse = response.body();
 
                 JsonArray offsets = bridgeResponse.getJsonArray("offsets");
-                assertEquals(numMessages, offsets.size());
+                assertThat(offsets.size(), is(numMessages));
                 for (int i = 0; i < numMessages; i++) {
                     JsonObject metadata = offsets.getJsonObject(i);
-                    assertEquals(0, metadata.getInteger("partition"));
-                    assertNotNull(metadata.getLong("offset"));
+                    assertThat(metadata.getInteger("partition"), is(0));
+                    assertThat(metadata.getLong("offset"), notNullValue());
                 }
             });
 
@@ -328,11 +328,11 @@ public class ProducerTest extends HttpBridgeTestBase {
         this.count = 0;
         consumer.handler(record -> {
             context.verify(() -> {
-                assertEquals(value + "-" + this.count++, record.value());
-                assertEquals(topic, record.topic());
-                assertNotNull(record.partition());
-                assertNotNull(record.offset());
-                assertNull(record.key());
+                assertThat(record.value(), is(value + "-" + this.count++));
+                assertThat(record.topic(), is(topic));
+                assertThat(record.partition(), notNullValue());
+                assertThat(record.offset(), notNullValue());
+                assertThat(record.key(), nullValue());
             });
 
             LOGGER.info("Message consumed topic={} partition={} offset={}, key={}, value={}",
@@ -362,11 +362,11 @@ public class ProducerTest extends HttpBridgeTestBase {
             .sendRecordsRequest(topic, root, BridgeContentType.KAFKA_JSON_JSON)
             .sendJsonObject(root, ar -> {
                 context.verify(() -> {
-                    assertTrue(ar.succeeded());
+                    assertThat(ar.succeeded(), is(true));
                     HttpResponse<JsonObject> response = ar.result();
                     HttpBridgeError error = HttpBridgeError.fromJson(response.body());
-                    assertEquals(HttpResponseStatus.UNPROCESSABLE_ENTITY.code(), response.statusCode());
-                    assertEquals(HttpResponseStatus.UNPROCESSABLE_ENTITY.code(), error.getCode());
+                    assertThat(response.statusCode(), is(HttpResponseStatus.UNPROCESSABLE_ENTITY.code()));
+                    assertThat(error.getCode(), is(HttpResponseStatus.UNPROCESSABLE_ENTITY.code()));
                 });
                 context.completeNow();
             });
@@ -393,21 +393,20 @@ public class ProducerTest extends HttpBridgeTestBase {
             .sendRecordsRequest(kafkaTopic, root, BridgeContentType.KAFKA_JSON_JSON)
             .sendJsonObject(root, ar -> {
                 context.verify(() -> {
-                    assertTrue(ar.succeeded());
+                    assertThat(ar.succeeded(), is(true));
                     HttpResponse<JsonObject> response = ar.result();
                     JsonObject bridgeResponse = response.body();
 
                     JsonArray offsets = bridgeResponse.getJsonArray("offsets");
-                    assertEquals(1, offsets.size());
+                    assertThat(offsets.size(), is(1));
 
                     HttpBridgeError error = HttpBridgeError.fromJson(offsets.getJsonObject(0));
-                    assertEquals(HttpResponseStatus.NOT_FOUND.code(), error.getCode());
+                    assertThat(error.getCode(), is(HttpResponseStatus.NOT_FOUND.code()));
                     // the message got from the Kafka producer (starting from 2.3) is misleading
                     // this JIRA (https://issues.apache.org/jira/browse/KAFKA-8862) raises the issue
-                    assertEquals(
+                    assertThat(error.getMessage(), is(
                             "Topic " + kafkaTopic + " not present in metadata after " +
-                                    config.get(KafkaProducerConfig.KAFKA_PRODUCER_CONFIG_PREFIX + ProducerConfig.MAX_BLOCK_MS_CONFIG) + " ms.",
-                            error.getMessage());
+                                    config.get(KafkaProducerConfig.KAFKA_PRODUCER_CONFIG_PREFIX + ProducerConfig.MAX_BLOCK_MS_CONFIG) + " ms."));
                 });
                 context.completeNow();
             });
@@ -433,19 +432,18 @@ public class ProducerTest extends HttpBridgeTestBase {
             .sendRecordsRequest(kafkaTopic, root, BridgeContentType.KAFKA_JSON_JSON)
             .sendJsonObject(root, ar -> {
                 context.verify(() -> {
-                    assertTrue(ar.succeeded());
+                    assertThat(ar.succeeded(), is(true));
                     HttpResponse<JsonObject> response = ar.result();
                     JsonObject bridgeResponse = response.body();
 
                     JsonArray offsets = bridgeResponse.getJsonArray("offsets");
-                    assertEquals(1, offsets.size());
+                    assertThat(offsets.size(), is(1));
                     int code = offsets.getJsonObject(0).getInteger("error_code");
                     String statusMessage = offsets.getJsonObject(0).getString("message");
 
-                    assertEquals(HttpResponseStatus.NOT_FOUND.code(), code);
-                    assertEquals("Topic " + kafkaTopic + " not present in metadata after " + 
-                                config.get(KafkaProducerConfig.KAFKA_PRODUCER_CONFIG_PREFIX + ProducerConfig.MAX_BLOCK_MS_CONFIG) + " ms.", 
-                                statusMessage);
+                    assertThat(code, is(HttpResponseStatus.NOT_FOUND.code()));
+                    assertThat(statusMessage, is("Topic " + kafkaTopic + " not present in metadata after " +
+                                config.get(KafkaProducerConfig.KAFKA_PRODUCER_CONFIG_PREFIX + ProducerConfig.MAX_BLOCK_MS_CONFIG) + " ms."));
                 });
                 context.completeNow();
             });
@@ -471,17 +469,17 @@ public class ProducerTest extends HttpBridgeTestBase {
             .sendRecordsToPartitionRequest(kafkaTopic, partition, root, BridgeContentType.KAFKA_JSON_JSON)
             .sendJsonObject(root, ar -> {
                 context.verify(() -> {
-                    assertTrue(ar.succeeded());
+                    assertThat(ar.succeeded(), is(true));
                     HttpResponse<JsonObject> response = ar.result();
-                    assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                    assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                     JsonObject bridgeResponse = response.body();
 
                     JsonArray offsets = bridgeResponse.getJsonArray("offsets");
-                    assertEquals(1, offsets.size());
+                    assertThat(offsets.size(), is(1));
                     JsonObject metadata = offsets.getJsonObject(0);
-                    assertNotNull(metadata.getInteger("partition"));
-                    assertEquals(partition, metadata.getInteger("partition"));
-                    assertEquals(0L, metadata.getLong("offset"));
+                    assertThat(metadata.getInteger("partition"), notNullValue());
+                    assertThat(metadata.getInteger("partition"), is(partition));
+                    assertThat(metadata.getLong("offset"), is(0L));
                 });
                 context.completeNow();
             });
@@ -576,12 +574,12 @@ public class ProducerTest extends HttpBridgeTestBase {
     Handler<AsyncResult<HttpResponse<JsonObject>>> verifyBadRequest(VertxTestContext context, String message) {
         return ar ->
             context.verify(() -> {
-                assertTrue(ar.succeeded());
+                assertThat(ar.succeeded(), is(true));
                 HttpResponse<JsonObject> response = ar.result();
-                assertEquals(HttpResponseStatus.BAD_REQUEST.code(), response.statusCode());
+                assertThat(response.statusCode(), is(HttpResponseStatus.BAD_REQUEST.code()));
                 HttpBridgeError error = HttpBridgeError.fromJson(response.body());
-                assertEquals(HttpResponseStatus.BAD_REQUEST.code(), error.getCode());
-                assertEquals(message, error.getMessage());
+                assertThat(error.getCode(), is(HttpResponseStatus.BAD_REQUEST.code()));
+                assertThat(error.getMessage(), is(message));
                 context.completeNow();
             });
     }
@@ -589,16 +587,16 @@ public class ProducerTest extends HttpBridgeTestBase {
     Handler<AsyncResult<HttpResponse<JsonObject>>> verifyOK(VertxTestContext context) {
         return ar ->
             context.verify(() -> {
-                assertTrue(ar.succeeded());
+                assertThat(ar.succeeded(), is(true));
                 HttpResponse<JsonObject> response = ar.result();
-                assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                 JsonObject bridgeResponse = response.body();
 
                 JsonArray offsets = bridgeResponse.getJsonArray("offsets");
-                assertEquals(1, offsets.size());
+                assertThat(offsets.size(), is(1));
                 JsonObject metadata = offsets.getJsonObject(0);
-                assertNotNull(metadata.getInteger("partition"));
-                assertEquals(0L, metadata.getLong("offset"));
+                assertThat(metadata.getInteger("partition"), notNullValue());
+                assertThat(metadata.getLong("offset"), is(0L));
             });
     }
 
@@ -628,20 +626,20 @@ public class ProducerTest extends HttpBridgeTestBase {
                 .sendRecordsRequest(kafkaTopic, root, BridgeContentType.KAFKA_JSON_JSON)
                 .sendJsonObject(root, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                         JsonObject bridgeResponse = response.body();
 
                         JsonArray offsets = bridgeResponse.getJsonArray("offsets");
-                        assertEquals(2, offsets.size());
+                        assertThat(offsets.size(), is(2));
                         JsonObject metadata = offsets.getJsonObject(0);
-                        assertNotNull(metadata.getInteger("partition"));
-                        assertEquals(partition, metadata.getInteger("partition"));
-                        assertEquals(0L, metadata.getLong("offset"));
+                        assertThat(metadata.getInteger("partition"), notNullValue());
+                        assertThat(metadata.getInteger("partition"), is(partition));
+                        assertThat(metadata.getLong("offset"), is(0L));
                         HttpBridgeError error = HttpBridgeError.fromJson(offsets.getJsonObject(1));
-                        assertEquals(HttpResponseStatus.NOT_FOUND.code(), error.getCode());
-                        assertEquals("Topic " + kafkaTopic + " not present in metadata after 10000 ms.", error.getMessage());
+                        assertThat(error.getCode(), is(HttpResponseStatus.NOT_FOUND.code()));
+                        assertThat(error.getMessage(), is("Topic " + kafkaTopic + " not present in metadata after 10000 ms."));
                     });
                     context.completeNow();
                 });
diff --git a/src/test/java/io/strimzi/kafka/bridge/http/SeekTest.java b/src/test/java/io/strimzi/kafka/bridge/http/SeekTest.java
index fa9e998..f36ffcd 100644
--- a/src/test/java/io/strimzi/kafka/bridge/http/SeekTest.java
+++ b/src/test/java/io/strimzi/kafka/bridge/http/SeekTest.java
@@ -24,9 +24,8 @@ import java.util.concurrent.TimeoutException;
 import java.util.stream.Collectors;
 
 import static io.netty.handler.codec.http.HttpHeaderNames.ACCEPT;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
 
 public class SeekTest extends HttpBridgeTestBase {
 
@@ -44,16 +43,16 @@ public class SeekTest extends HttpBridgeTestBase {
             .positionsBeginningRequest(groupId, name, root)
                 .sendJsonObject(root, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
                         HttpBridgeError error = HttpBridgeError.fromJson(response.body());
-                        assertEquals(HttpResponseStatus.NOT_FOUND.code(), response.statusCode());
-                        assertEquals(HttpResponseStatus.NOT_FOUND.code(), error.getCode());
-                        assertEquals("The specified consumer instance was not found.", error.getMessage());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.NOT_FOUND.code()));
+                        assertThat(error.getCode(), is(HttpResponseStatus.NOT_FOUND.code()));
+                        assertThat(error.getMessage(), is("The specified consumer instance was not found."));
                         context.completeNow();
                     });
                 });
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -77,16 +76,16 @@ public class SeekTest extends HttpBridgeTestBase {
         seekService().positionsBeginningRequest(groupId, name, partitionsJSON)
             .sendJsonObject(partitionsJSON, ar -> {
                 context.verify(() -> {
-                    assertTrue(ar.succeeded());
+                    assertThat(ar.succeeded(), is(true));
                     HttpResponse<JsonObject> response = ar.result();
                     HttpBridgeError error = HttpBridgeError.fromJson(response.body());
-                    assertEquals(HttpResponseStatus.NOT_FOUND.code(), response.statusCode());
-                    assertEquals(HttpResponseStatus.NOT_FOUND.code(), error.getCode());
-                    assertEquals("No current assignment for partition " + topic + "-" + notExistingPartition, error.getMessage());
+                    assertThat(response.statusCode(), is(HttpResponseStatus.NOT_FOUND.code()));
+                    assertThat(error.getCode(), is(HttpResponseStatus.NOT_FOUND.code()));
+                    assertThat(error.getMessage(), is("No current assignment for partition " + topic + "-" + notExistingPartition));
                     context.completeNow();
                 });
             });
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -108,12 +107,12 @@ public class SeekTest extends HttpBridgeTestBase {
         seekService().positionsBeginningRequest(groupId, name, partitionsWithWrongTopic)
                 .sendJsonObject(partitionsWithWrongTopic, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
                         HttpBridgeError error = HttpBridgeError.fromJson(response.body());
-                        assertEquals(HttpResponseStatus.NOT_FOUND.code(), response.statusCode());
-                        assertEquals(HttpResponseStatus.NOT_FOUND.code(), error.getCode());
-                        assertEquals("No current assignment for partition " + notExistingTopic + "-" + 0, error.getMessage());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.NOT_FOUND.code()));
+                        assertThat(error.getCode(), is(HttpResponseStatus.NOT_FOUND.code()));
+                        assertThat(error.getMessage(), is("No current assignment for partition " + notExistingTopic + "-" + 0));
                         context.completeNow();
                     });
                     consumerInstanceDontHaveTopic.complete(true);
@@ -146,9 +145,9 @@ public class SeekTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonArray())
                 .send(ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         JsonArray body = ar.result().body();
-                        assertEquals(10, body.size());
+                        assertThat(body.size(), is(10));
                     });
                     consume.complete(true);
                 });
@@ -167,8 +166,8 @@ public class SeekTest extends HttpBridgeTestBase {
         seekService().positionsBeginningRequest(groupId, name, root)
                 .sendJsonObject(root, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
-                        assertEquals(HttpResponseStatus.NO_CONTENT.code(), ar.result().statusCode());
+                        assertThat(ar.succeeded(), is(true));
+                        assertThat(ar.result().statusCode(), is(HttpResponseStatus.NO_CONTENT.code()));
                     });
                     seek.complete(true);
                 });
@@ -183,9 +182,9 @@ public class SeekTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonArray())
                 .send(ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         JsonArray body = ar.result().body();
-                        assertEquals(10, body.size());
+                        assertThat(body.size(), is(10));
                     });
                     consumeSeek.complete(true);
                 });
@@ -196,7 +195,7 @@ public class SeekTest extends HttpBridgeTestBase {
         consumerService()
             .deleteConsumer(context, groupId, name);
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -221,7 +220,8 @@ public class SeekTest extends HttpBridgeTestBase {
             .consumeRecordsRequest(groupId, name, BridgeContentType.KAFKA_JSON_BINARY)
                 .as(BodyCodec.jsonArray())
                 .send(ar -> {
-                    context.verify(() -> assertTrue(ar.succeeded()));
+                    context.verify(() ->
+                            assertThat(ar.succeeded(), is(true)));
                     dummy.complete(true);
                 });
 
@@ -241,8 +241,8 @@ public class SeekTest extends HttpBridgeTestBase {
             .positionsBeginningEnd(groupId, name, root)
                 .sendJsonObject(root, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
-                        assertEquals(HttpResponseStatus.NO_CONTENT.code(), ar.result().statusCode());
+                        assertThat(ar.succeeded(), is(true));
+                        assertThat(ar.result().statusCode(), is(HttpResponseStatus.NO_CONTENT.code()));
                     });
                     seek.complete(true);
                 });
@@ -256,10 +256,11 @@ public class SeekTest extends HttpBridgeTestBase {
                 .putHeader(ACCEPT.toString(), BridgeContentType.KAFKA_JSON_BINARY)
                 .as(BodyCodec.jsonArray())
                 .send(ar -> {
-                    context.verify(() -> assertTrue(ar.succeeded()));
+                    context.verify(() ->
+                            assertThat(ar.succeeded(), is(true)));
 
                     JsonArray body = ar.result().body();
-                    assertEquals(0, body.size());
+                    assertThat(body.size(), is(0));
                     consumeSeek.complete(true);
                 });
 
@@ -300,7 +301,7 @@ public class SeekTest extends HttpBridgeTestBase {
             .consumeRecordsRequest(groupId, name, BridgeContentType.KAFKA_JSON_JSON)
                 .as(BodyCodec.jsonArray())
                 .send(ar -> {
-                    assertTrue(ar.succeeded());
+                    assertThat(ar.succeeded(), is(true));
                     dummy.complete(true);
                 });
         dummy.get(TEST_TIMEOUT, TimeUnit.SECONDS);
@@ -318,8 +319,8 @@ public class SeekTest extends HttpBridgeTestBase {
             .positionsRequest(groupId, name, root)
                 .sendJsonObject(root, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
-                        assertEquals(HttpResponseStatus.NO_CONTENT.code(), ar.result().statusCode());
+                        assertThat(ar.succeeded(), is(true));
+                        assertThat(ar.result().statusCode(), is(HttpResponseStatus.NO_CONTENT.code()));
                     });
                     seek.complete(true);
                 });
@@ -332,7 +333,7 @@ public class SeekTest extends HttpBridgeTestBase {
                 .as(BodyCodec.jsonArray())
                 .send(ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         JsonArray body = ar.result().body();
 
                         // check it read from partition 0, at offset 9, just one message
@@ -340,25 +341,25 @@ public class SeekTest extends HttpBridgeTestBase {
                                 .map(JsonObject.class::cast)
                                 .filter(jo -> jo.getInteger("partition") == 0 && jo.getLong("offset") == 9)
                                 .collect(Collectors.toList());
-                        assertFalse(metadata.isEmpty());
-                        assertEquals(1, metadata.size());
+                        assertThat(metadata.isEmpty(), is(false));
+                        assertThat(metadata.size(), is(1));
 
-                        assertEquals(topic, metadata.get(0).getString("topic"));
-                        assertEquals("value-9", metadata.get(0).getString("value"));
-                        assertEquals("key-9", metadata.get(0).getString("key"));
+                        assertThat(metadata.get(0).getString("topic"), is(topic));
+                        assertThat(metadata.get(0).getString("value"), is("value-9"));
+                        assertThat(metadata.get(0).getString("key"), is("key-9"));
 
                         // check it read from partition 1, starting from offset 5, the last 5 messages
                         metadata = body.stream()
                                 .map(JsonObject.class::cast)
                                 .filter(jo -> jo.getInteger("partition") == 1)
                                 .collect(Collectors.toList());
-                        assertFalse(metadata.isEmpty());
-                        assertEquals(5, metadata.size());
+                        assertThat(metadata.isEmpty(), is(false));
+                        assertThat(metadata.size(), is(5));
 
                         for (int i = 0; i < metadata.size(); i++) {
-                            assertEquals(topic, metadata.get(i).getString("topic"));
-                            assertEquals("value-" + (i + 5), metadata.get(i).getString("value"));
-                            assertEquals("key-" + (i + 5), metadata.get(i).getString("key"));
+                            assertThat(metadata.get(i).getString("topic"), is(topic));
+                            assertThat(metadata.get(i).getString("value"), is("value-" + (i + 5)));
+                            assertThat(metadata.get(i).getString("key"), is("key-" + (i + 5)));
                         }
                     });
                     consume.complete(true);
@@ -369,7 +370,7 @@ public class SeekTest extends HttpBridgeTestBase {
         consumerService()
             .deleteConsumer(context, groupId, name);
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -414,12 +415,12 @@ public class SeekTest extends HttpBridgeTestBase {
         seekService().positionsBeginningRequest(groupId, name, root)
                 .sendJsonObject(root, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
                         HttpBridgeError error = HttpBridgeError.fromJson(response.body());
-                        assertEquals(HttpResponseStatus.NOT_FOUND.code(), response.statusCode());
-                        assertEquals(HttpResponseStatus.NOT_FOUND.code(), error.getCode());
-                        assertEquals("No current assignment for partition " + notSubscribedTopic + "-0", error.getMessage());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.NOT_FOUND.code()));
+                        assertThat(error.getCode(), is(HttpResponseStatus.NOT_FOUND.code()));
+                        assertThat(error.getMessage(), is("No current assignment for partition " + notSubscribedTopic + "-0"));
                     });
                     seek.complete(true);
                 });
@@ -430,7 +431,7 @@ public class SeekTest extends HttpBridgeTestBase {
             .deleteConsumer(context, groupId, name);
         
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 
     @Test
@@ -476,12 +477,12 @@ public class SeekTest extends HttpBridgeTestBase {
             .positionsRequest(groupId, name, root)
                 .sendJsonObject(root, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
                         HttpBridgeError error = HttpBridgeError.fromJson(response.body());
-                        assertEquals(HttpResponseStatus.NOT_FOUND.code(), response.statusCode());
-                        assertEquals(HttpResponseStatus.NOT_FOUND.code(), error.getCode());
-                        assertEquals("No current assignment for partition " + notSubscribedTopic + "-0", error.getMessage());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.NOT_FOUND.code()));
+                        assertThat(error.getCode(), is(HttpResponseStatus.NOT_FOUND.code()));
+                        assertThat(error.getMessage(), is("No current assignment for partition " + notSubscribedTopic + "-0"));
                     });
                     seek.complete(true);
                 });
@@ -492,6 +493,6 @@ public class SeekTest extends HttpBridgeTestBase {
             .deleteConsumer(context, groupId, name);
         
         context.completeNow();
-        assertTrue(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS));
+        assertThat(context.awaitCompletion(TEST_TIMEOUT, TimeUnit.SECONDS), is(true));
     }
 }
diff --git a/src/test/java/io/strimzi/kafka/bridge/http/services/ConsumerService.java b/src/test/java/io/strimzi/kafka/bridge/http/services/ConsumerService.java
index ca903ad..570b4b5 100644
--- a/src/test/java/io/strimzi/kafka/bridge/http/services/ConsumerService.java
+++ b/src/test/java/io/strimzi/kafka/bridge/http/services/ConsumerService.java
@@ -24,8 +24,8 @@ import java.util.concurrent.TimeoutException;
 import static io.netty.handler.codec.http.HttpHeaderNames.ACCEPT;
 import static io.netty.handler.codec.http.HttpHeaderNames.CONTENT_LENGTH;
 import static io.netty.handler.codec.http.HttpHeaderNames.CONTENT_TYPE;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class ConsumerService extends BaseService {
 
@@ -107,8 +107,8 @@ public class ConsumerService extends BaseService {
                 .as(BodyCodec.jsonObject())
                 .sendJsonObject(topicsRoot, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
-                        assertEquals(HttpResponseStatus.NO_CONTENT.code(), ar.result().statusCode());
+                        assertThat(ar.succeeded(), is(true));
+                        assertThat(ar.result().statusCode(), is(HttpResponseStatus.NO_CONTENT.code()));
                     });
                     unsubscribe.complete(true);
                 });
@@ -134,8 +134,8 @@ public class ConsumerService extends BaseService {
                 .as(BodyCodec.jsonObject())
                 .sendJsonObject(partitionsRoot, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
-                        assertEquals(HttpResponseStatus.NO_CONTENT.code(), ar.result().statusCode());
+                        assertThat(ar.succeeded(), is(true));
+                        assertThat(ar.result().statusCode(), is(HttpResponseStatus.NO_CONTENT.code()));
                     });
                     subscribe.complete(true);
                 });
@@ -148,14 +148,14 @@ public class ConsumerService extends BaseService {
         createConsumerRequest(groupId, json)
                 .sendJsonObject(json, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
-                        assertEquals(HttpResponseStatus.OK.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.OK.code()));
                         JsonObject bridgeResponse = response.body();
                         String consumerInstanceId = bridgeResponse.getString("instance_id");
                         String consumerBaseUri = bridgeResponse.getString("base_uri");
-                        assertEquals(json.getString("name"), consumerInstanceId);
-                        assertEquals(Urls.consumerInstance(groupId, json.getString("name")), consumerBaseUri);
+                        assertThat(consumerInstanceId, is(json.getString("name")));
+                        assertThat(consumerBaseUri, is(Urls.consumerInstance(groupId, json.getString("name"))));
                     });
                     create.complete(true);
                 });
@@ -185,8 +185,8 @@ public class ConsumerService extends BaseService {
                 .as(BodyCodec.jsonObject())
                 .sendJsonObject(jsonObject, ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
-                        assertEquals(HttpResponseStatus.NO_CONTENT.code(), ar.result().statusCode());
+                        assertThat(ar.succeeded(), is(true));
+                        assertThat(ar.result().statusCode(), is(HttpResponseStatus.NO_CONTENT.code()));
                     });
                     subscribe.complete(true);
                 });
@@ -200,9 +200,9 @@ public class ConsumerService extends BaseService {
         deleteConsumerRequest(groupId, name)
                 .send(ar -> {
                     context.verify(() -> {
-                        assertTrue(ar.succeeded());
+                        assertThat(ar.succeeded(), is(true));
                         HttpResponse<JsonObject> response = ar.result();
-                        assertEquals(HttpResponseStatus.NO_CONTENT.code(), response.statusCode());
+                        assertThat(response.statusCode(), is(HttpResponseStatus.NO_CONTENT.code()));
                     });
                     delete.complete(true);
                 });