diff --git a/ext/opentelemetry-ext-dbapi/setup.cfg b/ext/opentelemetry-ext-dbapi/setup.cfg
index 125812c96d8..53fe066dfd5 100644
--- a/ext/opentelemetry-ext-dbapi/setup.cfg
+++ b/ext/opentelemetry-ext-dbapi/setup.cfg
@@ -43,5 +43,9 @@ install_requires =
     opentelemetry-api == 0.7.dev0
     wrapt >= 1.0.0, < 2.0.0
 
+[options.extras_require]
+test =
+    opentelemetry-test == 0.7.dev0
+
 [options.packages.find]
 where = src
diff --git a/ext/opentelemetry-ext-dbapi/tests/test_dbapi_integration.py b/ext/opentelemetry-ext-dbapi/tests/test_dbapi_integration.py
index f0773788bce..9d894a2ccbd 100644
--- a/ext/opentelemetry-ext-dbapi/tests/test_dbapi_integration.py
+++ b/ext/opentelemetry-ext-dbapi/tests/test_dbapi_integration.py
@@ -12,29 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import unittest
-from unittest import mock
-
 from opentelemetry import trace as trace_api
 from opentelemetry.ext.dbapi import DatabaseApiIntegration
+from opentelemetry.test.test_base import TestBase
 
 
-class TestDBApiIntegration(unittest.TestCase):
+class TestDBApiIntegration(TestBase):
     def setUp(self):
-        self.tracer = trace_api.DefaultTracer()
-        self.span = MockSpan()
-        self.start_current_span_patcher = mock.patch.object(
-            self.tracer,
-            "start_as_current_span",
-            autospec=True,
-            spec_set=True,
-            return_value=self.span,
-        )
-
-        self.start_as_current_span = self.start_current_span_patcher.start()
-
-    def tearDown(self):
-        self.start_current_span_patcher.stop()
+        super().setUp()
+        self.tracer = self.tracer_provider.get_tracer(__name__)
 
     def test_span_succeeded(self):
         connection_props = {
@@ -57,28 +43,25 @@ def test_span_succeeded(self):
         )
         cursor = mock_connection.cursor()
         cursor.execute("Test query", ("param1Value", False))
-        self.assertTrue(self.start_as_current_span.called)
+        spans_list = self.memory_exporter.get_finished_spans()
+        self.assertEqual(len(spans_list), 1)
+        span = spans_list[0]
+        self.assertEqual(span.name, "testcomponent.testdatabase")
+        self.assertIs(span.kind, trace_api.SpanKind.CLIENT)
+
+        self.assertEqual(span.attributes["component"], "testcomponent")
+        self.assertEqual(span.attributes["db.type"], "testtype")
+        self.assertEqual(span.attributes["db.instance"], "testdatabase")
+        self.assertEqual(span.attributes["db.statement"], "Test query")
         self.assertEqual(
-            self.start_as_current_span.call_args[0][0],
-            "testcomponent.testdatabase",
-        )
-        self.assertIs(
-            self.start_as_current_span.call_args[1]["kind"],
-            trace_api.SpanKind.CLIENT,
-        )
-        self.assertEqual(self.span.attributes["component"], "testcomponent")
-        self.assertEqual(self.span.attributes["db.type"], "testtype")
-        self.assertEqual(self.span.attributes["db.instance"], "testdatabase")
-        self.assertEqual(self.span.attributes["db.statement"], "Test query")
-        self.assertEqual(
-            self.span.attributes["db.statement.parameters"],
+            span.attributes["db.statement.parameters"],
             "('param1Value', False)",
         )
-        self.assertEqual(self.span.attributes["db.user"], "testuser")
-        self.assertEqual(self.span.attributes["net.peer.name"], "testhost")
-        self.assertEqual(self.span.attributes["net.peer.port"], 123)
+        self.assertEqual(span.attributes["db.user"], "testuser")
+        self.assertEqual(span.attributes["net.peer.name"], "testhost")
+        self.assertEqual(span.attributes["net.peer.port"], 123)
         self.assertIs(
-            self.span.status.canonical_code,
+            span.status.canonical_code,
             trace_api.status.StatusCanonicalCode.OK,
         )
 
