diff --git a/tests/clients/test_cassandra-driver.py b/tests/clients/test_cassandra-driver.py
index 44f05a21..3493de14 100644
--- a/tests/clients/test_cassandra-driver.py
+++ b/tests/clients/test_cassandra-driver.py
@@ -1,268 +1,271 @@
 # (c) Copyright IBM Corp. 2021
 # (c) Copyright Instana Inc. 2020
 
-import os
-import time
 import random
-import unittest
-
-from instana.singletons import agent, tracer
-from ..helpers import testenv, get_first_span_by_name
+import time
+from typing import Generator
 
-from cassandra.cluster import Cluster
+import pytest
 from cassandra import ConsistencyLevel
+from cassandra.cluster import Cluster
 from cassandra.query import SimpleStatement
 
-cluster = Cluster([testenv['cassandra_host']], load_balancing_policy=None)
+from instana.singletons import agent, tracer
+from tests.helpers import get_first_span_by_name, testenv
+
+cluster = Cluster([testenv["cassandra_host"]], load_balancing_policy=None)
 session = cluster.connect()
 
 session.execute(
-    "CREATE KEYSPACE IF NOT EXISTS instana_tests WITH replication = {'class':'SimpleStrategy', 'replication_factor':1};")
-session.set_keyspace('instana_tests')
-session.execute("CREATE TABLE IF NOT EXISTS users("
-                "id int PRIMARY KEY,"
-                "name text,"
-                "age text,"
-                "email varint,"
-                "phone varint"
-                ");")
-
-
-@unittest.skipUnless(os.environ.get("CASSANDRA_TEST"), reason="")
-class TestCassandra(unittest.TestCase):
-    def setUp(self):
-        """ Clear all spans before a test run """
-        self.recorder = tracer.recorder
+    "CREATE KEYSPACE IF NOT EXISTS instana_tests WITH replication = {'class':'SimpleStrategy', 'replication_factor':1};"
+)
+session.set_keyspace("instana_tests")
+session.execute(
+    "CREATE TABLE IF NOT EXISTS users("
+    "id int PRIMARY KEY,"
+    "name text,"
+    "age text,"
+    "email varint,"
+    "phone varint"
+    ");"
+)
+
+
+class TestCassandra:
+    @pytest.fixture(autouse=True)
+    def _resource(self) -> Generator[None, None, None]:
+        """Clear all spans before a test run"""
+        self.recorder = tracer.span_processor
         self.recorder.clear_spans()
-
-    def tearDown(self):
-        """ Ensure that allow_exit_as_root has the default value """
+        yield
         agent.options.allow_exit_as_root = False
 
-    def test_untraced_execute(self):
-        res = session.execute('SELECT name, age, email FROM users')
+    def test_untraced_execute(self) -> None:
+        res = session.execute("SELECT name, age, email FROM users")
 
-        self.assertIsNotNone(res)
+        assert res
 
         time.sleep(0.5)
 
         spans = self.recorder.queued_spans()
-        self.assertEqual(0, len(spans))
+        assert len(spans) == 0
 
-    def test_untraced_execute_error(self):
+    def test_untraced_execute_error(self) -> None:
         res = None
         try:
-            res = session.execute('Not a valid query')
-        except:
+            res = session.execute("Not a valid query")
+        except Exception:
             pass
 
-        self.assertIsNone(res)
+        assert not res
 
         time.sleep(0.5)
 
         spans = self.recorder.queued_spans()
-        self.assertEqual(0, len(spans))
+        assert len(spans) == 0
 
-    def test_execute(self):
+    def test_execute(self) -> None:
         res = None
-        with tracer.start_active_span('test'):
-            res = session.execute('SELECT name, age, email FROM users')
+        with tracer.start_as_current_span("test"):
+            res = session.execute("SELECT name, age, email FROM users")
 
-        self.assertIsNotNone(res)
+        assert res
 
         time.sleep(0.5)
 
         spans = self.recorder.queued_spans()
