diff --git a/Makefile b/Makefile
index 1630cb16c..9480a4d5f 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,5 @@
 SHORT_VER = $(shell git describe --tags --abbrev=0 | cut -f1-)
 LONG_VER = $(shell git describe --long 2>/dev/null || echo $(SHORT_VER)-0-unknown-g`git describe --always`)
-KAFKA_VERSION=2.4.1
-SCALA_VERSION=2.12
 KAFKA_PATH = kafka_$(SCALA_VERSION)-$(KAFKA_VERSION)
 KAFKA_TAR = $(KAFKA_PATH).tgz
 PYTHON_SOURCE_DIRS = karapace/
@@ -11,6 +9,10 @@ GENERATED = karapace/version.py
 PYTHON = python3
 DNF_INSTALL = sudo dnf install -y
 
+# Keep these is sync with tests/integration/conftest.py
+KAFKA_VERSION=2.7.0
+SCALA_VERSION=2.13
+
 KAFKA_IMAGE = karapace-test-kafka
 ZK = 2181
 KAFKA = 9092
diff --git a/container/docker-compose.yml b/container/docker-compose.yml
index 3334577d1..d75608748 100644
--- a/container/docker-compose.yml
+++ b/container/docker-compose.yml
@@ -2,7 +2,7 @@
 version: '3'
 services:
   zookeeper:
-    image: confluentinc/cp-zookeeper:6.0.0
+    image: confluentinc/cp-zookeeper:latest
     ports:
       - "2181:2181"
     environment:
@@ -10,35 +10,50 @@ services:
       ZOOKEEPER_TICK_TIME: 2000
 
   kafka:
-    image: confluentinc/cp-server:6.0.0
+    image: confluentinc/cp-kafka:latest
     depends_on:
       - zookeeper
     ports:
       - "9101:9101"  # JMX
       - "9092:9092"  # Kafka
     environment:
-      KAFKA_BROKER_ID: 1
-      KAFKA_ZOOKEEPER_CONNECT: 'zookeeper:2181'
-      KAFKA_AUTO_CREATE_TOPICS_ENABLE: 'true'
       # Listeners:
       # PLAINTEXT_HOST -> Expose kafka to the host network
       # PLAINTEXT -> Used by kafka for inter broker communication / containers
       KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT
       KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:29092,PLAINTEXT_HOST://localhost:9092
-      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
       KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS: 0
-      KAFKA_CONFLUENT_LICENSE_TOPIC_REPLICATION_FACTOR: 1
-      KAFKA_CONFLUENT_BALANCER_TOPIC_REPLICATION_FACTOR: 1
-      KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1
-      KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
       KAFKA_CONFLUENT_SCHEMA_REGISTRY_URL: http://karapace-registry:8081
+      KAFKA_AUTO_CREATE_TOPICS_ENABLE: 'false'
       # Metrics:
-      KAFKA_METRIC_REPORTERS: io.confluent.metrics.reporter.ConfluentMetricsReporter
       KAFKA_JMX_PORT: 9101
       KAFKA_JMX_HOSTNAME: localhost
-      CONFLUENT_METRICS_REPORTER_BOOTSTRAP_SERVERS: kafka:29092
-      CONFLUENT_METRICS_REPORTER_TOPIC_REPLICAS: 1
-      CONFLUENT_METRICS_ENABLE: 'true'
+      # Keep in sync with tests/integration/conftest.py::configure_and_start_kafka
+      KAFKA_BROKER_ID: 1
+      KAFKA_BROKER_RACK: "local"
+      KAFKA_AUTO_CREATE_TOPICS_ENABLE: "false"
+      KAFKA_DEFAULT_REPLICATION_FACTOR: 1
+      KAFKA_DELETE_TOPIC_ENABLE: "true"
+      KAFKA_INTER_BROKER_LISTENER_NAME: "PLAINTEXT"
+      KAFKA_INTER_BROKER_PROTOCOL_VERSION: 2.4
+      KAFKA_LOG_CLEANER_ENABLE: "true"
+      KAFKA_LOG_MESSAGE_FORMAT_VERSION: 2.4
+      KAFKA_LOG_RETENTION_CHECK_INTERVAL_MS: 300000
+      KAFKA_LOG_SEGMENT_BYTES: 209715200
+      KAFKA_NUM_IO_THREADS: 8
+      KAFKA_NUM_NETWORK_THREADS: 112
+      KAFKA_NUM_PARTITIONS: 1
+      KAFKA_NUM_REPLICA_FETCHERS: 4
+      KAFKA_NUM_RECOVERY_THREADS_PER_DATA_DIR: 1
+      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
+      KAFKA_SOCKET_RECEIVE_BUFFER_BYTES: 102400
+      KAFKA_SOCKET_REQUEST_MAX_BYTES: 104857600
+      KAFKA_SOCKET_SEND_BUFFER_BYTES: 102400
+      KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1
+      KAFKA_TRANSACTION_STATE_LOG_NUM_PARTITIONS: 16
+      KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
+      KAFKA_ZOOKEEPER_CONNECTION_TIMEOUT_MS: 6000
+      KAFKA_ZOOKEEPER_CONNECT: "zookeeper:2181"
 
   karapace-registry:
     image: karapace-registry
@@ -55,6 +70,7 @@ services:
       KARAPACE_REGISTRY_GROUP_ID: karapace-registry
       KARAPACE_REGISTRY_MASTER_ELIGIBITY: "true"
       KARAPACE_REGISTRY_TOPIC_NAME: _schemas
+      KARAPACE_REGISTRY_LOG_LEVEL: WARNING
 
   karapace-rest:
     image: karapace-rest
@@ -70,3 +86,7 @@ services:
       KARAPACE_REST_BOOTSTRAP_URI: kafka:29092
       KARAPACE_REST_REGISTRY_HOST: karapace-registry
       KARAPACE_REST_REGISTRY_PORT: 8081
+      # Keep in sync with tests/integration/conftest.py::fixture_rest_async,
+      # new entries may need to be added to containers/start.sh
+      KARAPACE_REST_ADMIN_METADATA_MAX_AGE: 0
+      KARAPACE_REST_LOG_LEVEL: WARNING
diff --git a/container/start.sh b/container/start.sh
index d34a19080..4254a410f 100755
--- a/container/start.sh
+++ b/container/start.sh
@@ -1,18 +1,23 @@
 #!/bin/bash
 set -e
 
+# keep in sync with karapace/config.py
 KARAPACE_REGISTRY_PORT_DEFAULT=8081
 KARAPACE_REGISTRY_HOST_DEFAULT=0.0.0.0
 KARAPACE_REGISTRY_CLIENT_ID_DEFAULT=sr-1
 KARAPACE_REGISTRY_GROUP_ID_DEFAULT=schema-registry
 KARAPACE_REGISTRY_MASTER_ELIGIBITY_DEFAULT=true
 KARAPACE_REGISTRY_TOPIC_NAME_DEFAULT=_schemas
+KARAPACE_REGISTRY_LOG_LEVEL_DEFAULT=INFO
 # Variables without defaults:
 # KARAPACE_REGISTRY_ADVERTISED_HOSTNAME
 # KARAPACE_REGISTRY_BOOTSTRAP_URI
 
+# keep in sync with karapace/config.py
 KARAPACE_REST_PORT_DEFAULT=8082
+KARAPACE_REST_ADMIN_METADATA_MAX_AGE_DEFAULT=5
 KARAPACE_REST_HOST_DEFAULT=0.0.0.0
+KARAPACE_REST_LOG_LEVEL_DEFAULT=INFO
 # Variables without defaults:
 # KARAPACE_REST_ADVERTISED_HOSTNAME
 # KARAPACE_REST_BOOTSTRAP_URI