@@ -88,17 +71,18 @@ def test_span_failed(self):
             mock_connect, {}, {}
         )
         cursor = mock_connection.cursor()
-        try:
+        with self.assertRaises(Exception):
             cursor.execute("Test query", throw_exception=True)
-        except Exception:  # pylint: disable=broad-except
-            self.assertEqual(
-                self.span.attributes["db.statement"], "Test query"
-            )
-            self.assertIs(
-                self.span.status.canonical_code,
-                trace_api.status.StatusCanonicalCode.UNKNOWN,
-            )
-            self.assertEqual(self.span.status.description, "Test Exception")
+
+        spans_list = self.memory_exporter.get_finished_spans()
+        self.assertEqual(len(spans_list), 1)
+        span = spans_list[0]
+        self.assertEqual(span.attributes["db.statement"], "Test query")
+        self.assertIs(
+            span.status.canonical_code,
+            trace_api.status.StatusCanonicalCode.UNKNOWN,
+        )
+        self.assertEqual(span.status.description, "Test Exception")
 
     def test_executemany(self):
         db_integration = DatabaseApiIntegration(self.tracer, "testcomponent")
@@ -107,8 +91,10 @@ def test_executemany(self):
         )
         cursor = mock_connection.cursor()
         cursor.executemany("Test query")
-        self.assertTrue(self.start_as_current_span.called)
-        self.assertEqual(self.span.attributes["db.statement"], "Test query")
+        spans_list = self.memory_exporter.get_finished_spans()
+        self.assertEqual(len(spans_list), 1)
+        span = spans_list[0]
+        self.assertEqual(span.attributes["db.statement"], "Test query")
 
     def test_callproc(self):
         db_integration = DatabaseApiIntegration(self.tracer, "testcomponent")
@@ -117,9 +103,11 @@ def test_callproc(self):
         )
         cursor = mock_connection.cursor()
         cursor.callproc("Test stored procedure")
-        self.assertTrue(self.start_as_current_span.called)
+        spans_list = self.memory_exporter.get_finished_spans()
+        self.assertEqual(len(spans_list), 1)
+        span = spans_list[0]
         self.assertEqual(
-            self.span.attributes["db.statement"], "Test stored procedure"
+            span.attributes["db.statement"], "Test stored procedure"
         )
 
 
@@ -159,23 +147,3 @@ def executemany(self, query, params=None, throw_exception=False):
     def callproc(self, query, params=None, throw_exception=False):
         if throw_exception:
             raise Exception("Test Exception")
-
-
-class MockSpan:
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        return False
-
-    def __init__(self):
-        self.status = None
-        self.name = ""
-        self.kind = trace_api.SpanKind.INTERNAL
-        self.attributes = {}
-
-    def set_attribute(self, key, value):
-        self.attributes[key] = value
-
-    def set_status(self, status):
-        self.status = status
diff --git a/ext/opentelemetry-ext-docker-tests/tests/mysql/test_mysql_functional.py b/ext/opentelemetry-ext-docker-tests/tests/mysql/test_mysql_functional.py
index 305bea00bf1..c0790396b09 100644
--- a/ext/opentelemetry-ext-docker-tests/tests/mysql/test_mysql_functional.py
+++ b/ext/opentelemetry-ext-docker-tests/tests/mysql/test_mysql_functional.py
@@ -14,17 +14,12 @@
 
 import os
 import time
-import unittest
 
 import mysql.connector
 
 from opentelemetry import trace as trace_api
 from opentelemetry.ext.mysql import trace_integration
-from opentelemetry.sdk.trace import Tracer, TracerProvider
-from opentelemetry.sdk.trace.export import SimpleExportSpanProcessor
-from opentelemetry.sdk.trace.export.in_memory_span_exporter import (
-    InMemorySpanExporter,
-)
+from opentelemetry.test.test_base import TestBase
 
 MYSQL_USER = os.getenv("MYSQL_USER ", "testuser")
 MYSQL_PASSWORD = os.getenv("MYSQL_PASSWORD ", "testpassword")