-        self.assertEqual(2, len(spans))
+        assert len(spans) == 2
 
-        test_span = get_first_span_by_name(spans, 'sdk')
-        self.assertIsNotNone(test_span)
-        self.assertEqual(test_span.data["sdk"]["name"], 'test')
+        test_span = get_first_span_by_name(spans, "sdk")
+        assert test_span
+        assert test_span.data["sdk"]["name"] == "test"
 
-        cspan = get_first_span_by_name(spans, 'cassandra')
-        self.assertIsNotNone(cspan)
+        cspan = get_first_span_by_name(spans, "cassandra")
+        assert cspan
 
         # Same traceId and parent relationship
-        self.assertEqual(test_span.t, cspan.t)
-        self.assertEqual(cspan.p, test_span.s)
+        assert cspan.t == test_span.t
+        assert cspan.p == test_span.s
 
-        self.assertIsNotNone(cspan.stack)
-        self.assertIsNone(cspan.ec)
+        assert cspan.stack
+        assert not cspan.ec
 
-        self.assertEqual(cspan.data["cassandra"]["cluster"], 'Test Cluster')
-        self.assertEqual(cspan.data["cassandra"]["query"], 'SELECT name, age, email FROM users')
-        self.assertEqual(cspan.data["cassandra"]["keyspace"], 'instana_tests')
-        self.assertIsNone(cspan.data["cassandra"]["achievedConsistency"])
-        self.assertIsNotNone(cspan.data["cassandra"]["triedHosts"])
-        self.assertIsNone(cspan.data["cassandra"]["error"])
+        assert cspan.data["cassandra"]["cluster"] == "Test Cluster"
+        assert cspan.data["cassandra"]["query"] == "SELECT name, age, email FROM users"
+        assert cspan.data["cassandra"]["keyspace"] == "instana_tests"
+        assert not cspan.data["cassandra"]["achievedConsistency"]
+        assert cspan.data["cassandra"]["triedHosts"]
+        assert not cspan.data["cassandra"]["error"]
 
-    def test_execute_as_root_exit_span(self):
+    def test_execute_as_root_exit_span(self) -> None:
         agent.options.allow_exit_as_root = True
-        res = session.execute('SELECT name, age, email FROM users')
+        res = session.execute("SELECT name, age, email FROM users")
 
-        self.assertIsNotNone(res)
+        assert res
 
         time.sleep(0.5)
 
         spans = self.recorder.queued_spans()
-        self.assertEqual(1, len(spans))
+        assert len(spans) == 1
 
-        cspan = get_first_span_by_name(spans, 'cassandra')
-        self.assertIsNotNone(cspan)
+        cspan = get_first_span_by_name(spans, "cassandra")
+        assert cspan
 
-        self.assertIsNone(cspan.p)
+        assert not cspan.p
 
-        self.assertIsNotNone(cspan.stack)
-        self.assertIsNone(cspan.ec)
+        assert cspan.stack
+        assert not cspan.ec
 
-        self.assertEqual(cspan.data["cassandra"]["cluster"], 'Test Cluster')
-        self.assertEqual(cspan.data["cassandra"]["query"], 'SELECT name, age, email FROM users')
-        self.assertEqual(cspan.data["cassandra"]["keyspace"], 'instana_tests')
-        self.assertIsNone(cspan.data["cassandra"]["achievedConsistency"])
-        self.assertIsNotNone(cspan.data["cassandra"]["triedHosts"])
-        self.assertIsNone(cspan.data["cassandra"]["error"])
+        assert cspan.data["cassandra"]["cluster"] == "Test Cluster"
+        assert cspan.data["cassandra"]["query"] == "SELECT name, age, email FROM users"
+        assert cspan.data["cassandra"]["keyspace"] == "instana_tests"
+        assert not cspan.data["cassandra"]["achievedConsistency"]
+        assert cspan.data["cassandra"]["triedHosts"]
+        assert not cspan.data["cassandra"]["error"]
 