@@ -33,7 +38,7 @@ start_karapace_registry(){
     "master_eligibility": ${KARAPACE_REGISTRY_MASTER_ELIGIBITY:-$KARAPACE_REGISTRY_MASTER_ELIGIBITY_DEFAULT},
     "topic_name": "${KARAPACE_REGISTRY_TOPIC_NAME:-$KARAPACE_REGISTRY_TOPIC_NAME_DEFAULT}",
     "compatibility": "FULL",
-    "log_level": "INFO",
+    "log_level": "${KARAPACE_REGISTRY_LOG_LEVEL:-$KARAPACE_REGISTRY_LOG_LEVEL_DEFAULT}",
     "replication_factor": 1,
     "security_protocol": "PLAINTEXT",
     "ssl_cafile": null,
@@ -56,7 +61,8 @@ start_karapace_rest(){
     "registry_port": ${KARAPACE_REST_REGISTRY_PORT},
     "host": "${KARAPACE_REST_HOST:-$KARAPACE_REST_HOST_DEFAULT}",
     "port": ${KARAPACE_REST_PORT:-$KARAPACE_REST_PORT_DEFAULT},
-    "log_level": "INFO",
+    "admin_metadata_max_age": ${KARAPACE_REST_ADMIN_METADATA_MAX_AGE:-$KARAPACE_REST_ADMIN_METADATA_MAX_AGE_DEFAULT},
+    "log_level": "${KARAPACE_REST_LOG_LEVEL:-$KARAPACE_REST_LOG_LEVEL_DEFAULT}",
     "security_protocol": "PLAINTEXT",
     "ssl_cafile": null,
     "ssl_certfile": null,
diff --git a/karapace/compatibility/__init__.py b/karapace/compatibility/__init__.py
index b2f3914d4..57cc2593b 100644
--- a/karapace/compatibility/__init__.py
+++ b/karapace/compatibility/__init__.py
@@ -20,6 +20,16 @@
 
 @unique
 class CompatibilityModes(Enum):
+    """ Supported compatibility modes.
+
+    - none: no compatibility checks done.
+    - backward compatibility: new schema can *read* data produced by the olders
+      schemas.
+    - forward compatibility: new schema can *produce* data compatible with old
+      schemas.
+    - transitive compatibility: new schema can read data produced by *all*
+      previous schemas, otherwise only the previous schema is checked.
+    """
     BACKWARD = "BACKWARD"
     BACKWARD_TRANSITIVE = "BACKWARD_TRANSITIVE"
     FORWARD = "FORWARD"
@@ -53,12 +63,13 @@ def check_jsonschema_compatibility(reader: Draft7Validator, writer: Draft7Valida
 
 
 def check_compatibility(
-    source: TypedSchema, target: TypedSchema, compatibility_mode: CompatibilityModes
+    old_schema: TypedSchema, new_schema: TypedSchema, compatibility_mode: CompatibilityModes
 ) -> SchemaCompatibilityResult:
-    if source.schema_type is not target.schema_type:
+    """ Check that `old_schema` and `new_schema` are compatible under `compatibility_mode`. """
+    if old_schema.schema_type is not new_schema.schema_type:
         return SchemaCompatibilityResult.incompatible(
             incompat_type=SchemaIncompatibilityType.type_mismatch,
-            message=f"Comparing different schema types: {source.schema_type} with {target.schema_type}",
+            message=f"Comparing different schema types: {old_schema.schema_type} with {new_schema.schema_type}",
             location=[],
         )
 
@@ -66,32 +77,60 @@ def check_compatibility(
         LOG.info("Compatibility level set to NONE, no schema compatibility checks performed")
         return SchemaCompatibilityResult.compatible()
 
-    if source.schema_type is SchemaType.AVRO:
+    if old_schema.schema_type is SchemaType.AVRO:
         if compatibility_mode in {CompatibilityModes.BACKWARD, CompatibilityModes.BACKWARD_TRANSITIVE}:
-            result = check_avro_compatibility(reader_schema=target.schema, writer_schema=source.schema)
+            result = check_avro_compatibility(
+                reader_schema=new_schema.schema,
+                writer_schema=old_schema.schema,
+            )
 
         elif compatibility_mode in {CompatibilityModes.FORWARD, CompatibilityModes.FORWARD_TRANSITIVE}:
-            result = check_avro_compatibility(reader_schema=source.schema, writer_schema=target.schema)
+            result = check_avro_compatibility(
+                reader_schema=old_schema.schema,
+                writer_schema=new_schema.schema,
+            )
 
         elif compatibility_mode in {CompatibilityModes.FULL, CompatibilityModes.FULL_TRANSITIVE}:
-            result = check_avro_compatibility(reader_schema=target.schema, writer_schema=source.schema)
-            result = result.merged_with(check_avro_compatibility(reader_schema=source.schema, writer_schema=target.schema))
-
-    elif source.schema_type is SchemaType.JSONSCHEMA:
+            result = check_avro_compatibility(
+                reader_schema=new_schema.schema,
+                writer_schema=old_schema.schema,
+            )
+            result = result.merged_with(
+                check_avro_compatibility(
+                    reader_schema=old_schema.schema,
+                    writer_schema=new_schema.schema,
+                )
+            )
+
+    elif old_schema.schema_type is SchemaType.JSONSCHEMA:
         if compatibility_mode in {CompatibilityModes.BACKWARD, CompatibilityModes.BACKWARD_TRANSITIVE}:
-            result = check_jsonschema_compatibility(reader=target.schema, writer=source.schema)
+            result = check_jsonschema_compatibility(
+                reader=new_schema.schema,
+                writer=old_schema.schema,
+            )
 
         elif compatibility_mode in {CompatibilityModes.FORWARD, CompatibilityModes.FORWARD_TRANSITIVE}:
-            result = check_jsonschema_compatibility(reader=source.schema, writer=target.schema)
+            result = check_jsonschema_compatibility(
+                reader=old_schema.schema,
+                writer=new_schema.schema,
+            )
 
         elif compatibility_mode in {CompatibilityModes.FULL, CompatibilityModes.FULL_TRANSITIVE}:
-            result = check_jsonschema_compatibility(reader=target.schema, writer=source.schema)
-            result = result.merged_with(check_jsonschema_compatibility(reader=source.schema, writer=target.schema))
+            result = check_jsonschema_compatibility(
+                reader=new_schema.schema,
+                writer=old_schema.schema,
+            )
+            result = result.merged_with(
+                check_jsonschema_compatibility(
+                    reader=old_schema.schema,
+                    writer=new_schema.schema,
+                )
+            )
 
     else:
         result = SchemaCompatibilityResult.incompatible(
             incompat_type=SchemaIncompatibilityType.type_mismatch,
-            message=f"Unknow schema_type {source.schema_type}",
+            message=f"Unknow schema_type {old_schema.schema_type}",
             location=[],
         )
 
diff --git a/karapace/compatibility/jsonschema/checks.py b/karapace/compatibility/jsonschema/checks.py
index a4f406778..28ddd3db7 100644
--- a/karapace/compatibility/jsonschema/checks.py
+++ b/karapace/compatibility/jsonschema/checks.py
@@ -6,9 +6,9 @@
     AssertionCheck, BooleanSchema, Incompatibility, Instance, Keyword, Subschema
 )
 from karapace.compatibility.jsonschema.utils import (
-    get_type_of, gt, introduced_constraint, is_false_schema, is_object_content_model_open, is_simple_subschema,
-    is_true_schema, is_tuple, is_tuple_without_additional_items, lt, maybe_get_subschemas_and_type, ne, normalize_schema,
-    schema_from_partially_open_content_model
+    get_name_of, get_type_of, gt, introduced_constraint, is_false_schema, is_object_content_model_open, is_simple_subschema,
+    is_true_schema, is_tuple, is_tuple_without_additional_items, JSONSCHEMA_TYPES, lt, maybe_get_subschemas_and_type, ne,
+    normalize_schema, schema_from_partially_open_content_model
 )
 from typing import Any, List, Optional
 
@@ -224,15 +224,27 @@ def compatibility_rec(
 
     reader_is_true_schema = is_true_schema(reader_schema)
 
+    reader_is_object = reader_type == Instance.OBJECT
+    reader_is_true_schema = is_true_schema(reader_schema)
+    writer_is_object = writer_type == Instance.OBJECT
+    writer_is_true_schema = is_true_schema(writer_schema)
+    both_are_object = (reader_is_object or reader_is_true_schema) and (writer_is_object or writer_is_true_schema)
+
     # https://json-schema.org/draft/2020-12/json-schema-validation.html#rfc.section.6.1.1
-    if not both_are_numbers and not either_has_subschema and not reader_is_true_schema and reader_type != writer_type:
+    if not both_are_numbers and not either_has_subschema and not both_are_object and reader_type != writer_type:
         result = type_mismatch(reader_type, writer_type, location)
     elif both_are_numbers:
         result = compatibility_numerical(reader_schema, writer_schema, location)
     elif either_has_subschema:
         result = compatibility_subschemas(reader_schema, writer_schema, location)
-    elif reader_is_true_schema:
-        return SchemaCompatibilityResult.compatible()
+    elif both_are_object:
+        if reader_is_true_schema:
+            reader_schema = {"type": Instance.OBJECT.value}
+        if writer_is_true_schema:
+            writer_schema = {"type": Instance.OBJECT.value}
+        result = compatibility_object(reader_schema, writer_schema, location)
+    elif reader_type is BooleanSchema:
+        result = SchemaCompatibilityResult.compatible()
     elif reader_type is Subschema.NOT:
         assert reader_schema, "if just one schema is NOT the result should have been a type_mismatch"
         assert writer_schema, "if just one schema is NOT the result should have been a type_mismatch"
@@ -243,14 +255,10 @@ def compatibility_rec(
             writer_schema[Subschema.NOT.value],
             location_not,
         )
-    elif reader_type is BooleanSchema:
-        result = compatibility_boolean_schema(reader_schema, writer_schema, location)
     elif reader_type == Instance.BOOLEAN:
         result = SchemaCompatibilityResult.compatible()
     elif reader_type == Instance.STRING:
         result = compatibility_string(reader_schema, writer_schema, location)
-    elif reader_type == Instance.OBJECT:
-        result = compatibility_object(reader_schema, writer_schema, location)
     elif reader_type == Instance.ARRAY:
         result = compatibility_array(reader_schema, writer_schema, location)
     elif reader_type == Keyword.ENUM:
@@ -367,27 +375,6 @@ def compatibility_numerical(reader_schema, writer_schema, location: List[str]) -
     return result
 
 
-def compatibility_boolean_schema(reader_schema, writer_schema, location: List[str]) -> SchemaCompatibilityResult:
-    assert get_type_of(reader_schema) is BooleanSchema, "types should have been previously checked"
-    assert get_type_of(writer_schema) is BooleanSchema, "types should have been previously checked"
-
-    # The true schema accepts everything, so the writer can produce anything
-    if is_true_schema(reader_schema):
-        return SchemaCompatibilityResult.compatible()
-
-    # The false schema is only compatible with itself
-    if is_false_schema(writer_schema):
-        return SchemaCompatibilityResult.compatible()
-
-    reader_has_not = isinstance(reader_schema, dict) and Subschema.NOT.value in reader_schema
-    location_not = location + [Subschema.NOT.value]
-    return SchemaCompatibilityResult.incompatible(
-        incompat_type=Incompatibility.type_changed,
-        message=f"All new values are rejected by {reader_schema}",
-        location=location_not if reader_has_not else location,
-    )
-
-
 def compatibility_string(reader_schema, writer_schema, location: List[str]) -> SchemaCompatibilityResult:
     # https://json-schema.org/draft/2020-12/json-schema-validation.html#rfc.section.6.3
     result = SchemaCompatibilityResult.compatible()
@@ -409,8 +396,10 @@ def compatibility_string(reader_schema, writer_schema, location: List[str]) -> S
 
 def compatibility_array(reader_schema, writer_schema, location: List[str]) -> SchemaCompatibilityResult:
     # https://json-schema.org/draft/2020-12/json-schema-validation.html#rfc.section.6.4
-    assert get_type_of(reader_schema) == Instance.ARRAY, "types should have been previously checked"
-    assert get_type_of(writer_schema) == Instance.ARRAY, "types should have been previously checked"
+    reader_type = get_type_of(reader_schema)
+    writer_type = get_type_of(writer_schema)
+    assert reader_type == Instance.ARRAY, "types should have been previously checked"
+    assert writer_type == Instance.ARRAY, "types should have been previously checked"
 
     reader_items = reader_schema.get(Keyword.ITEMS.value)
     writer_items = writer_schema.get(Keyword.ITEMS.value)
@@ -420,22 +409,15 @@ def compatibility_array(reader_schema, writer_schema, location: List[str]) -> Sc
     reader_is_tuple = is_tuple(reader_schema)
     writer_is_tuple = is_tuple(writer_schema)
 
+    if reader_is_tuple != writer_is_tuple:
+        return type_mismatch(reader_type, writer_type, location)
+
     # Extend the array iterator to match the tuple size
     if reader_is_tuple and writer_is_tuple:
         reader_items_iter = iter(reader_items)
         writer_items_iter = iter(writer_items)
         reader_requires_more_items = len(reader_items) > len(writer_items)
         writer_has_more_items = len(writer_items) > len(reader_items)
-    elif reader_is_tuple:
-        reader_items_iter = iter(reader_items)
-        writer_items_iter = iter([writer_items] * (len(reader_items) + 1))  # +1 for the writer_has_more_items loop
-        reader_requires_more_items = False
-        writer_has_more_items = True
-    elif writer_is_tuple:
-        reader_items_iter = iter([reader_items] * len(writer_items))
-        writer_items_iter = iter(writer_items)
-        reader_requires_more_items = False  # The reader accepts but doesn't require more items
-        writer_has_more_items = False
     else:
         reader_items_iter = iter([reader_items])
         writer_items_iter = iter([writer_items])
@@ -726,6 +708,8 @@ def compatibility_subschemas(reader_schema, writer_schema, location: List[str])
     reader_subschemas_and_type = maybe_get_subschemas_and_type(reader_schema)
     writer_subschemas_and_type = maybe_get_subschemas_and_type(writer_schema)
 
+    reader_subschemas: Optional[List[Any]]
+    reader_type: JSONSCHEMA_TYPES
     if reader_subschemas_and_type is not None:
         reader_subschemas = reader_subschemas_and_type[0]
         reader_type = reader_subschemas_and_type[1]
@@ -735,6 +719,8 @@ def compatibility_subschemas(reader_schema, writer_schema, location: List[str])
         reader_type = get_type_of(reader_schema)
         reader_has_subschema = False
 
+    writer_subschemas: Optional[List[Any]]
+    writer_type: JSONSCHEMA_TYPES
     if writer_subschemas_and_type is not None:
         writer_subschemas = writer_subschemas_and_type[0]
         writer_type = writer_subschemas_and_type[1]
@@ -747,15 +733,18 @@ def compatibility_subschemas(reader_schema, writer_schema, location: List[str])
     is_reader_special_case = reader_has_subschema and not writer_has_subschema and is_simple_subschema(reader_schema)
     is_writer_special_case = not reader_has_subschema and writer_has_subschema and is_simple_subschema(writer_schema)
 
-    subschema_location = location + [reader_type.value]
+    subschema_location = location + [get_name_of(reader_type)]
 
     if is_reader_special_case:
+        assert reader_subschemas
         return check_simple_subschema(reader_subschemas[0], writer_schema, reader_type, writer_type, subschema_location)
 
     if is_writer_special_case:
+        assert writer_subschemas
         return check_simple_subschema(reader_schema, writer_subschemas[0], reader_type, writer_type, subschema_location)
 
     if reader_type in (Subschema.ANY_OF, Subschema.ONE_OF) and not writer_has_subschema:
+        assert isinstance(reader_type, Subschema)
         for reader_subschema in reader_schema[reader_type.value]:
             rec_result = compatibility_rec(reader_subschema, writer_schema, subschema_location)
             if is_compatible(rec_result):
diff --git a/karapace/compatibility/jsonschema/utils.py b/karapace/compatibility/jsonschema/utils.py
index 9bc3d453c..e1f4d0deb 100644
--- a/karapace/compatibility/jsonschema/utils.py
+++ b/karapace/compatibility/jsonschema/utils.py
@@ -6,6 +6,7 @@
 import re
 
 T = TypeVar('T')
+JSONSCHEMA_TYPES = Union[Instance, Subschema, Keyword, Type[BooleanSchema]]
 
 
 def normalize_schema(validator: Draft7Validator) -> Any:
@@ -164,8 +165,7 @@ def is_true_schema(schema: Any) -> bool:
     """True if the value of `schema` is equal to the explicit accept schema `{}`."""
     # https://json-schema.org/draft/2020-12/json-schema-core.html#rfc.section.4.3.2
     is_true = schema is True
-    is_empty_schema = isinstance(schema, dict) and len(schema) == 0
-    return is_true or is_empty_schema
+    return is_true
 
 
 def is_false_schema(schema: Any) -> bool:
@@ -176,8 +176,6 @@ def is_false_schema(schema: Any) -> bool:
 
     >>> is_false_schema(parse_jsonschema_definition("false"))
     True
-    >>> is_false_schema(parse_jsonschema_definition('{"not":{}}'))
-    True
     >>> is_false_schema(parse_jsonschema_definition("{}"))
     False
     >>> is_false_schema(parse_jsonschema_definition("true"))
@@ -186,14 +184,14 @@ def is_false_schema(schema: Any) -> bool:
     Note:
         Negated schemas are not the same as the false schema:
 
+        >>> is_false_schema(parse_jsonschema_definition('{"not":{}}'))
+        False
         >>> is_false_schema(parse_jsonschema_definition('{"not":{"type":"number"}}'))
         False
     """
     # https://json-schema.org/draft/2020-12/json-schema-core.html#rfc.section.4.3.2
     is_false = schema is False
-    not_subschema = isinstance(schema, dict) and schema.get("not")
-    is_not_of_true = not_subschema is not None and is_true_schema(not_subschema)
-    return is_false or is_not_of_true
+    return is_false
 
 
 def is_array_content_model_open(schema: Any) -> bool:
@@ -326,7 +324,7 @@ def schema_from_partially_open_content_model(schema: dict, target_property_name:
     return schema.get(Keyword.ADDITIONAL_PROPERTIES.value)
 
 
-def get_type_of(schema: Any) -> Union[Instance, Subschema, Keyword, Type[BooleanSchema]]:
+def get_type_of(schema: Any) -> JSONSCHEMA_TYPES:
     # https://json-schema.org/draft/2020-12/json-schema-core.html#rfc.section.4.2.1
 
     # The difference is due to the convertion of the JSON value null to the Python value None
@@ -358,9 +356,18 @@ def get_type_of(schema: Any) -> Union[Instance, Subschema, Keyword, Type[Boolean
         if Keyword.ENUM.value in schema:
             return Keyword.ENUM
 
+        return Instance.OBJECT
+
     raise ValueError("Couldnt determine type of schema")
 
 
+def get_name_of(schema_type: JSONSCHEMA_TYPES) -> str:
+    if isinstance(schema_type, (Instance, Subschema, Keyword)):
+        return schema_type.value
+
+    return ""
+
+
 def is_simple_subschema(schema: Any) -> bool:
     if schema is None:
         return False
diff --git a/karapace/config.py b/karapace/config.py
index 40ff7422e..4bea8a84e 100644
--- a/karapace/config.py
+++ b/karapace/config.py
@@ -5,13 +5,15 @@
 See LICENSE for details
 """
 from pathlib import Path
-from typing import Dict, IO, Union
+from typing import Dict, IO, List, Union
 
 import json
 import os
 import socket
 import ssl
 
+Config = Dict[str, Union[str, int, bool, List[str]]]
+
 DEFAULTS = {
     "advertised_hostname": socket.gethostname(),
     "bootstrap_uri": "127.0.0.1:9092",
@@ -65,7 +67,7 @@ def parse_env_value(value: str) -> Union[str, int, bool]:
     return value
 
 
-def set_config_defaults(config: Dict[str, Union[str, int, bool]]) -> Dict[str, Union[str, int, bool]]:
+def set_config_defaults(config: Config) -> Config:
     for k, v in DEFAULTS.items():
         if k.startswith("karapace"):
             env_name = k.upper()
@@ -81,11 +83,11 @@ def set_config_defaults(config: Dict[str, Union[str, int, bool]]) -> Dict[str, U
     return config
 
 
-def write_config(config_path: Path, custom_values: Dict[str, Union[str, int, bool]]):
+def write_config(config_path: Path, custom_values: Config) -> None:
     config_path.write_text(json.dumps(custom_values))
 
 
-def read_config(config_handler: IO) -> Dict[str, Union[str, int, bool]]:
+def read_config(config_handler: IO) -> Config:
     try:
         config = json.load(config_handler)
         config = set_config_defaults(config)
@@ -94,7 +96,7 @@ def read_config(config_handler: IO) -> Dict[str, Union[str, int, bool]]:
         raise InvalidConfiguration(ex)
 
 
-def create_ssl_context(config: Dict[str, Union[str, int, bool]]) -> ssl.SSLContext:
+def create_ssl_context(config: Config) -> ssl.SSLContext:
     # taken from conn.py, as it adds a lot more logic to the context configuration than the initial version
     ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS)  # pylint: disable=no-member
     ssl_context.options |= ssl.OP_NO_SSLv2  # pylint: disable=no-member
diff --git a/karapace/kafka_rest_apis/__init__.py b/karapace/kafka_rest_apis/__init__.py
index 1dec3d8b8..4e937b1a1 100644
--- a/karapace/kafka_rest_apis/__init__.py
+++ b/karapace/kafka_rest_apis/__init__.py
@@ -402,7 +402,11 @@ def validate_partition_id(partition_id: str, content_type: str) -> int:
         try:
             return int(partition_id)
         except ValueError:
-            KafkaRest.not_found(message=f"Partition {partition_id} not found", content_type=content_type, sub_code=404)
+            KafkaRest.not_found(
+                message=f"Partition {partition_id} not found",
+                content_type=content_type,
+                sub_code=RESTErrorCodes.HTTP_NOT_FOUND.value,
+            )
 
     @staticmethod
     def is_valid_schema_request(data: dict, prefix: str) -> bool:
@@ -483,18 +487,32 @@ def get_partition_info(self, topic: str, partition: str, content_type: str) -> d
             for p in partitions:
                 if p["partition"] == partition:
                     return p
-            self.not_found(message=f"Partition {partition} not found", content_type=content_type, sub_code=40402)
+            self.not_found(
+                message=f"Partition {partition} not found",
+                content_type=content_type,
+                sub_code=RESTErrorCodes.PARTITION_NOT_FOUND.value,
+            )
         except UnknownTopicOrPartitionError:
-            self.not_found(message=f"Partition {partition} not found", content_type=content_type, sub_code=40402)
+            self.not_found(
+                message=f"Partition {partition} not found",
+                content_type=content_type,
+                sub_code=RESTErrorCodes.PARTITION_NOT_FOUND.value,
+            )
         except KeyError:
-            self.not_found(message=f"Topic {topic} not found", content_type=content_type, sub_code=40401)
+            self.not_found(
+                message=f"Topic {topic} not found",
+                content_type=content_type,
+                sub_code=RESTErrorCodes.TOPIC_NOT_FOUND.value,
+            )
         return {}
 
     def get_topic_info(self, topic: str, content_type: str) -> dict:
         md = self.cluster_metadata()["topics"]
         if topic not in md:
             self.not_found(
-                message=f"Topic {topic} not found in {list(md.keys())}", content_type=content_type, sub_code=40401
+                message=f"Topic {topic} not found in {list(md.keys())}",
+                content_type=content_type,
+                sub_code=RESTErrorCodes.TOPIC_NOT_FOUND.value,
             )
         return md[topic]
 
@@ -531,11 +549,19 @@ async def validate_publish_request_format(self, data: dict, formats: dict, conte
 
         # disallow missing or non empty 'records' key , plus any other keys
         if "records" not in data or set(data.keys()).difference(PUBLISH_KEYS) or not data["records"]:
-            self.unprocessable_entity(message="Invalid request format", content_type=content_type, sub_code=422)
+            self.unprocessable_entity(
+                message="Invalid request format",
+                content_type=content_type,
+                sub_code=RESTErrorCodes.HTTP_UNPROCESSABLE_ENTITY.value,
+            )
         for r in data["records"]:
             convert_to_int(r, "partition", content_type)
             if set(r.keys()).difference(RECORD_KEYS):
-                self.unprocessable_entity(message="Invalid request format", content_type=content_type, sub_code=422)
+                self.unprocessable_entity(
+                    message="Invalid request format",
+                    content_type=content_type,
+                    sub_code=RESTErrorCodes.HTTP_UNPROCESSABLE_ENTITY.value,
+                )
         # disallow missing id and schema for any key/value list that has at least one populated element
         if formats["embedded_format"] in {"avro", "jsonschema"}:
             for prefix, code in zip(RECORD_KEYS, RECORD_CODES):
@@ -551,7 +577,11 @@ async def validate_publish_request_format(self, data: dict, formats: dict, conte
                 try:
                     await self.validate_schema_info(data, prefix, content_type, topic, formats["embedded_format"])
                 except InvalidMessageSchema as e:
-                    self.unprocessable_entity(message=str(e), content_type=content_type, sub_code=42205)
+                    self.unprocessable_entity(
+                        message=str(e),
+                        content_type=content_type,
+                        sub_code=RESTErrorCodes.INVALID_DATA.value,
+                    )
 
     async def produce_message(self, *, topic: str, key: bytes, value: bytes, partition: int = None) -> dict:
         prod = None
@@ -594,13 +624,21 @@ def topic_details(self, content_type: str, *, topic: str):
             metadata = self.cluster_metadata([topic])
             config = self.get_topic_config(topic)
             if topic not in metadata["topics"]:
-                self.not_found(message=f"Topic {topic} not found", content_type=content_type, sub_code=40401)
+                self.not_found(
+                    message=f"Topic {topic} not found",
+                    content_type=content_type,
+                    sub_code=RESTErrorCodes.TOPIC_NOT_FOUND.value,
+                )
             data = metadata["topics"][topic]
             data["name"] = topic
             data["configs"] = config
             self.r(data, content_type)
         except UnknownTopicOrPartitionError:
-            self.not_found(message=f"Topic {topic} not found", content_type=content_type, sub_code=40401)
+            self.not_found(
+                message=f"Topic {topic} not found",
+                content_type=content_type,
+                sub_code=RESTErrorCodes.UNKNOWN_TOPIC_OR_PARTITION.value,
+            )
 
     def list_partitions(self, content_type: str, *, topic: Optional[str]):
         self.log.info("Retrieving partition details for topic %s", topic)
@@ -608,7 +646,11 @@ def list_partitions(self, content_type: str, *, topic: Optional[str]):
             topic_details = self.cluster_metadata([topic])["topics"]
             self.r(topic_details[topic]["partitions"], content_type)
         except (UnknownTopicOrPartitionError, KeyError):
-            self.not_found(message=f"Topic {topic} not found", content_type=content_type, sub_code=40401)
+            self.not_found(
+                message=f"Topic {topic} not found",
+                content_type=content_type,
+                sub_code=RESTErrorCodes.TOPIC_NOT_FOUND.value,
+            )
 
     def partition_details(self, content_type: str, *, topic: str, partition_id: str):
         self.log.info("Retrieving partition details for topic %s and partition %s", topic, partition_id)
@@ -623,8 +665,16 @@ def partition_offsets(self, content_type: str, *, topic: str, partition_id: str)
         except UnknownTopicOrPartitionError as e:
             # Do a topics request on failure, figure out faster ways once we get correctness down
             if topic not in self.cluster_metadata()["topics"]:
-                self.not_found(message=f"Topic {topic} not found: {e}", content_type=content_type, sub_code=40401)
-            self.not_found(message=f"Partition {partition_id} not found: {e}", content_type=content_type, sub_code=40402)
+                self.not_found(
+                    message=f"Topic {topic} not found: {e}",
+                    content_type=content_type,
+                    sub_code=RESTErrorCodes.TOPIC_NOT_FOUND.value,
+                )
+            self.not_found(
+                message=f"Partition {partition_id} not found: {e}",
+                content_type=content_type,
+                sub_code=RESTErrorCodes.PARTITION_NOT_FOUND.value,
+            )
 
     def list_brokers(self, content_type: str):
         metadata = self.cluster_metadata()
diff --git a/karapace/kafka_rest_apis/__main__.py b/karapace/kafka_rest_apis/__main__.py
index 635fc8863..532928134 100644
--- a/karapace/kafka_rest_apis/__main__.py
+++ b/karapace/kafka_rest_apis/__main__.py
@@ -4,6 +4,7 @@
 from karapace.kafka_rest_apis import KafkaRest
 
 import argparse
+import logging
 import sys
 
 
@@ -16,6 +17,7 @@ def main() -> int:
     with closing(arg.config_file):
         config = read_config(arg.config_file)
 
+    logging.getLogger().setLevel(config["log_level"])
     kc = KafkaRest(config_file_path=arg.config_file.name, config=config)
     try:
         kc.run(host=kc.config["host"], port=kc.config["port"])
diff --git a/karapace/kafka_rest_apis/error_codes.py b/karapace/kafka_rest_apis/error_codes.py
index 9ae1f9b9e..3ac2a7f2a 100644
--- a/karapace/kafka_rest_apis/error_codes.py
+++ b/karapace/kafka_rest_apis/error_codes.py
@@ -1,15 +1,16 @@
-from enum import Enum, unique
+from enum import Enum
 from http import HTTPStatus
 
 
-@unique
 class RESTErrorCodes(Enum):
     HTTP_BAD_REQUEST = HTTPStatus.BAD_REQUEST.value
     HTTP_NOT_FOUND = HTTPStatus.NOT_FOUND.value
     HTTP_INTERNAL_SERVER_ERROR = HTTPStatus.INTERNAL_SERVER_ERROR.value
+    HTTP_UNPROCESSABLE_ENTITY = HTTPStatus.UNPROCESSABLE_ENTITY.value
     TOPIC_NOT_FOUND = 40401
     PARTITION_NOT_FOUND = 40402
     CONSUMER_NOT_FOUND = 40403
+    UNKNOWN_TOPIC_OR_PARTITION = 40403
     UNSUPPORTED_FORMAT = 40601
     SCHEMA_RETRIEVAL_ERROR = 40801
     CONSUMER_ALREADY_EXISTS = 40902
diff --git a/karapace/karapace.py b/karapace/karapace.py
index 8b437884d..11c656660 100644
--- a/karapace/karapace.py
+++ b/karapace/karapace.py
@@ -40,7 +40,6 @@ def __init__(self, config_file_path: str, config: dict) -> None:
         self.log = logging.getLogger("Karapace")
         self.app.on_startup.append(self.create_http_client)
         self.master_lock = asyncio.Lock()
-        self._set_log_level()
         self.log.info("Karapace initialized")
 
     def _create_producer(self) -> KafkaProducer:
@@ -68,12 +67,6 @@ def close(self) -> None:
         self.producer.close()
         self.producer = None
 
-    def _set_log_level(self) -> None:
-        try:
-            logging.getLogger().setLevel(self.config["log_level"])
-        except ValueError:
-            self.log.exception("Problem with log_level: %r", self.config["log_level"])
-
     @staticmethod
     def r(body: Union[dict, list], content_type: str, status: HTTPStatus = HTTPStatus.OK) -> NoReturn:
         raise HTTPResponse(
diff --git a/karapace/karapace_all.py b/karapace/karapace_all.py
index bd370399f..2b4e905cf 100644
--- a/karapace/karapace_all.py
+++ b/karapace/karapace_all.py
@@ -46,6 +46,8 @@ def main() -> int:
 
     config_file_path = arg.config_file.name
 
+    logging.getLogger().setLevel(config["log_level"])
+
     kc: RestApp
     if config["karapace_rest"] and config["karapace_registry"]:
         info_str = "both services"
diff --git a/karapace/schema_backup.py b/karapace/schema_backup.py
index 805936330..b100473c6 100644
--- a/karapace/schema_backup.py
+++ b/karapace/schema_backup.py
@@ -8,7 +8,7 @@
 from kafka.admin import KafkaAdminClient
 from kafka.errors import NoBrokersAvailable, NodeNotReadyError, TopicAlreadyExistsError
 from karapace import constants
-from karapace.config import read_config
+from karapace.config import Config, read_config
 from karapace.schema_reader import KafkaSchemaReader
 from karapace.utils import json_encode, KarapaceKafkaClient
 from typing import Optional
@@ -30,10 +30,8 @@ class Timeout(Exception):
 
 
 class SchemaBackup:
-    def __init__(self, config_path: str, backup_path: str, topic_option: Optional[str] = None) -> None:
-        with open(config_path) as handler:
-            self.config = read_config(handler)
-
+    def __init__(self, config: Config, backup_path: str, topic_option: Optional[str] = None) -> None:
+        self.config = config
         self.backup_location = backup_path
         self.topic_name = topic_option or self.config["topic_name"]
         self.log = logging.getLogger("SchemaBackup")
@@ -186,8 +184,9 @@ def restore_backup(self):
         with open(self.backup_location, "r") as fp:
             raw_msg = fp.read()
             values = json.loads(raw_msg)
+
         if not values:
-            raise BackupError("Nothing to restore in %s" % self.backup_location)
+            return
 
         for item in values:
             key = encode_value(item[0])
@@ -223,7 +222,11 @@ def parse_args():
 
 def main() -> int:
     args = parse_args()
-    sb = SchemaBackup(args.config, args.location, args.topic)
+
+    with open(args.config) as handler:
+        config = read_config(handler)
+
+    sb = SchemaBackup(config, args.location, args.topic)
 
     if args.command == "get":
         sb.request_backup()
diff --git a/karapace/schema_registry_apis.py b/karapace/schema_registry_apis.py
index 9f85398cd..0305692f3 100644
--- a/karapace/schema_registry_apis.py
+++ b/karapace/schema_registry_apis.py
@@ -13,6 +13,7 @@
 
 import argparse
 import asyncio
+import logging
 import sys
 import time
 
@@ -240,7 +241,7 @@ async def compatibility_check(self, content_type, *, subject, version, request):
         self.log.info("Existing schema: %r, new_schema: %r", old["schema"], body["schema"])
         try:
             schema_type = SchemaType(body.get("schemaType", "AVRO"))
-            new = TypedSchema.parse(schema_type, body["schema"])
+            new_schema = TypedSchema.parse(schema_type, body["schema"])
         except InvalidSchema:
             self.log.warning("Invalid schema: %r", body["schema"])
             self.r(
@@ -267,9 +268,15 @@ async def compatibility_check(self, content_type, *, subject, version, request):
 
         compatibility_mode = self._get_compatibility_mode(subject=old, content_type=content_type)
 
-        result = check_compatibility(source=old_schema, target=new, compatibility_mode=compatibility_mode)
+        result = check_compatibility(
+            old_schema=old_schema,
+            new_schema=new_schema,
+            compatibility_mode=compatibility_mode,
+        )
         if is_incompatible(result):
-            self.log.warning("Invalid schema %s found by compatibility check: old: %s new: %s", result, old_schema, new)
+            self.log.warning(
+                "Invalid schema %s found by compatibility check: old: %s new: %s", result, old_schema, new_schema
+            )
             self.r({"is_compatible": False}, content_type)
         self.r({"is_compatible": True}, content_type)
 
@@ -303,6 +310,8 @@ async def schemas_get(self, content_type, *, schema_id):
         self.r(response_body, content_type)
 
     async def config_get(self, content_type):
+        # Note: The format sent by the user differs from the return value, this
+        # is for compatibility reasons.
         self.r({"compatibilityLevel": self.ksr.config["compatibility"]}, content_type)
 
     async def config_set(self, content_type, *, request):
@@ -342,7 +351,12 @@ async def config_subject_get(self, content_type, subject: str, *, request: HTTPR
             if not compatibility and default_to_global:
                 compatibility = self.ksr.config["compatibility"]
             if compatibility:
-                self.r({"compatibilityLevel": compatibility}, content_type)
+                # Note: The format sent by the user differs from the return
+                # value, this is for compatibility reasons.
+                self.r(
+                    {"compatibilityLevel": compatibility},
+                    content_type,
+                )
 
         self.r(
             body={
@@ -680,7 +694,11 @@ def write_new_schema_local(self, subject, body, content_type):
 
             for old_version in check_against:
                 old_schema = subject_data["schemas"][old_version]["schema"]
-                result = check_compatibility(source=old_schema, target=new_schema, compatibility_mode=compatibility_mode)
+                result = check_compatibility(
+                    old_schema=old_schema,
+                    new_schema=new_schema,
+                    compatibility_mode=compatibility_mode,
+                )
                 if is_incompatible(result):
                     message = set(result.messages).pop() if result.messages else ""
                     self.log.warning("Incompatible schema: %s", result)
@@ -734,6 +752,7 @@ def main() -> int:
     with closing(arg.config_file):
         config = read_config(arg.config_file)
 
+    logging.getLogger().setLevel(config["log_level"])
     kc = KarapaceSchemaRegistry(config_file_path=arg.config_file.name, config=config)
     try:
         kc.run(host=kc.config["host"], port=kc.config["port"])
diff --git a/pytest.ini b/pytest.ini
index f9b0f9907..3417588cc 100644
--- a/pytest.ini
+++ b/pytest.ini
@@ -1,3 +1,3 @@
 [pytest]
 addopts = -ra -q --tb=short --showlocals --numprocesses auto
-timeout = 30
+timeout = 60
diff --git a/tests/conftest.py b/tests/conftest.py
index 6fbd85b48..c7c7d5841 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -44,6 +44,30 @@ def compatibility_details(header: str, depth: int, obj: SchemaCompatibilityResul
     return None
 
 
+def split_by_comma(arg: str) -> List[str]:
+    return arg.split(',')
+
+
+def pytest_addoption(parser, pluginmanager) -> None:  # pylint: disable=unused-argument
+    parser.addoption('--kafka-bootstrap-servers', type=split_by_comma)
+    parser.addoption('--registry-url')
+    parser.addoption('--rest-url')
+
+
+@pytest.fixture(autouse=True, scope="session")
+def fixture_validate_options(request) -> None:
+    """This fixture only exists to validate the custom command line flags."""
+    bootstrap_servers = request.config.getoption("kafka_bootstrap_servers")
+    registry_url = request.config.getoption("registry_url")
+    rest_url = request.config.getoption("rest_url")
+
+    needs_bootstrap_url = registry_url or rest_url
+
+    if needs_bootstrap_url and not bootstrap_servers:
+        msg = "When using an external registry or rest, the kafka bootstrap URIs must also be provided."
+        raise ValueError(msg)
+
+
 @pytest.fixture(scope="session", name="session_tmppath")
 def fixture_session_tmppath(tmp_path_factory) -> Path:
     return tmp_path_factory.mktemp("karapace")
diff --git a/tests/integration/conftest.py b/tests/integration/conftest.py
index d42c013c3..416261ca5 100644
--- a/tests/integration/conftest.py
+++ b/tests/integration/conftest.py
@@ -4,78 +4,36 @@
 Copyright (c) 2019 Aiven Ltd
 See LICENSE for details
 """
+from contextlib import closing, ExitStack
 from dataclasses import asdict, dataclass
 from filelock import FileLock
-from kafka import KafkaAdminClient, KafkaProducer
+from kafka import KafkaProducer
+from kafka.errors import LeaderNotAvailableError, NoBrokersAvailable
 from karapace.config import set_config_defaults, write_config
 from karapace.kafka_rest_apis import KafkaRest, KafkaRestAdminClient
 from karapace.schema_registry_apis import KarapaceSchemaRegistry
+from karapace.utils import Client
 from pathlib import Path
 from subprocess import Popen
-from tests.utils import Client, client_for, get_broker_ip, KafkaConfig, mock_factory, new_random_name, REGISTRY_URI, REST_URI
+from tests.utils import (
+    Expiration, get_random_port, KAFKA_PORT_RANGE, KafkaConfig, KafkaServers, new_random_name, REGISTRY_PORT_RANGE,
+    repeat_until_successful_request, ZK_PORT_RANGE
+)
 from typing import AsyncIterator, Dict, Iterator, List, Optional, Tuple
 
 import json
 import os
 import pytest
-import random
 import signal
 import socket
 import time
 
-KAFKA_CURRENT_VERSION = "2.4"
-BASEDIR = "kafka_2.12-2.4.1"
-CLASSPATH = os.path.join(BASEDIR, "libs", "*")
-
-
-@dataclass(frozen=True)
-class PortRangeInclusive:
-    start: int
-    end: int
-
-    PRIVILEGE_END = 2 ** 10
-    MAX_PORTS = 2 ** 16 - 1
-
-    def __post_init__(self):
-        # Make sure the range is valid and that we don't need to be root
-        assert self.end > self.start, "there must be at least one port available"
-        assert self.end <= self.MAX_PORTS, f"end must be lower than {self.MAX_PORTS}"
-        assert self.start > self.PRIVILEGE_END, "start must not be a privileged port"
-
-    def next_range(self, number_of_ports: int) -> "PortRangeInclusive":
-        next_start = self.end + 1
-        next_end = next_start + number_of_ports - 1  # -1 because the range is inclusive
-
-        return PortRangeInclusive(next_start, next_end)
-
-
-# To find a good port range use the following:
-#
-#   curl --silent 'https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.txt' | \
-#       egrep -i -e '^\s*[0-9]+-[0-9]+\s*unassigned' | \
-#       awk '{print $1}'
-#
-KAFKA_PORTS = PortRangeInclusive(48700, 48800)
-ZK_PORT_RANGE = KAFKA_PORTS.next_range(100)
-REGISTRY_PORT_RANGE = ZK_PORT_RANGE.next_range(100)
-
-
-class Timeout(Exception):
-    pass
-
+# Keep these in sync with the Makefile
+KAFKA_CURRENT_VERSION = "2.7"
+BASEDIR = "kafka_2.13-2.7.0"
 
-@dataclass(frozen=True)
-class Expiration:
-    msg: str
-    deadline: float
-
-    @classmethod
-    def from_timeout(cls, msg: str, timeout: float):
-        return cls(msg, time.monotonic() + timeout)
-
-    def raise_if_expired(self):
-        if time.monotonic() > self.deadline:
-            raise Timeout(self.msg)
+CLASSPATH = os.path.join(BASEDIR, "libs", "*")
+KAFKA_WAIT_TIMEOUT = 60
 
 
 @dataclass
@@ -93,6 +51,12 @@ def from_dict(data: dict) -> "ZKConfig":
         )
 
 
+def stop_process(proc: Optional[Popen]) -> None:
+    if proc:
+        os.kill(proc.pid, signal.SIGKILL)
+        proc.wait(timeout=10.0)
+
+
 def port_is_listening(hostname: str, port: int, ipv6: bool) -> bool:
     if ipv6:
         s = socket.socket(socket.AF_INET6, socket.SOCK_STREAM, 0)
@@ -107,58 +71,43 @@ def port_is_listening(hostname: str, port: int, ipv6: bool) -> bool:
         return False
 
 
-def wait_for_kafka(port: int, *, hostname: str = "127.0.0.1", wait_time: float = 20.0) -> None:
-    bootstrap_server = f"{hostname}:{port}"
-    expiration = Expiration.from_timeout(
-        msg=f"Could not contact kafka cluster on host `{bootstrap_server}`",
-        timeout=wait_time,
-    )
-
-    list_topics_successful = False
-    while not list_topics_successful:
-        expiration.raise_if_expired()
-        try:
-            KafkaAdminClient(bootstrap_servers=bootstrap_server).list_topics()
-        except Exception as e:  # pylint: disable=broad-except
-            print(f"Error checking kafka cluster: {e}")
-            time.sleep(2.0)
-        else:
-            list_topics_successful = True
+def wait_for_kafka(kafka_servers: KafkaServers, wait_time) -> None:
+    for server in kafka_servers.bootstrap_servers:
+        expiration = Expiration.from_timeout(timeout=wait_time)
+
+        list_topics_successful = False
+        msg = f"Could not contact kafka cluster on host `{server}`"
+        while not list_topics_successful:
+            expiration.raise_if_expired(msg)
+            try:
+                KafkaRestAdminClient(bootstrap_servers=server).cluster_metadata()
+            # ValueError:
+            # - if the port number is invalid (i.e. not a number)
+            # - if the port is not bound yet
+            # NoBrokersAvailable:
+            # - if the address/port does not point to a running server
+            # LeaderNotAvailableError:
+            # - if there is no leader yet
+            except (NoBrokersAvailable, LeaderNotAvailableError, ValueError) as e:  # pylint: disable=broad-except
+                print(f"Error checking kafka cluster: {e}")
+                time.sleep(2.0)
+            else:
+                list_topics_successful = True
 
 
 def wait_for_port(port: int, *, hostname: str = "127.0.0.1", wait_time: float = 20.0, ipv6: bool = False) -> None:
     start_time = time.monotonic()
-    expiration = Expiration(
-        msg=f"Timeout waiting for `{hostname}:{port}`",
-        deadline=start_time + wait_time,
-    )
+    expiration = Expiration(deadline=start_time + wait_time)
+    msg = f"Timeout waiting for `{hostname}:{port}`"
 
     while not port_is_listening(hostname, port, ipv6):
-        expiration.raise_if_expired()
+        expiration.raise_if_expired(msg)
         time.sleep(2.0)
 
     elapsed = time.monotonic() - start_time
     print(f"Server `{hostname}:{port}` listening after {elapsed} seconds")
 
 
-def get_random_port(*, port_range: PortRangeInclusive, blacklist: List[int]) -> int:
-    """ Find a random port in the range `PortRangeInclusive`.
-
-    Note:
-        This function is *not* aware of the ports currently open in the system,
-        the blacklist only prevents two services of the same type to randomly
-        get the same ports for *a single test run*.
-
-        Because of that, the port range should be chosen such that there is no
-        system service in the range. Also note that running two sessions of the
-        tests with the same range is not supported and will lead to flakiness.
-    """
-    value = random.randint(port_range.start, port_range.end)
-    while value in blacklist:
-        value = random.randint(port_range.start, port_range.end)
-    return value
-
-
 def lock_path_for(path: Path) -> Path:
     """ Append .lock to path """
     suffixes = path.suffixes
@@ -166,145 +115,133 @@ def lock_path_for(path: Path) -> Path:
     return path.with_suffix(''.join(suffixes))
 
 
-@pytest.fixture(scope="session", name="zkserver")
-def fixture_zkserver(session_tmppath: Path) -> Iterator[Optional[ZKConfig]]:
-    if REGISTRY_URI in os.environ or REST_URI in os.environ:
-        yield None
-        return
-
-    zk_dir = session_tmppath / "zk"
-    transfer_file = session_tmppath / "zk_config"
-
-    proc = None
-
-    # Synchronize xdist workers, data generated by the winner is shared through
-    # transfer_file (primarily the server's port number)
-    with FileLock(str(lock_path_for(zk_dir))):
-        if transfer_file.exists():
-            config = ZKConfig.from_dict(json.loads(transfer_file.read_text()))
-        else:
-            config, proc = configure_and_start_zk(zk_dir)
-            transfer_file.write_text(json.dumps(asdict(config)))
-    try:
-        wait_for_port(config.client_port)
-        yield config
-    finally:
-        if proc:
-            time.sleep(5)
-            os.kill(proc.pid, signal.SIGKILL)
-            proc.wait(timeout=10.0)
-
+@pytest.fixture(scope="session", name="kafka_servers")
+def fixture_kafka_server(request, session_tmppath: Path) -> Iterator[KafkaServers]:
+    bootstrap_servers = request.config.getoption("kafka_bootstrap_servers")
 
-@pytest.fixture(scope="session", name="kafka_server")
-def fixture_kafka_server(session_tmppath: Path, zkserver: ZKConfig) -> Iterator[Optional[KafkaConfig]]:
-    if REGISTRY_URI in os.environ or REST_URI in os.environ:
-        yield None
+    if bootstrap_servers:
+        kafka_servers = KafkaServers(bootstrap_servers)
+        wait_for_kafka(kafka_servers, KAFKA_WAIT_TIMEOUT)
+        yield kafka_servers
         return
 
     kafka_dir = session_tmppath / "kafka"
-    transfer_file = session_tmppath / "kafka_config"
-
-    proc = None
-
-    # Synchronize xdist workers, data generated by the winner is shared through
-    # transfer_file (primarily the server's port number)
-    with FileLock(str(lock_path_for(kafka_dir))):
-        if transfer_file.exists():
-            config = KafkaConfig.from_dict(json.loads(transfer_file.read_text()))
-        else:
-            config, proc = configure_and_start_kafka(kafka_dir, zkserver)
-            transfer_file.write_text(json.dumps(asdict(config)))
-
-    try:
-        wait_for_kafka(config.kafka_port, wait_time=60)
-        yield config
-    finally:
-        if proc is not None:
-            time.sleep(5)
-            os.kill(proc.pid, signal.SIGKILL)
-            proc.wait(timeout=10.0)
+    zk_dir = session_tmppath / "zk"
+    transfer_file = session_tmppath / "zk_kafka_config"
+
+    with ExitStack() as stack:
+        # Synchronize xdist workers, data generated by the winner is shared through
+        # transfer_file (primarily the server's port number)
+        with FileLock(str(lock_path_for(transfer_file))):
+            if transfer_file.exists():
+                config_data = json.loads(transfer_file.read_text())
+                zk_config = ZKConfig.from_dict(config_data['zookeeper'])
+                kafka_config = KafkaConfig.from_dict(config_data['kafka'])
+            else:
+                zk_config, zk_proc = configure_and_start_zk(zk_dir)
+                stack.callback(stop_process, zk_proc)
+
+                # Make sure zookeeper is running before trying to start Kafka
+                wait_for_port(zk_config.client_port, wait_time=20)
+
+                kafka_config, kafka_proc = configure_and_start_kafka(kafka_dir, zk_config)
+                stack.callback(stop_process, kafka_proc)
+
+                config_data = {
+                    'zookeeper': asdict(zk_config),
+                    'kafka': asdict(kafka_config),
+                }
+                transfer_file.write_text(json.dumps(config_data))
+
+        # Make sure every test worker can communicate with kafka
+        kafka_servers = KafkaServers(bootstrap_servers=[f"127.0.0.1:{kafka_config.kafka_port}"])
+        wait_for_kafka(kafka_servers, KAFKA_WAIT_TIMEOUT)
+        yield kafka_servers
+        return
 
 
 @pytest.fixture(scope="function", name="producer")
-def fixture_producer(kafka_server: Optional[KafkaConfig]) -> KafkaProducer:
-    if not kafka_server:
-        assert REST_URI in os.environ or REGISTRY_URI in os.environ
-        kafka_uri = f"{get_broker_ip()}:9092"
-    else:
-        kafka_uri = "127.0.0.1:{}".format(kafka_server.kafka_port)
-    prod = KafkaProducer(bootstrap_servers=kafka_uri)
-    try:
+def fixture_producer(kafka_servers: KafkaServers) -> KafkaProducer:
+    with closing(KafkaProducer(bootstrap_servers=kafka_servers.bootstrap_servers)) as prod:
         yield prod
-    finally:
-        prod.close()
 
 
 @pytest.fixture(scope="function", name="admin_client")
-def fixture_admin(kafka_server: Optional[KafkaConfig]) -> Iterator[KafkaRestAdminClient]:
-    if not kafka_server:
-        assert REST_URI in os.environ or REGISTRY_URI in os.environ
-        kafka_uri = f"{get_broker_ip()}:9092"
-    else:
-        kafka_uri = "127.0.0.1:{}".format(kafka_server.kafka_port)
-    cli = KafkaRestAdminClient(bootstrap_servers=kafka_uri)
-    try:
+def fixture_admin(kafka_servers: KafkaServers) -> Iterator[KafkaRestAdminClient]:
+    with closing(KafkaRestAdminClient(bootstrap_servers=kafka_servers.bootstrap_servers)) as cli:
         yield cli
-    finally:
-        cli.close()
 
 
 @pytest.fixture(scope="function", name="rest_async")
-async def fixture_rest_async(tmp_path: Path, kafka_server: Optional[KafkaConfig],
-                             registry_async_client: Client) -> AsyncIterator[KafkaRest]:
-    if not kafka_server:
-        assert REST_URI in os.environ
-        instance, _ = mock_factory("rest")()
-        yield instance
-    else:
-        config_path = tmp_path / "karapace_config.json"
-        kafka_port = kafka_server.kafka_port
-
-        config = set_config_defaults({
-            "log_level": "WARNING",
-            "bootstrap_uri": f"127.0.0.1:{kafka_port}",
-            "admin_metadata_max_age": 0
-        })
-        write_config(config_path, config)
-        rest = KafkaRest(config_file_path=str(config_path), config=config)
-
-        assert rest.serializer.registry_client
-        assert rest.consumer_manager.deserializer.registry_client
-        rest.serializer.registry_client.client = registry_async_client
-        rest.consumer_manager.deserializer.registry_client.client = registry_async_client
-        try:
-            yield rest
-        finally:
-            rest.close()
-            await rest.close_producers()
+async def fixture_rest_async(
+    request,
+    tmp_path: Path,
+    kafka_servers: KafkaServers,
+    registry_async_client: Client,
+) -> AsyncIterator[Optional[KafkaRest]]:
+
+    # Do not start a REST api when the user provided an external service. Doing
+    # so would cause this node to join the existing group and participate in
+    # the election process. Without proper configuration for the listeners that
+    # won't work and will cause test failures.
+    rest_url = request.config.getoption("rest_url")
+    if rest_url:
+        yield None
+        return
+
+    config_path = tmp_path / "karapace_config.json"
+
+    config = set_config_defaults({"bootstrap_uri": kafka_servers.bootstrap_servers, "admin_metadata_max_age": 0})
+    write_config(config_path, config)
+    rest = KafkaRest(config_file_path=str(config_path), config=config)
+
+    assert rest.serializer.registry_client
+    assert rest.consumer_manager.deserializer.registry_client
+    rest.serializer.registry_client.client = registry_async_client
+    rest.consumer_manager.deserializer.registry_client.client = registry_async_client
+    try:
+        yield rest
+    finally:
+        rest.close()
+        await rest.close_producers()
 
 
 @pytest.fixture(scope="function", name="rest_async_client")
-async def fixture_rest_async_client(rest_async: KafkaRest, aiohttp_client) -> AsyncIterator[Client]:
-    cli = await client_for(rest_async, aiohttp_client)
-    yield cli
-    await cli.close()
+async def fixture_rest_async_client(request, rest_async: KafkaRest, aiohttp_client) -> AsyncIterator[Client]:
+    rest_url = request.config.getoption("rest_url")
 
+    # client and server_uri are incompatible settings.
+    if rest_url:
+        client = Client(server_uri=rest_url)
+    else:
+        client_factory = await aiohttp_client(rest_async.app)
+        client = Client(client=client_factory)
+
+    with closing(client):
+        # wait until the server is listening, otherwise the tests may fail
+        await repeat_until_successful_request(
+            client.get,
+            "brokers",
+            json_data=None,
+            headers=None,
+            error_msg="REST API is unreachable",
+            timeout=10,
+            sleep=0.3,
+        )
+        yield client
 
-@pytest.fixture(scope="function", name="registry_async_pair")
-def fixture_registry_async_pair(tmp_path: Path, kafka_server: Optional[KafkaConfig]):
-    assert kafka_server, f"registry_async_pair can not be used if the env variable `{REGISTRY_URI}` or `{REST_URI}` is set"
 
+@pytest.fixture(scope="function", name="registry_async_pair")
+def fixture_registry_async_pair(tmp_path: Path, kafka_servers: KafkaServers):
     master_config_path = tmp_path / "karapace_config_master.json"
     slave_config_path = tmp_path / "karapace_config_slave.json"
     master_port = get_random_port(port_range=REGISTRY_PORT_RANGE, blacklist=[])
     slave_port = get_random_port(port_range=REGISTRY_PORT_RANGE, blacklist=[master_port])
-    kafka_port = kafka_server.kafka_port
     topic_name = new_random_name("schema_pairs")
     group_id = new_random_name("schema_pairs")
     write_config(
         master_config_path, {
-            "log_level": "WARNING",
-            "bootstrap_uri": f"127.0.0.1:{kafka_port}",
+            "bootstrap_uri": kafka_servers.bootstrap_servers,
             "topic_name": topic_name,
             "group_id": group_id,
             "advertised_hostname": "127.0.0.1",
@@ -314,8 +251,7 @@ def fixture_registry_async_pair(tmp_path: Path, kafka_server: Optional[KafkaConf
     )
     write_config(
         slave_config_path, {
-            "log_level": "WARNING",
-            "bootstrap_uri": f"127.0.0.1:{kafka_port}",
+            "bootstrap_uri": kafka_servers.bootstrap_servers,
             "topic_name": topic_name,
             "group_id": group_id,
             "advertised_hostname": "127.0.0.1",
@@ -335,36 +271,66 @@ def fixture_registry_async_pair(tmp_path: Path, kafka_server: Optional[KafkaConf
 
 
 @pytest.fixture(scope="function", name="registry_async")
-async def fixture_registry_async(tmp_path: Path,
-                                 kafka_server: Optional[KafkaConfig]) -> AsyncIterator[KarapaceSchemaRegistry]:
-    if not kafka_server:
-        assert REGISTRY_URI in os.environ or REST_URI in os.environ
-        instance, _ = mock_factory("registry")()
-        yield instance
-    else:
-        config_path = tmp_path / "karapace_config.json"
-        kafka_port = kafka_server.kafka_port
-
-        config = set_config_defaults({
-            "log_level": "WARNING",
-            "bootstrap_uri": f"127.0.0.1:{kafka_port}",
-            "topic_name": new_random_name(),
-            "group_id": new_random_name("schema_registry")
-        })
-        write_config(config_path, config)
-        registry = KarapaceSchemaRegistry(config_file_path=str(config_path), config=set_config_defaults(config))
-        await registry.get_master()
-        try:
-            yield registry
-        finally:
-            registry.close()
+async def fixture_registry_async(
+    request,
+    tmp_path: Path,
+    kafka_servers: KafkaServers,
+) -> AsyncIterator[Optional[KarapaceSchemaRegistry]]:
+    # Do not start a registry when the user provided an external service. Doing
+    # so would cause this node to join the existing group and participate in
+    # the election process. Without proper configuration for the listeners that
+    # won't work and will cause test failures.
+    rest_url = request.config.getoption("registry_url")
+    if rest_url:
+        yield None
+        return
+
+    config_path = tmp_path / "karapace_config.json"
+
+    config = set_config_defaults({
+        "bootstrap_uri": kafka_servers.bootstrap_servers,
+
+        # Using the default settings instead of random values, otherwise it
+        # would not be possible to run the tests with external services.
+        # Because of this every test must be written in such a way that it can
+        # be executed twice with the same servers.
+        # "topic_name": new_random_name("topic"),
+        # "group_id": new_random_name("schema_registry")
+    })
+    write_config(config_path, config)
+    registry = KarapaceSchemaRegistry(config_file_path=str(config_path), config=config)
+    await registry.get_master()
+    try:
+        yield registry
+    finally:
+        registry.close()
 
 
 @pytest.fixture(scope="function", name="registry_async_client")
-async def fixture_registry_async_client(registry_async: KarapaceSchemaRegistry, aiohttp_client) -> AsyncIterator[Client]:
-    cli = await client_for(registry_async, aiohttp_client)
-    yield cli
-    await cli.close()
+async def fixture_registry_async_client(request, registry_async: KarapaceSchemaRegistry,
+                                        aiohttp_client) -> AsyncIterator[Client]:
+
+    registry_url = request.config.getoption("registry_url")
+
+    # client and server_uri are incompatible settings.
+    if registry_url:
+        client = Client(server_uri=registry_url)
+    else:
+        client_factory = await aiohttp_client(registry_async.app)
+        client = Client(client=client_factory)
+
+    with closing(client):
+        # wait until the server is listening, otherwise the tests may fail
+        await repeat_until_successful_request(
+            client.get,
+            "subjects",
+            json_data=None,
+            headers=None,
+            error_msg="REST API is unreachable",
+            timeout=10,
+            sleep=0.3,
+        )
+        yield client
 
 
 def zk_java_args(cfg_path: Path) -> List[str]:
@@ -429,7 +395,7 @@ def configure_and_start_kafka(kafka_dir: Path, zk: ZKConfig) -> Tuple[KafkaConfi
     data_dir.mkdir(parents=True)
     config_dir.mkdir(parents=True)
 
-    plaintext_port = get_random_port(port_range=KAFKA_PORTS, blacklist=[])
+    plaintext_port = get_random_port(port_range=KAFKA_PORT_RANGE, blacklist=[])
 
     config = KafkaConfig(
         datadir=str(data_dir),
@@ -445,6 +411,7 @@ def configure_and_start_kafka(kafka_dir: Path, zk: ZKConfig) -> Tuple[KafkaConfi
         "PLAINTEXT://:{}".format(plaintext_port),
     ])
 
+    # Keep in sync with containers/docker-compose.yml
     kafka_config = {
         "broker.id": 1,
         "broker.rack": "local",
@@ -473,7 +440,7 @@ def configure_and_start_kafka(kafka_dir: Path, zk: ZKConfig) -> Tuple[KafkaConfi
         "transaction.state.log.num.partitions": 16,
         "transaction.state.log.replication.factor": 1,
         "zookeeper.connection.timeout.ms": 6000,
-        "zookeeper.connect": "{}:{}".format("127.0.0.1", zk.client_port)
+        "zookeeper.connect": f"127.0.0.1:{zk.client_port}",
     }
 
     with config_path.open("w") as fp:
diff --git a/tests/integration/schema_registry/test_jsonschema.py b/tests/integration/schema_registry/test_jsonschema.py
new file mode 100644
index 000000000..8cefa7ad7
--- /dev/null
+++ b/tests/integration/schema_registry/test_jsonschema.py
@@ -0,0 +1,1082 @@
+from jsonschema import Draft7Validator
+from karapace.compatibility import CompatibilityModes
+from karapace.schema_reader import SchemaType
+from karapace.utils import Client
+from tests.schemas.json_schemas import (
+    A_DINT_B_DINT_OBJECT_SCHEMA, A_DINT_B_INT_OBJECT_SCHEMA, A_DINT_B_NUM_C_DINT_OBJECT_SCHEMA, A_DINT_B_NUM_OBJECT_SCHEMA,
+    A_DINT_OBJECT_SCHEMA, A_INT_B_DINT_OBJECT_SCHEMA, A_INT_B_DINT_REQUIRED_OBJECT_SCHEMA, A_INT_B_INT_OBJECT_SCHEMA,
+    A_INT_B_INT_REQUIRED_OBJECT_SCHEMA, A_INT_OBJECT_SCHEMA, A_INT_OPEN_OBJECT_SCHEMA, A_OBJECT_SCHEMA, ALL_SCHEMAS,
+    ARRAY_OF_INT_SCHEMA, ARRAY_OF_NUMBER_SCHEMA, ARRAY_OF_POSITIVE_INTEGER, ARRAY_OF_POSITIVE_INTEGER_THROUGH_REF,
+    ARRAY_OF_STRING_SCHEMA, ARRAY_SCHEMA, B_DINT_OPEN_OBJECT_SCHEMA, B_INT_OBJECT_SCHEMA, B_INT_OPEN_OBJECT_SCHEMA,
+    B_NUM_C_DINT_OPEN_OBJECT_SCHEMA, B_NUM_C_INT_OBJECT_SCHEMA, B_NUM_C_INT_OPEN_OBJECT_SCHEMA, BOOLEAN_SCHEMA,
+    BOOLEAN_SCHEMAS, EMPTY_OBJECT_SCHEMA, EMPTY_SCHEMA, ENUM_AB_SCHEMA, ENUM_ABC_SCHEMA, ENUM_BC_SCHEMA,
+    EXCLUSIVE_MAXIMUM_DECREASED_INTEGER_SCHEMA, EXCLUSIVE_MAXIMUM_DECREASED_NUMBER_SCHEMA, EXCLUSIVE_MAXIMUM_INTEGER_SCHEMA,
+    EXCLUSIVE_MAXIMUM_NUMBER_SCHEMA, EXCLUSIVE_MINIMUM_INCREASED_INTEGER_SCHEMA, EXCLUSIVE_MINIMUM_INCREASED_NUMBER_SCHEMA,
+    EXCLUSIVE_MINIMUM_INTEGER_SCHEMA, EXCLUSIVE_MINIMUM_NUMBER_SCHEMA, FALSE_SCHEMA, INT_SCHEMA, MAX_ITEMS_DECREASED_SCHEMA,
+    MAX_ITEMS_SCHEMA, MAX_LENGTH_DECREASED_SCHEMA, MAX_LENGTH_SCHEMA, MAX_PROPERTIES_DECREASED_SCHEMA, MAX_PROPERTIES_SCHEMA,
+    MAXIMUM_DECREASED_INTEGER_SCHEMA, MAXIMUM_DECREASED_NUMBER_SCHEMA, MAXIMUM_INTEGER_SCHEMA, MAXIMUM_NUMBER_SCHEMA,
+    MIN_ITEMS_INCREASED_SCHEMA, MIN_ITEMS_SCHEMA, MIN_LENGTH_INCREASED_SCHEMA, MIN_LENGTH_SCHEMA, MIN_PATTERN_SCHEMA,
+    MIN_PATTERN_STRICT_SCHEMA, MIN_PROPERTIES_INCREASED_SCHEMA, MIN_PROPERTIES_SCHEMA, MINIMUM_INCREASED_INTEGER_SCHEMA,
+    MINIMUM_INCREASED_NUMBER_SCHEMA, MINIMUM_INTEGER_SCHEMA, MINIMUM_NUMBER_SCHEMA, NON_OBJECT_SCHEMAS, NOT_OF_EMPTY_SCHEMA,
+    NOT_OF_TRUE_SCHEMA, NUMBER_SCHEMA, OBJECT_SCHEMA, OBJECT_SCHEMAS, ONEOF_ARRAY_A_DINT_B_NUM_SCHEMA,
+    ONEOF_ARRAY_B_NUM_C_DINT_OPEN_SCHEMA, ONEOF_ARRAY_B_NUM_C_INT_SCHEMA, ONEOF_INT_SCHEMA, ONEOF_NUMBER_SCHEMA,
+    ONEOF_STRING_INT_SCHEMA, ONEOF_STRING_SCHEMA, PROPERTY_ASTAR_OBJECT_SCHEMA, STRING_SCHEMA, TRUE_SCHEMA,
+    TUPLE_OF_INT_INT_OPEN_SCHEMA, TUPLE_OF_INT_INT_SCHEMA, TUPLE_OF_INT_OPEN_SCHEMA, TUPLE_OF_INT_SCHEMA,
+    TUPLE_OF_INT_WITH_ADDITIONAL_INT_SCHEMA, TYPES_STRING_INT_SCHEMA, TYPES_STRING_SCHEMA
+)
+from tests.utils import new_random_name
+
+import json as jsonlib
+import pytest
+
+
+async def debugging_details(
+    newer: Draft7Validator,
+    older: Draft7Validator,
+    client: Client,
+    subject: str,
+) -> str:
+    newer_schema = jsonlib.dumps(newer.schema)
+    older_schema = jsonlib.dumps(older.schema)
+    config_res = await client.get(f"config/{subject}?defaultToGlobal=true")
+    config = config_res.json()
+    return f"subject={subject} newer={newer_schema} older={older_schema} compatibility={config}"
+
+
+async def not_schemas_are_compatible(
+    newer: Draft7Validator,
+    older: Draft7Validator,
+    client: Client,
+    compatibility_mode: CompatibilityModes,
+) -> None:
+    subject = new_random_name("subject")
+
+    # sanity check
+    subject_res = await client.get(f"subjects/{subject}/versions")
+    assert subject_res.status == 404, "random subject should no exist {subject}"
+
+    older_res = await client.post(
+        f"subjects/{subject}/versions",
+        json={
+            "schema": jsonlib.dumps(older.schema),
+            "schemaType": SchemaType.JSONSCHEMA.value,
+        },
+    )
+    assert older_res.status == 200, await debugging_details(newer, older, client, subject)
+    assert "id" in older_res.json(), await debugging_details(newer, older, client, subject)
+
+    # enforce the target compatibility mode. not using the global setting
+    # because that interfere with parallel runs.
+    subject_config_res = await client.put(f"config/{subject}", json={"compatibility": compatibility_mode.value})
+    assert subject_config_res.status == 200
+
+    newer_res = await client.post(
+        f"subjects/{subject}/versions",
+        json={
+            "schema": jsonlib.dumps(newer.schema),
+            "schemaType": SchemaType.JSONSCHEMA.value,
+        },
+    )
+    assert newer_res.status != 200, await debugging_details(newer, older, client, subject)
+
+    # Sanity check. The compatibility must be explicitly set because any
+    # difference can result in unexpected errors.
+    subject_config_res = await client.get(f"config/{subject}?defaultToGlobal=true")
+    subject_config = subject_config_res.json()
+    assert subject_config["compatibilityLevel"] == compatibility_mode.value
+
+
+async def schemas_are_compatible(
+    client: Client,
+    newer: Draft7Validator,
+    older: Draft7Validator,
+    compatibility_mode: CompatibilityModes,
+) -> None:
+    subject = new_random_name("subject")
+
+    # sanity check
+    subject_res = await client.get(f"subjects/{subject}/versions")
+    assert subject_res.status == 404, "random subject should no exist {subject}"
+
+    older_res = await client.post(
+        f"subjects/{subject}/versions",
+        json={
+            "schema": jsonlib.dumps(older.schema),
+            "schemaType": SchemaType.JSONSCHEMA.value,
+        },
+    )
+    assert older_res.status == 200, await debugging_details(newer, older, client, subject)
+    assert "id" in older_res.json(), await debugging_details(newer, older, client, subject)
+
+    # enforce the target compatibility mode. not using the global setting
+    # because that interfere with parallel runs.
+    subject_config_res = await client.put(f"config/{subject}", json={"compatibility": compatibility_mode.value})
+    assert subject_config_res.status == 200
+
+    newer_res = await client.post(
+        f"subjects/{subject}/versions",
+        json={
+            "schema": jsonlib.dumps(newer.schema),
+            "schemaType": SchemaType.JSONSCHEMA.value,
+        },
+    )
+    assert newer_res.status == 200, await debugging_details(newer, older, client, subject)
+    # Because the IDs are global, and the same schema is used in multiple
+    # tests, their order is unknown.
+    assert older_res.json()["id"] != newer_res.json()["id"], await debugging_details(newer, older, client, subject)
+
+    # Sanity check. The compatibility must be explicitly set because any
+    # difference can result in unexpected errors.
+    subject_config_res = await client.get(f"config/{subject}?defaultToGlobal=true")
+    subject_config = subject_config_res.json()
+    assert subject_config["compatibilityLevel"] == compatibility_mode.value
+
+
+async def schemas_are_backward_compatible(
+    reader: Draft7Validator,
+    writer: Draft7Validator,
+    client: Client,
+) -> None:
+    await schemas_are_compatible(
+        # For backwards compatibility the newer schema is the reader
+        newer=reader,
+        older=writer,
+        client=client,
+        compatibility_mode=CompatibilityModes.BACKWARD,
+    )
+
+
+async def not_schemas_are_backward_compatible(
+    reader: Draft7Validator,
+    writer: Draft7Validator,
+    client: Client,
+) -> None:
+    await not_schemas_are_compatible(
+        # For backwards compatibility the newer schema is the reader
+        newer=reader,
+        older=writer,
+        client=client,
+        compatibility_mode=CompatibilityModes.BACKWARD,
+    )
+
+
+@pytest.mark.parametrize("trail", ["", "/"])
+@pytest.mark.parametrize("compatibility", [CompatibilityModes.FORWARD, CompatibilityModes.BACKWARD, CompatibilityModes.FULL])
+async def test_same_jsonschema_must_have_same_id(
+    registry_async_client: Client, compatibility: CompatibilityModes, trail: str
+) -> None:
+    for schema in ALL_SCHEMAS:
+        subject = new_random_name("subject")
+
+        res = await registry_async_client.put(f"config/{subject}", json={"compatibility": compatibility.value})
+        assert res.status == 200
+
+        first_res = await registry_async_client.post(
+            f"subjects/{subject}/versions{trail}",
+            json={
+                "schema": jsonlib.dumps(schema.schema),
+                "schemaType": SchemaType.JSONSCHEMA.value,
+            },
+        )
+        assert first_res.status == 200
+        first_id = first_res.json().get("id")
+        assert first_id
+
+        second_res = await registry_async_client.post(
+            f"subjects/{subject}/versions{trail}",
+            json={
+                "schema": jsonlib.dumps(schema.schema),
+                "schemaType": SchemaType.JSONSCHEMA.value,
+            },
+        )
+        assert second_res.status == 200
+        assert first_id == second_res.json()["id"]
+
+
+async def test_schemaregistry_schemaregistry_extra_optional_field_with_open_model_is_compatible(
+    registry_async_client: Client
+) -> None:
+    # - the newer is an open model, the extra field produced by the older is
+    # automatically accepted
+    await schemas_are_backward_compatible(
+        reader=OBJECT_SCHEMA,
+        writer=A_INT_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=TRUE_SCHEMA,
+        writer=A_INT_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=EMPTY_SCHEMA,
+        writer=A_INT_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+
+    # - the older is a closed model, so the field `b` was never produced, which
+    # means that the older never produced an invalid value.
+    # - the newer's `b` field is optional, so the absenced of the field is not
+    # a problem, and `a` is ignored because of the open model
+    await schemas_are_backward_compatible(
+        reader=B_INT_OPEN_OBJECT_SCHEMA,
+        writer=A_INT_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+
+    # - if the model is closed, then `a` must also be accepted
+    await schemas_are_backward_compatible(
+        reader=A_INT_B_INT_OBJECT_SCHEMA,
+        writer=A_INT_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+
+    # Examples a bit more complex
+    await schemas_are_backward_compatible(
+        reader=A_DINT_B_NUM_C_DINT_OBJECT_SCHEMA,
+        writer=A_DINT_B_NUM_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=B_NUM_C_DINT_OPEN_OBJECT_SCHEMA,
+        writer=A_DINT_B_NUM_C_DINT_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=B_NUM_C_INT_OPEN_OBJECT_SCHEMA,
+        writer=A_DINT_B_NUM_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=B_NUM_C_DINT_OPEN_OBJECT_SCHEMA,
+        writer=A_DINT_B_NUM_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+
+
+async def test_schemaregistry_schemaregistry_extra_field_with_closed_model_is_incompatible(
+    registry_async_client: Client
+) -> None:
+    # await not_schemas_are_backward_compatible(
+    #     reader=FALSE_SCHEMA,
+    #     writer=A_INT_OBJECT_SCHEMA,
+    #     client=registry_async_client,
+    # )
+    await not_schemas_are_backward_compatible(
+        reader=A_INT_OBJECT_SCHEMA,
+        writer=FALSE_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        reader=NOT_OF_TRUE_SCHEMA,
+        writer=A_INT_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        reader=NOT_OF_EMPTY_SCHEMA,
+        writer=A_INT_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        reader=B_INT_OBJECT_SCHEMA,
+        writer=A_INT_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        reader=B_NUM_C_INT_OBJECT_SCHEMA,
+        writer=A_DINT_B_NUM_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        reader=B_NUM_C_INT_OBJECT_SCHEMA,
+        writer=A_DINT_B_NUM_C_DINT_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+
+
+async def test_schemaregistry_schemaregistry_missing_required_field_is_incompatible(registry_async_client: Client) -> None:
+    await not_schemas_are_backward_compatible(
+        reader=A_INT_B_INT_REQUIRED_OBJECT_SCHEMA,
+        writer=A_INT_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+    # await not_schemas_are_backward_compatible(
+    #     reader=A_INT_B_DINT_REQUIRED_OBJECT_SCHEMA,
+    #     writer=A_INT_OBJECT_SCHEMA,
+    #     client=registry_async_client,
+    # )
+    await not_schemas_are_backward_compatible(
+        reader=A_INT_OBJECT_SCHEMA,
+        writer=A_INT_B_DINT_REQUIRED_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+
+
+async def test_schemaregistry_giving_a_default_value_for_a_non_required_field_is_compatible(
+    registry_async_client: Client
+) -> None:
+    await schemas_are_backward_compatible(
+        reader=OBJECT_SCHEMA,
+        writer=A_DINT_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=TRUE_SCHEMA,
+        writer=A_DINT_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=EMPTY_SCHEMA,
+        writer=A_DINT_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=B_DINT_OPEN_OBJECT_SCHEMA,
+        writer=A_INT_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=A_INT_B_DINT_OBJECT_SCHEMA,
+        writer=A_INT_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=A_DINT_B_INT_OBJECT_SCHEMA,
+        writer=A_INT_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=B_NUM_C_DINT_OPEN_OBJECT_SCHEMA,
+        writer=A_DINT_B_NUM_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=A_DINT_B_DINT_OBJECT_SCHEMA,
+        writer=A_INT_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=A_DINT_B_DINT_OBJECT_SCHEMA,
+        writer=EMPTY_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+
+
+async def test_schemaregistry_boolean_schemas_are_backward_compatible(registry_async_client: Client) -> None:
+    # await not_schemas_are_backward_compatible(
+    #     reader=FALSE_SCHEMA,
+    #     writer=TRUE_SCHEMA,
+    #     client=registry_async_client,
+    # )
+    await schemas_are_backward_compatible(
+        reader=TRUE_SCHEMA,
+        writer=FALSE_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=FALSE_SCHEMA,
+        writer=TRUE_SCHEMA,
+        client=registry_async_client,
+    )
+
+
+async def test_schemaregistry_from_closed_to_open_is_incompatible(registry_async_client: Client) -> None:
+    await not_schemas_are_backward_compatible(
+        reader=B_NUM_C_INT_OBJECT_SCHEMA,
+        writer=B_NUM_C_DINT_OPEN_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+
+
+async def test_schemaregistry_union_with_incompatible_elements(registry_async_client: Client) -> None:
+    await not_schemas_are_backward_compatible(
+        reader=ONEOF_ARRAY_B_NUM_C_INT_SCHEMA,
+        writer=ONEOF_ARRAY_A_DINT_B_NUM_SCHEMA,
+        client=registry_async_client,
+    )
+
+
+async def test_schemaregistry_union_with_compatible_elements(registry_async_client: Client) -> None:
+    await schemas_are_backward_compatible(
+        reader=ONEOF_ARRAY_B_NUM_C_DINT_OPEN_SCHEMA,
+        writer=ONEOF_ARRAY_A_DINT_B_NUM_SCHEMA,
+        client=registry_async_client,
+    )
+
+
+async def test_schemaregistry_array_and_tuples_are_incompatible(registry_async_client: Client) -> None:
+    await not_schemas_are_backward_compatible(
+        reader=TUPLE_OF_INT_OPEN_SCHEMA,
+        writer=ARRAY_OF_INT_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        reader=ARRAY_OF_INT_SCHEMA,
+        writer=TUPLE_OF_INT_OPEN_SCHEMA,
+        client=registry_async_client,
+    )
+
+
+async def test_schemaregistry_true_schema_is_compatible_with_object(registry_async_client: Client) -> None:
+    for schema in OBJECT_SCHEMAS + BOOLEAN_SCHEMAS:
+        if schema != TRUE_SCHEMA:
+            await schemas_are_backward_compatible(
+                reader=TRUE_SCHEMA,
+                writer=schema,
+                client=registry_async_client,
+            )
+
+    for schema in NON_OBJECT_SCHEMAS:
+        await not_schemas_are_backward_compatible(
+            reader=TRUE_SCHEMA,
+            writer=schema,
+            client=registry_async_client,
+        )
+
+
+async def test_schemaregistry_schema_compatibility_successes(registry_async_client: Client) -> None:
+    # allowing a broader set of values is compatible
+    await schemas_are_backward_compatible(
+        reader=NUMBER_SCHEMA,
+        writer=INT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=ARRAY_OF_NUMBER_SCHEMA,
+        writer=ARRAY_OF_INT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=TUPLE_OF_INT_OPEN_SCHEMA,
+        writer=TUPLE_OF_INT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=TUPLE_OF_INT_WITH_ADDITIONAL_INT_SCHEMA,
+        writer=TUPLE_OF_INT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=ENUM_ABC_SCHEMA,
+        writer=ENUM_AB_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=ONEOF_STRING_INT_SCHEMA,
+        writer=ONEOF_STRING_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=ONEOF_STRING_INT_SCHEMA,
+        writer=STRING_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=A_INT_OPEN_OBJECT_SCHEMA,
+        writer=A_INT_B_INT_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+
+    # requiring less values is compatible
+    await schemas_are_backward_compatible(
+        reader=TUPLE_OF_INT_OPEN_SCHEMA,
+        writer=TUPLE_OF_INT_INT_OPEN_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=TUPLE_OF_INT_OPEN_SCHEMA,
+        writer=TUPLE_OF_INT_INT_SCHEMA,
+        client=registry_async_client,
+    )
+
+    # equivalences
+    await schemas_are_backward_compatible(
+        reader=ONEOF_STRING_SCHEMA,
+        writer=STRING_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=STRING_SCHEMA,
+        writer=ONEOF_STRING_SCHEMA,
+        client=registry_async_client,
+    )
+
+    # new non-required fields is compatible
+    await schemas_are_backward_compatible(
+        reader=A_INT_OBJECT_SCHEMA,
+        writer=EMPTY_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=A_INT_B_INT_OBJECT_SCHEMA,
+        writer=A_INT_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+
+
+async def test_schemaregistry_type_narrowing_incompabilities(registry_async_client: Client) -> None:
+    await not_schemas_are_backward_compatible(
+        reader=INT_SCHEMA,
+        writer=NUMBER_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        reader=ARRAY_OF_INT_SCHEMA,
+        writer=ARRAY_OF_NUMBER_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        reader=ENUM_AB_SCHEMA,
+        writer=ENUM_ABC_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        reader=ENUM_BC_SCHEMA,
+        writer=ENUM_ABC_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        reader=ONEOF_INT_SCHEMA,
+        writer=ONEOF_NUMBER_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        reader=ONEOF_STRING_SCHEMA,
+        writer=ONEOF_STRING_INT_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        reader=INT_SCHEMA,
+        writer=ONEOF_STRING_INT_SCHEMA,
+        client=registry_async_client,
+    )
+
+
+async def test_schemaregistry_type_mismatch_incompabilities(registry_async_client: Client) -> None:
+    await not_schemas_are_backward_compatible(
+        reader=BOOLEAN_SCHEMA,
+        writer=INT_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        reader=INT_SCHEMA,
+        writer=BOOLEAN_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        reader=STRING_SCHEMA,
+        writer=BOOLEAN_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        reader=STRING_SCHEMA,
+        writer=INT_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        reader=ARRAY_OF_INT_SCHEMA,
+        writer=ARRAY_OF_STRING_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        reader=TUPLE_OF_INT_INT_SCHEMA,
+        writer=TUPLE_OF_INT_OPEN_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        reader=TUPLE_OF_INT_INT_OPEN_SCHEMA,
+        writer=TUPLE_OF_INT_OPEN_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        reader=INT_SCHEMA,
+        writer=ENUM_AB_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        reader=ENUM_AB_SCHEMA,
+        writer=INT_SCHEMA,
+        client=registry_async_client,
+    )
+
+
+async def test_schemaregistry_true_and_false_schemas(registry_async_client: Client) -> None:
+    await schemas_are_backward_compatible(
+        writer=NOT_OF_EMPTY_SCHEMA,
+        reader=NOT_OF_TRUE_SCHEMA,
+        client=registry_async_client,
+    )
+    # await schemas_are_backward_compatible(
+    #     writer=NOT_OF_TRUE_SCHEMA,
+    #     reader=FALSE_SCHEMA,
+    #     client=registry_async_client,
+    # )
+    # await schemas_are_backward_compatible(
+    #     writer=NOT_OF_EMPTY_SCHEMA,
+    #     reader=FALSE_SCHEMA,
+    #     client=registry_async_client,
+    # )
+
+    await schemas_are_backward_compatible(
+        writer=TRUE_SCHEMA,
+        reader=EMPTY_SCHEMA,
+        client=registry_async_client,
+    )
+
+    # await schemas_are_backward_compatible(
+    #     writer=NOT_OF_EMPTY_SCHEMA,
+    #     reader=TRUE_SCHEMA,
+    #     client=registry_async_client,
+    # )
+    # await schemas_are_compatible(
+    #     writer=NOT_OF_TRUE_SCHEMA,
+    #     reader=TRUE_SCHEMA,
+    #     client=registry_async_client,
+    # )
+    # await schemas_are_compatible(
+    #     writer=NOT_OF_EMPTY_SCHEMA,
+    #     reader=TRUE_SCHEMA,
+    #     client=registry_async_client,
+    # )
+
+    await not_schemas_are_backward_compatible(
+        writer=TRUE_SCHEMA,
+        reader=NOT_OF_EMPTY_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=TRUE_SCHEMA,
+        reader=NOT_OF_TRUE_SCHEMA,
+        client=registry_async_client,
+    )
+
+    await not_schemas_are_backward_compatible(
+        writer=TRUE_SCHEMA,
+        reader=A_INT_B_INT_REQUIRED_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=FALSE_SCHEMA,
+        reader=A_INT_B_INT_REQUIRED_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+
+    await not_schemas_are_backward_compatible(
+        writer=NOT_OF_TRUE_SCHEMA,
+        reader=FALSE_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=FALSE_SCHEMA,
+        reader=NOT_OF_TRUE_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=FALSE_SCHEMA,
+        reader=NOT_OF_EMPTY_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=NOT_OF_EMPTY_SCHEMA,
+        reader=FALSE_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=TRUE_SCHEMA,
+        reader=NOT_OF_EMPTY_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=NOT_OF_EMPTY_SCHEMA,
+        reader=TRUE_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=TRUE_SCHEMA,
+        reader=NOT_OF_TRUE_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=NOT_OF_TRUE_SCHEMA,
+        reader=TRUE_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=TRUE_SCHEMA,
+        reader=NOT_OF_EMPTY_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=NOT_OF_EMPTY_SCHEMA,
+        reader=TRUE_SCHEMA,
+        client=registry_async_client,
+    )
+
+
+async def test_schemaregistry_schema_restrict_attributes_is_incompatible(registry_async_client: Client) -> None:
+    await not_schemas_are_backward_compatible(
+        writer=STRING_SCHEMA,
+        reader=MAX_LENGTH_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=MAX_LENGTH_SCHEMA,
+        reader=MAX_LENGTH_DECREASED_SCHEMA,
+        client=registry_async_client,
+    )
+
+    await not_schemas_are_backward_compatible(
+        writer=STRING_SCHEMA,
+        reader=MIN_LENGTH_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=MIN_LENGTH_SCHEMA,
+        reader=MIN_LENGTH_INCREASED_SCHEMA,
+        client=registry_async_client,
+    )
+
+    await not_schemas_are_backward_compatible(
+        writer=STRING_SCHEMA,
+        reader=MIN_PATTERN_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=MIN_PATTERN_SCHEMA,
+        reader=MIN_PATTERN_STRICT_SCHEMA,
+        client=registry_async_client,
+    )
+
+    await not_schemas_are_backward_compatible(
+        writer=INT_SCHEMA,
+        reader=MAXIMUM_INTEGER_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=INT_SCHEMA,
+        reader=MAXIMUM_NUMBER_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=NUMBER_SCHEMA,
+        reader=MAXIMUM_NUMBER_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=MAXIMUM_NUMBER_SCHEMA,
+        reader=MAXIMUM_DECREASED_NUMBER_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=MAXIMUM_INTEGER_SCHEMA,
+        reader=MAXIMUM_DECREASED_INTEGER_SCHEMA,
+        client=registry_async_client,
+    )
+
+    await not_schemas_are_backward_compatible(
+        writer=INT_SCHEMA,
+        reader=MINIMUM_NUMBER_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=NUMBER_SCHEMA,
+        reader=MINIMUM_NUMBER_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=MINIMUM_NUMBER_SCHEMA,
+        reader=MINIMUM_INCREASED_NUMBER_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=MINIMUM_INTEGER_SCHEMA,
+        reader=MINIMUM_INCREASED_INTEGER_SCHEMA,
+        client=registry_async_client,
+    )
+
+    await not_schemas_are_backward_compatible(
+        writer=INT_SCHEMA,
+        reader=EXCLUSIVE_MAXIMUM_NUMBER_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=NUMBER_SCHEMA,
+        reader=EXCLUSIVE_MAXIMUM_NUMBER_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=EXCLUSIVE_MAXIMUM_NUMBER_SCHEMA,
+        reader=EXCLUSIVE_MAXIMUM_DECREASED_NUMBER_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=EXCLUSIVE_MAXIMUM_NUMBER_SCHEMA,
+        reader=EXCLUSIVE_MAXIMUM_DECREASED_INTEGER_SCHEMA,
+        client=registry_async_client,
+    )
+
+    await not_schemas_are_backward_compatible(
+        writer=NUMBER_SCHEMA,
+        reader=EXCLUSIVE_MINIMUM_NUMBER_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=INT_SCHEMA,
+        reader=EXCLUSIVE_MINIMUM_NUMBER_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=EXCLUSIVE_MINIMUM_NUMBER_SCHEMA,
+        reader=EXCLUSIVE_MINIMUM_INCREASED_NUMBER_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=EXCLUSIVE_MINIMUM_INTEGER_SCHEMA,
+        reader=EXCLUSIVE_MINIMUM_INCREASED_INTEGER_SCHEMA,
+        client=registry_async_client,
+    )
+
+    await not_schemas_are_backward_compatible(
+        writer=OBJECT_SCHEMA,
+        reader=MAX_PROPERTIES_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=MAX_PROPERTIES_SCHEMA,
+        reader=MAX_PROPERTIES_DECREASED_SCHEMA,
+        client=registry_async_client,
+    )
+
+    await not_schemas_are_backward_compatible(
+        writer=OBJECT_SCHEMA,
+        reader=MIN_PROPERTIES_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=MIN_PROPERTIES_SCHEMA,
+        reader=MIN_PROPERTIES_INCREASED_SCHEMA,
+        client=registry_async_client,
+    )
+
+    await not_schemas_are_backward_compatible(
+        writer=ARRAY_SCHEMA,
+        reader=MAX_ITEMS_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=MAX_ITEMS_SCHEMA,
+        reader=MAX_ITEMS_DECREASED_SCHEMA,
+        client=registry_async_client,
+    )
+
+    await not_schemas_are_backward_compatible(
+        writer=ARRAY_SCHEMA,
+        reader=MIN_ITEMS_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        writer=MIN_ITEMS_SCHEMA,
+        reader=MIN_ITEMS_INCREASED_SCHEMA,
+        client=registry_async_client,
+    )
+
+
+async def test_schemaregistry_schema_broadenning_attributes_is_compatible(registry_async_client: Client) -> None:
+    await schemas_are_backward_compatible(
+        writer=MAX_LENGTH_SCHEMA,
+        reader=STRING_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        writer=MAX_LENGTH_DECREASED_SCHEMA,
+        reader=MAX_LENGTH_SCHEMA,
+        client=registry_async_client,
+    )
+
+    await schemas_are_backward_compatible(
+        writer=MIN_LENGTH_SCHEMA,
+        reader=STRING_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        writer=MIN_LENGTH_INCREASED_SCHEMA,
+        reader=MIN_LENGTH_SCHEMA,
+        client=registry_async_client,
+    )
+
+    await schemas_are_backward_compatible(
+        writer=MIN_PATTERN_SCHEMA,
+        reader=STRING_SCHEMA,
+        client=registry_async_client,
+    )
+
+    await schemas_are_backward_compatible(
+        writer=MAXIMUM_INTEGER_SCHEMA,
+        reader=INT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        writer=MAXIMUM_NUMBER_SCHEMA,
+        reader=NUMBER_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        writer=MAXIMUM_DECREASED_NUMBER_SCHEMA,
+        reader=MAXIMUM_NUMBER_SCHEMA,
+        client=registry_async_client,
+    )
+
+    await schemas_are_backward_compatible(
+        writer=MINIMUM_INTEGER_SCHEMA,
+        reader=INT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        writer=MINIMUM_NUMBER_SCHEMA,
+        reader=NUMBER_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        writer=MINIMUM_INCREASED_NUMBER_SCHEMA,
+        reader=MINIMUM_NUMBER_SCHEMA,
+        client=registry_async_client,
+    )
+
+    await schemas_are_backward_compatible(
+        writer=EXCLUSIVE_MAXIMUM_INTEGER_SCHEMA,
+        reader=INT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        writer=EXCLUSIVE_MAXIMUM_NUMBER_SCHEMA,
+        reader=NUMBER_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        writer=EXCLUSIVE_MAXIMUM_DECREASED_NUMBER_SCHEMA,
+        reader=EXCLUSIVE_MAXIMUM_NUMBER_SCHEMA,
+        client=registry_async_client,
+    )
+
+    await schemas_are_backward_compatible(
+        writer=EXCLUSIVE_MINIMUM_NUMBER_SCHEMA,
+        reader=NUMBER_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        writer=EXCLUSIVE_MINIMUM_INTEGER_SCHEMA,
+        reader=INT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        writer=EXCLUSIVE_MINIMUM_INCREASED_NUMBER_SCHEMA,
+        reader=EXCLUSIVE_MINIMUM_NUMBER_SCHEMA,
+        client=registry_async_client,
+    )
+
+    await schemas_are_backward_compatible(
+        writer=MAX_PROPERTIES_SCHEMA,
+        reader=OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        writer=MAX_PROPERTIES_DECREASED_SCHEMA,
+        reader=MAX_PROPERTIES_SCHEMA,
+        client=registry_async_client,
+    )
+
+    await schemas_are_backward_compatible(
+        writer=MIN_PROPERTIES_SCHEMA,
+        reader=OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        writer=MIN_PROPERTIES_INCREASED_SCHEMA,
+        reader=MIN_PROPERTIES_SCHEMA,
+        client=registry_async_client,
+    )
+
+    await schemas_are_backward_compatible(
+        writer=MAX_ITEMS_SCHEMA,
+        reader=ARRAY_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        writer=MAX_ITEMS_DECREASED_SCHEMA,
+        reader=MAX_ITEMS_SCHEMA,
+        client=registry_async_client,
+    )
+
+    await schemas_are_backward_compatible(
+        writer=MIN_ITEMS_SCHEMA,
+        reader=ARRAY_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        writer=MIN_ITEMS_INCREASED_SCHEMA,
+        reader=MIN_ITEMS_SCHEMA,
+        client=registry_async_client,
+    )
+
+
+@pytest.mark.skip("not implemented yet")
+async def test_schemaregistry_property_name(registry_async_client: Client):
+    await schemas_are_backward_compatible(
+        reader=OBJECT_SCHEMA,
+        writer=PROPERTY_ASTAR_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+    await not_schemas_are_backward_compatible(
+        reader=A_OBJECT_SCHEMA,
+        writer=PROPERTY_ASTAR_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=PROPERTY_ASTAR_OBJECT_SCHEMA,
+        writer=A_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+
+    # - older accept any value for `a`
+    # - newer requires it to be an `int`, therefore the other values became
+    # invalid
+    await not_schemas_are_backward_compatible(
+        reader=A_INT_OBJECT_SCHEMA,
+        writer=PROPERTY_ASTAR_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+
+    # - older has property `b`
+    # - newer only accepts properties with match regex `a*`
+    await not_schemas_are_backward_compatible(
+        reader=B_INT_OBJECT_SCHEMA,
+        writer=PROPERTY_ASTAR_OBJECT_SCHEMA,
+        client=registry_async_client,
+    )
+
+
+async def test_schemaregistry_type_with_list(registry_async_client: Client):
+    # "type": [] is treated as a shortcut for anyOf
+    await schemas_are_backward_compatible(
+        reader=STRING_SCHEMA,
+        writer=TYPES_STRING_SCHEMA,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=TYPES_STRING_INT_SCHEMA,
+        writer=TYPES_STRING_SCHEMA,
+        client=registry_async_client,
+    )
+
+
+async def test_schemaregistry_ref(registry_async_client: Client):
+    await schemas_are_backward_compatible(
+        reader=ARRAY_OF_POSITIVE_INTEGER,
+        writer=ARRAY_OF_POSITIVE_INTEGER_THROUGH_REF,
+        client=registry_async_client,
+    )
+    await schemas_are_backward_compatible(
+        reader=ARRAY_OF_POSITIVE_INTEGER_THROUGH_REF,
+        writer=ARRAY_OF_POSITIVE_INTEGER,
+        client=registry_async_client,
+    )
diff --git a/tests/integration/test_client.py b/tests/integration/test_client.py
index 2d9583081..6ce07f85d 100644
--- a/tests/integration/test_client.py
+++ b/tests/integration/test_client.py
@@ -1,16 +1,17 @@
 from karapace.schema_reader import SchemaType, TypedSchema
 from karapace.serialization import SchemaRegistryClient
-from tests.utils import schema_avro_json
+from tests.utils import new_random_name, schema_avro_json
 
 
 async def test_remote_client(registry_async_client):
     schema_avro = TypedSchema.parse(SchemaType.AVRO, schema_avro_json)
     reg_cli = SchemaRegistryClient()
     reg_cli.client = registry_async_client
-    sc_id = await reg_cli.post_new_schema("foo", schema_avro)
+    subject = new_random_name("subject")
+    sc_id = await reg_cli.post_new_schema(subject, schema_avro)
     assert sc_id >= 0
     stored_schema = await reg_cli.get_schema_for_id(sc_id)
     assert stored_schema == schema_avro, f"stored schema {stored_schema.to_json()} is not {schema_avro.to_json()}"
-    stored_id, stored_schema = await reg_cli.get_latest_schema("foo")
+    stored_id, stored_schema = await reg_cli.get_latest_schema(subject)
     assert stored_id == sc_id
     assert stored_schema == schema_avro
diff --git a/tests/integration/test_master_coordinator.py b/tests/integration/test_master_coordinator.py
index 4229e51da..a70dcaa7e 100644
--- a/tests/integration/test_master_coordinator.py
+++ b/tests/integration/test_master_coordinator.py
@@ -4,14 +4,13 @@
 Copyright (c) 2019 Aiven Ltd
 See LICENSE for details
 """
+from contextlib import closing
 from karapace.config import set_config_defaults
 from karapace.master_coordinator import MasterCoordinator
-from tests.utils import KafkaConfig, REGISTRY_URI, REST_URI
-from typing import Optional
+from tests.utils import get_random_port, KafkaServers, new_random_name, TESTS_PORT_RANGE
 
 import asyncio
 import json
-import os
 import pytest
 import requests
 import time
@@ -41,54 +40,62 @@ def has_master(mc: MasterCoordinator) -> bool:
     return bool(mc.sc and not mc.sc.master and mc.sc.master_url)
 
 
+@pytest.mark.timeout(60)  # Github workflows need a bit of extra time
 @pytest.mark.parametrize("strategy", ["lowest", "highest"])
-def test_master_selection(kafka_server: Optional[KafkaConfig], strategy: str) -> None:
-    assert kafka_server, f"test_master_selection can not be used if the env variable `{REGISTRY_URI}` or `{REST_URI}` is set"
-
-    config_aa = set_config_defaults({})
-    config_aa["advertised_hostname"] = "127.0.0.1"
-    config_aa["bootstrap_uri"] = f"127.0.0.1:{kafka_server.kafka_port}"
-    config_aa["client_id"] = "aa"
-    config_aa["port"] = 1234
-    config_aa["master_election_strategy"] = strategy
-    mc_aa = init_admin(config_aa)
-    config_bb = set_config_defaults({})
-    config_bb["advertised_hostname"] = "127.0.0.1"
-    config_bb["bootstrap_uri"] = f"127.0.0.1:{kafka_server.kafka_port}"
-    config_bb["client_id"] = "bb"
-    config_bb["port"] = 5678
-    config_bb["master_election_strategy"] = strategy
-    mc_bb = init_admin(config_bb)
-
-    if strategy == "lowest":
-        master = mc_aa
-        slave = mc_bb
-    else:
-        master = mc_bb
-        slave = mc_aa
-
-    # Wait for the election to happen
-    while not is_master(master):
-        time.sleep(0.3)
-
-    while not has_master(slave):
-        time.sleep(0.3)
-
-    # Make sure the end configuration is as expected
-    master_url = f'http://{master.config["host"]}:{master.config["port"]}'
-    assert master.sc.election_strategy == strategy
-    assert slave.sc.election_strategy == strategy
-    assert master.sc.master_url == master_url
-    assert slave.sc.master_url == master_url
-    mc_aa.close()
-    mc_bb.close()
+def test_master_selection(kafka_servers: KafkaServers, strategy: str) -> None:
+    # Use random port to allow for parallel runs.
+    port1 = get_random_port(port_range=TESTS_PORT_RANGE, blacklist=[])
+    port2 = get_random_port(port_range=TESTS_PORT_RANGE, blacklist=[port1])
+    port_aa, port_bb = sorted((port1, port2))
+    client_id_aa = new_random_name("master_selection_aa_")
+    client_id_bb = new_random_name("master_selection_bb_")
+    group_id = new_random_name("group_id")
+
+    config_aa = set_config_defaults({
+        "advertised_hostname": "127.0.0.1",
+        "bootstrap_uri": kafka_servers.bootstrap_servers,
+        "client_id": client_id_aa,
+        "group_id": group_id,
+        "port": port_aa,
+        "master_election_strategy": strategy,
+    })
+    config_bb = set_config_defaults({
+        "advertised_hostname": "127.0.0.1",
+        "bootstrap_uri": kafka_servers.bootstrap_servers,
+        "client_id": client_id_bb,
+        "group_id": group_id,
+        "port": port_bb,
+        "master_election_strategy": strategy,
+    })
+
+    with closing(init_admin(config_aa)) as mc_aa, closing(init_admin(config_bb)) as mc_bb:
+        if strategy == "lowest":
+            master = mc_aa
+            slave = mc_bb
+        else:
+            master = mc_bb
+            slave = mc_aa
+
+        # Wait for the election to happen
+        while not is_master(master):
+            time.sleep(0.3)
+
+        while not has_master(slave):
+            time.sleep(0.3)
+
+        # Make sure the end configuration is as expected
+        master_url = f'http://{master.config["host"]}:{master.config["port"]}'
+        assert master.sc.election_strategy == strategy
+        assert slave.sc.election_strategy == strategy
+        assert master.sc.master_url == master_url
+        assert slave.sc.master_url == master_url
 
 
 async def test_schema_request_forwarding(registry_async_pair):
     master_url, slave_url = registry_async_pair
     max_tries, counter = 5, 0
     wait_time = 0.5
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     schema = {"type": "string"}
     other_schema = {"type": "int"}
     # Config updates
diff --git a/tests/integration/test_rest.py b/tests/integration/test_rest.py
index 2f105fbd6..a7d972522 100644
--- a/tests/integration/test_rest.py
+++ b/tests/integration/test_rest.py
@@ -1,9 +1,10 @@
 from kafka.errors import UnknownTopicOrPartitionError
 from pytest import raises
-from tests.utils import new_topic, REST_HEADERS, schema_avro_json, second_obj, second_schema_json, test_objects_avro
+from tests.utils import (
+    new_topic, REST_HEADERS, schema_avro_json, second_obj, second_schema_json, test_objects_avro, wait_for_topics
+)
 
-import os
-import pytest
+NEW_TOPIC_TIMEOUT = 10
 
 
 def check_successful_publish_response(success_response, objects, partition_id=None):
@@ -21,6 +22,7 @@ def check_successful_publish_response(success_response, objects, partition_id=No
 
 async def test_content_types(rest_async_client, admin_client):
     tn = new_topic(admin_client)
+    await wait_for_topics(rest_async_client, topic_names=[tn], timeout=NEW_TOPIC_TIMEOUT, sleep=1)
     valid_headers = [
         "application/vnd.kafka.v1+json",
         "application/vnd.kafka.binary.v1+json",
@@ -94,6 +96,7 @@ async def test_avro_publish(rest_async_client, registry_async_client, admin_clie
     # pylint: disable=W0612
     tn = new_topic(admin_client)
     other_tn = new_topic(admin_client)
+    await wait_for_topics(rest_async_client, topic_names=[tn, other_tn], timeout=NEW_TOPIC_TIMEOUT, sleep=1)
     header = REST_HEADERS["avro"]
     # check succeeds with 1 record and brand new schema
     res = await registry_async_client.post(f"subjects/{other_tn}/versions", json={"schema": second_schema_json})
@@ -121,7 +124,7 @@ async def test_avro_publish(rest_async_client, registry_async_client, admin_clie
             # assert res.status == 422, f"Expecting schema {second_schema_json} to not match records {test_objects}"
 
 
-def test_admin_client(admin_client, producer):
+async def test_admin_client(admin_client, producer):
     topic_names = [new_topic(admin_client) for i in range(10, 13)]
     topic_info = admin_client.cluster_metadata()
     retrieved_names = list(topic_info["topics"].keys())
@@ -179,11 +182,9 @@ async def test_internal(rest_async, admin_client):
 
 
 async def test_topics(rest_async_client, admin_client):
+    topic_foo = "foo"
     tn = new_topic(admin_client)
-    res = await rest_async_client.get("/topics")
-    assert res.ok, "Status code is not 200: %r" % res.status_code
-    data = res.json()
-    assert {tn}.difference(set(data)) == set(), "Retrieved topic names do not match: %r" % data
+    await wait_for_topics(rest_async_client, topic_names=[tn], timeout=NEW_TOPIC_TIMEOUT, sleep=1)
     res = await rest_async_client.get(f"/topics/{tn}")
     assert res.ok, "Status code is not 200: %r" % res.status_code
     data = res.json()
@@ -196,13 +197,14 @@ async def test_topics(rest_async_client, admin_client):
     assert len(data["partitions"][0]["replicas"]) == 1, "should only have one replica"
     assert data["partitions"][0]["replicas"][0]["leader"], "Replica should be leader"
     assert data["partitions"][0]["replicas"][0]["in_sync"], "Replica should be in sync"
-    res = await rest_async_client.get("/topics/foo")
-    assert res.status_code == 404, "Topic should not exist"
-    assert res.json()["error_code"] == 40401, "Error code does not match"
+    res = await rest_async_client.get(f"/topics/{topic_foo}")
+    assert res.status_code == 404, f"Topic {topic_foo} should not exist, status_code={res.status_code}"
+    assert res.json()["error_code"] == 40403, "Error code does not match"
 
 
 async def test_publish(rest_async_client, admin_client):
     topic = new_topic(admin_client)
+    await wait_for_topics(rest_async_client, topic_names=[topic], timeout=NEW_TOPIC_TIMEOUT, sleep=1)
     topic_url = f"/topics/{topic}"
     partition_url = f"/topics/{topic}/partitions/0"
     # Proper Json / Binary
@@ -220,6 +222,7 @@ async def test_publish(rest_async_client, admin_client):
 
 async def test_publish_malformed_requests(rest_async_client, admin_client):
     topic_name = new_topic(admin_client)
+    await wait_for_topics(rest_async_client, topic_names=[topic_name], timeout=NEW_TOPIC_TIMEOUT, sleep=1)
     for url in [f"/topics/{topic_name}", f"/topics/{topic_name}/partitions/0"]:
         # Malformed schema ++ empty records
         for js in [{"records": []}, {"foo": "bar"}, {"records": [{"valur": {"foo": "bar"}}]}]:
@@ -233,8 +236,6 @@ async def test_publish_malformed_requests(rest_async_client, admin_client):
         res_json = res.json()
         assert res.status == 422
         assert res_json["error_code"] == 42201
-        if "REST_URI" in os.environ and "REGISTRY_URI" in os.environ:
-            pytest.skip("Skipping encoding tests for remote proxy")
         res = await rest_async_client.post(url, json={"records": [{"value": "not base64"}]}, headers=REST_HEADERS["binary"])
         res_json = res.json()
         assert res.status == 422
@@ -250,6 +251,7 @@ async def test_brokers(rest_async_client):
 async def test_partitions(rest_async_client, admin_client, producer):
     # TODO -> This seems to be the only combination accepted by the offsets endpoint
     topic_name = new_topic(admin_client)
+    await wait_for_topics(rest_async_client, topic_names=[topic_name], timeout=NEW_TOPIC_TIMEOUT, sleep=1)
     header = {"Accept": "*/*", "Content-Type": "application/vnd.kafka.v2+json"}
     all_partitions_res = await rest_async_client.get(f"/topics/{topic_name}/partitions")
     assert all_partitions_res.ok, "Topic should exist"
diff --git a/tests/integration/test_rest_consumer.py b/tests/integration/test_rest_consumer.py
index b6cfa22e4..b564ac754 100644
--- a/tests/integration/test_rest_consumer.py
+++ b/tests/integration/test_rest_consumer.py
@@ -1,4 +1,7 @@
-from tests.utils import consumer_valid_payload, new_consumer, new_topic, REST_HEADERS, schema_data
+from tests.utils import (
+    consumer_valid_payload, new_consumer, new_random_name, new_topic, repeat_until_successful_request, REST_HEADERS,
+    schema_data
+)
 
 import base64
 import copy
@@ -64,8 +67,11 @@ async def test_assignment(rest_async_client, admin_client, trail):
 
 @pytest.mark.parametrize("trail", ["", "/"])
 async def test_subscription(rest_async_client, admin_client, producer, trail):
+    # The random name is necessary to avoid test errors, without it the second
+    # parametrize test will fail. Issue: #178
+    group_name = new_random_name("group")
+
     header = REST_HEADERS["binary"]
-    group_name = "sub_group"
     topic_name = new_topic(admin_client)
     instance_id = await new_consumer(rest_async_client, group_name, fmt="binary", trail=trail)
     sub_path = f"/consumers/{group_name}/instances/{instance_id}/subscription{trail}"
@@ -135,7 +141,7 @@ async def test_subscription(rest_async_client, admin_client, producer, trail):
     data = res.json()
     assert data["error_code"] == 40903, f"Invalid state error expected: {data}"
     # assign after subscribe will fail
-    assign_path = f"/consumers/sub_group/instances/{instance_id}/assignments{trail}"
+    assign_path = f"/consumers/{group_name}/instances/{instance_id}/assignments{trail}"
     assign_payload = {"partitions": [{"topic": topic_name, "partition": 0}]}
     res = await rest_async_client.post(assign_path, headers=REST_HEADERS["json"], json=assign_payload)
     assert res.status == 409, "Expecting status code 409 on assign after subscribe on the same consumer instance"
@@ -183,14 +189,19 @@ async def test_offsets(rest_async_client, admin_client, trail):
     )
     assert res.ok, f"Unexpected response status for assignment {res}"
 
-    res = await rest_async_client.post(
-        offsets_path, json={"offsets": [{
+    await repeat_until_successful_request(
+        rest_async_client.post,
+        offsets_path,
+        json_data={"offsets": [{
             "topic": topic_name,
             "partition": 0,
-            "offset": 0
-        }]}, headers=header
+            "offset": 0,
+        }]},
+        headers=header,
+        error_msg="Unexpected response status for offset commit",
+        timeout=20,
+        sleep=1,
     )
-    assert res.ok, f"Unexpected response status for offset commit {res}"
 
     res = await rest_async_client.get(
         offsets_path, headers=header, json={"partitions": [{
@@ -279,9 +290,20 @@ async def test_publish_consume_avro(rest_async_client, admin_client, trail, sche
     res = await rest_async_client.post(assign_path, json=assign_payload, headers=header)
     assert res.ok
     publish_payload = schema_data[schema_type][1]
-    pl = {"value_schema": schema_data[schema_type][0], "records": [{"value": o} for o in publish_payload]}
-    res = await rest_async_client.post(f"topics/{tn}{trail}", json=pl, headers=header)
-    assert res.ok
+    await repeat_until_successful_request(
+        rest_async_client.post,
+        f"topics/{tn}{trail}",
+        json_data={
+            "value_schema": schema_data[schema_type][0],
+            "records": [{
+                "value": o
+            } for o in publish_payload]
+        },
+        headers=header,
+        error_msg="Unexpected response status for offset commit",
+        timeout=10,
+        sleep=1,
+    )
     resp = await rest_async_client.get(consume_path, headers=header)
     assert resp.ok, f"Expected a successful response: {resp}"
     data = resp.json()
diff --git a/tests/integration/test_schema.py b/tests/integration/test_schema.py
index c1152306d..68c677a19 100644
--- a/tests/integration/test_schema.py
+++ b/tests/integration/test_schema.py
@@ -7,8 +7,8 @@
 from http import HTTPStatus
 from kafka import KafkaProducer
 from karapace.rapu import is_success
+from tests.utils import new_random_name, repeat_until_successful_request
 
-import asyncio
 import json as jsonlib
 import os
 import pytest
@@ -20,8 +20,7 @@
 @pytest.mark.parametrize("trail", ["", "/"])
 @pytest.mark.parametrize("compatibility", ["FORWARD", "BACKWARD", "FULL"])
 async def test_enum_schema_compatibility(registry_async_client, compatibility, trail):
-    subject = os.urandom(16).hex()
-
+    subject = new_random_name("subject")
     res = await registry_async_client.put(f"config{trail}", json={"compatibility": compatibility})
     assert res.status == 200
     schema = {
@@ -98,7 +97,7 @@ async def test_enum_schema_compatibility(registry_async_client, compatibility, t
 
 @pytest.mark.parametrize("trail", ["", "/"])
 async def test_union_to_union(registry_async_client, trail):
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     res = await registry_async_client.put(f"config/{subject}{trail}", json={"compatibility": "BACKWARD"})
     assert res.status == 200
     init_schema = {"name": "init", "type": "record", "fields": [{"name": "inner", "type": ["string", "int"]}]}
@@ -132,7 +131,7 @@ async def test_union_to_union(registry_async_client, trail):
     )
     assert res.status == 200
     # fw compat check
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     res = await registry_async_client.put(f"config/{subject}{trail}", json={"compatibility": "FORWARD"})
     assert res.status == 200
     res = await registry_async_client.post(
@@ -150,7 +149,7 @@ async def test_union_to_union(registry_async_client, trail):
 
 @pytest.mark.parametrize("trail", ["", "/"])
 async def test_missing_subject_compatibility(registry_async_client, trail):
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     res = await registry_async_client.post(
         f"subjects/{subject}/versions{trail}", json={"schema": jsonlib.dumps({"type": "string"})}
     )
@@ -167,7 +166,7 @@ async def test_missing_subject_compatibility(registry_async_client, trail):
 
 @pytest.mark.parametrize("trail", ["", "/"])
 async def test_record_union_schema_compatibility(registry_async_client, trail):
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     res = await registry_async_client.put(f"config/{subject}{trail}", json={"compatibility": "BACKWARD"})
     assert res.status == 200
     original_schema = {
@@ -246,8 +245,7 @@ async def test_record_union_schema_compatibility(registry_async_client, trail):
 
 @pytest.mark.parametrize("trail", ["", "/"])
 async def test_record_nested_schema_compatibility(registry_async_client, trail):
-    subject = os.urandom(16).hex()
-
+    subject = new_random_name("subject")
     res = await registry_async_client.put("config", json={"compatibility": "BACKWARD"})
     assert res.status == 200
     schema = {
@@ -294,7 +292,7 @@ async def test_compatibility_endpoint(registry_async_client, trail):
     res = await registry_async_client.put(f"config{trail}", json={"compatibility": "BACKWARD"})
     assert res.status == 200
 
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     schema = {
         "type": "record",
         "name": "Objct",
@@ -387,7 +385,7 @@ def _test_cases():
             yield "FULL", source, target, False
 
     for compatibility, source_type, target_type, expected in _test_cases():
-        subject = os.urandom(16).hex()
+        subject = new_random_name("subject")
         res = await registry_async_client.put(f"config/{subject}{trail}", json={"compatibility": compatibility})
         schema = {
             "type": "record",
@@ -416,7 +414,7 @@ def _test_cases():
 
 @pytest.mark.parametrize("trail", ["", "/"])
 async def test_record_schema_compatibility(registry_async_client, trail):
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
 
     res = await registry_async_client.put("config", json={"compatibility": "FORWARD"})
     assert res.status == 200
@@ -601,7 +599,7 @@ async def test_record_schema_compatibility(registry_async_client, trail):
     )
     assert res.status == 409
 
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     res = await registry_async_client.put(f"config/{subject}{trail}", json={"compatibility": "BACKWARD"})
     schema = {"type": "record", "name": "Object", "fields": [{"name": "first_name", "type": "string"}]}
     res = await registry_async_client.post(f"subjects/{subject}/versions{trail}", json={"schema": jsonlib.dumps(schema)})
@@ -615,7 +613,7 @@ async def test_record_schema_compatibility(registry_async_client, trail):
 async def test_enum_schema_field_add_compatibility(registry_async_client, trail):
     expected_results = [("BACKWARD", 200), ("FORWARD", 200), ("FULL", 200)]
     for compatibility, status_code in expected_results:
-        subject = os.urandom(16).hex()
+        subject = new_random_name("subject")
         res = await registry_async_client.put(f"config/{subject}{trail}", json={"compatibility": compatibility})
         assert res.status == 200
         schema = {"type": "enum", "name": "Suit", "symbols": ["SPADES", "HEARTS", "DIAMONDS"]}
@@ -632,7 +630,7 @@ async def test_enum_schema_field_add_compatibility(registry_async_client, trail)
 async def test_array_schema_field_add_compatibility(registry_async_client, trail):
     expected_results = [("BACKWARD", 200), ("FORWARD", 409), ("FULL", 409)]
     for compatibility, status_code in expected_results:
-        subject = os.urandom(16).hex()
+        subject = new_random_name("subject")
         res = await registry_async_client.put(f"config/{subject}{trail}", json={"compatibility": compatibility})
         assert res.status == 200
         schema = {"type": "array", "items": "int"}
@@ -649,7 +647,7 @@ async def test_array_schema_field_add_compatibility(registry_async_client, trail
 async def test_array_nested_record_compatibility(registry_async_client, trail):
     expected_results = [("BACKWARD", 409), ("FORWARD", 200), ("FULL", 409)]
     for compatibility, status_code in expected_results:
-        subject = os.urandom(16).hex()
+        subject = new_random_name("subject")
         res = await registry_async_client.put(f"config/{subject}{trail}", json={"compatibility": compatibility})
         assert res.status == 200
         schema = {
@@ -676,7 +674,7 @@ async def test_array_nested_record_compatibility(registry_async_client, trail):
 async def test_record_nested_array_compatibility(registry_async_client, trail):
     expected_results = [("BACKWARD", 200), ("FORWARD", 409), ("FULL", 409)]
     for compatibility, status_code in expected_results:
-        subject = os.urandom(16).hex()
+        subject = new_random_name("subject")
         res = await registry_async_client.put(f"config/{subject}{trail}", json={"compatibility": compatibility})
         assert res.status == 200
         schema = {
@@ -704,7 +702,7 @@ async def test_map_schema_field_add_compatibility(
 ):  # TODO: Rename to pålain check map schema and add additional steps
     expected_results = [("BACKWARD", 200), ("FORWARD", 409), ("FULL", 409)]
     for compatibility, status_code in expected_results:
-        subject = os.urandom(16).hex()
+        subject = new_random_name("subject")
         res = await registry_async_client.put(f"config/{subject}", json={"compatibility": compatibility})
         assert res.status == 200
         schema = {"type": "map", "values": "int"}
@@ -719,7 +717,7 @@ async def test_map_schema_field_add_compatibility(
 
 async def test_enum_schema(registry_async_client):
     for compatibility in {"BACKWARD", "FORWARD", "FULL"}:
-        subject = os.urandom(16).hex()
+        subject = new_random_name("subject")
         res = await registry_async_client.put(f"config/{subject}", json={"compatibility": compatibility})
         assert res.status == 200
         schema = {"type": "enum", "name": "testenum", "symbols": ["first"]}
@@ -741,7 +739,7 @@ async def test_enum_schema(registry_async_client):
         assert res.status == 409
 
         # Inside record
-        subject = os.urandom(16).hex()
+        subject = new_random_name("subject")
         schema = {
             "type": "record",
             "name": "object",
@@ -776,7 +774,7 @@ async def test_enum_schema(registry_async_client):
 async def test_fixed_schema(registry_async_client, compatibility):
     status_code_allowed = 200
     status_code_denied = 409
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     res = await registry_async_client.put(f"config/{subject}", json={"compatibility": compatibility})
     assert res.status == 200
     schema = {"type": "fixed", "size": 16, "name": "md5", "aliases": ["testalias"]}
@@ -799,7 +797,7 @@ async def test_fixed_schema(registry_async_client, compatibility):
     assert res.status == status_code_denied
 
     # In a record
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     schema = {
         "type": "record",
         "name": "object",
@@ -835,7 +833,7 @@ async def test_fixed_schema(registry_async_client, compatibility):
 async def test_primitive_schema(registry_async_client):
     expected_results = [("BACKWARD", 200), ("FORWARD", 200), ("FULL", 200)]
     for compatibility, status_code in expected_results:
-        subject = os.urandom(16).hex()
+        subject = new_random_name("subject")
         res = await registry_async_client.put(f"config/{subject}", json={"compatibility": compatibility})
         assert res.status == 200
 
@@ -849,7 +847,7 @@ async def test_primitive_schema(registry_async_client):
 
     expected_results = [("BACKWARD", 409), ("FORWARD", 409), ("FULL", 409)]
     for compatibility, status_code in expected_results:
-        subject = os.urandom(16).hex()
+        subject = new_random_name("subject")
         res = await registry_async_client.put(f"config/{subject}", json={"compatibility": compatibility})
         assert res.status == 200
 
@@ -864,7 +862,7 @@ async def test_primitive_schema(registry_async_client):
 async def test_union_comparing_to_other_types(registry_async_client):
     expected_results = [("BACKWARD", 409), ("FORWARD", 200), ("FULL", 409)]
     for compatibility, status_code in expected_results:
-        subject = os.urandom(16).hex()
+        subject = new_random_name("subject")
         res = await registry_async_client.put(f"config/{subject}", json={"compatibility": compatibility})
         assert res.status == 200
 
@@ -878,7 +876,7 @@ async def test_union_comparing_to_other_types(registry_async_client):
 
     expected_results = [("BACKWARD", 200), ("FORWARD", 409), ("FULL", 409)]
     for compatibility, status_code in expected_results:
-        subject = os.urandom(16).hex()
+        subject = new_random_name("subject")
         res = await registry_async_client.put(f"config/{subject}", json={"compatibility": compatibility})
         assert res.status == 200
 
@@ -892,7 +890,7 @@ async def test_union_comparing_to_other_types(registry_async_client):
 
     expected_results = [("BACKWARD", 409), ("FORWARD", 409), ("FULL", 409)]
     for compatibility, status_code in expected_results:
-        subject = os.urandom(16).hex()
+        subject = new_random_name("subject")
         res = await registry_async_client.put(f"config/{subject}", json={"compatibility": compatibility})
         assert res.status == 200
 
@@ -908,7 +906,7 @@ async def test_union_comparing_to_other_types(registry_async_client):
 
 
 async def test_transitive_compatibility(registry_async_client):
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     res = await registry_async_client.put(f"config/{subject}", json={"compatibility": "BACKWARD_TRANSITIVE"})
     assert res.status == 200
 
@@ -979,7 +977,7 @@ async def test_transitive_compatibility(registry_async_client):
 
 @pytest.mark.parametrize("trail", ["", "/"])
 async def test_schema(registry_async_client, trail):
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     schema_str = '{"type": "string"}'
     res = await registry_async_client.post(
         f"subjects/{subject}/versions{trail}",
@@ -1108,7 +1106,7 @@ async def test_schema(registry_async_client, trail):
     assert res.json() == [4]
 
     # Check version number generation when deleting an entire subjcect
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     res = await registry_async_client.put("config/{}".format(subject), json={"compatibility": "NONE"})
     assert res.status == 200
     schema = {
@@ -1152,7 +1150,7 @@ async def test_schema(registry_async_client, trail):
     assert res.json() == [3]  # Version number generation should now begin at 3
 
     # Check the return format on a more complex schema for version get
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     schema = {
         "type": "record",
         "name": "Objct",
@@ -1173,7 +1171,7 @@ async def test_schema(registry_async_client, trail):
     assert sorted(jsonlib.loads(res.json()["schema"])) == sorted(schema)
 
     # Submitting the exact same schema for a different subject should return the same schema ID.
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     schema = {
         "type": "record",
         "name": "Object",
@@ -1189,7 +1187,7 @@ async def test_schema(registry_async_client, trail):
     assert "id" in res.json()
     original_schema_id = res.json()["id"]
     # New subject with the same schema
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     res = await registry_async_client.post("subjects/{}/versions".format(subject), json={"schema": jsonlib.dumps(schema)})
     assert res.status == 200
     assert "id" in res.json()
@@ -1197,7 +1195,7 @@ async def test_schema(registry_async_client, trail):
     assert original_schema_id == new_schema_id
 
     # It also works for multiple versions in a single subject
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     res = await registry_async_client.put(
         "config/{}".format(subject), json={"compatibility": "NONE"}
     )  # We don't care about the compatibility in this test
@@ -1214,7 +1212,7 @@ async def test_schema(registry_async_client, trail):
     assert res.json()["id"] == new_schema_id  # Same ID as in the previous test step
 
     # The subject version schema endpoint returns the correct results
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     schema_str = '{"type": "string"}'
     res = await registry_async_client.post(
         "subjects/{}/versions".format(subject),
@@ -1224,7 +1222,8 @@ async def test_schema(registry_async_client, trail):
     res = await registry_async_client.get(f"subjects/{subject}/versions/1/schema")
     assert res.status == 200
     assert res.json() == jsonlib.loads(schema_str)
-    res = await registry_async_client.get(f"subjects/{os.urandom(16).hex()}/versions/1/schema")  # Invalid subject
+    subject2 = new_random_name("subject")
+    res = await registry_async_client.get(f"subjects/{subject2}/versions/1/schema")  # Invalid subject
     assert res.status == 404
     assert res.json()["error_code"] == 40401
     assert res.json()["message"] == "Subject not found."
@@ -1237,7 +1236,7 @@ async def test_schema(registry_async_client, trail):
     assert res.json() == jsonlib.loads(schema_str)
 
     # The schema check for subject endpoint returns correct results
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     res = await registry_async_client.post(
         "subjects/{}/versions".format(subject),
         json={"schema": schema_str},
@@ -1259,8 +1258,9 @@ async def test_schema(registry_async_client, trail):
     assert res.status == 500
     assert res.json()["message"] == f"Error while looking up schema under subject {subject}"
     # Subject is not found
+    subject3 = new_random_name("subject")
     res = await registry_async_client.post(
-        f"subjects/{os.urandom(16).hex()}",
+        f"subjects/{subject3}",
         json={"schema": schema_str},
     )
     assert res.status == 404
@@ -1280,8 +1280,9 @@ async def test_schema(registry_async_client, trail):
     assert res.json()["error_code"] == 500
     assert res.json()["message"] == "Internal Server Error"
     # Schema not included in the request body for subject that does not exist
+    subject4 = new_random_name("subject")
     res = await registry_async_client.post(
-        f"subjects/{os.urandom(16).hex()}",
+        f"subjects/{subject4}",
         json={},
     )
     assert res.status == 404
@@ -1289,7 +1290,7 @@ async def test_schema(registry_async_client, trail):
     assert res.json()["message"] == "Subject not found."
 
     # Test that global ID values stay consistent after using pre-existing schema ids
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     res = await registry_async_client.put(
         "config/{}".format(subject), json={"compatibility": "NONE"}
     )  # We don't care about compatibility
@@ -1330,7 +1331,7 @@ async def test_schema(registry_async_client, trail):
     assert res.status == 200
     assert res.json()["id"] == first_schema_id + 1
     # Reuse the first schema in another subject
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     res = await registry_async_client.put(
         "config/{}".format(subject), json={"compatibility": "NONE"}
     )  # We don't care about compatibility
@@ -1368,7 +1369,7 @@ async def test_config(registry_async_client, trail):
     assert res.headers["Content-Type"] == "application/vnd.schemaregistry.v1+json"
 
     # Create a new subject so we can try setting its config
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     res = await registry_async_client.post(
         f"subjects/{subject}/versions{trail}",
         json={"schema": '{"type": "string"}'},
@@ -1391,7 +1392,7 @@ async def test_config(registry_async_client, trail):
     assert res.json()["compatibilityLevel"] == "FULL"
 
     # It's possible to add a config to a subject that doesn't exist yet
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     res = await registry_async_client.put(f"config/{subject}{trail}", json={"compatibility": "FULL"})
     assert res.status_code == 200
     assert res.json()["compatibility"] == "FULL"
@@ -1413,7 +1414,7 @@ async def test_config(registry_async_client, trail):
     assert res.json()["compatibilityLevel"] == "FULL"
 
     # Test that config is returned for a subject that does not have an existing schema
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     res = await registry_async_client.put(f"config/{subject}", json={"compatibility": "NONE"})
     assert res.status == 200
     assert res.json()["compatibility"] == "NONE"
@@ -1528,7 +1529,7 @@ async def test_http_headers(registry_async_client):
 
 
 async def test_schema_body_validation(registry_async_client):
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     post_endpoints = {f"subjects/{subject}", f"subjects/{subject}/versions"}
     for endpoint in post_endpoints:
         # Wrong field name
@@ -1555,7 +1556,7 @@ async def test_schema_body_validation(registry_async_client):
 
 async def test_version_number_validation(registry_async_client):
     # Create a schema
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     res = await registry_async_client.post(
         "subjects/{}/versions".format(subject),
         json={"schema": '{"type": "string"}'},
@@ -1597,14 +1598,14 @@ async def test_common_endpoints(registry_async_client):
 
 async def test_invalid_namespace(registry_async_client):
     schema = {"type": "record", "name": "foo", "namespace": "foo-bar-baz", "fields": []}
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     res = await registry_async_client.post(f"subjects/{subject}/versions", json={"schema": jsonlib.dumps(schema)})
     assert res.ok, res.json()
 
 
 async def test_schema_remains_constant(registry_async_client):
     schema = {"type": "record", "name": "foo", "namespace": "foo-bar-baz", "fields": [{"type": "string", "name": "bla"}]}
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     schema_str = jsonlib.dumps(schema)
     res = await registry_async_client.post(f"subjects/{subject}/versions", json={"schema": schema_str})
     assert res.ok, res.json()
@@ -1624,16 +1625,18 @@ async def test_malformed_kafka_message(registry_async, registry_async_client):
     message_value = {"deleted": False, "id": schema_id, "subject": "foo", "version": 1}
     message_value.update(payload)
     prod.send(topic, key=jsonlib.dumps(message_key).encode(), value=jsonlib.dumps(message_value).encode()).get()
-    found = False
-    for _ in range(30):
-        if schema_id in registry_async.ksr.schemas:
-            found = True
-            break
-        await asyncio.sleep(0.1)
-    assert found, f"{schema_id} not in {registry_async.ksr.schemas}"
-    res = await registry_async_client.get(f"schemas/ids/{schema_id}")
+
+    path = f"schemas/ids/{schema_id}"
+    res = await repeat_until_successful_request(
+        registry_async_client.get,
+        path,
+        json_data=None,
+        headers=None,
+        error_msg=f"Schema id {schema_id} not found",
+        timeout=20,
+        sleep=1,
+    )
     res_data = res.json()
-    assert res.ok, res_data
     assert res_data == payload, res_data
 
 
@@ -1673,7 +1676,7 @@ async def test_inner_type_compat_failure(registry_async_client):
             },
         }]
     }
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     res = await registry_async_client.post(f"subjects/{subject}/versions", json={"schema": jsonlib.dumps(sc)})
     assert res.ok
     sc_id = res.json()["id"]
@@ -1725,7 +1728,7 @@ async def test_anon_type_union_failure(registry_async_client):
         ]
     }
 
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     res = await registry_async_client.post(f"subjects/{subject}/versions", json={"schema": jsonlib.dumps(schema)})
     assert res.ok
     sc_id = res.json()["id"]
@@ -1779,7 +1782,7 @@ async def test_full_transitive_failure(registry_async_client, compatibility):
             "default": "null"
         }]
     }
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     await registry_async_client.put(f"config/{subject}", json={"compatibility": compatibility})
     res = await registry_async_client.post(f"subjects/{subject}/versions", json={"schema": jsonlib.dumps(init)})
     assert res.ok
@@ -1789,7 +1792,7 @@ async def test_full_transitive_failure(registry_async_client, compatibility):
 
 
 async def test_invalid_schemas(registry_async_client):
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
 
     repated_field = {
         "type": "record",
diff --git a/tests/integration/test_schema_backup.py b/tests/integration/test_schema_backup.py
index 5ee827e8d..338ea98fb 100644
--- a/tests/integration/test_schema_backup.py
+++ b/tests/integration/test_schema_backup.py
@@ -4,7 +4,11 @@
 Copyright (c) 2019 Aiven Ltd
 See LICENSE for details
 """
+from karapace.config import set_config_defaults
 from karapace.schema_backup import SchemaBackup
+from karapace.utils import Client
+from pathlib import Path
+from tests.utils import Expiration, KafkaServers, new_random_name
 
 import json as jsonlib
 import os
@@ -14,7 +18,7 @@
 
 
 async def insert_data(c):
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     res = await c.post(
         "subjects/{}/versions".format(subject),
         json={"schema": '{"type": "string"}'},
@@ -24,51 +28,62 @@ async def insert_data(c):
     return subject
 
 
-async def test_backup_get(registry_async, registry_async_client):
+async def test_backup_get(registry_async_client, kafka_servers: KafkaServers, tmp_path: Path):
     _ = await insert_data(registry_async_client)
 
     # Get the backup
-    backup_location = os.path.join(os.path.dirname(registry_async.config_path), "schemas.log")
-    sb = SchemaBackup(registry_async.config_path, backup_location)
+    backup_location = tmp_path / "schemas.log"
+    config = set_config_defaults({"bootstrap_uri": kafka_servers.bootstrap_servers})
+    sb = SchemaBackup(config, str(backup_location))
     sb.request_backup()
 
     # The backup file has been created
     assert os.path.exists(backup_location)
 
 
-async def test_backup_restore(registry_async, registry_async_client):
+async def test_backup_restore(
+    registry_async_client: Client,
+    kafka_servers: KafkaServers,
+    tmp_path: Path,
+) -> None:
+    subject = new_random_name("subject")
+    restore_location = tmp_path / "restore.log"
+
+    with restore_location.open("w") as fp:
+        jsonlib.dump(
+            [[
+                {
+                    "subject": subject,
+                    "version": 1,
+                    "magic": 1,
+                    "keytype": "SCHEMA",
+                },
+                {
+                    "deleted": False,
+                    "id": 1,
+                    "schema": "\"string\"",
+                    "subject": subject,
+                    "version": 1,
+                },
+            ]],
+            fp=fp,
+        )
 
-    subject = os.urandom(16).hex()
-    restore_location = os.path.join(os.path.dirname(registry_async.config_path), "restore.log")
-    with open(restore_location, "w") as fp:
-        jsonlib.dump([[
-            {
-                "subject": subject,
-                "version": 1,
-                "magic": 1,
-                "keytype": "SCHEMA",
-            },
-            {
-                "deleted": False,
-                "id": 1,
-                "schema": "\"string\"",
-                "subject": subject,
-                "version": 1,
-            },
-        ]],
-                     fp=fp)
-    sb = SchemaBackup(registry_async.config_path, restore_location)
+    config = set_config_defaults({"bootstrap_uri": kafka_servers.bootstrap_servers})
+    sb = SchemaBackup(config, str(restore_location))
     sb.restore_backup()
 
     # The restored karapace should have the previously created subject
-    time.sleep(1.0)
-    res = await registry_async_client.get("subjects")
-    assert res.status_code == 200
-    data = res.json()
-    assert subject in data
+    all_subjects = []
+    expiration = Expiration.from_timeout(timeout=10)
+    while subject not in all_subjects:
+        expiration.raise_if_expired(msg=f"{subject} not in {all_subjects}")
+        res = await registry_async_client.get("subjects")
+        assert res.status_code == 200
+        all_subjects = res.json()
 
     # Test a few exotic scenarios
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     res = await registry_async_client.put(f"config/{subject}", json={"compatibility": "NONE"})
     assert res.status == 200
     assert res.json()["compatibility"] == "NONE"
@@ -97,7 +112,7 @@ async def test_backup_restore(registry_async, registry_async_client):
     assert res.status == 404
 
     # Restore a complete schema delete message
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     res = await registry_async_client.put(f"config/{subject}", json={"compatibility": "NONE"})
     res = await registry_async_client.post(f"subjects/{subject}/versions", json={"schema": '{"type": "int"}'})
     res = await registry_async_client.post(f"subjects/{subject}/versions", json={"schema": '{"type": "float"}'})
@@ -127,7 +142,7 @@ async def test_backup_restore(registry_async, registry_async_client):
     assert res.json() == [1]
 
     # Schema delete for a nonexistent subject version is ignored
-    subject = os.urandom(16).hex()
+    subject = new_random_name("subject")
     res = await registry_async_client.post(f"subjects/{subject}/versions", json={"schema": '{"type": "string"}'})
     with open(restore_location, "w") as fp:
         fp.write(
diff --git a/tests/schemas/__init__.py b/tests/schemas/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/schemas/json_schemas.py b/tests/schemas/json_schemas.py
new file mode 100644
index 000000000..59565276e
--- /dev/null
+++ b/tests/schemas/json_schemas.py
@@ -0,0 +1,204 @@
+from karapace.schema_reader import parse_jsonschema_definition
+
+# boolean schemas
+NOT_OF_EMPTY_SCHEMA = parse_jsonschema_definition('{"not":{}}')
+NOT_OF_TRUE_SCHEMA = parse_jsonschema_definition('{"not":true}')
+FALSE_SCHEMA = parse_jsonschema_definition('false')
+TRUE_SCHEMA = parse_jsonschema_definition('true')
+EMPTY_SCHEMA = parse_jsonschema_definition('{}')
+
+# simple instance schemas
+BOOLEAN_SCHEMA = parse_jsonschema_definition('{"type":"boolean"}')
+INT_SCHEMA = parse_jsonschema_definition('{"type":"integer"}')
+NUMBER_SCHEMA = parse_jsonschema_definition('{"type":"number"}')
+STRING_SCHEMA = parse_jsonschema_definition('{"type":"string"}')
+OBJECT_SCHEMA = parse_jsonschema_definition('{"type":"object"}')
+ARRAY_SCHEMA = parse_jsonschema_definition('{"type":"array"}')
+
+# negation of simple schemas
+NOT_BOOLEAN_SCHEMA = parse_jsonschema_definition('{"not":{"type":"boolean"}}')
+NOT_INT_SCHEMA = parse_jsonschema_definition('{"not":{"type":"integer"}}')
+NOT_NUMBER_SCHEMA = parse_jsonschema_definition('{"not":{"type":"number"}}')
+NOT_STRING_SCHEMA = parse_jsonschema_definition('{"not":{"type":"string"}}')
+NOT_OBJECT_SCHEMA = parse_jsonschema_definition('{"not":{"type":"object"}}')
+NOT_ARRAY_SCHEMA = parse_jsonschema_definition('{"not":{"type":"array"}}')
+
+# structural validation
+MAX_LENGTH_SCHEMA = parse_jsonschema_definition('{"type":"string","maxLength":3}')
+MAX_LENGTH_DECREASED_SCHEMA = parse_jsonschema_definition('{"type":"string","maxLength":2}')
+MIN_LENGTH_SCHEMA = parse_jsonschema_definition('{"type":"string","minLength":5}')
+MIN_LENGTH_INCREASED_SCHEMA = parse_jsonschema_definition('{"type":"string","minLength":7}')
+MIN_PATTERN_SCHEMA = parse_jsonschema_definition('{"type":"string","pattern":"a*"}')
+MIN_PATTERN_STRICT_SCHEMA = parse_jsonschema_definition('{"type":"string","pattern":"a+"}')
+MAXIMUM_INTEGER_SCHEMA = parse_jsonschema_definition('{"type":"integer","maximum":13}')
+MAXIMUM_NUMBER_SCHEMA = parse_jsonschema_definition('{"type":"number","maximum":13}')
+MAXIMUM_DECREASED_INTEGER_SCHEMA = parse_jsonschema_definition('{"type":"integer","maximum":11}')
+MAXIMUM_DECREASED_NUMBER_SCHEMA = parse_jsonschema_definition('{"type":"number","maximum":11}')
+MINIMUM_INTEGER_SCHEMA = parse_jsonschema_definition('{"type":"integer","minimum":17}')
+MINIMUM_NUMBER_SCHEMA = parse_jsonschema_definition('{"type":"number","minimum":17}')
+MINIMUM_INCREASED_INTEGER_SCHEMA = parse_jsonschema_definition('{"type":"integer","minimum":19}')
+MINIMUM_INCREASED_NUMBER_SCHEMA = parse_jsonschema_definition('{"type":"number","minimum":19}')
+EXCLUSIVE_MAXIMUM_INTEGER_SCHEMA = parse_jsonschema_definition('{"type":"integer","exclusiveMaximum":29}')
+EXCLUSIVE_MAXIMUM_NUMBER_SCHEMA = parse_jsonschema_definition('{"type":"number","exclusiveMaximum":29}')
+EXCLUSIVE_MAXIMUM_DECREASED_INTEGER_SCHEMA = parse_jsonschema_definition('{"type":"integer","exclusiveMaximum":23}')
+EXCLUSIVE_MAXIMUM_DECREASED_NUMBER_SCHEMA = parse_jsonschema_definition('{"type":"number","exclusiveMaximum":23}')
+EXCLUSIVE_MINIMUM_INTEGER_SCHEMA = parse_jsonschema_definition('{"type":"integer","exclusiveMinimum":31}')
+EXCLUSIVE_MINIMUM_NUMBER_SCHEMA = parse_jsonschema_definition('{"type":"number","exclusiveMinimum":31}')
+EXCLUSIVE_MINIMUM_INCREASED_INTEGER_SCHEMA = parse_jsonschema_definition('{"type":"integer","exclusiveMinimum":37}')
+EXCLUSIVE_MINIMUM_INCREASED_NUMBER_SCHEMA = parse_jsonschema_definition('{"type":"number","exclusiveMinimum":37}')
+MAX_PROPERTIES_SCHEMA = parse_jsonschema_definition('{"type":"object","maxProperties":43}')
+MAX_PROPERTIES_DECREASED_SCHEMA = parse_jsonschema_definition('{"type":"object","maxProperties":41}')
+MIN_PROPERTIES_SCHEMA = parse_jsonschema_definition('{"type":"object","minProperties":47}')
+MIN_PROPERTIES_INCREASED_SCHEMA = parse_jsonschema_definition('{"type":"object","minProperties":53}')
+MAX_ITEMS_SCHEMA = parse_jsonschema_definition('{"type":"array","maxItems":61}')
+MAX_ITEMS_DECREASED_SCHEMA = parse_jsonschema_definition('{"type":"array","maxItems":59}')
+MIN_ITEMS_SCHEMA = parse_jsonschema_definition('{"type":"array","minItems":67}')
+MIN_ITEMS_INCREASED_SCHEMA = parse_jsonschema_definition('{"type":"array","minItems":71}')
+
+TUPLE_OF_INT_INT_SCHEMA = parse_jsonschema_definition(
+    '{"type":"array","items":[{"type":"integer"},{"type":"integer"}],"additionalItems":false}'
+)
+TUPLE_OF_INT_SCHEMA = parse_jsonschema_definition('{"type":"array","items":[{"type":"integer"}],"additionalItems":false}')
+TUPLE_OF_INT_WITH_ADDITIONAL_INT_SCHEMA = parse_jsonschema_definition(
+    '{"type":"array","items":[{"type":"integer"}],"additionalItems":{"type":"integer"}}'
+)
+TUPLE_OF_INT_INT_OPEN_SCHEMA = parse_jsonschema_definition(
+    '{"type":"array","items":[{"type":"integer"},{"type":"integer"}]}'
+)
+TUPLE_OF_INT_OPEN_SCHEMA = parse_jsonschema_definition('{"type":"array","items":[{"type":"integer"}]}')
+ARRAY_OF_INT_SCHEMA = parse_jsonschema_definition('{"type":"array","items":{"type":"integer"}}')
+ARRAY_OF_NUMBER_SCHEMA = parse_jsonschema_definition('{"type":"array","items":{"type":"number"}}')
+ARRAY_OF_STRING_SCHEMA = parse_jsonschema_definition('{"type":"array","items":{"type":"string"}}')
+ENUM_AB_SCHEMA = parse_jsonschema_definition('{"enum":["A","B"]}')
+ENUM_ABC_SCHEMA = parse_jsonschema_definition('{"enum":["A","B","C"]}')
+ENUM_BC_SCHEMA = parse_jsonschema_definition('{"enum":["B","C"]}')
+ONEOF_STRING_SCHEMA = parse_jsonschema_definition('{"oneOf":[{"type":"string"}]}')
+ONEOF_STRING_INT_SCHEMA = parse_jsonschema_definition('{"oneOf":[{"type":"string"},{"type":"integer"}]}')
+ONEOF_INT_SCHEMA = parse_jsonschema_definition('{"oneOf":[{"type":"integer"}]}')
+ONEOF_NUMBER_SCHEMA = parse_jsonschema_definition('{"oneOf":[{"type":"number"}]}')
+TYPES_STRING_INT_SCHEMA = parse_jsonschema_definition('{"type":["string","integer"]}')
+TYPES_STRING_SCHEMA = parse_jsonschema_definition('{"type":["string"]}')
+EMPTY_OBJECT_SCHEMA = parse_jsonschema_definition('{"type":"object","additionalProperties":false}')
+A_OBJECT_SCHEMA = parse_jsonschema_definition('{"type":"object","properties":{"a":{}}}')
+A_INT_OBJECT_SCHEMA = parse_jsonschema_definition(
+    '{"type":"object","additionalProperties":false,"properties":{"a":{"type":"integer"}}}'
+)
+A_DINT_OBJECT_SCHEMA = parse_jsonschema_definition(
+    '{"type":"object","additionalProperties":false,"properties":{"a":{"type":"integer","default":0}}}'
+)
+B_INT_OBJECT_SCHEMA = parse_jsonschema_definition(
+    '{"type":"object","additionalProperties":false,"properties":{"b":{"type":"integer"}}}'
+)
+A_INT_OPEN_OBJECT_SCHEMA = parse_jsonschema_definition('{"type":"object","properties":{"a":{"type":"integer"}}}')
+B_INT_OPEN_OBJECT_SCHEMA = parse_jsonschema_definition('{"type":"object","properties":{"b":{"type":"integer"}}}')
+B_DINT_OPEN_OBJECT_SCHEMA = parse_jsonschema_definition(
+    '{"type":"object","properties":{"b":{"type":"integer","default":0}}}'
+)
+A_INT_B_INT_OBJECT_SCHEMA = parse_jsonschema_definition(
+    '{"type":"object","additionalProperties":false,"properties":{"a":{"type":"integer"},"b":{"type":"integer"}}}'
+)
+A_DINT_B_INT_OBJECT_SCHEMA = parse_jsonschema_definition(
+    '{"type":"object","additionalProperties":false,"properties":{"a":{"type":"integer","default":0},"b":{"type":"integer"}}}'
+)
+A_INT_B_INT_REQUIRED_OBJECT_SCHEMA = parse_jsonschema_definition(
+    '{"type":"object","additionalProperties":false,"required":["b"],'
+    '"properties":{"a":{"type":"integer"},"b":{"type":"integer"}}}'
+)
+A_INT_B_DINT_OBJECT_SCHEMA = parse_jsonschema_definition(
+    '{"type":"object","additionalProperties":false,"properties":{"a":{"type":"integer"},"b":{"type":"integer","default":0}}}'
+)
+A_INT_B_DINT_REQUIRED_OBJECT_SCHEMA = parse_jsonschema_definition(
+    '{"type":"object","additionalProperties":false,"required":["b"],'
+    '"properties":{"a":{"type":"integer"},"b":{"type":"integer","default":0}}}'
+)
+A_DINT_B_DINT_OBJECT_SCHEMA = parse_jsonschema_definition(
+    '{"type":"object","additionalProperties":false,'
+    '"properties":{"a":{"type":"integer","default":0},"b":{"type":"integer","default":0}}}'
+)
+A_DINT_B_NUM_OBJECT_SCHEMA = parse_jsonschema_definition(
+    '{"type":"object","additionalProperties":false,"properties":{"a":{"type":"integer","default":1},"b":{"type":"number"}}}'
+)
+A_DINT_B_NUM_C_DINT_OBJECT_SCHEMA = parse_jsonschema_definition(
+    '{"type":"object","additionalProperties":false,'
+    '"properties":{"a":{"type":"integer","default":1},"b":{"type":"number"},"c":{"type":"integer","default":0}}}'
+)
+B_NUM_C_DINT_OPEN_OBJECT_SCHEMA = parse_jsonschema_definition(
+    '{"type":"object","properties":{"b":{"type":"number"},"c":{"type":"integer","default":0}}}'
+)
+B_NUM_C_INT_OPEN_OBJECT_SCHEMA = parse_jsonschema_definition(
+    '{"type":"object","properties":{"b":{"type":"number"},"c":{"type":"integer"}}}'
+)
+B_NUM_C_INT_OBJECT_SCHEMA = parse_jsonschema_definition(
+    '{"type":"object","additionalProperties":false,"properties":{"b":{"type":"number"},"c":{"type":"integer"}}}'
+)
+PROPERTY_ASTAR_OBJECT_SCHEMA = parse_jsonschema_definition('{"type":"object","propertyNames":{"pattern":"a*"}}')
+ARRAY_OF_POSITIVE_INTEGER = parse_jsonschema_definition(
+    '''
+    {
+        "type": "array",
+        "items": {"type": "integer", "exclusiveMinimum": 0}
+    }
+    '''
+)
+ARRAY_OF_POSITIVE_INTEGER_THROUGH_REF = parse_jsonschema_definition(
+    '''
+    {
+        "type": "array",
+        "items": {"$ref": "#/$defs/positiveInteger"},
+        "$defs": {
+            "positiveInteger": {
+                "type": "integer",
+                "exclusiveMinimum": 0
+            }
+        }
+    }
+    '''
+)
+
+ONEOF_ARRAY_A_DINT_B_NUM_SCHEMA = parse_jsonschema_definition(
+    '{"oneOf":[{"type":"array","items":{"type":"object",'
+    '"additionalProperties":false,"properties":{"a":{"type":"integer","default":1},"b":{"type":"number"}}}}]}'
+)
+ONEOF_ARRAY_B_NUM_C_INT_SCHEMA = parse_jsonschema_definition(
+    '{"oneOf":[{"type":"array","items":{"type":"object",'
+    '"additionalProperties":false,"properties":{"b":{"type":"number"},"c":{"type":"integer"}}}}]}'
+)
+ONEOF_ARRAY_B_NUM_C_DINT_OPEN_SCHEMA = parse_jsonschema_definition(
+    '{"oneOf":[{"type":"array","items":{"type":"object",'
+    '"properties":{"b":{"type":"number"},"c":{"type":"integer","default":0}}}}]}'
+)
+EVERY_TYPE_SCHEMA = parse_jsonschema_definition(
+    '{"type":"object","required":["boolF","intF","numberF","stringF","enumF","arrayF","recordF"],'
+    '"properties":{"recordF":{"type":"object","properties":{"f":{"type":"number"}}},"stringF":{"type":"string"},'
+    '"boolF":{"type":"boolean"},"intF":{"type":"integer"},"enumF":{"enum":["S"]},'
+    '"arrayF":{"type":"array","items":{"type":"string"}},"numberF":{"type":"number"},"bool0":{"type":"boolean"}}}'
+)
+
+OBJECT_SCHEMAS = (
+    A_DINT_B_DINT_OBJECT_SCHEMA, A_DINT_B_INT_OBJECT_SCHEMA, A_DINT_B_NUM_C_DINT_OBJECT_SCHEMA, A_DINT_B_NUM_OBJECT_SCHEMA,
+    A_DINT_OBJECT_SCHEMA, A_INT_B_DINT_OBJECT_SCHEMA, A_INT_B_DINT_REQUIRED_OBJECT_SCHEMA, A_INT_B_INT_OBJECT_SCHEMA,
+    A_INT_B_INT_REQUIRED_OBJECT_SCHEMA, A_INT_OBJECT_SCHEMA, A_INT_OPEN_OBJECT_SCHEMA, A_OBJECT_SCHEMA,
+    B_DINT_OPEN_OBJECT_SCHEMA, B_INT_OBJECT_SCHEMA, B_INT_OPEN_OBJECT_SCHEMA, B_NUM_C_DINT_OPEN_OBJECT_SCHEMA,
+    B_NUM_C_INT_OBJECT_SCHEMA, B_NUM_C_INT_OPEN_OBJECT_SCHEMA, EMPTY_OBJECT_SCHEMA, EMPTY_SCHEMA, EVERY_TYPE_SCHEMA,
+    MAX_PROPERTIES_SCHEMA, MAX_PROPERTIES_DECREASED_SCHEMA, MIN_PROPERTIES_SCHEMA, MIN_PROPERTIES_INCREASED_SCHEMA,
+    OBJECT_SCHEMA, PROPERTY_ASTAR_OBJECT_SCHEMA
+)
+BOOLEAN_SCHEMAS = (TRUE_SCHEMA, FALSE_SCHEMA)
+NON_OBJECT_SCHEMAS = (
+    BOOLEAN_SCHEMA, ARRAY_OF_INT_SCHEMA, ARRAY_OF_NUMBER_SCHEMA, ARRAY_OF_POSITIVE_INTEGER,
+    ARRAY_OF_POSITIVE_INTEGER_THROUGH_REF, ARRAY_OF_STRING_SCHEMA, ARRAY_SCHEMA, ENUM_AB_SCHEMA, ENUM_ABC_SCHEMA,
+    ENUM_BC_SCHEMA, EXCLUSIVE_MAXIMUM_DECREASED_INTEGER_SCHEMA, EXCLUSIVE_MAXIMUM_DECREASED_NUMBER_SCHEMA,
+    EXCLUSIVE_MAXIMUM_INTEGER_SCHEMA, EXCLUSIVE_MAXIMUM_NUMBER_SCHEMA, EXCLUSIVE_MINIMUM_INCREASED_INTEGER_SCHEMA,
+    EXCLUSIVE_MINIMUM_INCREASED_NUMBER_SCHEMA, EXCLUSIVE_MINIMUM_INTEGER_SCHEMA, EXCLUSIVE_MINIMUM_NUMBER_SCHEMA, INT_SCHEMA,
+    MAX_ITEMS_DECREASED_SCHEMA, MAX_ITEMS_SCHEMA, MAX_LENGTH_DECREASED_SCHEMA, MAX_LENGTH_SCHEMA,
+    MAXIMUM_DECREASED_INTEGER_SCHEMA, MAXIMUM_DECREASED_NUMBER_SCHEMA, MAXIMUM_INTEGER_SCHEMA, MAXIMUM_NUMBER_SCHEMA,
+    MIN_ITEMS_INCREASED_SCHEMA, MIN_ITEMS_SCHEMA, MIN_LENGTH_INCREASED_SCHEMA, MIN_LENGTH_SCHEMA, MIN_PATTERN_SCHEMA,
+    MIN_PATTERN_STRICT_SCHEMA, MINIMUM_INCREASED_INTEGER_SCHEMA, MINIMUM_INCREASED_NUMBER_SCHEMA, MINIMUM_INTEGER_SCHEMA,
+    MINIMUM_NUMBER_SCHEMA, NOT_ARRAY_SCHEMA, NOT_BOOLEAN_SCHEMA, NOT_INT_SCHEMA, NOT_NUMBER_SCHEMA, NOT_OBJECT_SCHEMA,
+    NOT_OF_EMPTY_SCHEMA, NOT_OF_TRUE_SCHEMA, NOT_STRING_SCHEMA, NUMBER_SCHEMA, ONEOF_ARRAY_A_DINT_B_NUM_SCHEMA,
+    ONEOF_ARRAY_B_NUM_C_DINT_OPEN_SCHEMA, ONEOF_ARRAY_B_NUM_C_INT_SCHEMA, ONEOF_INT_SCHEMA, ONEOF_NUMBER_SCHEMA,
+    ONEOF_STRING_INT_SCHEMA, ONEOF_STRING_SCHEMA, STRING_SCHEMA, TUPLE_OF_INT_INT_OPEN_SCHEMA, TUPLE_OF_INT_INT_SCHEMA,
+    TUPLE_OF_INT_OPEN_SCHEMA, TUPLE_OF_INT_SCHEMA, TUPLE_OF_INT_WITH_ADDITIONAL_INT_SCHEMA, TYPES_STRING_INT_SCHEMA,
+    TYPES_STRING_SCHEMA
+)
+ALL_SCHEMAS = OBJECT_SCHEMAS + BOOLEAN_SCHEMAS + NON_OBJECT_SCHEMAS
diff --git a/tests/unit/test_json_schema.py b/tests/unit/test_json_schema.py
index db3f1561e..d6c30a1b0 100644
--- a/tests/unit/test_json_schema.py
+++ b/tests/unit/test_json_schema.py
@@ -1,891 +1,1326 @@
+from jsonschema import Draft7Validator
 from karapace.avro_compatibility import SchemaCompatibilityResult
 from karapace.compatibility.jsonschema.checks import compatibility
-from karapace.schema_reader import parse_jsonschema_definition
+from tests.schemas.json_schemas import (
+    A_DINT_B_DINT_OBJECT_SCHEMA, A_DINT_B_INT_OBJECT_SCHEMA, A_DINT_B_NUM_C_DINT_OBJECT_SCHEMA, A_DINT_B_NUM_OBJECT_SCHEMA,
+    A_DINT_OBJECT_SCHEMA, A_INT_B_DINT_OBJECT_SCHEMA, A_INT_B_DINT_REQUIRED_OBJECT_SCHEMA, A_INT_B_INT_OBJECT_SCHEMA,
+    A_INT_B_INT_REQUIRED_OBJECT_SCHEMA, A_INT_OBJECT_SCHEMA, A_INT_OPEN_OBJECT_SCHEMA, A_OBJECT_SCHEMA, ARRAY_OF_INT_SCHEMA,
+    ARRAY_OF_NUMBER_SCHEMA, ARRAY_OF_POSITIVE_INTEGER, ARRAY_OF_POSITIVE_INTEGER_THROUGH_REF, ARRAY_OF_STRING_SCHEMA,
+    ARRAY_SCHEMA, B_DINT_OPEN_OBJECT_SCHEMA, B_INT_OBJECT_SCHEMA, B_INT_OPEN_OBJECT_SCHEMA, B_NUM_C_DINT_OPEN_OBJECT_SCHEMA,
+    B_NUM_C_INT_OBJECT_SCHEMA, B_NUM_C_INT_OPEN_OBJECT_SCHEMA, BOOLEAN_SCHEMA, BOOLEAN_SCHEMAS, EMPTY_OBJECT_SCHEMA,
+    EMPTY_SCHEMA, ENUM_AB_SCHEMA, ENUM_ABC_SCHEMA, ENUM_BC_SCHEMA, EVERY_TYPE_SCHEMA,
+    EXCLUSIVE_MAXIMUM_DECREASED_INTEGER_SCHEMA, EXCLUSIVE_MAXIMUM_DECREASED_NUMBER_SCHEMA, EXCLUSIVE_MAXIMUM_INTEGER_SCHEMA,
+    EXCLUSIVE_MAXIMUM_NUMBER_SCHEMA, EXCLUSIVE_MINIMUM_INCREASED_INTEGER_SCHEMA, EXCLUSIVE_MINIMUM_INCREASED_NUMBER_SCHEMA,
+    EXCLUSIVE_MINIMUM_INTEGER_SCHEMA, EXCLUSIVE_MINIMUM_NUMBER_SCHEMA, FALSE_SCHEMA, INT_SCHEMA, MAX_ITEMS_DECREASED_SCHEMA,
+    MAX_ITEMS_SCHEMA, MAX_LENGTH_DECREASED_SCHEMA, MAX_LENGTH_SCHEMA, MAX_PROPERTIES_DECREASED_SCHEMA, MAX_PROPERTIES_SCHEMA,
+    MAXIMUM_DECREASED_INTEGER_SCHEMA, MAXIMUM_DECREASED_NUMBER_SCHEMA, MAXIMUM_INTEGER_SCHEMA, MAXIMUM_NUMBER_SCHEMA,
+    MIN_ITEMS_INCREASED_SCHEMA, MIN_ITEMS_SCHEMA, MIN_LENGTH_INCREASED_SCHEMA, MIN_LENGTH_SCHEMA, MIN_PATTERN_SCHEMA,
+    MIN_PATTERN_STRICT_SCHEMA, MIN_PROPERTIES_INCREASED_SCHEMA, MIN_PROPERTIES_SCHEMA, MINIMUM_INCREASED_INTEGER_SCHEMA,
+    MINIMUM_INCREASED_NUMBER_SCHEMA, MINIMUM_INTEGER_SCHEMA, MINIMUM_NUMBER_SCHEMA, NON_OBJECT_SCHEMAS, NOT_ARRAY_SCHEMA,
+    NOT_BOOLEAN_SCHEMA, NOT_INT_SCHEMA, NOT_NUMBER_SCHEMA, NOT_OBJECT_SCHEMA, NOT_OF_EMPTY_SCHEMA, NOT_OF_TRUE_SCHEMA,
+    NOT_STRING_SCHEMA, NUMBER_SCHEMA, OBJECT_SCHEMA, OBJECT_SCHEMAS, ONEOF_ARRAY_A_DINT_B_NUM_SCHEMA,
+    ONEOF_ARRAY_B_NUM_C_DINT_OPEN_SCHEMA, ONEOF_ARRAY_B_NUM_C_INT_SCHEMA, ONEOF_INT_SCHEMA, ONEOF_NUMBER_SCHEMA,
+    ONEOF_STRING_INT_SCHEMA, ONEOF_STRING_SCHEMA, PROPERTY_ASTAR_OBJECT_SCHEMA, STRING_SCHEMA, TRUE_SCHEMA,
+    TUPLE_OF_INT_INT_OPEN_SCHEMA, TUPLE_OF_INT_INT_SCHEMA, TUPLE_OF_INT_OPEN_SCHEMA, TUPLE_OF_INT_SCHEMA,
+    TUPLE_OF_INT_WITH_ADDITIONAL_INT_SCHEMA, TYPES_STRING_INT_SCHEMA, TYPES_STRING_SCHEMA
+)
+
+import pytest
 
 COMPATIBLE = SchemaCompatibilityResult.compatible()
 
-# boolean schemas
-NOT_OF_EMPTY_SCHEMA = parse_jsonschema_definition('{"not":{}}')
-NOT_OF_TRUE_SCHEMA = parse_jsonschema_definition('{"not":true}')
-FALSE_SCHEMA = parse_jsonschema_definition('false')
-TRUE_SCHEMA = parse_jsonschema_definition('true')
-EMPTY_SCHEMA = parse_jsonschema_definition('{}')
-
-# simple instance schemas
-BOOLEAN_SCHEMA = parse_jsonschema_definition('{"type":"boolean"}')
-INT_SCHEMA = parse_jsonschema_definition('{"type":"integer"}')
-NUMBER_SCHEMA = parse_jsonschema_definition('{"type":"number"}')
-STRING_SCHEMA = parse_jsonschema_definition('{"type":"string"}')
-OBJECT_SCHEMA = parse_jsonschema_definition('{"type":"object"}')
-ARRAY_SCHEMA = parse_jsonschema_definition('{"type":"array"}')
-
-# negation of simple schemas
-NOT_BOOLEAN_SCHEMA = parse_jsonschema_definition('{"not":{"type":"boolean"}}')
-NOT_INT_SCHEMA = parse_jsonschema_definition('{"not":{"type":"integer"}}')
-NOT_NUMBER_SCHEMA = parse_jsonschema_definition('{"not":{"type":"number"}}')
-NOT_STRING_SCHEMA = parse_jsonschema_definition('{"not":{"type":"string"}}')
-NOT_OBJECT_SCHEMA = parse_jsonschema_definition('{"not":{"type":"object"}}')
-NOT_ARRAY_SCHEMA = parse_jsonschema_definition('{"not":{"type":"array"}}')
-
-# structural validation
-MAX_LENGTH_SCHEMA = parse_jsonschema_definition('{"type":"string","maxLength":3}')
-MAX_LENGTH_DECREASED_SCHEMA = parse_jsonschema_definition('{"type":"string","maxLength":2}')
-MIN_LENGTH_SCHEMA = parse_jsonschema_definition('{"type":"string","minLength":5}')
-MIN_LENGTH_INCREASED_SCHEMA = parse_jsonschema_definition('{"type":"string","minLength":7}')
-MIN_PATTERN_SCHEMA = parse_jsonschema_definition('{"type":"string","pattern":"a*"}')
-MIN_PATTERN_STRICT_SCHEMA = parse_jsonschema_definition('{"type":"string","pattern":"a+"}')
-MAXIMUM_INTEGER_SCHEMA = parse_jsonschema_definition('{"type":"integer","maximum":13}')
-MAXIMUM_NUMBER_SCHEMA = parse_jsonschema_definition('{"type":"number","maximum":13}')
-MAXIMUM_DECREASED_INTEGER_SCHEMA = parse_jsonschema_definition('{"type":"integer","maximum":11}')
-MAXIMUM_DECREASED_NUMBER_SCHEMA = parse_jsonschema_definition('{"type":"number","maximum":11}')
-MINIMUM_INTEGER_SCHEMA = parse_jsonschema_definition('{"type":"integer","minimum":17}')
-MINIMUM_NUMBER_SCHEMA = parse_jsonschema_definition('{"type":"number","minimum":17}')
-MINIMUM_INCREASED_INTEGER_SCHEMA = parse_jsonschema_definition('{"type":"integer","minimum":19}')
-MINIMUM_INCREASED_NUMBER_SCHEMA = parse_jsonschema_definition('{"type":"number","minimum":19}')
-EXCLUSIVE_MAXIMUM_INTEGER_SCHEMA = parse_jsonschema_definition('{"type":"integer","exclusiveMaximum":29}')
-EXCLUSIVE_MAXIMUM_NUMBER_SCHEMA = parse_jsonschema_definition('{"type":"number","exclusiveMaximum":29}')
-EXCLUSIVE_MAXIMUM_DECREASED_INTEGER_SCHEMA = parse_jsonschema_definition('{"type":"integer","exclusiveMaximum":23}')
-EXCLUSIVE_MAXIMUM_DECREASED_NUMBER_SCHEMA = parse_jsonschema_definition('{"type":"number","exclusiveMaximum":23}')
-EXCLUSIVE_MINIMUM_INTEGER_SCHEMA = parse_jsonschema_definition('{"type":"integer","exclusiveMinimum":31}')
-EXCLUSIVE_MINIMUM_NUMBER_SCHEMA = parse_jsonschema_definition('{"type":"number","exclusiveMinimum":31}')
-EXCLUSIVE_MINIMUM_INCREASED_INTEGER_SCHEMA = parse_jsonschema_definition('{"type":"integer","exclusiveMinimum":37}')
-EXCLUSIVE_MINIMUM_INCREASED_NUMBER_SCHEMA = parse_jsonschema_definition('{"type":"number","exclusiveMinimum":37}')
-MAX_PROPERTIES_SCHEMA = parse_jsonschema_definition('{"type":"object","maxProperties":43}')
-MAX_PROPERTIES_DECREASED_SCHEMA = parse_jsonschema_definition('{"type":"object","maxProperties":41}')
-MIN_PROPERTIES_SCHEMA = parse_jsonschema_definition('{"type":"object","minProperties":47}')
-MIN_PROPERTIES_INCREASED_SCHEMA = parse_jsonschema_definition('{"type":"object","minProperties":53}')
-MAX_ITEMS_SCHEMA = parse_jsonschema_definition('{"type":"array","maxItems":61}')
-MAX_ITEMS_DECREASED_SCHEMA = parse_jsonschema_definition('{"type":"array","maxItems":59}')
-MIN_ITEMS_SCHEMA = parse_jsonschema_definition('{"type":"array","minItems":67}')
-MIN_ITEMS_INCREASED_SCHEMA = parse_jsonschema_definition('{"type":"array","minItems":71}')
-
-TUPLE_OF_INT_INT_SCHEMA = parse_jsonschema_definition(
-    '{"type":"array","items":[{"type":"integer"},{"type":"integer"}],"additionalItems":false}'
-)
-TUPLE_OF_INT_SCHEMA = parse_jsonschema_definition('{"type":"array","items":[{"type":"integer"}],"additionalItems":false}')
-TUPLE_OF_INT_WITH_ADDITIONAL_INT_SCHEMA = parse_jsonschema_definition(
-    '{"type":"array","items":[{"type":"integer"}],"additionalItems":{"type":"integer"}}'
-)
-TUPLE_OF_INT_INT_OPEN_SCHEMA = parse_jsonschema_definition(
-    '{"type":"array","items":[{"type":"integer"},{"type":"integer"}]}'
-)
-TUPLE_OF_INT_OPEN_SCHEMA = parse_jsonschema_definition('{"type":"array","items":[{"type":"integer"}]}')
-ARRAY_OF_INT_SCHEMA = parse_jsonschema_definition('{"type":"array","items":{"type":"integer"}}')
-ARRAY_OF_NUMBER_SCHEMA = parse_jsonschema_definition('{"type":"array","items":{"type":"number"}}')
-ARRAY_OF_STRING_SCHEMA = parse_jsonschema_definition('{"type":"array","items":{"type":"string"}}')
-ENUM_AB_SCHEMA = parse_jsonschema_definition('{"enum":["A","B"]}')
-ENUM_ABC_SCHEMA = parse_jsonschema_definition('{"enum":["A","B","C"]}')
-ENUM_BC_SCHEMA = parse_jsonschema_definition('{"enum":["B","C"]}')
-ONEOF_STRING_SCHEMA = parse_jsonschema_definition('{"oneOf":[{"type":"string"}]}')
-ONEOF_STRING_INT_SCHEMA = parse_jsonschema_definition('{"oneOf":[{"type":"string"},{"type":"integer"}]}')
-ONEOF_INT_SCHEMA = parse_jsonschema_definition('{"oneOf":[{"type":"integer"}]}')
-ONEOF_NUMBER_SCHEMA = parse_jsonschema_definition('{"oneOf":[{"type":"number"}]}')
-TYPES_STRING_INT_SCHEMA = parse_jsonschema_definition('{"type":["string","integer"]}')
-TYPES_STRING_SCHEMA = parse_jsonschema_definition('{"type":["string"]}')
-EMPTY_OBJECT_SCHEMA = parse_jsonschema_definition('{"type":"object","additionalProperties":false}')
-A_OBJECT_SCHEMA = parse_jsonschema_definition('{"type":"object","properties":{"a":{}}}')
-B_OBJECT_SCHEMA = parse_jsonschema_definition('{"type":"object","properties":{"b":{}}}')
-A_INT_OBJECT_SCHEMA = parse_jsonschema_definition(
-    '{"type":"object","additionalProperties":false,"properties":{"a":{"type":"integer"}}}'
-)
-A_DINT_OBJECT_SCHEMA = parse_jsonschema_definition(
-    '{"type":"object","additionalProperties":false,"properties":{"a":{"type":"integer","default":0}}}'
-)
-B_INT_OBJECT_SCHEMA = parse_jsonschema_definition(
-    '{"type":"object","additionalProperties":false,"properties":{"b":{"type":"integer"}}}'
-)
-A_INT_OPEN_OBJECT_SCHEMA = parse_jsonschema_definition('{"type":"object","properties":{"a":{"type":"integer"}}}')
-B_INT_OPEN_OBJECT_SCHEMA = parse_jsonschema_definition('{"type":"object","properties":{"b":{"type":"integer"}}}')
-B_DINT_OPEN_OBJECT_SCHEMA = parse_jsonschema_definition(
-    '{"type":"object","properties":{"b":{"type":"integer","default":0}}}'
-)
-A_INT_B_INT_OBJECT_SCHEMA = parse_jsonschema_definition(
-    '{"type":"object","additionalProperties":false,"properties":{"a":{"type":"integer"},"b":{"type":"integer"}}}'
-)
-A_DINT_B_INT_OBJECT_SCHEMA = parse_jsonschema_definition(
-    '{"type":"object","additionalProperties":false,"properties":{"a":{"type":"integer","default":0},"b":{"type":"integer"}}}'
-)
-A_INT_B_INT_REQUIRED_OBJECT_SCHEMA = parse_jsonschema_definition(
-    '{"type":"object","additionalProperties":false,"required":["b"],'
-    '"properties":{"a":{"type":"integer"},"b":{"type":"integer"}}}'
-)
-A_INT_B_DINT_OBJECT_SCHEMA = parse_jsonschema_definition(
-    '{"type":"object","additionalProperties":false,"properties":{"a":{"type":"integer"},"b":{"type":"integer","default":0}}}'
-)
-A_INT_B_DINT_REQUIRED_OBJECT_SCHEMA = parse_jsonschema_definition(
-    '{"type":"object","additionalProperties":false,"required":["b"],'
-    '"properties":{"a":{"type":"integer"},"b":{"type":"integer","default":0}}}'
-)
-A_DINT_B_DINT_OBJECT_SCHEMA = parse_jsonschema_definition(
-    '{"type":"object","additionalProperties":false,'
-    '"properties":{"a":{"type":"integer","default":0},"b":{"type":"integer","default":0}}}'
-)
-A_DINT_B_NUM_OBJECT_SCHEMA = parse_jsonschema_definition(
-    '{"type":"object","additionalProperties":false,"properties":{"a":{"type":"integer","default":1},"b":{"type":"number"}}}'
-)
-A_DINT_B_NUM_C_DINT_OBJECT_SCHEMA = parse_jsonschema_definition(
-    '{"type":"object","additionalProperties":false,'
-    '"properties":{"a":{"type":"integer","default":1},"b":{"type":"number"},"c":{"type":"integer","default":0}}}'
-)
-B_NUM_C_DINT_OPEN_OBJECT_SCHEMA = parse_jsonschema_definition(
-    '{"type":"object","properties":{"b":{"type":"number"},"c":{"type":"integer","default":0}}}'
-)
-B_NUM_C_INT_OPEN_OBJECT_SCHEMA = parse_jsonschema_definition(
-    '{"type":"object","properties":{"b":{"type":"number"},"c":{"type":"integer"}}}'
-)
-B_NUM_C_INT_OBJECT_SCHEMA = parse_jsonschema_definition(
-    '{"type":"object","additionalProperties":false,"properties":{"b":{"type":"number"},"c":{"type":"integer"}}}'
-)
-PROPERTY_ASTAR_OBJECT_SCHEMA = parse_jsonschema_definition('{"type":"object","propertyNames":{"pattern":"a*"}}')
-ARRAY_OF_POSITIVE_INTEGER = parse_jsonschema_definition(
-    '''
-    {
-        "type": "array",
-        "items": {"type": "integer", "exclusiveMinimum": 0}
-    }
-    '''
-)
-ARRAY_OF_POSITIVE_INTEGER_THROUGH_REF = parse_jsonschema_definition(
-    '''
-    {
-        "type": "array",
-        "items": {"$ref": "#/$defs/positiveInteger"},
-        "$defs": {
-            "positiveInteger": {
-                "type": "integer",
-                "exclusiveMinimum": 0
-            }
-        }
-    }
-    '''
+COMPATIBILIY = "compatibility with schema registry"
+COMPATIBLE_READER_IS_TRUE_SCHEMA = "The reader is a true schema which _accepts_ every value"
+COMPATIBLE_READER_IS_OPEN_AND_IGNORE_UNKNOWN_VALUES = "The reader schema is an open schema and ignores unknown values"
+COMPATIBLE_READER_NEW_FIELD_IS_NOT_REQUIRED = "The new fields in the reader schema are not required"
+COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET = "The reader schema changed a field type which accepts all writer values"
+COMPATIBLE_READER_EVERY_VALUE_IS_ACCEPTED = "Every value produced by the writer is accepted by the reader"
+
+INCOMPATIBLE_READER_IS_FALSE_SCHEMA = "The reader is a false schema which _rejects_ every value"
+INCOMPATIBLE_READER_IS_CLOSED_AND_REMOVED_FIELD = "The does not accepts all fields produced by the writer"
+INCOMPATIBLE_READER_HAS_A_NEW_REQUIRED_FIELDg = "The reader has a new required field"
+INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES = (
+    "The reader changed restricted field and only accept a subset of the writer's values"
 )
+INCOMPATIBLE_READER_CHANGED_FIELD_TYPE = "The reader schema changed a field type, the previous values are no longer valid"
+
+
+def schemas_are_compatible(
+    reader: Draft7Validator,
+    writer: Draft7Validator,
+    msg: str,
+) -> None:
+    assert compatibility(reader=reader, writer=writer) == COMPATIBLE, msg
+
+
+def not_schemas_are_compatible(
+    reader: Draft7Validator,
+    writer: Draft7Validator,
+    msg: str,
+) -> None:
+    assert compatibility(reader=reader, writer=writer) != COMPATIBLE, msg
+
+
+def test_reflexivity() -> None:
+    reflexivity_msg = "every schema is compatible with itself"
+    schemas_are_compatible(
+        reader=EVERY_TYPE_SCHEMA,
+        writer=EVERY_TYPE_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=NOT_OF_EMPTY_SCHEMA,
+        writer=NOT_OF_EMPTY_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=NOT_OF_TRUE_SCHEMA,
+        writer=NOT_OF_TRUE_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=FALSE_SCHEMA,
+        writer=FALSE_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=TRUE_SCHEMA,
+        writer=TRUE_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=EMPTY_SCHEMA,
+        writer=EMPTY_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=BOOLEAN_SCHEMA,
+        writer=BOOLEAN_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=INT_SCHEMA,
+        writer=INT_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=NUMBER_SCHEMA,
+        writer=NUMBER_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=STRING_SCHEMA,
+        writer=STRING_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=OBJECT_SCHEMA,
+        writer=OBJECT_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=ARRAY_SCHEMA,
+        writer=ARRAY_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=NOT_BOOLEAN_SCHEMA,
+        writer=NOT_BOOLEAN_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=NOT_INT_SCHEMA,
+        writer=NOT_INT_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=NOT_NUMBER_SCHEMA,
+        writer=NOT_NUMBER_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=NOT_STRING_SCHEMA,
+        writer=NOT_STRING_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=NOT_OBJECT_SCHEMA,
+        writer=NOT_OBJECT_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=NOT_ARRAY_SCHEMA,
+        writer=NOT_ARRAY_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=MAX_LENGTH_SCHEMA,
+        writer=MAX_LENGTH_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=MAX_LENGTH_DECREASED_SCHEMA,
+        writer=MAX_LENGTH_DECREASED_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=MIN_LENGTH_SCHEMA,
+        writer=MIN_LENGTH_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=MIN_LENGTH_INCREASED_SCHEMA,
+        writer=MIN_LENGTH_INCREASED_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=MIN_PATTERN_SCHEMA,
+        writer=MIN_PATTERN_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=MIN_PATTERN_STRICT_SCHEMA,
+        writer=MIN_PATTERN_STRICT_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=MAXIMUM_INTEGER_SCHEMA,
+        writer=MAXIMUM_INTEGER_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=MAXIMUM_NUMBER_SCHEMA,
+        writer=MAXIMUM_NUMBER_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=MAXIMUM_DECREASED_INTEGER_SCHEMA,
+        writer=MAXIMUM_DECREASED_INTEGER_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=MAXIMUM_DECREASED_NUMBER_SCHEMA,
+        writer=MAXIMUM_DECREASED_NUMBER_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=MINIMUM_INTEGER_SCHEMA,
+        writer=MINIMUM_INTEGER_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=MINIMUM_NUMBER_SCHEMA,
+        writer=MINIMUM_NUMBER_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=MINIMUM_INCREASED_INTEGER_SCHEMA,
+        writer=MINIMUM_INCREASED_INTEGER_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=MINIMUM_INCREASED_NUMBER_SCHEMA,
+        writer=MINIMUM_INCREASED_NUMBER_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=EXCLUSIVE_MAXIMUM_INTEGER_SCHEMA,
+        writer=EXCLUSIVE_MAXIMUM_INTEGER_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=EXCLUSIVE_MAXIMUM_NUMBER_SCHEMA,
+        writer=EXCLUSIVE_MAXIMUM_NUMBER_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=EXCLUSIVE_MAXIMUM_DECREASED_INTEGER_SCHEMA,
+        writer=EXCLUSIVE_MAXIMUM_DECREASED_INTEGER_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=EXCLUSIVE_MAXIMUM_DECREASED_NUMBER_SCHEMA,
+        writer=EXCLUSIVE_MAXIMUM_DECREASED_NUMBER_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=EXCLUSIVE_MINIMUM_INTEGER_SCHEMA,
+        writer=EXCLUSIVE_MINIMUM_INTEGER_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=EXCLUSIVE_MINIMUM_NUMBER_SCHEMA,
+        writer=EXCLUSIVE_MINIMUM_NUMBER_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=EXCLUSIVE_MINIMUM_INCREASED_INTEGER_SCHEMA,
+        writer=EXCLUSIVE_MINIMUM_INCREASED_INTEGER_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=EXCLUSIVE_MINIMUM_INCREASED_NUMBER_SCHEMA,
+        writer=EXCLUSIVE_MINIMUM_INCREASED_NUMBER_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=MAX_PROPERTIES_SCHEMA,
+        writer=MAX_PROPERTIES_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=MAX_PROPERTIES_DECREASED_SCHEMA,
+        writer=MAX_PROPERTIES_DECREASED_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=MIN_PROPERTIES_SCHEMA,
+        writer=MIN_PROPERTIES_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=MIN_PROPERTIES_INCREASED_SCHEMA,
+        writer=MIN_PROPERTIES_INCREASED_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=MAX_ITEMS_SCHEMA,
+        writer=MAX_ITEMS_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=MAX_ITEMS_DECREASED_SCHEMA,
+        writer=MAX_ITEMS_DECREASED_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=MIN_ITEMS_SCHEMA,
+        writer=MIN_ITEMS_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=MIN_ITEMS_INCREASED_SCHEMA,
+        writer=MIN_ITEMS_INCREASED_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=TUPLE_OF_INT_INT_SCHEMA,
+        writer=TUPLE_OF_INT_INT_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=TUPLE_OF_INT_SCHEMA,
+        writer=TUPLE_OF_INT_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=TUPLE_OF_INT_WITH_ADDITIONAL_INT_SCHEMA,
+        writer=TUPLE_OF_INT_WITH_ADDITIONAL_INT_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=TUPLE_OF_INT_INT_SCHEMA,
+        writer=TUPLE_OF_INT_INT_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=TUPLE_OF_INT_OPEN_SCHEMA,
+        writer=TUPLE_OF_INT_OPEN_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=ARRAY_OF_INT_SCHEMA,
+        writer=ARRAY_OF_INT_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=ARRAY_OF_NUMBER_SCHEMA,
+        writer=ARRAY_OF_NUMBER_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=ARRAY_OF_STRING_SCHEMA,
+        writer=ARRAY_OF_STRING_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=ENUM_AB_SCHEMA,
+        writer=ENUM_AB_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=ENUM_ABC_SCHEMA,
+        writer=ENUM_ABC_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=ENUM_BC_SCHEMA,
+        writer=ENUM_BC_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=ONEOF_STRING_SCHEMA,
+        writer=ONEOF_STRING_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=ONEOF_STRING_INT_SCHEMA,
+        writer=ONEOF_STRING_INT_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=EMPTY_OBJECT_SCHEMA,
+        writer=EMPTY_OBJECT_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=A_INT_OBJECT_SCHEMA,
+        writer=A_INT_OBJECT_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=A_INT_OPEN_OBJECT_SCHEMA,
+        writer=A_INT_OPEN_OBJECT_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=A_INT_B_INT_OBJECT_SCHEMA,
+        writer=A_INT_B_INT_OBJECT_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=A_INT_B_INT_REQUIRED_OBJECT_SCHEMA,
+        writer=A_INT_B_INT_REQUIRED_OBJECT_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=A_INT_B_DINT_OBJECT_SCHEMA,
+        writer=A_INT_B_DINT_OBJECT_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=A_INT_B_DINT_REQUIRED_OBJECT_SCHEMA,
+        writer=A_INT_B_DINT_REQUIRED_OBJECT_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=A_DINT_B_DINT_OBJECT_SCHEMA,
+        writer=A_DINT_B_DINT_OBJECT_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=A_DINT_B_NUM_OBJECT_SCHEMA,
+        writer=A_DINT_B_NUM_OBJECT_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=A_DINT_B_NUM_C_DINT_OBJECT_SCHEMA,
+        writer=A_DINT_B_NUM_C_DINT_OBJECT_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=B_NUM_C_DINT_OPEN_OBJECT_SCHEMA,
+        writer=B_NUM_C_DINT_OPEN_OBJECT_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=B_NUM_C_INT_OBJECT_SCHEMA,
+        writer=B_NUM_C_INT_OBJECT_SCHEMA,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=ARRAY_OF_POSITIVE_INTEGER,
+        writer=ARRAY_OF_POSITIVE_INTEGER,
+        msg=reflexivity_msg,
+    )
+    schemas_are_compatible(
+        reader=ARRAY_OF_POSITIVE_INTEGER_THROUGH_REF,
+        writer=ARRAY_OF_POSITIVE_INTEGER_THROUGH_REF,
+        msg=reflexivity_msg,
+    )
 
 
 def test_extra_optional_field_with_open_model_is_compatible() -> None:
     # - the reader is an open model, the extra field produced by the writer is
     # automatically accepted
-    assert compatibility(
+    schemas_are_compatible(
         reader=OBJECT_SCHEMA,
         writer=A_INT_OBJECT_SCHEMA,
-    ) == COMPATIBLE, "An unknown field to an open model is compatible"
-    assert compatibility(
+        msg=COMPATIBLE_READER_IS_TRUE_SCHEMA,
+    )
+    schemas_are_compatible(
         reader=TRUE_SCHEMA,
         writer=A_INT_OBJECT_SCHEMA,
-    ) == COMPATIBLE, "An unknown field to an open model is compatible"
-    assert compatibility(
+        msg=COMPATIBLE_READER_IS_TRUE_SCHEMA,
+    )
+    schemas_are_compatible(
         reader=EMPTY_SCHEMA,
         writer=A_INT_OBJECT_SCHEMA,
-    ) == COMPATIBLE, "An unknown field to an open model is compatible"
+        msg=COMPATIBLE_READER_IS_TRUE_SCHEMA,
+    )
 
     # - the writer is a closed model, so the field `b` was never produced, which
     # means that the writer never produced an invalid value.
     # - the reader's `b` field is optional, so the absenced of the field is not
     # a problem, and `a` is ignored because of the open model
-    assert compatibility(
+    schemas_are_compatible(
         reader=B_INT_OPEN_OBJECT_SCHEMA,
         writer=A_INT_OBJECT_SCHEMA,
-    ) == COMPATIBLE, "An unknown field on a open model is compatible"
+        msg=COMPATIBLE_READER_IS_OPEN_AND_IGNORE_UNKNOWN_VALUES,
+    )
 
     # - if the model is closed, then `a` must also be accepted
-    assert compatibility(
+    schemas_are_compatible(
         reader=A_INT_B_INT_OBJECT_SCHEMA,
         writer=A_INT_OBJECT_SCHEMA,
-    ) == COMPATIBLE, "A new optional field is compatible"
+        msg=COMPATIBLE_READER_NEW_FIELD_IS_NOT_REQUIRED,
+    )
 
     # Examples a bit more complex
-    assert compatibility(
-        reader=B_NUM_C_INT_OPEN_OBJECT_SCHEMA,
+    schemas_are_compatible(
+        reader=A_DINT_B_NUM_C_DINT_OBJECT_SCHEMA,
         writer=A_DINT_B_NUM_OBJECT_SCHEMA,
-    ) == COMPATIBLE, "An extra optional field is compatible"
-    assert compatibility(
+        msg=COMPATIBLE_READER_NEW_FIELD_IS_NOT_REQUIRED,
+    )
+    schemas_are_compatible(
         reader=B_NUM_C_DINT_OPEN_OBJECT_SCHEMA,
         writer=A_DINT_B_NUM_C_DINT_OBJECT_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(
-        reader=B_NUM_C_DINT_OPEN_OBJECT_SCHEMA,
+        msg=COMPATIBLE_READER_IS_OPEN_AND_IGNORE_UNKNOWN_VALUES,
+    )
+    schemas_are_compatible(
+        reader=B_NUM_C_INT_OPEN_OBJECT_SCHEMA,
         writer=A_DINT_B_NUM_OBJECT_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(
-        reader=A_DINT_B_NUM_C_DINT_OBJECT_SCHEMA,
+        msg=f"{COMPATIBLE_READER_IS_OPEN_AND_IGNORE_UNKNOWN_VALUES} + {COMPATIBLE_READER_NEW_FIELD_IS_NOT_REQUIRED}",
+    )
+    schemas_are_compatible(
+        reader=B_NUM_C_DINT_OPEN_OBJECT_SCHEMA,
         writer=A_DINT_B_NUM_OBJECT_SCHEMA,
-    ) == COMPATIBLE
+        msg=f"{COMPATIBLE_READER_IS_OPEN_AND_IGNORE_UNKNOWN_VALUES} + {COMPATIBLE_READER_NEW_FIELD_IS_NOT_REQUIRED}",
+    )
 
 
 def test_extra_field_with_closed_model_is_incompatible() -> None:
-    # The field here is not required but forbidden, because of this the reader
-    # will reject the writer data
-    assert compatibility(
-        reader=FALSE_SCHEMA,
-        writer=A_INT_OBJECT_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
+    # The false schema always falways validation, so the values produced by the
+    # writer won't be valid.
+    # https://json-schema.org/draft/2020-12/json-schema-core.html#rfc.section.4.3.2
+    #
+    # not_schemas_are_compatible(
+    #     reader=FALSE_SCHEMA,
+    #     writer=A_INT_OBJECT_SCHEMA,
+    #     msg=INCOMPATIBLE_READER_IS_FALSE_SCHEMA,
+    # )
+    not_schemas_are_compatible(
+        reader=A_INT_OBJECT_SCHEMA,
+        writer=FALSE_SCHEMA,
+        msg=INCOMPATIBLE_READER_IS_FALSE_SCHEMA,
+    )
+    not_schemas_are_compatible(
         reader=NOT_OF_TRUE_SCHEMA,
         writer=A_INT_OBJECT_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
+        msg=INCOMPATIBLE_READER_IS_FALSE_SCHEMA,
+    )
+    not_schemas_are_compatible(
         reader=NOT_OF_EMPTY_SCHEMA,
         writer=A_INT_OBJECT_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
+        msg=INCOMPATIBLE_READER_IS_FALSE_SCHEMA,
+    )
+    not_schemas_are_compatible(
         reader=B_INT_OBJECT_SCHEMA,
         writer=A_INT_OBJECT_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
+        msg=INCOMPATIBLE_READER_IS_CLOSED_AND_REMOVED_FIELD,
+    )
+    not_schemas_are_compatible(
         reader=B_NUM_C_INT_OBJECT_SCHEMA,
         writer=A_DINT_B_NUM_OBJECT_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
+        msg=INCOMPATIBLE_READER_IS_CLOSED_AND_REMOVED_FIELD,
+    )
+    not_schemas_are_compatible(
         reader=B_NUM_C_INT_OBJECT_SCHEMA,
         writer=A_DINT_B_NUM_C_DINT_OBJECT_SCHEMA,
-    ) != COMPATIBLE
+        msg=INCOMPATIBLE_READER_IS_CLOSED_AND_REMOVED_FIELD,
+    )
 
 
 def test_missing_required_field_is_incompatible() -> None:
-    assert compatibility(
+    not_schemas_are_compatible(
         reader=A_INT_B_INT_REQUIRED_OBJECT_SCHEMA,
         writer=A_INT_OBJECT_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
-        reader=A_INT_B_DINT_REQUIRED_OBJECT_SCHEMA,
-        writer=A_INT_OBJECT_SCHEMA,
-    ) != COMPATIBLE
+        msg=INCOMPATIBLE_READER_HAS_A_NEW_REQUIRED_FIELDg,
+    )
+    # The writer is not producing the value `b`, which is required by the
+    # reader
+    # not_schemas_are_compatible(
+    #     reader=A_INT_B_DINT_REQUIRED_OBJECT_SCHEMA,
+    #     writer=A_INT_OBJECT_SCHEMA,
+    #     msg=INCOMPATIBLE_READER_HAS_A_NEW_REQUIRED_FIELDg,
+    # )
+    not_schemas_are_compatible(
+        reader=A_INT_OBJECT_SCHEMA,
+        writer=A_INT_B_DINT_REQUIRED_OBJECT_SCHEMA,
+        msg=INCOMPATIBLE_READER_HAS_A_NEW_REQUIRED_FIELDg,
+    )
 
 
 def test_giving_a_default_value_for_a_non_required_field_is_compatible() -> None:
-    assert compatibility(
+    schemas_are_compatible(
         reader=OBJECT_SCHEMA,
         writer=A_DINT_OBJECT_SCHEMA,
-    ) == COMPATIBLE, "An unknown field to an open model is compatible"
-    assert compatibility(
+        msg=COMPATIBLE_READER_IS_TRUE_SCHEMA,
+    )
+    schemas_are_compatible(
         reader=TRUE_SCHEMA,
         writer=A_DINT_OBJECT_SCHEMA,
-    ) == COMPATIBLE, "An unknown field to an open model is compatible"
-    assert compatibility(
+        msg=COMPATIBLE_READER_IS_TRUE_SCHEMA,
+    )
+    schemas_are_compatible(
         reader=EMPTY_SCHEMA,
         writer=A_DINT_OBJECT_SCHEMA,
-    ) == COMPATIBLE, "An unknown field to an open model is compatible"
-    assert compatibility(
+        msg=COMPATIBLE_READER_IS_TRUE_SCHEMA,
+    )
+    schemas_are_compatible(
         reader=B_DINT_OPEN_OBJECT_SCHEMA,
         writer=A_INT_OBJECT_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(
+        msg=COMPATIBLE_READER_IS_TRUE_SCHEMA,
+    )
+    schemas_are_compatible(
         reader=A_INT_B_DINT_OBJECT_SCHEMA,
         writer=A_INT_OBJECT_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(
+        msg=COMPATIBLE_READER_NEW_FIELD_IS_NOT_REQUIRED,
+    )
+    schemas_are_compatible(
         reader=A_DINT_B_INT_OBJECT_SCHEMA,
         writer=A_INT_OBJECT_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(
+        msg=COMPATIBLE_READER_NEW_FIELD_IS_NOT_REQUIRED,
+    )
+    schemas_are_compatible(
         reader=B_NUM_C_DINT_OPEN_OBJECT_SCHEMA,
         writer=A_DINT_B_NUM_OBJECT_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(
-        reader=A_DINT_B_DINT_OBJECT_SCHEMA,
-        writer=EMPTY_OBJECT_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(
+        msg=f"{COMPATIBLE_READER_IS_OPEN_AND_IGNORE_UNKNOWN_VALUES} + {COMPATIBLE_READER_NEW_FIELD_IS_NOT_REQUIRED}",
+    )
+    schemas_are_compatible(
         reader=A_DINT_B_DINT_OBJECT_SCHEMA,
         writer=A_INT_OBJECT_SCHEMA,
-    ) == COMPATIBLE
+        msg=INCOMPATIBLE_READER_CHANGED_FIELD_TYPE,  # field B was anything, now it int
+    )
+    schemas_are_compatible(
+        reader=A_DINT_B_DINT_OBJECT_SCHEMA,
+        writer=EMPTY_OBJECT_SCHEMA,
+        msg=COMPATIBLE_READER_NEW_FIELD_IS_NOT_REQUIRED,
+    )
 
 
-def test_from_closed_to_open_is_incompatible() -> None:
-    assert compatibility(
+def test_boolean_schemas_are_backward_compatible() -> None:
+    # reader is the false schema, which never accepts a value
+    # https://json-schema.org/draft/2020-12/json-schema-core.html#rfc.section.4.3.2
+    # not_schemas_are_compatible(
+    #     reader=FALSE_SCHEMA,
+    #     writer=TRUE_SCHEMA,
+    #     msg=INCOMPATIBLE_READER_IS_FALSE_SCHEMA,
+    # )
+    schemas_are_compatible(
         reader=FALSE_SCHEMA,
         writer=TRUE_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
+        msg=INCOMPATIBLE_READER_IS_FALSE_SCHEMA,
+    )
+    schemas_are_compatible(
+        reader=TRUE_SCHEMA,
+        writer=FALSE_SCHEMA,
+        msg=INCOMPATIBLE_READER_IS_FALSE_SCHEMA,
+    )
+
+
+def test_from_closed_to_open_is_incompatible() -> None:
+    not_schemas_are_compatible(
         reader=B_NUM_C_INT_OBJECT_SCHEMA,
         writer=B_NUM_C_DINT_OPEN_OBJECT_SCHEMA,
-    ) != COMPATIBLE
+        msg="The reader is closed model and rejects the fields ignored by the writer",
+    )
 
 
 def test_union_with_incompatible_elements() -> None:
-    union1 = parse_jsonschema_definition(
-        '{"oneOf":[{"type":"array","items":{"type":"object",'
-        '"additionalProperties":false,"properties":{"a":{"type":"integer","default":1},"b":{"type":"number"}}}}]}'
-    )
-    union2 = parse_jsonschema_definition(
-        '{"oneOf":[{"type":"array","items":{"type":"object",'
-        '"additionalProperties":false,"properties":{"b":{"type":"number"},"c":{"type":"integer"}}}}]}'
+    not_schemas_are_compatible(
+        reader=ONEOF_ARRAY_B_NUM_C_INT_SCHEMA,
+        writer=ONEOF_ARRAY_A_DINT_B_NUM_SCHEMA,
+        msg=INCOMPATIBLE_READER_IS_CLOSED_AND_REMOVED_FIELD,
     )
-    assert compatibility(reader=union2, writer=union1) != COMPATIBLE
 
 
 def test_union_with_compatible_elements() -> None:
-    union1 = parse_jsonschema_definition(
-        '{"oneOf":[{"type":"array","items":{"type":"object",'
-        '"additionalProperties":false,"properties":{"a":{"type":"integer","default":1},"b":{"type":"number"}}}}]}'
+    schemas_are_compatible(
+        reader=ONEOF_ARRAY_B_NUM_C_DINT_OPEN_SCHEMA,
+        writer=ONEOF_ARRAY_A_DINT_B_NUM_SCHEMA,
+        msg=COMPATIBLE_READER_IS_OPEN_AND_IGNORE_UNKNOWN_VALUES,
     )
-    union2 = parse_jsonschema_definition(
-        '{"oneOf":[{"type":"array","items":{"type":"object",'
-        '"properties":{"b":{"type":"number"},"c":{"type":"integer","default":0}}}}]}'
+
+
+def test_array_and_tuples_are_incompatible() -> None:
+    # both tuple and arrays are represented using lists, this should be
+    # compatible
+    # schemas_are_compatible(
+    #     reader=ARRAY_OF_INT_SCHEMA,
+    #     writer=TUPLE_OF_INT_OPEN_SCHEMA,
+    #     msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    # )
+    # schemas_are_compatible(
+    #     reader=ARRAY_OF_INT_SCHEMA,
+    #     writer=TUPLE_OF_INT_INT_SCHEMA,
+    #     msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    # )
+    not_schemas_are_compatible(
+        reader=TUPLE_OF_INT_OPEN_SCHEMA,
+        writer=ARRAY_OF_INT_SCHEMA,
+        msg=COMPATIBILIY,
+    )
+    not_schemas_are_compatible(
+        reader=ARRAY_OF_INT_SCHEMA,
+        writer=TUPLE_OF_INT_OPEN_SCHEMA,
+        msg=COMPATIBILIY,
     )
-    assert compatibility(reader=union2, writer=union1) == COMPATIBLE
 
 
-def test_reflexivity() -> None:
-    schema = parse_jsonschema_definition(
-        '{"type":"object","required":["boolF","intF","numberF","stringF","enumF","arrayF","recordF"],'
-        '"properties":{"recordF":{"type":"object","properties":{"f":{"type":"number"}}},"stringF":{"type":"string"},'
-        '"boolF":{"type":"boolean"},"intF":{"type":"integer"},"enumF":{"enum":["S"]},'
-        '"arrayF":{"type":"array","items":{"type":"string"}},"numberF":{"type":"number"},"bool0":{"type":"boolean"}}}'
-    )
-    assert compatibility(reader=schema, writer=schema) == COMPATIBLE
-
-    assert compatibility(NOT_OF_EMPTY_SCHEMA, NOT_OF_EMPTY_SCHEMA) == COMPATIBLE
-    assert compatibility(NOT_OF_TRUE_SCHEMA, NOT_OF_TRUE_SCHEMA) == COMPATIBLE
-    assert compatibility(FALSE_SCHEMA, FALSE_SCHEMA) == COMPATIBLE
-    assert compatibility(TRUE_SCHEMA, TRUE_SCHEMA) == COMPATIBLE
-    assert compatibility(EMPTY_SCHEMA, EMPTY_SCHEMA) == COMPATIBLE
-    assert compatibility(BOOLEAN_SCHEMA, BOOLEAN_SCHEMA) == COMPATIBLE
-    assert compatibility(INT_SCHEMA, INT_SCHEMA) == COMPATIBLE
-    assert compatibility(NUMBER_SCHEMA, NUMBER_SCHEMA) == COMPATIBLE
-    assert compatibility(STRING_SCHEMA, STRING_SCHEMA) == COMPATIBLE
-    assert compatibility(OBJECT_SCHEMA, OBJECT_SCHEMA) == COMPATIBLE
-    assert compatibility(ARRAY_SCHEMA, ARRAY_SCHEMA) == COMPATIBLE
-    assert compatibility(NOT_BOOLEAN_SCHEMA, NOT_BOOLEAN_SCHEMA) == COMPATIBLE
-    assert compatibility(NOT_INT_SCHEMA, NOT_INT_SCHEMA) == COMPATIBLE
-    assert compatibility(NOT_NUMBER_SCHEMA, NOT_NUMBER_SCHEMA) == COMPATIBLE
-    assert compatibility(NOT_STRING_SCHEMA, NOT_STRING_SCHEMA) == COMPATIBLE
-    assert compatibility(NOT_OBJECT_SCHEMA, NOT_OBJECT_SCHEMA) == COMPATIBLE
-    assert compatibility(NOT_ARRAY_SCHEMA, NOT_ARRAY_SCHEMA) == COMPATIBLE
-    assert compatibility(MAX_LENGTH_SCHEMA, MAX_LENGTH_SCHEMA) == COMPATIBLE
-    assert compatibility(MAX_LENGTH_DECREASED_SCHEMA, MAX_LENGTH_DECREASED_SCHEMA) == COMPATIBLE
-    assert compatibility(MIN_LENGTH_SCHEMA, MIN_LENGTH_SCHEMA) == COMPATIBLE
-    assert compatibility(MIN_LENGTH_INCREASED_SCHEMA, MIN_LENGTH_INCREASED_SCHEMA) == COMPATIBLE
-    assert compatibility(MIN_PATTERN_SCHEMA, MIN_PATTERN_SCHEMA) == COMPATIBLE
-    assert compatibility(MIN_PATTERN_STRICT_SCHEMA, MIN_PATTERN_STRICT_SCHEMA) == COMPATIBLE
-    assert compatibility(MAXIMUM_INTEGER_SCHEMA, MAXIMUM_INTEGER_SCHEMA) == COMPATIBLE
-    assert compatibility(MAXIMUM_NUMBER_SCHEMA, MAXIMUM_NUMBER_SCHEMA) == COMPATIBLE
-    assert compatibility(MAXIMUM_DECREASED_INTEGER_SCHEMA, MAXIMUM_DECREASED_INTEGER_SCHEMA) == COMPATIBLE
-    assert compatibility(MAXIMUM_DECREASED_NUMBER_SCHEMA, MAXIMUM_DECREASED_NUMBER_SCHEMA) == COMPATIBLE
-    assert compatibility(MINIMUM_INTEGER_SCHEMA, MINIMUM_INTEGER_SCHEMA) == COMPATIBLE
-    assert compatibility(MINIMUM_NUMBER_SCHEMA, MINIMUM_NUMBER_SCHEMA) == COMPATIBLE
-    assert compatibility(MINIMUM_INCREASED_INTEGER_SCHEMA, MINIMUM_INCREASED_INTEGER_SCHEMA) == COMPATIBLE
-    assert compatibility(MINIMUM_INCREASED_NUMBER_SCHEMA, MINIMUM_INCREASED_NUMBER_SCHEMA) == COMPATIBLE
-    assert compatibility(EXCLUSIVE_MAXIMUM_INTEGER_SCHEMA, EXCLUSIVE_MAXIMUM_INTEGER_SCHEMA) == COMPATIBLE
-    assert compatibility(EXCLUSIVE_MAXIMUM_NUMBER_SCHEMA, EXCLUSIVE_MAXIMUM_NUMBER_SCHEMA) == COMPATIBLE
-    assert compatibility(
-        EXCLUSIVE_MAXIMUM_DECREASED_INTEGER_SCHEMA,
-        EXCLUSIVE_MAXIMUM_DECREASED_INTEGER_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(EXCLUSIVE_MAXIMUM_DECREASED_NUMBER_SCHEMA, EXCLUSIVE_MAXIMUM_DECREASED_NUMBER_SCHEMA) == COMPATIBLE
-    assert compatibility(EXCLUSIVE_MINIMUM_INTEGER_SCHEMA, EXCLUSIVE_MINIMUM_INTEGER_SCHEMA) == COMPATIBLE
-    assert compatibility(EXCLUSIVE_MINIMUM_NUMBER_SCHEMA, EXCLUSIVE_MINIMUM_NUMBER_SCHEMA) == COMPATIBLE
-    assert compatibility(
-        EXCLUSIVE_MINIMUM_INCREASED_INTEGER_SCHEMA,
-        EXCLUSIVE_MINIMUM_INCREASED_INTEGER_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(EXCLUSIVE_MINIMUM_INCREASED_NUMBER_SCHEMA, EXCLUSIVE_MINIMUM_INCREASED_NUMBER_SCHEMA) == COMPATIBLE
-    assert compatibility(MAX_PROPERTIES_SCHEMA, MAX_PROPERTIES_SCHEMA) == COMPATIBLE
-    assert compatibility(MAX_PROPERTIES_DECREASED_SCHEMA, MAX_PROPERTIES_DECREASED_SCHEMA) == COMPATIBLE
-    assert compatibility(MIN_PROPERTIES_SCHEMA, MIN_PROPERTIES_SCHEMA) == COMPATIBLE
-    assert compatibility(MIN_PROPERTIES_INCREASED_SCHEMA, MIN_PROPERTIES_INCREASED_SCHEMA) == COMPATIBLE
-    assert compatibility(MAX_ITEMS_SCHEMA, MAX_ITEMS_SCHEMA) == COMPATIBLE
-    assert compatibility(MAX_ITEMS_DECREASED_SCHEMA, MAX_ITEMS_DECREASED_SCHEMA) == COMPATIBLE
-    assert compatibility(MIN_ITEMS_SCHEMA, MIN_ITEMS_SCHEMA) == COMPATIBLE
-    assert compatibility(MIN_ITEMS_INCREASED_SCHEMA, MIN_ITEMS_INCREASED_SCHEMA) == COMPATIBLE
-    assert compatibility(TUPLE_OF_INT_INT_SCHEMA, TUPLE_OF_INT_INT_SCHEMA) == COMPATIBLE
-    assert compatibility(TUPLE_OF_INT_SCHEMA, TUPLE_OF_INT_SCHEMA) == COMPATIBLE
-    assert compatibility(TUPLE_OF_INT_WITH_ADDITIONAL_INT_SCHEMA, TUPLE_OF_INT_WITH_ADDITIONAL_INT_SCHEMA) == COMPATIBLE
-    assert compatibility(TUPLE_OF_INT_INT_OPEN_SCHEMA, TUPLE_OF_INT_INT_OPEN_SCHEMA) == COMPATIBLE
-    assert compatibility(TUPLE_OF_INT_OPEN_SCHEMA, TUPLE_OF_INT_OPEN_SCHEMA) == COMPATIBLE
-    assert compatibility(ARRAY_OF_INT_SCHEMA, ARRAY_OF_INT_SCHEMA) == COMPATIBLE
-    assert compatibility(ARRAY_OF_NUMBER_SCHEMA, ARRAY_OF_NUMBER_SCHEMA) == COMPATIBLE
-    assert compatibility(ARRAY_OF_STRING_SCHEMA, ARRAY_OF_STRING_SCHEMA) == COMPATIBLE
-    assert compatibility(ENUM_AB_SCHEMA, ENUM_AB_SCHEMA) == COMPATIBLE
-    assert compatibility(ENUM_ABC_SCHEMA, ENUM_ABC_SCHEMA) == COMPATIBLE
-    assert compatibility(ENUM_BC_SCHEMA, ENUM_BC_SCHEMA) == COMPATIBLE
-    assert compatibility(ONEOF_STRING_SCHEMA, ONEOF_STRING_SCHEMA) == COMPATIBLE
-    assert compatibility(ONEOF_STRING_INT_SCHEMA, ONEOF_STRING_INT_SCHEMA) == COMPATIBLE
-    assert compatibility(EMPTY_OBJECT_SCHEMA, EMPTY_OBJECT_SCHEMA) == COMPATIBLE
-    assert compatibility(A_INT_OBJECT_SCHEMA, A_INT_OBJECT_SCHEMA) == COMPATIBLE
-    assert compatibility(A_INT_OPEN_OBJECT_SCHEMA, A_INT_OPEN_OBJECT_SCHEMA) == COMPATIBLE
-    assert compatibility(A_INT_B_INT_OBJECT_SCHEMA, A_INT_B_INT_OBJECT_SCHEMA) == COMPATIBLE
-    assert compatibility(A_INT_B_INT_REQUIRED_OBJECT_SCHEMA, A_INT_B_INT_REQUIRED_OBJECT_SCHEMA) == COMPATIBLE
-    assert compatibility(A_INT_B_DINT_OBJECT_SCHEMA, A_INT_B_DINT_OBJECT_SCHEMA) == COMPATIBLE
-    assert compatibility(A_INT_B_DINT_REQUIRED_OBJECT_SCHEMA, A_INT_B_DINT_REQUIRED_OBJECT_SCHEMA) == COMPATIBLE
-    assert compatibility(A_DINT_B_DINT_OBJECT_SCHEMA, A_DINT_B_DINT_OBJECT_SCHEMA) == COMPATIBLE
-    assert compatibility(A_DINT_B_NUM_OBJECT_SCHEMA, A_DINT_B_NUM_OBJECT_SCHEMA) == COMPATIBLE
-    assert compatibility(A_DINT_B_NUM_C_DINT_OBJECT_SCHEMA, A_DINT_B_NUM_C_DINT_OBJECT_SCHEMA) == COMPATIBLE
-    assert compatibility(B_NUM_C_DINT_OPEN_OBJECT_SCHEMA, B_NUM_C_DINT_OPEN_OBJECT_SCHEMA) == COMPATIBLE
-    assert compatibility(B_NUM_C_INT_OBJECT_SCHEMA, B_NUM_C_INT_OBJECT_SCHEMA) == COMPATIBLE
-    assert compatibility(ARRAY_OF_POSITIVE_INTEGER, ARRAY_OF_POSITIVE_INTEGER) == COMPATIBLE
-    assert compatibility(ARRAY_OF_POSITIVE_INTEGER_THROUGH_REF, ARRAY_OF_POSITIVE_INTEGER_THROUGH_REF) == COMPATIBLE
+def test_true_schema_is_compatible_with_object() -> None:
+    for schema in OBJECT_SCHEMAS + BOOLEAN_SCHEMAS:
+        if schema != TRUE_SCHEMA:
+            schemas_are_compatible(
+                reader=TRUE_SCHEMA,
+                writer=schema,
+                msg=COMPATIBILIY,
+            )
+
+    for schema in NON_OBJECT_SCHEMAS:
+        not_schemas_are_compatible(
+            reader=TRUE_SCHEMA,
+            writer=schema,
+            msg=COMPATIBILIY,
+        )
 
 
 def test_schema_compatibility_successes() -> None:
     # allowing a broader set of values is compatible
-    assert compatibility(reader=NUMBER_SCHEMA, writer=INT_SCHEMA) == COMPATIBLE
-    assert compatibility(reader=ARRAY_OF_NUMBER_SCHEMA, writer=ARRAY_OF_INT_SCHEMA) == COMPATIBLE
-    assert compatibility(
+    schemas_are_compatible(
+        reader=NUMBER_SCHEMA,
+        writer=INT_SCHEMA,
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
+    schemas_are_compatible(
+        reader=ARRAY_OF_NUMBER_SCHEMA,
+        writer=ARRAY_OF_INT_SCHEMA,
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
+    schemas_are_compatible(
         reader=TUPLE_OF_INT_OPEN_SCHEMA,
         writer=TUPLE_OF_INT_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
+    schemas_are_compatible(
         reader=TUPLE_OF_INT_WITH_ADDITIONAL_INT_SCHEMA,
         writer=TUPLE_OF_INT_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(reader=ARRAY_OF_INT_SCHEMA, writer=TUPLE_OF_INT_OPEN_SCHEMA) == COMPATIBLE
-    assert compatibility(
-        reader=ARRAY_OF_INT_SCHEMA,
-        writer=TUPLE_OF_INT_INT_OPEN_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(reader=ENUM_ABC_SCHEMA, writer=ENUM_AB_SCHEMA) == COMPATIBLE
-    assert compatibility(
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
+    schemas_are_compatible(
+        reader=ENUM_ABC_SCHEMA,
+        writer=ENUM_AB_SCHEMA,
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
+    schemas_are_compatible(
         reader=ONEOF_STRING_INT_SCHEMA,
         writer=ONEOF_STRING_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(reader=ONEOF_STRING_INT_SCHEMA, writer=STRING_SCHEMA) == COMPATIBLE
-    assert compatibility(
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
+    schemas_are_compatible(
+        reader=ONEOF_STRING_INT_SCHEMA,
+        writer=STRING_SCHEMA,
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
+    schemas_are_compatible(
         reader=A_INT_OPEN_OBJECT_SCHEMA,
         writer=A_INT_B_INT_OBJECT_SCHEMA,
-    ) == COMPATIBLE
+        msg=COMPATIBLE_READER_IS_OPEN_AND_IGNORE_UNKNOWN_VALUES,
+    )
 
     # requiring less values is compatible
-    assert compatibility(
+    schemas_are_compatible(
         reader=TUPLE_OF_INT_OPEN_SCHEMA,
         writer=TUPLE_OF_INT_INT_OPEN_SCHEMA,
-    ) == COMPATIBLE
+        msg=COMPATIBLE_READER_IS_OPEN_AND_IGNORE_UNKNOWN_VALUES,
+    )
+    schemas_are_compatible(
+        reader=TUPLE_OF_INT_OPEN_SCHEMA,
+        writer=TUPLE_OF_INT_INT_SCHEMA,
+        msg=COMPATIBLE_READER_IS_OPEN_AND_IGNORE_UNKNOWN_VALUES,
+    )
 
     # equivalences
-    assert compatibility(reader=ONEOF_STRING_SCHEMA, writer=STRING_SCHEMA) == COMPATIBLE
-    assert compatibility(reader=STRING_SCHEMA, writer=ONEOF_STRING_SCHEMA) == COMPATIBLE
+    schemas_are_compatible(
+        reader=ONEOF_STRING_SCHEMA,
+        writer=STRING_SCHEMA,
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
+    schemas_are_compatible(
+        reader=STRING_SCHEMA,
+        writer=ONEOF_STRING_SCHEMA,
+        msg=COMPATIBLE_READER_EVERY_VALUE_IS_ACCEPTED,
+    )
 
     # new non-required fields is compatible
-    assert compatibility(reader=A_INT_OBJECT_SCHEMA, writer=EMPTY_OBJECT_SCHEMA) == COMPATIBLE
-    assert compatibility(
+    schemas_are_compatible(
+        reader=A_INT_OBJECT_SCHEMA,
+        writer=EMPTY_OBJECT_SCHEMA,
+        msg=COMPATIBLE_READER_EVERY_VALUE_IS_ACCEPTED,
+    )
+    schemas_are_compatible(
         reader=A_INT_B_INT_OBJECT_SCHEMA,
         writer=A_INT_OBJECT_SCHEMA,
-    ) == COMPATIBLE
+        msg=COMPATIBLE_READER_EVERY_VALUE_IS_ACCEPTED,
+    )
 
 
 def test_type_narrowing_incompabilities() -> None:
-    assert compatibility(reader=INT_SCHEMA, writer=NUMBER_SCHEMA) != COMPATIBLE
-    assert compatibility(reader=ARRAY_OF_INT_SCHEMA, writer=ARRAY_OF_NUMBER_SCHEMA) != COMPATIBLE
-    assert compatibility(reader=ENUM_AB_SCHEMA, writer=ENUM_ABC_SCHEMA) != COMPATIBLE
-    assert compatibility(reader=ENUM_BC_SCHEMA, writer=ENUM_ABC_SCHEMA) != COMPATIBLE
-    assert compatibility(
+    not_schemas_are_compatible(
+        reader=INT_SCHEMA,
+        writer=NUMBER_SCHEMA,
+        msg=INCOMPATIBLE_READER_CHANGED_FIELD_TYPE,
+    )
+    not_schemas_are_compatible(
+        reader=ARRAY_OF_INT_SCHEMA,
+        writer=ARRAY_OF_NUMBER_SCHEMA,
+        msg=INCOMPATIBLE_READER_CHANGED_FIELD_TYPE,
+    )
+    not_schemas_are_compatible(
+        reader=ENUM_AB_SCHEMA,
+        writer=ENUM_ABC_SCHEMA,
+        msg=INCOMPATIBLE_READER_CHANGED_FIELD_TYPE,
+    )
+    not_schemas_are_compatible(
+        reader=ENUM_BC_SCHEMA,
+        writer=ENUM_ABC_SCHEMA,
+        msg=INCOMPATIBLE_READER_CHANGED_FIELD_TYPE,
+    )
+    not_schemas_are_compatible(
         reader=ONEOF_INT_SCHEMA,
         writer=ONEOF_NUMBER_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
+        msg=INCOMPATIBLE_READER_CHANGED_FIELD_TYPE,
+    )
+    not_schemas_are_compatible(
         reader=ONEOF_STRING_SCHEMA,
         writer=ONEOF_STRING_INT_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(reader=INT_SCHEMA, writer=ONEOF_STRING_INT_SCHEMA) != COMPATIBLE
+        msg=INCOMPATIBLE_READER_CHANGED_FIELD_TYPE,
+    )
+    not_schemas_are_compatible(
+        reader=INT_SCHEMA,
+        writer=ONEOF_STRING_INT_SCHEMA,
+        msg=INCOMPATIBLE_READER_CHANGED_FIELD_TYPE,
+    )
 
 
 def test_type_mismatch_incompabilities() -> None:
-    assert compatibility(reader=BOOLEAN_SCHEMA, writer=INT_SCHEMA) != COMPATIBLE
-    assert compatibility(reader=INT_SCHEMA, writer=BOOLEAN_SCHEMA) != COMPATIBLE
-    assert compatibility(reader=STRING_SCHEMA, writer=BOOLEAN_SCHEMA) != COMPATIBLE
-    assert compatibility(reader=STRING_SCHEMA, writer=INT_SCHEMA) != COMPATIBLE
-    assert compatibility(reader=ARRAY_OF_INT_SCHEMA, writer=ARRAY_OF_STRING_SCHEMA) != COMPATIBLE
-    assert compatibility(
+    not_schemas_are_compatible(
+        reader=BOOLEAN_SCHEMA,
+        writer=INT_SCHEMA,
+        msg=INCOMPATIBLE_READER_CHANGED_FIELD_TYPE,
+    )
+    not_schemas_are_compatible(
+        reader=INT_SCHEMA,
+        writer=BOOLEAN_SCHEMA,
+        msg=INCOMPATIBLE_READER_CHANGED_FIELD_TYPE,
+    )
+    not_schemas_are_compatible(
+        reader=STRING_SCHEMA,
+        writer=BOOLEAN_SCHEMA,
+        msg=INCOMPATIBLE_READER_CHANGED_FIELD_TYPE,
+    )
+    not_schemas_are_compatible(
+        reader=STRING_SCHEMA,
+        writer=INT_SCHEMA,
+        msg=INCOMPATIBLE_READER_CHANGED_FIELD_TYPE,
+    )
+    not_schemas_are_compatible(
+        reader=ARRAY_OF_INT_SCHEMA,
+        writer=ARRAY_OF_STRING_SCHEMA,
+        msg=INCOMPATIBLE_READER_CHANGED_FIELD_TYPE,
+    )
+    not_schemas_are_compatible(
+        reader=TUPLE_OF_INT_INT_SCHEMA,
+        writer=TUPLE_OF_INT_OPEN_SCHEMA,
+        msg=INCOMPATIBLE_READER_CHANGED_FIELD_TYPE,
+    )
+    not_schemas_are_compatible(
         reader=TUPLE_OF_INT_INT_OPEN_SCHEMA,
         writer=TUPLE_OF_INT_OPEN_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(reader=INT_SCHEMA, writer=ENUM_AB_SCHEMA) != COMPATIBLE
-    assert compatibility(reader=ENUM_AB_SCHEMA, writer=INT_SCHEMA) != COMPATIBLE
+        msg=INCOMPATIBLE_READER_CHANGED_FIELD_TYPE,
+    )
+    not_schemas_are_compatible(
+        reader=INT_SCHEMA,
+        writer=ENUM_AB_SCHEMA,
+        msg=INCOMPATIBLE_READER_CHANGED_FIELD_TYPE,
+    )
+    not_schemas_are_compatible(
+        reader=ENUM_AB_SCHEMA,
+        writer=INT_SCHEMA,
+        msg=INCOMPATIBLE_READER_CHANGED_FIELD_TYPE,
+    )
 
 
 def test_true_and_false_schemas() -> None:
-    assert compatibility(
+    schemas_are_compatible(
         writer=NOT_OF_EMPTY_SCHEMA,
         reader=NOT_OF_TRUE_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(
-        writer=NOT_OF_TRUE_SCHEMA,
-        reader=FALSE_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(
-        writer=NOT_OF_EMPTY_SCHEMA,
-        reader=FALSE_SCHEMA,
-    ) == COMPATIBLE
-
-    assert compatibility(
+        msg="both schemas reject every value",
+    )
+    # the schemas below are just different ways of representing the same schema
+    # schemas_are_compatible(
+    #     writer=NOT_OF_TRUE_SCHEMA,
+    #     reader=FALSE_SCHEMA,
+    #     msg="both schemas reject every value",
+    # )
+    # schemas_are_compatible(
+    #     writer=NOT_OF_EMPTY_SCHEMA,
+    #     reader=FALSE_SCHEMA,
+    #     msg="both schemas reject every value",
+    # )
+
+    schemas_are_compatible(
         writer=TRUE_SCHEMA,
         reader=EMPTY_SCHEMA,
-    ) == COMPATIBLE
+        msg="both schemas accept every value",
+    )
 
     # the true schema accepts anything ... including nothing
-    assert compatibility(
-        writer=NOT_OF_EMPTY_SCHEMA,
-        reader=TRUE_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(
-        writer=NOT_OF_TRUE_SCHEMA,
-        reader=TRUE_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(
-        writer=NOT_OF_EMPTY_SCHEMA,
-        reader=TRUE_SCHEMA,
-    ) == COMPATIBLE
-
-    assert compatibility(
+    # schemas_are_compatible(
+    #     writer=NOT_OF_EMPTY_SCHEMA,
+    #     reader=TRUE_SCHEMA,
+    #     msg=COMPATIBLE_READER_EVERY_VALUE_IS_ACCEPTED,
+    # )
+    # schemas_are_compatible(
+    #     writer=NOT_OF_TRUE_SCHEMA,
+    #     reader=TRUE_SCHEMA,
+    #     msg=COMPATIBLE_READER_EVERY_VALUE_IS_ACCEPTED,
+    # )
+    # schemas_are_compatible(
+    #     writer=NOT_OF_EMPTY_SCHEMA,
+    #     reader=TRUE_SCHEMA,
+    #     msg=COMPATIBLE_READER_EVERY_VALUE_IS_ACCEPTED,
+    # )
+
+    # the reader rejects every value
+    not_schemas_are_compatible(
         writer=TRUE_SCHEMA,
         reader=NOT_OF_EMPTY_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
+        msg=INCOMPATIBLE_READER_IS_FALSE_SCHEMA,
+    )
+    not_schemas_are_compatible(
         writer=TRUE_SCHEMA,
         reader=NOT_OF_TRUE_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
-        writer=TRUE_SCHEMA,
-        reader=NOT_OF_EMPTY_SCHEMA,
-    ) != COMPATIBLE
+        msg=INCOMPATIBLE_READER_IS_FALSE_SCHEMA,
+    )
 
-    assert compatibility(
+    not_schemas_are_compatible(
         writer=TRUE_SCHEMA,
         reader=A_INT_B_INT_REQUIRED_OBJECT_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
+        msg=INCOMPATIBLE_READER_CHANGED_FIELD_TYPE,
+    )
+    not_schemas_are_compatible(
         writer=FALSE_SCHEMA,
         reader=A_INT_B_INT_REQUIRED_OBJECT_SCHEMA,
-    ) != COMPATIBLE
+        msg=INCOMPATIBLE_READER_HAS_A_NEW_REQUIRED_FIELDg,
+    )
+
+    not_schemas_are_compatible(
+        writer=NOT_OF_TRUE_SCHEMA,
+        reader=FALSE_SCHEMA,
+        msg=COMPATIBILIY,
+    )
+    not_schemas_are_compatible(
+        writer=FALSE_SCHEMA,
+        reader=NOT_OF_TRUE_SCHEMA,
+        msg=COMPATIBILIY,
+    )
+    not_schemas_are_compatible(
+        writer=FALSE_SCHEMA,
+        reader=NOT_OF_EMPTY_SCHEMA,
+        msg=COMPATIBILIY,
+    )
+    not_schemas_are_compatible(
+        writer=NOT_OF_EMPTY_SCHEMA,
+        reader=FALSE_SCHEMA,
+        msg=COMPATIBILIY,
+    )
+    not_schemas_are_compatible(
+        writer=TRUE_SCHEMA,
+        reader=NOT_OF_EMPTY_SCHEMA,
+        msg=COMPATIBILIY,
+    )
+    not_schemas_are_compatible(
+        writer=NOT_OF_EMPTY_SCHEMA,
+        reader=TRUE_SCHEMA,
+        msg=COMPATIBILIY,
+    )
+    not_schemas_are_compatible(
+        writer=TRUE_SCHEMA,
+        reader=NOT_OF_TRUE_SCHEMA,
+        msg=COMPATIBILIY,
+    )
+    not_schemas_are_compatible(
+        writer=NOT_OF_TRUE_SCHEMA,
+        reader=TRUE_SCHEMA,
+        msg=COMPATIBILIY,
+    )
+    not_schemas_are_compatible(
+        writer=TRUE_SCHEMA,
+        reader=NOT_OF_EMPTY_SCHEMA,
+        msg=COMPATIBILIY,
+    )
+    not_schemas_are_compatible(
+        writer=NOT_OF_EMPTY_SCHEMA,
+        reader=TRUE_SCHEMA,
+        msg=COMPATIBILIY,
+    )
 
 
-def test_schema_strict_attributes() -> None:
-    assert compatibility(
+def test_schema_restrict_attributes_is_incompatible() -> None:
+    not_schemas_are_compatible(
         writer=STRING_SCHEMA,
         reader=MAX_LENGTH_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
+    not_schemas_are_compatible(
         writer=MAX_LENGTH_SCHEMA,
         reader=MAX_LENGTH_DECREASED_SCHEMA,
-    ) != COMPATIBLE
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
 
-    assert compatibility(
+    not_schemas_are_compatible(
         writer=STRING_SCHEMA,
         reader=MIN_LENGTH_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
+    not_schemas_are_compatible(
         writer=MIN_LENGTH_SCHEMA,
         reader=MIN_LENGTH_INCREASED_SCHEMA,
-    ) != COMPATIBLE
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
 
-    assert compatibility(
+    not_schemas_are_compatible(
         writer=STRING_SCHEMA,
         reader=MIN_PATTERN_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
+    not_schemas_are_compatible(
         writer=MIN_PATTERN_SCHEMA,
         reader=MIN_PATTERN_STRICT_SCHEMA,
-    ) != COMPATIBLE
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
 
-    assert compatibility(writer=INT_SCHEMA, reader=MAXIMUM_INTEGER_SCHEMA) != COMPATIBLE
-    assert compatibility(writer=INT_SCHEMA, reader=MAXIMUM_NUMBER_SCHEMA) != COMPATIBLE
-    assert compatibility(writer=NUMBER_SCHEMA, reader=MAXIMUM_NUMBER_SCHEMA) != COMPATIBLE
-    assert compatibility(writer=MAXIMUM_NUMBER_SCHEMA, reader=MAXIMUM_DECREASED_NUMBER_SCHEMA) != COMPATIBLE
+    not_schemas_are_compatible(
+        writer=INT_SCHEMA,
+        reader=MAXIMUM_INTEGER_SCHEMA,
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
+    not_schemas_are_compatible(
+        writer=INT_SCHEMA,
+        reader=MAXIMUM_NUMBER_SCHEMA,
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
+    not_schemas_are_compatible(
+        writer=NUMBER_SCHEMA,
+        reader=MAXIMUM_NUMBER_SCHEMA,
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
+    not_schemas_are_compatible(
+        writer=MAXIMUM_NUMBER_SCHEMA,
+        reader=MAXIMUM_DECREASED_NUMBER_SCHEMA,
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
 
-    assert compatibility(writer=INT_SCHEMA, reader=MINIMUM_NUMBER_SCHEMA) != COMPATIBLE
-    assert compatibility(writer=NUMBER_SCHEMA, reader=MINIMUM_NUMBER_SCHEMA) != COMPATIBLE
-    assert compatibility(writer=MINIMUM_NUMBER_SCHEMA, reader=MINIMUM_INCREASED_NUMBER_SCHEMA) != COMPATIBLE
+    not_schemas_are_compatible(
+        writer=INT_SCHEMA,
+        reader=MINIMUM_NUMBER_SCHEMA,
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
+    not_schemas_are_compatible(
+        writer=NUMBER_SCHEMA,
+        reader=MINIMUM_NUMBER_SCHEMA,
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
+    not_schemas_are_compatible(
+        writer=MINIMUM_NUMBER_SCHEMA,
+        reader=MINIMUM_INCREASED_NUMBER_SCHEMA,
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
 
-    assert compatibility(
+    not_schemas_are_compatible(
         writer=INT_SCHEMA,
         reader=EXCLUSIVE_MAXIMUM_NUMBER_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
+    not_schemas_are_compatible(
         writer=NUMBER_SCHEMA,
         reader=EXCLUSIVE_MAXIMUM_NUMBER_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
+    not_schemas_are_compatible(
         writer=EXCLUSIVE_MAXIMUM_NUMBER_SCHEMA,
         reader=EXCLUSIVE_MAXIMUM_DECREASED_NUMBER_SCHEMA,
-    ) != COMPATIBLE
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
 
-    assert compatibility(
+    not_schemas_are_compatible(
         writer=NUMBER_SCHEMA,
         reader=EXCLUSIVE_MINIMUM_NUMBER_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
+    not_schemas_are_compatible(
         writer=INT_SCHEMA,
         reader=EXCLUSIVE_MINIMUM_NUMBER_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
+    not_schemas_are_compatible(
         writer=EXCLUSIVE_MINIMUM_NUMBER_SCHEMA,
         reader=EXCLUSIVE_MINIMUM_INCREASED_NUMBER_SCHEMA,
-    ) != COMPATIBLE
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
 
-    assert compatibility(
+    not_schemas_are_compatible(
         writer=OBJECT_SCHEMA,
         reader=MAX_PROPERTIES_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
+    not_schemas_are_compatible(
         writer=MAX_PROPERTIES_SCHEMA,
         reader=MAX_PROPERTIES_DECREASED_SCHEMA,
-    ) != COMPATIBLE
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
 
-    assert compatibility(
+    not_schemas_are_compatible(
         writer=OBJECT_SCHEMA,
         reader=MIN_PROPERTIES_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
+    not_schemas_are_compatible(
         writer=MIN_PROPERTIES_SCHEMA,
         reader=MIN_PROPERTIES_INCREASED_SCHEMA,
-    ) != COMPATIBLE
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
 
-    assert compatibility(
+    not_schemas_are_compatible(
         writer=ARRAY_SCHEMA,
         reader=MAX_ITEMS_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
+    not_schemas_are_compatible(
         writer=MAX_ITEMS_SCHEMA,
         reader=MAX_ITEMS_DECREASED_SCHEMA,
-    ) != COMPATIBLE
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
 
-    assert compatibility(
+    not_schemas_are_compatible(
         writer=ARRAY_SCHEMA,
         reader=MIN_ITEMS_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
+    not_schemas_are_compatible(
         writer=MIN_ITEMS_SCHEMA,
         reader=MIN_ITEMS_INCREASED_SCHEMA,
-    ) != COMPATIBLE
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
 
 
 def test_schema_broadenning_attributes_is_compatible() -> None:
-    assert compatibility(
+    schemas_are_compatible(
         writer=MAX_LENGTH_SCHEMA,
         reader=STRING_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
+    schemas_are_compatible(
         writer=MAX_LENGTH_DECREASED_SCHEMA,
         reader=MAX_LENGTH_SCHEMA,
-    ) == COMPATIBLE
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
 
-    assert compatibility(
+    schemas_are_compatible(
         writer=MIN_LENGTH_SCHEMA,
         reader=STRING_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
+    schemas_are_compatible(
         writer=MIN_LENGTH_INCREASED_SCHEMA,
         reader=MIN_LENGTH_SCHEMA,
-    ) == COMPATIBLE
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
 
-    assert compatibility(
+    schemas_are_compatible(
         writer=MIN_PATTERN_SCHEMA,
         reader=STRING_SCHEMA,
-    ) == COMPATIBLE
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
 
-    assert compatibility(writer=MAXIMUM_INTEGER_SCHEMA, reader=INT_SCHEMA) == COMPATIBLE
-    assert compatibility(writer=MAXIMUM_NUMBER_SCHEMA, reader=NUMBER_SCHEMA) == COMPATIBLE
-    assert compatibility(writer=MAXIMUM_DECREASED_NUMBER_SCHEMA, reader=MAXIMUM_NUMBER_SCHEMA) == COMPATIBLE
+    schemas_are_compatible(
+        writer=MAXIMUM_INTEGER_SCHEMA,
+        reader=INT_SCHEMA,
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
+    schemas_are_compatible(
+        writer=MAXIMUM_NUMBER_SCHEMA,
+        reader=NUMBER_SCHEMA,
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
+    schemas_are_compatible(
+        writer=MAXIMUM_DECREASED_NUMBER_SCHEMA,
+        reader=MAXIMUM_NUMBER_SCHEMA,
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
 
-    assert compatibility(writer=MINIMUM_INTEGER_SCHEMA, reader=INT_SCHEMA) == COMPATIBLE
-    assert compatibility(writer=MINIMUM_NUMBER_SCHEMA, reader=NUMBER_SCHEMA) == COMPATIBLE
-    assert compatibility(writer=MINIMUM_INCREASED_NUMBER_SCHEMA, reader=MINIMUM_NUMBER_SCHEMA) == COMPATIBLE
+    schemas_are_compatible(
+        writer=MINIMUM_INTEGER_SCHEMA,
+        reader=INT_SCHEMA,
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
+    schemas_are_compatible(
+        writer=MINIMUM_NUMBER_SCHEMA,
+        reader=NUMBER_SCHEMA,
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
+    schemas_are_compatible(
+        writer=MINIMUM_INCREASED_NUMBER_SCHEMA,
+        reader=MINIMUM_NUMBER_SCHEMA,
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
 
-    assert compatibility(
+    schemas_are_compatible(
         writer=EXCLUSIVE_MAXIMUM_INTEGER_SCHEMA,
         reader=INT_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
+    schemas_are_compatible(
         writer=EXCLUSIVE_MAXIMUM_NUMBER_SCHEMA,
         reader=NUMBER_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
+    schemas_are_compatible(
         writer=EXCLUSIVE_MAXIMUM_DECREASED_NUMBER_SCHEMA,
         reader=EXCLUSIVE_MAXIMUM_NUMBER_SCHEMA,
-    ) == COMPATIBLE
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
 
-    assert compatibility(
+    schemas_are_compatible(
         writer=EXCLUSIVE_MINIMUM_NUMBER_SCHEMA,
         reader=NUMBER_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
+    schemas_are_compatible(
         writer=EXCLUSIVE_MINIMUM_INTEGER_SCHEMA,
         reader=INT_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
+    schemas_are_compatible(
         writer=EXCLUSIVE_MINIMUM_INCREASED_NUMBER_SCHEMA,
         reader=EXCLUSIVE_MINIMUM_NUMBER_SCHEMA,
-    ) == COMPATIBLE
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
 
-    assert compatibility(
+    schemas_are_compatible(
         writer=MAX_PROPERTIES_SCHEMA,
         reader=OBJECT_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
+    schemas_are_compatible(
         writer=MAX_PROPERTIES_DECREASED_SCHEMA,
         reader=MAX_PROPERTIES_SCHEMA,
-    ) == COMPATIBLE
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
 
-    assert compatibility(
+    schemas_are_compatible(
         writer=MIN_PROPERTIES_SCHEMA,
         reader=OBJECT_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
+    schemas_are_compatible(
         writer=MIN_PROPERTIES_INCREASED_SCHEMA,
         reader=MIN_PROPERTIES_SCHEMA,
-    ) == COMPATIBLE
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
 
-    assert compatibility(
+    schemas_are_compatible(
         writer=MAX_ITEMS_SCHEMA,
         reader=ARRAY_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
+    schemas_are_compatible(
         writer=MAX_ITEMS_DECREASED_SCHEMA,
         reader=MAX_ITEMS_SCHEMA,
-    ) == COMPATIBLE
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
 
-    assert compatibility(
+    schemas_are_compatible(
         writer=MIN_ITEMS_SCHEMA,
         reader=ARRAY_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
+    schemas_are_compatible(
         writer=MIN_ITEMS_INCREASED_SCHEMA,
         reader=MIN_ITEMS_SCHEMA,
-    ) == COMPATIBLE
-
-
-def test_schema_restrict_attributes_is_incompatible() -> None:
-    assert compatibility(
-        writer=STRING_SCHEMA,
-        reader=MAX_LENGTH_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
-        writer=MAX_LENGTH_SCHEMA,
-        reader=MAX_LENGTH_DECREASED_SCHEMA,
-    ) != COMPATIBLE
-
-    assert compatibility(
-        writer=STRING_SCHEMA,
-        reader=MIN_LENGTH_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
-        writer=MIN_LENGTH_SCHEMA,
-        reader=MIN_LENGTH_INCREASED_SCHEMA,
-    ) != COMPATIBLE
-
-    assert compatibility(
-        writer=STRING_SCHEMA,
-        reader=MIN_PATTERN_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
-        writer=MIN_PATTERN_SCHEMA,
-        reader=MIN_PATTERN_STRICT_SCHEMA,
-    ) != COMPATIBLE
-
-    assert compatibility(writer=INT_SCHEMA, reader=MAXIMUM_NUMBER_SCHEMA) != COMPATIBLE
-    assert compatibility(writer=NUMBER_SCHEMA, reader=MAXIMUM_NUMBER_SCHEMA) != COMPATIBLE
-    assert compatibility(writer=MAXIMUM_NUMBER_SCHEMA, reader=MAXIMUM_DECREASED_NUMBER_SCHEMA) != COMPATIBLE
-
-    assert compatibility(writer=INT_SCHEMA, reader=MINIMUM_NUMBER_SCHEMA) != COMPATIBLE
-    assert compatibility(writer=NUMBER_SCHEMA, reader=MINIMUM_NUMBER_SCHEMA) != COMPATIBLE
-    assert compatibility(writer=MINIMUM_NUMBER_SCHEMA, reader=MINIMUM_INCREASED_NUMBER_SCHEMA) != COMPATIBLE
-
-    assert compatibility(
-        writer=INT_SCHEMA,
-        reader=EXCLUSIVE_MAXIMUM_NUMBER_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
-        writer=NUMBER_SCHEMA,
-        reader=EXCLUSIVE_MAXIMUM_NUMBER_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
-        writer=EXCLUSIVE_MAXIMUM_NUMBER_SCHEMA,
-        reader=EXCLUSIVE_MAXIMUM_DECREASED_NUMBER_SCHEMA,
-    ) != COMPATIBLE
-
-    assert compatibility(
-        writer=NUMBER_SCHEMA,
-        reader=EXCLUSIVE_MINIMUM_NUMBER_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
-        writer=INT_SCHEMA,
-        reader=EXCLUSIVE_MINIMUM_NUMBER_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
-        writer=EXCLUSIVE_MINIMUM_NUMBER_SCHEMA,
-        reader=EXCLUSIVE_MINIMUM_INCREASED_NUMBER_SCHEMA,
-    ) != COMPATIBLE
-
-    assert compatibility(
-        writer=OBJECT_SCHEMA,
-        reader=MAX_PROPERTIES_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
-        writer=MAX_PROPERTIES_SCHEMA,
-        reader=MAX_PROPERTIES_DECREASED_SCHEMA,
-    ) != COMPATIBLE
-
-    assert compatibility(
-        writer=OBJECT_SCHEMA,
-        reader=MIN_PROPERTIES_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
-        writer=MIN_PROPERTIES_SCHEMA,
-        reader=MIN_PROPERTIES_INCREASED_SCHEMA,
-    ) != COMPATIBLE
-
-    assert compatibility(
-        writer=ARRAY_SCHEMA,
-        reader=MAX_ITEMS_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
-        writer=MAX_ITEMS_SCHEMA,
-        reader=MAX_ITEMS_DECREASED_SCHEMA,
-    ) != COMPATIBLE
-
-    assert compatibility(
-        writer=ARRAY_SCHEMA,
-        reader=MIN_ITEMS_SCHEMA,
-    ) != COMPATIBLE
-    assert compatibility(
-        writer=MIN_ITEMS_SCHEMA,
-        reader=MIN_ITEMS_INCREASED_SCHEMA,
-    ) != COMPATIBLE
+        msg=COMPATIBLE_READER_FIELD_TYPE_IS_A_SUPERSET,
+    )
 
 
+@pytest.mark.skip("not implemented yet")
 def test_property_name():
-    assert compatibility(
+    schemas_are_compatible(
         reader=OBJECT_SCHEMA,
         writer=PROPERTY_ASTAR_OBJECT_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(
+        msg=COMPATIBLE_READER_IS_OPEN_AND_IGNORE_UNKNOWN_VALUES,
+    )
+    not_schemas_are_compatible(
         reader=A_OBJECT_SCHEMA,
         writer=PROPERTY_ASTAR_OBJECT_SCHEMA,
-    ) == COMPATIBLE
+        msg=COMPATIBILIY,
+    )
+    schemas_are_compatible(
+        reader=PROPERTY_ASTAR_OBJECT_SCHEMA,
+        writer=A_OBJECT_SCHEMA,
+        msg=COMPATIBILIY,
+    )
 
     # - writer accept any value for `a`
     # - reader requires it to be an `int`, therefore the other values became
     # invalid
-    assert compatibility(
+    not_schemas_are_compatible(
         reader=A_INT_OBJECT_SCHEMA,
         writer=PROPERTY_ASTAR_OBJECT_SCHEMA,
-    ) != COMPATIBLE
+        msg=INCOMPATIBLE_READER_RESTRICTED_ACCEPTED_VALUES,
+    )
 
     # - writer has property `b`
     # - reader only accepts properties with match regex `a*`
-    assert compatibility(
+    not_schemas_are_compatible(
         reader=PROPERTY_ASTAR_OBJECT_SCHEMA,
         writer=B_INT_OBJECT_SCHEMA,
-    ) != COMPATIBLE
+        msg=INCOMPATIBLE_READER_IS_CLOSED_AND_REMOVED_FIELD,
+    )
 
 
 def test_type_with_list():
     # "type": [] is treated as a shortcut for anyOf
-    assert compatibility(
+    schemas_are_compatible(
         reader=STRING_SCHEMA,
         writer=TYPES_STRING_SCHEMA,
-    ) == COMPATIBLE
-    assert compatibility(
+        msg=COMPATIBLE_READER_EVERY_VALUE_IS_ACCEPTED,
+    )
+    schemas_are_compatible(
         reader=TYPES_STRING_INT_SCHEMA,
         writer=TYPES_STRING_SCHEMA,
-    ) == COMPATIBLE
+        msg=COMPATIBLE_READER_EVERY_VALUE_IS_ACCEPTED,
+    )
 
 
 def test_ref():
-    assert compatibility(
+    schemas_are_compatible(
         reader=ARRAY_OF_POSITIVE_INTEGER,
         writer=ARRAY_OF_POSITIVE_INTEGER_THROUGH_REF,
-    ) == COMPATIBLE
-    assert compatibility(
+        msg="the schemas are the same",
+    )
+    schemas_are_compatible(
         reader=ARRAY_OF_POSITIVE_INTEGER_THROUGH_REF,
         writer=ARRAY_OF_POSITIVE_INTEGER,
-    ) == COMPATIBLE
+        msg="the schemas are the same",
+    )
diff --git a/tests/utils.py b/tests/utils.py
index e1eff7f9f..3a17cc931 100644
--- a/tests/utils.py
+++ b/tests/utils.py
@@ -1,13 +1,14 @@
+from aiohttp.client_exceptions import ClientOSError, ServerDisconnectedError
 from dataclasses import dataclass
 from kafka.errors import TopicAlreadyExistsError
 from karapace.utils import Client
-from unittest.mock import MagicMock
-from urllib.parse import urlparse
+from typing import List
 
+import asyncio
 import copy
 import json
-import os
 import random
+import time
 
 consumer_valid_payload = {
     "format": "avro",
@@ -96,8 +97,10 @@
         "Accept": "application/vnd.kafka.avro.v2+json, application/vnd.kafka.v2+json, application/json, */*"
     },
 }
-REST_URI = "REST_URI"
-REGISTRY_URI = "REGISTRY_URI"
+
+
+class Timeout(Exception):
+    pass
 
 
 @dataclass
@@ -117,10 +120,81 @@ def from_dict(data: dict) -> "KafkaConfig":
         )
 
 
-def get_broker_ip():
-    if REST_URI in os.environ and REGISTRY_URI in os.environ:
-        return urlparse(os.environ[REGISTRY_URI]).hostname
-    return "127.0.0.1"
+@dataclass
+class KafkaServers:
+    bootstrap_servers: List[str]
+
+    def __post_init__(self):
+        is_bootstrap_uris_valid = (
+            isinstance(self.bootstrap_servers, list) and len(self.bootstrap_servers) > 0
+            and all(isinstance(url, str) for url in self.bootstrap_servers)
+        )
+        if not is_bootstrap_uris_valid:
+            raise ValueError("bootstrap_servers must be a non-empty list of urls")
+
+
+@dataclass(frozen=True)
+class Expiration:
+    deadline: float
+
+    @classmethod
+    def from_timeout(cls, timeout: float) -> "Expiration":
+        return cls(time.monotonic() + timeout)
+
+    def raise_if_expired(self, msg: str) -> None:
+        if time.monotonic() > self.deadline:
+            raise Timeout(msg)
+
+
+@dataclass(frozen=True)
+class PortRangeInclusive:
+    start: int
+    end: int
+
+    PRIVILEGE_END = 2 ** 10
+    MAX_PORTS = 2 ** 16 - 1
+
+    def __post_init__(self):
+        # Make sure the range is valid and that we don't need to be root
+        assert self.end > self.start, "there must be at least one port available"
+        assert self.end <= self.MAX_PORTS, f"end must be lower than {self.MAX_PORTS}"
+        assert self.start > self.PRIVILEGE_END, "start must not be a privileged port"
+
+    def next_range(self, number_of_ports: int) -> "PortRangeInclusive":
+        next_start = self.end + 1
+        next_end = next_start + number_of_ports - 1  # -1 because the range is inclusive
+
+        return PortRangeInclusive(next_start, next_end)
+
+
+# To find a good port range use the following:
+#
+#   curl --silent 'https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.txt' | \
+#       egrep -i -e '^\s*[0-9]+-[0-9]+\s*unassigned' | \
+#       awk '{print $1}'
+#
+KAFKA_PORT_RANGE = PortRangeInclusive(48700, 48800)
+ZK_PORT_RANGE = KAFKA_PORT_RANGE.next_range(100)
+REGISTRY_PORT_RANGE = ZK_PORT_RANGE.next_range(100)
+TESTS_PORT_RANGE = REGISTRY_PORT_RANGE.next_range(100)
+
+
+def get_random_port(*, port_range: PortRangeInclusive, blacklist: List[int]) -> int:
+    """ Find a random port in the range `PortRangeInclusive`.
+
+    Note:
+        This function is *not* aware of the ports currently open in the system,
+        the blacklist only prevents two services of the same type to randomly
+        get the same ports for *a single test run*.
+
+        Because of that, the port range should be chosen such that there is no
+        system service in the range. Also note that running two sessions of the
+        tests with the same range is not supported and will lead to flakiness.
+    """
+    value = random.randint(port_range.start, port_range.end)
+    while value in blacklist:
+        value = random.randint(port_range.start, port_range.end)
+    return value
 
 
 async def new_consumer(c, group, fmt="avro", trail=""):
@@ -131,19 +205,7 @@ async def new_consumer(c, group, fmt="avro", trail=""):
     return resp.json()["instance_id"]
 
 
-async def client_for(app, client_factory):
-    if REST_URI in os.environ and REGISTRY_URI in os.environ:
-        # least intrusive way of figuring out which client is which
-        if app.type == "rest":
-            return Client(server_uri=os.environ[REST_URI])
-        return Client(server_uri=os.environ[REGISTRY_URI])
-
-    client_factory = await client_factory(app.app)
-    c = Client(client=client_factory)
-    return c
-
-
-def new_random_name(prefix="topic"):
+def new_random_name(prefix):
     suffix = hash(random.random())
     return f"{prefix}{suffix}"
 
@@ -157,16 +219,46 @@ def new_topic(admin_client, prefix="topic"):
     return tn
 
 
-def mock_factory(app_name):
-    def inner():
-        app = MagicMock()
-        app.type = app_name
-        app.serializer = MagicMock()
-        app.consumer_manager = MagicMock()
-        app.serializer.registry_client = MagicMock()
-        app.consumer_manager.deserializer = MagicMock()
-        app.consumer_manager.hostname = "http://localhost:8082"
-        app.consumer_manager.deserializer.registry_client = MagicMock()
-        return app, None
+async def wait_for_topics(rest_async_client: Client, topic_names: List[str], timeout: float, sleep: float) -> None:
+    for topic in topic_names:
+        expiration = Expiration.from_timeout(timeout=timeout)
+        topic_found = False
+        current_topics = None
+
+        while not topic_found:
+            await asyncio.sleep(sleep)
+            expiration.raise_if_expired(msg=f"New topic {topic} must be in the result of /topics. Result={current_topics}")
+            res = await rest_async_client.get("/topics")
+            assert res.ok, f"Status code is not 200: {res.status_code}"
+            current_topics = res.json()
+            topic_found = topic in current_topics
+
+
+async def repeat_until_successful_request(
+    callback, path: str, json_data, headers, error_msg: str, timeout: float, sleep: float
+):
+    expiration = Expiration.from_timeout(timeout=timeout)
+    ok = False
+    res = None
+
+    try:
+        res = await callback(path, json=json_data, headers=headers)
+    # ClientOSError: Raised when the listening socket is not yet open in the server
+    # ServerDisconnectedError: Wrong url
+    except (ClientOSError, ServerDisconnectedError):
+        pass
+    else:
+        ok = res.ok
+
+    while not ok:
+        await asyncio.sleep(sleep)
+        expiration.raise_if_expired(msg=f"{error_msg} {res} after {timeout} secs")
+
+        try:
+            res = await callback(path, json=json_data, headers=headers)
+        except (ClientOSError, ServerDisconnectedError):
+            pass
+        else:
+            ok = res.ok
 
-    return inner
+    return res