@@ -33,16 +28,13 @@
 MYSQL_DB_NAME = os.getenv("MYSQL_DB_NAME ", "opentelemetry-tests")
 
 
-class TestFunctionalMysql(unittest.TestCase):
+class TestFunctionalMysql(TestBase):
     @classmethod
     def setUpClass(cls):
+        super().setUpClass()
         cls._connection = None
         cls._cursor = None
-        cls._tracer_provider = TracerProvider()
-        cls._tracer = Tracer(cls._tracer_provider, None)
-        cls._span_exporter = InMemorySpanExporter()
-        cls._span_processor = SimpleExportSpanProcessor(cls._span_exporter)
-        cls._tracer_provider.add_span_processor(cls._span_processor)
+        cls._tracer = cls.tracer_provider.get_tracer(__name__)
         trace_integration(cls._tracer)
         cls._connection = mysql.connector.connect(
             user=MYSQL_USER,
@@ -58,11 +50,8 @@ def tearDownClass(cls):
         if cls._connection:
             cls._connection.close()
 
-    def setUp(self):
-        self._span_exporter.clear()
-
     def validate_spans(self):
-        spans = self._span_exporter.get_finished_spans()
+        spans = self.memory_exporter.get_finished_spans()
         self.assertEqual(len(spans), 2)
         for span in spans:
             if span.name == "rootSpan":
diff --git a/ext/opentelemetry-ext-docker-tests/tests/postgres/test_psycopg_functional.py b/ext/opentelemetry-ext-docker-tests/tests/postgres/test_psycopg_functional.py
index d58e332c1bc..a0ddfcae15b 100644
--- a/ext/opentelemetry-ext-docker-tests/tests/postgres/test_psycopg_functional.py
+++ b/ext/opentelemetry-ext-docker-tests/tests/postgres/test_psycopg_functional.py
@@ -14,17 +14,12 @@
 
 import os
 import time
-import unittest
 
 import psycopg2
 
 from opentelemetry import trace as trace_api
 from opentelemetry.ext.psycopg2 import trace_integration
-from opentelemetry.sdk.trace import Tracer, TracerProvider
-from opentelemetry.sdk.trace.export import SimpleExportSpanProcessor
-from opentelemetry.sdk.trace.export.in_memory_span_exporter import (
-    InMemorySpanExporter,
-)
+from opentelemetry.test.test_base import TestBase
 
 POSTGRES_HOST = os.getenv("POSTGRESQL_HOST ", "localhost")
 POSTGRES_PORT = int(os.getenv("POSTGRESQL_PORT ", "5432"))
@@ -33,16 +28,13 @@
 POSTGRES_USER = os.getenv("POSTGRESQL_HOST ", "testuser")
 
 
-class TestFunctionalPsycopg(unittest.TestCase):
+class TestFunctionalPsycopg(TestBase):
     @classmethod
     def setUpClass(cls):
+        super().setUpClass()
         cls._connection = None
         cls._cursor = None
-        cls._tracer_provider = TracerProvider()
-        cls._tracer = Tracer(cls._tracer_provider, None)
-        cls._span_exporter = InMemorySpanExporter()
-        cls._span_processor = SimpleExportSpanProcessor(cls._span_exporter)
-        cls._tracer_provider.add_span_processor(cls._span_processor)
+        cls._tracer = cls.tracer_provider.get_tracer(__name__)
         trace_integration(cls._tracer)
         cls._connection = psycopg2.connect(
             dbname=POSTGRES_DB_NAME,
@@ -61,11 +53,8 @@ def tearDownClass(cls):
         if cls._connection:
             cls._connection.close()
 
-    def setUp(self):
-        self._span_exporter.clear()
-
     def validate_spans(self):
-        spans = self._span_exporter.get_finished_spans()
+        spans = self.memory_exporter.get_finished_spans()
         self.assertEqual(len(spans), 2)
         for span in spans:
             if span.name == "rootSpan":
diff --git a/ext/opentelemetry-ext-docker-tests/tests/pymongo/test_pymongo_functional.py b/ext/opentelemetry-ext-docker-tests/tests/pymongo/test_pymongo_functional.py
index 7b018dab253..6f6a728e519 100644
--- a/ext/opentelemetry-ext-docker-tests/tests/pymongo/test_pymongo_functional.py
+++ b/ext/opentelemetry-ext-docker-tests/tests/pymongo/test_pymongo_functional.py
@@ -13,18 +13,12 @@
 # limitations under the License.
 
 import os
-import typing
-import unittest
 
 from pymongo import MongoClient
 
 from opentelemetry import trace as trace_api
 from opentelemetry.ext.pymongo import trace_integration
-from opentelemetry.sdk.trace import Span, Tracer, TracerProvider
-from opentelemetry.sdk.trace.export import SimpleExportSpanProcessor
-from opentelemetry.sdk.trace.export.in_memory_span_exporter import (
-    InMemorySpanExporter,
-)
+from opentelemetry.test.test_base import TestBase
 
 MONGODB_HOST = os.getenv("MONGODB_HOST ", "localhost")
 MONGODB_PORT = int(os.getenv("MONGODB_PORT ", "27017"))
@@ -32,14 +26,11 @@
 MONGODB_COLLECTION_NAME = "test"
 
 
-class TestFunctionalPymongo(unittest.TestCase):
+class TestFunctionalPymongo(TestBase):
     @classmethod
     def setUpClass(cls):
-        cls._tracer_provider = TracerProvider()
-        cls._tracer = Tracer(cls._tracer_provider, None)
-        cls._span_exporter = InMemorySpanExporter()
-        cls._span_processor = SimpleExportSpanProcessor(cls._span_exporter)
-        cls._tracer_provider.add_span_processor(cls._span_processor)
+        super().setUpClass()
+        cls._tracer = cls.tracer_provider.get_tracer(__name__)
         trace_integration(cls._tracer)
         client = MongoClient(
             MONGODB_HOST, MONGODB_PORT, serverSelectionTimeoutMS=2000
@@ -47,11 +38,8 @@ def setUpClass(cls):
         db = client[MONGODB_DB_NAME]
         cls._collection = db[MONGODB_COLLECTION_NAME]
 
-    def setUp(self):
-        self._span_exporter.clear()
-
     def validate_spans(self):
-        spans = self._span_exporter.get_finished_spans()
+        spans = self.memory_exporter.get_finished_spans()
         self.assertEqual(len(spans), 2)
         for span in spans:
             if span.name == "rootSpan":
diff --git a/ext/opentelemetry-ext-grpc/setup.cfg b/ext/opentelemetry-ext-grpc/setup.cfg
index 211cf465533..f774ddc6c5a 100644
--- a/ext/opentelemetry-ext-grpc/setup.cfg
+++ b/ext/opentelemetry-ext-grpc/setup.cfg
@@ -43,5 +43,10 @@ install_requires =
     opentelemetry-api == 0.7.dev0
     grpcio ~= 1.27
 
+[options.extras_require]
+test =
+    opentelemetry-test == 0.7.dev0
+    opentelemetry-sdk == 0.7.dev0
+
 [options.packages.find]
 where = src
diff --git a/ext/opentelemetry-ext-grpc/tests/test_server_interceptor.py b/ext/opentelemetry-ext-grpc/tests/test_server_interceptor.py
index 8dabd11fdf0..74ce9babab7 100644
--- a/ext/opentelemetry-ext-grpc/tests/test_server_interceptor.py
+++ b/ext/opentelemetry-ext-grpc/tests/test_server_interceptor.py
@@ -16,10 +16,7 @@
 # pylint:disable=no-self-use
 
 import threading
-import unittest
 from concurrent import futures
-from contextlib import contextmanager
-from unittest import mock
 
 import grpc
 
@@ -27,6 +24,7 @@
 from opentelemetry.ext.grpc import server_interceptor
 from opentelemetry.ext.grpc.grpcext import intercept_server
 from opentelemetry.sdk import trace as trace_sdk
+from opentelemetry.test.test_base import TestBase
 
 
 class UnaryUnaryMethodHandler(grpc.RpcMethodHandler):
@@ -49,18 +47,16 @@ def service(self, handler_call_details):
         return UnaryUnaryMethodHandler(self._unary_unary_handler)
 
 
-class TestOpenTelemetryServerInterceptor(unittest.TestCase):
+class TestOpenTelemetryServerInterceptor(TestBase):
+    def setUp(self):
+        super().setUp()
+        self.tracer = self.tracer_provider.get_tracer(__name__)
+
     def test_create_span(self):
         """Check that the interceptor wraps calls with spans server-side."""
 
-        @contextmanager
-        def mock_start_as_current_span(*args, **kwargs):
-            yield mock.Mock(spec=trace.Span)
-
         # Intercept gRPC calls...
-        tracer = mock.Mock(spec=trace.Tracer)
-        tracer.start_as_current_span.side_effect = mock_start_as_current_span
-        interceptor = server_interceptor(tracer)
+        interceptor = server_interceptor(self.tracer)
 
         # No-op RPC handler
         def handler(request, context):
@@ -84,9 +80,12 @@ def handler(request, context):
         finally:
             server.stop(None)
 
-        tracer.start_as_current_span.assert_called_once_with(
-            name="", kind=trace.SpanKind.SERVER
-        )
+        spans_list = self.memory_exporter.get_finished_spans()
+        self.assertEqual(len(spans_list), 1)
+        span = spans_list[0]
+
+        self.assertEqual(span.name, "")
+        self.assertIs(span.kind, trace.SpanKind.SERVER)
 
     def test_span_lifetime(self):
         """Check that the span is active for the duration of the call."""
diff --git a/ext/opentelemetry-ext-http-requests/tests/test_requests_integration.py b/ext/opentelemetry-ext-http-requests/tests/test_requests_integration.py
index 441ce74e06c..67de0692f1d 100644
--- a/ext/opentelemetry-ext-http-requests/tests/test_requests_integration.py
+++ b/ext/opentelemetry-ext-http-requests/tests/test_requests_integration.py
@@ -88,6 +88,8 @@ def test_disable(self):
         span_list = self.memory_exporter.get_finished_spans()
         self.assertEqual(len(span_list), 0)
 
+        opentelemetry.ext.http_requests.disable()
+
     def test_disable_session(self):
         session1 = requests.Session()
         opentelemetry.ext.http_requests.disable_session(session1)
diff --git a/ext/opentelemetry-ext-mysql/setup.cfg b/ext/opentelemetry-ext-mysql/setup.cfg
index 37fb0b5b61c..3da2aad0f01 100644
--- a/ext/opentelemetry-ext-mysql/setup.cfg
+++ b/ext/opentelemetry-ext-mysql/setup.cfg
@@ -41,8 +41,12 @@ package_dir=
 packages=find_namespace:
 install_requires =
     opentelemetry-api == 0.7.dev0
-    mysql-connector-python ~=  8.0
+    mysql-connector-python ~= 8.0
     wrapt >= 1.0.0, < 2.0.0
 
+[options.extras_require]
+test =
+    opentelemetry-test == 0.7.dev0
+
 [options.packages.find]
 where = src
diff --git a/ext/opentelemetry-ext-mysql/tests/test_mysql_integration.py b/ext/opentelemetry-ext-mysql/tests/test_mysql_integration.py
index b4f1a006a19..150f9f51f99 100644
--- a/ext/opentelemetry-ext-mysql/tests/test_mysql_integration.py
+++ b/ext/opentelemetry-ext-mysql/tests/test_mysql_integration.py
@@ -12,27 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import unittest
 from unittest import mock
 
 import mysql.connector
 
-from opentelemetry import trace as trace_api
 from opentelemetry.ext.mysql import trace_integration
+from opentelemetry.test.test_base import TestBase
 
 
-class TestMysqlIntegration(unittest.TestCase):
+class TestMysqlIntegration(TestBase):
     def test_trace_integration(self):
-        tracer = trace_api.DefaultTracer()
-        span = mock.create_autospec(trace_api.Span, spec_set=True)
-        start_current_span_patcher = mock.patch.object(
-            tracer,
-            "start_as_current_span",
-            autospec=True,
-            spec_set=True,
-            return_value=span,
-        )
-        start_as_current_span = start_current_span_patcher.start()
+        tracer = self.tracer_provider.get_tracer(__name__)
 
         with mock.patch("mysql.connector.connect") as mock_connect:
             mock_connect.get.side_effect = mysql.connector.MySQLConnection()
@@ -41,4 +31,5 @@ def test_trace_integration(self):
             cursor = cnx.cursor()
             query = "SELECT * FROM test"
             cursor.execute(query)
-            self.assertTrue(start_as_current_span.called)
+            spans_list = self.memory_exporter.get_finished_spans()
+            self.assertEqual(len(spans_list), 1)
diff --git a/ext/opentelemetry-ext-pymongo/setup.cfg b/ext/opentelemetry-ext-pymongo/setup.cfg
index 236715c3d5e..790ea8bff2b 100644
--- a/ext/opentelemetry-ext-pymongo/setup.cfg
+++ b/ext/opentelemetry-ext-pymongo/setup.cfg
@@ -43,5 +43,9 @@ install_requires =
     opentelemetry-api == 0.7.dev0
     pymongo ~= 3.1
 
+[options.extras_require]
+test =
+    opentelemetry-test == 0.7.dev0
+
 [options.packages.find]
 where = src
diff --git a/ext/opentelemetry-ext-pymongo/tests/test_pymongo.py b/ext/opentelemetry-ext-pymongo/tests/test_pymongo.py
index 8c82e016792..197c4d02666 100644
--- a/ext/opentelemetry-ext-pymongo/tests/test_pymongo.py
+++ b/ext/opentelemetry-ext-pymongo/tests/test_pymongo.py
@@ -12,23 +12,25 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import unittest
 from unittest import mock
 
 from opentelemetry import trace as trace_api
 from opentelemetry.ext.pymongo import CommandTracer, trace_integration
-from opentelemetry.util import time_ns
+from opentelemetry.test.test_base import TestBase
 
 
-class TestPymongo(unittest.TestCase):
+class TestPymongo(TestBase):
+    def setUp(self):
+        super().setUp()
+        self.tracer = self.tracer_provider.get_tracer(__name__)
+
     def test_trace_integration(self):
         mock_register = mock.Mock()
         patch = mock.patch(
             "pymongo.monitoring.register", side_effect=mock_register
         )
-        mock_tracer = MockTracer()
         with patch:
-            trace_integration(mock_tracer)
+            trace_integration(self.tracer)
 
         self.assertTrue(mock_register.called)
 
@@ -40,12 +42,13 @@ def test_started(self):
             "pipeline": "pipeline",
             "command_name": "find",
         }
-        mock_tracer = MockTracer()
-        command_tracer = CommandTracer(mock_tracer)
+        command_tracer = CommandTracer(self.tracer)
         mock_event = MockEvent(
             command_attrs, ("test.com", "1234"), "test_request_id"
         )
         command_tracer.started(event=mock_event)
+        # the memory exporter can't be used here because the span isn't ended
+        # yet
         # pylint: disable=protected-access
         span = command_tracer._get_span(mock_event)
         self.assertIs(span.kind, trace_api.SpanKind.CLIENT)
@@ -69,13 +72,13 @@ def test_started(self):
         self.assertEqual(span.attributes["db.mongo.pipeline"], "pipeline")
 
     def test_succeeded(self):
-        mock_tracer = MockTracer()
         mock_event = MockEvent({})
-        command_tracer = CommandTracer(mock_tracer)
+        command_tracer = CommandTracer(self.tracer)
         command_tracer.started(event=mock_event)
-        # pylint: disable=protected-access
-        span = command_tracer._get_span(mock_event)
         command_tracer.succeeded(event=mock_event)
+        spans_list = self.memory_exporter.get_finished_spans()
+        self.assertEqual(len(spans_list), 1)
+        span = spans_list[0]
         self.assertEqual(
             span.attributes["db.mongo.duration_micros"], "duration_micros"
         )
@@ -86,13 +89,15 @@ def test_succeeded(self):
         self.assertIsNotNone(span.end_time)
 
     def test_failed(self):
-        mock_tracer = MockTracer()
         mock_event = MockEvent({})
-        command_tracer = CommandTracer(mock_tracer)
+        command_tracer = CommandTracer(self.tracer)
         command_tracer.started(event=mock_event)
-        # pylint: disable=protected-access
-        span = command_tracer._get_span(mock_event)
         command_tracer.failed(event=mock_event)
+
+        spans_list = self.memory_exporter.get_finished_spans()
+        self.assertEqual(len(spans_list), 1)
+        span = spans_list[0]
+
         self.assertEqual(
             span.attributes["db.mongo.duration_micros"], "duration_micros"
         )
@@ -104,19 +109,19 @@ def test_failed(self):
         self.assertIsNotNone(span.end_time)
 
     def test_multiple_commands(self):
-        mock_tracer = MockTracer()
         first_mock_event = MockEvent({}, ("firstUrl", "123"), "first")
         second_mock_event = MockEvent({}, ("secondUrl", "456"), "second")
-        command_tracer = CommandTracer(mock_tracer)
+        command_tracer = CommandTracer(self.tracer)
         command_tracer.started(event=first_mock_event)
-        # pylint: disable=protected-access
-        first_span = command_tracer._get_span(first_mock_event)
         command_tracer.started(event=second_mock_event)
-        # pylint: disable=protected-access
-        second_span = command_tracer._get_span(second_mock_event)
         command_tracer.succeeded(event=first_mock_event)
         command_tracer.failed(event=second_mock_event)
 
+        spans_list = self.memory_exporter.get_finished_spans()
+        self.assertEqual(len(spans_list), 2)
+        first_span = spans_list[0]
+        second_span = spans_list[1]
+
         self.assertEqual(first_span.attributes["db.mongo.request_id"], "first")
         self.assertIs(
             first_span.status.canonical_code,
@@ -147,41 +152,3 @@ def __init__(self, command_attrs, connection_id=None, request_id=""):
 
     def __getattr__(self, item):
         return item
-
-
-class MockSpan:
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        return False
-
-    def __init__(self):
-        self.status = None
-        self.name = ""
-        self.kind = trace_api.SpanKind.INTERNAL
-        self.attributes = None
-        self.end_time = None
-
-    def set_attribute(self, key, value):
-        self.attributes[key] = value
-
-    def set_status(self, status):
-        self.status = status
-
-    def end(self, end_time=None):
-        self.end_time = end_time if end_time is not None else time_ns()
-
-
-class MockTracer:
-    def __init__(self):
-        self.end_span = mock.Mock()
-
-    # pylint: disable=no-self-use
-    def start_span(self, name, kind):
-        span = MockSpan()
-        span.attributes = {}
-        span.status = None
-        span.name = name
-        span.kind = kind
-        return span
diff --git a/tox.ini b/tox.ini
index 9d1d1a26cc7..dc7f20aa8d1 100644
--- a/tox.ini
+++ b/tox.ini
@@ -131,50 +131,52 @@ changedir =
 commands_pre =
 ; Install without -e to test the actual installation
   python -m pip install -U pip setuptools wheel
+
+; Install common packages for all the tests. These are not needed in all the
+; cases but it saves a lot of boilerplate in this file.
   test: pip install {toxinidir}/opentelemetry-api
-  test-sdk: pip install {toxinidir}/opentelemetry-sdk
+  test: pip install {toxinidir}/opentelemetry-sdk
+  test: pip install {toxinidir}/tests/util
+
   test-auto-instrumentation: pip install {toxinidir}/opentelemetry-auto-instrumentation
-  example-app: pip install {toxinidir}/opentelemetry-sdk
+
   example-app: pip install {toxinidir}/opentelemetry-auto-instrumentation
   example-app: pip install {toxinidir}/ext/opentelemetry-ext-http-requests
   example-app: pip install {toxinidir}/ext/opentelemetry-ext-wsgi
   example-app: pip install {toxinidir}/ext/opentelemetry-ext-flask
   example-app: pip install {toxinidir}/docs/examples/opentelemetry-example-app
-  example-basic-tracer: pip install -e {toxinidir}/opentelemetry-api
-  example-basic-tracer: pip install -e {toxinidir}/opentelemetry-sdk
-  example-http: pip install -e {toxinidir}/opentelemetry-api
-  example-http: pip install -e {toxinidir}/opentelemetry-sdk
+
   example-http: pip install -e {toxinidir}/ext/opentelemetry-ext-http-requests
   example-http: pip install -e {toxinidir}/ext/opentelemetry-ext-wsgi
   example-http: pip install -r {toxinidir}/docs/examples/http/requirements.txt
 
-  ext: pip install {toxinidir}/opentelemetry-api
-  grpc: pip install {toxinidir}/ext/opentelemetry-ext-grpc
-  grpc: pip install {toxinidir}/opentelemetry-sdk
-  wsgi,flask: pip install {toxinidir}/tests/util
+  grpc: pip install {toxinidir}/ext/opentelemetry-ext-grpc[test]
+
   wsgi,flask: pip install {toxinidir}/ext/opentelemetry-ext-wsgi
-  wsgi,flask: pip install {toxinidir}/opentelemetry-sdk
+
   flask: pip install {toxinidir}/opentelemetry-auto-instrumentation
   flask: pip install {toxinidir}/ext/opentelemetry-ext-flask[test]
-  dbapi: pip install {toxinidir}/ext/opentelemetry-ext-dbapi
+
+  dbapi: pip install {toxinidir}/ext/opentelemetry-ext-dbapi[test]
+
   mysql: pip install {toxinidir}/ext/opentelemetry-ext-dbapi
-  mysql: pip install {toxinidir}/ext/opentelemetry-ext-mysql
-  otcollector: pip install {toxinidir}/opentelemetry-sdk
+  mysql: pip install {toxinidir}/ext/opentelemetry-ext-mysql[test]
+
   otcollector: pip install {toxinidir}/ext/opentelemetry-ext-otcollector
-  prometheus: pip install {toxinidir}/opentelemetry-sdk
+
   prometheus: pip install {toxinidir}/ext/opentelemetry-ext-prometheus
-  pymongo: pip install {toxinidir}/ext/opentelemetry-ext-pymongo
+
+  pymongo: pip install {toxinidir}/ext/opentelemetry-ext-pymongo[test]
+
   psycopg2: pip install {toxinidir}/ext/opentelemetry-ext-dbapi
   psycopg2: pip install {toxinidir}/ext/opentelemetry-ext-psycopg2
-  http-requests: pip install {toxinidir}/ext/opentelemetry-ext-http-requests
-  http-requests: pip install {toxinidir}/tests/util
-  http-requests: pip install {toxinidir}/opentelemetry-sdk
+
   http-requests: pip install {toxinidir}/ext/opentelemetry-ext-http-requests[test]
-  jaeger: pip install {toxinidir}/opentelemetry-sdk
+
   jaeger: pip install {toxinidir}/ext/opentelemetry-ext-jaeger
-  opentracing-shim: pip install {toxinidir}/opentelemetry-sdk {toxinidir}/ext/opentelemetry-ext-opentracing-shim
-  opentracing-shim: pip install {toxinidir}/tests/util
-  zipkin: pip install {toxinidir}/opentelemetry-sdk
+
+  opentracing-shim: pip install {toxinidir}/ext/opentelemetry-ext-opentracing-shim
+
   zipkin: pip install {toxinidir}/ext/opentelemetry-ext-zipkin
 
 ; In order to get a healthy coverage report,
@@ -274,6 +276,7 @@ changedir =
 commands_pre =
   pip install -e {toxinidir}/opentelemetry-api \
               -e {toxinidir}/opentelemetry-sdk \
+              -e {toxinidir}/tests/util \
               -e {toxinidir}/ext/opentelemetry-ext-dbapi \
               -e {toxinidir}/ext/opentelemetry-ext-mysql \
               -e {toxinidir}/ext/opentelemetry-ext-psycopg2 \