-    def test_execute_async(self):
+    def test_execute_async(self) -> None:
         res = None
-        with tracer.start_active_span('test'):
-            res = session.execute_async('SELECT name, age, email FROM users').result()
+        with tracer.start_as_current_span("test"):
+            res = session.execute_async("SELECT name, age, email FROM users").result()
 
-        self.assertIsNotNone(res)
+        assert res
 
         time.sleep(0.5)
 
         spans = self.recorder.queued_spans()
-        self.assertEqual(2, len(spans))
+        assert len(spans) == 2
 
-        test_span = get_first_span_by_name(spans, 'sdk')
-        self.assertIsNotNone(test_span)
-        self.assertEqual(test_span.data["sdk"]["name"], 'test')
+        test_span = get_first_span_by_name(spans, "sdk")
+        assert test_span
+        assert test_span.data["sdk"]["name"] == "test"
 
-        cspan = get_first_span_by_name(spans, 'cassandra')
-        self.assertIsNotNone(cspan)
+        cspan = get_first_span_by_name(spans, "cassandra")
+        assert cspan
 
         # Same traceId and parent relationship
-        self.assertEqual(test_span.t, cspan.t)
-        self.assertEqual(cspan.p, test_span.s)
+        assert cspan.t == test_span.t
+        assert cspan.p == test_span.s
 
-        self.assertIsNotNone(cspan.stack)
-        self.assertIsNone(cspan.ec)
+        assert cspan.stack
+        assert not cspan.ec
 
-        self.assertEqual(cspan.data["cassandra"]["cluster"], 'Test Cluster')
-        self.assertEqual(cspan.data["cassandra"]["query"], 'SELECT name, age, email FROM users')
-        self.assertEqual(cspan.data["cassandra"]["keyspace"], 'instana_tests')
-        self.assertIsNone(cspan.data["cassandra"]["achievedConsistency"])
-        self.assertIsNotNone(cspan.data["cassandra"]["triedHosts"])
-        self.assertIsNone(cspan.data["cassandra"]["error"])
+        assert cspan.data["cassandra"]["cluster"] == "Test Cluster"
+        assert cspan.data["cassandra"]["query"] == "SELECT name, age, email FROM users"
+        assert cspan.data["cassandra"]["keyspace"] == "instana_tests"
+        assert not cspan.data["cassandra"]["achievedConsistency"]
+        assert cspan.data["cassandra"]["triedHosts"]
+        assert not cspan.data["cassandra"]["error"]
 
-    def test_simple_statement(self):
+    def test_simple_statement(self) -> None:
         res = None
-        with tracer.start_active_span('test'):
+        with tracer.start_as_current_span("test"):
             query = SimpleStatement(
-                'SELECT name, age, email FROM users',
-                is_idempotent=True
+                "SELECT name, age, email FROM users", is_idempotent=True
             )
             res = session.execute(query)
 
-        self.assertIsNotNone(res)
+        assert res
 
         time.sleep(0.5)
 
         spans = self.recorder.queued_spans()
-        self.assertEqual(2, len(spans))
+        assert len(spans) == 2
 
-        test_span = get_first_span_by_name(spans, 'sdk')
-        self.assertIsNotNone(test_span)
-        self.assertEqual(test_span.data["sdk"]["name"], 'test')
+        test_span = get_first_span_by_name(spans, "sdk")
+        assert test_span
+        assert test_span.data["sdk"]["name"] == "test"
 
-        cspan = get_first_span_by_name(spans, 'cassandra')
-        self.assertIsNotNone(cspan)
+        cspan = get_first_span_by_name(spans, "cassandra")
+        assert cspan
 
         # Same traceId and parent relationship
-        self.assertEqual(test_span.t, cspan.t)
-        self.assertEqual(cspan.p, test_span.s)
+        assert cspan.t == test_span.t
+        assert cspan.p == test_span.s
 
-        self.assertIsNotNone(cspan.stack)
-        self.assertIsNone(cspan.ec)
+        assert cspan.stack
+        assert not cspan.ec
 
-        self.assertEqual(cspan.data["cassandra"]["cluster"], 'Test Cluster')
-        self.assertEqual(cspan.data["cassandra"]["query"], 'SELECT name, age, email FROM users')
-        self.assertEqual(cspan.data["cassandra"]["keyspace"], 'instana_tests')
-        self.assertIsNone(cspan.data["cassandra"]["achievedConsistency"])
-        self.assertIsNotNone(cspan.data["cassandra"]["triedHosts"])
-        self.assertIsNone(cspan.data["cassandra"]["error"])
+        assert cspan.data["cassandra"]["cluster"] == "Test Cluster"
+        assert cspan.data["cassandra"]["query"] == "SELECT name, age, email FROM users"
+        assert cspan.data["cassandra"]["keyspace"] == "instana_tests"
+        assert not cspan.data["cassandra"]["achievedConsistency"]
+        assert cspan.data["cassandra"]["triedHosts"]
+        assert not cspan.data["cassandra"]["error"]
 
-    def test_execute_error(self):
+    def test_execute_error(self) -> None:
         res = None
 
         try:
-            with tracer.start_active_span('test'):
-                res = session.execute('Not a real query')
-        except:
+            with tracer.start_as_current_span("test"):
+                res = session.execute("Not a real query")
+        except Exception:
             pass
 
-        self.assertIsNone(res)
+        assert not res
 
         time.sleep(0.5)
 
         spans = self.recorder.queued_spans()
-        self.assertEqual(2, len(spans))
+        assert len(spans) == 2
 
-        test_span = get_first_span_by_name(spans, 'sdk')
-        self.assertIsNotNone(test_span)
-        self.assertEqual(test_span.data["sdk"]["name"], 'test')
+        test_span = get_first_span_by_name(spans, "sdk")
+        assert test_span
+        assert test_span.data["sdk"]["name"] == "test"
 
-        cspan = get_first_span_by_name(spans, 'cassandra')
-        self.assertIsNotNone(cspan)
+        cspan = get_first_span_by_name(spans, "cassandra")
+        assert cspan
 
         # Same traceId and parent relationship
-        self.assertEqual(test_span.t, cspan.t)
-        self.assertEqual(cspan.p, test_span.s)
+        assert cspan.t == test_span.t
+        assert cspan.p == test_span.s
 
-        self.assertIsNotNone(cspan.stack)
-        self.assertEqual(cspan.ec, 1)
+        assert cspan.stack
+        assert cspan.ec == 1
 
-        self.assertEqual(cspan.data["cassandra"]["cluster"], 'Test Cluster')
-        self.assertEqual(cspan.data["cassandra"]["query"], 'Not a real query')
-        self.assertEqual(cspan.data["cassandra"]["keyspace"], 'instana_tests')
-        self.assertIsNone(cspan.data["cassandra"]["achievedConsistency"])
-        self.assertIsNotNone(cspan.data["cassandra"]["triedHosts"])
-        self.assertEqual(cspan.data["cassandra"]["error"], "Syntax error in CQL query")
+        assert cspan.data["cassandra"]["cluster"] == "Test Cluster"
+        assert cspan.data["cassandra"]["query"] == "Not a real query"
+        assert cspan.data["cassandra"]["keyspace"] == "instana_tests"
+        assert not cspan.data["cassandra"]["achievedConsistency"]
+        assert cspan.data["cassandra"]["triedHosts"]
+        assert cspan.data["cassandra"]["error"] == "Syntax error in CQL query"
 
-    def test_prepared_statement(self):
+    def test_prepared_statement(self) -> None:
         prepared = None
-        result = None
 
-        with tracer.start_active_span('test'):
-            prepared = session.prepare('INSERT INTO users (id, name, age) VALUES (?, ?, ?)')
+        with tracer.start_as_current_span("test"):
+            prepared = session.prepare(
+                "INSERT INTO users (id, name, age) VALUES (?, ?, ?)"
+            )
             prepared.consistency_level = ConsistencyLevel.QUORUM
-            result = session.execute(prepared, (random.randint(0, 1000000), "joe", "17"))
+            session.execute(prepared, (random.randint(0, 1000000), "joe", "17"))
 
-        self.assertIsNotNone(prepared)
-        self.assertIsNotNone(result)
+        assert prepared
 
         time.sleep(0.5)
 
         spans = self.recorder.queued_spans()
-        self.assertEqual(2, len(spans))
+        assert len(spans) == 2
 
-        test_span = get_first_span_by_name(spans, 'sdk')
-        self.assertIsNotNone(test_span)
-        self.assertEqual(test_span.data["sdk"]["name"], 'test')
+        test_span = get_first_span_by_name(spans, "sdk")
+        assert test_span
+        assert test_span.data["sdk"]["name"] == "test"
 
-        cspan = get_first_span_by_name(spans, 'cassandra')
-        self.assertIsNotNone(cspan)
+        cspan = get_first_span_by_name(spans, "cassandra")
+        assert cspan
 
         # Same traceId and parent relationship
-        self.assertEqual(test_span.t, cspan.t)
-        self.assertEqual(cspan.p, test_span.s)
-
-        self.assertIsNotNone(cspan.stack)
-        self.assertIsNone(cspan.ec)
-
-        self.assertEqual(cspan.data["cassandra"]["cluster"], 'Test Cluster')
-        self.assertEqual(cspan.data["cassandra"]["query"], 'INSERT INTO users (id, name, age) VALUES (?, ?, ?)')
-        self.assertEqual(cspan.data["cassandra"]["keyspace"], 'instana_tests')
-        self.assertEqual(cspan.data["cassandra"]["achievedConsistency"], "QUORUM")
-        self.assertIsNotNone(cspan.data["cassandra"]["triedHosts"])
-        self.assertIsNone(cspan.data["cassandra"]["error"])
+        assert test_span.t == cspan.t
+        assert cspan.p == test_span.s
+
+        assert cspan.stack
+        assert not cspan.ec
+
+        assert cspan.data["cassandra"]["cluster"] == "Test Cluster"
+        assert (
+            cspan.data["cassandra"]["query"]
+            == "INSERT INTO users (id, name, age) VALUES (?, ?, ?)"
+        )
+        assert cspan.data["cassandra"]["keyspace"] == "instana_tests"
+        assert cspan.data["cassandra"]["achievedConsistency"] == "QUORUM"
+        assert cspan.data["cassandra"]["triedHosts"]
+        assert not cspan.data["cassandra"]["error"]
diff --git a/tests/conftest.py b/tests/conftest.py
index b73954b1..7c5f6d7e 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -37,7 +37,6 @@
 
 # TODO: remove the following entries as the migration of the instrumentation
 # codes are finalised.
-collect_ignore_glob.append("*clients/test_cassandra*")
 collect_ignore_glob.append("*clients/test_couchbase*")
 collect_ignore_glob.append("*clients/test_google*")
 collect_ignore_glob.append("*clients/test_pika*")
@@ -53,8 +52,8 @@
 
 # # Cassandra and gevent tests are run in dedicated jobs on CircleCI and will
 # # be run explicitly.  (So always exclude them here)
-# if not os.environ.get("CASSANDRA_TEST"):
-#     collect_ignore_glob.append("*test_cassandra*")
+if not os.environ.get("CASSANDRA_TEST"):
+    collect_ignore_glob.append("*test_cassandra*")
 
 # if not os.environ.get("COUCHBASE_TEST"):
 #     collect_ignore_glob.append("*test_couchbase*")