diff --git a/cms/djangoapps/contentstore/management/commands/migrate_to_split.py b/cms/djangoapps/contentstore/management/commands/migrate_to_split.py
deleted file mode 100644
index 38fed6265c0c..000000000000
--- a/cms/djangoapps/contentstore/management/commands/migrate_to_split.py
+++ /dev/null
@@ -1,57 +0,0 @@
-"""
-Django management command to migrate a course from the old Mongo modulestore
-to the new split-Mongo modulestore.
-"""
-
-
-from django.contrib.auth.models import User  # lint-amnesty, pylint: disable=imported-auth-user
-from django.core.management.base import BaseCommand, CommandError
-from opaque_keys import InvalidKeyError
-from opaque_keys.edx.keys import CourseKey
-
-from cms.djangoapps.contentstore.management.commands.utils import user_from_str
-from xmodule.modulestore import ModuleStoreEnum  # lint-amnesty, pylint: disable=wrong-import-order
-from xmodule.modulestore.django import modulestore  # lint-amnesty, pylint: disable=wrong-import-order
-from xmodule.modulestore.split_migrator import SplitMigrator  # lint-amnesty, pylint: disable=wrong-import-order
-
-
-class Command(BaseCommand):
-    """
-    Migrate a course from old-Mongo to split-Mongo. It reuses the old course id except where overridden.
-    """
-
-    help = "Migrate a course from old-Mongo to split-Mongo. The new org, course, and run will " \
-           "default to the old one unless overridden."
-
-    def add_arguments(self, parser):
-        parser.add_argument('course_key')
-        parser.add_argument('email')
-        parser.add_argument('--org', help='New org to migrate to.')
-        parser.add_argument('--course', help='New course key to migrate to.')
-        parser.add_argument('--run', help='New run to migrate to.')
-
-    def parse_args(self, **options):
-        """
-        Return a 5-tuple of passed in values for (course_key, user, org, course, run).
-        """
-        try:
-            course_key = CourseKey.from_string(options['course_key'])
-        except InvalidKeyError:
-            raise CommandError("Invalid location string")  # lint-amnesty, pylint: disable=raise-missing-from
-
-        try:
-            user = user_from_str(options['email'])
-        except User.DoesNotExist:
-            raise CommandError("No user found identified by {}".format(options['email']))  # lint-amnesty, pylint: disable=raise-missing-from
-
-        return course_key, user.id, options['org'], options['course'], options['run']
-
-    def handle(self, *args, **options):
-        course_key, user, org, course, run = self.parse_args(**options)
-
-        migrator = SplitMigrator(
-            source_modulestore=modulestore(),
-            split_modulestore=modulestore()._get_modulestore_by_type(ModuleStoreEnum.Type.split),  # lint-amnesty, pylint: disable=protected-access
-        )
-
-        migrator.migrate_mongo_course(course_key, user, org, course, run)
diff --git a/cms/djangoapps/contentstore/management/commands/tests/test_backfill_course_outlines.py b/cms/djangoapps/contentstore/management/commands/tests/test_backfill_course_outlines.py
index 1aaa4de9fa1b..12a0eae32c9d 100644
--- a/cms/djangoapps/contentstore/management/commands/tests/test_backfill_course_outlines.py
+++ b/cms/djangoapps/contentstore/management/commands/tests/test_backfill_course_outlines.py
@@ -6,7 +6,6 @@
 
 from openedx.core.djangoapps.content.course_overviews.models import CourseOverview
 from openedx.core.djangoapps.content.learning_sequences.api import get_course_keys_with_outlines
-from xmodule.modulestore import ModuleStoreEnum  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.tests.django_utils import SharedModuleStoreTestCase  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory  # lint-amnesty, pylint: disable=wrong-import-order
 
@@ -40,47 +39,41 @@ def setUpClass(cls):
         """
         super().setUpClass()
         course_run_ids = [
-            "OpenEdX/OutlineCourse/OldMongoRun1",
+            "course-v1:OpenEdX+OutlineCourse+Run1",
             "course-v1:OpenEdX+OutlineCourse+Run2",
-            "course-v1:OpenEdX+OutlineCourse+Run3",
         ]
         cls.course_keys = [
             CourseKey.from_string(course_run_id) for course_run_id in course_run_ids
         ]
         for course_key in cls.course_keys:
-            if course_key.deprecated:
-                store_type = ModuleStoreEnum.Type.mongo
-            else:
-                store_type = ModuleStoreEnum.Type.split
 
-            with cls.store.default_store(store_type):
-                course = CourseFactory.create(
-                    org=course_key.org,
-                    number=course_key.course,
-                    run=course_key.run,
-                    display_name=f"Outline Backfill Test Course {course_key.run}"
+            course = CourseFactory.create(
+                org=course_key.org,
+                number=course_key.course,
+                run=course_key.run,
+                display_name=f"Outline Backfill Test Course {course_key.run}"
+            )
+            with cls.store.bulk_operations(course_key):
+                section = ItemFactory.create(
+                    parent=course,
+                    category="chapter",
+                    display_name="A Section"
+                )
+                sequence = ItemFactory.create(
+                    parent=section,
+                    category="sequential",
+                    display_name="A Sequence"
+                )
+                unit = ItemFactory.create(
+                    parent=sequence,
+                    category="vertical",
+                    display_name="A Unit"
+                )
+                ItemFactory.create(
+                    parent=unit,
+                    category="html",
+                    display_name="An HTML Module"
                 )
-                with cls.store.bulk_operations(course_key):
-                    section = ItemFactory.create(
-                        parent=course,
-                        category="chapter",
-                        display_name="A Section"
-                    )
-                    sequence = ItemFactory.create(
-                        parent=section,
-                        category="sequential",
-                        display_name="A Sequence"
-                    )
-                    unit = ItemFactory.create(
-                        parent=sequence,
-                        category="vertical",
-                        display_name="A Unit"
-                    )
-                    ItemFactory.create(
-                        parent=unit,
-                        category="html",
-                        display_name="An HTML Module"
-                    )
 
     def test_end_to_end(self):
         """Normal invocation, it should skip only the Old Mongo course."""
@@ -91,8 +84,8 @@ def test_end_to_end(self):
         call_command("backfill_course_outlines")
         course_keys_with_outlines = set(get_course_keys_with_outlines())
         assert course_keys_with_outlines == {
+            CourseKey.from_string("course-v1:OpenEdX+OutlineCourse+Run1"),
             CourseKey.from_string("course-v1:OpenEdX+OutlineCourse+Run2"),
-            CourseKey.from_string("course-v1:OpenEdX+OutlineCourse+Run3"),
         }
 
     def test_partial(self):
@@ -102,16 +95,16 @@ def test_partial(self):
 
         # Manually create one
         update_outline_from_modulestore(
-            CourseKey.from_string("course-v1:OpenEdX+OutlineCourse+Run2")
+            CourseKey.from_string("course-v1:OpenEdX+OutlineCourse+Run1")
         )
         assert set(get_course_keys_with_outlines()) == {
-            CourseKey.from_string("course-v1:OpenEdX+OutlineCourse+Run2")
+            CourseKey.from_string("course-v1:OpenEdX+OutlineCourse+Run1")
         }
 
         # backfill command should fill in the other
         call_command("backfill_course_outlines")
         course_keys_with_outlines = set(get_course_keys_with_outlines())
         assert course_keys_with_outlines == {
+            CourseKey.from_string("course-v1:OpenEdX+OutlineCourse+Run1"),
             CourseKey.from_string("course-v1:OpenEdX+OutlineCourse+Run2"),
-            CourseKey.from_string("course-v1:OpenEdX+OutlineCourse+Run3"),
         }
diff --git a/cms/djangoapps/contentstore/management/commands/tests/test_cleanup_assets.py b/cms/djangoapps/contentstore/management/commands/tests/test_cleanup_assets.py
index dfed3bb69caa..47698bfeaf84 100644
--- a/cms/djangoapps/contentstore/management/commands/tests/test_cleanup_assets.py
+++ b/cms/djangoapps/contentstore/management/commands/tests/test_cleanup_assets.py
@@ -4,6 +4,8 @@
 """
 
 
+from unittest import skip
+
 from django.conf import settings
 from django.core.management import call_command
 from opaque_keys.edx.keys import CourseKey
@@ -20,6 +22,7 @@
 TEST_DATA_DIR = settings.COMMON_TEST_DATA_ROOT
 
 
+@skip("OldMongo Deprecation")
 class ExportAllCourses(ModuleStoreTestCase):
     """
     Tests assets cleanup for all courses.
diff --git a/cms/djangoapps/contentstore/management/commands/tests/test_create_course.py b/cms/djangoapps/contentstore/management/commands/tests/test_create_course.py
index 40d1493f94b3..a0b216357515 100644
--- a/cms/djangoapps/contentstore/management/commands/tests/test_create_course.py
+++ b/cms/djangoapps/contentstore/management/commands/tests/test_create_course.py
@@ -46,21 +46,23 @@ class TestCreateCourse(ModuleStoreTestCase):
     Unit tests for creating a course in either old mongo or split mongo via command line
     """
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_all_stores_user_email(self, store):
+    def test_all_stores_user_email(self):
         call_command(
             "create_course",
-            store,
+            ModuleStoreEnum.Type.split,
             str(self.user.email),
             "org", "course", "run", "dummy-course-name"
         )
         new_key = modulestore().make_course_key("org", "course", "run")
         self.assertTrue(
             modulestore().has_course(new_key),
-            f"Could not find course in {store}"
+            f"Could not find course in {ModuleStoreEnum.Type.split}"
         )
         # pylint: disable=protected-access
-        self.assertEqual(store, modulestore()._get_modulestore_for_courselike(new_key).get_modulestore_type())
+        self.assertEqual(
+            ModuleStoreEnum.Type.split,
+            modulestore()._get_modulestore_for_courselike(new_key).get_modulestore_type()
+        )
 
     def test_duplicate_course(self):
         """
@@ -85,8 +87,7 @@ def test_duplicate_course(self):
         expected = "Course already exists"
         self.assertIn(out.getvalue().strip(), expected)
 
-    @ddt.data(ModuleStoreEnum.Type.split, ModuleStoreEnum.Type.mongo)
-    def test_get_course_with_different_case(self, default_store):
+    def test_get_course_with_different_case(self):
         """
         Tests that course can not be accessed with different case.
 
@@ -98,21 +99,20 @@ def test_get_course_with_different_case(self, default_store):
         org = 'org1'
         number = 'course1'
         run = 'run1'
-        with self.store.default_store(default_store):
-            lowercase_course_id = self.store.make_course_key(org, number, run)
-            with self.store.bulk_operations(lowercase_course_id, ignore_case=True):
-                # Create course with lowercase key & Verify that store returns course.
-                self.store.create_course(
-                    lowercase_course_id.org,
-                    lowercase_course_id.course,
-                    lowercase_course_id.run,
-                    self.user.id
-                )
-                course = self.store.get_course(lowercase_course_id)
-                self.assertIsNotNone(course, 'Course not found using lowercase course key.')
-                self.assertEqual(str(course.id), str(lowercase_course_id))
-
-                # Verify store does not return course with different case.
-                uppercase_course_id = self.store.make_course_key(org.upper(), number.upper(), run.upper())
-                course = self.store.get_course(uppercase_course_id)
-                self.assertIsNone(course, 'Course should not be accessed with uppercase course id.')
+        lowercase_course_id = self.store.make_course_key(org, number, run)
+        with self.store.bulk_operations(lowercase_course_id, ignore_case=True):
+            # Create course with lowercase key & Verify that store returns course.
+            self.store.create_course(
+                lowercase_course_id.org,
+                lowercase_course_id.course,
+                lowercase_course_id.run,
+                self.user.id
+            )
+            course = self.store.get_course(lowercase_course_id)
+            self.assertIsNotNone(course, 'Course not found using lowercase course key.')
+            self.assertEqual(str(course.id), str(lowercase_course_id))
+
+            # Verify store does not return course with different case.
+            uppercase_course_id = self.store.make_course_key(org.upper(), number.upper(), run.upper())
+            course = self.store.get_course(uppercase_course_id)
+            self.assertIsNone(course, 'Course should not be accessed with uppercase course id.')
diff --git a/cms/djangoapps/contentstore/management/commands/tests/test_delete_orphans.py b/cms/djangoapps/contentstore/management/commands/tests/test_delete_orphans.py
index 33ae814a7faf..99f9d9de4324 100644
--- a/cms/djangoapps/contentstore/management/commands/tests/test_delete_orphans.py
+++ b/cms/djangoapps/contentstore/management/commands/tests/test_delete_orphans.py
@@ -23,26 +23,24 @@ def test_no_args(self):
         with self.assertRaisesRegex(CommandError, errstring):
             call_command('delete_orphans')
 
-    @ddt.data(ModuleStoreEnum.Type.split, ModuleStoreEnum.Type.mongo)
-    def test_delete_orphans_no_commit(self, default_store):
+    def test_delete_orphans_no_commit(self):
         """
         Tests that running the command without a '--commit' argument
         results in no orphans being deleted
         """
-        course = self.create_course_with_orphans(default_store)
+        course = self.create_course_with_orphans(ModuleStoreEnum.Type.split)
         call_command('delete_orphans', str(course.id))
         self.assertTrue(self.store.has_item(course.id.make_usage_key('html', 'multi_parent_html')))
         self.assertTrue(self.store.has_item(course.id.make_usage_key('vertical', 'OrphanVert')))
         self.assertTrue(self.store.has_item(course.id.make_usage_key('chapter', 'OrphanChapter')))
         self.assertTrue(self.store.has_item(course.id.make_usage_key('html', 'OrphanHtml')))
 
-    @ddt.data(ModuleStoreEnum.Type.split, ModuleStoreEnum.Type.mongo)
-    def test_delete_orphans_commit(self, default_store):
+    def test_delete_orphans_commit(self):
         """
         Tests that running the command WITH the '--commit' argument
         results in the orphans being deleted
         """
-        course = self.create_course_with_orphans(default_store)
+        course = self.create_course_with_orphans(ModuleStoreEnum.Type.split)
 
         call_command('delete_orphans', str(course.id), '--commit')
 
diff --git a/cms/djangoapps/contentstore/management/commands/tests/test_export.py b/cms/djangoapps/contentstore/management/commands/tests/test_export.py
index d73286517dd7..4514d8755db0 100644
--- a/cms/djangoapps/contentstore/management/commands/tests/test_export.py
+++ b/cms/djangoapps/contentstore/management/commands/tests/test_export.py
@@ -45,16 +45,15 @@ def setUp(self):
         self.addCleanup(shutil.rmtree, self.temp_dir_1)
         self.addCleanup(shutil.rmtree, self.temp_dir_2)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_export_course_with_directory_name(self, store):
+    def test_export_course_with_directory_name(self):
         """
         Create a new course try exporting in a path specified
         """
-        course = CourseFactory.create(default_store=store)
+        course = CourseFactory.create()
         course_id = str(course.id)
         self.assertTrue(
             modulestore().has_course(course.id),
-            f"Could not find course in {store}"
+            f"Could not find course in {ModuleStoreEnum.Type.split}"
         )
         # Test `export` management command with invalid course_id
         errstring = "Invalid course_key: 'InvalidCourseID'."
diff --git a/cms/djangoapps/contentstore/management/commands/tests/test_export_all_courses.py b/cms/djangoapps/contentstore/management/commands/tests/test_export_all_courses.py
index 262becacbfe5..086d84301828 100644
--- a/cms/djangoapps/contentstore/management/commands/tests/test_export_all_courses.py
+++ b/cms/djangoapps/contentstore/management/commands/tests/test_export_all_courses.py
@@ -5,6 +5,7 @@
 
 import shutil
 from tempfile import mkdtemp
+from unittest import skip
 
 from cms.djangoapps.contentstore.management.commands.export_all_courses import export_courses_to_output_path
 from xmodule.modulestore import ModuleStoreEnum  # lint-amnesty, pylint: disable=wrong-import-order
@@ -13,6 +14,7 @@
 from xmodule.modulestore.tests.factories import CourseFactory  # lint-amnesty, pylint: disable=wrong-import-order
 
 
+@skip("OldMongo Deprecation")
 class ExportAllCourses(ModuleStoreTestCase):
     """
     Tests exporting all courses.
diff --git a/cms/djangoapps/contentstore/management/commands/tests/test_export_olx.py b/cms/djangoapps/contentstore/management/commands/tests/test_export_olx.py
index 3dea23778535..8d2c2ff5b669 100644
--- a/cms/djangoapps/contentstore/management/commands/tests/test_export_olx.py
+++ b/cms/djangoapps/contentstore/management/commands/tests/test_export_olx.py
@@ -74,9 +74,8 @@ def check_export_file(self, tar_file, course_key):
         self.assertIn(f"{dirname}/assets/assets.xml", names)
         self.assertIn(f"{dirname}/policies", names)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_export_course(self, store_type):
-        test_course_key = self.create_dummy_course(store_type)
+    def test_export_course(self):
+        test_course_key = self.create_dummy_course(ModuleStoreEnum.Type.split)
         tmp_dir = path(mkdtemp())
         self.addCleanup(shutil.rmtree, tmp_dir)
         filename = tmp_dir / 'test.tar.gz'
@@ -91,9 +90,8 @@ def test_export_course(self, store_type):
     # django this is fixed.  Howevere it's not possible to get this test to
     # pass in Python3 and django 1.11
     @unittest.skip("Bug in django 1.11 prevents this from working in python3.  Re-enable after django 2.x upgrade.")
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
     def test_export_course_stdout(self, store_type):
-        test_course_key = self.create_dummy_course(store_type)
+        test_course_key = self.create_dummy_course(ModuleStoreEnum.Type.split)
         out = StringIO()
         call_command('export_olx', str(test_course_key), stdout=out)
         out.seek(0)
diff --git a/cms/djangoapps/contentstore/management/commands/tests/test_fix_not_found.py b/cms/djangoapps/contentstore/management/commands/tests/test_fix_not_found.py
index c3c016aa1590..042baf89e08f 100644
--- a/cms/djangoapps/contentstore/management/commands/tests/test_fix_not_found.py
+++ b/cms/djangoapps/contentstore/management/commands/tests/test_fix_not_found.py
@@ -23,14 +23,6 @@ def test_no_args(self):
         with self.assertRaisesRegex(CommandError, msg):
             call_command('fix_not_found')
 
-    def test_fix_not_found_non_split(self):
-        """
-        The management command doesn't work on non split courses
-        """
-        course = CourseFactory.create(default_store=ModuleStoreEnum.Type.mongo)
-        with self.assertRaisesRegex(CommandError, "The owning modulestore does not support this command."):
-            call_command("fix_not_found", str(course.id))
-
     def test_fix_not_found(self):
         course = CourseFactory.create(default_store=ModuleStoreEnum.Type.split)
         ItemFactory.create(category='chapter', parent_location=course.location)
diff --git a/cms/djangoapps/contentstore/management/commands/tests/test_force_publish.py b/cms/djangoapps/contentstore/management/commands/tests/test_force_publish.py
index b6c78b60232e..8baecc954a4e 100644
--- a/cms/djangoapps/contentstore/management/commands/tests/test_force_publish.py
+++ b/cms/djangoapps/contentstore/management/commands/tests/test_force_publish.py
@@ -58,15 +58,6 @@ def test_course_key_not_found(self):
         with self.assertRaisesRegex(CommandError, errstring):
             call_command('force_publish', 'course-v1:org+course+run')
 
-    def test_force_publish_non_split(self):
-        """
-        Test 'force_publish' command doesn't work on non split courses
-        """
-        course = CourseFactory.create(default_store=ModuleStoreEnum.Type.mongo)
-        errstring = 'The owning modulestore does not support this command.'
-        with self.assertRaisesRegex(CommandError, errstring):
-            call_command('force_publish', str(course.id))
-
 
 class TestForcePublishModifications(ModuleStoreTestCase):
     """
diff --git a/cms/djangoapps/contentstore/management/commands/tests/test_git_export.py b/cms/djangoapps/contentstore/management/commands/tests/test_git_export.py
index 8a2334b34375..330cf65424c4 100644
--- a/cms/djangoapps/contentstore/management/commands/tests/test_git_export.py
+++ b/cms/djangoapps/contentstore/management/commands/tests/test_git_export.py
@@ -128,6 +128,7 @@ def test_bad_git_repos(self):
                 course_key,
                 'https://user:blah@example.com/r.git')
 
+    @unittest.skip("OldMongo Deprecation")
     @unittest.skipIf(os.environ.get('GIT_CONFIG') or
                      os.environ.get('GIT_AUTHOR_EMAIL') or
                      os.environ.get('GIT_AUTHOR_NAME') or
diff --git a/cms/djangoapps/contentstore/management/commands/tests/test_import.py b/cms/djangoapps/contentstore/management/commands/tests/test_import.py
index 3e00def45852..5b90973b0463 100644
--- a/cms/djangoapps/contentstore/management/commands/tests/test_import.py
+++ b/cms/djangoapps/contentstore/management/commands/tests/test_import.py
@@ -11,7 +11,6 @@
 from path import Path as path
 
 from openedx.core.djangoapps.django_comment_common.utils import are_permissions_roles_seeded
-from xmodule.modulestore import ModuleStoreEnum  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.django import modulestore  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase  # lint-amnesty, pylint: disable=wrong-import-order
 
@@ -73,23 +72,3 @@ def test_truncated_course_with_url(self):
         # Now load up the course with a similar course_id and verify it loads
         call_command('import', self.content_dir, self.course_dir)
         self.assertIsNotNone(store.get_course(self.truncated_key))
-
-    def test_existing_course_with_different_modulestore(self):
-        """
-        Checks that a course that originally existed in old mongo can be re-imported when
-        split is the default modulestore.
-        """
-        with modulestore().default_store(ModuleStoreEnum.Type.mongo):
-            call_command('import', self.content_dir, self.good_dir)
-
-        # Clear out the modulestore mappings, else when the next import command goes to create a destination
-        # course_key, it will find the existing course and return the mongo course_key. To reproduce TNL-1362,
-        # the destination course_key needs to be the one for split modulestore.
-        modulestore().mappings = {}
-
-        with modulestore().default_store(ModuleStoreEnum.Type.split):
-            call_command('import', self.content_dir, self.good_dir)
-            course = modulestore().get_course(self.base_course_key)
-            # With the bug, this fails because the chapter's course_key is the split mongo form,
-            # while the course's course_key is the old mongo form.
-            self.assertEqual(str(course.location.course_key), str(course.children[0].course_key))
diff --git a/cms/djangoapps/contentstore/management/commands/tests/test_migrate_to_split.py b/cms/djangoapps/contentstore/management/commands/tests/test_migrate_to_split.py
deleted file mode 100644
index ba67bf28a3ea..000000000000
--- a/cms/djangoapps/contentstore/management/commands/tests/test_migrate_to_split.py
+++ /dev/null
@@ -1,119 +0,0 @@
-"""
-Unittests for migrating a course to split mongo
-"""
-
-
-from django.core.management import CommandError, call_command
-from django.test import TestCase
-
-from xmodule.modulestore import ModuleStoreEnum
-from xmodule.modulestore.django import modulestore
-from xmodule.modulestore.exceptions import ItemNotFoundError
-from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
-from xmodule.modulestore.tests.factories import CourseFactory
-
-
-class TestArgParsing(TestCase):
-    """
-    Tests for parsing arguments for the `migrate_to_split` management command
-    """
-    def setUp(self):  # lint-amnesty, pylint: disable=useless-super-delegation
-        super().setUp()
-
-    def test_no_args(self):
-        """
-        Test the arg length error
-        """
-        errstring = "Error: the following arguments are required: course_key, email"
-        with self.assertRaisesRegex(CommandError, errstring):
-            call_command("migrate_to_split")
-
-    def test_invalid_location(self):
-        """
-        Test passing an unparsable course id
-        """
-        errstring = "Invalid location string"
-        with self.assertRaisesRegex(CommandError, errstring):
-            call_command("migrate_to_split", "foo", "bar")
-
-    def test_nonexistent_user_id(self):
-        """
-        Test error for using an unknown user primary key
-        """
-        errstring = "No user found identified by 99"
-        with self.assertRaisesRegex(CommandError, errstring):
-            call_command("migrate_to_split", "org/course/name", "99")
-
-    def test_nonexistent_user_email(self):
-        """
-        Test error for using an unknown user email
-        """
-        errstring = "No user found identified by fake@example.com"
-        with self.assertRaisesRegex(CommandError, errstring):
-            call_command("migrate_to_split", "org/course/name", "fake@example.com")
-
-
-# pylint: disable=protected-access
-class TestMigrateToSplit(ModuleStoreTestCase):
-    """
-    Unit tests for migrating a course from old mongo to split mongo
-    """
-
-    def setUp(self):
-        super().setUp()
-        self.course = CourseFactory(default_store=ModuleStoreEnum.Type.mongo)
-
-    def test_user_email(self):
-        """
-        Test migration for real as well as testing using an email addr to id the user
-        """
-        call_command(
-            "migrate_to_split",
-            str(self.course.id),  # lint-amnesty, pylint: disable=no-member
-            str(self.user.email),
-        )
-        split_store = modulestore()._get_modulestore_by_type(ModuleStoreEnum.Type.split)
-        new_key = split_store.make_course_key(self.course.id.org, self.course.id.course, self.course.id.run)  # lint-amnesty, pylint: disable=no-member
-        self.assertTrue(
-            split_store.has_course(new_key),
-            "Could not find course"
-        )
-
-    def test_user_id(self):
-        """
-        Test that the command accepts the user's primary key
-        """
-        # lack of error implies success
-        call_command(
-            "migrate_to_split",
-            str(self.course.id),  # lint-amnesty, pylint: disable=no-member
-            str(self.user.id),
-        )
-
-    def test_locator_string(self):
-        """
-        Test importing to a different course id
-        """
-        call_command(
-            "migrate_to_split",
-            str(self.course.id),  # lint-amnesty, pylint: disable=no-member
-            str(self.user.id),
-            org="org.dept",
-            course="name",
-            run="run",
-        )
-        split_store = modulestore()._get_modulestore_by_type(ModuleStoreEnum.Type.split)
-        locator = split_store.make_course_key("org.dept", "name", "run")
-        course_from_split = split_store.get_course(locator)
-        self.assertIsNotNone(course_from_split)
-
-        # Getting the original course with mongo course_id
-        mongo_store = modulestore()._get_modulestore_by_type(ModuleStoreEnum.Type.mongo)
-        mongo_locator = mongo_store.make_course_key(self.course.id.org, self.course.id.course, self.course.id.run)  # lint-amnesty, pylint: disable=no-member
-        course_from_mongo = mongo_store.get_course(mongo_locator)
-        self.assertIsNotNone(course_from_mongo)
-
-        # Throws ItemNotFoundError when try to access original course with split course_id
-        split_locator = split_store.make_course_key(self.course.id.org, self.course.id.course, self.course.id.run)  # lint-amnesty, pylint: disable=no-member
-        with self.assertRaises(ItemNotFoundError):
-            mongo_store.get_course(split_locator)
diff --git a/cms/djangoapps/contentstore/tests/test_clone_course.py b/cms/djangoapps/contentstore/tests/test_clone_course.py
index 1c84055a113c..6d45ae5469e1 100644
--- a/cms/djangoapps/contentstore/tests/test_clone_course.py
+++ b/cms/djangoapps/contentstore/tests/test_clone_course.py
@@ -27,25 +27,17 @@ class CloneCourseTest(CourseTestCase):
     Unit tests for cloning a course
     """
     def test_clone_course(self):
-        """Tests cloning of a course as follows: XML -> Mongo (+ data) -> Mongo -> Split -> Split"""
-        # 1. import and populate test toy course
-        mongo_course1_id = self.import_and_populate_course()
-        mongo_course2_id = mongo_course1_id
+        """
+        Tests cloning of a course: Split -> Split
+        """
 
-        # 3. clone course (mongo -> split)
         with self.store.default_store(ModuleStoreEnum.Type.split):
-            split_course3_id = CourseLocator(
-                org="edx3", course="split3", run="2013_Fall"
-            )
-            self.store.clone_course(mongo_course2_id, split_course3_id, self.user.id)
-            self.assertCoursesEqual(mongo_course2_id, split_course3_id)
-
-            # 4. clone course (split -> split)
-            split_course4_id = CourseLocator(
+            split_course1_id = CourseFactory().id
+            split_course2_id = CourseLocator(
                 org="edx4", course="split4", run="2013_Fall"
             )
-            self.store.clone_course(split_course3_id, split_course4_id, self.user.id)
-            self.assertCoursesEqual(split_course3_id, split_course4_id)
+            self.store.clone_course(split_course1_id, split_course2_id, self.user.id)
+            self.assertCoursesEqual(split_course1_id, split_course2_id)
 
     def test_space_in_asset_name_for_rerun_course(self):
         """
@@ -99,16 +91,28 @@ def test_rerun_course(self):
         """
         Unit tests for :meth: `contentstore.tasks.rerun_course`
         """
-        mongo_course1_id = self.import_and_populate_course()
+        org = 'edX'
+        course_number = 'CS101'
+        course_run = '2015_Q1'
+        display_name = 'rerun'
+        fields = {'display_name': display_name}
+
+        # Create a course using split modulestore
+        split_course = CourseFactory.create(
+            org=org,
+            number=course_number,
+            run=course_run,
+            display_name=display_name,
+            default_store=ModuleStoreEnum.Type.split
+        )
 
-        # rerun from mongo into split
         split_course3_id = CourseLocator(
             org="edx3", course="split3", run="rerun_test"
         )
         # Mark the action as initiated
         fields = {'display_name': 'rerun'}
-        CourseRerunState.objects.initiated(mongo_course1_id, split_course3_id, self.user, fields['display_name'])
-        result = rerun_course.delay(str(mongo_course1_id), str(split_course3_id), self.user.id,
+        CourseRerunState.objects.initiated(split_course.id, split_course3_id, self.user, fields['display_name'])
+        result = rerun_course.delay(str(split_course.id), str(split_course3_id), self.user.id,
                                     json.dumps(fields, cls=EdxJSONEncoder))
         self.assertEqual(result.get(), "succeeded")
         self.assertTrue(has_course_author_access(self.user, split_course3_id), "Didn't grant access")
@@ -116,7 +120,7 @@ def test_rerun_course(self):
         self.assertEqual(rerun_state.state, CourseRerunUIStateManager.State.SUCCEEDED)
 
         # try creating rerunning again to same name and ensure it generates error
-        result = rerun_course.delay(str(mongo_course1_id), str(split_course3_id), self.user.id)
+        result = rerun_course.delay(str(split_course.id), str(split_course3_id), self.user.id)
         self.assertEqual(result.get(), "duplicate course")
         # the below will raise an exception if the record doesn't exist
         CourseRerunState.objects.find_first(
diff --git a/cms/djangoapps/contentstore/tests/test_contentstore.py b/cms/djangoapps/contentstore/tests/test_contentstore.py
index 7d36753472e7..6d0452f8051e 100644
--- a/cms/djangoapps/contentstore/tests/test_contentstore.py
+++ b/cms/djangoapps/contentstore/tests/test_contentstore.py
@@ -7,7 +7,7 @@
 from functools import wraps
 from json import loads
 from textwrap import dedent
-from unittest import SkipTest, mock
+from unittest import SkipTest, mock, skip
 from uuid import uuid4
 
 import ddt
@@ -29,12 +29,11 @@
 from xmodule.contentstore.django import contentstore
 from xmodule.contentstore.utils import empty_asset_trashcan, restore_asset_from_trashcan
 from xmodule.course_module import CourseBlock, Textbook
-from xmodule.exceptions import InvalidVersionError
 from xmodule.modulestore import ModuleStoreEnum
 from xmodule.modulestore.django import modulestore
 from xmodule.modulestore.exceptions import ItemNotFoundError
 from xmodule.modulestore.inheritance import own_metadata
-from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory, check_mongo_calls
+from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
 from xmodule.modulestore.xml_exporter import export_course_to_xml
 from xmodule.modulestore.xml_importer import import_course_from_xml, perform_xlint
 from xmodule.seq_module import SequenceBlock
@@ -212,7 +211,7 @@ def test_asset_import(self):
         all_thumbnails = content_store.get_all_content_thumbnails_for_course(course.id)
         self.assertGreater(len(all_thumbnails), 0)
 
-        location = AssetKey.from_string('/c4x/edX/toy/asset/just_a_test.jpg')
+        location = AssetKey.from_string('asset-v1:edX+toy+2012_Fall+type@asset+block@just_a_test.jpg')
         content = content_store.find(location)
         self.assertIsNotNone(content)
 
@@ -282,7 +281,7 @@ def test_rewrite_nonportable_links_on_import(self):
         )
 
         # first check a static asset link
-        course_key = self.store.make_course_key('edX', 'toy', 'run')
+        course_key = self.store.make_course_key('edX', 'toy', '2012_Fall')
         html_module_location = course_key.make_usage_key('html', 'nonportable')
         html_module = self.store.get_item(html_module_location)
         self.assertIn('/static/foo.jpg', html_module.data)
@@ -325,16 +324,6 @@ def test_export_course_roundtrip(self, mock_get):
         # check for about content
         self.verify_content_existence(self.store, root_dir, course_id, 'about', 'about', '.html')
 
-        # assert that there is an html and video directory in drafts:
-        draft_dir = OSFS(root_dir / 'test_export/drafts')
-        self.assertTrue(draft_dir.exists('html'))
-        self.assertTrue(draft_dir.exists('video'))
-        # and assert that they contain the created modules
-        self.assertIn(self.DRAFT_HTML + ".xml", draft_dir.listdir('html'))
-        self.assertIn(self.DRAFT_VIDEO + ".xml", draft_dir.listdir('video'))
-        # and assert the child of the orphaned draft wasn't exported
-        self.assertNotIn(self.ORPHAN_DRAFT_HTML + ".xml", draft_dir.listdir('html'))
-
         # check for grading_policy.json
         filesystem = OSFS(root_dir / 'test_export/policies/2012_Fall')
         self.assertTrue(filesystem.exists('grading_policy.json'))
@@ -371,12 +360,9 @@ def check_import(self, root_dir, content_store, course_id):
         """Imports the course in root_dir into the given course_id and verifies its content"""
         # reimport
         import_course_from_xml(
-            self.store,
-            self.user.id,
-            root_dir,
-            ['test_export'],
-            static_content_store=content_store,
-            target_id=course_id,
+            self.store, self.user.id, root_dir, ['test_export'],
+            static_content_store=content_store, target_id=course_id,
+            create_if_not_present=True
         )
 
         # verify content of the course
@@ -551,17 +537,15 @@ def test_export_course_without_content_store(self):
 
         import_course_from_xml(
             self.store, self.user.id, root_dir, ['test_export_no_content_store'],
-            static_content_store=None,
+            static_content_store=None, create_if_not_present=True,
             target_id=course_id
         )
 
         # Verify reimported course
-
         items = self.store.get_items(
             course_id,
             qualifiers={
-                'category': 'sequential',
-                'name': 'vertical_sequential',
+                'name': 'vertical_sequential'
             }
         )
         self.assertEqual(len(items), 1)
@@ -724,29 +708,6 @@ def test_export_on_invalid_displayname(self, invalid_displayname):
         # Remove tempdir
         shutil.rmtree(root_dir)
 
-    @mock.patch(
-        'lms.djangoapps.ccx.modulestore.CCXModulestoreWrapper.get_item',
-        mock.Mock(return_value=mock.Mock(children=[]))
-    )
-    def test_export_with_orphan_vertical(self):
-        """
-        Tests that, export does not fail when a parent xblock does not have draft child xblock
-        information but the draft child xblock has parent information.
-        """
-        # Make an existing unit a draft
-        self.store.convert_to_draft(self.problem.location, self.user.id)
-        root_dir = path(mkdtemp_clean())
-        export_course_to_xml(self.store, None, self.course.id, root_dir, 'test_export')
-
-        # Verify that problem is exported in the drafts. This is expected because we are
-        # mocking get_item to for drafts. Expect no draft is exported.
-        # Specifically get_item is used in `xmodule.modulestore.xml_exporter._export_drafts`
-        export_draft_dir = OSFS(root_dir / 'test_export/drafts')
-        self.assertEqual(len(export_draft_dir.listdir('/')), 0)
-
-        # Remove tempdir
-        shutil.rmtree(root_dir)
-
     def test_assets_overwrite(self):
         """ Tests that assets will similar 'displayname' will be overwritten during export """
         content_store = contentstore()
@@ -788,7 +749,7 @@ def test_advanced_components_require_two_clicks(self):
 
     def test_malformed_edit_unit_request(self):
         # just pick one vertical
-        usage_key = self.course.id.make_usage_key('vertical', None)
+        usage_key = self.course.id.make_usage_key('vertical', 'test_vertical')
 
         resp = self.client.get_html(get_url('container_handler', usage_key))
         self.assertEqual(resp.status_code, 400)
@@ -804,31 +765,6 @@ def _get_draft_counts(self, item):  # lint-amnesty, pylint: disable=missing-func
 
         return cnt
 
-    def test_get_items(self):
-        """
-        This verifies a bug we had where the None setting in get_items() meant 'wildcard'
-        Unfortunately, None = published for the revision field, so get_items() would return
-        both draft and non-draft copies.
-        """
-        self.store.convert_to_draft(self.problem.location, self.user.id)
-
-        # Query get_items() and find the html item. This should just return back a single item (not 2).
-        direct_store_items = self.store.get_items(
-            self.course.id, revision=ModuleStoreEnum.RevisionOption.published_only
-        )
-        items_from_direct_store = [item for item in direct_store_items if item.location == self.problem.location]
-        self.assertEqual(len(items_from_direct_store), 1)
-        self.assertFalse(getattr(items_from_direct_store[0], 'is_draft', False))
-
-        # Fetch from the draft store.
-        draft_store_items = self.store.get_items(
-            self.course.id, revision=ModuleStoreEnum.RevisionOption.draft_only
-        )
-        items_from_draft_store = [item for item in draft_store_items if item.location == self.problem.location]
-        self.assertEqual(len(items_from_draft_store), 1)
-        # TODO the below won't work for split mongo
-        self.assertTrue(getattr(items_from_draft_store[0], 'is_draft', False))
-
     def test_draft_metadata(self):
         """
         This verifies a bug we had where inherited metadata was getting written to the
@@ -893,25 +829,6 @@ def test_draft_metadata(self):
         self.assertIn('graceperiod', own_metadata(problem))
         self.assertEqual(problem.graceperiod, new_graceperiod)
 
-    def test_get_depth_with_drafts(self):
-        # make sure no draft items have been returned
-        num_drafts = self._get_draft_counts(self.course)
-        self.assertEqual(num_drafts, 0)
-
-        # put into draft
-        self.store.convert_to_draft(self.problem.location, self.user.id)
-
-        # make sure we can query that item and verify that it is a draft
-        draft_problem = self.store.get_item(self.problem.location)
-        self.assertTrue(getattr(draft_problem, 'is_draft', False))
-
-        # now requery with depth
-        course = self.store.get_course(self.course.id, depth=None)
-
-        # make sure just one draft item have been returned
-        num_drafts = self._get_draft_counts(course)
-        self.assertEqual(num_drafts, 1)
-
     @mock.patch('xmodule.course_module.requests.get')
     def test_import_textbook_as_content_element(self, mock_get):
         mock_get.return_value.text = dedent("""
@@ -1024,36 +941,19 @@ def test_empty_trashcan(self):
         self.assertEqual(len(all_assets), 0)
         self.assertEqual(count, 0)
 
-    def test_illegal_draft_crud_ops(self):
-        # this test presumes old mongo and split_draft not full split
-        with self.assertRaises(InvalidVersionError):
-            self.store.convert_to_draft(self.chapter_loc, self.user.id)
-
-        chapter = self.store.get_item(self.chapter_loc)
-        chapter.data = 'chapter data'
-        self.store.update_item(chapter, self.user.id)
-        newobject = self.store.get_item(self.chapter_loc)
-        self.assertFalse(getattr(newobject, 'is_draft', False))
-
-        with self.assertRaises(InvalidVersionError):
-            self.store.unpublish(self.chapter_loc, self.user.id)
-
     def test_bad_contentstore_request(self):
         """
         Test that user get proper responses for urls with invalid url or
         asset/course key
         """
-        resp = self.client.get_html('/c4x/CDX/123123/asset/&invalid.png')
+        resp = self.client.get_html('/asset-v1:CDX+123123+2012_Fall+type@asset+block@&invalid.png')
         self.assertEqual(resp.status_code, 400)
 
-        resp = self.client.get_html('/c4x/CDX/123123/asset/invalid.png')
+        resp = self.client.get_html('/asset-v1:CDX+123123+2012_Fall+type@asset+block@invalid.png')
         self.assertEqual(resp.status_code, 404)
 
-        # Now test that 404 response is returned when user tries to access
-        # asset of some invalid course from split ModuleStore
-        with self.store.default_store(ModuleStoreEnum.Type.split):
-            resp = self.client.get_html('/c4x/InvalidOrg/InvalidCourse/asset/invalid.png')
-            self.assertEqual(resp.status_code, 404)
+        resp = self.client.get_html('/c4x/InvalidOrg/InvalidCourse/asset/invalid.png')
+        self.assertEqual(resp.status_code, 400)
 
     @override_waffle_switch(waffle.ENABLE_ACCESSIBILITY_POLICY_PAGE, active=False)
     def test_disabled_accessibility_page(self):
@@ -1063,36 +963,6 @@ def test_disabled_accessibility_page(self):
         resp = self.client.get_html('/accessibility')
         self.assertEqual(resp.status_code, 404)
 
-    def test_delete_course(self):
-        """
-        This test creates a course, makes a draft item, and deletes the course. This will also assert that the
-        draft content is also deleted
-        """
-        # add an asset
-        asset_key = self.course.id.make_asset_key('asset', 'sample_static.html')
-        content = StaticContent(
-            asset_key, "Fake asset", "application/text", b"test",
-        )
-        contentstore().save(content)
-        assets, count = contentstore().get_all_content_for_course(self.course.id)
-        self.assertGreater(len(assets), 0)
-        self.assertGreater(count, 0)
-
-        self.store.convert_to_draft(self.vert_loc, self.user.id)
-
-        # delete the course
-        self.store.delete_course(self.course.id, self.user.id)
-
-        # assert that there's absolutely no non-draft modules in the course
-        # this should also include all draft items
-        items = self.store.get_items(self.course.id)
-        self.assertEqual(len(items), 0)
-
-        # assert that all content in the asset library is also deleted
-        assets, count = contentstore().get_all_content_for_course(self.course.id)
-        self.assertEqual(len(assets), 0)
-        self.assertEqual(count, 0)
-
     def test_course_handouts_rewrites(self):
         """
         Test that the xblock_handler rewrites static handout links
@@ -1105,36 +975,15 @@ def test_course_handouts_rewrites(self):
 
         # get module info (json)
         resp = self.client.get(get_url('xblock_handler', handouts.location))
-
         # make sure we got a successful response
         self.assertEqual(resp.status_code, 200)
         # check that /static/ has been converted to the full path
         # note, we know the link it should be because that's what in the 'toy' course in the test data
-        asset_key = self.course.id.make_asset_key('asset', 'handouts_sample_handout.txt')
-        self.assertContains(resp, str(asset_key))
-
-    def test_prefetch_children(self):
-        # make sure we haven't done too many round trips to DB:
-        # 1) the course,
-        # 2 & 3) for the chapters and sequentials
-        # Because we're querying from the top of the tree, we cache information needed for inheritance,
-        # so we don't need to make an extra query to compute it.
-        # set the branch to 'publish' in order to prevent extra lookups of draft versions
-        with self.store.branch_setting(ModuleStoreEnum.Branch.published_only, self.course.id):
-            with check_mongo_calls(3):
-                course = self.store.get_course(self.course.id, depth=2)
-
-            # make sure we pre-fetched a known sequential which should be at depth=2
-            self.assertIn(self.seq_loc, course.system.module_data)
-
-            # make sure we don't have a specific vertical which should be at depth=3
-            self.assertNotIn(self.vert_loc, course.system.module_data)
-
-        # Now, test with the branch set to draft. No extra round trips b/c it doesn't go deep enough to get
-        # beyond direct only categories
-        with self.store.branch_setting(ModuleStoreEnum.Branch.draft_preferred, self.course.id):
-            with check_mongo_calls(3):
-                self.store.get_course(self.course.id, depth=2)
+        asset_key = str(self.course.id.make_asset_key('asset', 'handouts_sample_handout.txt'))
+        # replase last `@` to `/`
+        index = asset_key.rfind('@')
+        expected_url = f'{asset_key[:index]}/{asset_key[index+1:]}'
+        self.assertContains(resp, expected_url)
 
     def _check_verticals(self, locations):
         """ Test getting the editing HTML for each vertical. """
@@ -1205,21 +1054,19 @@ def test_create_course_with_dots(self):
         self.course_data['run'] = 'run.name'
         self.assert_created_course()
 
-    @ddt.data(ModuleStoreEnum.Type.split, ModuleStoreEnum.Type.mongo)
-    def test_course_with_different_cases(self, default_store):
+    def test_course_with_different_cases(self):
         """
         Tests that course can not be created with different case using an AJAX request to
         course handler.
         """
         course_number = '99x'
-        with self.store.default_store(default_store):
-            # Verify create a course passes with lower case.
-            self.course_data['number'] = course_number.lower()
-            self.assert_created_course()
+        # Verify create a course passes with lower case.
+        self.course_data['number'] = course_number.lower()
+        self.assert_created_course()
 
-            # Verify create a course fail when same course number is provided with different case.
-            self.course_data['number'] = course_number.upper()
-            self.assert_course_creation_failed(self.duplicate_course_error)
+        # Verify create a course fail when same course number is provided with different case.
+        self.course_data['number'] = course_number.upper()
+        self.assert_course_creation_failed(self.duplicate_course_error)
 
     def test_create_course_check_forum_seeding(self):
         """Test new course creation and verify forum seeding """
@@ -1350,44 +1197,33 @@ def assert_course_creation_failed(self, error_message):
             # the user will be enrolled. In the other cases, initially_enrolled will be False.
             self.assertEqual(initially_enrolled, CourseEnrollment.is_enrolled(self.user, course_id))
 
-    def test_create_course_duplicate_number(self):
-        """Test new course creation - error path"""
-        self.client.ajax_post('/course/', self.course_data)
-        self.course_data['display_name'] = 'Robot Super Course Two'
-        self.course_data['run'] = '2013_Summer'
-
-        self.assert_course_creation_failed(self.duplicate_course_error)
-
-    @ddt.data(ModuleStoreEnum.Type.split, ModuleStoreEnum.Type.mongo)
-    def test_create_course_case_change(self, default_store):
+    def test_create_course_case_change(self):
         """Test new course creation - error path due to case insensitive name equality"""
         self.course_data['number'] = '99x'
 
-        with self.store.default_store(default_store):
-
-            # Verify that the course was created properly.
-            self.assert_created_course()
+        # Verify that the course was created properly.
+        self.assert_created_course()
 
-            # Keep the copy of original org
-            cache_current = self.course_data['org']
+        # Keep the copy of original org
+        cache_current = self.course_data['org']
 
-            # Change `org` to lower case and verify that course did not get created
-            self.course_data['org'] = self.course_data['org'].lower()
-            self.assert_course_creation_failed(self.duplicate_course_error)
+        # Change `org` to lower case and verify that course did not get created
+        self.course_data['org'] = self.course_data['org'].lower()
+        self.assert_course_creation_failed(self.duplicate_course_error)
 
-            # Replace the org with its actual value, and keep the copy of course number.
-            self.course_data['org'] = cache_current
-            cache_current = self.course_data['number']
+        # Replace the org with its actual value, and keep the copy of course number.
+        self.course_data['org'] = cache_current
+        cache_current = self.course_data['number']
 
-            self.course_data['number'] = self.course_data['number'].upper()
-            self.assert_course_creation_failed(self.duplicate_course_error)
+        self.course_data['number'] = self.course_data['number'].upper()
+        self.assert_course_creation_failed(self.duplicate_course_error)
 
-            # Replace the org with its actual value, and keep the copy of course number.
-            self.course_data['number'] = cache_current
-            __ = self.course_data['run']
+        # Replace the org with its actual value, and keep the copy of course number.
+        self.course_data['number'] = cache_current
+        __ = self.course_data['run']
 
-            self.course_data['run'] = self.course_data['run'].upper()
-            self.assert_course_creation_failed(self.duplicate_course_error)
+        self.course_data['run'] = self.course_data['run'].upper()
+        self.assert_course_creation_failed(self.duplicate_course_error)
 
     def test_course_substring(self):
         """
@@ -1515,7 +1351,9 @@ def test_create_item(self):
 
         self.assertEqual(resp.status_code, 200)
         data = parse_json(resp)
-        retarget = str(course.id.make_usage_key('chapter', 'REPLACE')).replace('REPLACE', r'([0-9]|[a-f]){3,}')
+        retarget = str(
+            course.id.make_usage_key('chapter', 'REPLACE')
+        ).replace('REPLACE', r'([0-9]|[a-f]){3,}').replace('+', r'\+')
         self.assertRegex(data['locator'], retarget)
 
     def test_capa_module(self):
@@ -1625,7 +1463,7 @@ def test_import_into_new_course_id(self):
         self.assertEqual(course_module.pdf_textbooks[0]["chapters"][1]["url"], '/static/Chapter2.pdf')
 
     def test_import_into_new_course_id_wiki_slug_renamespacing(self):
-        # If reimporting into the same course do not change the wiki_slug.
+        # If reimporting into the same course change the wiki_slug.
         target_id = self.store.make_course_key('edX', 'toy', '2012_Fall')
         course_data = {
             'org': target_id.org,
@@ -1637,13 +1475,14 @@ def test_import_into_new_course_id_wiki_slug_renamespacing(self):
         course_module = self.store.get_course(target_id)
         course_module.wiki_slug = 'toy'
         course_module.save()
+        self.assertEqual(course_module.wiki_slug, 'toy')
 
         # Import a course with wiki_slug == location.course
         import_course_from_xml(self.store, self.user.id, TEST_DATA_DIR, ['toy'], target_id=target_id)
         course_module = self.store.get_course(target_id)
-        self.assertEqual(course_module.wiki_slug, 'toy')
+        self.assertEqual(course_module.wiki_slug, 'edX.toy.2012_Fall')
 
-        # But change the wiki_slug if it is a different course.
+        # Change the wiki_slug if it is a different course.
         target_id = self.store.make_course_key('MITx', '111', '2013_Spring')
         course_data = {
             'org': target_id.org,
@@ -1667,7 +1506,7 @@ def test_import_metadata_with_attempts_empty_string(self):
         import_course_from_xml(self.store, self.user.id, TEST_DATA_DIR, ['simple'], create_if_not_present=True)
         did_load_item = False
         try:
-            course_key = self.store.make_course_key('edX', 'simple', 'problem')
+            course_key = self.store.make_course_key('edX', 'simple', '2012_Fall')
             usage_key = course_key.make_usage_key('problem', 'ps01-simple')
             self.store.get_item(usage_key)
             did_load_item = True
@@ -1677,13 +1516,12 @@ def test_import_metadata_with_attempts_empty_string(self):
         # make sure we found the item (e.g. it didn't error while loading)
         self.assertTrue(did_load_item)
 
-    @ddt.data(ModuleStoreEnum.Type.split, ModuleStoreEnum.Type.mongo)
-    def test_forum_id_generation(self, default_store):
+    def test_forum_id_generation(self):
         """
         Test that a discussion item, even if it doesn't set its discussion_id,
         consistently generates the same one
         """
-        course = CourseFactory.create(default_store=default_store)
+        course = CourseFactory.create()
 
         # create a discussion item
         discussion_item = self.store.create_item(self.user.id, course.id, 'discussion', 'new_component')
@@ -1807,6 +1645,7 @@ def test_course_handler_with_invalid_course_key_string(self):
         self.assertEqual(response.status_code, 404)
 
 
+@skip("OldMongo Deprecation")
 class MetadataSaveTestCase(ContentStoreTestCase):
     """Test that metadata is correctly cached and decached."""
 
@@ -1951,7 +1790,7 @@ def test_rerun_course_no_videos_in_val(self):
         """
         Test when rerunning a course with no videos, VAL copies nothing
         """
-        source_course = CourseFactory.create()
+        source_course = CourseFactory.create(default_store=ModuleStoreEnum.Type.split)
         destination_course_key = self.post_rerun_request(source_course.id)
         self.verify_rerun_course(source_course.id, destination_course_key, self.destination_course_data['display_name'])
         videos, __ = get_videos_for_course(str(destination_course_key))
@@ -1964,7 +1803,10 @@ def test_rerun_course_video_upload_token(self):
         Test when rerunning a course with video upload token, video upload token is not copied to new course.
         """
         # Create a course with video upload token.
-        source_course = CourseFactory.create(video_upload_pipeline={"course_video_upload_token": 'test-token'})
+        source_course = CourseFactory.create(
+            video_upload_pipeline={"course_video_upload_token": 'test-token'},
+            default_store=ModuleStoreEnum.Type.split
+        )
 
         destination_course_key = self.post_rerun_request(source_course.id)
         self.verify_rerun_course(source_course.id, destination_course_key, self.destination_course_data['display_name'])
@@ -1977,7 +1819,7 @@ def test_rerun_course_video_upload_token(self):
         self.assertEqual(new_course.video_upload_pipeline, {})
 
     def test_rerun_course_success(self):
-        source_course = CourseFactory.create()
+        source_course = CourseFactory.create(default_store=ModuleStoreEnum.Type.split)
         create_video(
             dict(
                 edx_video_id="tree-hugger",
@@ -2003,14 +1845,17 @@ def test_rerun_course_success(self):
         self.assertEqual(new_course.video_upload_pipeline, {})
 
     def test_rerun_course_resets_advertised_date(self):
-        source_course = CourseFactory.create(advertised_start="01-12-2015")
+        source_course = CourseFactory.create(
+            advertised_start="01-12-2015",
+            default_store=ModuleStoreEnum.Type.split
+        )
         destination_course_key = self.post_rerun_request(source_course.id)
         destination_course = self.store.get_course(destination_course_key)
 
         self.assertEqual(None, destination_course.advertised_start)
 
     def test_rerun_of_rerun(self):
-        source_course = CourseFactory.create()
+        source_course = CourseFactory.create(default_store=ModuleStoreEnum.Type.split)
         rerun_course_key = self.post_rerun_request(source_course.id)
         rerun_of_rerun_data = {
             'org': rerun_course_key.org,
@@ -2022,7 +1867,7 @@ def test_rerun_of_rerun(self):
         self.verify_rerun_course(rerun_course_key, rerun_of_rerun_course_key, rerun_of_rerun_data['display_name'])
 
     def test_rerun_course_fail_no_source_course(self):
-        existent_course_key = CourseFactory.create().id
+        existent_course_key = CourseFactory.create(default_store=ModuleStoreEnum.Type.split).id
         non_existent_course_key = CourseLocator("org", "non_existent_course", "non_existent_run")
         destination_course_key = self.post_rerun_request(non_existent_course_key)
 
@@ -2061,7 +1906,7 @@ def test_rerun_course_fail_duplicate_course(self):
 
     def test_rerun_with_permission_denied(self):
         with mock.patch.dict('django.conf.settings.FEATURES', {"ENABLE_CREATOR_GROUP": True}):
-            source_course = CourseFactory.create()
+            source_course = CourseFactory.create(default_store=ModuleStoreEnum.Type.split)
             auth.add_users(self.user, CourseCreatorRole(), self.user)
             self.user.is_staff = False
             self.user.save()
@@ -2090,7 +1935,7 @@ def test_rerun_error_trunc_message(self):
             'xmodule.modulestore.mixed.MixedModuleStore.clone_course',
             mock.Mock(side_effect=Exception()),
         ):
-            source_course = CourseFactory.create()
+            source_course = CourseFactory.create(default_store=ModuleStoreEnum.Type.split)
             message_too_long = "traceback".rjust(CourseRerunState.MAX_MESSAGE_LENGTH * 2, '-')
             with mock.patch('traceback.format_exc', return_value=message_too_long):
                 destination_course_key = self.post_rerun_request(source_course.id)
@@ -2103,37 +1948,38 @@ def test_rerun_course_wiki_slug(self):
         """
         Test that unique wiki_slug is assigned to rerun course.
         """
-        course_data = {
-            'org': 'edX',
-            'number': '123',
-            'display_name': 'Rerun Course',
-            'run': '2013'
-        }
+        with self.store.default_store(ModuleStoreEnum.Type.split):
+            course_data = {
+                'org': 'edX',
+                'number': '123',
+                'display_name': 'Rerun Course',
+                'run': '2013'
+            }
 
-        source_wiki_slug = '{}.{}.{}'.format(course_data['org'], course_data['number'], course_data['run'])
+            source_wiki_slug = '{}.{}.{}'.format(course_data['org'], course_data['number'], course_data['run'])
 
-        source_course_key = _get_course_id(self.store, course_data)
-        _create_course(self, source_course_key, course_data)
-        source_course = self.store.get_course(source_course_key)
+            source_course_key = _get_course_id(self.store, course_data)
+            _create_course(self, source_course_key, course_data)
+            source_course = self.store.get_course(source_course_key)
 
-        # Verify created course's wiki_slug.
-        self.assertEqual(source_course.wiki_slug, source_wiki_slug)
+            # Verify created course's wiki_slug.
+            self.assertEqual(source_course.wiki_slug, source_wiki_slug)
 
-        destination_course_data = course_data
-        destination_course_data['run'] = '2013_Rerun'
+            destination_course_data = course_data
+            destination_course_data['run'] = '2013_Rerun'
 
-        destination_course_key = self.post_rerun_request(
-            source_course.id, destination_course_data=destination_course_data
-        )
-        self.verify_rerun_course(source_course.id, destination_course_key, destination_course_data['display_name'])
-        destination_course = self.store.get_course(destination_course_key)
+            destination_course_key = self.post_rerun_request(
+                source_course.id, destination_course_data=destination_course_data
+            )
+            self.verify_rerun_course(source_course.id, destination_course_key, destination_course_data['display_name'])
+            destination_course = self.store.get_course(destination_course_key)
 
-        destination_wiki_slug = '{}.{}.{}'.format(
-            destination_course.id.org, destination_course.id.course, destination_course.id.run
-        )
+            destination_wiki_slug = '{}.{}.{}'.format(
+                destination_course.id.org, destination_course.id.course, destination_course.id.run
+            )
 
-        # Verify rerun course's wiki_slug.
-        self.assertEqual(destination_course.wiki_slug, destination_wiki_slug)
+            # Verify rerun course's wiki_slug.
+            self.assertEqual(destination_course.wiki_slug, destination_wiki_slug)
 
 
 class ContentLicenseTest(ContentStoreTestCase):
@@ -2141,6 +1987,7 @@ class ContentLicenseTest(ContentStoreTestCase):
     Tests around content licenses
     """
 
+    @skip("OldMongo Deprecation")
     def test_course_license_export(self):
         content_store = contentstore()
         root_dir = path(mkdtemp_clean())
diff --git a/cms/djangoapps/contentstore/tests/test_course_create_rerun.py b/cms/djangoapps/contentstore/tests/test_course_create_rerun.py
index c76837912daa..c92f53e7fd7f 100644
--- a/cms/djangoapps/contentstore/tests/test_course_create_rerun.py
+++ b/cms/djangoapps/contentstore/tests/test_course_create_rerun.py
@@ -17,8 +17,6 @@
 from organizations.exceptions import InvalidOrganizationException
 from organizations.models import Organization
 from xmodule.course_module import CourseFields
-from xmodule.modulestore import ModuleStoreEnum
-from xmodule.modulestore.django import modulestore
 from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory
 
@@ -114,26 +112,23 @@ def test_rerun(self):
         self.assertEqual(len(course_orgs), 1)
         self.assertEqual(course_orgs[0]['short_name'], self.source_course_key.org)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_newly_created_course_has_web_certs_enabled(self, store):
+    def test_newly_created_course_has_web_certs_enabled(self):
         """
         Tests newly created course has web certs enabled by default.
         """
-        with modulestore().default_store(store):
-            response = self.client.ajax_post(self.course_create_rerun_url, {
-                'org': 'orgX',
-                'number': 'CS101',
-                'display_name': 'Course with web certs enabled',
-                'run': '2015_T2'
-            })
-            self.assertEqual(response.status_code, 200)
-            data = parse_json(response)
-            new_course_key = CourseKey.from_string(data['course_key'])
-            course = self.store.get_course(new_course_key)
-            self.assertTrue(course.cert_html_view_enabled)
+        response = self.client.ajax_post(self.course_create_rerun_url, {
+            'org': 'orgX',
+            'number': 'CS101',
+            'display_name': 'Course with web certs enabled',
+            'run': '2015_T2'
+        })
+        self.assertEqual(response.status_code, 200)
+        data = parse_json(response)
+        new_course_key = CourseKey.from_string(data['course_key'])
+        course = self.store.get_course(new_course_key)
+        self.assertTrue(course.cert_html_view_enabled)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_course_creation_for_unknown_organization_relaxed(self, store):
+    def test_course_creation_for_unknown_organization_relaxed(self):
         """
         Tests that when ORGANIZATIONS_AUTOCREATE is True,
         creating a course-run with an unknown org slug will create an organization
@@ -141,40 +136,37 @@ def test_course_creation_for_unknown_organization_relaxed(self, store):
         """
         with self.assertRaises(InvalidOrganizationException):
             get_organization_by_short_name("orgX")
-        with modulestore().default_store(store):
-            response = self.client.ajax_post(self.course_create_rerun_url, {
-                'org': 'orgX',
-                'number': 'CS101',
-                'display_name': 'Course with web certs enabled',
-                'run': '2015_T2'
-            })
-            self.assertEqual(response.status_code, 200)
-            self.assertIsNotNone(get_organization_by_short_name("orgX"))
-            data = parse_json(response)
-            new_course_key = CourseKey.from_string(data['course_key'])
-            course_orgs = get_course_organizations(new_course_key)
-            self.assertEqual(len(course_orgs), 1)
-            self.assertEqual(course_orgs[0]['short_name'], 'orgX')
+        response = self.client.ajax_post(self.course_create_rerun_url, {
+            'org': 'orgX',
+            'number': 'CS101',
+            'display_name': 'Course with web certs enabled',
+            'run': '2015_T2'
+        })
+        self.assertEqual(response.status_code, 200)
+        self.assertIsNotNone(get_organization_by_short_name("orgX"))
+        data = parse_json(response)
+        new_course_key = CourseKey.from_string(data['course_key'])
+        course_orgs = get_course_organizations(new_course_key)
+        self.assertEqual(len(course_orgs), 1)
+        self.assertEqual(course_orgs[0]['short_name'], 'orgX')
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
     @override_settings(ORGANIZATIONS_AUTOCREATE=False)
-    def test_course_creation_for_unknown_organization_strict(self, store):
+    def test_course_creation_for_unknown_organization_strict(self):
         """
         Tests that when ORGANIZATIONS_AUTOCREATE is False,
         creating a course-run with an unknown org slug will raise a validation error.
         """
-        with modulestore().default_store(store):
-            response = self.client.ajax_post(self.course_create_rerun_url, {
-                'org': 'orgX',
-                'number': 'CS101',
-                'display_name': 'Course with web certs enabled',
-                'run': '2015_T2'
-            })
-            self.assertEqual(response.status_code, 400)
-            with self.assertRaises(InvalidOrganizationException):
-                get_organization_by_short_name("orgX")
-            data = parse_json(response)
-            self.assertIn('Organization you selected does not exist in the system', data['error'])
+        response = self.client.ajax_post(self.course_create_rerun_url, {
+            'org': 'orgX',
+            'number': 'CS101',
+            'display_name': 'Course with web certs enabled',
+            'run': '2015_T2'
+        })
+        self.assertEqual(response.status_code, 400)
+        with self.assertRaises(InvalidOrganizationException):
+            get_organization_by_short_name("orgX")
+        data = parse_json(response)
+        self.assertIn('Organization you selected does not exist in the system', data['error'])
 
     @ddt.data(True, False)
     def test_course_creation_for_known_organization(self, organizations_autocreate):
@@ -201,23 +193,20 @@ def test_course_creation_for_known_organization(self, organizations_autocreate):
             self.assertEqual(course_orgs[0]['short_name'], 'orgX')
 
     @override_settings(FEATURES={'ENABLE_CREATOR_GROUP': True})
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_course_creation_when_user_not_in_org(self, store):
+    def test_course_creation_when_user_not_in_org(self):
         """
         Tests course creation when user doesn't have the required role.
         """
-        with modulestore().default_store(store):
-            response = self.client.ajax_post(self.course_create_rerun_url, {
-                'org': 'TestorgX',
-                'number': 'CS101',
-                'display_name': 'Course with web certs enabled',
-                'run': '2021_T1'
-            })
-            self.assertEqual(response.status_code, 403)
+        response = self.client.ajax_post(self.course_create_rerun_url, {
+            'org': 'TestorgX',
+            'number': 'CS101',
+            'display_name': 'Course with web certs enabled',
+            'run': '2021_T1'
+        })
+        self.assertEqual(response.status_code, 403)
 
     @override_settings(FEATURES={'ENABLE_CREATOR_GROUP': True})
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_course_creation_when_user_in_org_with_creator_role(self, store):
+    def test_course_creation_when_user_in_org_with_creator_role(self):
         """
         Tests course creation with user having the organization content creation role.
         """
@@ -227,22 +216,20 @@ def test_course_creation_when_user_in_org_with_creator_role(self, store):
             'description': 'Testing Organization Description',
         })
         update_org_role(self.global_admin, OrgContentCreatorRole, self.user, [self.source_course_key.org])
-        with modulestore().default_store(store):
-            response = self.client.ajax_post(self.course_create_rerun_url, {
-                'org': self.source_course_key.org,
-                'number': 'CS101',
-                'display_name': 'Course with web certs enabled',
-                'run': '2021_T1'
-            })
-            self.assertEqual(response.status_code, 200)
+        response = self.client.ajax_post(self.course_create_rerun_url, {
+            'org': self.source_course_key.org,
+            'number': 'CS101',
+            'display_name': 'Course with web certs enabled',
+            'run': '2021_T1'
+        })
+        self.assertEqual(response.status_code, 200)
 
     @override_settings(FEATURES={'ENABLE_CREATOR_GROUP': True})
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
     @mock.patch(
         'cms.djangoapps.course_creators.admin.render_to_string',
         mock.Mock(side_effect=mock_render_to_string, autospec=True)
     )
-    def test_course_creation_with_all_org_checked(self, store):
+    def test_course_creation_with_all_org_checked(self):
         """
         Tests course creation with user having permission to create course for all organization.
         """
@@ -254,22 +241,20 @@ def test_course_creation_with_all_org_checked(self, store):
         self.course_creator_entry.all_organizations = True
         self.course_creator_entry.state = CourseCreator.GRANTED
         self.creator_admin.save_model(self.request, self.course_creator_entry, None, True)
-        with modulestore().default_store(store):
-            response = self.client.ajax_post(self.course_create_rerun_url, {
-                'org': self.source_course_key.org,
-                'number': 'CS101',
-                'display_name': 'Course with web certs enabled',
-                'run': '2021_T1'
-            })
-            self.assertEqual(response.status_code, 200)
+        response = self.client.ajax_post(self.course_create_rerun_url, {
+            'org': self.source_course_key.org,
+            'number': 'CS101',
+            'display_name': 'Course with web certs enabled',
+            'run': '2021_T1'
+        })
+        self.assertEqual(response.status_code, 200)
 
     @override_settings(FEATURES={'ENABLE_CREATOR_GROUP': True})
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
     @mock.patch(
         'cms.djangoapps.course_creators.admin.render_to_string',
         mock.Mock(side_effect=mock_render_to_string, autospec=True)
     )
-    def test_course_creation_with_permission_for_specific_organization(self, store):
+    def test_course_creation_with_permission_for_specific_organization(self):
         """
         Tests course creation with user having permission to create course for specific organization.
         """
@@ -283,22 +268,20 @@ def test_course_creation_with_permission_for_specific_organization(self, store):
         self.creator_admin.save_model(self.request, self.course_creator_entry, None, True)
         dc_org_object = Organization.objects.get(name='Test Organization')
         self.course_creator_entry.organizations.add(dc_org_object)
-        with modulestore().default_store(store):
-            response = self.client.ajax_post(self.course_create_rerun_url, {
-                'org': self.source_course_key.org,
-                'number': 'CS101',
-                'display_name': 'Course with web certs enabled',
-                'run': '2021_T1'
-            })
-            self.assertEqual(response.status_code, 200)
+        response = self.client.ajax_post(self.course_create_rerun_url, {
+            'org': self.source_course_key.org,
+            'number': 'CS101',
+            'display_name': 'Course with web certs enabled',
+            'run': '2021_T1'
+        })
+        self.assertEqual(response.status_code, 200)
 
     @override_settings(FEATURES={'ENABLE_CREATOR_GROUP': True})
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
     @mock.patch(
         'cms.djangoapps.course_creators.admin.render_to_string',
         mock.Mock(side_effect=mock_render_to_string, autospec=True)
     )
-    def test_course_creation_without_permission_for_specific_organization(self, store):
+    def test_course_creation_without_permission_for_specific_organization(self):
         """
         Tests course creation with user not having permission to create course for specific organization.
         """
@@ -319,11 +302,10 @@ def test_course_creation_without_permission_for_specific_organization(self, stor
         # When the user tries to create course under `Test Organization` it throws a 403.
         dc_org_object = Organization.objects.get(name='DC')
         self.course_creator_entry.organizations.add(dc_org_object)
-        with modulestore().default_store(store):
-            response = self.client.ajax_post(self.course_create_rerun_url, {
-                'org': self.source_course_key.org,
-                'number': 'CS101',
-                'display_name': 'Course with web certs enabled',
-                'run': '2021_T1'
-            })
-            self.assertEqual(response.status_code, 403)
+        response = self.client.ajax_post(self.course_create_rerun_url, {
+            'org': self.source_course_key.org,
+            'number': 'CS101',
+            'display_name': 'Course with web certs enabled',
+            'run': '2021_T1'
+        })
+        self.assertEqual(response.status_code, 403)
diff --git a/cms/djangoapps/contentstore/tests/test_course_listing.py b/cms/djangoapps/contentstore/tests/test_course_listing.py
index 44fe762f7333..c141786499ac 100644
--- a/cms/djangoapps/contentstore/tests/test_course_listing.py
+++ b/cms/djangoapps/contentstore/tests/test_course_listing.py
@@ -162,12 +162,8 @@ def test_courses_list_with_ccx_courses(self):
             courses_iter, __ = _accessible_courses_iter_for_tests(self.request)
             self.assertEqual(len(list(courses_iter)), 0)
 
-    @ddt.data(
-        (ModuleStoreEnum.Type.split, 2),
-        (ModuleStoreEnum.Type.mongo, 1)
-    )
     @ddt.unpack
-    def test_staff_course_listing(self, default_store, mongo_calls):
+    def test_staff_course_listing(self):
         """
         Create courses and verify they take certain amount of mongo calls to call get_courses_accessible_to_user.
         Also verify that fetch accessible courses list for staff user returns CourseSummary instances.
@@ -177,11 +173,10 @@ def test_staff_course_listing(self, default_store, mongo_calls):
         GlobalStaff().add_users(self.user)
         self.assertTrue(GlobalStaff().has_user(self.user))
 
-        with self.store.default_store(default_store):
-            # Create few courses
-            for num in range(TOTAL_COURSES_COUNT):
-                course_location = self.store.make_course_key('Org', 'CreatedCourse' + str(num), 'Run')
-                self._create_course_with_access_groups(course_location, self.user)
+        # Create few courses
+        for num in range(TOTAL_COURSES_COUNT):
+            course_location = self.store.make_course_key('Org', 'CreatedCourse' + str(num), 'Run')
+            self._create_course_with_access_groups(course_location, self.user)
 
         # Fetch accessible courses list & verify their count
         courses_list_by_staff, __ = get_courses_accessible_to_user(self.request)
@@ -192,7 +187,7 @@ def test_staff_course_listing(self, default_store, mongo_calls):
         self.assertTrue(all(isinstance(course, CourseSummary) for course in courses_list_by_staff))
 
         # Now count the db queries for staff
-        with check_mongo_calls(mongo_calls):
+        with check_mongo_calls(2):
             list(_accessible_courses_summary_iter(self.request))
 
     @ddt.data(ModuleStoreEnum.Type.split)
@@ -248,7 +243,6 @@ def test_get_course_list_with_invalid_course_location(self, store):
 
     @ddt.data(
         (ModuleStoreEnum.Type.split, 1, 2),
-        (ModuleStoreEnum.Type.mongo, 1, 2),
     )
     @ddt.unpack
     def test_course_listing_performance(self, store, courses_list_from_group_calls, courses_list_calls):
diff --git a/cms/djangoapps/contentstore/tests/test_course_settings.py b/cms/djangoapps/contentstore/tests/test_course_settings.py
index 3b36efb4a977..ab852d20bf7f 100644
--- a/cms/djangoapps/contentstore/tests/test_course_settings.py
+++ b/cms/djangoapps/contentstore/tests/test_course_settings.py
@@ -7,7 +7,7 @@
 import datetime
 import json
 import unittest
-from unittest import mock
+from unittest import mock, skip
 from unittest.mock import Mock, patch
 
 import ddt
@@ -40,7 +40,6 @@
 )
 from openedx.core.djangoapps.models.course_details import CourseDetails
 from xmodule.fields import Date  # lint-amnesty, pylint: disable=wrong-import-order
-from xmodule.modulestore import ModuleStoreEnum  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.django import modulestore  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.tests.factories import CourseFactory  # lint-amnesty, pylint: disable=wrong-import-order
 
@@ -542,10 +541,9 @@ def test_fetch_grader(self):
     @mock.patch('common.djangoapps.track.event_transaction_utils.uuid4')
     @mock.patch('cms.djangoapps.models.settings.course_grading.tracker')
     @mock.patch('cms.djangoapps.contentstore.signals.signals.GRADING_POLICY_CHANGED.send')
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_update_from_json(self, store, send_signal, tracker, uuid):
+    def test_update_from_json(self, send_signal, tracker, uuid):
         uuid.return_value = "mockUUID"
-        self.course = CourseFactory.create(default_store=store)
+        self.course = CourseFactory.create()
         test_grader = CourseGradingModel.fetch(self.course.id)
         # there should be no event raised after this call, since nothing got modified
         altered_grader = CourseGradingModel.update_from_json(self.course.id, test_grader.__dict__, self.user)
@@ -600,14 +598,13 @@ def test_update_from_json(self, store, send_signal, tracker, uuid):
             )
         ])
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_must_fire_grading_event_and_signal_multiple_type(self, store):
+    def test_must_fire_grading_event_and_signal_multiple_type(self):
         """
         Verifies that 'must_fire_grading_event_and_signal' ignores (returns False) if we modify
         short_label and or name
         use test_must_fire_grading_event_and_signal_multiple_type_2_split to run this test only
         """
-        self.course = CourseFactory.create(default_store=store)
+        self.course = CourseFactory.create()
         # .raw_grader approximates what our UI sends down. It uses decimal representation of percent
         # without it, the  weights would be percentages
         raw_grader_list = modulestore().get_course(self.course.id).raw_grader
@@ -626,14 +623,13 @@ def test_must_fire_grading_event_and_signal_multiple_type(self, store):
         self.assertTrue(result)
 
     @override_waffle_flag(MATERIAL_RECOMPUTE_ONLY_FLAG, True)
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_must_fire_grading_event_and_signal_multiple_type_waffle_on(self, store):
+    def test_must_fire_grading_event_and_signal_multiple_type_waffle_on(self):
         """
         Verifies that 'must_fire_grading_event_and_signal' ignores (returns False) if we modify
         short_label and or name
         use test_must_fire_grading_event_and_signal_multiple_type_2_split to run this test only
         """
-        self.course = CourseFactory.create(default_store=store)
+        self.course = CourseFactory.create()
         # .raw_grader approximates what our UI sends down. It uses decimal representation of percent
         # without it, the  weights would be percentages
         raw_grader_list = modulestore().get_course(self.course.id).raw_grader
@@ -651,14 +647,13 @@ def test_must_fire_grading_event_and_signal_multiple_type_waffle_on(self, store)
         )
         self.assertFalse(result)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_must_fire_grading_event_and_signal_return_true(self, store):
+    def test_must_fire_grading_event_and_signal_return_true(self):
         """
         Verifies that 'must_fire_grading_event_and_signal' ignores (returns False) if we modify
         short_label and or name
         use _2_split suffix to run this test only
         """
-        self.course = CourseFactory.create(default_store=store)
+        self.course = CourseFactory.create()
         # .raw_grader approximates what our UI sends down. It uses decimal representation of percent
         # without it, the  weights would be percentages
         raw_grader_list = modulestore().get_course(self.course.id).raw_grader
@@ -915,6 +910,7 @@ def setup_test_set_get_section_grader_ajax(self):
         section = sections[0]  # just take the first one
         return reverse_usage_url('xblock_handler', section.location)
 
+    @skip("OldMongo Deprecation")
     def test_set_get_section_grader_ajax(self):
         """
         Test setting and getting section grades via the grade as url
diff --git a/cms/djangoapps/contentstore/tests/test_courseware_index.py b/cms/djangoapps/contentstore/tests/test_courseware_index.py
index 9dbbfffdd059..c5454d3bde36 100644
--- a/cms/djangoapps/contentstore/tests/test_courseware_index.py
+++ b/cms/djangoapps/contentstore/tests/test_courseware_index.py
@@ -32,7 +32,6 @@
 from xmodule.modulestore.django import SignalHandler, modulestore  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.tests.django_utils import (  # lint-amnesty, pylint: disable=wrong-import-order
     ModuleStoreTestCase,
-    TEST_DATA_MONGO_MODULESTORE,
     SharedModuleStoreTestCase,
 )
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory, LibraryFactory  # lint-amnesty, pylint: disable=wrong-import-order
@@ -125,22 +124,21 @@ def update_item(self, store, item):
 
 
 @pytest.mark.django_db
-@ddt.ddt
 class TestCoursewareSearchIndexer(MixedWithOptionsTestCase):
     """ Tests the operation of the CoursewareSearchIndexer """
 
-    WORKS_WITH_STORES = (ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
     ENABLED_SIGNALS = ['course_deleted']
 
     def setUp(self):
         super().setUp()
-
         self.course = None
         self.chapter = None
         self.sequential = None
         self.vertical = None
         self.html_unit = None
 
+        self.setup_course_base(self.store)
+
     def setup_course_base(self, store):
         """
         Set up the for the course outline tests.
@@ -463,58 +461,45 @@ def _test_exception(self, store):
         with self.assertRaises(SearchIndexingError):
             self.reindex_course(store)
 
-    @ddt.data(*WORKS_WITH_STORES)
-    def test_indexing_course(self, store_type):
-        self._perform_test_using_store(store_type, self._test_indexing_course)
+    def test_indexing_course(self):
+        self._test_indexing_course(self.store)
 
-    @ddt.data(*WORKS_WITH_STORES)
-    def test_not_indexing_unpublished_content(self, store_type):
-        self._perform_test_using_store(store_type, self._test_not_indexing_unpublished_content)
+    def test_not_indexing_unpublished_content(self):
+        self._test_not_indexing_unpublished_content(self.store)
 
-    @ddt.data(*WORKS_WITH_STORES)
-    def test_deleting_item(self, store_type):
-        self._perform_test_using_store(store_type, self._test_deleting_item)
+    def test_deleting_item(self):
+        self._test_deleting_item(self.store)
 
-    @ddt.data(*WORKS_WITH_STORES)
-    def test_start_date_propagation(self, store_type):
-        self._perform_test_using_store(store_type, self._test_start_date_propagation)
+    def test_start_date_propagation(self):
+        self._test_start_date_propagation(self.store)
 
-    @ddt.data(*WORKS_WITH_STORES)
-    def test_search_disabled(self, store_type):
-        self._perform_test_using_store(store_type, self._test_search_disabled)
+    def test_search_disabled(self):
+        self._test_search_disabled(self.store)
 
-    @ddt.data(*WORKS_WITH_STORES)
-    def test_time_based_index(self, store_type):
-        self._perform_test_using_store(store_type, self._test_time_based_index)
+    def test_time_based_index(self):
+        self._test_time_based_index(self.store)
 
-    @ddt.data(*WORKS_WITH_STORES)
-    def test_exception(self, store_type):
-        self._perform_test_using_store(store_type, self._test_exception)
+    def test_exception(self):
+        self._test_exception(self.store)
 
-    @ddt.data(*WORKS_WITH_STORES)
-    def test_course_about_property_index(self, store_type):
-        self._perform_test_using_store(store_type, self._test_course_about_property_index)
+    def test_course_about_property_index(self):
+        self._test_course_about_property_index(self.store)
 
-    @ddt.data(*WORKS_WITH_STORES)
-    def test_course_about_store_index(self, store_type):
-        self._perform_test_using_store(store_type, self._test_course_about_store_index)
+    def test_course_about_store_index(self):
+        self._test_course_about_store_index(self.store)
 
-    @ddt.data(*WORKS_WITH_STORES)
-    def test_course_about_mode_index(self, store_type):
-        self._perform_test_using_store(store_type, self._test_course_about_mode_index)
+    def test_course_about_mode_index(self):
+        self._test_course_about_mode_index(self.store)
 
-    @ddt.data(*WORKS_WITH_STORES)
-    def test_course_location_info(self, store_type):
-        self._perform_test_using_store(store_type, self._test_course_location_info)
+    def test_course_location_info(self):
+        self._test_course_location_info(self.store)
 
-    @ddt.data(*WORKS_WITH_STORES)
-    def test_course_location_null(self, store_type):
-        self._perform_test_using_store(store_type, self._test_course_location_null)
+    def test_course_location_null(self):
+        self._test_course_location_null(self.store)
 
-    @ddt.data(*WORKS_WITH_STORES)
-    def test_delete_course_from_search_index_after_course_deletion(self, store_type):
+    def test_delete_course_from_search_index_after_course_deletion(self):
         """ Test for removing course from CourseAboutSearchIndexer """
-        self._perform_test_using_store(store_type, self._test_delete_course_from_search_index_after_course_deletion)
+        self._test_delete_course_from_search_index_after_course_deletion(self.store)
 
 
 @patch('django.conf.settings.SEARCH_ENGINE', 'search.tests.utils.ForceRefreshElasticSearchEngine')
@@ -522,8 +507,6 @@ def test_delete_course_from_search_index_after_course_deletion(self, store_type)
 class TestLargeCourseDeletions(MixedWithOptionsTestCase):
     """ Tests to excerise deleting items from a course """
 
-    WORKS_WITH_STORES = (ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-
     def _clean_course_id(self):
         """
         Clean all documents from the index that have a specific course provided.
@@ -540,6 +523,7 @@ def _clean_course_id(self):
     def setUp(self):
         super().setUp()
         self.course_id = None
+        self.setup_course_base(self.store)
 
     def tearDown(self):
         super().tearDown()
@@ -594,9 +578,8 @@ def _test_large_course_deletion(self, store):
 
     @skip("This test is to see how we handle very large courses, to ensure that the delete"
           "procedure works smoothly - too long to run during the normal course of things")
-    @ddt.data(*WORKS_WITH_STORES)
-    def test_large_course_deletion(self, store_type):
-        self._perform_test_using_store(store_type, self._test_large_course_deletion)
+    def test_large_course_deletion(self):
+        self._test_large_course_deletion(self.store)
 
 
 class TestTaskExecution(SharedModuleStoreTestCase):
@@ -1358,10 +1341,3 @@ def test_different_groups_indexed_on_same_vertical_html_blocks(self):
             self.assertIn(self._html_group_result(self.html_unit2, [1]), indexed_content)
             self.assertIn(self._html_group_result(self.html_unit3, [0]), indexed_content)
             mock_index.reset_mock()
-
-
-class GroupConfigurationSearchMongo(GroupConfigurationSearchSplit):  # pylint: disable=test-inherits-tests
-    """
-    Tests indexing of content groups on course modules using mongo modulestore.
-    """
-    MODULESTORE = TEST_DATA_MONGO_MODULESTORE
diff --git a/cms/djangoapps/contentstore/tests/test_export_git.py b/cms/djangoapps/contentstore/tests/test_export_git.py
index d853a7a4a3c1..f2e19b209cc5 100644
--- a/cms/djangoapps/contentstore/tests/test_export_git.py
+++ b/cms/djangoapps/contentstore/tests/test_export_git.py
@@ -7,6 +7,7 @@
 import os
 import shutil
 import subprocess
+from unittest import skip
 from uuid import uuid4
 
 from django.conf import settings
@@ -97,6 +98,7 @@ def test_exception_translation(self):
         response = self.client.get(f'{self.test_url}?action=push')
         self.assertNotContains(response, 'django.utils.functional.__proxy__')
 
+    @skip("OldMongo Deprecation")
     def test_course_export_success(self):
         """
         Test successful course export response.
@@ -106,6 +108,7 @@ def test_course_export_success(self):
         response = self.client.get(f'{self.test_url}?action=push')
         self.assertContains(response, 'Export Succeeded')
 
+    @skip("OldMongo Deprecation")
     def test_repo_with_dots(self):
         """
         Regression test for a bad directory pathing of repo's that have dots.
@@ -114,6 +117,7 @@ def test_repo_with_dots(self):
         response = self.client.get(f'{self.test_url}?action=push')
         self.assertContains(response, 'Export Succeeded')
 
+    @skip("OldMongo Deprecation")
     def test_dirty_repo(self):
         """
         Add additional items not in the repo and make sure they aren't
diff --git a/cms/djangoapps/contentstore/tests/test_i18n.py b/cms/djangoapps/contentstore/tests/test_i18n.py
index 30e031a43d53..b80a77adf4f7 100644
--- a/cms/djangoapps/contentstore/tests/test_i18n.py
+++ b/cms/djangoapps/contentstore/tests/test_i18n.py
@@ -9,7 +9,7 @@
 from django.utils import translation
 from django.utils.translation import get_language
 from xmodule.modulestore.django import ModuleI18nService
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, ModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
 
 from cms.djangoapps.contentstore.tests.utils import AjaxEnabledTestClient
@@ -55,9 +55,10 @@ def _translation(domain, localedir=None, languages=None):  # pylint: disable=unu
         return _translation
 
 
+@skip("OldMongo Deprecation")
 class TestModuleI18nService(ModuleStoreTestCase):
     """ Test ModuleI18nService """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         """ Setting up tests """
diff --git a/cms/djangoapps/contentstore/tests/test_import.py b/cms/djangoapps/contentstore/tests/test_import.py
index 4c63ecd735d8..b8ea250a7080 100644
--- a/cms/djangoapps/contentstore/tests/test_import.py
+++ b/cms/djangoapps/contentstore/tests/test_import.py
@@ -5,6 +5,7 @@
 
 
 import copy
+from unittest import skip
 from unittest.mock import patch
 from uuid import uuid4
 
@@ -18,7 +19,6 @@
 from xmodule.modulestore import ModuleStoreEnum
 from xmodule.modulestore.django import modulestore
 from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
-from xmodule.modulestore.tests.factories import check_exact_number_of_calls, check_number_of_calls
 from xmodule.modulestore.xml_importer import import_course_from_xml
 
 TEST_DATA_CONTENTSTORE = copy.deepcopy(settings.CONTENTSTORE)
@@ -175,31 +175,15 @@ def test_tab_name_imports_correctly(self):
         print(f"course tabs = {course.tabs}")
         self.assertEqual(course.tabs[1]['name'], 'Syllabus')
 
-    def test_import_performance_mongo(self):
-        store = modulestore()._get_modulestore_by_type(ModuleStoreEnum.Type.mongo)
-
-        # we try to refresh the inheritance tree for each update_item in the import
-        with check_exact_number_of_calls(store, 'refresh_cached_metadata_inheritance_tree', 28):
-
-            # _get_cached_metadata_inheritance_tree should be called once
-            with check_exact_number_of_calls(store, '_get_cached_metadata_inheritance_tree', 1):
-
-                # with bulk-edit in progress, the inheritance tree should be recomputed only at the end of the import
-                # NOTE: On Jenkins, with memcache enabled, the number of calls here is 1.
-                #       Locally, without memcache, the number of calls is 1 (publish no longer counted)
-                with check_number_of_calls(store, '_compute_metadata_inheritance_tree', 1):
-                    self.load_test_import_course(create_if_not_present=False, module_store=store)
-
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_reimport(self, default_ms_type):
-        with modulestore().default_store(default_ms_type):
-            __, __, course = self.load_test_import_course(create_if_not_present=True)
-            self.load_test_import_course(target_id=course.id)
+    def test_reimport(self):
+        __, __, course = self.load_test_import_course(create_if_not_present=True)
+        self.load_test_import_course(target_id=course.id)
 
+    @skip("OldMongo Deprecation")
     def test_rewrite_reference_list(self):
         # This test fails with split modulestore (the HTML component is not in "different_course_id" namespace).
         # More investigation needs to be done.
-        module_store = modulestore()._get_modulestore_by_type(ModuleStoreEnum.Type.mongo)
+        module_store = modulestore()
         target_id = module_store.make_course_key('testX', 'conditional_copy', 'copy_run')
         import_course_from_xml(
             module_store,
@@ -272,22 +256,20 @@ def _verify_split_test_import(self, target_course_name, source_course_name, spli
 
         self.assertEqual(remapped_verticals, split_test_module.group_id_to_child)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_video_components_present_while_import(self, store):
+    def test_video_components_present_while_import(self):
         """
         Test that video components with same edx_video_id are present while re-importing
         """
-        with modulestore().default_store(store):
-            module_store = modulestore()
-            course_id = module_store.make_course_key('edX', 'test_import_course', '2012_Fall')
+        module_store = modulestore()
+        course_id = module_store.make_course_key('edX', 'test_import_course', '2012_Fall')
 
-            # Import first time
-            __, __, course = self.load_test_import_course(target_id=course_id, module_store=module_store)
+        # Import first time
+        __, __, course = self.load_test_import_course(target_id=course_id, module_store=module_store)
 
-            # Re-import
-            __, __, re_course = self.load_test_import_course(target_id=course.id, module_store=module_store)
+        # Re-import
+        __, __, re_course = self.load_test_import_course(target_id=course.id, module_store=module_store)
 
-            vertical = module_store.get_item(re_course.id.make_usage_key('vertical', 'vertical_test'))
+        vertical = module_store.get_item(re_course.id.make_usage_key('vertical', 'vertical_test'))
 
-            video = module_store.get_item(vertical.children[1])
-            self.assertEqual(video.display_name, 'default')
+        video = module_store.get_item(vertical.children[1])
+        self.assertEqual(video.display_name, 'default')
diff --git a/cms/djangoapps/contentstore/tests/test_import_pure_xblock.py b/cms/djangoapps/contentstore/tests/test_import_pure_xblock.py
index a4a4368bdf59..63e5e26b82e7 100644
--- a/cms/djangoapps/contentstore/tests/test_import_pure_xblock.py
+++ b/cms/djangoapps/contentstore/tests/test_import_pure_xblock.py
@@ -7,7 +7,6 @@
 from xblock.core import XBlock
 from xblock.fields import String
 
-from xmodule.modulestore import ModuleStoreEnum
 from xmodule.modulestore.django import modulestore
 from xmodule.modulestore.mongo.draft import as_draft
 from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
@@ -41,14 +40,6 @@ def test_import_public(self):
             'set by xml'
         )
 
-    @XBlock.register_temp_plugin(StubXBlock)
-    def test_import_draft(self):
-        self._assert_import(
-            'pure_xblock_draft',
-            'set by xml',
-            has_draft=True
-        )
-
     def _assert_import(self, course_dir, expected_field_val, has_draft=False):
         """
         Import a course from XML, then verify that the XBlock was loaded
@@ -66,7 +57,7 @@ def _assert_import(self, course_dir, expected_field_val, has_draft=False):
         """
         # It is necessary to use the "old mongo" modulestore because split doesn't work
         # with the "has_draft" logic below.
-        store = modulestore()._get_modulestore_by_type(ModuleStoreEnum.Type.mongo)  # pylint: disable=protected-access
+        store = modulestore()
         courses = import_course_from_xml(
             store, self.user.id, TEST_DATA_DIR, [course_dir], create_if_not_present=True
         )
diff --git a/cms/djangoapps/contentstore/tests/test_libraries.py b/cms/djangoapps/contentstore/tests/test_libraries.py
index 91dc14983b86..feb13882f2da 100644
--- a/cms/djangoapps/contentstore/tests/test_libraries.py
+++ b/cms/djangoapps/contentstore/tests/test_libraries.py
@@ -1014,28 +1014,3 @@ def test_duplicated_version(self):
         self.assertEqual(self.lc_block.source_library_version, duplicate.source_library_version)
         problem2_in_course = store.get_item(duplicate.children[0])
         self.assertEqual(problem2_in_course.display_name, self.original_display_name)
-
-
-class TestIncompatibleModuleStore(LibraryTestCase):
-    """
-    Tests for proper validation errors with an incompatible course modulestore.
-    """
-
-    def setUp(self):
-        super().setUp()
-        # Create a course in an incompatible modulestore.
-        with modulestore().default_store(ModuleStoreEnum.Type.mongo):
-            self.course = CourseFactory.create()
-
-        # Add a LibraryContent block to the course:
-        self.lc_block = self._add_library_content_block(self.course, self.lib_key)
-
-    def test_incompatible_modulestore(self):
-        """
-        Verifies that, if a user is using a modulestore that doesn't support libraries,
-        a validation error will be produced.
-        """
-        validation = self.lc_block.validate()
-        self.assertEqual(validation.summary.type, validation.summary.ERROR)
-        self.assertIn(
-            "This course does not support content libraries.", validation.summary.text)
diff --git a/cms/djangoapps/contentstore/tests/test_orphan.py b/cms/djangoapps/contentstore/tests/test_orphan.py
index e0489f73e6e7..6431f698783c 100644
--- a/cms/djangoapps/contentstore/tests/test_orphan.py
+++ b/cms/djangoapps/contentstore/tests/test_orphan.py
@@ -80,12 +80,11 @@ class TestOrphan(TestOrphanBase):
     Test finding orphans via view and django config
     """
 
-    @ddt.data(ModuleStoreEnum.Type.split, ModuleStoreEnum.Type.mongo)
-    def test_get_orphans(self, default_store):
+    def test_get_orphans(self):
         """
         Test that the orphan handler finds the orphans
         """
-        course = self.create_course_with_orphans(default_store)
+        course = self.create_course_with_orphans(ModuleStoreEnum.Type.split)
         orphan_url = reverse_course_url('orphan_handler', course.id)
 
         orphans = json.loads(
@@ -104,7 +103,6 @@ def test_get_orphans(self, default_store):
 
     @ddt.data(
         (ModuleStoreEnum.Type.split, 5, 3),
-        (ModuleStoreEnum.Type.mongo, 34, 12),
     )
     @ddt.unpack
     def test_delete_orphans(self, default_store, max_mongo_calls, min_mongo_calls):
@@ -126,12 +124,11 @@ def test_delete_orphans(self, default_store, max_mongo_calls, min_mongo_calls):
         # parent are not deleted
         self.assertTrue(self.store.has_item(course.id.make_usage_key('html', "multi_parent_html")))
 
-    @ddt.data(ModuleStoreEnum.Type.split, ModuleStoreEnum.Type.mongo)
-    def test_not_permitted(self, default_store):
+    def test_not_permitted(self):
         """
         Test that auth restricts get and delete appropriately
         """
-        course = self.create_course_with_orphans(default_store)
+        course = self.create_course_with_orphans(ModuleStoreEnum.Type.split)
         orphan_url = reverse_course_url('orphan_handler', course.id)
 
         test_user_client, test_user = self.create_non_staff_authed_user_client()
diff --git a/cms/djangoapps/contentstore/tests/test_proctoring.py b/cms/djangoapps/contentstore/tests/test_proctoring.py
index d398bc896a59..95eba736f665 100644
--- a/cms/djangoapps/contentstore/tests/test_proctoring.py
+++ b/cms/djangoapps/contentstore/tests/test_proctoring.py
@@ -4,6 +4,7 @@
 
 
 from datetime import datetime, timedelta
+from unittest import skip
 from unittest.mock import patch
 
 import ddt
@@ -11,20 +12,21 @@
 from edx_proctoring.api import get_all_exams_for_course, get_review_policy_by_exam_id
 from pytz import UTC
 from xmodule.modulestore import ModuleStoreEnum
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, ModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
 
 from cms.djangoapps.contentstore.signals.handlers import listen_for_course_publish
 from common.djangoapps.student.tests.factories import UserFactory
 
 
+@skip("OldMongo Deprecation")
 @ddt.ddt
 @patch.dict('django.conf.settings.FEATURES', {'ENABLE_SPECIAL_EXAMS': True})
 class TestProctoredExams(ModuleStoreTestCase):
     """
     Tests for the publishing of proctored exams
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         """
diff --git a/cms/djangoapps/contentstore/tests/test_tasks.py b/cms/djangoapps/contentstore/tests/test_tasks.py
index ad904e3e4b9d..d037f1d99c2d 100644
--- a/cms/djangoapps/contentstore/tests/test_tasks.py
+++ b/cms/djangoapps/contentstore/tests/test_tasks.py
@@ -23,6 +23,7 @@
 from common.djangoapps.student.tests.factories import UserFactory
 from openedx.core.djangoapps.embargo.models import Country, CountryAccessRule, RestrictedCourse
 from xmodule.modulestore.django import modulestore  # lint-amnesty, pylint: disable=wrong-import-order
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE
 
 TEST_DATA_CONTENTSTORE = copy.deepcopy(settings.CONTENTSTORE)
 TEST_DATA_CONTENTSTORE['DOC_STORE_CONFIG']['db'] = 'test_xcontent_%s' % uuid4().hex
@@ -117,6 +118,9 @@ def test_success(self):
 
 @override_settings(CONTENTSTORE=TEST_DATA_CONTENTSTORE)
 class RerunCourseTaskTestCase(CourseTestCase):  # lint-amnesty, pylint: disable=missing-class-docstring
+
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
+
     def _rerun_course(self, old_course_key, new_course_key):
         CourseRerunState.objects.initiated(old_course_key, new_course_key, self.user, 'Test Re-run')
         rerun_course(str(old_course_key), str(new_course_key), self.user.id)
diff --git a/cms/djangoapps/contentstore/tests/test_users_default_role.py b/cms/djangoapps/contentstore/tests/test_users_default_role.py
index 82bd4e960b9e..5698073bfad4 100644
--- a/cms/djangoapps/contentstore/tests/test_users_default_role.py
+++ b/cms/djangoapps/contentstore/tests/test_users_default_role.py
@@ -3,7 +3,8 @@
 after deleting it creates same course again
 """
 
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, ModuleStoreTestCase
+from unittest import skip
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase
 
 from cms.djangoapps.contentstore.tests.utils import AjaxEnabledTestClient
 from cms.djangoapps.contentstore.utils import delete_course, reverse_url
@@ -15,7 +16,7 @@ class TestUsersDefaultRole(ModuleStoreTestCase):
     """
     Unit tests for checking enrollment and default forum role "Student" of a logged in user
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         """
@@ -92,6 +93,7 @@ def test_user_role_on_course_recreate(self):
         # check that user has his default "Student" forum role for this course
         self.assertTrue(self.user.roles.filter(name="Student", course_id=self.course_key))
 
+    @skip("OldMongo Deprecation")
     def test_user_role_on_course_recreate_with_change_name_case(self):
         """
         Test that creating same course again with different name case after deleting it gives user
diff --git a/cms/djangoapps/contentstore/tests/test_utils.py b/cms/djangoapps/contentstore/tests/test_utils.py
index b166de0ef9c7..80c4cdce59fb 100644
--- a/cms/djangoapps/contentstore/tests/test_utils.py
+++ b/cms/djangoapps/contentstore/tests/test_utils.py
@@ -1,7 +1,7 @@
 """ Tests for utils. """
 import collections
 from datetime import datetime, timedelta
-from unittest import mock
+from unittest import mock, skip
 from unittest.mock import Mock, patch
 from uuid import uuid4
 
@@ -411,6 +411,7 @@ def verify_all_components_visible_to_all():
 
         verify_all_components_visible_to_all()
 
+    @skip("OldMongo Deprecation")
     def test_sequential_and_problem_have_group_access(self):
         """ Tests when group_access is set on a few different components. """
         self.set_group_access(self.sequential, {1: [0]})
diff --git a/cms/djangoapps/contentstore/tests/utils.py b/cms/djangoapps/contentstore/tests/utils.py
index fabfb2c75fd7..54455bdf3841 100644
--- a/cms/djangoapps/contentstore/tests/utils.py
+++ b/cms/djangoapps/contentstore/tests/utils.py
@@ -10,12 +10,12 @@
 from django.conf import settings
 from django.contrib.auth.models import User  # lint-amnesty, pylint: disable=imported-auth-user
 from django.test.client import Client
-from opaque_keys.edx.keys import AssetKey, CourseKey
+from opaque_keys.edx.keys import AssetKey
 from xmodule.contentstore.django import contentstore
 from xmodule.modulestore import ModuleStoreEnum
 from xmodule.modulestore.inheritance import own_metadata
 from xmodule.modulestore.split_mongo.split import SplitMongoModuleStore
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_MODULESTORE, ModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory
 from xmodule.modulestore.tests.utils import ProceduralCourseTestMixin
 from xmodule.modulestore.xml_importer import import_course_from_xml
@@ -74,7 +74,7 @@ class CourseTestCase(ProceduralCourseTestMixin, ModuleStoreTestCase):
     Base class for Studio tests that require a logged in user and a course.
     Also provides helper methods for manipulating and verifying the course.
     """
-    MODULESTORE = TEST_DATA_MONGO_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         """
@@ -124,15 +124,18 @@ def save_course(self):
     SEQUENTIAL = 'vertical_sequential'
     DRAFT_HTML = 'draft_html'
     DRAFT_VIDEO = 'draft_video'
-    LOCKED_ASSET_KEY = AssetKey.from_string('/c4x/edX/toy/asset/sample_static.html')
+    LOCKED_ASSET_KEY = AssetKey.from_string('asset-v1:edX+toy+2012_Fall+type@asset+block@sample_static.html')
 
     def import_and_populate_course(self):
         """
         Imports the test toy course and populates it with additional test data
         """
         content_store = contentstore()
-        import_course_from_xml(self.store, self.user.id, TEST_DATA_DIR, ['toy'], static_content_store=content_store)
-        course_id = CourseKey.from_string('/'.join(['edX', 'toy', '2012_Fall']))
+        import_course_from_xml(
+            self.store, self.user.id, TEST_DATA_DIR, ['toy'], static_content_store=content_store, verbose=True,
+            create_if_not_present=True
+        )
+        course_id = self.store.make_course_key('edX', 'toy', '2012_Fall')
 
         # create an Orphan
         # We had a bug where orphaned draft nodes caused export to fail. This is here to cover that case.
@@ -155,11 +158,6 @@ def import_and_populate_course(self):
         orphan_draft_vertical.children.append(orphan_draft_html.location)
         self.store.update_item(orphan_draft_vertical, self.user.id)
 
-        # create a Draft vertical
-        vertical = self.store.get_item(course_id.make_usage_key('vertical', self.TEST_VERTICAL), depth=1)
-        draft_vertical = self.store.convert_to_draft(vertical.location, self.user.id)
-        self.assertTrue(self.store.has_published_version(draft_vertical))
-
         # create a Private (draft only) vertical
         private_vertical = self.store.create_item(self.user.id, course_id, 'vertical', self.PRIVATE_VERTICAL)
         self.assertFalse(self.store.has_published_version(private_vertical))
@@ -185,24 +183,10 @@ def import_and_populate_course(self):
         self.store.update_item(public_vertical, self.user.id)
         # publish changes to vertical
         self.store.publish(public_vertical.location, self.user.id)
-        # convert html/video to draft
-        self.store.convert_to_draft(draft_html.location, self.user.id)
-        self.store.convert_to_draft(draft_video.location, self.user.id)
 
         # lock an asset
         content_store.set_attr(self.LOCKED_ASSET_KEY, 'locked', True)
 
-        # create a non-portable link - should be rewritten in new courses
-        html_module = self.store.get_item(course_id.make_usage_key('html', 'nonportable'))
-        new_data = html_module.data = html_module.data.replace(
-            '/static/',
-            f'/c4x/{course_id.org}/{course_id.course}/asset/'
-        )
-        self.store.update_item(html_module, self.user.id)
-
-        html_module = self.store.get_item(html_module.location)
-        self.assertEqual(new_data, html_module.data)
-
         return course_id
 
     def check_populated_course(self, course_id):
@@ -234,12 +218,7 @@ def get_and_verify_publish_state(item_type, item_name, publish_state):
         for child in vertical.get_children():
             verify_item_publish_state(child, True)
 
-        # verify that it has a draft too
-        self.assertTrue(getattr(vertical, "is_draft", False))
-
-        # make sure that we don't have a sequential that is in draft mode
         sequential = get_and_verify_publish_state('sequential', self.SEQUENTIAL, True)
-        self.assertFalse(getattr(sequential, "is_draft", False))
 
         # verify that we have the private vertical
         private_vertical = get_and_verify_publish_state('vertical', self.PRIVATE_VERTICAL, False)
@@ -248,22 +227,20 @@ def get_and_verify_publish_state(item_type, item_name, publish_state):
         public_vertical = get_and_verify_publish_state('vertical', self.PUBLISHED_VERTICAL, True)
 
         # verify that we have the draft html
-        draft_html = self.store.get_item(course_id.make_usage_key('html', self.DRAFT_HTML))
-        self.assertTrue(getattr(draft_html, 'is_draft', False))
+        html = self.store.get_item(course_id.make_usage_key('html', self.DRAFT_HTML))
 
         # verify that we have the draft video
-        draft_video = self.store.get_item(course_id.make_usage_key('video', self.DRAFT_VIDEO))
-        self.assertTrue(getattr(draft_video, 'is_draft', False))
+        video = self.store.get_item(course_id.make_usage_key('video', self.DRAFT_VIDEO))
 
         # verify verticals are children of sequential
         for vert in [vertical, private_vertical, public_vertical]:
             self.assertIn(vert.location, sequential.children)
 
         # verify draft html is the child of the public vertical
-        self.assertIn(draft_html.location, public_vertical.children)
+        self.assertIn(html.location, public_vertical.children)
 
         # verify draft video is the child of the public vertical
-        self.assertIn(draft_video.location, public_vertical.children)
+        self.assertIn(video.location, public_vertical.children)
 
         # verify textbook exists
         course = self.store.get_course(course_id)
diff --git a/cms/djangoapps/contentstore/views/tests/test_assets.py b/cms/djangoapps/contentstore/views/tests/test_assets.py
index 6ee861888809..ea6c0d35de38 100644
--- a/cms/djangoapps/contentstore/views/tests/test_assets.py
+++ b/cms/djangoapps/contentstore/views/tests/test_assets.py
@@ -6,7 +6,7 @@
 import json
 from datetime import datetime
 from io import BytesIO
-from unittest import mock
+from unittest import mock, skip
 from unittest.mock import patch
 
 from ddt import data, ddt
@@ -73,6 +73,7 @@ def get_sample_asset(self, name, asset_type='text'):
         return sample_asset
 
 
+@skip("OldMongo Deprecation")
 class BasicAssetsTestCase(AssetsTestCase):
     """
     Test getting assets via html w/o additional args
@@ -439,6 +440,7 @@ def test_basic(self):
         self.assertIsNone(output["thumbnail"])
 
 
+@skip("OldMongo Deprecation")
 class LockAssetTestCase(AssetsTestCase):
     """
     Unit test for locking and unlocking an asset.
@@ -499,6 +501,7 @@ def post_asset_update(lock, course):
         verify_asset_locked_state(False)
 
 
+@skip("OldMongo Deprecation")
 class DeleteAssetTestCase(AssetsTestCase):
     """
     Unit test for removing an asset.
diff --git a/cms/djangoapps/contentstore/views/tests/test_container_page.py b/cms/djangoapps/contentstore/views/tests/test_container_page.py
index 599cd4f51957..a6546deb11fb 100644
--- a/cms/djangoapps/contentstore/views/tests/test_container_page.py
+++ b/cms/djangoapps/contentstore/views/tests/test_container_page.py
@@ -5,6 +5,7 @@
 
 import datetime
 import re
+from unittest import skip
 from unittest.mock import Mock, patch
 
 from django.http import Http404
@@ -190,11 +191,12 @@ def _create_item(self, parent_location, category, display_name, **kwargs):
             **kwargs
         )
 
+    @skip("OldMongo Deprecation")
     def test_public_child_container_preview_html(self):
         """
         Verify that a public container rendered as a child of the container page returns the expected HTML.
         """
-        empty_child_container = self._create_item(self.vertical.location, 'split_test', 'Split Test')
+        empty_child_container = self._create_item(self.vertical.location, 'split_test', 'Split Test 1')
         published_empty_child_container = self.store.publish(empty_child_container.location, self.user.id)
         self.validate_preview_html(published_empty_child_container, self.reorderable_child_view, can_add=False)
 
@@ -202,7 +204,7 @@ def test_draft_child_container_preview_html(self):
         """
         Verify that a draft container rendered as a child of the container page returns the expected HTML.
         """
-        empty_child_container = self._create_item(self.vertical.location, 'split_test', 'Split Test')
+        empty_child_container = self._create_item(self.vertical.location, 'split_test', 'Split Test 1')
         self.validate_preview_html(empty_child_container, self.reorderable_child_view, can_add=False)
 
     @patch(
diff --git a/cms/djangoapps/contentstore/views/tests/test_course_index.py b/cms/djangoapps/contentstore/views/tests/test_course_index.py
index 04b66498b01d..2c524de6a9a1 100644
--- a/cms/djangoapps/contentstore/views/tests/test_course_index.py
+++ b/cms/djangoapps/contentstore/views/tests/test_course_index.py
@@ -96,6 +96,7 @@ def _assert_library_tab_present(response):
         index_response = self.client.get(index_url, {}, HTTP_ACCEPT='text/html')
         _assert_library_tab_present(index_response)
 
+    @skip("OldMongo Deprecation")
     def test_is_staff_access(self):
         """
         Test that people with is_staff see the courses and can navigate into them
@@ -115,6 +116,7 @@ def test_negative_conditions(self):
         else:
             self.assertEqual(response.status_code, 403)
 
+    @skip("OldMongo Deprecation")
     def test_course_staff_access(self):
         """
         Make and register course_staff and ensure they can access the courses
@@ -584,6 +586,7 @@ def _verify_deprecated_info(self, course_id, advanced_modules, info, deprecated_
             reverse_course_url('advanced_settings_handler', course_id)
         )
 
+    @skip("OldMongo Deprecation")
     @ddt.data(
         [{'publish': True}, ['notes']],
         [{'publish': False}, ['notes']],
@@ -604,6 +607,7 @@ def test_verify_deprecated_warning_message(self, publish, block_types):
             block_types
         )
 
+    @skip("OldMongo Deprecation")
     @ddt.data(
         (["a", "b", "c"], ["a", "b", "c"]),
         (["a", "b", "c"], ["a", "b", "d"]),
@@ -835,6 +839,7 @@ def test_reindex_seq_error_json_responses(self, mock_index_dictionary):
         with self.assertRaises(SearchIndexingError):
             reindex_course_and_check_access(self.course.id, self.user)
 
+    @skip("OldMongo Deprecation")
     @mock.patch('xmodule.modulestore.mongo.base.MongoModuleStore.get_course')
     def test_reindex_no_item(self, mock_get_course):
         """
@@ -923,6 +928,7 @@ def test_indexing_html_error_responses(self, mock_index_dictionary):
         with self.assertRaises(SearchIndexingError):
             CoursewareSearchIndexer.do_course_reindex(modulestore(), self.course.id)
 
+    @skip("OldMongo Deprecation")
     @mock.patch('xmodule.seq_module.SequenceBlock.index_dictionary')
     def test_indexing_seq_error_responses(self, mock_index_dictionary):
         """
@@ -945,7 +951,8 @@ def test_indexing_seq_error_responses(self, mock_index_dictionary):
         with self.assertRaises(SearchIndexingError):
             CoursewareSearchIndexer.do_course_reindex(modulestore(), self.course.id)
 
-    @mock.patch('xmodule.modulestore.mongo.base.MongoModuleStore.get_course')
+    @skip("OldMongo Deprecation")
+    @mock.patch('xmodule.modulestore.split_mongo.split.SplitMongoModuleStore.get_course')
     def test_indexing_no_item(self, mock_get_course):
         """
         Test system logs an error if no item found.
diff --git a/cms/djangoapps/contentstore/views/tests/test_group_configurations.py b/cms/djangoapps/contentstore/views/tests/test_group_configurations.py
index 728d2d980890..0d95abfc96d2 100644
--- a/cms/djangoapps/contentstore/views/tests/test_group_configurations.py
+++ b/cms/djangoapps/contentstore/views/tests/test_group_configurations.py
@@ -5,6 +5,7 @@
 
 import json
 from operator import itemgetter
+from unittest import skip
 from unittest.mock import patch
 
 import ddt
@@ -64,9 +65,9 @@ def _create_content_experiment(self, cid=-1, group_id=None, cid_for_problem=None
             parent_location=sequential.location,
             display_name=f'Test Unit {name_suffix}'
         )
-        c0_url = self.course.id.make_usage_key("vertical", "split_test_cond0")
-        c1_url = self.course.id.make_usage_key("vertical", "split_test_cond1")
-        c2_url = self.course.id.make_usage_key("vertical", "split_test_cond2")
+        c0_url = self.course.id.make_usage_key("vertical", f"split_test_cond0_{name_suffix}")
+        c1_url = self.course.id.make_usage_key("vertical", f"split_test_cond1_{name_suffix}")
+        c2_url = self.course.id.make_usage_key("vertical", f"split_test_cond2_{name_suffix}")
         split_test = ItemFactory.create(
             category='split_test',
             parent_location=vertical.location,
@@ -770,13 +771,12 @@ def test_can_get_correct_usage_info_for_content_groups(self):
 
         self.assertEqual(actual, expected)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_can_get_correct_usage_info_with_orphan(self, module_store_type):
+    def test_can_get_correct_usage_info_with_orphan(self):
         """
         Test if content group json updated successfully with usage information
         even if there is an orphan in content group.
         """
-        self.course = CourseFactory.create(default_store=module_store_type)
+        self.course = CourseFactory.create()
         self._add_user_partitions(count=1, scheme_id='cohort')
         vertical, __ = self._create_problem_with_content_group(cid=0, group_id=1, name_suffix='0', orphan=True)
 
@@ -784,16 +784,8 @@ def test_can_get_correct_usage_info_with_orphan(self, module_store_type):
         self.assertEqual(len(self.store.get_orphans(self.course.id)), 1)
         self.assertIn(vertical.location, self.store.get_orphans(self.course.id))
 
-        # Get the expected content group information based on module store.
-        if module_store_type == ModuleStoreEnum.Type.mongo:
-            expected = self._get_expected_content_group(usage_for_group=[
-                {
-                    'url': f'/container/{vertical.location}',
-                    'label': 'Test Unit 0 / Test Problem 0'
-                }
-            ])
-        else:
-            expected = self._get_expected_content_group(usage_for_group=[])
+        # Get the expected content group information.
+        expected = self._get_expected_content_group(usage_for_group=[])
 
         # Get the actual content group information
         actual = self._get_user_partition('cohort')
@@ -801,6 +793,7 @@ def test_can_get_correct_usage_info_with_orphan(self, module_store_type):
         # Assert that actual content group information is same as expected one.
         self.assertEqual(actual, expected)
 
+    @skip("OldMongo Deprecation")
     def test_can_use_one_content_group_in_multiple_problems(self):
         """
         Test if multiple problems are present in usage info when they use same
@@ -848,6 +841,7 @@ def test_group_configuration_not_used(self):
         }]
         self.assertEqual(actual, expected)
 
+    @skip("OldMongo Deprecation")
     def test_can_get_correct_usage_info_for_split_test(self):
         """
         When a split test is created and content group access is set for a problem within a group,
@@ -1060,6 +1054,7 @@ def test_can_use_one_configuration_in_multiple_experiments(self):
         }]
         self.assertEqual(actual, expected)
 
+    @skip("OldMongo Deprecation")
     def test_can_handle_without_parent(self):
         """
         Test if it possible to handle case when split_test has no parent.
diff --git a/cms/djangoapps/contentstore/views/tests/test_import_export.py b/cms/djangoapps/contentstore/views/tests/test_import_export.py
index 280ea4d469b6..68e7bd9ccb9f 100644
--- a/cms/djangoapps/contentstore/views/tests/test_import_export.py
+++ b/cms/djangoapps/contentstore/views/tests/test_import_export.py
@@ -6,7 +6,6 @@
 import json
 import logging
 import os
-import re
 import shutil
 import tarfile
 import tempfile
@@ -28,6 +27,7 @@
 from storages.backends.s3boto import S3BotoStorage
 from storages.backends.s3boto3 import S3Boto3Storage
 from user_tasks.models import UserTaskStatus
+from xblock.plugin import PluginMissingError
 
 from cms.djangoapps.contentstore import errors as import_error
 from cms.djangoapps.contentstore.storage import course_import_export_storage
@@ -749,36 +749,11 @@ def test_unknown_xblock_top_level(self):
         """
         Export unknown XBlock type (i.e. we uninstalled the XBlock), top level.
         """
-        fake_xblock = ItemFactory.create(
-            parent_location=self.course.location,
-            category='not_a_real_block_type'
-        )
-        self.store.publish(fake_xblock.location, self.user.id)
-
-        # Now check the resulting export
-        tar_ball = self.test_export_async()
-        course_file_path = next(
-            path for path in tar_ball.getnames()
-            if re.match(r'\w+/course/\w+.xml', path)
-        )
-        course_file = tar_ball.extractfile(course_file_path)
-        course_xml = lxml.etree.parse(course_file)
-        course_elem = course_xml.getroot()
-
-        # The course run file still has a child pointer to the unknown type and
-        # creates the <not_a_real_block_type url="..."> pointer tag...
-        self.assertEqual(course_elem.tag, 'course')
-        unknown_elem = course_elem[0]
-        self.assertEqual(unknown_elem.tag, 'not_a_real_block_type')
-        # Non empty url_name attribute (the generated ID)
-        self.assertTrue(unknown_elem.attrib['url_name'])
-
-        # But there should be no file exported for our fake block type. Without
-        # the XBlock installed, we don't know how to serialize it properly.
-        assert not any(
-            '/not_a_real_block_type/' in path
-            for path in tar_ball.getnames()
-        )
+        with self.assertRaisesMessage(PluginMissingError, 'not_a_real_block_type'):
+            ItemFactory.create(
+                parent_location=self.course.location,
+                category='not_a_real_block_type'
+            )
 
     def test_unknown_xblock_subsection_level(self):
         """
@@ -789,46 +764,11 @@ def test_unknown_xblock_subsection_level(self):
             category='vertical',
             display_name='sample_vertical',
         )
-        fake_xblock = ItemFactory.create(
-            parent_location=vertical.location,
-            category='not_a_real_block_type',
-        )
-        self.store.publish(fake_xblock.location, self.user.id)
-
-        # Now check the resulting export
-        tar_ball = self.test_export_async()
-        course_file_path = next(
-            path for path in tar_ball.getnames()
-            if re.match(r'\w+/course/\w+.xml', path)
-        )
-        course_file = tar_ball.extractfile(course_file_path)
-        course_xml = lxml.etree.parse(course_file)
-        course_elem = course_xml.getroot()
-
-        # The course run file should have a vertical that points to the
-        # non-existant block.
-        self.assertEqual(course_elem.tag, 'course')
-        self.assertEqual(course_elem[0].tag, 'vertical')  # This is just a reference
-
-        vert_file_path = next(
-            path for path in tar_ball.getnames()
-            if re.match(r'\w+/vertical/\w+.xml', path)
-        )
-        vert_file = tar_ball.extractfile(vert_file_path)
-        vert_xml = lxml.etree.parse(vert_file)
-        vert_elem = vert_xml.getroot()
-        self.assertEqual(vert_elem.tag, 'vertical')
-        self.assertEqual(len(vert_elem), 1)
-        unknown_elem = vert_elem[0]
-        self.assertEqual(unknown_elem.tag, 'not_a_real_block_type')
-        # Non empty url_name attribute (the generated ID)
-        self.assertTrue(unknown_elem.attrib['url_name'])
-
-        # There should be no file exported for our fake block type
-        assert not any(
-            '/not_a_real_block_type/' in path
-            for path in tar_ball.getnames()
-        )
+        with self.assertRaisesMessage(PluginMissingError, 'not_a_real_block_type'):
+            ItemFactory.create(
+                parent_location=vertical.location,
+                category='not_a_real_block_type',
+            )
 
     def _verify_export_failure(self, expected_text):
         """ Export failure helper method. """
diff --git a/cms/djangoapps/contentstore/views/tests/test_item.py b/cms/djangoapps/contentstore/views/tests/test_item.py
index 055cea6401c2..be3ef7ad1e86 100644
--- a/cms/djangoapps/contentstore/views/tests/test_item.py
+++ b/cms/djangoapps/contentstore/views/tests/test_item.py
@@ -4,6 +4,7 @@
 import json
 import re
 from datetime import datetime, timedelta
+from unittest import skip
 from unittest.mock import Mock, PropertyMock, patch
 
 import ddt
@@ -92,13 +93,11 @@ def setUp(self):
         self.course_key = self.course.id
         self.usage_key = self.course.location
 
-    def get_item_from_modulestore(self, usage_key, verify_is_draft=False):
+    def get_item_from_modulestore(self, usage_key):
         """
         Get the item referenced by the UsageKey from the modulestore
         """
         item = self.store.get_item(usage_key)
-        if verify_is_draft:
-            self.assertTrue(getattr(item, 'is_draft', False))
         return item
 
     def response_usage_key(self, response):
@@ -167,6 +166,7 @@ def _get_container_preview_with_error(self, usage_key, expected_code, data=None,
             self.assertContains(resp, content_contains, status_code=expected_code)
         return resp
 
+    @skip("OldMongo Deprecation")
     @ddt.data(
         (1, 17, 15, 16, 12),
         (2, 17, 15, 16, 12),
@@ -185,13 +185,14 @@ def test_get_query_count(self, branching_factor, chapter_queries, section_querie
         with check_mongo_calls(problem_queries):
             self.client.get(reverse_usage_url('xblock_handler', self.populated_usage_keys['problem'][-1]))
 
+    @skip("OldMongo Deprecation")
     @ddt.data(
         (1, 30),
         (2, 32),
         (3, 34),
     )
     @ddt.unpack
-    def test_container_get_query_count(self, branching_factor, unit_queries,):
+    def test_container_get_query_count(self, branching_factor, unit_queries):
         self.populate_course(branching_factor)
         with check_mongo_calls(unit_queries):
             self.client.get(reverse_usage_url('xblock_container_handler', self.populated_usage_keys['vertical'][-1]))
@@ -483,9 +484,8 @@ def assert_xblock_info(xblock, xblock_info):
 class DeleteItem(ItemTest):
     """Tests for '/xblock' DELETE url."""
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_delete_static_page(self, store):
-        course = CourseFactory.create(default_store=store)
+    def test_delete_static_page(self):
+        course = CourseFactory.create()
         # Add static tab
         resp = self.create_xblock(category='static_tab', parent_usage_key=course.location)
         usage_key = self.response_usage_key(resp)
@@ -532,7 +532,7 @@ def test_create_nicely(self):
             boilerplate=template_id
         )
         prob_usage_key = self.response_usage_key(resp)
-        problem = self.get_item_from_modulestore(prob_usage_key, verify_is_draft=True)
+        problem = self.get_item_from_modulestore(prob_usage_key)
         # check against the template
         template = ProblemBlock.get_template(template_id)
         self.assertEqual(problem.data, template['data'])
@@ -700,7 +700,7 @@ def setUp(self):
         self.html_usage_key = self.response_usage_key(resp)
 
         # Create a second sequential just (testing children of children)
-        self.create_xblock(parent_usage_key=self.chapter_usage_key, category='sequential2')
+        self.create_xblock(parent_usage_key=self.chapter_usage_key, category='sequential')
 
     def test_duplicate_equality(self):
         """
@@ -844,7 +844,7 @@ def setup_and_verify_content_experiment(self, partition_id):
         Arguments:
             partition_id (int): User partition id.
         """
-        split_test = self.get_item_from_modulestore(self.split_test_usage_key, verify_is_draft=True)
+        split_test = self.get_item_from_modulestore(self.split_test_usage_key)
 
         # Initially, no user_partition_id is set, and the split_test has no children.
         self.assertEqual(split_test.user_partition_id, -1)
@@ -855,7 +855,7 @@ def setup_and_verify_content_experiment(self, partition_id):
             reverse_usage_url("xblock_handler", self.split_test_usage_key),
             data={'metadata': {'user_partition_id': str(partition_id)}}
         )
-        split_test = self.get_item_from_modulestore(self.split_test_usage_key, verify_is_draft=True)
+        split_test = self.get_item_from_modulestore(self.split_test_usage_key)
         self.assertEqual(split_test.user_partition_id, partition_id)
         self.assertEqual(len(split_test.children), len(self.course.user_partitions[partition_id].groups))
         return split_test
@@ -918,15 +918,14 @@ def assert_move_item(self, source_usage_key, target_usage_key, target_index=None
         self.assertIn(source_usage_key, target_parent.children)
         self.assertNotIn(source_usage_key, source_parent.children)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_move_component(self, store_type):
+    def test_move_component(self):
         """
         Test move component with different xblock types.
 
         Arguments:
             store_type (ModuleStoreEnum.Type): Type of modulestore to create test course in.
         """
-        self.setup_course(default_store=store_type)
+        self.setup_course()
         for source_usage_key, target_usage_key in [
                 (self.html_usage_key, self.vert2_usage_key),
                 (self.vert_usage_key, self.seq2_usage_key),
@@ -1131,7 +1130,7 @@ def test_can_not_move_content_experiment_into_its_children(self):
             reverse_usage_url("xblock_handler", child_split_test_usage_key),
             data={'metadata': {'user_partition_id': str(0)}}
         )
-        child_split_test = self.get_item_from_modulestore(self.split_test_usage_key, verify_is_draft=True)
+        child_split_test = self.get_item_from_modulestore(self.split_test_usage_key)
 
         # Try to move content experiment further down the level to a child group A nested inside main group A.
         response = self._move_component(self.split_test_usage_key, child_split_test.children[0])
@@ -1186,6 +1185,7 @@ def _verify_validation_message(self, message, expected_message, expected_message
         self.assertEqual(message.text, expected_message)
         self.assertEqual(message.type, expected_message_type)
 
+    @skip("OldMongo Deprecation")
     def test_move_component_nonsensical_access_restriction_validation(self):
         """
         Test that moving a component with non-contradicting access
@@ -1255,8 +1255,7 @@ def test_move_logging(self, mock_logger):
             insert_at
         )
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_move_and_discard_changes(self, store_type):
+    def test_move_and_discard_changes(self):
         """
         Verifies that discard changes operation brings moved component back to source location and removes the component
         from target location.
@@ -1264,7 +1263,7 @@ def test_move_and_discard_changes(self, store_type):
         Arguments:
             store_type (ModuleStoreEnum.Type): Type of modulestore to create test course in.
         """
-        self.setup_course(default_store=store_type)
+        self.setup_course()
 
         old_parent_loc = self.store.get_parent_location(self.html_usage_key)
 
@@ -1308,15 +1307,14 @@ def test_move_and_discard_changes(self, store_type):
         self.assertIn(self.html_usage_key, source_parent.children)
         self.assertNotIn(self.html_usage_key, target_parent.children)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_move_item_not_found(self, store_type=ModuleStoreEnum.Type.mongo):
+    def test_move_item_not_found(self):
         """
         Test that an item not found exception raised when an item is not found when getting the item.
 
         Arguments:
             store_type (ModuleStoreEnum.Type): Type of modulestore to create test course in.
         """
-        self.setup_course(default_store=store_type)
+        self.setup_course()
 
         data = {
             'move_source_locator': str(self.usage_key.course_key.make_usage_key('html', 'html_test')),
@@ -1437,26 +1435,26 @@ def test_delete_field(self):
             self.problem_update_url,
             data={'metadata': {'rerandomize': 'onreset'}}
         )
-        problem = self.get_item_from_modulestore(self.problem_usage_key, verify_is_draft=True)
+        problem = self.get_item_from_modulestore(self.problem_usage_key)
         self.assertEqual(problem.rerandomize, 'onreset')
         self.client.ajax_post(
             self.problem_update_url,
             data={'metadata': {'rerandomize': None}}
         )
-        problem = self.get_item_from_modulestore(self.problem_usage_key, verify_is_draft=True)
+        problem = self.get_item_from_modulestore(self.problem_usage_key)
         self.assertEqual(problem.rerandomize, 'never')
 
     def test_null_field(self):
         """
         Sending null in for a field 'deletes' it
         """
-        problem = self.get_item_from_modulestore(self.problem_usage_key, verify_is_draft=True)
+        problem = self.get_item_from_modulestore(self.problem_usage_key)
         self.assertIsNotNone(problem.markdown)
         self.client.ajax_post(
             self.problem_update_url,
             data={'nullout': ['markdown']}
         )
-        problem = self.get_item_from_modulestore(self.problem_usage_key, verify_is_draft=True)
+        problem = self.get_item_from_modulestore(self.problem_usage_key)
         self.assertIsNone(problem.markdown)
 
     def test_date_fields(self):
@@ -1517,7 +1515,7 @@ def test_update_generic_fields(self):
                 }
             }
         )
-        problem = self.get_item_from_modulestore(self.problem_usage_key, verify_is_draft=True)
+        problem = self.get_item_from_modulestore(self.problem_usage_key)
         self.assertEqual(problem.display_name, new_display_name)
         self.assertEqual(problem.max_attempts, new_max_attempts)
 
@@ -1714,7 +1712,7 @@ def test_republish(self):
             }
         )
         self.assertFalse(self._is_location_published(self.problem_usage_key))
-        draft = self.get_item_from_modulestore(self.problem_usage_key, verify_is_draft=True)
+        draft = self.get_item_from_modulestore(self.problem_usage_key)
         self.assertEqual(draft.display_name, new_display_name)
 
         # Publish the item
@@ -1772,7 +1770,7 @@ def _make_draft_content_different_from_published(self):
             self.problem_update_url,
             data={'metadata': {'due': '2077-10-10T04:00Z'}}
         )
-        updated_draft = self.get_item_from_modulestore(self.problem_usage_key, verify_is_draft=True)
+        updated_draft = self.get_item_from_modulestore(self.problem_usage_key)
         self.assertEqual(updated_draft.due, datetime(2077, 10, 10, 4, 0, tzinfo=UTC))
         self.assertIsNone(published.due)
         # Fetch the published version again to make sure the due date is still unset.
@@ -1814,7 +1812,7 @@ def test_published_and_draft_contents_with_update(self):
         )
 
         # Both published and draft content should be different
-        draft = self.get_item_from_modulestore(self.problem_usage_key, verify_is_draft=True)
+        draft = self.get_item_from_modulestore(self.problem_usage_key)
         self.assertNotEqual(draft.data, published.data)
 
         # Get problem by 'xblock_handler'
@@ -1828,12 +1826,13 @@ def test_published_and_draft_contents_with_update(self):
         self.assertEqual(resp.status_code, 200)
 
         # Both published and draft content should still be different
-        draft = self.get_item_from_modulestore(self.problem_usage_key, verify_is_draft=True)
+        draft = self.get_item_from_modulestore(self.problem_usage_key)
         self.assertNotEqual(draft.data, published.data)
         # Fetch the published version again to make sure the data is correct.
         published = modulestore().get_item(published.location, revision=ModuleStoreEnum.RevisionOption.published_only)
         self.assertNotEqual(draft.data, published.data)
 
+    @skip("OldMongo Deprecation")
     def test_publish_states_of_nested_xblocks(self):
         """ Test publishing of a unit page containing a nested xblock  """
 
@@ -1970,7 +1969,7 @@ def _update_partition_id(self, partition_id):
         )
 
         # Verify the partition_id was saved.
-        split_test = self.get_item_from_modulestore(self.split_test_usage_key, verify_is_draft=True)
+        split_test = self.get_item_from_modulestore(self.split_test_usage_key)
         self.assertEqual(partition_id, split_test.user_partition_id)
         return split_test
 
@@ -1978,7 +1977,7 @@ def _assert_children(self, expected_number):
         """
         Verifies the number of children of the split_test instance.
         """
-        split_test = self.get_item_from_modulestore(self.split_test_usage_key, True)
+        split_test = self.get_item_from_modulestore(self.split_test_usage_key)
         self.assertEqual(expected_number, len(split_test.children))
         return split_test
 
@@ -1987,7 +1986,7 @@ def test_create_groups(self):
         Test that verticals are created for the configuration groups when
         a spit test module is edited.
         """
-        split_test = self.get_item_from_modulestore(self.split_test_usage_key, verify_is_draft=True)
+        split_test = self.get_item_from_modulestore(self.split_test_usage_key)
         # Initially, no user_partition_id is set, and the split_test has no children.
         self.assertEqual(-1, split_test.user_partition_id)
         self.assertEqual(0, len(split_test.children))
@@ -1997,8 +1996,8 @@ def test_create_groups(self):
 
         # Verify that child verticals have been set to match the groups
         self.assertEqual(2, len(split_test.children))
-        vertical_0 = self.get_item_from_modulestore(split_test.children[0], verify_is_draft=True)
-        vertical_1 = self.get_item_from_modulestore(split_test.children[1], verify_is_draft=True)
+        vertical_0 = self.get_item_from_modulestore(split_test.children[0])
+        vertical_1 = self.get_item_from_modulestore(split_test.children[1])
         self.assertEqual("vertical", vertical_0.category)
         self.assertEqual("vertical", vertical_1.category)
         self.assertEqual("Group ID " + str(MINIMUM_STATIC_PARTITION_ID + 1), vertical_0.display_name)
@@ -2013,7 +2012,7 @@ def test_split_xblock_info_group_name(self):
         """
         Test that concise outline for split test component gives display name as group name.
         """
-        split_test = self.get_item_from_modulestore(self.split_test_usage_key, verify_is_draft=True)
+        split_test = self.get_item_from_modulestore(self.split_test_usage_key)
         # Initially, no user_partition_id is set, and the split_test has no children.
         self.assertEqual(split_test.user_partition_id, -1)
         self.assertEqual(len(split_test.children), 0)
@@ -2051,9 +2050,9 @@ def test_change_user_partition_id(self):
         self.assertEqual(5, len(split_test.children))
         self.assertEqual(initial_vertical_0_location, split_test.children[0])
         self.assertEqual(initial_vertical_1_location, split_test.children[1])
-        vertical_0 = self.get_item_from_modulestore(split_test.children[2], verify_is_draft=True)
-        vertical_1 = self.get_item_from_modulestore(split_test.children[3], verify_is_draft=True)
-        vertical_2 = self.get_item_from_modulestore(split_test.children[4], verify_is_draft=True)
+        vertical_0 = self.get_item_from_modulestore(split_test.children[2])
+        vertical_1 = self.get_item_from_modulestore(split_test.children[3])
+        vertical_2 = self.get_item_from_modulestore(split_test.children[4])
 
         # Verify that the group_id_to child mapping is correct.
         self.assertEqual(3, len(split_test.group_id_to_child))
@@ -2563,31 +2562,26 @@ def test_json_responses(self):
         json_response = json.loads(resp.content.decode('utf-8'))
         self.validate_course_xblock_info(json_response, course_outline=True)
 
-    @ddt.data(
-        (ModuleStoreEnum.Type.split, 3, 3),
-        (ModuleStoreEnum.Type.mongo, 5, 7),
-    )
     @ddt.unpack
-    def test_xblock_outline_handler_mongo_calls(self, store_type, chapter_queries, chapter_queries_1):
-        with self.store.default_store(store_type):
-            course = CourseFactory.create()
-            chapter = ItemFactory.create(
-                parent_location=course.location, category='chapter', display_name='Week 1'
-            )
-            outline_url = reverse_usage_url('xblock_outline_handler', chapter.location)
-            with check_mongo_calls(chapter_queries):
-                self.client.get(outline_url, HTTP_ACCEPT='application/json')
+    def test_xblock_outline_handler_mongo_calls(self):
+        course = CourseFactory.create()
+        chapter = ItemFactory.create(
+            parent_location=course.location, category='chapter', display_name='Week 1'
+        )
+        outline_url = reverse_usage_url('xblock_outline_handler', chapter.location)
+        with check_mongo_calls(3):
+            self.client.get(outline_url, HTTP_ACCEPT='application/json')
 
-            sequential = ItemFactory.create(
-                parent_location=chapter.location, category='sequential', display_name='Sequential 1'
-            )
+        sequential = ItemFactory.create(
+            parent_location=chapter.location, category='sequential', display_name='Sequential 1'
+        )
 
-            ItemFactory.create(
-                parent_location=sequential.location, category='vertical', display_name='Vertical 1'
-            )
-            # calls should be same after adding two new children for split only.
-            with check_mongo_calls(chapter_queries_1):
-                self.client.get(outline_url, HTTP_ACCEPT='application/json')
+        ItemFactory.create(
+            parent_location=sequential.location, category='vertical', display_name='Vertical 1'
+        )
+        # calls should be same after adding two new children for split only.
+        with check_mongo_calls(3):
+            self.client.get(outline_url, HTTP_ACCEPT='application/json')
 
     def test_entrance_exam_chapter_xblock_info(self):
         chapter = ItemFactory.create(
@@ -2703,28 +2697,26 @@ def test_component_xblock_info(self):
         )
         self.validate_component_xblock_info(xblock_info)
 
-    @ddt.data(ModuleStoreEnum.Type.split, ModuleStoreEnum.Type.mongo)
-    def test_validate_start_date(self, store_type):
+    def test_validate_start_date(self):
         """
         Validate if start-date year is less than 1900 reset the date to DEFAULT_START_DATE.
         """
-        with self.store.default_store(store_type):
-            course = CourseFactory.create()
-            chapter = ItemFactory.create(
-                parent_location=course.location, category='chapter', display_name='Week 1'
-            )
+        course = CourseFactory.create()
+        chapter = ItemFactory.create(
+            parent_location=course.location, category='chapter', display_name='Week 1'
+        )
 
-            chapter.start = datetime(year=1899, month=1, day=1, tzinfo=UTC)
+        chapter.start = datetime(year=1899, month=1, day=1, tzinfo=UTC)
 
-            xblock_info = create_xblock_info(
-                chapter,
-                include_child_info=True,
-                include_children_predicate=ALWAYS,
-                include_ancestor_info=True,
-                user=self.user
-            )
+        xblock_info = create_xblock_info(
+            chapter,
+            include_child_info=True,
+            include_children_predicate=ALWAYS,
+            include_ancestor_info=True,
+            user=self.user
+        )
 
-            self.assertEqual(xblock_info['start'], DEFAULT_START_DATE.strftime('%Y-%m-%dT%H:%M:%SZ'))
+        self.assertEqual(xblock_info['start'], DEFAULT_START_DATE.strftime('%Y-%m-%dT%H:%M:%SZ'))
 
     def test_highlights_enabled(self):
         self.course.highlights_enabled_for_messaging = True
@@ -2846,6 +2838,7 @@ def validate_xblock_info_consistency(self, xblock_info, has_ancestor_info=False,
             self.assertIsNone(xblock_info.get('child_info', None))
 
 
+@skip("OldMongo Deprecation")
 @patch.dict('django.conf.settings.FEATURES', {'ENABLE_SPECIAL_EXAMS': True})
 @ddt.ddt
 class TestSpecialExamXBlockInfo(ItemTest):
@@ -3185,9 +3178,8 @@ def test_empty_chapter(self):
         xblock_info = self._get_xblock_info(empty_chapter.location)
         self._verify_visibility_state(xblock_info, VisibilityState.unscheduled)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_chapter_self_paced_default_start_date(self, store_type):
-        course = CourseFactory.create(default_store=store_type)
+    def test_chapter_self_paced_default_start_date(self):
+        course = CourseFactory.create()
         course.self_paced = True
         self.store.update_item(course, self.user.id)
         chapter = self._create_child(course, 'chapter', "Test Chapter")
@@ -3250,6 +3242,7 @@ def test_unpublished_changes(self):
         self._verify_visibility_state(xblock_info, VisibilityState.needs_attention, path=self.FIRST_UNIT_PATH)
         self._verify_visibility_state(xblock_info, VisibilityState.staff_only, path=self.SECOND_UNIT_PATH)
 
+    @skip("OldMongo Deprecation")
     def test_partially_released_section(self):
         chapter = self._create_child(self.course, 'chapter', "Test Chapter")
         released_sequential = self._create_child(chapter, 'sequential', "Released Sequential")
@@ -3408,8 +3401,7 @@ def test_locked_unit_staff_only_message(self):
         self._verify_has_staff_only_message(xblock_info, True, path=self.FIRST_SUBSECTION_PATH)
         self._verify_has_staff_only_message(xblock_info, True, path=self.FIRST_UNIT_PATH)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_self_paced_item_visibility_state(self, store_type):
+    def test_self_paced_item_visibility_state(self):
         """
         Test that in self-paced course, item has `live` visibility state.
         Test that when item was initially in `scheduled` state in instructor mode, change course pacing to self-paced,
@@ -3417,7 +3409,7 @@ def test_self_paced_item_visibility_state(self, store_type):
         """
 
         # Create course, chapter and setup future release date to make chapter in scheduled state
-        course = CourseFactory.create(default_store=store_type)
+        course = CourseFactory.create()
         chapter = self._create_child(course, 'chapter', "Test Chapter")
         self._set_release_date(chapter.location, datetime.now(UTC) + timedelta(days=1))
 
diff --git a/cms/djangoapps/contentstore/views/tests/test_preview.py b/cms/djangoapps/contentstore/views/tests/test_preview.py
index 66e934911f06..6f239db54d68 100644
--- a/cms/djangoapps/contentstore/views/tests/test_preview.py
+++ b/cms/djangoapps/contentstore/views/tests/test_preview.py
@@ -4,7 +4,7 @@
 
 
 import re
-from unittest import mock
+from unittest import mock, skip
 
 import ddt
 from django.test.client import Client, RequestFactory
@@ -15,10 +15,9 @@
 
 from xmodule.contentstore.django import contentstore
 from xmodule.lti_module import LTIBlock
-from xmodule.modulestore import ModuleStoreEnum
 from xmodule.modulestore.django import modulestore
 from xmodule.modulestore.tests.django_utils import (
-    TEST_DATA_MONGO_MODULESTORE, ModuleStoreTestCase, upload_file_to_course,
+    TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase, upload_file_to_course,
 )
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
 from xmodule.modulestore.tests.test_asides import AsideTestType
@@ -45,7 +44,7 @@ def test_preview_fragment(self):
         Test for calling get_preview_html. Ensures data-usage-id is correctly set and
         asides are correctly included.
         """
-        course = CourseFactory.create(default_store=ModuleStoreEnum.Type.split)
+        course = CourseFactory.create()
         html = ItemFactory.create(
             parent_location=course.location,
             category="html",
@@ -93,7 +92,7 @@ def test_preview_no_asides(self):
         Test for calling get_preview_html. Ensures data-usage-id is correctly set and
         asides are correctly excluded because they are not enabled.
         """
-        course = CourseFactory.create(default_store=ModuleStoreEnum.Type.split)
+        course = CourseFactory.create()
         html = ItemFactory.create(
             parent_location=course.location,
             category="html",
@@ -127,52 +126,49 @@ def test_preview_conditional_module_children_context(self, mock_is_condition_sat
         client = Client()
         client.login(username=self.user.username, password=self.user_password)
 
-        with self.store.default_store(ModuleStoreEnum.Type.split):
-            course = CourseFactory.create()
-
-            conditional_block = ItemFactory.create(
-                parent_location=course.location,
-                category="conditional"
-            )
-
-            # child conditional_block
-            ItemFactory.create(
-                parent_location=conditional_block.location,
-                category="conditional"
-            )
-
-            url = reverse_usage_url(
-                'preview_handler',
-                conditional_block.location,
-                kwargs={'handler': 'xmodule_handler/conditional_get'}
-            )
-            response = client.post(url)
-            self.assertEqual(response.status_code, 200)
-
-    @ddt.data(ModuleStoreEnum.Type.split, ModuleStoreEnum.Type.mongo)
-    def test_block_branch_not_changed_by_preview_handler(self, default_store):
+        course = CourseFactory.create()
+
+        conditional_block = ItemFactory.create(
+            parent_location=course.location,
+            category="conditional"
+        )
+
+        # child conditional_block
+        ItemFactory.create(
+            parent_location=conditional_block.location,
+            category="conditional"
+        )
+
+        url = reverse_usage_url(
+            'preview_handler',
+            conditional_block.location,
+            kwargs={'handler': 'xmodule_handler/conditional_get'}
+        )
+        response = client.post(url)
+        self.assertEqual(response.status_code, 200)
+
+    def test_block_branch_not_changed_by_preview_handler(self):
         """
         Tests preview_handler should not update blocks being previewed
         """
         client = Client()
         client.login(username=self.user.username, password=self.user_password)
 
-        with self.store.default_store(default_store):
-            course = CourseFactory.create()
+        course = CourseFactory.create()
 
-            block = ItemFactory.create(
-                parent_location=course.location,
-                category="problem"
-            )
+        block = ItemFactory.create(
+            parent_location=course.location,
+            category="problem"
+        )
 
-            url = reverse_usage_url(
-                'preview_handler',
-                block.location,
-                kwargs={'handler': 'xmodule_handler/problem_check'}
-            )
-            response = client.post(url)
-            self.assertEqual(response.status_code, 200)
-            self.assertFalse(modulestore().has_changes(modulestore().get_item(block.location)))
+        url = reverse_usage_url(
+            'preview_handler',
+            block.location,
+            kwargs={'handler': 'xmodule_handler/problem_check'}
+        )
+        response = client.post(url)
+        self.assertEqual(response.status_code, 200)
+        self.assertFalse(modulestore().has_changes(modulestore().get_item(block.location)))
 
 
 @XBlock.needs("field-data")
@@ -229,8 +225,8 @@ class CmsModuleSystemShimTest(ModuleStoreTestCase):
     """
     Tests that the deprecated attributes in the Module System (XBlock Runtime) return the expected values.
     """
-    MODULESTORE = TEST_DATA_MONGO_MODULESTORE
-    COURSE_ID = 'edX/CmsModuleShimTest/2021_Fall'
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
+    COURSE_ID = 'course-v1:edX+LmsModuleShimTest+2021_Fall'
     PYTHON_LIB_FILENAME = 'test_python_lib.zip'
     PYTHON_LIB_SOURCE_FILE = './common/test/data/uploads/python_lib.zip'
 
@@ -239,8 +235,7 @@ def setUp(self):
         Set up the user, course and other fields that will be used to instantiate the runtime.
         """
         super().setUp()
-        org, number, run = self.COURSE_ID.split('/')
-        self.course = CourseFactory.create(org=org, number=number, run=run)
+        self.course = CourseFactory.create(org='edX', number='LmsModuleShimTest', run='2021_Fall')
         self.user = UserFactory()
         self.request = RequestFactory().get('/dummy-url')
         self.request.user = self.user
@@ -263,7 +258,7 @@ def test_render_template(self):
         html = get_preview_fragment(self.request, descriptor, {'element_id': 142}).content
         assert '<div id="142" ns="main">Testing the MakoService</div>' in html
 
-    @override_settings(COURSES_WITH_UNSAFE_CODE=[COURSE_ID])
+    @override_settings(COURSES_WITH_UNSAFE_CODE=[r'course-v1:edX\+LmsModuleShimTest\+2021_Fall'])
     def test_can_execute_unsafe_code(self):
         assert self.runtime.can_execute_unsafe_code()
 
@@ -312,6 +307,7 @@ def test_anonymous_user_id_individual_per_student(self):
         )
         assert runtime.anonymous_student_id == '26262401c528d7c4a6bbeabe0455ec46'
 
+    @skip("OldMongo Deprecation")
     @override_waffle_flag(INDIVIDUALIZE_ANONYMOUS_USER_ID, active=True)
     def test_anonymous_user_id_individual_per_course(self):
         """Test anonymous_user_id on a block which uses per-course anonymous IDs"""
diff --git a/cms/djangoapps/maintenance/tests.py b/cms/djangoapps/maintenance/tests.py
index 453d2a9a3e0e..07a4f5322958 100644
--- a/cms/djangoapps/maintenance/tests.py
+++ b/cms/djangoapps/maintenance/tests.py
@@ -12,7 +12,6 @@
 from cms.djangoapps.contentstore.management.commands.utils import get_course_versions
 from common.djangoapps.student.tests.factories import AdminFactory, UserFactory
 from openedx.features.announcements.models import Announcement
-from xmodule.modulestore import ModuleStoreEnum  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.django import modulestore  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory  # lint-amnesty, pylint: disable=wrong-import-order
@@ -140,7 +139,7 @@ def setup_test_course(self):
         Returns:
             course: a course object
         """
-        course = CourseFactory.create(default_store=ModuleStoreEnum.Type.split)
+        course = CourseFactory.create()
         # Add some changes to course
         chapter = ItemFactory.create(category='chapter', parent_location=course.location)
         self.store.create_child(
@@ -169,34 +168,6 @@ def test_invalid_course_key_messages(self, course_key, error_message):
             error_message=error_message
         )
 
-    def test_mongo_course(self):
-        """
-        Test that we get a error message on old mongo courses.
-        """
-        # validate non split error message
-        course = CourseFactory.create(default_store=ModuleStoreEnum.Type.mongo)
-        self.verify_error_message(
-            data={'course-id': str(course.id)},
-            error_message='Force publishing course is not supported with old mongo courses.'
-        )
-
-    def test_mongo_course_with_split_course_key(self):
-        """
-        Test that we get an error message `course_key_not_found` for a provided split course key
-        if we already have an old mongo course.
-        """
-        # validate non split error message
-        course = CourseFactory.create(org='e', number='d', run='X', default_store=ModuleStoreEnum.Type.mongo)
-        self.verify_error_message(
-            data={'course-id': str(course.id)},
-            error_message='Force publishing course is not supported with old mongo courses.'
-        )
-        # Now search for the course key in split version.
-        self.verify_error_message(
-            data={'course-id': 'course-v1:e+d+X'},
-            error_message=COURSE_KEY_ERROR_MESSAGES['course_key_not_found']
-        )
-
     def test_already_published(self):
         """
         Test that when a course is forcefully publish, we get a 'course is already published' message.
diff --git a/cms/lib/xblock/test/test_authoring_mixin.py b/cms/lib/xblock/test/test_authoring_mixin.py
index 6028f39614a2..c604b56ebc95 100644
--- a/cms/lib/xblock/test/test_authoring_mixin.py
+++ b/cms/lib/xblock/test/test_authoring_mixin.py
@@ -3,10 +3,11 @@
 """
 
 
+from unittest import skip
 from django.conf import settings
 from django.test.utils import override_settings
 from xblock.core import XBlock
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, ModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
 from xmodule.partitions.partitions import (
     ENROLLMENT_TRACK_PARTITION_ID,
@@ -23,7 +24,7 @@ class AuthoringMixinTestCase(ModuleStoreTestCase):
     """
     Tests the studio authoring XBlock mixin.
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
     GROUP_NO_LONGER_EXISTS = "This group no longer exists"
     NO_CONTENT_OR_ENROLLMENT_GROUPS = "Access to this component is not restricted"
     NO_CONTENT_ENROLLMENT_TRACK_ENABLED = "You can restrict access to this component to learners in specific enrollment tracks or content groups"  # lint-amnesty, pylint: disable=line-too-long
@@ -158,6 +159,7 @@ def test_html_empty_partition_staff_locked(self):
             [self.STAFF_LOCKED, self.CONTENT_GROUPS_TITLE, self.ENROLLMENT_GROUPS_TITLE]
         )
 
+    @skip("OldMongo Deprecation")
     def test_html_populated_partition_staff_locked(self):
         self.create_content_groups(self.pet_groups)
         self.set_staff_only(self.vertical_location)
@@ -178,6 +180,7 @@ def test_html_false_content_group(self):
             [self.STAFF_LOCKED]
         )
 
+    @skip("OldMongo Deprecation")
     def test_html_false_content_group_staff_locked(self):
         self.create_content_groups(self.pet_groups)
         self.set_staff_only(self.vertical_location)
diff --git a/common/djangoapps/static_replace/test/test_static_replace.py b/common/djangoapps/static_replace/test/test_static_replace.py
index 093ff9de0698..c386748ecc55 100644
--- a/common/djangoapps/static_replace/test/test_static_replace.py
+++ b/common/djangoapps/static_replace/test/test_static_replace.py
@@ -268,7 +268,7 @@ def setUpClass(cls):
 
         super().setUpClass()
 
-        names_and_prefixes = [(ModuleStoreEnum.Type.split, 'split'), (ModuleStoreEnum.Type.mongo, 'old')]
+        names_and_prefixes = [(ModuleStoreEnum.Type.split, 'split')]
         for store, prefix in names_and_prefixes:
             with cls.store.default_store(store):
                 cls.courses[prefix] = CourseFactory.create(org='a', course='b', run=prefix)
@@ -592,202 +592,6 @@ def test_canonical_asset_path_with_new_style_assets(self, base_url, start, expec
             asset_path = StaticContent.get_canonicalized_asset_path(self.courses[prefix].id, start, base_url, exts)
             assert re.match(expected, asset_path) is not None
 
-    @ddt.data(
-        # No leading slash.
-        ('', '{prfx}_ünlöck.png', '/{c4x}/{prfx}_ünlöck.png', 1),
-        ('', '{prfx}_lock.png', '/{c4x}/{prfx}_lock.png', 1),
-        ('', 'weird {prfx}_ünlöck.png', '/{c4x}/weird_{prfx}_ünlöck.png', 1),
-        ('', '{prfx}_excluded.html', '/{base_c4x}/{prfx}_excluded.html', 1),
-        ('', '{prfx}_not_excluded.htm', '/{c4x}/{prfx}_not_excluded.htm', 1),
-        ('dev', '{prfx}_ünlöck.png', '//dev/{c4x}/{prfx}_ünlöck.png', 1),
-        ('dev', '{prfx}_lock.png', '/{c4x}/{prfx}_lock.png', 1),
-        ('dev', 'weird {prfx}_ünlöck.png', '//dev/{c4x}/weird_{prfx}_ünlöck.png', 1),
-        ('dev', '{prfx}_excluded.html', '/{base_c4x}/{prfx}_excluded.html', 1),
-        ('dev', '{prfx}_not_excluded.htm', '//dev/{c4x}/{prfx}_not_excluded.htm', 1),
-        # No leading slash with subdirectory.  This ensures we probably substitute slashes.
-        ('', 'special/{prfx}_ünlöck.png', '/{c4x}/special_{prfx}_ünlöck.png', 1),
-        ('', 'special/{prfx}_lock.png', '/{c4x}/special_{prfx}_lock.png', 1),
-        ('', 'special/weird {prfx}_ünlöck.png', '/{c4x}/special_weird_{prfx}_ünlöck.png', 1),
-        ('', 'special/{prfx}_excluded.html', '/{base_c4x}/special_{prfx}_excluded.html', 1),
-        ('', 'special/{prfx}_not_excluded.htm', '/{c4x}/special_{prfx}_not_excluded.htm', 1),
-        ('dev', 'special/{prfx}_ünlöck.png', '//dev/{c4x}/special_{prfx}_ünlöck.png', 1),
-        ('dev', 'special/{prfx}_lock.png', '/{c4x}/special_{prfx}_lock.png', 1),
-        ('dev', 'special/weird {prfx}_ünlöck.png', '//dev/{c4x}/special_weird_{prfx}_ünlöck.png', 1),
-        ('dev', 'special/{prfx}_excluded.html', '/{base_c4x}/special_{prfx}_excluded.html', 1),
-        ('dev', 'special/{prfx}_not_excluded.htm', '//dev/{c4x}/special_{prfx}_not_excluded.htm', 1),
-        # Leading slash.
-        ('', '/{prfx}_ünlöck.png', '/{c4x}/{prfx}_ünlöck.png', 1),
-        ('', '/{prfx}_lock.png', '/{c4x}/{prfx}_lock.png', 1),
-        ('', '/weird {prfx}_ünlöck.png', '/{c4x}/weird_{prfx}_ünlöck.png', 1),
-        ('', '/{prfx}_excluded.html', '/{base_c4x}/{prfx}_excluded.html', 1),
-        ('', '/{prfx}_not_excluded.htm', '/{c4x}/{prfx}_not_excluded.htm', 1),
-        ('dev', '/{prfx}_ünlöck.png', '//dev/{c4x}/{prfx}_ünlöck.png', 1),
-        ('dev', '/{prfx}_lock.png', '/{c4x}/{prfx}_lock.png', 1),
-        ('dev', '/weird {prfx}_ünlöck.png', '//dev/{c4x}/weird_{prfx}_ünlöck.png', 1),
-        ('dev', '/{prfx}_excluded.html', '/{base_c4x}/{prfx}_excluded.html', 1),
-        ('dev', '/{prfx}_not_excluded.htm', '//dev/{c4x}/{prfx}_not_excluded.htm', 1),
-        # Leading slash with subdirectory. This ensures we properly substitute slashes.
-        ('', '/special/{prfx}_ünlöck.png', '/{c4x}/special_{prfx}_ünlöck.png', 1),
-        ('', '/special/{prfx}_lock.png', '/{c4x}/special_{prfx}_lock.png', 1),
-        ('', '/special/weird {prfx}_ünlöck.png', '/{c4x}/special_weird_{prfx}_ünlöck.png', 1),
-        ('', '/special/{prfx}_excluded.html', '/{base_c4x}/special_{prfx}_excluded.html', 1),
-        ('', '/special/{prfx}_not_excluded.htm', '/{c4x}/special_{prfx}_not_excluded.htm', 1),
-        ('dev', '/special/{prfx}_ünlöck.png', '//dev/{c4x}/special_{prfx}_ünlöck.png', 1),
-        ('dev', '/special/{prfx}_lock.png', '/{c4x}/special_{prfx}_lock.png', 1),
-        ('dev', '/special/weird {prfx}_ünlöck.png', '//dev/{c4x}/special_weird_{prfx}_ünlöck.png', 1),
-        ('dev', '/special/{prfx}_excluded.html', '/{base_c4x}/special_{prfx}_excluded.html', 1),
-        ('dev', '/special/{prfx}_not_excluded.htm', '//dev/{c4x}/special_{prfx}_not_excluded.htm', 1),
-        # Static path.
-        ('', '/static/{prfx}_ünlöck.png', '/{c4x}/{prfx}_ünlöck.png', 1),
-        ('', '/static/{prfx}_lock.png', '/{c4x}/{prfx}_lock.png', 1),
-        ('', '/static/weird {prfx}_ünlöck.png', '/{c4x}/weird_{prfx}_ünlöck.png', 1),
-        ('', '/static/{prfx}_excluded.html', '/{base_c4x}/{prfx}_excluded.html', 1),
-        ('', '/static/{prfx}_not_excluded.htm', '/{c4x}/{prfx}_not_excluded.htm', 1),
-        ('dev', '/static/{prfx}_ünlöck.png', '//dev/{c4x}/{prfx}_ünlöck.png', 1),
-        ('dev', '/static/{prfx}_lock.png', '/{c4x}/{prfx}_lock.png', 1),
-        ('dev', '/static/weird {prfx}_ünlöck.png', '//dev/{c4x}/weird_{prfx}_ünlöck.png', 1),
-        ('dev', '/static/{prfx}_excluded.html', '/{base_c4x}/{prfx}_excluded.html', 1),
-        ('dev', '/static/{prfx}_not_excluded.htm', '//dev/{c4x}/{prfx}_not_excluded.htm', 1),
-        # Static path with subdirectory.  This ensures we properly substitute slashes.
-        ('', '/static/special/{prfx}_ünlöck.png', '/{c4x}/special_{prfx}_ünlöck.png', 1),
-        ('', '/static/special/{prfx}_lock.png', '/{c4x}/special_{prfx}_lock.png', 1),
-        ('', '/static/special/weird {prfx}_ünlöck.png', '/{c4x}/special_weird_{prfx}_ünlöck.png', 1),
-        ('', '/static/special/{prfx}_excluded.html', '/{base_c4x}/special_{prfx}_excluded.html', 1),
-        ('', '/static/special/{prfx}_not_excluded.htm', '/{c4x}/special_{prfx}_not_excluded.htm', 1),
-        ('dev', '/static/special/{prfx}_ünlöck.png', '//dev/{c4x}/special_{prfx}_ünlöck.png', 1),
-        ('dev', '/static/special/{prfx}_lock.png', '/{c4x}/special_{prfx}_lock.png', 1),
-        ('dev', '/static/special/weird {prfx}_ünlöck.png', '//dev/{c4x}/special_weird_{prfx}_ünlöck.png', 1),
-        ('dev', '/static/special/{prfx}_excluded.html', '/{base_c4x}/special_{prfx}_excluded.html', 1),
-        ('dev', '/static/special/{prfx}_not_excluded.htm', '//dev/{c4x}/special_{prfx}_not_excluded.htm', 1),
-        # Static path with query parameter.
-        (
-            '',
-            '/static/{prfx}_ünlöck.png?foo=/static/{prfx}_lock.png',
-            '/{c4x}/{prfx}_ünlöck.png?foo={encoded_c4x}{prfx}_lock.png',
-            2
-        ),
-        (
-            '',
-            '/static/{prfx}_lock.png?foo=/static/{prfx}_ünlöck.png',
-            '/{c4x}/{prfx}_lock.png?foo={encoded_c4x}{prfx}_ünlöck.png',
-            2
-        ),
-        (
-            '',
-            '/static/{prfx}_excluded.html?foo=/static/{prfx}_excluded.html',
-            '/{base_c4x}/{prfx}_excluded.html?foo={encoded_base_c4x}{prfx}_excluded.html',
-            2
-        ),
-        (
-            '',
-            '/static/{prfx}_excluded.html?foo=/static/{prfx}_not_excluded.htm',
-            '/{base_c4x}/{prfx}_excluded.html?foo={encoded_c4x}{prfx}_not_excluded.htm',
-            2
-        ),
-        (
-            '',
-            '/static/{prfx}_not_excluded.htm?foo=/static/{prfx}_excluded.html',
-            '/{c4x}/{prfx}_not_excluded.htm?foo={encoded_base_c4x}{prfx}_excluded.html',
-            2
-        ),
-        (
-            '',
-            '/static/{prfx}_not_excluded.htm?foo=/static/{prfx}_not_excluded.htm',
-            '/{c4x}/{prfx}_not_excluded.htm?foo={encoded_c4x}{prfx}_not_excluded.htm',
-            2
-        ),
-        (
-            'dev',
-            '/static/{prfx}_ünlöck.png?foo=/static/{prfx}_lock.png',
-            '//dev/{c4x}/{prfx}_ünlöck.png?foo={encoded_c4x}{prfx}_lock.png',
-            2
-        ),
-        (
-            'dev',
-            '/static/{prfx}_lock.png?foo=/static/{prfx}_ünlöck.png',
-            '/{c4x}/{prfx}_lock.png?foo={encoded_base_url}{encoded_c4x}{prfx}_ünlöck.png',
-            2
-        ),
-        (
-            'dev',
-            '/static/{prfx}_excluded.html?foo=/static/{prfx}_excluded.html',
-            '/{base_c4x}/{prfx}_excluded.html?foo={encoded_base_c4x}{prfx}_excluded.html',
-            2
-        ),
-        (
-            'dev',
-            '/static/{prfx}_excluded.html?foo=/static/{prfx}_not_excluded.htm',
-            '/{base_c4x}/{prfx}_excluded.html?foo={encoded_base_url}{encoded_c4x}{prfx}_not_excluded.htm',
-            2
-        ),
-        (
-            'dev',
-            '/static/{prfx}_not_excluded.htm?foo=/static/{prfx}_excluded.html',
-            '//dev/{c4x}/{prfx}_not_excluded.htm?foo={encoded_base_c4x}{prfx}_excluded.html',
-            2
-        ),
-        (
-            'dev',
-            '/static/{prfx}_not_excluded.htm?foo=/static/{prfx}_not_excluded.htm',
-            '//dev/{c4x}/{prfx}_not_excluded.htm?foo={encoded_base_url}{encoded_c4x}{prfx}_not_excluded.htm',
-            2
-        ),
-        # Old, c4x-style path.
-        ('', '/{c4x}/{prfx}_ünlöck.png', '/{c4x}/{prfx}_ünlöck.png', 1),
-        ('', '/{c4x}/{prfx}_lock.png', '/{c4x}/{prfx}_lock.png', 1),
-        ('', '/{c4x}/weird_{prfx}_lock.png', '/{c4x}/weird_{prfx}_lock.png', 1),
-        ('', '/{c4x}/{prfx}_excluded.html', '/{base_c4x}/{prfx}_excluded.html', 1),
-        ('', '/{c4x}/{prfx}_not_excluded.htm', '/{c4x}/{prfx}_not_excluded.htm', 1),
-        ('dev', '/{c4x}/{prfx}_ünlöck.png', '//dev/{c4x}/{prfx}_ünlöck.png', 1),
-        ('dev', '/{c4x}/{prfx}_lock.png', '/{c4x}/{prfx}_lock.png', 1),
-        ('dev', '/{c4x}/weird_{prfx}_ünlöck.png', '//dev/{c4x}/weird_{prfx}_ünlöck.png', 1),
-        ('dev', '/{c4x}/{prfx}_excluded.html', '/{base_c4x}/{prfx}_excluded.html', 1),
-        ('dev', '/{c4x}/{prfx}_not_excluded.htm', '//dev/{c4x}/{prfx}_not_excluded.htm', 1),
-    )
-    @ddt.unpack
-    def test_canonical_asset_path_with_c4x_style_assets(self, base_url, start, expected, mongo_calls):
-        exts = ['.html', '.tm']
-        prefix = 'old'
-        base_c4x_block = 'c4x/a/b/asset'
-        adjusted_c4x_block = base_c4x_block
-        encoded_c4x_block = quote('/' + base_c4x_block + '/')
-        encoded_base_url = quote('//' + base_url)
-        encoded_base_c4x_block = encoded_c4x_block
-
-        start = start.format(
-            prfx=prefix,
-            encoded_base_url=encoded_base_url,
-            c4x=base_c4x_block,
-            encoded_c4x=encoded_c4x_block
-        )
-
-        # Adjust for content digest.  This gets dicey quickly and we have to order our steps:
-        # - replace format markets because they have curly braces
-        # - encode Unicode characters to percent-encoded
-        # - finally shove back in our regex patterns
-        digest = CanonicalContentTest.get_content_digest_for_asset_path(prefix, start)
-        if digest:
-            adjusted_c4x_block = 'assets/courseware/VMARK/HMARK/c4x/a/b/asset'
-            encoded_c4x_block = quote('/' + adjusted_c4x_block + '/')
-
-        expected = expected.format(
-            prfx=prefix,
-            encoded_base_url=encoded_base_url,
-            base_c4x=base_c4x_block,
-            c4x=adjusted_c4x_block,
-            encoded_c4x=encoded_c4x_block,
-            encoded_base_c4x=encoded_base_c4x_block,
-        )
-
-        expected = encode_unicode_characters_in_url(expected)
-        expected = expected.replace('VMARK', r'v[\d]')
-        expected = expected.replace('HMARK', '[a-f0-9]{32}')
-        expected = expected.replace('+', r'\+').replace('?', r'\?')
-
-        with check_mongo_calls(mongo_calls):
-            asset_path = StaticContent.get_canonicalized_asset_path(self.courses[prefix].id, start, base_url, exts)
-            assert re.match(expected, asset_path) is not None
-
 
 class ReplaceURLServiceTest(TestCase):
     """
@@ -846,7 +650,6 @@ def test_replace_jump_to_id_urls_not_called(self):
         assert not self.mock_replace_jump_to_id_urls.called
 
 
-@ddt.ddt
 class TestReplaceURLWrapper(SharedModuleStoreTestCase):
     """
     Tests for replace_url_wrapper utility function.
@@ -855,28 +658,19 @@ class TestReplaceURLWrapper(SharedModuleStoreTestCase):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
-        cls.course_mongo = CourseFactory.create(
-            default_store=ModuleStoreEnum.Type.mongo,
-            org='TestX',
-            number='TS01',
-            run='2015'
-        )
-        cls.course_split = CourseFactory.create(
-            default_store=ModuleStoreEnum.Type.split,
+        cls.course = CourseFactory.create(
             org='TestX',
             number='TS02',
             run='2015'
         )
 
-    @ddt.data('course_mongo', 'course_split')
-    def test_replace_jump_to_id_urls(self, course_id):
+    def test_replace_jump_to_id_urls(self):
         """
         Verify that the jump-to URL has been replaced.
         """
-        course = getattr(self, course_id)
-        replace_url_service = ReplaceURLService(course_id=course.id, jump_to_id_base_url='/base_url/')
+        replace_url_service = ReplaceURLService(course_id=self.course.id, jump_to_id_base_url='/base_url/')
         test_replace = replace_urls_wrapper(
-            block=course,
+            block=self.course,
             view='baseview',
             frag=Fragment('<a href="/jump_to_id/id">'),
             context=None,
@@ -885,40 +679,28 @@ def test_replace_jump_to_id_urls(self, course_id):
         assert isinstance(test_replace, Fragment)
         assert test_replace.content == '<a href="/base_url/id">'
 
-    @ddt.data(
-        ('course_mongo', '<a href="/courses/TestX/TS01/2015/id">'),
-        ('course_split', '<a href="/courses/course-v1:TestX+TS02+2015/id">')
-    )
-    @ddt.unpack
-    def test_replace_course_urls(self, course_id, anchor_tag):
+    def test_replace_course_urls(self):
         """
         Verify that the course URL has been replaced.
         """
-        course = getattr(self, course_id)
-        replace_url_service = ReplaceURLService(course_id=course.id)
+        replace_url_service = ReplaceURLService(course_id=self.course.id)
         test_replace = replace_urls_wrapper(
-            block=course,
+            block=self.course,
             view='baseview',
             frag=Fragment('<a href="/course/id">'),
             context=None,
             replace_url_service=replace_url_service
         )
         assert isinstance(test_replace, Fragment)
-        assert test_replace.content == anchor_tag
+        assert test_replace.content == '<a href="/courses/course-v1:TestX+TS02+2015/id">'
 
-    @ddt.data(
-        ('course_mongo', '<a href="/c4x/TestX/TS01/asset/id">'),
-        ('course_split', '<a href="/asset-v1:TestX+TS02+2015+type@asset+block/id">')
-    )
-    @ddt.unpack
-    def test_replace_static_urls(self, course_id, anchor_tag):
+    def test_replace_static_urls(self):
         """
         Verify that the static URL has been replaced.
         """
-        course = getattr(self, course_id)
-        replace_url_service = ReplaceURLService(course_id=course.id)
+        replace_url_service = ReplaceURLService(course_id=self.course.id)
         test_replace = replace_urls_wrapper(
-            block=course,
+            block=self.course,
             view='baseview',
             frag=Fragment('<a href="/static/id">'),
             context=None,
@@ -926,4 +708,4 @@ def test_replace_static_urls(self, course_id, anchor_tag):
             static_replace_only=True
         )
         assert isinstance(test_replace, Fragment)
-        assert test_replace.content == anchor_tag
+        assert test_replace.content == '<a href="/asset-v1:TestX+TS02+2015+type@asset+block/id">'
diff --git a/common/djangoapps/student/tests/test_certificates.py b/common/djangoapps/student/tests/test_certificates.py
index f935653e3460..6bfb57721b1a 100644
--- a/common/djangoapps/student/tests/test_certificates.py
+++ b/common/djangoapps/student/tests/test_certificates.py
@@ -11,7 +11,7 @@
 from django.urls import reverse
 from pytz import UTC
 from xmodule.modulestore import ModuleStoreEnum
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, SharedModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, SharedModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory
 from xmodule.data import CertificatesDisplayBehaviors
 
@@ -32,7 +32,7 @@
 class CertificateDisplayTestBase(SharedModuleStoreTestCase):
     """Tests display of certificates on the student dashboard. """
 
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
     USERNAME = "test_user"
     PASSWORD = "password"
 
@@ -76,6 +76,7 @@ def _create_certificate(self, enrollment_mode):
         )
 
 
+@unittest.skip("OldMongo Deprecation")
 @ddt.ddt
 @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms')
 class CertificateDashboardMessageDisplayTest(CertificateDisplayTestBase):
diff --git a/common/djangoapps/student/tests/test_course_listing.py b/common/djangoapps/student/tests/test_course_listing.py
index e93ec5f81747..5478a1c39aff 100644
--- a/common/djangoapps/student/tests/test_course_listing.py
+++ b/common/djangoapps/student/tests/test_course_listing.py
@@ -105,12 +105,13 @@ def test_errored_course_regular_access(self):
         """
         Test the course list for regular staff when get_course returns an ErrorBlock
         """
-        # pylint: disable=protected-access
-        mongo_store = modulestore()._get_modulestore_by_type(ModuleStoreEnum.Type.mongo)
-        course_key = mongo_store.make_course_key('Org1', 'Course1', 'Run1')
-        self._create_course_with_access_groups(course_key, default_store=ModuleStoreEnum.Type.mongo)
+        store = modulestore()
+        course_key = store.make_course_key('Org1', 'Course1', 'Run1')
+        self._create_course_with_access_groups(course_key)
 
-        with mock.patch('xmodule.modulestore.mongo.base.MongoKeyValueStore', mock.Mock(side_effect=Exception)):
+        with mock.patch(
+            'xmodule.modulestore.split_mongo.caching_descriptor_system.SplitMongoKVS', mock.Mock(side_effect=Exception)
+        ):
             assert isinstance(modulestore().get_course(course_key), ErrorBlock)
 
             # Invalidate (e.g., delete) the corresponding CourseOverview, forcing get_course to be called.
@@ -124,14 +125,14 @@ def test_course_listing_errored_deleted_courses(self):
         Create good courses, courses that won't load, and deleted courses which still have
         roles. Test course listing.
         """
-        mongo_store = modulestore()._get_modulestore_by_type(ModuleStoreEnum.Type.mongo)  # lint-amnesty, pylint: disable=protected-access
+        store = modulestore()
 
-        good_location = mongo_store.make_course_key('testOrg', 'testCourse', 'RunBabyRun')
-        self._create_course_with_access_groups(good_location, default_store=ModuleStoreEnum.Type.mongo)
+        good_location = store.make_course_key('testOrg', 'testCourse', 'RunBabyRun')
+        self._create_course_with_access_groups(good_location)
 
-        course_location = mongo_store.make_course_key('testOrg', 'doomedCourse', 'RunBabyRun')
-        self._create_course_with_access_groups(course_location, default_store=ModuleStoreEnum.Type.mongo)
-        mongo_store.delete_course(course_location, ModuleStoreEnum.UserID.test)
+        course_location = store.make_course_key('testOrg', 'doomedCourse', 'RunBabyRun')
+        self._create_course_with_access_groups(course_location)
+        store.delete_course(course_location, ModuleStoreEnum.UserID.test)
 
         courses_list = list(get_course_enrollments(self.student, None, []))
         assert len(courses_list) == 1, courses_list
diff --git a/common/djangoapps/student/tests/test_views.py b/common/djangoapps/student/tests/test_views.py
index 9d88752bf1a1..6786411e2c54 100644
--- a/common/djangoapps/student/tests/test_views.py
+++ b/common/djangoapps/student/tests/test_views.py
@@ -34,7 +34,6 @@
     remove_prerequisite_course,
     set_prerequisite_courses
 )
-from common.djangoapps.util.testing import UrlResetMixin  # lint-amnesty, pylint: disable=unused-import
 from lms.djangoapps.certificates.tests.factories import GeneratedCertificateFactory
 from lms.djangoapps.certificates.data import CertificateStatuses
 from lms.djangoapps.commerce.utils import EcommerceService
@@ -45,7 +44,6 @@
 from openedx.features.course_duration_limits.models import CourseDurationLimitConfig
 from openedx.features.course_experience.tests.views.helpers import add_course_mode
 from xmodule.data import CertificatesDisplayBehaviors  # lint-amnesty, pylint: disable=wrong-import-order
-from xmodule.modulestore import ModuleStoreEnum  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.tests.django_utils import SharedModuleStoreTestCase  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory  # lint-amnesty, pylint: disable=wrong-import-order
 
@@ -288,16 +286,15 @@ def test_cert_available_message_after_course_end(self):
         *itertools.product(
             [True, False],
             [True, False],
-            [ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split],
         )
     )
     @ddt.unpack
-    def test_sharing_icons_for_future_course(self, set_marketing, set_social_sharing, modulestore_type):
+    def test_sharing_icons_for_future_course(self, set_marketing, set_social_sharing):
         """
         Verify that the course sharing icons show up if course is starting in future and
         any of marketing or social sharing urls are set.
         """
-        self.course = CourseFactory.create(start=TOMORROW, emit_signals=True, default_store=modulestore_type)  # lint-amnesty, pylint: disable=attribute-defined-outside-init
+        self.course = CourseFactory.create(start=TOMORROW, emit_signals=True)  # lint-amnesty, pylint: disable=attribute-defined-outside-init
         self.course_enrollment = CourseEnrollmentFactory(course_id=self.course.id, user=self.user)  # lint-amnesty, pylint: disable=attribute-defined-outside-init
         self.set_course_sharing_urls(set_marketing, set_social_sharing)
 
diff --git a/common/djangoapps/student/tests/tests.py b/common/djangoapps/student/tests/tests.py
index f607821cf766..23f9101e5b52 100644
--- a/common/djangoapps/student/tests/tests.py
+++ b/common/djangoapps/student/tests/tests.py
@@ -50,7 +50,7 @@
 from openedx.core.djangoapps.site_configuration.tests.mixins import SiteMixin
 from openedx.core.djangolib.testing.utils import CacheIsolationTestCase, skip_unless_lms
 from openedx.core.djangoapps.site_configuration import helpers as configuration_helpers
-from xmodule.modulestore.tests.django_utils import ModuleStoreEnum, ModuleStoreTestCase, SharedModuleStoreTestCase  # lint-amnesty, pylint: disable=wrong-import-order
+from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase, SharedModuleStoreTestCase  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.tests.factories import CourseFactory, check_mongo_calls  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.data import CertificatesDisplayBehaviors  # lint-amnesty, pylint: disable=wrong-import-order
 
@@ -472,8 +472,7 @@ def test_linked_in_add_to_profile_btn_with_certificate(self):
         )))
 
     @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms')
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_dashboard_metadata_caching(self, modulestore_type):
+    def test_dashboard_metadata_caching(self):
         """
         Check that the student dashboard makes use of course metadata caching.
 
@@ -481,10 +480,6 @@ def test_dashboard_metadata_caching(self, modulestore_type):
         CourseOverview. The student dashboard should never have to make calls to
         the modulestore.
 
-        Arguments:
-            modulestore_type (ModuleStoreEnum.Type): Type of modulestore to create
-                test course in.
-
         Note to future developers:
             If you break this test so that the "check_mongo_calls(0)" fails,
             please do NOT change it to "check_mongo_calls(n>=1)". Instead, change
@@ -494,7 +489,7 @@ def test_dashboard_metadata_caching(self, modulestore_type):
         """
         # Create a course and log in the user.
         # Creating a new course will trigger a publish event and the course will be cached
-        test_course = CourseFactory.create(default_store=modulestore_type, emit_signals=True)
+        test_course = CourseFactory.create(emit_signals=True)
         self.client.login(username="jack", password="test")
 
         with check_mongo_calls(0):
diff --git a/lms/djangoapps/course_api/blocks/tests/test_api.py b/lms/djangoapps/course_api/blocks/tests/test_api.py
index 8bf7b9d518ed..7f70267b0b0a 100644
--- a/lms/djangoapps/course_api/blocks/tests/test_api.py
+++ b/lms/djangoapps/course_api/blocks/tests/test_api.py
@@ -211,7 +211,7 @@ class TestGetBlocksQueryCounts(TestGetBlocksQueryCountsBase):
 
     @ddt.data(
         *product(
-            (ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split),
+            (ModuleStoreEnum.Type.split,),
             (True, False),
         )
     )
@@ -226,8 +226,6 @@ def test_query_counts_cached(self, store_type, with_storage_backing):
             )
 
     @ddt.data(
-        (ModuleStoreEnum.Type.mongo, 5, True, 24),
-        (ModuleStoreEnum.Type.mongo, 5, False, 14),
         (ModuleStoreEnum.Type.split, 2, True, 24),
         (ModuleStoreEnum.Type.split, 2, False, 14),
     )
diff --git a/lms/djangoapps/course_api/tests/test_serializers.py b/lms/djangoapps/course_api/tests/test_serializers.py
index 7bba11d54055..7c3b59fdfecf 100644
--- a/lms/djangoapps/course_api/tests/test_serializers.py
+++ b/lms/djangoapps/course_api/tests/test_serializers.py
@@ -3,6 +3,7 @@
 """
 
 
+from collections import OrderedDict
 from datetime import datetime
 from unittest import TestCase
 
@@ -12,7 +13,7 @@
 from rest_framework.test import APIRequestFactory
 from xblock.core import XBlock
 from xmodule.course_module import DEFAULT_START_DATE
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, ModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import check_mongo_calls
 
 from openedx.core.djangoapps.content.course_overviews.models import CourseOverview
@@ -31,7 +32,7 @@ class TestCourseSerializer(CourseApiFactoryMixin, ModuleStoreTestCase):
     maxDiff = 5000  # long enough to show mismatched dicts, in case of error
     serializer_class = CourseSerializer
 
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
     ENABLED_SIGNALS = ['course_published']
 
     def setUp(self):
@@ -40,45 +41,47 @@ def setUp(self):
         self.honor_user = self.create_user('honor', is_staff=False)
         self.request_factory = APIRequestFactory()
 
-        course_id = 'edX/toy/2012_Fall'
-        banner_image_uri = '/c4x/edX/toy/asset/images_course_image.jpg'
+        course_id = 'course-v1:edX+toy+2012_Fall'
+        banner_image_uri = '/asset-v1:edX+toy+2012_Fall+type@asset+block@images_course_image.jpg'
         banner_image_absolute_uri = 'http://testserver' + banner_image_uri
-        image_path = '/c4x/edX/toy/asset/just_a_test.jpg'
+        image_path = '/asset-v1:edX+toy+2012_Fall+type@asset+block@just_a_test.jpg'
         image_url = 'http://testserver' + image_path
         self.expected_data = {
             'id': course_id,
             'name': 'Toy Course',
             'number': 'toy',
             'org': 'edX',
-            'short_description': 'A course about toys.',
-            'media': {
-                'banner_image': {
-                    'uri': banner_image_uri,
-                    'uri_absolute': banner_image_absolute_uri,
-                },
-                'course_image': {
-                    'uri': image_path,
-                },
-                'course_video': {
-                    'uri': 'http://www.youtube.com/watch?v=test_youtube_id',
-                },
-                'image': {
-                    'raw': image_url,
-                    'small': image_url,
-                    'large': image_url,
-                },
-            },
+            'short_description': None,
+            'media': OrderedDict([
+                (
+                    'banner_image',
+                    OrderedDict([
+                        ('uri', banner_image_uri),
+                        ('uri_absolute', banner_image_absolute_uri)
+                    ])
+                ),
+                ('course_image', OrderedDict([('uri', image_path)])),
+                ('course_video', OrderedDict([('uri', None)])),
+                (
+                    'image',
+                    OrderedDict([
+                        ('raw', image_url),
+                        ('small', image_url),
+                        ('large', image_url)
+                    ])
+                )]
+            ),
             'start': '2015-07-17T12:00:00Z',
             'start_type': 'timestamp',
             'start_display': 'July 17, 2015',
             'end': '2015-09-19T18:00:00Z',
             'enrollment_start': '2015-06-15T00:00:00Z',
             'enrollment_end': '2015-07-15T00:00:00Z',
-            'blocks_url': 'http://testserver/api/courses/v2/blocks/?course_id=edX%2Ftoy%2F2012_Fall',
-            'effort': '6 hours',
+            'blocks_url': 'http://testserver/api/courses/v2/blocks/?course_id=course-v1%3AedX%2Btoy%2B2012_Fall',
+            'effort': None,
             'pacing': 'instructor',
             'mobile_available': True,
-            'hidden': True,  # because it's an old mongo course
+            'hidden': False,
             'invitation_only': False,
 
             # 'course_id' is a deprecated field, please use 'id' instead.
@@ -125,14 +128,14 @@ def test_advertised_start(self):
             advertised_start='The Ides of March'
         )
         result = self._get_result(course)
-        assert result['course_id'] == 'edX/custom/2012_Fall'
+        assert result['course_id'] == 'course-v1:edX+custom+2012_Fall'
         assert result['start_type'] == 'string'
         assert result['start_display'] == 'The Ides of March'
 
     def test_empty_start(self):
         course = self.create_course(start=DEFAULT_START_DATE, course='custom')
         result = self._get_result(course)
-        assert result['course_id'] == 'edX/custom/2012_Fall'
+        assert result['course_id'] == 'course-v1:edX+custom+2012_Fall'
         assert result['start_type'] == 'empty'
         assert result['start_display'] is None
 
@@ -154,8 +157,8 @@ class TestCourseDetailSerializer(TestCourseSerializer):  # lint-amnesty, pylint:
     CourseDetailSerializer serializer class.
 
     """
-    # 1 mongo call is made to get the course About overview text.
-    expected_mongo_calls = 1
+    # 2 mongo call is made to get the course About overview text.
+    expected_mongo_calls = 2
     serializer_class = CourseDetailSerializer
 
     def setUp(self):
diff --git a/lms/djangoapps/course_blocks/transformers/tests/test_load_override_data.py b/lms/djangoapps/course_blocks/transformers/tests/test_load_override_data.py
index e522bc5b65d3..0dc844af2bd1 100644
--- a/lms/djangoapps/course_blocks/transformers/tests/test_load_override_data.py
+++ b/lms/djangoapps/course_blocks/transformers/tests/test_load_override_data.py
@@ -8,7 +8,7 @@
 import ddt
 import pytz
 from xmodule.modulestore.django import modulestore
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, ModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import ToyCourseFactory
 
 from common.djangoapps.student.tests.factories import CourseEnrollmentFactory, UserFactory
@@ -32,7 +32,7 @@ class TestOverrideDataTransformer(ModuleStoreTestCase):
     """
     Test proper behavior for OverrideDataTransformer
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     @classmethod
     def setUpClass(cls):
@@ -52,9 +52,6 @@ def setUp(self):
             self.learner.id, subsection.location, 'html', 'new_component'
         )
         CourseEnrollmentFactory.create(user=self.learner, course_id=self.course_key, is_active=True)
-        self.block = self.store.create_child(
-            self.learner2.id, subsection.location, 'html', 'new_component'
-        )
         CourseEnrollmentFactory.create(user=self.learner2, course_id=self.course_key, is_active=True)
 
     @ddt.data(*REQUESTED_FIELDS)
diff --git a/lms/djangoapps/course_wiki/tests/test_access.py b/lms/djangoapps/course_wiki/tests/test_access.py
index 86c6e54b8a9b..daf51c7c0054 100644
--- a/lms/djangoapps/course_wiki/tests/test_access.py
+++ b/lms/djangoapps/course_wiki/tests/test_access.py
@@ -5,7 +5,7 @@
 
 from django.contrib.auth.models import Group
 from wiki.models import URLPath
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, ModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory
 
 from common.djangoapps.student.tests.factories import InstructorFactory
@@ -18,14 +18,14 @@
 
 class TestWikiAccessBase(ModuleStoreTestCase):
     """Base class for testing wiki access."""
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         super().setUp()
 
         self.wiki = get_or_create_root()
 
-        self.course_math101 = CourseFactory.create(org='org', number='math101', display_name='Course', metadata={'use_unique_wiki_id': 'false'})  # lint-amnesty, pylint: disable=line-too-long
+        self.course_math101 = CourseFactory.create(org='org', number='math101', display_name='Course')  # lint-amnesty, pylint: disable=line-too-long
         self.course_math101_staff = self.create_staff_for_course(self.course_math101)
 
         wiki_math101 = self.create_urlpath(self.wiki, course_wiki_slug(self.course_math101))
@@ -33,7 +33,7 @@ def setUp(self):
         wiki_math101_page_page = self.create_urlpath(wiki_math101_page, 'Grandchild')
         self.wiki_math101_pages = [wiki_math101, wiki_math101_page, wiki_math101_page_page]
 
-        self.course_math101b = CourseFactory.create(org='org', number='math101b', display_name='Course', metadata={'use_unique_wiki_id': 'true'})  # lint-amnesty, pylint: disable=line-too-long
+        self.course_math101b = CourseFactory.create(org='org', number='math101b', display_name='Course')  # lint-amnesty, pylint: disable=line-too-long
         self.course_math101b_staff = self.create_staff_for_course(self.course_math101b)
 
         wiki_math101b = self.create_urlpath(self.wiki, course_wiki_slug(self.course_math101b))
diff --git a/lms/djangoapps/course_wiki/tests/test_middleware.py b/lms/djangoapps/course_wiki/tests/test_middleware.py
index 16937cc77289..7836f4d4fbf2 100644
--- a/lms/djangoapps/course_wiki/tests/test_middleware.py
+++ b/lms/djangoapps/course_wiki/tests/test_middleware.py
@@ -5,7 +5,7 @@
 
 from django.test.client import Client
 from wiki.models import URLPath
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, ModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory
 
 from common.djangoapps.student.tests.factories import InstructorFactory
@@ -14,7 +14,7 @@
 
 class TestWikiAccessMiddleware(ModuleStoreTestCase):
     """Tests for WikiAccessMiddleware."""
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         """Test setup."""
@@ -22,7 +22,7 @@ def setUp(self):
 
         self.wiki = get_or_create_root()
 
-        self.course_math101 = CourseFactory.create(org='edx', number='math101', display_name='2014', metadata={'use_unique_wiki_id': 'false'})  # lint-amnesty, pylint: disable=line-too-long
+        self.course_math101 = CourseFactory.create(org='edx', number='math101', display_name='2014')  # lint-amnesty, pylint: disable=line-too-long
         self.course_math101_instructor = InstructorFactory(course_key=self.course_math101.id, username='instructor', password='secret')  # lint-amnesty, pylint: disable=line-too-long
         self.wiki_math101 = URLPath.create_article(self.wiki, 'math101', title='math101')
 
@@ -31,6 +31,6 @@ def setUp(self):
 
     def test_url_tranform(self):
         """Test that the correct prefix ('/courses/<course_id>') is added to the urls in the wiki."""
-        response = self.client.get('/courses/edx/math101/2014/wiki/math101/')
-        self.assertContains(response, '/courses/edx/math101/2014/wiki/math101/_edit/')
-        self.assertContains(response, '/courses/edx/math101/2014/wiki/math101/_settings/')
+        response = self.client.get('/courses/course-v1:edx+math101+2014/wiki/math101/')
+        self.assertContains(response, '/courses/course-v1:edx+math101+2014/wiki/math101/_edit/')
+        self.assertContains(response, '/courses/course-v1:edx+math101+2014/wiki/math101/_settings/')
diff --git a/lms/djangoapps/courseware/management/commands/tests/test_dump_course.py b/lms/djangoapps/courseware/management/commands/tests/test_dump_course.py
index 230dbbc7b523..075703bab967 100644
--- a/lms/djangoapps/courseware/management/commands/tests/test_dump_course.py
+++ b/lms/djangoapps/courseware/management/commands/tests/test_dump_course.py
@@ -14,7 +14,6 @@
 from xmodule.modulestore import ModuleStoreEnum
 from xmodule.modulestore.django import modulestore
 from xmodule.modulestore.tests.django_utils import (
-    TEST_DATA_MONGO_MODULESTORE,
     TEST_DATA_SPLIT_MODULESTORE,
     SharedModuleStoreTestCase
 )
@@ -223,15 +222,6 @@ def check_export_file(self, tar_file):  # pylint: disable=missing-function-docst
         assert_in('edX-simple-2012_Fall/sequential/Lecture_2.xml', names)
 
 
-class CommandsMongoTestCase(CommandsTestBase):
-    """
-    Test case for management commands using the mixed mongo modulestore with old mongo as the default.
-
-    """
-    MODULESTORE = TEST_DATA_MONGO_MODULESTORE
-    __test__ = True
-
-
 class CommandSplitMongoTestCase(CommandsTestBase):
     """
     Test case for management commands using the mixed mongo modulestore with split as the default.
diff --git a/lms/djangoapps/courseware/tests/helpers.py b/lms/djangoapps/courseware/tests/helpers.py
index b362ece11f1b..c463163329ef 100644
--- a/lms/djangoapps/courseware/tests/helpers.py
+++ b/lms/djangoapps/courseware/tests/helpers.py
@@ -31,7 +31,7 @@
 from common.djangoapps.student.tests.factories import CourseEnrollmentFactory, UserFactory
 from common.djangoapps.util.date_utils import strftime_localized_html
 from xmodule.modulestore.django import modulestore  # lint-amnesty, pylint: disable=wrong-import-order
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_MODULESTORE, ModuleStoreTestCase  # lint-amnesty, pylint: disable=wrong-import-order
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.tests import get_test_descriptor_system, get_test_system  # lint-amnesty, pylint: disable=wrong-import-order
 
@@ -52,10 +52,9 @@ class BaseTestXmodule(ModuleStoreTestCase):
     This class should not contain any tests, because CATEGORY
     should be defined in child class.
     """
-    MODULESTORE = TEST_DATA_MONGO_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     USER_COUNT = 2
-    COURSE_DATA = {}
 
     # Data from YAML xmodule/templates/NAME/default.yaml
     CATEGORY = "vertical"
@@ -99,7 +98,7 @@ def initialize_module(self, runtime_kwargs=None, **kwargs):  # lint-amnesty, pyl
         self.item_url = str(self.item_descriptor.location)
 
     def setup_course(self):  # lint-amnesty, pylint: disable=missing-function-docstring
-        self.course = CourseFactory.create(data=self.COURSE_DATA)
+        self.course = CourseFactory.create()
 
         # Turn off cache.
         modulestore().request_cache = None
diff --git a/lms/djangoapps/courseware/tests/test_courses.py b/lms/djangoapps/courseware/tests/test_courses.py
index 7dd231b1eb1c..561d355628bd 100644
--- a/lms/djangoapps/courseware/tests/test_courses.py
+++ b/lms/djangoapps/courseware/tests/test_courses.py
@@ -20,9 +20,8 @@
 from opaque_keys.edx.keys import CourseKey
 from xmodule.modulestore import ModuleStoreEnum
 from xmodule.modulestore.django import _get_modulestore_branch_setting, modulestore
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, ModuleStoreTestCase
-from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory, check_mongo_calls
-from xmodule.modulestore.xml_importer import import_course_from_xml
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase
+from xmodule.modulestore.tests.factories import CourseFactory, ToyCourseFactory, ItemFactory, check_mongo_calls
 from xmodule.tests.xml import XModuleXmlImportTest
 from xmodule.tests.xml import factories as xml
 
@@ -39,13 +38,11 @@
     get_courses,
     get_current_child
 )
-from lms.djangoapps.courseware.exceptions import CourseAccessRedirect
 from lms.djangoapps.courseware.model_data import FieldDataCache
 from lms.djangoapps.courseware.module_render import get_module_for_descriptor
 from lms.djangoapps.courseware.courseware_access_exception import CoursewareAccessException
 from openedx.core.djangolib.testing.utils import get_mock_request
 from openedx.core.lib.courses import course_image_url
-from openedx.core.lib.courses import get_course_by_id
 from common.djangoapps.student.tests.factories import UserFactory
 
 CMS_BASE_TEST = 'testcms'
@@ -89,18 +86,6 @@ def test_get_course_func_with_access_error(self, course_access_func_name):
         assert error.value.access_response.error_code == 'not_visible_to_user'
         assert not error.value.access_response.has_access
 
-    @ddt.data(GET_COURSE_WITH_ACCESS, GET_COURSE_OVERVIEW_WITH_ACCESS)
-    def test_old_mongo_access_error(self, course_access_func_name):
-        course_access_func = self.COURSE_ACCESS_FUNCS[course_access_func_name]
-        user = UserFactory.create()
-        with self.store.default_store(ModuleStoreEnum.Type.mongo):
-            course = CourseFactory.create()
-
-        with pytest.raises(CourseAccessRedirect) as error:
-            course_access_func(user, 'load', course.id)
-        assert error.value.access_error.error_code == 'old_mongo'
-        assert not error.value.access_error.has_access
-
     @ddt.data(
         (GET_COURSE_WITH_ACCESS, 2),
         (GET_COURSE_OVERVIEW_WITH_ACCESS, 0),
@@ -281,7 +266,7 @@ def test_spaces_in_image_name(self):
 
 class CoursesRenderTest(ModuleStoreTestCase):
     """Test methods related to rendering courses content."""
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     # TODO: this test relies on the specific setup of the toy course.
     # It should be rewritten to build the course it needs and then test that.
@@ -291,17 +276,15 @@ def setUp(self):
         """
         super().setUp()
 
-        store = modulestore()
-        course_items = import_course_from_xml(store, self.user.id, TEST_DATA_DIR, ['toy'])
-        course_key = course_items[0].id
-        self.course = get_course_by_id(course_key)
+        self.course = ToyCourseFactory()
         self.addCleanup(set_current_request, None)
         self.request = get_mock_request(UserFactory.create())
 
     def test_get_course_info_section_render(self):
         # Test render works okay
         course_info = get_course_info_section(self.request, self.request.user, self.course, 'handouts')
-        assert course_info == "<a href='/c4x/edX/toy/asset/handouts_sample_handout.txt'>Sample</a>"
+        assert course_info == \
+            "<a href='/asset-v1:edX+toy+2012_Fall+type@asset+block/handouts_sample_handout.txt'>Sample</a>"
 
         # Test when render raises an exception
         with mock.patch('lms.djangoapps.courseware.courses.get_module') as mock_module_render:
diff --git a/lms/djangoapps/courseware/tests/test_discussion_xblock.py b/lms/djangoapps/courseware/tests/test_discussion_xblock.py
index e5ee524ec8a7..09d3b1cf1599 100644
--- a/lms/djangoapps/courseware/tests/test_discussion_xblock.py
+++ b/lms/djangoapps/courseware/tests/test_discussion_xblock.py
@@ -17,8 +17,7 @@
 from web_fragments.fragment import Fragment
 from xblock.field_data import DictFieldData
 from xmodule.discussion_block import DiscussionXBlock, loader
-from xmodule.modulestore import ModuleStoreEnum
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, SharedModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, SharedModuleStoreTestCase
 from xmodule.modulestore.tests.factories import ItemFactory, ToyCourseFactory
 
 from lms.djangoapps.course_api.blocks.tests.helpers import deserialize_usage_key
@@ -261,7 +260,7 @@ class TestXBlockInCourse(SharedModuleStoreTestCase):
     """
     Test the discussion xblock as rendered in the course and course API.
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     @classmethod
     def setUpClass(cls):
@@ -309,52 +308,50 @@ def test_html_with_user(self):
         assert 'data-user-create-comment="false"' in html
         assert 'data-user-create-subcomment="false"' in html
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_discussion_render_successfully_with_orphan_parent(self, default_store):
+    def test_discussion_render_successfully_with_orphan_parent(self):
         """
         Test that discussion xblock render successfully
         if discussion xblock is child of an orphan.
         """
-        with self.store.default_store(default_store):
-            orphan_sequential = self.store.create_item(self.user.id, self.course.id, 'sequential')
+        orphan_sequential = self.store.create_item(self.user.id, self.course.id, 'sequential')
 
-            vertical = self.store.create_child(
-                self.user.id,
-                orphan_sequential.location,
-                'vertical',
-                block_id=self.course.location.block_id
-            )
+        vertical = self.store.create_child(
+            self.user.id,
+            orphan_sequential.location,
+            'vertical',
+            block_id=self.course.location.block_id
+        )
 
-            discussion = self.store.create_child(
-                self.user.id,
-                vertical.location,
-                'discussion',
-                block_id=self.course.location.block_id
-            )
+        discussion = self.store.create_child(
+            self.user.id,
+            vertical.location,
+            'discussion',
+            block_id=self.course.location.block_id
+        )
 
-            discussion = self.store.get_item(discussion.location)
+        discussion = self.store.get_item(discussion.location)
 
-            root = self.get_root(discussion)
-            # Assert that orphan sequential is root of the discussion xblock.
-            assert orphan_sequential.location.block_type == root.location.block_type
-            assert orphan_sequential.location.block_id == root.location.block_id
+        root = self.get_root(discussion)
+        # Assert that orphan sequential is root of the discussion xblock.
+        assert orphan_sequential.location.block_type == root.location.block_type
+        assert orphan_sequential.location.block_id == root.location.block_id
 
-            # Get xblock bound to a user and a descriptor.
-            discussion_xblock = get_module_for_descriptor_internal(
-                user=self.user,
-                descriptor=discussion,
-                student_data=mock.Mock(name='student_data'),
-                course_id=self.course.id,
-                track_function=mock.Mock(name='track_function'),
-                request_token='request_token',
-            )
+        # Get xblock bound to a user and a descriptor.
+        discussion_xblock = get_module_for_descriptor_internal(
+            user=self.user,
+            descriptor=discussion,
+            student_data=mock.Mock(name='student_data'),
+            course_id=self.course.id,
+            track_function=mock.Mock(name='track_function'),
+            request_token='request_token',
+        )
 
-            fragment = discussion_xblock.render('student_view')
-            html = fragment.content
+        fragment = discussion_xblock.render('student_view')
+        html = fragment.content
 
-            assert isinstance(discussion_xblock, DiscussionXBlock)
-            assert 'data-user-create-comment="false"' in html
-            assert 'data-user-create-subcomment="false"' in html
+        assert isinstance(discussion_xblock, DiscussionXBlock)
+        assert 'data-user-create-comment="false"' in html
+        assert 'data-user-create-subcomment="false"' in html
 
     def test_discussion_student_view_data(self):
         """
diff --git a/lms/djangoapps/courseware/tests/test_group_access.py b/lms/djangoapps/courseware/tests/test_group_access.py
index 6d42caf09077..278f28bc7e0e 100644
--- a/lms/djangoapps/courseware/tests/test_group_access.py
+++ b/lms/djangoapps/courseware/tests/test_group_access.py
@@ -7,7 +7,7 @@
 import ddt
 from stevedore.extension import Extension, ExtensionManager
 from xmodule.modulestore.django import modulestore
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, ModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
 from xmodule.partitions.partitions import USER_PARTITION_SCHEME_NAMESPACE, Group, UserPartition
 
@@ -57,7 +57,7 @@ class GroupAccessTestCase(ModuleStoreTestCase):
     Tests to ensure that has_access() correctly enforces the visibility
     restrictions specified in the `group_access` field of XBlocks.
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def set_user_group(self, user, partition, group):
         """
diff --git a/lms/djangoapps/courseware/tests/test_module_render.py b/lms/djangoapps/courseware/tests/test_module_render.py
index 15b33844790d..cf1bb5131d7f 100644
--- a/lms/djangoapps/courseware/tests/test_module_render.py
+++ b/lms/djangoapps/courseware/tests/test_module_render.py
@@ -48,7 +48,7 @@
 from xmodule.modulestore import ModuleStoreEnum
 from xmodule.modulestore.django import modulestore
 from xmodule.modulestore.tests.django_utils import (
-    TEST_DATA_MONGO_AMNESTY_MODULESTORE,
+    TEST_DATA_SPLIT_MODULESTORE,
     ModuleStoreTestCase,
     SharedModuleStoreTestCase,
     upload_file_to_course,
@@ -1562,7 +1562,7 @@ def test_course_image(self):
         self.course.static_asset_path = ""
 
     @override_settings(DEFAULT_COURSE_ABOUT_IMAGE_URL='test.png')
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_course_image_for_split_course(self, store):
         """
         for split courses if course_image is empty then course_image_url will be
@@ -1658,7 +1658,7 @@ def student_view(self, context=None):  # pylint: disable=unused-argument
 @patch('lms.djangoapps.courseware.module_render.has_access', Mock(return_value=True, autospec=True))
 class TestStaffDebugInfo(SharedModuleStoreTestCase):
     """Tests to verify that Staff Debug Info panel and histograms are displayed to staff."""
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     @classmethod
     def setUpClass(cls):
@@ -2436,13 +2436,13 @@ def setUp(self):
         super().setUp()
         XBlockConfiguration(name='video', enabled=False).save()
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_get_item(self, default_ms):
         with self.store.default_store(default_ms):
             course = CourseFactory()
             self._verify_descriptor('video', course, 'HiddenDescriptorWithMixins')
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_dynamic_updates(self, default_ms):
         """Tests that the list of disabled xblocks can dynamically update."""
         with self.store.default_store(default_ms):
@@ -2478,8 +2478,8 @@ class LmsModuleSystemShimTest(SharedModuleStoreTestCase):
     """
     Tests that the deprecated attributes in the LMS Module System (XBlock Runtime) return the expected values.
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
-    COURSE_ID = 'edX/LmsModuleShimTest/2021_Fall'
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
+    COURSE_ID = 'course-v1:edX+LmsModuleShimTest+2021_Fall'
     PYTHON_LIB_FILENAME = 'test_python_lib.zip'
     PYTHON_LIB_SOURCE_FILE = './common/test/data/uploads/python_lib.zip'
 
@@ -2489,7 +2489,9 @@ def setUpClass(cls):
         Set up the course and descriptor used to instantiate the runtime.
         """
         super().setUpClass()
-        org, number, run = cls.COURSE_ID.split('/')
+        org = 'edX'
+        number = 'LmsModuleShimTest'
+        run = '2021_Fall'
         cls.course = CourseFactory.create(org=org, number=number, run=run)
         cls.descriptor = ItemFactory(category="vertical", parent=cls.course)
         cls.problem_descriptor = ItemFactory(category="problem", parent=cls.course)
@@ -2633,8 +2635,7 @@ def test_xqueue(self):
         assert xqueue['interface'].url == 'http://sandbox-xqueue.edx.org'
         assert xqueue['default_queuename'] == 'edX-LmsModuleShimTest'
         assert xqueue['waittime'] == 5
-        callback_url = ('http://localhost:8000/courses/edX/LmsModuleShimTest/2021_Fall/xqueue/232/'
-                        + str(self.descriptor.location))
+        callback_url = f'http://localhost:8000/courses/{self.course.id}/xqueue/232/{self.descriptor.location}'
         assert xqueue['construct_callback']() == f'{callback_url}/score_update'
         assert xqueue['construct_callback']('mock_dispatch') == f'{callback_url}/mock_dispatch'
 
@@ -2665,15 +2666,15 @@ def test_xqueue_settings(self):
         assert xqueue['interface'].url == 'http://xqueue.url'
         assert xqueue['default_queuename'] == 'edX-LmsModuleShimTest'
         assert xqueue['waittime'] == 15
-        callback_url = f'http://alt.url/courses/edX/LmsModuleShimTest/2021_Fall/xqueue/232/{self.descriptor.location}'
+        callback_url = f'http://alt.url/courses/{self.course.id}/xqueue/232/{self.descriptor.location}'
         assert xqueue['construct_callback']() == f'{callback_url}/score_update'
         assert xqueue['construct_callback']('mock_dispatch') == f'{callback_url}/mock_dispatch'
 
-    @override_settings(COURSES_WITH_UNSAFE_CODE=[COURSE_ID])
+    @override_settings(COURSES_WITH_UNSAFE_CODE=[r'course-v1:edX\+LmsModuleShimTest\+2021_Fall'])
     def test_can_execute_unsafe_code_when_allowed(self):
         assert self.runtime.can_execute_unsafe_code()
 
-    @override_settings(COURSES_WITH_UNSAFE_CODE=['edX/full/2012_Fall'])
+    @override_settings(COURSES_WITH_UNSAFE_CODE=[r'course-v1:edX\+full\+2021_Fall'])
     def test_cannot_execute_unsafe_code_when_disallowed(self):
         assert not self.runtime.can_execute_unsafe_code()
 
diff --git a/lms/djangoapps/courseware/tests/test_tabs.py b/lms/djangoapps/courseware/tests/test_tabs.py
index 42687d441275..35d3296bda61 100644
--- a/lms/djangoapps/courseware/tests/test_tabs.py
+++ b/lms/djangoapps/courseware/tests/test_tabs.py
@@ -38,7 +38,7 @@
 )
 from xmodule import tabs as xmodule_tabs  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.tests.django_utils import (  # lint-amnesty, pylint: disable=wrong-import-order
-    TEST_DATA_MIXED_MODULESTORE,
+    TEST_DATA_SPLIT_MODULESTORE,
     ModuleStoreTestCase,
     SharedModuleStoreTestCase
 )
@@ -435,7 +435,7 @@ class TextBookCourseViewsTestCase(LoginEnrollmentTestCase, SharedModuleStoreTest
     """
     Validate tab behavior when dealing with textbooks.
     """
-    MODULESTORE = TEST_DATA_MIXED_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     @classmethod
     def setUpClass(cls):
diff --git a/lms/djangoapps/courseware/tests/test_video_handlers.py b/lms/djangoapps/courseware/tests/test_video_handlers.py
index 91ad34d0b504..3aaeba0c4a8c 100644
--- a/lms/djangoapps/courseware/tests/test_video_handlers.py
+++ b/lms/djangoapps/courseware/tests/test_video_handlers.py
@@ -143,6 +143,7 @@ def initialize_block(self, data=None, **kwargs):
             # a lot of tests code, parse and set the values as fields.
             fields_data = VideoBlock.parse_video_xml(data)
             kwargs.update(fields_data)
+        kwargs.pop('source', None)
         super().initialize_module(**kwargs)
 
     def setUp(self):
diff --git a/lms/djangoapps/courseware/tests/test_video_mongo.py b/lms/djangoapps/courseware/tests/test_video_mongo.py
index c84bf675b794..34255fd722d5 100644
--- a/lms/djangoapps/courseware/tests/test_video_mongo.py
+++ b/lms/djangoapps/courseware/tests/test_video_mongo.py
@@ -36,9 +36,8 @@
 from path import Path as path
 from xmodule.contentstore.content import StaticContent
 from xmodule.exceptions import NotFoundError
-from xmodule.modulestore import ModuleStoreEnum
 from xmodule.modulestore.inheritance import own_metadata
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_MODULESTORE, TEST_DATA_SPLIT_MODULESTORE
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE
 from xmodule.tests.test_import import DummySystem
 from xmodule.tests.test_video import VideoBlockTestBase
 from xmodule.video_module import VideoBlock, bumper_utils, video_utils
@@ -55,10 +54,6 @@
 from .test_video_handlers import BaseTestVideoXBlock, TestVideo
 from .test_video_xml import SOURCE_XML
 
-MODULESTORES = {
-    ModuleStoreEnum.Type.mongo: TEST_DATA_MONGO_MODULESTORE,
-    ModuleStoreEnum.Type.split: TEST_DATA_SPLIT_MODULESTORE,
-}
 
 TRANSCRIPT_FILE_SRT_DATA = """
 1
@@ -281,7 +276,7 @@ def test_get_html_track(self):
         # lint-amnesty, pylint: disable=redefined-outer-name
         SOURCE_XML = """
             <video show_captions="true"
-            display_name="A Name"
+            display_name="{name}"
                 sub="{sub}" download_track="{download_track}"
             start_time="3603.0" end_time="3610.0" download_video="true"
             >
@@ -294,6 +289,7 @@ def test_get_html_track(self):
 
         cases = [
             {
+                'name': 'video 1',
                 'download_track': 'true',
                 'track': '<track src="http://www.example.com/track"/>',
                 'sub': 'a_sub_file.srt.sjson',
@@ -301,6 +297,7 @@ def test_get_html_track(self):
                 'transcripts': '',
             },
             {
+                'name': 'video 2',
                 'download_track': 'true',
                 'track': '',
                 'sub': 'a_sub_file.srt.sjson',
@@ -308,6 +305,7 @@ def test_get_html_track(self):
                 'transcripts': '',
             },
             {
+                'name': 'video 3',
                 'download_track': 'true',
                 'track': '',
                 'sub': '',
@@ -315,6 +313,7 @@ def test_get_html_track(self):
                 'transcripts': '',
             },
             {
+                'name': 'video 4',
                 'download_track': 'false',
                 'track': '<track src="http://www.example.com/track"/>',
                 'sub': 'a_sub_file.srt.sjson',
@@ -322,6 +321,7 @@ def test_get_html_track(self):
                 'transcripts': '',
             },
             {
+                'name': 'video 5',
                 'download_track': 'true',
                 'track': '',
                 'sub': '',
@@ -361,6 +361,7 @@ def test_get_html_track(self):
                 track=data['track'],
                 sub=data['sub'],
                 transcripts=data['transcripts'],
+                name=data['name'],
             )
 
             self.initialize_block(data=DATA)
@@ -376,6 +377,7 @@ def test_get_html_track(self):
                 'saveStateUrl': self.item_descriptor.ajax_url + '/save_user_state',
             })
             expected_context.update({
+                'display_name': data['name'],
                 'transcript_download_format': (
                     None if self.item_descriptor.track and self.item_descriptor.download_track else 'srt'
                 ),
@@ -394,7 +396,7 @@ def test_get_html_source(self):
         # lint-amnesty, pylint: disable=invalid-name, redefined-outer-name
         SOURCE_XML = """
             <video show_captions="true"
-            display_name="A Name"
+            display_name="{name}"
             sub="a_sub_file.srt.sjson" source="{source}"
             download_video="{download_video}"
             start_time="3603.0" end_time="3610.0"
@@ -405,6 +407,7 @@ def test_get_html_source(self):
         cases = [
             # self.download_video == True
             {
+                'name': 'video 1',
                 'download_video': 'true',
                 'source': 'example_source.mp4',
                 'sources': """
@@ -417,6 +420,7 @@ def test_get_html_source(self):
                 },
             },
             {
+                'name': 'video 2',
                 'download_video': 'true',
                 'source': '',
                 'sources': """
@@ -429,6 +433,7 @@ def test_get_html_source(self):
                 },
             },
             {
+                'name': 'video 3',
                 'download_video': 'true',
                 'source': '',
                 'sources': [],
@@ -437,6 +442,7 @@ def test_get_html_source(self):
 
             # self.download_video == False
             {
+                'name': 'video 4',
                 'download_video': 'false',
                 'source': 'example_source.mp4',
                 'sources': """
@@ -475,7 +481,8 @@ def test_get_html_source(self):
             DATA = SOURCE_XML.format(  # lint-amnesty, pylint: disable=invalid-name
                 download_video=data['download_video'],
                 source=data['source'],
-                sources=data['sources']
+                sources=data['sources'],
+                name=data['name'],
             )
             self.initialize_block(data=DATA)
             context = self.item_descriptor.render(STUDENT_VIEW).content
@@ -489,6 +496,7 @@ def test_get_html_source(self):
                 'sources': data['result'].get('sources', []),
             })
             expected_context.update({
+                'display_name': data['name'],
                 'id': self.item_descriptor.location.html_id(),
                 'download_video_link': data['result'].get('download_video_link'),
                 'metadata': json.dumps(expected_context['metadata'])
@@ -506,7 +514,7 @@ def test_get_html_with_non_existent_edx_video_id(self):
         # lint-amnesty, pylint: disable=redefined-outer-name
         SOURCE_XML = """
             <video show_captions="true"
-            display_name="A Name"
+            display_name="{name}"
             sub="a_sub_file.srt.sjson" source="{source}"
             download_video="{download_video}"
             start_time="3603.0" end_time="3610.0"
@@ -516,6 +524,7 @@ def test_get_html_with_non_existent_edx_video_id(self):
             </video>
         """
         no_video_data = {
+            'name': 'video 1',
             'download_video': 'true',
             'source': 'example_source.mp4',
             'sources': """
@@ -532,7 +541,8 @@ def test_get_html_with_non_existent_edx_video_id(self):
             download_video=no_video_data['download_video'],
             source=no_video_data['source'],
             sources=no_video_data['sources'],
-            edx_video_id=no_video_data['edx_video_id']
+            edx_video_id=no_video_data['edx_video_id'],
+            name=no_video_data['name'],
         )
         self.initialize_block(data=DATA)
 
@@ -1295,12 +1305,12 @@ class TestEditorSavedMethod(BaseTestVideoXBlock):
     CATEGORY = "video"
     DATA = SOURCE_XML
     METADATA = {}
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         super().setUp()
         self.setup_course()
         self.metadata = {
-            'source': 'http://youtu.be/3_yD_cEKoCk',
             'html5_sources': ['http://example.org/video.mp4'],
         }
         # path to subs_3_yD_cEKoCk.srt.sjson file
@@ -1308,14 +1318,12 @@ def setUp(self):
         self.test_dir = path(__file__).abspath().dirname().dirname().dirname().dirname().dirname()
         self.file_path = self.test_dir + '/common/test/data/uploads/' + self.file_name
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_editor_saved_when_html5_sub_not_exist(self, default_store):
+    def test_editor_saved_when_html5_sub_not_exist(self):
         """
         When there is youtube_sub exist but no html5_sub present for
         html5_sources, editor_saved function will generate new html5_sub
         for video.
         """
-        self.MODULESTORE = MODULESTORES[default_store]  # pylint: disable=invalid-name
         self.initialize_block(metadata=self.metadata)
         item = self.store.get_item(self.item_descriptor.location)
         with open(self.file_path, "rb") as myfile:  # lint-amnesty, pylint: disable=bad-option-value, open-builtin
@@ -1329,13 +1337,11 @@ def test_editor_saved_when_html5_sub_not_exist(self, default_store):
         item.editor_saved(self.user, old_metadata, None)
         assert isinstance(Transcript.get_asset(item.location, 'subs_3_yD_cEKoCk.srt.sjson'), StaticContent)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_editor_saved_when_youtube_and_html5_subs_exist(self, default_store):
+    def test_editor_saved_when_youtube_and_html5_subs_exist(self):
         """
         When both youtube_sub and html5_sub already exist then no new
         sub will be generated by editor_saved function.
         """
-        self.MODULESTORE = MODULESTORES[default_store]
         self.initialize_block(metadata=self.metadata)
         item = self.store.get_item(self.item_descriptor.location)
         with open(self.file_path, "rb") as myfile:  # lint-amnesty, pylint: disable=bad-option-value, open-builtin
@@ -1350,12 +1356,10 @@ def test_editor_saved_when_youtube_and_html5_subs_exist(self, default_store):
             item.editor_saved(self.user, old_metadata, None)
             assert not manage_video_subtitles_save.called
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_editor_saved_with_unstripped_video_id(self, default_store):
+    def test_editor_saved_with_unstripped_video_id(self):
         """
         Verify editor saved when video id contains spaces/tabs.
         """
-        self.MODULESTORE = MODULESTORES[default_store]
         stripped_video_id = str(uuid4())
         unstripped_video_id = '{video_id}{tabs}'.format(video_id=stripped_video_id, tabs='\t\t\t')
         self.metadata.update({
@@ -1371,14 +1375,12 @@ def test_editor_saved_with_unstripped_video_id(self, default_store):
         item.editor_saved(self.user, old_metadata, None)
         assert item.edx_video_id == stripped_video_id
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
     @patch('xmodule.video_module.video_module.edxval_api.get_url_for_profile', Mock(return_value='test_yt_id'))
-    def test_editor_saved_with_yt_val_profile(self, default_store):
+    def test_editor_saved_with_yt_val_profile(self):
         """
         Verify editor saved overrides `youtube_id_1_0` when a youtube val profile is there
         for a given `edx_video_id`.
         """
-        self.MODULESTORE = MODULESTORES[default_store]
         self.initialize_block(metadata=self.metadata)
         item = self.store.get_item(self.item_descriptor.location)
         assert item.youtube_id_1_0 == '3_yD_cEKoCk'
@@ -1516,7 +1518,7 @@ def test_no_edx_video_id(self):
         self.verify_result_with_fallback_and_youtube(result)
 
     def test_no_edx_video_id_and_no_fallback(self):
-        video_declaration = f"<video display_name='Test Video' youtube_id_1_0=\'{self.TEST_YOUTUBE_ID}\'>"
+        video_declaration = f"<video display_name='Test Video 2' youtube_id_1_0=\'{self.TEST_YOUTUBE_ID}\'>"
         # the video has no source listed, only a youtube link, so no fallback url will be provided
         sample_xml = ''.join([
             video_declaration,
diff --git a/lms/djangoapps/courseware/tests/test_views.py b/lms/djangoapps/courseware/tests/test_views.py
index e549e62d3eaa..cef760cd235c 100644
--- a/lms/djangoapps/courseware/tests/test_views.py
+++ b/lms/djangoapps/courseware/tests/test_views.py
@@ -144,7 +144,6 @@ def test_jump_to_legacy_vs_mfe(self, preview_mode, expect_mfe):
         assert response.url.split('?')[0] == expected_url
 
     @ddt.data(
-        (False, ModuleStoreEnum.Type.mongo),
         (False, ModuleStoreEnum.Type.split),
         (True, ModuleStoreEnum.Type.split),
     )
@@ -168,7 +167,7 @@ def test_jump_to_invalid_location(self, preview_mode, store_type):
         assert response.url == expected_redirect_url
 
     @set_preview_mode(True)
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_jump_to_legacy_from_sequence(self, store_type):
         with self.store.default_store(store_type):
             course = CourseFactory.create()
@@ -196,7 +195,7 @@ def test_jump_to_mfe_from_sequence(self):
         assert response.url == expected_redirect_url
 
     @set_preview_mode(True)
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_jump_to_legacy_from_module(self, store_type):
         with self.store.default_store(store_type):
             course = CourseFactory.create()
@@ -252,7 +251,7 @@ def test_jump_to_mfe_from_module(self):
     # The new courseware experience does not support this sort of course structure;
     # it assumes a simple course->chapter->sequence->unit->component tree.
     @set_preview_mode(True)
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_jump_to_legacy_from_nested_module(self, store_type):
         with self.store.default_store(store_type):
             course = CourseFactory.create()
@@ -276,7 +275,6 @@ def test_jump_to_legacy_from_nested_module(self, store_type):
         self.assertRedirects(response, expected_redirect_url, status_code=302, target_status_code=302)
 
     @ddt.data(
-        (False, ModuleStoreEnum.Type.mongo),
         (False, ModuleStoreEnum.Type.split),
         (True, ModuleStoreEnum.Type.split),
     )
@@ -291,8 +289,6 @@ def test_jump_to_id_invalid_location(self, preview_mode, store_type):
 
     @set_preview_mode(True)
     @ddt.data(
-        (ModuleStoreEnum.Type.mongo, False, '1'),
-        (ModuleStoreEnum.Type.mongo, True, '2'),
         (ModuleStoreEnum.Type.split, False, '1'),
         (ModuleStoreEnum.Type.split, True, '2'),
     )
@@ -1349,7 +1345,7 @@ def test_student_progress_with_valid_and_invalid_id(self):
         # Assert that valid 'student_id' returns 200 status
         self._get_student_progress_page()
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_unenrolled_student_progress_for_credit_course(self, default_store):
         """
          Test that student progress page does not break while checking for an unenrolled student.
diff --git a/lms/djangoapps/courseware/tests/tests.py b/lms/djangoapps/courseware/tests/tests.py
index 7d613721fa4f..7adc03dd442d 100644
--- a/lms/djangoapps/courseware/tests/tests.py
+++ b/lms/djangoapps/courseware/tests/tests.py
@@ -14,7 +14,7 @@
 from lms.djangoapps.lms_xblock.field_data import LmsFieldData
 from xmodule.error_module import ErrorBlock  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.django import modulestore  # lint-amnesty, pylint: disable=wrong-import-order
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MIXED_MODULESTORE, ModuleStoreTestCase  # lint-amnesty, pylint: disable=wrong-import-order
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.tests.factories import ToyCourseFactory  # lint-amnesty, pylint: disable=wrong-import-order
 
 
@@ -117,7 +117,7 @@ class TestMongoCoursesLoad(ModuleStoreTestCase, PageLoaderTestCase):
     """
     Check that all pages in test courses load properly from Mongo.
     """
-    MODULESTORE = TEST_DATA_MIXED_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         super().setUp()
@@ -131,7 +131,7 @@ def test_toy_textbooks_loads(self, mock_get):
             <entry page="5" page_label="ii" name="Table of Contents"/>
             </table_of_contents>
         """).strip()
-        location = self.toy_course_key.make_usage_key('course', '2012_Fall')
+        location = self.toy_course_key.make_usage_key('course', 'course')
         course = self.store.get_item(location)
         assert len(course.textbooks) > 0
 
diff --git a/lms/djangoapps/discussion/django_comment_client/base/tests.py b/lms/djangoapps/discussion/django_comment_client/base/tests.py
index 6254579d6835..a56612640380 100644
--- a/lms/djangoapps/discussion/django_comment_client/base/tests.py
+++ b/lms/djangoapps/discussion/django_comment_client/base/tests.py
@@ -53,7 +53,7 @@
 from xmodule.modulestore import ModuleStoreEnum
 from xmodule.modulestore.django import modulestore
 from xmodule.modulestore.tests.django_utils import (
-    TEST_DATA_MONGO_AMNESTY_MODULESTORE, ModuleStoreTestCase, SharedModuleStoreTestCase,
+    TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase, SharedModuleStoreTestCase,
 )
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory, check_mongo_calls
 
@@ -2031,7 +2031,7 @@ class ForumThreadViewedEventTransformerTestCase(ForumsEnableMixin, UrlResetMixin
     sources (e.g., a mobile app), we carefully test a myriad of cases, including
     those with incomplete and malformed events.
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     CATEGORY_ID = 'i4x-edx-discussion-id'
     CATEGORY_NAME = 'Discussion 1'
@@ -2047,21 +2047,12 @@ class ForumThreadViewedEventTransformerTestCase(ForumsEnableMixin, UrlResetMixin
     @mock.patch.dict("common.djangoapps.student.models.settings.FEATURES", {"ENABLE_DISCUSSION_SERVICE": True})
     def setUp(self):
         super().setUp()
-        self.courses_by_store = {
-            ModuleStoreEnum.Type.mongo: CourseFactory.create(
-                org='TestX',
-                course='TR-101',
-                run='Event_Transform_Test',
-                default_store=ModuleStoreEnum.Type.mongo,
-            ),
-            ModuleStoreEnum.Type.split: CourseFactory.create(
-                org='TestX',
-                course='TR-101S',
-                run='Event_Transform_Test_Split',
-                default_store=ModuleStoreEnum.Type.split,
-            ),
-        }
-        self.course = self.courses_by_store['mongo']
+        self.course = CourseFactory.create(
+            org='TestX',
+            course='TR-101S',
+            run='Event_Transform_Test_Split',
+            default_store=ModuleStoreEnum.Type.split,
+        )
         self.student = UserFactory.create()
         self.staff = UserFactory.create(is_staff=True)
         UserBasedRole(user=self.staff, role=CourseStaffRole.ROLE).add_course(self.course.id)
@@ -2184,18 +2175,16 @@ def test_titles(self):
         assert 'title_truncated' in event_3_trans['event']
         assert event_3_trans['event']['title_truncated']
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_urls(self, store):
-        course = self.courses_by_store[store]
+    def test_urls(self):
         commentable_id = self.DUMMY_CATEGORY_ID
         thread_id = self.DUMMY_THREAD_ID
         _, event_trans = _create_and_transform_event(
-            course_id=course.id,
+            course_id=self.course.id,
             topic_id=commentable_id,
             thread_id=thread_id,
         )
         expected_path = '/courses/{}/discussion/forum/{}/threads/{}'.format(
-            course.id, commentable_id, thread_id
+            self.course.id, commentable_id, thread_id
         )
         assert event_trans['event'].get('url').endswith(expected_path)
 
diff --git a/lms/djangoapps/discussion/django_comment_client/tests/test_models.py b/lms/djangoapps/discussion/django_comment_client/tests/test_models.py
index 3e04944c9f3a..776cbf0514f3 100644
--- a/lms/djangoapps/discussion/django_comment_client/tests/test_models.py
+++ b/lms/djangoapps/discussion/django_comment_client/tests/test_models.py
@@ -6,7 +6,7 @@
 from django.test.testcases import TestCase
 from opaque_keys.edx.keys import CourseKey
 from xmodule.modulestore.tests.django_utils import (
-    TEST_DATA_MIXED_MODULESTORE,
+    TEST_DATA_SPLIT_MODULESTORE,
     ModuleStoreTestCase
 )
 from xmodule.modulestore.tests.factories import ToyCourseFactory
@@ -18,14 +18,13 @@ class RoleClassTestCase(ModuleStoreTestCase):
     """
     Tests for roles of the comment client service integration
     """
-    MODULESTORE = TEST_DATA_MIXED_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         super().setUp()
 
         # For course ID, syntax edx/classname/classdate is important
         # because xmodel.course_module.id_to_location looks for a string to split
-
         self.course_id = ToyCourseFactory.create().id
         self.student_role = models.Role.objects.get_or_create(name="Student",
                                                               course_id=self.course_id)[0]
diff --git a/lms/djangoapps/discussion/django_comment_client/tests/test_utils.py b/lms/djangoapps/discussion/django_comment_client/tests/test_utils.py
index 3a09e6cdda2b..3e7a1b68ee64 100644
--- a/lms/djangoapps/discussion/django_comment_client/tests/test_utils.py
+++ b/lms/djangoapps/discussion/django_comment_client/tests/test_utils.py
@@ -52,9 +52,8 @@
 from openedx.core.djangoapps.util.testing import ContentGroupTestCase
 from xmodule.modulestore import ModuleStoreEnum
 from xmodule.modulestore.django import modulestore
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MIXED_MODULESTORE, ModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory, ToyCourseFactory
-from xmodule.tabs import CourseTabList
 
 
 class DictionaryTestCase(TestCase):
@@ -194,7 +193,7 @@ def test_empty_discussion_subcategory_title(self):
         utils.add_courseware_context([thread], self.course, self.user)
         assert '/' not in thread.get('courseware_title')
 
-    @ddt.data((ModuleStoreEnum.Type.mongo, 2), (ModuleStoreEnum.Type.split, 1))
+    @ddt.data((ModuleStoreEnum.Type.split, 1))
     @ddt.unpack
     def test_get_accessible_discussion_xblocks(self, modulestore_type, expected_discussion_xblocks):
         """
@@ -1239,7 +1238,7 @@ class IsCommentableDividedTestCase(ModuleStoreTestCase):
     Test the is_commentable_divided function.
     """
 
-    MODULESTORE = TEST_DATA_MIXED_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         """
diff --git a/lms/djangoapps/discussion/tests/test_views.py b/lms/djangoapps/discussion/tests/test_views.py
index 332ac6e40fa0..26346dbadebd 100644
--- a/lms/djangoapps/discussion/tests/test_views.py
+++ b/lms/djangoapps/discussion/tests/test_views.py
@@ -5,6 +5,7 @@
 import json
 import logging
 from datetime import datetime
+from unittest import skip
 from unittest.mock import ANY, Mock, call, patch
 
 import ddt
@@ -20,7 +21,7 @@
 from xmodule.modulestore import ModuleStoreEnum
 from xmodule.modulestore.django import modulestore
 from xmodule.modulestore.tests.django_utils import (
-    TEST_DATA_MONGO_AMNESTY_MODULESTORE,
+    TEST_DATA_SPLIT_MODULESTORE,
     ModuleStoreTestCase,
     SharedModuleStoreTestCase
 )
@@ -1934,11 +1935,12 @@ def create_divided_discussions(self):
         return divided_inline_discussions, divided_course_wide_discussions
 
 
+@skip("OldMongo Deprecation")
 class CourseDiscussionTopicsTestCase(DividedDiscussionsTestCase):
     """
     Tests the `divide_discussion_topics` view.
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def test_non_staff(self):
         """
@@ -1994,7 +1996,7 @@ class CourseDiscussionsHandlerTestCase(DividedDiscussionsTestCase):
     """
     Tests the course_discussion_settings_handler
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def get_expected_response(self):
         """
@@ -2093,6 +2095,7 @@ def test_update_inline_discussion_settings(self):
 
         assert response == expected_response
 
+    @skip("OldMongo Deprecation")
     def test_get_settings(self):
         """
         Verify that course_discussions_settings_handler is working for HTTP GET.
diff --git a/lms/djangoapps/edxnotes/tests.py b/lms/djangoapps/edxnotes/tests.py
index a67ba7e0fa2e..1a3811e1296c 100644
--- a/lms/djangoapps/edxnotes/tests.py
+++ b/lms/djangoapps/edxnotes/tests.py
@@ -104,9 +104,7 @@ def setUp(self):
         super().setUp()
 
         ApplicationFactory(name="edx-notes")
-        # Using old mongo because of locator comparison issues (see longer
-        # note below in EdxNotesHelpersTest setUp.
-        self.course = CourseFactory(edxnotes=True, default_store=ModuleStoreEnum.Type.mongo)
+        self.course = CourseFactory(edxnotes=True, default_store=ModuleStoreEnum.Type.split)
         self.user = UserFactory()
         self.client.login(username=self.user.username, password=UserFactory._DEFAULT_PASSWORD)  # lint-amnesty, pylint: disable=protected-access
         self.problem = TestProblem(self.course, self.user)
@@ -205,11 +203,7 @@ def setUp(self):
         """
         super().setUp()
 
-        # There are many tests that are comparing locators as returned from helper methods. When using
-        # the split modulestore, some of those locators have version and branch information, but the
-        # comparison values do not. This needs further investigation in order to enable these tests
-        # with the split modulestore.
-        with self.store.default_store(ModuleStoreEnum.Type.mongo):
+        with self.store.default_store(ModuleStoreEnum.Type.split):
             ApplicationFactory(name="edx-notes")
             self.course = CourseFactory.create()
             self.chapter = ItemFactory.create(category="chapter", parent_location=self.course.location)
diff --git a/lms/djangoapps/gating/tests/test_integration.py b/lms/djangoapps/gating/tests/test_integration.py
index b58073f5c2b6..dd45df6ad9d5 100644
--- a/lms/djangoapps/gating/tests/test_integration.py
+++ b/lms/djangoapps/gating/tests/test_integration.py
@@ -2,6 +2,7 @@
 Integration tests for gated content.
 """
 
+from unittest import skip
 
 import ddt
 from completion.waffle import ENABLE_COMPLETION_TRACKING_SWITCH
@@ -11,7 +12,7 @@
 from milestones import api as milestones_api
 from milestones.tests.utils import MilestonesTestCaseMixin
 from xmodule.modulestore.django import modulestore
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, SharedModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, SharedModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
 
 from common.djangoapps.student.tests.factories import UserFactory
@@ -22,13 +23,14 @@
 from openedx.core.lib.gating import api as gating_api
 
 
+@skip("OldMongo Deprecation")
 @ddt.ddt
 class TestGatedContent(MilestonesTestCaseMixin, SharedModuleStoreTestCase):
     """
     Base TestCase class for setting up a basic course structure
     and testing the gating feature
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     @classmethod
     def setUpClass(cls):
@@ -76,6 +78,10 @@ def set_up_course(cls):
                 display_name='chapter 1'
             )
 
+            cls.course.children = [
+                cls.chapter1.location
+            ]
+
             # create sequentials
             cls.seq1 = ItemFactory.create(
                 parent_location=cls.chapter1.location,
@@ -99,6 +105,12 @@ def set_up_course(cls):
                 format='Homework',
             )
 
+            cls.chapter1.children = [
+                cls.seq1.location,
+                cls.seq2.location,
+                cls.seq3.location,
+            ]
+
             # create problem
             cls.gating_prob1 = ItemFactory.create(
                 parent_location=cls.seq1.location,
diff --git a/lms/djangoapps/grades/rest_api/v1/tests/test_grading_policy_view.py b/lms/djangoapps/grades/rest_api/v1/tests/test_grading_policy_view.py
index a061ef41bec9..08337c6f9993 100644
--- a/lms/djangoapps/grades/rest_api/v1/tests/test_grading_policy_view.py
+++ b/lms/djangoapps/grades/rest_api/v1/tests/test_grading_policy_view.py
@@ -9,7 +9,7 @@
 from django.urls import reverse
 from pytz import UTC
 from xmodule.modulestore import ModuleStoreEnum
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, SharedModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, SharedModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
 from xmodule.capa.tests.response_xml_factory import MultipleChoiceResponseXMLFactory
 from common.djangoapps.student.tests.factories import GlobalStaffFactory
@@ -36,8 +36,10 @@ def create_user_and_access_token(self):
 
     @classmethod
     def create_course_data(cls):  # lint-amnesty, pylint: disable=missing-function-docstring
-        cls.invalid_course_id = 'foo/bar/baz'
-        cls.course = CourseFactory.create(display_name='An Introduction to API Testing', raw_grader=cls.raw_grader)
+        cls.invalid_course_id = 'course-v1:foo+bar+baz'
+        cls.course = CourseFactory.create(
+            display_name='An Introduction to API Testing', grading_policy=cls.grading_policy
+        )
         cls.course_id = str(cls.course.id)
         with cls.store.bulk_operations(cls.course.id, emit_signals=False):
             cls.sequential = ItemFactory.create(
@@ -141,7 +143,7 @@ def test_not_authorized(self):
         auth_header = self.get_auth_header(user)
         self.assert_get_for_course(expected_status_code=403, HTTP_AUTHORIZATION=auth_header)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_course_keys(self, modulestore_type):
         """
         The view should be addressable by course-keys from both module stores.
@@ -159,25 +161,27 @@ class CourseGradingPolicyTests(GradingPolicyTestMixin, SharedModuleStoreTestCase
     """
     Tests for CourseGradingPolicy view.
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
     view_name = 'grades_api:v1:course_grading_policy'
 
-    raw_grader = [
-        {
-            "min_count": 24,
-            "weight": 0.2,
-            "type": "Homework",
-            "drop_count": 0,
-            "short_label": "HW"
-        },
-        {
-            "min_count": 4,
-            "weight": 0.8,
-            "type": "Exam",
-            "drop_count": 0,
-            "short_label": "Exam"
-        }
-    ]
+    grading_policy = {
+        'GRADER': [
+            {
+                "min_count": 24,
+                "weight": 0.2,
+                "type": "Homework",
+                "drop_count": 0,
+                "short_label": "HW"
+            },
+            {
+                "min_count": 4,
+                "weight": 0.8,
+                "type": "Exam",
+                "drop_count": 0,
+                "short_label": "Exam"
+            }
+        ]
+    }
 
     @classmethod
     def setUpClass(cls):
@@ -211,26 +215,27 @@ class CourseGradingPolicyMissingFieldsTests(GradingPolicyTestMixin, SharedModule
     """
     Tests for CourseGradingPolicy view when fields are missing.
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
     view_name = 'grades_api:v1:course_grading_policy'
 
-    # Raw grader with missing keys
-    raw_grader = [
-        {
-            "min_count": 24,
-            "weight": 0.2,
-            "type": "Homework",
-            "drop_count": 0,
-            "short_label": "HW"
-        },
-        {
-            # Deleted "min_count" key
-            "weight": 0.8,
-            "type": "Exam",
-            "drop_count": 0,
-            "short_label": "Exam"
-        }
-    ]
+    grading_policy = {
+        'GRADER': [
+            {
+                "min_count": 24,
+                "weight": 0.2,
+                "type": "Homework",
+                "drop_count": 0,
+                "short_label": "HW"
+            },
+            {
+                # Deleted "min_count" key
+                "weight": 0.8,
+                "type": "Exam",
+                "drop_count": 0,
+                "short_label": "Exam"
+            }
+        ]
+    }
 
     @classmethod
     def setUpClass(cls):
diff --git a/lms/djangoapps/grades/tests/integration/test_problems.py b/lms/djangoapps/grades/tests/integration/test_problems.py
index bb25ea047c0b..fc187b22618e 100644
--- a/lms/djangoapps/grades/tests/integration/test_problems.py
+++ b/lms/djangoapps/grades/tests/integration/test_problems.py
@@ -8,7 +8,7 @@
 from xmodule.graders import ProblemScore
 from xmodule.modulestore import ModuleStoreEnum
 from xmodule.modulestore.tests.django_utils import (
-    TEST_DATA_MONGO_AMNESTY_MODULESTORE, ModuleStoreTestCase, SharedModuleStoreTestCase,
+    TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase, SharedModuleStoreTestCase,
 )
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
 from xmodule.modulestore.tests.utils import TEST_DATA_DIR
@@ -29,7 +29,7 @@ class TestMultipleProblemTypesSubsectionScores(SharedModuleStoreTestCase):
     """
     Test grading of different problem types.
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     SCORED_BLOCK_COUNT = 7
     ACTUAL_TOTAL_POSSIBLE = 17.0
@@ -58,10 +58,12 @@ def load_scoreable_course(cls):
         For details on the contents and structure of the file, see
         `common/test/data/scoreable/README`.
         """
+        password = 'test'
+        user = UserFactory.create(is_staff=False, username='test_student', password=password)
 
         course_items = import_course_from_xml(
             cls.store,
-            'test_user',
+            user.id,
             TEST_DATA_DIR,
             source_dirs=['scoreable'],
             static_content_store=None,
@@ -104,7 +106,7 @@ class TestVariedMetadata(ProblemSubmissionTestMixin, ModuleStoreTestCase):
     Test that changing the metadata on a block has the desired effect on the
     persisted score.
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     default_problem_metadata = {
         'graded': True,
@@ -214,7 +216,7 @@ class TestWeightedProblems(SharedModuleStoreTestCase):
     """
     Test scores and grades with various problem weight values.
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     @classmethod
     def setUpClass(cls):
diff --git a/lms/djangoapps/grades/tests/test_course_grade.py b/lms/djangoapps/grades/tests/test_course_grade.py
index 77ea291957ee..0f09a4917c6d 100644
--- a/lms/djangoapps/grades/tests/test_course_grade.py
+++ b/lms/djangoapps/grades/tests/test_course_grade.py
@@ -5,7 +5,7 @@
 from crum import set_current_request
 from django.conf import settings
 from edx_toggles.toggles.testutils import override_waffle_switch
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, SharedModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, SharedModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
 
 from common.djangoapps.student.models import CourseEnrollment
@@ -73,7 +73,7 @@ class TestScoreForModule(SharedModuleStoreTestCase):
                    (2/5) (3/5) (0/1)   -   (1/3)   -   (3/10)
 
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     @classmethod
     def setUpClass(cls):
diff --git a/lms/djangoapps/grades/tests/test_tasks.py b/lms/djangoapps/grades/tests/test_tasks.py
index 1c121fcfe0d5..bef689bda6fa 100644
--- a/lms/djangoapps/grades/tests/test_tasks.py
+++ b/lms/djangoapps/grades/tests/test_tasks.py
@@ -161,8 +161,6 @@ def test_block_structure_created_only_once(self):
             assert mock_block_structure_create.call_count == 1
 
     @ddt.data(
-        (ModuleStoreEnum.Type.mongo, 1, 41, True),
-        (ModuleStoreEnum.Type.mongo, 1, 41, False),
         (ModuleStoreEnum.Type.split, 2, 41, True),
         (ModuleStoreEnum.Type.split, 2, 41, False),
     )
@@ -176,7 +174,6 @@ def test_query_counts(self, default_store, num_mongo_calls, num_sql_calls, creat
                     self._apply_recalculate_subsection_grade()
 
     @ddt.data(
-        (ModuleStoreEnum.Type.mongo, 1, 41),
         (ModuleStoreEnum.Type.split, 2, 41),
     )
     @ddt.unpack
@@ -223,7 +220,6 @@ def test_other_inaccessible_subsection(self, mock_subsection_signal):
         )
 
     @ddt.data(
-        (ModuleStoreEnum.Type.mongo, 1, 24),
         (ModuleStoreEnum.Type.split, 2, 24),
     )
     @ddt.unpack
@@ -238,7 +234,6 @@ def test_persistent_grades_not_enabled_on_course(self, default_store, num_mongo_
             assert len(PersistentSubsectionGrade.bulk_read_grades(self.user.id, self.course.id)) == 0
 
     @ddt.data(
-        (ModuleStoreEnum.Type.mongo, 1, 42),
         (ModuleStoreEnum.Type.split, 2, 42),
     )
     @ddt.unpack
diff --git a/lms/djangoapps/grades/tests/test_transformer.py b/lms/djangoapps/grades/tests/test_transformer.py
index d30b333f1c7f..05f208cf3869 100644
--- a/lms/djangoapps/grades/tests/test_transformer.py
+++ b/lms/djangoapps/grades/tests/test_transformer.py
@@ -367,12 +367,6 @@ def test_max_score_for_invalid_dropdown_problem(self):
             max_score=0,
         )
 
-    def test_course_version_not_collected_in_old_mongo(self):
-        with self.store.default_store(ModuleStoreEnum.Type.mongo):
-            blocks = self.build_course_with_problems()
-        block_structure = get_course_blocks(self.student, blocks['course'].location, self.transformers)
-        assert block_structure.get_xblock_field(blocks['course'].location, 'course_version') is None
-
     def test_course_version_collected_in_split(self):
         blocks = self.build_course_with_problems()
         block_structure = get_course_blocks(self.student, blocks['course'].location, self.transformers)
@@ -430,7 +424,6 @@ def setUp(self):
 
     @ddt.data(
         (ModuleStoreEnum.Type.split, 2),
-        (ModuleStoreEnum.Type.mongo, 2),
     )
     @ddt.unpack
     def test_modulestore_performance(self, store_type, expected_mongo_queries):
diff --git a/lms/djangoapps/instructor/tests/test_api.py b/lms/djangoapps/instructor/tests/test_api.py
index d24e65b5c6a7..a01959d92ee2 100644
--- a/lms/djangoapps/instructor/tests/test_api.py
+++ b/lms/djangoapps/instructor/tests/test_api.py
@@ -33,7 +33,7 @@
 from xmodule.fields import Date
 from xmodule.modulestore import ModuleStoreEnum
 from xmodule.modulestore.tests.django_utils import (
-    TEST_DATA_MONGO_AMNESTY_MODULESTORE, ModuleStoreTestCase, SharedModuleStoreTestCase,
+    TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase, SharedModuleStoreTestCase,
 )
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
 
@@ -3091,7 +3091,7 @@ class TestEntranceExamInstructorAPIRegradeTask(SharedModuleStoreTestCase, LoginE
     Test endpoints whereby instructors can rescore student grades,
     reset student attempts and delete state for entrance exam.
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     @classmethod
     def setUpClass(cls):
@@ -3156,7 +3156,7 @@ def setUp(self):
         )
         self.ee_modules = [ee_module_to_reset1.module_state_key, ee_module_to_reset2.module_state_key]
 
-    @ddt.data(ModuleStoreEnum.Type.split, ModuleStoreEnum.Type.mongo)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_grade_histogram(self, store):
         """
         Verify that a histogram has been created.
@@ -3929,7 +3929,7 @@ class TestDueDateExtensions(SharedModuleStoreTestCase, LoginEnrollmentTestCase):
     """
     Test data dumps for reporting.
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     @classmethod
     def setUpClass(cls):
@@ -4105,7 +4105,7 @@ class TestDueDateExtensionsDeletedDate(ModuleStoreTestCase, LoginEnrollmentTestC
     """
     Tests for deleting due date extensions
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         """
@@ -4121,15 +4121,15 @@ def setUp(self):
             self.week2 = ItemFactory.create(due=self.due)
             self.week3 = ItemFactory.create()  # No due date
             self.course.children = [
-                str(self.week1.location),
-                str(self.week2.location),
-                str(self.week3.location)
+                self.week1.location,
+                self.week2.location,
+                self.week3.location
             ]
             self.homework = ItemFactory.create(
                 parent_location=self.week1.location,
                 due=self.due
             )
-            self.week1.children = [str(self.homework.location)]
+            self.week1.children = [self.homework.location]
 
         user1 = UserFactory.create()
         StudentModule(
diff --git a/lms/djangoapps/instructor/tests/test_email.py b/lms/djangoapps/instructor/tests/test_email.py
index a84c728c30e9..213485dafdb8 100644
--- a/lms/djangoapps/instructor/tests/test_email.py
+++ b/lms/djangoapps/instructor/tests/test_email.py
@@ -13,7 +13,7 @@
 from lms.djangoapps.bulk_email.models_api import is_bulk_email_enabled_for_course, is_bulk_email_feature_enabled
 
 from lms.djangoapps.bulk_email.models import BulkEmailFlag, CourseAuthorization, DisabledCourse
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MIXED_MODULESTORE, SharedModuleStoreTestCase  # lint-amnesty, pylint: disable=wrong-import-order
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, SharedModuleStoreTestCase  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.tests.factories import CourseFactory  # lint-amnesty, pylint: disable=wrong-import-order
 
 from lms.djangoapps.bulk_email.models_api import is_bulk_email_disabled_for_course
@@ -131,7 +131,7 @@ class TestNewInstructorDashboardEmailViewXMLBacked(SharedModuleStoreTestCase):
     Check for email view on the new instructor dashboard
     """
 
-    MODULESTORE = TEST_DATA_MIXED_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     @classmethod
     def setUpClass(cls):
diff --git a/lms/djangoapps/instructor/tests/test_enrollment.py b/lms/djangoapps/instructor/tests/test_enrollment.py
index ac7ab1749c93..3be910402106 100644
--- a/lms/djangoapps/instructor/tests/test_enrollment.py
+++ b/lms/djangoapps/instructor/tests/test_enrollment.py
@@ -17,7 +17,7 @@
 from opaque_keys.edx.locator import CourseLocator
 from submissions import api as sub_api
 
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, SharedModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, SharedModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
 from xmodule.capa.tests.response_xml_factory import MultipleChoiceResponseXMLFactory
 from common.djangoapps.student.models import CourseEnrollment, CourseEnrollmentAllowed, anonymous_id_for_user
@@ -368,21 +368,27 @@ def test_unenroll_norecord(self):
 
 class TestInstructorEnrollmentStudentModule(SharedModuleStoreTestCase):
     """ Test student module manipulations. """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
-        cls.course = CourseFactory(
+        cls.course = CourseFactory.create(
             name='fake',
             org='course',
             run='id',
         )
+
         cls.course_key = cls.course.location.course_key  # lint-amnesty, pylint: disable=no-member
         with cls.store.bulk_operations(cls.course.id, emit_signals=False):  # lint-amnesty, pylint: disable=no-member
+            cls.chapter = ItemFactory.create(
+                parent_location=cls.course.location,
+                category='chapter',
+                display_name='chapter'
+            )
             cls.parent = ItemFactory(
                 category="library_content",
-                parent=cls.course,
+                parent=cls.chapter,
                 publish_item=True,
             )
             cls.child = ItemFactory(
@@ -392,7 +398,7 @@ def setUpClass(cls):
             )
             cls.unrelated = ItemFactory(
                 category="html",
-                parent=cls.course,
+                parent=cls.chapter,
                 publish_item=True,
             )
             cls.team_enabled_ora = ItemFactory.create(
diff --git a/lms/djangoapps/instructor/tests/test_tools.py b/lms/djangoapps/instructor/tests/test_tools.py
index cffd7edb47f3..8d68f842c527 100644
--- a/lms/djangoapps/instructor/tests/test_tools.py
+++ b/lms/djangoapps/instructor/tests/test_tools.py
@@ -6,7 +6,7 @@
 import datetime
 import json
 import unittest
-from unittest import mock
+from unittest import mock, skip
 
 import pytest
 from django.contrib.auth.models import User  # lint-amnesty, pylint: disable=imported-auth-user
@@ -18,7 +18,7 @@
 from pytz import UTC
 from xmodule.fields import Date
 from xmodule.modulestore.tests.django_utils import (
-    TEST_DATA_MONGO_AMNESTY_MODULESTORE, ModuleStoreTestCase, SharedModuleStoreTestCase,
+    TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase, SharedModuleStoreTestCase,
 )
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
 
@@ -97,11 +97,12 @@ def test_parse_error(self):
             tools.parse_datetime('foo')
 
 
+@skip("OldMongo Deprecation")
 class TestFindUnit(SharedModuleStoreTestCase):
     """
     Test the find_unit function.
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     @classmethod
     def setUpClass(cls):
@@ -128,11 +129,12 @@ def test_find_unit_notfound(self):
             tools.find_unit(self.course, url)
 
 
+@skip("OldMongo Deprecation")
 class TestGetUnitsWithDueDate(ModuleStoreTestCase):
     """
     Test the get_units_with_due_date function.
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         """
@@ -199,7 +201,7 @@ class TestSetDueDateExtension(ModuleStoreTestCase):
     """
     Test the set_due_date_extensions function.
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         """
@@ -241,6 +243,7 @@ def _clear_field_data_cache(self):
             block._field_data._load_dates(self.course.id, self.user, use_cached=False)  # pylint: disable=protected-access
             block.fields['due']._del_cached_value(block)  # pylint: disable=protected-access
 
+    @skip("OldMongo Deprecation")
     def test_set_due_date_extension(self):
         # First, extend the leaf assignment date
         extended_hw = datetime.datetime(2013, 10, 25, 0, 0, tzinfo=UTC)
@@ -285,11 +288,12 @@ def test_reset_due_date_extension_with_no_enrollment(self):
             tools.set_due_date_extension(self.course, self.week3, user, extended)
 
 
+@skip("OldMongo Deprecation")
 class TestDataDumps(ModuleStoreTestCase):
     """
     Test data dumps for reporting.
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         """
diff --git a/lms/djangoapps/instructor_task/tests/test_base.py b/lms/djangoapps/instructor_task/tests/test_base.py
index 75f6eb0b33a9..7a0072396b80 100644
--- a/lms/djangoapps/instructor_task/tests/test_base.py
+++ b/lms/djangoapps/instructor_task/tests/test_base.py
@@ -21,7 +21,7 @@
 
 from xmodule.modulestore import ModuleStoreEnum
 from xmodule.modulestore.django import modulestore
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, ModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
 from xmodule.capa.tests.response_xml_factory import OptionResponseXMLFactory
 from common.djangoapps.student.tests.factories import CourseEnrollmentFactory, UserFactory
@@ -37,7 +37,7 @@
 TEST_COURSE_ORG = 'edx'
 TEST_COURSE_NAME = 'test_course'
 TEST_COURSE_NUMBER = '1.23x'
-TEST_COURSE_KEY = CourseKey.from_string('/'.join([TEST_COURSE_ORG, TEST_COURSE_NUMBER, TEST_COURSE_NAME]))
+TEST_COURSE_KEY = CourseKey.from_string(f'course-v1:{TEST_COURSE_ORG}+{TEST_COURSE_NUMBER}+{TEST_COURSE_NAME}')
 TEST_CHAPTER_NAME = "Section"
 TEST_SECTION_NAME = "Subsection"
 
@@ -108,7 +108,7 @@ class InstructorTaskCourseTestCase(LoginEnrollmentTestCase, ModuleStoreTestCase)
     Base test class for InstructorTask-related tests that require
     the setup of a course.
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
     course = None
     current_user = None
 
diff --git a/lms/djangoapps/instructor_task/tests/test_integration.py b/lms/djangoapps/instructor_task/tests/test_integration.py
index db8413046a5e..e17aab41693b 100644
--- a/lms/djangoapps/instructor_task/tests/test_integration.py
+++ b/lms/djangoapps/instructor_task/tests/test_integration.py
@@ -11,6 +11,7 @@
 import logging
 import textwrap
 from collections import namedtuple
+from unittest import skip
 from unittest.mock import patch
 
 import pytest
@@ -69,6 +70,7 @@ def _assert_task_failure(self, entry_id, task_type, problem_url_name, expected_m
         assert status['message'] == expected_message
 
 
+@skip("OldMongo Deprecation")
 @ddt.ddt
 @override_settings(RATELIMIT_ENABLE=False)
 class TestRescoringTask(TestIntegrationTask):
@@ -569,6 +571,7 @@ def test_delete_non_problem(self):
         assert instructor_task.task_state == SUCCESS
 
 
+@skip("OldMongo Deprecation")
 class TestGradeReportConditionalContent(TestReportMixin, TestConditionalContent, TestIntegrationTask):
     """
     Test grade report in cases where there are problems contained within split tests.
diff --git a/lms/djangoapps/instructor_task/tests/test_tasks_helper.py b/lms/djangoapps/instructor_task/tests/test_tasks_helper.py
index 6fbb4834dbcb..72275e7b66e5 100644
--- a/lms/djangoapps/instructor_task/tests/test_tasks_helper.py
+++ b/lms/djangoapps/instructor_task/tests/test_tasks_helper.py
@@ -13,6 +13,7 @@
 from collections import OrderedDict
 from contextlib import ExitStack, contextmanager
 from datetime import datetime, timedelta
+from unittest import skip
 from unittest.mock import ANY, MagicMock, Mock, patch
 
 import ddt
@@ -370,7 +371,6 @@ def test_certificate_eligibility(self):
         self._verify_cell_data_for_user(verified_user.username, course.id, 'Certificate Eligible', 'Y', num_rows=2)
 
     @ddt.data(
-        (ModuleStoreEnum.Type.mongo, 4, 47),
         (ModuleStoreEnum.Type.split, 2, 48),
     )
     @ddt.unpack
@@ -464,6 +464,7 @@ def test_team_deleted(self):
 
 
 # pylint: disable=protected-access
+@skip("OldMongo Deprecation")
 @ddt.ddt
 class TestProblemResponsesReport(TestReportMixin, InstructorTaskModuleTestCase):
     """
@@ -787,6 +788,7 @@ def test_file_names(self, problem_locations, problem_types_filter, file_name):
         assert result.get('report_name') == file_name
 
 
+@skip("OldMongo Deprecation")
 @ddt.ddt
 class TestProblemGradeReport(TestReportMixin, InstructorTaskModuleTestCase):
     """
@@ -933,6 +935,7 @@ def test_inactive_enrollment_included(self, _get_current_task):
         ])
 
 
+@skip("OldMongo Deprecation")
 class TestProblemReportSplitTestContent(TestReportMixin, TestConditionalContent, InstructorTaskModuleTestCase):
     """
     Test the problem report on a course that has split tests.
@@ -1065,6 +1068,7 @@ def test_problem_grade_report_valid_columns_order(self):
         assert self.get_csv_row_with_headers() == header_row
 
 
+@skip("OldMongo Deprecation")
 class TestProblemReportCohortedContent(TestReportMixin, ContentGroupTestCase, InstructorTaskModuleTestCase):
     """
     Test the problem report on a course that has cohorted content.
@@ -1710,6 +1714,7 @@ def test_move_users_to_same_cohort(self):
         )
 
 
+@skip("OldMongo Deprecation")
 @ddt.ddt
 @patch('lms.djangoapps.instructor_task.tasks_helper.misc.DefaultStorage', new=MockDefaultStorage)
 class TestGradeReport(TestReportMixin, InstructorTaskModuleTestCase):
diff --git a/lms/djangoapps/lti_provider/management/commands/tests/test_resend_lti_scores.py b/lms/djangoapps/lti_provider/management/commands/tests/test_resend_lti_scores.py
index bc076d4c9f31..986b75fcd4aa 100644
--- a/lms/djangoapps/lti_provider/management/commands/tests/test_resend_lti_scores.py
+++ b/lms/djangoapps/lti_provider/management/commands/tests/test_resend_lti_scores.py
@@ -7,7 +7,8 @@
 
 from django.test import TestCase
 from opaque_keys.edx.keys import CourseKey, UsageKey
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_MODULESTORE, SharedModuleStoreTestCase
+from xmodule.modulestore import ModuleStoreEnum  # lint-amnesty, pylint: disable=wrong-import-order
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, SharedModuleStoreTestCase
 from xmodule.modulestore.tests.utils import TEST_DATA_DIR
 from xmodule.modulestore.xml_importer import import_course_from_xml
 
@@ -46,7 +47,7 @@ class CommandExecutionTestCase(SharedModuleStoreTestCase):
     """
     Test `manage.py resend_lti_scores` command.
     """
-    MODULESTORE = TEST_DATA_MONGO_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     @classmethod
     def setUpClass(cls):
@@ -54,7 +55,7 @@ def setUpClass(cls):
         cls.course_key = cls.store.make_course_key('edX', 'lti_provider', '3000')
         import_course_from_xml(
             cls.store,
-            'test_user',
+            ModuleStoreEnum.UserID.test,
             TEST_DATA_DIR,
             source_dirs=['simple'],
             static_content_store=None,
diff --git a/lms/djangoapps/lti_provider/tests/test_outcomes.py b/lms/djangoapps/lti_provider/tests/test_outcomes.py
index 4f9cc4779db5..c992b80c4626 100644
--- a/lms/djangoapps/lti_provider/tests/test_outcomes.py
+++ b/lms/djangoapps/lti_provider/tests/test_outcomes.py
@@ -3,12 +3,13 @@
 """
 
 
+from unittest import skip
 from unittest.mock import ANY, MagicMock, patch
 
 from django.test import TestCase
 from lxml import etree
 from opaque_keys.edx.locator import BlockUsageLocator, CourseLocator
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, ModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory, check_mongo_calls
 
 import lms.djangoapps.lti_provider.outcomes as outcomes
@@ -293,11 +294,12 @@ def test_response_with_failing_status_field(self):
         assert not outcomes.check_replace_result_response(response)
 
 
+@skip("OldMongo Deprecation")
 class TestAssignmentsForProblem(ModuleStoreTestCase):
     """
     Test cases for the assignments_for_problem method in outcomes.py
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         super().setUp()
diff --git a/lms/djangoapps/program_enrollments/rest_api/v1/tests/test_views.py b/lms/djangoapps/program_enrollments/rest_api/v1/tests/test_views.py
index a6158cc0d0af..e656bb12d007 100644
--- a/lms/djangoapps/program_enrollments/rest_api/v1/tests/test_views.py
+++ b/lms/djangoapps/program_enrollments/rest_api/v1/tests/test_views.py
@@ -5,7 +5,7 @@
 import json
 from collections import OrderedDict, defaultdict
 from datetime import datetime, timedelta
-from unittest import mock
+from unittest import mock, skip
 from uuid import UUID, uuid4
 
 import ddt
@@ -20,7 +20,7 @@
 from rest_framework import status
 from rest_framework.test import APITestCase
 from social_django.models import UserSocialAuth
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, SharedModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, SharedModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory as ModulestoreCourseFactory
 from xmodule.modulestore.tests.factories import ItemFactory
 
@@ -96,7 +96,7 @@ class EnrollmentsDataMixin(ProgramCacheMixin):
     Mixin to define some shared test data objects for program/course enrollment
     view tests.
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
     view_name = 'SET-ME-IN-SUBCLASS'
 
     @classmethod
@@ -1637,7 +1637,7 @@ class ProgramCourseEnrollmentOverviewGetTests(
     """
     Tests for the ProgramCourseEnrollmentOverview view GET method.
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     patch_resume_url = mock.patch(
         _UTILS_PATCH_FORMAT.format('get_resume_urls_for_enrollments'),
@@ -1884,6 +1884,7 @@ def test_no_due_dates(self):
         assert status.HTTP_200_OK == response_status_code
         assert [] == response_course_runs[0]['due_dates']
 
+    @skip("OldMongo Deprecation")
     @ddt.data(
         ('2018-12-01', False),
         ('2019-01-01', True),
diff --git a/lms/djangoapps/support/tests/test_views.py b/lms/djangoapps/support/tests/test_views.py
index dcbfe3c82b62..e5a05f7ef556 100644
--- a/lms/djangoapps/support/tests/test_views.py
+++ b/lms/djangoapps/support/tests/test_views.py
@@ -6,6 +6,7 @@
 import json
 import re
 from datetime import datetime, timedelta
+from unittest import skip
 from unittest.mock import patch
 from urllib.parse import quote
 from uuid import UUID, uuid4
@@ -30,7 +31,7 @@
 from rest_framework import status
 from social_django.models import UserSocialAuth
 from xmodule.modulestore.tests.django_utils import (
-    TEST_DATA_MONGO_AMNESTY_MODULESTORE, ModuleStoreTestCase, SharedModuleStoreTestCase,
+    TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase, SharedModuleStoreTestCase,
 )
 from xmodule.modulestore.tests.factories import CourseFactory
 
@@ -254,7 +255,7 @@ class SupportViewCertificatesTests(SupportViewTestCase):
     """
     Tests for the certificates support view.
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         """Make the user support staff. """
@@ -272,6 +273,7 @@ def test_certificates_with_user_filter(self):
         response = self.client.get(url)
         self.assertContains(response, "userFilter: 'student@example.com'")
 
+    @skip("OldMongo Deprecation")
     def test_certificates_along_with_course_filter(self):
         # Check that an initial filter is passed to the JavaScript client.
         url = reverse("support:certificates") + "?user=student@example.com&course_id=" + quote(str(self.course.id))
@@ -1846,7 +1848,7 @@ class TestOnboardingView(SupportViewTestCase, ProctoredExamTestCase):
     """
     Tests for OnboardingView
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         super().setUp()
@@ -1930,6 +1932,7 @@ def test_no_record(self):
         self.assertEqual(response_data['verified_in'], None)
         self.assertEqual(response_data['current_status'], None)
 
+    @skip("OldMongo Deprecation")
     def test_no_verified_attempts(self):
         """
         Test that if there are no verified attempts, the most recent status is returned
@@ -1962,6 +1965,7 @@ def test_no_verified_attempts(self):
             ProctoredExamStudentAttemptStatus.created
         )
 
+    @skip("OldMongo Deprecation")
     def test_get_verified_attempt(self):
         """
         Test that if there is at least one verified attempt, the status returned is always verified
@@ -2000,6 +2004,7 @@ def test_get_verified_attempt(self):
             ProctoredExamStudentAttemptStatus.verified
         )
 
+    @skip("OldMongo Deprecation")
     def test_verified_in_another_course(self):
         """
         Test that, if there is at least one verified attempt in any course for a given user,
diff --git a/lms/lib/tests/test_utils.py b/lms/lib/tests/test_utils.py
index d907c9cc5438..15bd6efe9880 100644
--- a/lms/lib/tests/test_utils.py
+++ b/lms/lib/tests/test_utils.py
@@ -4,7 +4,6 @@
 
 
 from lms.lib import utils
-from xmodule.modulestore import ModuleStoreEnum  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory  # lint-amnesty, pylint: disable=wrong-import-order
 
@@ -20,30 +19,29 @@ def setUp(self):
         """
         super().setUp()
 
-        with self.store.default_store(ModuleStoreEnum.Type.mongo):
-            self.course = CourseFactory.create()
-            self.chapter = ItemFactory.create(category="chapter", parent_location=self.course.location)
-            self.sequential = ItemFactory.create(category="sequential", parent_location=self.chapter.location)
-            self.vertical = ItemFactory.create(category="vertical", parent_location=self.sequential.location)
-            self.html_module_1 = ItemFactory.create(category="html", parent_location=self.vertical.location)
-            self.vertical_with_container = ItemFactory.create(
-                category="vertical", parent_location=self.sequential.location
-            )
-            self.child_container = ItemFactory.create(
-                category="split_test", parent_location=self.vertical_with_container.location)
-            self.child_vertical = ItemFactory.create(category="vertical", parent_location=self.child_container.location)
-            self.child_html_module = ItemFactory.create(category="html", parent_location=self.child_vertical.location)
+        self.course = CourseFactory.create()
+        self.chapter = ItemFactory.create(category="chapter", parent_location=self.course.location)
+        self.sequential = ItemFactory.create(category="sequential", parent_location=self.chapter.location)
+        self.vertical = ItemFactory.create(category="vertical", parent_location=self.sequential.location)
+        self.html_module_1 = ItemFactory.create(category="html", parent_location=self.vertical.location)
+        self.vertical_with_container = ItemFactory.create(
+            category="vertical", parent_location=self.sequential.location
+        )
+        self.child_container = ItemFactory.create(
+            category="split_test", parent_location=self.vertical_with_container.location)
+        self.child_vertical = ItemFactory.create(category="vertical", parent_location=self.child_container.location)
+        self.child_html_module = ItemFactory.create(category="html", parent_location=self.child_vertical.location)
 
-            # Read again so that children lists are accurate
-            self.course = self.store.get_item(self.course.location)
-            self.chapter = self.store.get_item(self.chapter.location)
-            self.sequential = self.store.get_item(self.sequential.location)
-            self.vertical = self.store.get_item(self.vertical.location)
+        # Read again so that children lists are accurate
+        self.course = self.store.get_item(self.course.location)
+        self.chapter = self.store.get_item(self.chapter.location)
+        self.sequential = self.store.get_item(self.sequential.location)
+        self.vertical = self.store.get_item(self.vertical.location)
 
-            self.vertical_with_container = self.store.get_item(self.vertical_with_container.location)
-            self.child_container = self.store.get_item(self.child_container.location)
-            self.child_vertical = self.store.get_item(self.child_vertical.location)
-            self.child_html_module = self.store.get_item(self.child_html_module.location)
+        self.vertical_with_container = self.store.get_item(self.vertical_with_container.location)
+        self.child_container = self.store.get_item(self.child_container.location)
+        self.child_vertical = self.store.get_item(self.child_vertical.location)
+        self.child_html_module = self.store.get_item(self.child_html_module.location)
 
     def test_get_parent_unit(self):
         """
diff --git a/lms/lib/xblock/test/test_mixin.py b/lms/lib/xblock/test/test_mixin.py
index 34ba5dc79c9d..3d64f559a26a 100644
--- a/lms/lib/xblock/test/test_mixin.py
+++ b/lms/lib/xblock/test/test_mixin.py
@@ -14,7 +14,7 @@
     NONSENSICAL_ACCESS_RESTRICTION
 )
 from xmodule.modulestore import ModuleStoreEnum  # lint-amnesty, pylint: disable=wrong-import-order
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MIXED_MODULESTORE, ModuleStoreTestCase  # lint-amnesty, pylint: disable=wrong-import-order
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory, ToyCourseFactory  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.partitions.partitions import Group, UserPartition  # lint-amnesty, pylint: disable=wrong-import-order
 
@@ -296,17 +296,15 @@ def test_has_score(self):
         assert self.open_assessment.has_score
 
 
-@ddt.ddt
 class XBlockGetParentTest(LmsXBlockMixinTestCase):
     """
     Test that XBlock.get_parent returns correct results with each modulestore
     backend.
     """
-    MODULESTORE = TEST_DATA_MIXED_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_parents(self, modulestore_type):
-        with self.store.default_store(modulestore_type):
+    def test_parents(self):
+        with self.store.default_store(ModuleStoreEnum.Type.split):
 
             # setting up our own local course tree here, since it needs to be
             # created with the correct modulestore type.
@@ -330,10 +328,9 @@ def recurse(parent):
             visited = recurse(course)
             assert len(visited) == 28
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_parents_draft_content(self, modulestore_type):
+    def test_parents_draft_content(self):
         # move the video to the new vertical
-        with self.store.default_store(modulestore_type):
+        with self.store.default_store(ModuleStoreEnum.Type.split):
             self.build_course()
             subsection = self.store.get_item(self.subsection_location)
             new_vertical = ItemFactory.create(parent=subsection, category='vertical', display_name='New Test Unit')
diff --git a/openedx/core/djangoapps/bookmarks/tests/test_views.py b/openedx/core/djangoapps/bookmarks/tests/test_views.py
index 82fc24588df5..592ae4d7b689 100644
--- a/openedx/core/djangoapps/bookmarks/tests/test_views.py
+++ b/openedx/core/djangoapps/bookmarks/tests/test_views.py
@@ -11,8 +11,7 @@
 from django.conf import settings
 from django.urls import reverse
 from rest_framework.test import APIClient
-from xmodule.modulestore import ModuleStoreEnum
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE
 
 from openedx.core.djangolib.testing.utils import skip_unless_lms
 
@@ -72,7 +71,7 @@ class BookmarksListViewTests(BookmarksViewsTestsBase):
     GET /api/bookmarks/v1/bookmarks/?course_id={course_id1}
     POST /api/bookmarks/v1/bookmarks
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     @ddt.data(
         (1, False),
@@ -90,9 +89,7 @@ def test_get_bookmarks_successfully(self, bookmarks_count, check_all_fields, moc
         expected order without optional fields.
         """
 
-        course, __, bookmarks = self.create_course_with_bookmarks_count(
-            bookmarks_count, store_type=ModuleStoreEnum.Type.mongo
-        )
+        course, __, bookmarks = self.create_course_with_bookmarks_count(bookmarks_count)
 
         query_parameters = 'course_id={}&page_size={}'.format(
             quote(str(course.id)), 100)
@@ -133,9 +130,7 @@ def test_get_bookmarks_with_pagination(self, bookmarks_count, mock_tracker):
         Test that requesting bookmarks for a course return results with pagination 200 code.
         """
 
-        course, __, bookmarks = self.create_course_with_bookmarks_count(
-            bookmarks_count, store_type=ModuleStoreEnum.Type.mongo
-        )
+        course, __, bookmarks = self.create_course_with_bookmarks_count(bookmarks_count)
 
         page_size = 5
         query_parameters = 'course_id={}&page_size={}'.format(
diff --git a/openedx/core/djangoapps/content/course_overviews/tests/test_course_overviews.py b/openedx/core/djangoapps/content/course_overviews/tests/test_course_overviews.py
index 3af01b49a309..40e2a2cbdcbf 100644
--- a/openedx/core/djangoapps/content/course_overviews/tests/test_course_overviews.py
+++ b/openedx/core/djangoapps/content/course_overviews/tests/test_course_overviews.py
@@ -35,7 +35,6 @@
 )
 from xmodule.error_module import ErrorBlock  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore import ModuleStoreEnum  # lint-amnesty, pylint: disable=wrong-import-order
-from xmodule.modulestore.django import modulestore  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.tests.factories import CourseFactory, check_mongo_calls_range  # lint-amnesty, pylint: disable=wrong-import-order
 
@@ -248,7 +247,7 @@ def get_seconds_since_epoch(date_time):
                 "catalog_visibility": CATALOG_VISIBILITY_NONE,
             }
         ],
-        [ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split]
+        [ModuleStoreEnum.Type.split]
     ))
     @ddt.unpack
     def test_course_overview_behavior(self, course_kwargs, modulestore_type):
@@ -305,8 +304,7 @@ def test_closest_released_language(self, released_languages, course_language, ex
         course_overview = CourseOverviewFactory.create(language=course_language)
         assert course_overview.closest_released_language == expected_language
 
-    @ddt.data(ModuleStoreEnum.Type.split, ModuleStoreEnum.Type.mongo)
-    def test_get_non_existent_course(self, modulestore_type):
+    def test_get_non_existent_course(self):
         """
         Tests that requesting a non-existent course from get_from_id raises
         CourseOverview.DoesNotExist.
@@ -315,39 +313,34 @@ def test_get_non_existent_course(self, modulestore_type):
             modulestore_type (ModuleStoreEnum.Type): type of store to create the
                 course in.
         """
-        store = modulestore()._get_modulestore_by_type(modulestore_type)  # pylint: disable=protected-access
         with pytest.raises(CourseOverview.DoesNotExist):
-            CourseOverview.get_from_id(store.make_course_key('Non', 'Existent', 'Course'))
+            CourseOverview.get_from_id(self.store.make_course_key('Non', 'Existent', 'Course'))
 
-    @ddt.data(ModuleStoreEnum.Type.split, ModuleStoreEnum.Type.mongo)
-    def test_course_with_course_overview_exists(self, modulestore_type):
+    def test_course_with_course_overview_exists(self):
         """
         Tests that calling course_exists on an existent course
         that is cached in CourseOverview table returns True.
         """
-        course = CourseFactory.create(default_store=modulestore_type)
+        course = CourseFactory.create()
         CourseOverview.get_from_id(course.id)  # Ensure course in cached in CourseOverviews
         assert CourseOverview.objects.filter(id=course.id).exists()
         assert CourseOverview.course_exists(course.id)
 
-    @ddt.data(ModuleStoreEnum.Type.split, ModuleStoreEnum.Type.mongo)
-    def test_course_without_overview_exists(self, modulestore_type):
+    def test_course_without_overview_exists(self):
         """
         Tests that calling course_exists on an existent course
         that is NOT cached in CourseOverview table returns True.
         """
-        course = CourseFactory.create(default_store=modulestore_type)
+        course = CourseFactory.create()
         CourseOverview.objects.filter(id=course.id).delete()
         assert CourseOverview.course_exists(course.id)
         assert not CourseOverview.objects.filter(id=course.id).exists()
 
-    @ddt.data(ModuleStoreEnum.Type.split, ModuleStoreEnum.Type.mongo)
-    def test_nonexistent_course_does_not_exists(self, modulestore_type):
+    def test_nonexistent_course_does_not_exists(self):
         """
         Tests that calling course_exists on an non-existent course returns False.
         """
-        store = modulestore()._get_modulestore_by_type(modulestore_type)  # pylint: disable=protected-access
-        course_id = store.make_course_key('Non', 'Existent', 'Course')
+        course_id = self.store.make_course_key('Non', 'Existent', 'Course')
         assert not CourseOverview.course_exists(course_id)
 
     def test_get_errored_course(self):
@@ -378,23 +371,20 @@ def test_malformed_grading_policy(self):
         course_overview = CourseOverview._create_or_update(course)  # pylint: disable=protected-access
         assert course_overview.lowest_passing_grade is None
 
-    @ddt.data((ModuleStoreEnum.Type.mongo, 4, 4), (ModuleStoreEnum.Type.split, 2, 2))
-    @ddt.unpack
-    def test_versioning(self, modulestore_type, min_mongo_calls, max_mongo_calls):
+    def test_versioning(self):
         """
         Test that CourseOverviews with old version numbers are thrown out.
         """
-        with self.store.default_store(modulestore_type):
-            course = CourseFactory.create()
-            course_overview = CourseOverview.get_from_id(course.id)
-            course_overview.version = CourseOverview.VERSION - 1
-            course_overview.save()
+        course = CourseFactory.create()
+        course_overview = CourseOverview.get_from_id(course.id)
+        course_overview.version = CourseOverview.VERSION - 1
+        course_overview.save()
 
-            # Because the course overview now has an old version number, it should
-            # be thrown out after being loaded from the cache, which results in
-            # a call to get_course.
-            with check_mongo_calls_range(max_finds=max_mongo_calls, min_finds=min_mongo_calls):
-                _course_overview_2 = CourseOverview.get_from_id(course.id)
+        # Because the course overview now has an old version number, it should
+        # be thrown out after being loaded from the cache, which results in
+        # a call to get_course.
+        with check_mongo_calls_range(max_finds=2, min_finds=2):
+            _course_overview_2 = CourseOverview.get_from_id(course.id)
 
     # The CourseOverviewTab and CourseOverviewImageSet objects can't be filtered with course overview object as it is
     # created with `None` as 'id' - We are going to mock this to as this isn't being tested in this test case, instead
@@ -650,28 +640,21 @@ def set_config(self, enabled):
 
     @override_settings(DEFAULT_COURSE_ABOUT_IMAGE_URL='default_course.png')
     @override_settings(STATIC_URL='static/')
-    @ddt.data(
-        *itertools.product(
-            [ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split],
-            [None, '']
-        )
-    )
-    @ddt.unpack
-    def test_no_source_image(self, modulestore_type, course_image):
+    @ddt.data(None, '')
+    def test_no_source_image(self, course_image):
         """
         Tests that we behave as expected if no source image was specified.
         """
         # Because we're sending None and '', we expect to get the generic
         # fallback URL for course images.
         fallback_url = settings.STATIC_URL + settings.DEFAULT_COURSE_ABOUT_IMAGE_URL
-        course_overview = self._assert_image_urls_all_default(modulestore_type, course_image, fallback_url)
+        course_overview = self._assert_image_urls_all_default(ModuleStoreEnum.Type.split, course_image, fallback_url)
 
         # Even though there was no source image to generate, we should still
         # have a CourseOverviewImageSet object associated with this overview.
         assert hasattr(course_overview, 'image_set')
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_disabled_no_prior_data(self, modulestore_type):
+    def test_disabled_no_prior_data(self):
         """
         Test behavior when we are disabled and no entries exist.
 
@@ -684,13 +667,12 @@ def test_disabled_no_prior_data(self, modulestore_type):
         # Since we're disabled, we should just return the raw source image back
         # for every resolution in image_urls.
         fake_course_image = 'sample_image.png'
-        course_overview = self._assert_image_urls_all_default(modulestore_type, fake_course_image)
+        course_overview = self._assert_image_urls_all_default(ModuleStoreEnum.Type.split, fake_course_image)
 
         # Because we are disabled, no image set should have been generated.
         assert not hasattr(course_overview, 'image_set')
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_disabled_with_prior_data(self, modulestore_type):
+    def test_disabled_with_prior_data(self):
         """
         Test behavior when entries have been created but we are disabled.
 
@@ -706,11 +688,8 @@ def test_disabled_with_prior_data(self, modulestore_type):
         course_image = "my_course.jpg"
         broken_small_url = "I am small!"
         broken_large_url = "I am big!"
-        with self.store.default_store(modulestore_type):
-            course = CourseFactory.create(
-                default_store=modulestore_type, course_image=course_image
-            )
-            course_overview_before = self.get_from_id(course.id)
+        course = CourseFactory.create(course_image=course_image)
+        course_overview_before = self.get_from_id(course.id)
 
         # This initial seeding should create an entry for the image_set.
         assert hasattr(course_overview_before, 'image_set')
@@ -738,81 +717,71 @@ def test_disabled_with_prior_data(self, modulestore_type):
         expected_url = course_image_url(course)
         assert course_overview_after.image_urls == {'raw': expected_url, 'small': expected_url, 'large': expected_url}
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_cdn(self, modulestore_type):
+    def test_cdn(self):
         """
         Test that we return CDN prefixed URLs if it is enabled.
         """
-        with self.store.default_store(modulestore_type):
-            course = CourseFactory.create(default_store=modulestore_type)
-            overview = self.get_from_id(course.id)
+        course = CourseFactory.create()
+        overview = self.get_from_id(course.id)
 
-            # First the behavior when there's no CDN enabled...
-            AssetBaseUrlConfig.objects.all().delete()
-            if modulestore_type == ModuleStoreEnum.Type.mongo:
-                expected_path_start = "/c4x/"
-            elif modulestore_type == ModuleStoreEnum.Type.split:
-                expected_path_start = "/asset-v1:"
+        # First the behavior when there's no CDN enabled...
+        AssetBaseUrlConfig.objects.all().delete()
+        expected_path_start = "/asset-v1:"
 
-            for url in overview.image_urls.values():
-                assert url.startswith(expected_path_start)
+        for url in overview.image_urls.values():
+            assert url.startswith(expected_path_start)
 
-            # Now enable the CDN...
-            AssetBaseUrlConfig.objects.create(enabled=True, base_url='fakecdn.edx.org')
-            expected_cdn_url = "//fakecdn.edx.org" + expected_path_start
+        # Now enable the CDN...
+        AssetBaseUrlConfig.objects.create(enabled=True, base_url='fakecdn.edx.org')
+        expected_cdn_url = "//fakecdn.edx.org" + expected_path_start
 
-            for url in overview.image_urls.values():
-                assert url.startswith(expected_cdn_url)
+        for url in overview.image_urls.values():
+            assert url.startswith(expected_cdn_url)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_cdn_with_external_image(self, modulestore_type):
+    def test_cdn_with_external_image(self):
         """
         Test that we return CDN prefixed URLs unless they're absolute.
         """
-        with self.store.default_store(modulestore_type):
-            course = CourseFactory.create(default_store=modulestore_type)
-            overview = self.get_from_id(course.id)
+        course = CourseFactory.create()
+        overview = self.get_from_id(course.id)
 
-            # Now enable the CDN...
-            AssetBaseUrlConfig.objects.create(enabled=True, base_url='fakecdn.edx.org')
-            expected_cdn_url = "//fakecdn.edx.org"
+        # Now enable the CDN...
+        AssetBaseUrlConfig.objects.create(enabled=True, base_url='fakecdn.edx.org')
+        expected_cdn_url = "//fakecdn.edx.org"
 
-            start_urls = {
-                'raw': 'http://google.com/image.png',
-                'small': '/static/overview.png',
-                'large': ''
-            }
+        start_urls = {
+            'raw': 'http://google.com/image.png',
+            'small': '/static/overview.png',
+            'large': ''
+        }
 
-            modified_urls = overview.apply_cdn_to_urls(start_urls)
-            assert modified_urls['raw'] == start_urls['raw']
-            assert modified_urls['small'] != start_urls['small']
-            assert modified_urls['small'].startswith(expected_cdn_url)
-            assert modified_urls['large'] == start_urls['large']
+        modified_urls = overview.apply_cdn_to_urls(start_urls)
+        assert modified_urls['raw'] == start_urls['raw']
+        assert modified_urls['small'] != start_urls['small']
+        assert modified_urls['small'].startswith(expected_cdn_url)
+        assert modified_urls['large'] == start_urls['large']
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_cdn_with_a_single_external_image(self, modulestore_type):
+    def test_cdn_with_a_single_external_image(self):
         """
         Test CDN is applied for a URL when apply_cdn_to_url called directly.
 
         Apply CDN/base URL to the given URL if CDN configuration is enabled
         and the URL is not absolute.
         """
-        with self.store.default_store(modulestore_type):
-            course = CourseFactory.create(default_store=modulestore_type)
-            overview = self.get_from_id(course.id)
+        course = CourseFactory.create()
+        overview = self.get_from_id(course.id)
 
-            # Now enable the CDN...
-            AssetBaseUrlConfig.objects.create(enabled=True, base_url='fakecdn.edx.org')
-            expected_cdn_url = "//fakecdn.edx.org"
+        # Now enable the CDN...
+        AssetBaseUrlConfig.objects.create(enabled=True, base_url='fakecdn.edx.org')
+        expected_cdn_url = "//fakecdn.edx.org"
 
-            start_url = "/static/overview.png"
-            modified_url = overview.apply_cdn_to_url(start_url)
+        start_url = "/static/overview.png"
+        modified_url = overview.apply_cdn_to_url(start_url)
 
-            assert start_url != modified_url
-            assert modified_url.startswith(expected_cdn_url)
+        assert start_url != modified_url
+        assert modified_url.startswith(expected_cdn_url)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_error_generating_thumbnails(self, modulestore_type):
+    def test_error_generating_thumbnails(self):
         """
         Test a scenario where thumbnails cannot be generated.
 
@@ -832,7 +801,7 @@ def test_error_generating_thumbnails(self, modulestore_type):
 
             # This will generate a CourseOverview and verify that we get the
             # source image back for all resolutions.
-            course_overview = self._assert_image_urls_all_default(modulestore_type, fake_course_image)
+            course_overview = self._assert_image_urls_all_default(ModuleStoreEnum.Type.split, fake_course_image)
 
             # Make sure we were called (i.e. we tried to create the thumbnail)
             patched_create_thumbnail.assert_called()
@@ -849,14 +818,8 @@ def test_error_generating_thumbnails(self, modulestore_type):
             self.get_from_id(course_overview.id)
             patched_create_thumbnail.assert_not_called()
 
-    @ddt.data(
-        *itertools.product(
-            [ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split],
-            [True, False],
-        )
-    )
-    @ddt.unpack
-    def test_happy_path(self, modulestore_type, create_after_overview):
+    @ddt.data(True, False)
+    def test_happy_path(self, create_after_overview):
         """
         What happens when everything works like we expect it to.
 
@@ -873,48 +836,45 @@ def test_happy_path(self, modulestore_type, create_after_overview):
         image_buff.seek(0)
         image_name = "big_course_image.jpeg"
 
-        with self.store.default_store(modulestore_type):
-            course = CourseFactory.create(
-                default_store=modulestore_type, course_image=image_name
-            )
+        course = CourseFactory.create(course_image=image_name)
+
+        # Save a real image here...
+        course_image_asset_key = StaticContent.compute_location(course.id, course.course_image)
+        course_image_content = StaticContent(course_image_asset_key, image_name, 'image/jpeg', image_buff)
+        contentstore().save(course_image_content)
 
-            # Save a real image here...
-            course_image_asset_key = StaticContent.compute_location(course.id, course.course_image)
-            course_image_content = StaticContent(course_image_asset_key, image_name, 'image/jpeg', image_buff)
-            contentstore().save(course_image_content)
+        # If create_after_overview is True, disable thumbnail generation so
+        # that the CourseOverview object is created and saved without an
+        # image_set at first (it will be lazily created later).
+        if create_after_overview:
+            self.set_config(enabled=False)
 
-            # If create_after_overview is True, disable thumbnail generation so
-            # that the CourseOverview object is created and saved without an
-            # image_set at first (it will be lazily created later).
-            if create_after_overview:
-                self.set_config(enabled=False)
+        # Now generate the CourseOverview...
+        course_overview = self.get_from_id(course.id)
 
-            # Now generate the CourseOverview...
+        # If create_after_overview is True, no image_set exists yet. Verify
+        # that, then switch config back over to True and it should lazily
+        # create the image_set on the next get_from_id() call.
+        if create_after_overview:
+            assert not hasattr(course_overview, 'image_set')
+            self.set_config(enabled=True)
             course_overview = self.get_from_id(course.id)
 
-            # If create_after_overview is True, no image_set exists yet. Verify
-            # that, then switch config back over to True and it should lazily
-            # create the image_set on the next get_from_id() call.
-            if create_after_overview:
-                assert not hasattr(course_overview, 'image_set')
-                self.set_config(enabled=True)
-                course_overview = self.get_from_id(course.id)
-
-            assert hasattr(course_overview, 'image_set')
-            image_urls = course_overview.image_urls
-            config = CourseOverviewImageConfig.current()
-
-            # Make sure the thumbnail names come out as expected...
-            assert image_urls['raw'].endswith('big_course_image.jpeg')
-            assert image_urls['small'].endswith('big_course_image-jpeg-{}x{}.jpg'.format(*config.small))
-            assert image_urls['large'].endswith('big_course_image-jpeg-{}x{}.jpg'.format(*config.large))
-
-            # Now make sure our thumbnails are of the sizes we expect...
-            for image_url, expected_size in [(image_urls['small'], config.small), (image_urls['large'], config.large)]:
-                image_key = StaticContent.get_location_from_path(image_url)
-                image_content = AssetManager.find(image_key)
-                image = Image.open(BytesIO(image_content.data))
-                assert image.size == expected_size
+        assert hasattr(course_overview, 'image_set')
+        image_urls = course_overview.image_urls
+        config = CourseOverviewImageConfig.current()
+
+        # Make sure the thumbnail names come out as expected...
+        assert image_urls['raw'].endswith('big_course_image.jpeg')
+        assert image_urls['small'].endswith('big_course_image-jpeg-{}x{}.jpg'.format(*config.small))
+        assert image_urls['large'].endswith('big_course_image-jpeg-{}x{}.jpg'.format(*config.large))
+
+        # Now make sure our thumbnails are of the sizes we expect...
+        for image_url, expected_size in [(image_urls['small'], config.small), (image_urls['large'], config.large)]:
+            image_key = StaticContent.get_location_from_path(image_url)
+            image_content = AssetManager.find(image_key)
+            image = Image.open(BytesIO(image_content.data))
+            assert image.size == expected_size
 
     @ddt.data(
         (800, 400),  # Larger than both, correct ratio
@@ -1096,13 +1056,12 @@ class CourseOverviewTabTestCase(ModuleStoreTestCase):
 
     ENABLED_SIGNALS = ['course_published']
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_tabs_deletion_rollback_on_integrity_error(self, modulestore_type):
+    def test_tabs_deletion_rollback_on_integrity_error(self):
         """
         Tests that course_overview tabs deletion is correctly rolled back if an Exception
         occurs while updating the course_overview.
         """
-        course = CourseFactory.create(default_store=modulestore_type)
+        course = CourseFactory.create()
         course_overview = CourseOverview.get_from_id(course.id)
         expected_tabs = {tab.tab_id for tab in course_overview.tab_set.all()}
 
diff --git a/openedx/core/djangoapps/content/course_overviews/tests/test_signals.py b/openedx/core/djangoapps/content/course_overviews/tests/test_signals.py
index 9506a584bb4b..bf4fb43e30e7 100644
--- a/openedx/core/djangoapps/content/course_overviews/tests/test_signals.py
+++ b/openedx/core/djangoapps/content/course_overviews/tests/test_signals.py
@@ -6,10 +6,11 @@
 
 import pytest
 import ddt
+from pytz import UTC
 
 from xmodule.data import CertificatesDisplayBehaviors
 from xmodule.modulestore import ModuleStoreEnum
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, ModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_ONLY_SPLIT_MODULESTORE_DRAFT_PREFERRED, ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory, check_mongo_calls
 
 from ..models import CourseOverview
@@ -23,13 +24,12 @@ class CourseOverviewSignalsTestCase(ModuleStoreTestCase):
     """
     Tests for CourseOverview signals.
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_ONLY_SPLIT_MODULESTORE_DRAFT_PREFERRED
     ENABLED_SIGNALS = ['course_deleted', 'course_published']
-    TODAY = datetime.datetime.utcnow()
+    TODAY = datetime.datetime.now(UTC)
     NEXT_WEEK = TODAY + datetime.timedelta(days=7)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_caching(self, modulestore_type):
+    def test_caching(self):
         """
         Tests that CourseOverview structures are actually getting cached.
 
@@ -38,14 +38,13 @@ def test_caching(self, modulestore_type):
                 course in.
         """
         # Creating a new course will trigger a publish event and the course will be cached
-        course = CourseFactory.create(default_store=modulestore_type, emit_signals=True)
+        course = CourseFactory.create(emit_signals=True)
 
         # The cache will be hit and mongo will not be queried
         with check_mongo_calls(0):
             CourseOverview.get_from_id(course.id)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
-    def test_cache_invalidation(self, modulestore_type):
+    def test_cache_invalidation(self):
         """
         Tests that when a course is published or deleted, the corresponding
         course_overview is removed from the cache.
@@ -54,28 +53,27 @@ def test_cache_invalidation(self, modulestore_type):
             modulestore_type (ModuleStoreEnum.Type): type of store to create the
                 course in.
         """
-        with self.store.default_store(modulestore_type):
-
-            # Create a course where mobile_available is True.
-            course = CourseFactory.create(mobile_available=True, default_store=modulestore_type)
-            course_overview_1 = CourseOverview.get_from_id(course.id)
-            assert course_overview_1.mobile_available
-
-            # Set mobile_available to False and update the course.
-            # This fires a course_published signal, which should be caught in signals.py, which should in turn
-            # delete the corresponding CourseOverview from the cache.
-            course.mobile_available = False
-            with self.store.branch_setting(ModuleStoreEnum.Branch.draft_preferred):
-                self.store.update_item(course, ModuleStoreEnum.UserID.test)
-
-            # Make sure that when we load the CourseOverview again, mobile_available is updated.
-            course_overview_2 = CourseOverview.get_from_id(course.id)
-            assert not course_overview_2.mobile_available
-
-            # Verify that when the course is deleted, the corresponding CourseOverview is deleted as well.
-            with pytest.raises(CourseOverview.DoesNotExist):
-                self.store.delete_course(course.id, ModuleStoreEnum.UserID.test)
-                CourseOverview.get_from_id(course.id)
+
+        # Create a course where mobile_available is True.
+        course = CourseFactory.create(mobile_available=True)
+        course_overview_1 = CourseOverview.get_from_id(course.id)
+        assert course_overview_1.mobile_available
+
+        # Set mobile_available to False and update the course.
+        # This fires a course_published signal, which should be caught in signals.py, which should in turn
+        # delete the corresponding CourseOverview from the cache.
+        course.mobile_available = False
+        with self.store.branch_setting(ModuleStoreEnum.Branch.draft_preferred):
+            self.store.update_item(course, ModuleStoreEnum.UserID.test)
+
+        # Make sure that when we load the CourseOverview again, mobile_available is updated.
+        course_overview_2 = CourseOverview.get_from_id(course.id)
+        assert not course_overview_2.mobile_available
+
+        # Verify that when the course is deleted, the corresponding CourseOverview is deleted as well.
+        with pytest.raises(CourseOverview.DoesNotExist):
+            self.store.delete_course(course.id, ModuleStoreEnum.UserID.test)
+            CourseOverview.get_from_id(course.id)
 
     def assert_changed_signal_sent(self, changes, mock_signal):  # lint-amnesty, pylint: disable=missing-function-docstring
         course = CourseFactory.create(
diff --git a/openedx/core/djangoapps/content/course_overviews/tests/test_tasks.py b/openedx/core/djangoapps/content/course_overviews/tests/test_tasks.py
index 07fc9f7c2271..1dc29aa9ca2c 100644
--- a/openedx/core/djangoapps/content/course_overviews/tests/test_tasks.py
+++ b/openedx/core/djangoapps/content/course_overviews/tests/test_tasks.py
@@ -12,9 +12,9 @@
 class BatchedAsyncCourseOverviewUpdateTests(ModuleStoreTestCase):  # lint-amnesty, pylint: disable=missing-class-docstring
     def setUp(self):
         super().setUp()
-        self.course_1 = CourseFactory.create(default_store=ModuleStoreEnum.Type.mongo)
-        self.course_2 = CourseFactory.create(default_store=ModuleStoreEnum.Type.mongo)
-        self.course_3 = CourseFactory.create(default_store=ModuleStoreEnum.Type.mongo)
+        self.course_1 = CourseFactory.create()
+        self.course_2 = CourseFactory.create()
+        self.course_3 = CourseFactory.create()
 
     @mock.patch('openedx.core.djangoapps.content.course_overviews.models.CourseOverview.update_select_courses')
     def test_enqueue_all_courses_in_single_batch(self, mock_update_courses):
diff --git a/openedx/core/djangoapps/contentserver/middleware.py b/openedx/core/djangoapps/contentserver/middleware.py
index 7bdb429b815e..c13ebb412ebc 100644
--- a/openedx/core/djangoapps/contentserver/middleware.py
+++ b/openedx/core/djangoapps/contentserver/middleware.py
@@ -49,8 +49,6 @@ class StaticContentServer(MiddlewareMixin):
     def is_asset_request(self, request):
         """Determines whether the given request is an asset request"""
         return (
-            request.path.startswith('/' + XASSET_LOCATION_TAG + '/')
-            or
             request.path.startswith('/' + AssetLocator.CANONICAL_NAMESPACE)
             or
             StaticContent.is_versioned_asset_path(request.path)
@@ -61,6 +59,11 @@ def process_request(self, request):
         """Process the given request"""
         asset_path = request.path
 
+        # Return HttpResponseBadRequest if asset_path start with '/c4x/'
+        if asset_path.startswith('/' + XASSET_LOCATION_TAG + '/'):
+            log.warning(f'Old Mongo static assets deprecated: {asset_path}')
+            return HttpResponseBadRequest()
+
         if self.is_asset_request(request):  # lint-amnesty, pylint: disable=too-many-nested-blocks
             # Make sure we can convert this request into a location.
             if AssetLocator.CANONICAL_NAMESPACE in asset_path:
diff --git a/openedx/core/djangoapps/contentserver/test/test_contentserver.py b/openedx/core/djangoapps/contentserver/test/test_contentserver.py
index cf5ae5b5097b..a825cfb111ad 100644
--- a/openedx/core/djangoapps/contentserver/test/test_contentserver.py
+++ b/openedx/core/djangoapps/contentserver/test/test_contentserver.py
@@ -20,10 +20,10 @@
 from xmodule.contentstore.django import contentstore
 from xmodule.contentstore.content import StaticContent, VERSIONED_ASSETS_PREFIX
 from xmodule.modulestore.django import modulestore
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_MODULESTORE, SharedModuleStoreTestCase
-from xmodule.modulestore.xml_importer import import_course_from_xml
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, SharedModuleStoreTestCase
 from xmodule.assetstore.assetmgr import AssetManager
 from xmodule.modulestore.exceptions import ItemNotFoundError
+from xmodule.modulestore.tests.factories import ToyCourseFactory  # lint-amnesty, pylint: disable=wrong-import-order
 
 from common.djangoapps.student.models import CourseEnrollment
 from common.djangoapps.student.tests.factories import UserFactory, AdminFactory
@@ -67,13 +67,14 @@ def get_old_style_versioned_asset_url(asset_path):
     return asset_path
 
 
+@unittest.skip('OldMongo Deprecation')
 @ddt.ddt
 @override_settings(CONTENTSTORE=TEST_DATA_CONTENTSTORE)
 class ContentStoreToyCourseTest(SharedModuleStoreTestCase):
     """
     Tests that use the toy course.
     """
-    MODULESTORE = TEST_DATA_MONGO_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     @classmethod
     def setUpClass(cls):
@@ -82,12 +83,8 @@ def setUpClass(cls):
         cls.contentstore = contentstore()
         cls.modulestore = modulestore()
 
-        cls.course_key = cls.modulestore.make_course_key('edX', 'toy', '2012_Fall')
-
-        import_course_from_xml(
-            cls.modulestore, 1, TEST_DATA_DIR, ['toy'],
-            static_content_store=cls.contentstore, verbose=True
-        )
+        cls.course = ToyCourseFactory()
+        cls.course_key = cls.course.id
 
         # A locked asset
         cls.locked_asset = cls.course_key.make_asset_key('asset', 'sample_static.html')
diff --git a/openedx/core/djangoapps/course_date_signals/tests.py b/openedx/core/djangoapps/course_date_signals/tests.py
index ce93bc852970..b58b3d279cc9 100644
--- a/openedx/core/djangoapps/course_date_signals/tests.py
+++ b/openedx/core/djangoapps/course_date_signals/tests.py
@@ -1,9 +1,10 @@
 # lint-amnesty, pylint: disable=missing-module-docstring
 from datetime import timedelta
+from unittest import skip
 from unittest.mock import patch  # lint-amnesty, pylint: disable=wrong-import-order
 
 from edx_toggles.toggles.testutils import override_waffle_flag
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, ModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
 
 from cms.djangoapps.contentstore.config.waffle import CUSTOM_RELATIVE_DATES
@@ -19,7 +20,7 @@
 
 
 class SelfPacedDueDatesTests(ModuleStoreTestCase):  # lint-amnesty, pylint: disable=missing-class-docstring
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         super().setUp()
@@ -27,6 +28,7 @@ def setUp(self):
         for i in range(4):
             ItemFactory(parent=self.course, category="sequential", display_name=f"Section {i}")
 
+    @skip("OldMongo Deprecation")
     def test_basic_spacing(self):
         expected_sections = [
             (0, 'Section 0', timedelta(days=7)),
@@ -39,6 +41,7 @@ def test_basic_spacing(self):
 
         assert actual == expected_sections
 
+    @skip("OldMongo Deprecation")
     def test_hidden_sections(self):
         for _ in range(2):
             ItemFactory(parent=self.course, category="sequential", visible_to_staff_only=True)
@@ -53,6 +56,7 @@ def test_hidden_sections(self):
 
         assert actual == expected_sections
 
+    @skip("OldMongo Deprecation")
     def test_dates_for_ungraded_assignments(self):
         """
         _has_assignment_blocks should return true if the argument block
@@ -157,6 +161,7 @@ def test_sequence_with_ora_and_non_ora_assignments(self):
             sequence = self.store.get_item(sequence.location)
             self.assertCountEqual(_gather_graded_items(sequence, 5), expected_graded_items)
 
+    @skip("OldMongo Deprecation")
     def test_get_custom_pacing_children(self):
         """
         _get_custom_pacing_items should return a list of (block item location, field metadata dictionary)
@@ -204,7 +209,7 @@ class SelfPacedCustomDueDateTests(ModuleStoreTestCase):
     """
     Tests the custom Personalized Learner Schedule (PLS) dates in self paced courses
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         super().setUp()
@@ -288,6 +293,7 @@ def test_extract_dates_from_course_custom_and_default_pls_one_subsection_graded(
         with patch.object(utils, 'get_expected_duration', return_value=timedelta(weeks=6)):
             self.assertCountEqual(extract_dates_from_course(course), expected_dates)
 
+    @skip("OldMongo Deprecation")
     @override_waffle_flag(CUSTOM_RELATIVE_DATES, active=True)
     def test_extract_dates_from_course_custom_and_default_pls_multiple_subsections_graded(self):
         """
@@ -326,6 +332,7 @@ def test_extract_dates_from_course_custom_and_default_pls_multiple_subsections_g
         with patch.object(utils, 'get_expected_duration', return_value=timedelta(weeks=8)):
             self.assertCountEqual(extract_dates_from_course(course), expected_dates)
 
+    @skip("OldMongo Deprecation")
     @override_waffle_flag(CUSTOM_RELATIVE_DATES, active=True)
     def test_extract_dates_from_course_all_subsections(self):
         """
diff --git a/openedx/core/djangoapps/course_groups/tests/test_cohorts.py b/openedx/core/djangoapps/course_groups/tests/test_cohorts.py
index 01588ca529a4..0f6dd85863ba 100644
--- a/openedx/core/djangoapps/course_groups/tests/test_cohorts.py
+++ b/openedx/core/djangoapps/course_groups/tests/test_cohorts.py
@@ -17,7 +17,7 @@
 from common.djangoapps.student.models import CourseEnrollment
 from common.djangoapps.student.tests.factories import UserFactory
 from xmodule.modulestore.django import modulestore  # lint-amnesty, pylint: disable=wrong-import-order
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MIXED_MODULESTORE, ModuleStoreTestCase  # lint-amnesty, pylint: disable=wrong-import-order
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.tests.factories import ToyCourseFactory  # lint-amnesty, pylint: disable=wrong-import-order
 
 from .. import cohorts
@@ -149,7 +149,7 @@ class TestCohorts(ModuleStoreTestCase):
     """
     Test the cohorts feature
     """
-    MODULESTORE = TEST_DATA_MIXED_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         """
@@ -648,7 +648,7 @@ class TestCohortsAndPartitionGroups(ModuleStoreTestCase):
     """
     Test Cohorts and Partitions Groups.
     """
-    MODULESTORE = TEST_DATA_MIXED_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         """
diff --git a/openedx/core/djangoapps/course_groups/tests/test_partition_scheme.py b/openedx/core/djangoapps/course_groups/tests/test_partition_scheme.py
index b156196606b9..73f824d9fab5 100644
--- a/openedx/core/djangoapps/course_groups/tests/test_partition_scheme.py
+++ b/openedx/core/djangoapps/course_groups/tests/test_partition_scheme.py
@@ -12,7 +12,7 @@
 from openedx.core.djangolib.testing.utils import skip_unless_lms
 from common.djangoapps.student.tests.factories import UserFactory
 from xmodule.modulestore.django import modulestore  # lint-amnesty, pylint: disable=wrong-import-order
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MIXED_MODULESTORE, ModuleStoreTestCase  # lint-amnesty, pylint: disable=wrong-import-order
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.tests.factories import ToyCourseFactory  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.partitions.partitions import Group, UserPartition, UserPartitionError  # lint-amnesty, pylint: disable=wrong-import-order
 
@@ -27,7 +27,7 @@ class TestCohortPartitionScheme(ModuleStoreTestCase):
     """
     Test the logic for linking a user to a partition group based on their cohort.
     """
-    MODULESTORE = TEST_DATA_MIXED_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         """
@@ -267,7 +267,7 @@ class TestGetCohortedUserPartition(ModuleStoreTestCase):
     """
     Test that `get_cohorted_user_partition` returns the first user_partition with scheme `CohortPartitionScheme`.
     """
-    MODULESTORE = TEST_DATA_MIXED_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         """
diff --git a/openedx/core/djangoapps/discussions/tests/test_tasks.py b/openedx/core/djangoapps/discussions/tests/test_tasks.py
index 1d0c3a9d037c..d19de45d9dc1 100644
--- a/openedx/core/djangoapps/discussions/tests/test_tasks.py
+++ b/openedx/core/djangoapps/discussions/tests/test_tasks.py
@@ -1,6 +1,7 @@
 """
 Tests for discussions tasks.
 """
+from unittest import skip
 import ddt
 import mock
 
@@ -8,7 +9,7 @@
 from openedx_events.learning.data import DiscussionTopicContext
 from openedx.core.djangoapps.discussions.tasks import update_discussions_settings_from_course
 
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, ModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
 
 
@@ -18,7 +19,7 @@ class UpdateDiscussionsSettingsFromCourseTestCase(ModuleStoreTestCase):
     """
     Tests for the discussions settings update tasks
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         super().setUp()
@@ -101,6 +102,7 @@ def update_discussions_settings(self, settings):
         self.course.discussions_settings.update(settings)
         self.update_course(self.course, self.user.id)
 
+    @skip("OldMongo Deprecation")
     def test_default(self):
         """
         Test that the course defaults.
@@ -113,9 +115,10 @@ def test_default(self):
         assert config_data.plugin_configuration == {}
         assert {context.title for context in config_data.contexts} == {"General", "Unit", "Discussable Unit"}
 
-    def test_topics_contexts(self):
+    @skip("OldMongo Deprecation")
+    def test_general_topics(self):
         """
-        Test the handling of topics.
+        Test the handling of course general topics.
         """
         self.update_course_field(discussion_topics={
             "General": {"id": "general-topic"},
@@ -142,6 +145,7 @@ def test_topics_contexts(self):
             context={'section': 'Section', 'subsection': 'Sequence', 'unit': 'Unit'}
         ) in config_data.contexts
 
+    @skip("OldMongo Deprecation")
     @ddt.data(
         ({}, 3, {"Unit", "Discussable Unit"},
          {"Graded Unit", "Non-Discussable Unit", "Discussable Graded Unit", "Non-Discussable Graded Unit"}),
diff --git a/openedx/core/djangoapps/models/tests/test_course_details.py b/openedx/core/djangoapps/models/tests/test_course_details.py
index 6d102ed32b4e..cd12d146f538 100644
--- a/openedx/core/djangoapps/models/tests/test_course_details.py
+++ b/openedx/core/djangoapps/models/tests/test_course_details.py
@@ -12,7 +12,7 @@
 from django.conf import settings
 from xmodule.modulestore import ModuleStoreEnum
 from xmodule.data import CertificatesDisplayBehaviors
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, ModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory
 
 from openedx.core.djangoapps.models.course_details import ABOUT_ATTRIBUTES, CourseDetails
@@ -25,7 +25,7 @@ class CourseDetailsTestCase(ModuleStoreTestCase):
     """
     Tests the first course settings page (course dates, overview, etc.).
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         super().setUp()
@@ -35,7 +35,7 @@ def test_virgin_fetch(self):
         details = CourseDetails.fetch(self.course.id)
         assert details.org == self.course.location.org, 'Org not copied into'
         assert details.course_id == self.course.location.course, 'Course_id not copied into'
-        assert details.run == self.course.location.block_id, 'Course name not copied into'
+        assert details.run == self.course.location.run, 'Course name not copied into'
         assert details.course_image_name == self.course.course_image
         assert details.start_date.tzinfo is not None
         assert details.end_date is None, ('end date somehow initialized ' + str(details.end_date))
@@ -116,7 +116,7 @@ def test_update_and_fetch(self):
                    jsondetails.instructor_info
 
     def test_toggle_pacing_during_course_run(self):
-        self.course.start = datetime.datetime.now()
+        self.course.start = datetime.datetime.now(UTC)
         self.store.update_item(self.course, self.user.id)
 
         details = CourseDetails.fetch(self.course.id)
diff --git a/openedx/core/lib/gating/tests/test_api.py b/openedx/core/lib/gating/tests/test_api.py
index 13f2414a3997..7214fff42133 100644
--- a/openedx/core/lib/gating/tests/test_api.py
+++ b/openedx/core/lib/gating/tests/test_api.py
@@ -11,7 +11,7 @@
 from django.conf import settings
 from milestones import api as milestones_api
 from milestones.tests.utils import MilestonesTestCaseMixin
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, ModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
 
 from common.djangoapps.student.tests.factories import UserFactory
@@ -351,7 +351,7 @@ class TestGatingGradesIntegration(GradeTestBase):
     """
     Tests the integration between the gating API and our Persistent Grades framework.
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms')
     def test_get_subsection_grade_percentage(self):
diff --git a/openedx/core/lib/tests/test_courses.py b/openedx/core/lib/tests/test_courses.py
index e4a112761e0b..c6f40dc67ee4 100644
--- a/openedx/core/lib/tests/test_courses.py
+++ b/openedx/core/lib/tests/test_courses.py
@@ -6,7 +6,6 @@
 import ddt
 from django.test.utils import override_settings
 
-from xmodule.modulestore import ModuleStoreEnum
 from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory
 
@@ -52,13 +51,12 @@ def test_spaces_in_image_name(self):
         )
 
     @override_settings(DEFAULT_COURSE_ABOUT_IMAGE_URL='test.png')
-    @ddt.data(ModuleStoreEnum.Type.split, ModuleStoreEnum.Type.mongo)
-    def test_empty_image_name(self, default_store):
+    def test_empty_image_name(self):
         """
         Verify that if a course has empty `course_image`, `course_image_url` returns
         `DEFAULT_COURSE_ABOUT_IMAGE_URL` defined in the settings.
         """
-        course = CourseFactory.create(course_image='', default_store=default_store)
+        course = CourseFactory.create(course_image='')
         assert '/static/test.png' == course_image_url(course)
 
     def test_get_banner_image_url(self):
diff --git a/openedx/core/lib/tests/test_xblock_utils.py b/openedx/core/lib/tests/test_xblock_utils.py
index 6671267133c6..9e92c8fc9af8 100644
--- a/openedx/core/lib/tests/test_xblock_utils.py
+++ b/openedx/core/lib/tests/test_xblock_utils.py
@@ -3,6 +3,7 @@
 """
 
 
+from unittest import skip
 import uuid
 from unittest.mock import patch
 
@@ -13,7 +14,7 @@
 from web_fragments.fragment import Fragment
 from xblock.core import XBlockAside
 from xmodule.modulestore import ModuleStoreEnum
-from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, SharedModuleStoreTestCase
+from xmodule.modulestore.tests.django_utils import TEST_DATA_SPLIT_MODULESTORE, SharedModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
 from xmodule.modulestore.tests.test_asides import AsideTestType
 
@@ -38,13 +39,7 @@ class TestXblockUtils(SharedModuleStoreTestCase):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
-        cls.course_mongo = CourseFactory.create(
-            default_store=ModuleStoreEnum.Type.mongo,
-            org='TestX',
-            number='TS01',
-            run='2015'
-        )
-        cls.course_split = CourseFactory.create(
+        cls.course = CourseFactory.create(
             default_store=ModuleStoreEnum.Type.split,
             org='TestX',
             number='TS02',
@@ -86,21 +81,15 @@ def test_request_token(self):
         test_uuid = uuid.UUID(token, version=1)
         assert token == test_uuid.hex
 
-    @ddt.data(
-        ('course_mongo', 'data-usage-id="i4x:;_;_TestX;_TS01;_course;_2015"'),
-        ('course_split', 'data-usage-id="block-v1:TestX+TS02+2015+type@course+block@course"')
-    )
-    @ddt.unpack
-    def test_wrap_xblock(self, course_id, data_usage_id):
+    def test_wrap_xblock(self):
         """
         Verify that new content is added and the resources are the same.
         """
         fragment = self.create_fragment("<h1>Test!</h1>")
         fragment.initialize_js('BlockMain')  # wrap_block() sets some attributes only if there is JS.
-        course = getattr(self, course_id)
         test_wrap_output = wrap_xblock(
             runtime_class='TestRuntime',
-            block=course,
+            block=self.course,
             view='baseview',
             frag=fragment,
             context={"wrap_xblock_data": {"custom-attribute": "custom-value"}},
@@ -110,7 +99,7 @@ def test_wrap_xblock(self, course_id, data_usage_id):
         assert isinstance(test_wrap_output, Fragment)
         assert 'xblock-baseview' in test_wrap_output.content
         assert 'data-runtime-class="TestRuntime"' in test_wrap_output.content
-        assert data_usage_id in test_wrap_output.content
+        assert 'data-usage-id="block-v1:TestX+TS02+2015+type@course+block@course"' in test_wrap_output.content
         assert '<h1>Test!</h1>' in test_wrap_output.content
         assert 'data-custom-attribute="custom-value"' in test_wrap_output.content
         assert test_wrap_output.resources[0].data == 'body {background-color:red;}'
@@ -168,9 +157,10 @@ def test_get_js_dependencies(self, pipeline_enabled, expected_js_dependencies):
             assert js_dependencies == expected_js_dependencies
 
 
+@skip("OldMongo Deprecation")
 class TestXBlockAside(SharedModuleStoreTestCase):
     """Test the xblock aside function."""
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     @classmethod
     def setUpClass(cls):
diff --git a/openedx/features/content_type_gating/tests/test_access.py b/openedx/features/content_type_gating/tests/test_access.py
index ba16fdd6bda2..395eb74f6d85 100644
--- a/openedx/features/content_type_gating/tests/test_access.py
+++ b/openedx/features/content_type_gating/tests/test_access.py
@@ -3,6 +3,7 @@
 """
 import os
 from datetime import datetime, timedelta
+from unittest import skip
 from unittest.mock import patch, Mock
 
 import ddt
@@ -14,7 +15,7 @@
 from django.contrib.auth import get_user_model
 from pyquery import PyQuery as pq
 from xmodule.modulestore.tests.django_utils import (
-    TEST_DATA_MONGO_AMNESTY_MODULESTORE, ModuleStoreTestCase, SharedModuleStoreTestCase,
+    TEST_DATA_SPLIT_MODULESTORE, ModuleStoreTestCase, SharedModuleStoreTestCase,
 )
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
 from xmodule.partitions.partitions import ENROLLMENT_TRACK_PARTITION_ID
@@ -1123,7 +1124,7 @@ class TestContentTypeGatingService(ModuleStoreTestCase):
     to check whether a sequence contains content type gated blocks
     The content_type_gate_for_block can be used to return the content type gate for a given block
     """
-    MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
+    MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     def setUp(self):
         super().setUp()
@@ -1190,6 +1191,7 @@ def test_content_type_gate_for_block(self):
             self.user, blocks_dict['not_graded_1'], course['course'].id
         ) is None
 
+    @skip("OldMongo Deprecation")
     @patch.object(ContentTypeGatingService, '_get_user', return_value=UserFactory.build())
     def test_check_children_for_content_type_gating_paywall(self, mocked_user):  # pylint: disable=unused-argument
         ''' Verify that the method returns a content type gate when appropriate '''
diff --git a/openedx/features/course_experience/tests/test_url_helpers.py b/openedx/features/course_experience/tests/test_url_helpers.py
index aeb7d7ffaa4f..00414d70eec0 100644
--- a/openedx/features/course_experience/tests/test_url_helpers.py
+++ b/openedx/features/course_experience/tests/test_url_helpers.py
@@ -8,7 +8,6 @@
 from django.test.client import RequestFactory
 from django.test.utils import override_settings
 
-from xmodule.modulestore import ModuleStoreEnum
 from xmodule.modulestore.tests.django_utils import SharedModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
 
@@ -70,113 +69,63 @@ def setUpClass(cls):
     @classmethod
     def create_test_courses(cls):
         """
-        We build two simple course structures (one using Split, the other Old Mongo).
-        Each course structure is a non-branching tree from the root Course block down
-        to the Component-level problem block; that is, we make one item for each course
-        hierarchy level.
+        We build simple course structures.
+        Course structure is a non-branching tree from the root Course block down
+        to the Component-level problem block;
 
-        For easy access in the test functions, we return them in a dict like this:
+        For easy access in the test functions, we return a dict like this:
         {
-            "split": {
-                "course_run": <course block for Split Mongo course>,
-                "section": <chapter block in course run>
-                "subsection": <sequence block in section>
-                "unit": <vertical block in subsection>
-                "component": <problem block in unit>
-            },
-            "mongo": {
-                "course_run": <course block for (deprecated) Old Mongo course>,
-                ... etc ...
-            }
+            "course_run": <course block for Split Mongo course>,
+            "section": <chapter block in course run>
+            "subsection": <sequence block in section>
+            "unit": <vertical block in subsection>
+            "component": <problem block in unit>
         }
         """
 
-        # Make Split Mongo course.
-        with cls.store.default_store(ModuleStoreEnum.Type.split):
-            course_run = CourseFactory.create(
-                org='TestX',
-                number='UrlHelpers',
-                run='split',
-                display_name='URL Helpers Test Course',
+        course_run = CourseFactory.create(
+            org='TestX',
+            number='UrlHelpers',
+            run='split',
+            display_name='URL Helpers Test Course',
+        )
+        with cls.store.bulk_operations(course_run.id):
+            section = ItemFactory.create(
+                parent_location=course_run.location,
+                category='chapter',
+                display_name="Generated Section",
             )
-            with cls.store.bulk_operations(course_run.id):
-                section = ItemFactory.create(
-                    parent_location=course_run.location,
-                    category='chapter',
-                    display_name="Generated Section",
-                )
-                subsection = ItemFactory.create(
-                    parent_location=section.location,
-                    category='sequential',
-                    display_name="Generated Subsection",
-                )
-                unit = ItemFactory.create(
-                    parent_location=subsection.location,
-                    category='vertical',
-                    display_name="Generated Unit",
-                )
-                component = ItemFactory.create(
-                    parent_location=unit.location,
-                    category='problem',
-                    display_name="Generated Problem Component",
-                )
-
-        # Make (deprecated) Old Mongo course.
-        with cls.store.default_store(ModuleStoreEnum.Type.mongo):
-            deprecated_course_run = CourseFactory.create(
-                org='TestX',
-                number='UrlHelpers',
-                run='mongo',
-                display_name='URL Helpers Test Course (Deprecated)',
+            subsection = ItemFactory.create(
+                parent_location=section.location,
+                category='sequential',
+                display_name="Generated Subsection",
+            )
+            unit = ItemFactory.create(
+                parent_location=subsection.location,
+                category='vertical',
+                display_name="Generated Unit",
+            )
+            component = ItemFactory.create(
+                parent_location=unit.location,
+                category='problem',
+                display_name="Generated Problem Component",
             )
-            with cls.store.bulk_operations(deprecated_course_run.id):
-                deprecated_section = ItemFactory.create(
-                    parent_location=deprecated_course_run.location,
-                    category='chapter',
-                    display_name="Generated Section",
-                )
-                deprecated_subsection = ItemFactory.create(
-                    parent_location=deprecated_section.location,
-                    category='sequential',
-                    display_name="Generated Subsection",
-                )
-                deprecated_unit = ItemFactory.create(
-                    parent_location=deprecated_subsection.location,
-                    category='vertical',
-                    display_name="Generated Unit",
-                )
-                deprecated_component = ItemFactory.create(
-                    parent_location=deprecated_unit.location,
-                    category='problem',
-                    display_name="Generated Problem Component",
-                )
 
         return {
-            ModuleStoreEnum.Type.split: {
-                'course_run': course_run,
-                'section': section,
-                'subsection': subsection,
-                'unit': unit,
-                'component': component,
-            },
-            ModuleStoreEnum.Type.mongo: {
-                'course_run': deprecated_course_run,
-                'section': deprecated_section,
-                'subsection': deprecated_subsection,
-                'unit': deprecated_unit,
-                'component': deprecated_component,
-            }
+            'course_run': course_run,
+            'section': section,
+            'subsection': subsection,
+            'unit': unit,
+            'component': component,
         }
 
     @ddt.data(
         (
-            ModuleStoreEnum.Type.split,
             'mfe',
             'course_run',
             'http://learning-mfe/course/course-v1:TestX+UrlHelpers+split'
         ),
         (
-            ModuleStoreEnum.Type.split,
             'mfe',
             'section',
             (
@@ -185,7 +134,6 @@ def create_test_courses(cls):
             ),
         ),
         (
-            ModuleStoreEnum.Type.split,
             'mfe',
             'subsection',
             (
@@ -194,7 +142,6 @@ def create_test_courses(cls):
             ),
         ),
         (
-            ModuleStoreEnum.Type.split,
             'mfe',
             'unit',
             (
@@ -204,7 +151,6 @@ def create_test_courses(cls):
             ),
         ),
         (
-            ModuleStoreEnum.Type.split,
             'mfe',
             'component',
             (
@@ -214,58 +160,29 @@ def create_test_courses(cls):
             ),
         ),
         (
-            ModuleStoreEnum.Type.split,
             'legacy',
             'course_run',
             '/courses/course-v1:TestX+UrlHelpers+split/courseware',
         ),
         (
-            ModuleStoreEnum.Type.split,
             'legacy',
             'subsection',
             '/courses/course-v1:TestX+UrlHelpers+split/courseware/Generated_Section/Generated_Subsection/',
         ),
         (
-            ModuleStoreEnum.Type.split,
             'legacy',
             'unit',
             '/courses/course-v1:TestX+UrlHelpers+split/courseware/Generated_Section/Generated_Subsection/1',
         ),
         (
-            ModuleStoreEnum.Type.split,
             'legacy',
             'component',
             '/courses/course-v1:TestX+UrlHelpers+split/courseware/Generated_Section/Generated_Subsection/1',
-        ),
-        (
-            ModuleStoreEnum.Type.mongo,
-            'legacy',
-            'course_run',
-            '/courses/TestX/UrlHelpers/mongo/courseware',
-        ),
-        (
-            ModuleStoreEnum.Type.mongo,
-            'legacy',
-            'subsection',
-            '/courses/TestX/UrlHelpers/mongo/courseware/Generated_Section/Generated_Subsection/',
-        ),
-        (
-            ModuleStoreEnum.Type.mongo,
-            'legacy',
-            'unit',
-            '/courses/TestX/UrlHelpers/mongo/courseware/Generated_Section/Generated_Subsection/1',
-        ),
-        (
-            ModuleStoreEnum.Type.mongo,
-            'legacy',
-            'component',
-            '/courses/TestX/UrlHelpers/mongo/courseware/Generated_Section/Generated_Subsection/1',
-        ),
+        )
     )
     @ddt.unpack
     def test_get_courseware_url(
         self,
-        store_type,
         active_experience,
         structure_level,
         expected_path,
@@ -278,10 +195,10 @@ def test_get_courseware_url(
 
         check that the expected path (URL without querystring) is returned by `get_courseware_url`.
         """
-        block = self.items[store_type][structure_level]
+        block = self.items[structure_level]
         with _patch_courseware_mfe_is_active(active_experience == 'mfe') as mock_mfe_is_active:
             url = url_helpers.get_courseware_url(block.location)
         path = url.split('?')[0]
         assert path == expected_path
-        course_run = self.items[store_type]['course_run']
+        course_run = self.items['course_run']
         mock_mfe_is_active.assert_called_once()
diff --git a/openedx/features/enterprise_support/tests/test_utils.py b/openedx/features/enterprise_support/tests/test_utils.py
index ec271de137d5..0f79019c92b7 100644
--- a/openedx/features/enterprise_support/tests/test_utils.py
+++ b/openedx/features/enterprise_support/tests/test_utils.py
@@ -4,7 +4,7 @@
 
 import json
 import uuid
-from unittest import mock
+from unittest import mock, skip
 
 import ddt
 from completion.models import BlockCompletion
@@ -463,6 +463,7 @@ def test_get_enterprise_learner_generic_name_no_replacement(self, mock_customer_
         generic_name = get_enterprise_learner_generic_name(request)
         assert '' == generic_name
 
+    @skip("OldMongo Deprecation")
     def test_is_enterprise_learner(self):
         with mock.patch(
             'django.core.cache.cache.set'
diff --git a/openedx/tests/completion_integration/test_views.py b/openedx/tests/completion_integration/test_views.py
index 5d3624b05a15..607f2051d09e 100644
--- a/openedx/tests/completion_integration/test_views.py
+++ b/openedx/tests/completion_integration/test_views.py
@@ -28,9 +28,6 @@ class CompletionBatchTestCase(CompletionWaffleTestMixin, ModuleStoreTestCase):
     UNENROLLED_USERNAME = 'unenrolled_user'
     COURSE_KEY = 'course-v1:TestX+101+Test'
     BLOCK_KEY = 'block-v1:TestX+101+Test+type@problem+block@Test_Problem'
-    # And for old mongo:
-    COURSE_KEY_DEPRECATED = 'TestX/201/Test'
-    BLOCK_KEY_DEPRECATED = 'i4x://TestX/201/problem/Test_Problem'
 
     def setUp(self):
         """
@@ -52,17 +49,6 @@ def setUp(self):
             parent=self.course, category="problem", display_name="Test Problem", publish_item=False,
         )
         assert str(self.problem.location) == self.BLOCK_KEY
-        # And an old mongo course:
-        self.course_deprecated = CourseFactory.create(
-            org='TestX', number='201', display_name='Test',
-            default_store=ModuleStoreEnum.Type.mongo,
-        )
-        assert str(self.course_deprecated.id) == self.COURSE_KEY_DEPRECATED
-        self.problem_deprecated = ItemFactory.create(
-            parent=self.course_deprecated, category="problem", display_name="Test Problem",
-            publish_item=False,
-        )
-        assert str(self.problem_deprecated.location) == self.BLOCK_KEY_DEPRECATED
 
         # Create users
         self.staff_user = UserFactory(is_staff=True)
@@ -71,7 +57,6 @@ def setUp(self):
 
         # Enrol one user in the course
         CourseEnrollmentFactory.create(user=self.enrolled_user, course_id=self.course.id)
-        CourseEnrollmentFactory.create(user=self.enrolled_user, course_id=self.course_deprecated.id)
 
         # Login the enrolled user by for all tests
         self.client = APIClient()
@@ -101,16 +86,6 @@ def test_enable_completion_tracking(self):
                 }
             }, 200, {'detail': 'ok'}
         ),
-        # Valid submission (old mongo)
-        (
-            {
-                'username': ENROLLED_USERNAME,
-                'course_key': COURSE_KEY_DEPRECATED,
-                'blocks': {
-                    BLOCK_KEY_DEPRECATED: 1.0,
-                }
-            }, 200, {'detail': 'ok'}
-        ),
         # Blocks list can be empty, though it's a no-op
         (
             {
@@ -222,16 +197,6 @@ def test_batch_submit(self, payload, expected_status, expected_data):
                 }
             }, 200, {'detail': 'ok'}
         ),
-        # Staff can submit completion on behalf of other users (old mongo)
-        (
-            {
-                'username': ENROLLED_USERNAME,
-                'course_key': COURSE_KEY_DEPRECATED,
-                'blocks': {
-                    BLOCK_KEY_DEPRECATED: 1.0,
-                }
-            }, 200, {'detail': 'ok'}
-        ),
         # User must be enrolled in the course
         (
             {
diff --git a/xmodule/modulestore/mixed.py b/xmodule/modulestore/mixed.py
index 88bb8215fe26..17b5e8a0869d 100644
--- a/xmodule/modulestore/mixed.py
+++ b/xmodule/modulestore/mixed.py
@@ -15,10 +15,9 @@
 
 from xmodule.assetstore import AssetMetadata
 
-from . import XMODULE_FIELDS_WITH_USAGE_KEYS, ModuleStoreEnum, ModuleStoreWriteBase
+from . import XMODULE_FIELDS_WITH_USAGE_KEYS, ModuleStoreWriteBase
 from .draft_and_published import ModuleStoreDraftAndPublished
 from .exceptions import DuplicateCourseError, ItemNotFoundError
-from .split_migrator import SplitMigrator
 
 log = logging.getLogger(__name__)
 
@@ -717,17 +716,9 @@ def clone_course(self, source_course_id, dest_course_id, user_id, fields=None, *
         if source_modulestore == dest_modulestore:
             return source_modulestore.clone_course(source_course_id, dest_course_id, user_id, fields, **kwargs)
 
-        if dest_modulestore.get_modulestore_type() == ModuleStoreEnum.Type.split:
-            split_migrator = SplitMigrator(dest_modulestore, source_modulestore)
-            split_migrator.migrate_mongo_course(source_course_id, user_id, dest_course_id.org,
-                                                dest_course_id.course, dest_course_id.run, fields, **kwargs)
-
-            # the super handles assets and any other necessities
-            super().clone_course(source_course_id, dest_course_id, user_id, fields, **kwargs)
-        else:
-            raise NotImplementedError("No code for cloning from {} to {}".format(
-                source_modulestore, dest_modulestore
-            ))
+        raise NotImplementedError("No code for cloning from {} to {}".format(
+            source_modulestore, dest_modulestore
+        ))
 
     @strip_key
     @prepare_asides
diff --git a/xmodule/modulestore/mongo/base.py b/xmodule/modulestore/mongo/base.py
index 869d45cd1564..c8acfeca2a9f 100644
--- a/xmodule/modulestore/mongo/base.py
+++ b/xmodule/modulestore/mongo/base.py
@@ -1017,34 +1017,7 @@ def get_courses(self, **kwargs):
         Returns a list of course descriptors. This accepts an optional parameter of 'org' which
         will apply an efficient filter to only get courses with the specified ORG
         '''
-
-        course_org_filter = kwargs.get('org')
-
-        if course_org_filter:
-            course_records = self.collection.find({'_id.category': 'course', '_id.org': course_org_filter})
-        else:
-            course_records = self.collection.find({'_id.category': 'course'})
-
-        base_list = sum(
-            [
-                self._load_items(
-                    CourseKey.from_string('/'.join(
-                        [course['_id']['org'], course['_id']['course'], course['_id']['name']]
-                    )),
-                    [course]
-                )
-                for course
-                # I tried to add '$and': [{'_id.org': {'$ne': 'edx'}}, {'_id.course': {'$ne': 'templates'}}]
-                # but it didn't do the right thing (it filtered all edx and all templates out)
-                in course_records
-                if not (  # TODO kill this
-                    course['_id']['org'] == 'edx' and
-                    course['_id']['course'] == 'templates'
-                )
-            ],
-            []
-        )
-        return [course for course in base_list if not isinstance(course, ErrorBlock)]
+        return []
 
     @autoretry_read()
     def _find_one(self, location):
diff --git a/xmodule/modulestore/mongo/draft.py b/xmodule/modulestore/mongo/draft.py
index 29c2536f3372..f00279a227e3 100644
--- a/xmodule/modulestore/mongo/draft.py
+++ b/xmodule/modulestore/mongo/draft.py
@@ -9,29 +9,19 @@
 
 import logging
 
-import pymongo
-from opaque_keys.edx.keys import UsageKey
-from opaque_keys.edx.locator import BlockUsageLocator
 from xblock.core import XBlock
 
 from openedx.core.lib.cache_utils import request_cached
-from xmodule.exceptions import InvalidVersionError
 from xmodule.modulestore import ModuleStoreEnum
 from xmodule.modulestore.draft_and_published import DIRECT_ONLY_CATEGORIES, UnsupportedRevisionError
 from xmodule.modulestore.exceptions import (
-    DuplicateCourseError,
-    DuplicateItemError,
-    InvalidBranchSetting,
     ItemNotFoundError
 )
 from xmodule.modulestore.mongo.base import (
-    SORT_REVISION_FAVOR_DRAFT,
     MongoModuleStore,
     MongoRevisionKey,
     as_draft,
-    as_published
 )
-from xmodule.modulestore.store_utilities import rewrite_nonportable_content_links
 
 log = logging.getLogger(__name__)
 
@@ -143,25 +133,7 @@ def has_item(self, usage_key, revision=None):  # lint-amnesty, pylint: disable=a
                     if branch setting is ModuleStoreEnum.Branch.published_only, checks for the published item only
                     if branch setting is ModuleStoreEnum.Branch.draft_preferred, checks whether draft or published item exists  # lint-amnesty, pylint: disable=line-too-long
         """
-        def has_published():
-            return super(DraftModuleStore, self).has_item(usage_key)  # lint-amnesty, pylint: disable=super-with-arguments
-
-        def has_draft():
-            return super(DraftModuleStore, self).has_item(as_draft(usage_key))  # lint-amnesty, pylint: disable=super-with-arguments
-
-        if revision == ModuleStoreEnum.RevisionOption.draft_only:
-            return has_draft()
-        elif (
-                revision == ModuleStoreEnum.RevisionOption.published_only or
-                self.get_branch_setting() == ModuleStoreEnum.Branch.published_only
-        ):
-            return has_published()
-        elif revision is None:
-            key = usage_key.to_deprecated_son(prefix='_id.')
-            del key['_id.revision']
-            return self.collection.count_documents(key) > 0
-        else:
-            raise UnsupportedRevisionError()
+        return False
 
     def delete_course(self, course_key, user_id):  # lint-amnesty, pylint: disable=arguments-differ
         """
@@ -180,83 +152,18 @@ def delete_course(self, course_key, user_id):  # lint-amnesty, pylint: disable=a
 
         self._emit_course_deleted_signal(course_key)
 
-    def clone_course(self, source_course_id, dest_course_id, user_id, fields=None, **kwargs):
+    def clone_course(self, source_course_id, dest_course_id, user_id, fields=None, **kwargs):  # lint-amnesty, pylint: disable=unused-argument
         """
         Only called if cloning within this store or if env doesn't set up mixed.
         * copy the courseware
         """
-        # check to see if the source course is actually there
-        if not self.has_course(source_course_id):
-            raise ItemNotFoundError(f"Cannot find a course at {source_course_id}. Aborting")
-
-        with self.bulk_operations(dest_course_id):
-            # verify that the dest_location really is an empty course
-            # b/c we don't want the payload, I'm copying the guts of get_items here
-            query = self._course_key_to_son(dest_course_id)
-            query['_id.category'] = {'$nin': ['course', 'about']}
-            if self.collection.count_documents(query, limit=1) > 0:
-                raise DuplicateCourseError(
-                    dest_course_id,
-                    "Course at destination {} is not an empty course. "
-                    "You can only clone into an empty course. Aborting...".format(
-                        dest_course_id
-                    )
-                )
-
-            # clone the assets
-            super().clone_course(source_course_id, dest_course_id, user_id, fields)  # lint-amnesty, pylint: disable=super-with-arguments
-
-            # get the whole old course
-            new_course = self.get_course(dest_course_id)
-            if new_course is None:
-                # create_course creates the about overview
-                new_course = self.create_course(
-                    dest_course_id.org, dest_course_id.course, dest_course_id.run, user_id, fields=fields
-                )
-            else:
-                # update fields on existing course
-                for key, value in fields.items():
-                    setattr(new_course, key, value)
-                self.update_item(new_course, user_id)
-
-            # Get all modules under this namespace which is (tag, org, course) tuple
-            modules = self.get_items(source_course_id, revision=ModuleStoreEnum.RevisionOption.published_only)
-            self._clone_modules(modules, dest_course_id, user_id)
-            course_location = dest_course_id.make_usage_key('course', dest_course_id.run)
-            self.publish(course_location, user_id)
-
-            modules = self.get_items(source_course_id, revision=ModuleStoreEnum.RevisionOption.draft_only)
-            self._clone_modules(modules, dest_course_id, user_id)
-
-            return True
-
-    def _clone_modules(self, modules, dest_course_id, user_id):
-        """Clones each module into the given course"""
-        for module in modules:
-            original_loc = module.location
-            module.location = module.location.map_into_course(dest_course_id)
-            if module.location.block_type == 'course':
-                module.location = module.location.replace(name=module.location.run)
+        raise NotImplementedError
 
-            log.info("Cloning module %s to %s....", original_loc, module.location)
-
-            if 'data' in module.fields and module.fields['data'].is_set_on(module) and isinstance(module.data, str):  # lint-amnesty, pylint: disable=line-too-long
-                module.data = rewrite_nonportable_content_links(
-                    original_loc.course_key, dest_course_id, module.data
-                )
-
-            # repoint children
-            if module.has_children:
-                new_children = []
-                for child_loc in module.children:
-                    child_loc = child_loc.map_into_course(dest_course_id)
-                    new_children.append(child_loc)
-
-                module.children = new_children
-
-            self.update_item(module, user_id, allow_not_found=True)
+    def _clone_modules(self, modules, dest_course_id, user_id):  # lint-amnesty, pylint: disable=unused-argument
+        """Clones each module into the given course"""
+        raise NotImplementedError
 
-    def _get_raw_parent_locations(self, location, key_revision):
+    def _get_raw_parent_locations(self, location, key_revision):  # lint-amnesty, pylint: disable=unused-argument
         """
         Get the parents but don't unset the revision in their locations.
 
@@ -269,30 +176,9 @@ def _get_raw_parent_locations(self, location, key_revision):
                 MongoRevisionKey.published - return only the published parent
                 ModuleStoreEnum.RevisionOption.all - return both draft and published parents
         """
-        _verify_revision_is_published(location)
-
-        # create a query to find all items in the course that have the given location listed as a child
-        query = self._course_key_to_son(location.course_key)
-        query['definition.children'] = str(location)
-
-        # find all the items that satisfy the query
-        parents = self.collection.find(query, {'_id': True}, sort=[SORT_REVISION_FAVOR_DRAFT])
-
-        # return only the parent(s) that satisfy the request
-        return [
-            BlockUsageLocator._from_deprecated_son(parent['_id'], location.course_key.run)  # lint-amnesty, pylint: disable=protected-access
-            for parent in parents
-            if (
-                # return all versions of the parent if revision is ModuleStoreEnum.RevisionOption.all
-                key_revision == ModuleStoreEnum.RevisionOption.all or
-                # return this parent if it's direct-only, regardless of which revision is requested
-                parent['_id']['category'] in DIRECT_ONLY_CATEGORIES or
-                # return this parent only if its revision matches the requested one
-                parent['_id']['revision'] == key_revision
-            )
-        ]
-
-    def get_parent_location(self, location, revision=None, **kwargs):
+        raise NotImplementedError
+
+    def get_parent_location(self, location, revision=None, **kwargs):  # lint-amnesty, pylint: disable=unused-argument
         '''
         Returns the given location's parent location in this course.
 
@@ -313,11 +199,7 @@ def get_parent_location(self, location, revision=None, **kwargs):
                     is not DIRECT_ONLY, then the parent revision must be DRAFT.
                     Only xml_exporter currently uses this argument. Others should avoid it.
         '''
-        if revision is None:
-            revision = ModuleStoreEnum.RevisionOption.published_only \
-                if self.get_branch_setting() == ModuleStoreEnum.Branch.published_only \
-                else ModuleStoreEnum.RevisionOption.draft_preferred
-        return super().get_parent_location(location, revision, **kwargs)  # lint-amnesty, pylint: disable=super-with-arguments
+        raise NotImplementedError
 
     def create_xblock(self, runtime, course_key, block_type, block_id=None, fields=None, **kwargs):  # lint-amnesty, pylint: disable=arguments-differ
         """
@@ -330,11 +212,7 @@ def create_xblock(self, runtime, course_key, block_type, block_id=None, fields=N
         :param runtime: if you already have an xmodule from the course, the xmodule.runtime value
         :param fields: a dictionary of field names and values for the new xmodule
         """
-        new_block = super().create_xblock(  # lint-amnesty, pylint: disable=super-with-arguments
-            runtime, course_key, block_type, block_id, fields, **kwargs
-        )
-        new_block.location = self.for_branch_setting(new_block.location)
-        return wrap_draft(new_block)
+        raise NotImplementedError
 
     def get_items(self, course_key, revision=None, **kwargs):  # lint-amnesty, pylint: disable=arguments-differ
         """
@@ -383,7 +261,7 @@ def published_items(draft_items):
         else:
             raise UnsupportedRevisionError()
 
-    def convert_to_draft(self, location, user_id):
+    def convert_to_draft(self, location, user_id):  # lint-amnesty, pylint: disable=unused-argument
         """
         Copy the subtree rooted at source_location and mark the copies as draft.
 
@@ -395,14 +273,7 @@ def convert_to_draft(self, location, user_id):
             InvalidVersionError: if the source can not be made into a draft
             ItemNotFoundError: if the source does not exist
         """
-        # TODO (dhm) I don't think this needs to recurse anymore but can convert each unit on demand.
-        #     See if that's true.
-        # delegating to internal b/c we don't want any public user to use the kwargs on the internal
-        self._convert_to_draft(location, user_id, ignore_if_draft=True)
-
-        # return the new draft item (does another fetch)
-        # get_item will wrap_draft so don't call it here (otherwise, it would override the is_draft attribute)
-        return self.get_item(location)
+        raise NotImplementedError
 
     def _convert_to_draft(self, location, user_id, delete_published=False, ignore_if_draft=False):  # lint-amnesty, pylint: disable=unused-argument
         """
@@ -420,46 +291,7 @@ def _convert_to_draft(self, location, user_id, delete_published=False, ignore_if
             DuplicateItemError: if the source or any of its descendants already has a draft copy. Only
                 useful for unpublish b/c we don't want unpublish to overwrite any existing drafts.
         """
-        # verify input conditions: can only convert to draft branch; so, verify that's the setting
-        self._verify_branch_setting(ModuleStoreEnum.Branch.draft_preferred)
-        _verify_revision_is_published(location)
-
-        # ensure we are not creating a DRAFT of an item that is direct-only
-        if location.block_type in DIRECT_ONLY_CATEGORIES:
-            raise InvalidVersionError(location)
-
-        def convert_item(item, to_be_deleted):
-            """
-            Convert the subtree
-            """
-            # collect the children's ids for future processing
-            next_tier = []
-            for child in item.get('definition', {}).get('children', []):
-                child_loc = BlockUsageLocator.from_string(child)
-                next_tier.append(child_loc.to_deprecated_son())
-
-            # insert a new DRAFT version of the item
-            item['_id']['revision'] = MongoRevisionKey.draft
-            # ensure keys are in fixed and right order before inserting
-            item['_id'] = self._id_dict_to_son(item['_id'])
-            bulk_record = self._get_bulk_ops_record(location.course_key)
-            bulk_record.dirty = True
-            try:
-                self.collection.insert_one(item)
-            except pymongo.errors.DuplicateKeyError:
-                # prevent re-creation of DRAFT versions, unless explicitly requested to ignore
-                if not ignore_if_draft:
-                    raise DuplicateItemError(item['_id'], self, 'collection')  # lint-amnesty, pylint: disable=raise-missing-from
-
-            # delete the old PUBLISHED version if requested
-            if delete_published:
-                item['_id']['revision'] = MongoRevisionKey.published
-                to_be_deleted.append(item['_id'])
-
-            return next_tier
-
-        # convert the subtree using the original item as the root
-        self._breadth_first(convert_item, [location])
+        raise NotImplementedError
 
     def update_item(  # lint-amnesty, pylint: disable=arguments-differ
             self,  # lint-amnesty, pylint: disable=unused-argument
@@ -475,30 +307,7 @@ def update_item(  # lint-amnesty, pylint: disable=arguments-differ
         In addition to the superclass's behavior, this method converts the unit to draft if it's not
         direct-only and not already draft.
         """
-        draft_loc = self.for_branch_setting(xblock.location)
-
-        # if the revision is published, defer to base
-        if draft_loc.branch == MongoRevisionKey.published:
-            item = super().update_item(xblock, user_id, allow_not_found)  # lint-amnesty, pylint: disable=super-with-arguments
-            course_key = xblock.location.course_key
-            if isPublish or (item.category in DIRECT_ONLY_CATEGORIES and not child_update):
-                self._flag_publish_event(course_key)
-            return item
-
-        if not super().has_item(draft_loc):  # lint-amnesty, pylint: disable=super-with-arguments
-            try:
-                # ignore any descendants which are already draft
-                self._convert_to_draft(xblock.location, user_id, ignore_if_draft=True)
-            except ItemNotFoundError as exception:
-                # ignore the exception only if allow_not_found is True and
-                # the item that wasn't found is the one that was passed in
-                # we make this extra location check so we do not hide errors when converting any children to draft
-                if not (allow_not_found and exception.args[0] == xblock.location):
-                    raise
-
-        xblock.location = draft_loc
-        super().update_item(xblock, user_id, allow_not_found, isPublish=isPublish)  # lint-amnesty, pylint: disable=super-with-arguments
-        return wrap_draft(xblock)
+        raise NotImplementedError
 
     def delete_item(self, location, user_id, revision=None, **kwargs):  # lint-amnesty, pylint: disable=arguments-differ
         """
@@ -523,103 +332,15 @@ def delete_item(self, location, user_id, revision=None, **kwargs):  # lint-amnes
                     currently only provided by contentstore.views.item.orphan_handler
                 Otherwise, raises a ValueError.
         """
-        self._verify_branch_setting(ModuleStoreEnum.Branch.draft_preferred)
-        _verify_revision_is_published(location)
-
-        is_item_direct_only = location.block_type in DIRECT_ONLY_CATEGORIES
-        if is_item_direct_only or revision == ModuleStoreEnum.RevisionOption.published_only:
-            parent_revision = MongoRevisionKey.published
-        elif revision == ModuleStoreEnum.RevisionOption.all:
-            parent_revision = ModuleStoreEnum.RevisionOption.all
-        else:
-            parent_revision = MongoRevisionKey.draft
-
-        # remove subtree from its parent
-        parent_locations = self._get_raw_parent_locations(location, key_revision=parent_revision)
-        # if no parents, then we're trying to delete something which we should convert to draft
-        if not parent_locations:
-            # find the published parent, convert it to draft, then manipulate the draft
-            parent_locations = self._get_raw_parent_locations(location, key_revision=MongoRevisionKey.published)
-            # parent_locations will still be empty if the object was an orphan
-            if parent_locations:
-                draft_parent = self.convert_to_draft(parent_locations[0], user_id)
-                parent_locations = [draft_parent.location]
-        # there could be 2 parents if
-        #   Case 1: the draft item moved from one parent to another
-        # Case 2: revision==ModuleStoreEnum.RevisionOption.all and the single
-        # parent has 2 versions: draft and published
-        for parent_location in parent_locations:
-            # don't remove from direct_only parent if other versions of this still exists (this code
-            # assumes that there's only one parent_location in this case)
-            if not is_item_direct_only and parent_location.block_type in DIRECT_ONLY_CATEGORIES:
-                # see if other version of to-be-deleted root exists
-                query = location.to_deprecated_son(prefix='_id.')
-                del query['_id.revision']
-                if self.collection.count_documents(query) > 1:
-                    continue
-
-            parent_block = super().get_item(parent_location)  # lint-amnesty, pylint: disable=super-with-arguments
-            parent_block.children.remove(location)
-            parent_block.location = parent_location  # ensure the location is with the correct revision
-            self.update_item(parent_block, user_id, child_update=True)
-        self._flag_publish_event(location.course_key)
-
-        if is_item_direct_only or revision == ModuleStoreEnum.RevisionOption.all:
-            as_functions = [as_draft, as_published]
-        elif revision == ModuleStoreEnum.RevisionOption.published_only:
-            as_functions = [as_published]
-        elif revision is None:
-            as_functions = [as_draft]
-        else:
-            raise UnsupportedRevisionError(
-                [
-                    None,
-                    ModuleStoreEnum.RevisionOption.published_only,
-                    ModuleStoreEnum.RevisionOption.all
-                ]
-            )
-        self._delete_subtree(location, as_functions)
+        raise NotImplementedError
 
-    def _delete_subtree(self, location, as_functions, draft_only=False):
+    def _delete_subtree(self, location, as_functions, draft_only=False):  # lint-amnesty, pylint: disable=unused-argument
         """
         Internal method for deleting all of the subtree whose revisions match the as_functions
         """
-        course_key = location.course_key
-
-        def _delete_item(current_entry, to_be_deleted):
-            """
-            Depth first deletion of nodes
-            """
-            to_be_deleted.append(self._id_dict_to_son(current_entry['_id']))
-            next_tier = []
-            for child_loc in current_entry.get('definition', {}).get('children', []):
-                child_loc = UsageKey.from_string(child_loc).map_into_course(course_key)
-
-                # single parent can have 2 versions: draft and published
-                # get draft parents only while deleting draft module
-                if draft_only:
-                    revision = MongoRevisionKey.draft
-                else:
-                    revision = ModuleStoreEnum.RevisionOption.all
-
-                parents = self._get_raw_parent_locations(child_loc, revision)
-                # Don't delete modules if one of its parents shouldn't be deleted
-                # This should only be an issue for courses have ended up in
-                # a state where modules have multiple parents
-                if all(parent.to_deprecated_son() in to_be_deleted for parent in parents):
-                    for rev_func in as_functions:
-                        current_loc = rev_func(child_loc)
-                        current_son = current_loc.to_deprecated_son()
-                        next_tier.append(current_son)
-
-            return next_tier
-
-        first_tier = [as_func(location) for as_func in as_functions]
-        self._breadth_first(_delete_item, first_tier)
-        # recompute (and update) the metadata inheritance tree which is cached
-        self.refresh_cached_metadata_inheritance_tree(location.course_key)
-
-    def _breadth_first(self, function, root_usages):
+        raise NotImplementedError
+
+    def _breadth_first(self, function, root_usages):  # lint-amnesty, pylint: disable=unused-argument
         """
         Get the root_usage from the db and do a depth first scan. Call the function on each. The
         function should return a list of SON for any next tier items to process and should
@@ -631,33 +352,16 @@ def _breadth_first(self, function, root_usages):
         :param function: a function taking (item, to_be_deleted) and returning [SON] for next_tier invocation
         :param root_usages: the usage keys for the root items (ensure they have the right revision set)
         """
-        if len(root_usages) == 0:
-            return
-        to_be_deleted = []
+        raise NotImplementedError
 
-        def _internal(tier):
-            next_tier = []
-            tier_items = self.collection.find({'_id': {'$in': tier}})
-            for current_entry in tier_items:
-                next_tier.extend(function(current_entry, to_be_deleted))
-
-            if len(next_tier) > 0:
-                _internal(next_tier)
-
-        _internal([root_usage.to_deprecated_son() for root_usage in root_usages])
-        if len(to_be_deleted) > 0:
-            bulk_record = self._get_bulk_ops_record(root_usages[0].course_key)
-            bulk_record.dirty = True
-            self.collection.delete_many({'_id': {'$in': to_be_deleted}})
-
-    def has_changes(self, xblock):
+    def has_changes(self, xblock):  # lint-amnesty, pylint: disable=unused-argument
         """
         Check if the subtree rooted at xblock has any drafts and thus may possibly have changes
         :param xblock: xblock to check
         :return: True if there are any drafts anywhere in the subtree under xblock (a weaker
             condition than for other stores)
         """
-        return self._cached_has_changes(self.request_cache, xblock)
+        raise NotImplementedError
 
     @request_cached(
         # use the XBlock's location value in the cache key
@@ -669,18 +373,7 @@ def _cached_has_changes(self, request_cache, xblock):  # lint-amnesty, pylint: d
         """
         Internal has_changes method that caches the result.
         """
-        # don't check children if this block has changes (is not public)
-        if getattr(xblock, 'is_draft', False):
-            return True
-        # if this block doesn't have changes, then check its children
-        elif xblock.has_children:
-            # fix a bug where dangling pointers should imply a change
-            if len(xblock.children) > len(xblock.get_children()):
-                return True
-            return any(self.has_changes(child) for child in xblock.get_children())
-        # otherwise there are no changes
-        else:
-            return False
+        raise NotImplementedError
 
     def publish(self, location, user_id, **kwargs):  # lint-amnesty, pylint: disable=unused-argument
         """
@@ -697,77 +390,7 @@ def publish(self, location, user_id, **kwargs):  # lint-amnesty, pylint: disable
         Returns:
             The newly published xblock
         """
-        # NOTE: cannot easily use self._breadth_first b/c need to get pub'd and draft as pairs
-        # (could do it by having 2 breadth first scans, the first to just get all published children
-        # and the second to do the publishing on the drafts looking for the published in the cached
-        # list of published ones.)
-        to_be_deleted = []
-
-        def _internal_depth_first(item_location, is_root):
-            """
-            Depth first publishing from the given location
-            """
-            try:
-                # handle child does not exist w/o killing publish
-                item = self.get_item(item_location)
-            except ItemNotFoundError:
-                log.warning('Cannot find: %s', item_location)
-                return
-
-            # publish the children first
-            if item.has_children:
-                for child_loc in item.children:
-                    _internal_depth_first(child_loc, False)
-
-            if item_location.block_type in DIRECT_ONLY_CATEGORIES or not getattr(item, 'is_draft', False):
-                # ignore noop attempt to publish something that can't be or isn't currently draft
-                return
-
-            # try to find the originally PUBLISHED version, if it exists
-            try:
-                original_published = super(DraftModuleStore, self).get_item(item_location)  # lint-amnesty, pylint: disable=super-with-arguments
-            except ItemNotFoundError:
-                original_published = None
-
-            # if the category of this item allows having children
-            if item.has_children:
-                if original_published is not None:
-                    # see if previously published children were deleted. 2 reasons for children lists to differ:
-                    #   Case 1: child deleted
-                    #   Case 2: child moved
-                    for orig_child in original_published.children:
-                        if orig_child not in item.children:
-                            published_parent = self.get_parent_location(orig_child)
-                            if published_parent == item_location:
-                                # Case 1: child was deleted in draft parent item
-                                # So, delete published version of the child now that we're publishing the draft parent
-                                self._delete_subtree(orig_child, [as_published])
-                            else:
-                                # Case 2: child was moved to a new draft parent item
-                                # So, do not delete the child.  It will be published when the new parent is published.
-                                pass
-
-            # update the published (not draft) item (ignoring that item is "draft"). The published
-            # may not exist; (if original_published is None); so, allow_not_found
-            super(DraftModuleStore, self).update_item(  # lint-amnesty, pylint: disable=super-with-arguments
-                item, user_id, isPublish=True, is_publish_root=is_root, allow_not_found=True
-            )
-            to_be_deleted.append(as_draft(item_location).to_deprecated_son())
-
-        # verify input conditions
-        self._verify_branch_setting(ModuleStoreEnum.Branch.draft_preferred)
-        _verify_revision_is_published(location)
-
-        _internal_depth_first(location, True)
-        course_key = location.course_key
-        bulk_record = self._get_bulk_ops_record(course_key)
-        if len(to_be_deleted) > 0:
-            bulk_record.dirty = True
-            self.collection.delete_many({'_id': {'$in': to_be_deleted}})
-
-        self._flag_publish_event(course_key)
-
-        return self.get_item(as_published(location))
+        raise NotImplementedError
 
     def unpublish(self, location, user_id, **kwargs):  # lint-amnesty, pylint: disable=unused-argument
         """
@@ -776,17 +399,9 @@ def unpublish(self, location, user_id, **kwargs):  # lint-amnesty, pylint: disab
         NOTE: unlike publish, this gives an error if called above the draftable level as it's intended
         to remove things from the published version
         """
-        # ensure we are not creating a DRAFT of an item that is direct-only
-        if location.block_type in DIRECT_ONLY_CATEGORIES:
-            raise InvalidVersionError(location)
-
-        self._verify_branch_setting(ModuleStoreEnum.Branch.draft_preferred)
-        self._convert_to_draft(location, user_id, delete_published=True)
+        raise NotImplementedError
 
-        course_key = location.course_key
-        self._flag_publish_event(course_key)
-
-    def revert_to_published(self, location, user_id=None):
+    def revert_to_published(self, location, user_id=None):  # lint-amnesty, pylint: disable=unused-argument
         """
         Reverts an item to its last published version (recursively traversing all of its descendants).
         If no published version exists, an InvalidVersionError is thrown.
@@ -796,52 +411,9 @@ def revert_to_published(self, location, user_id=None):
 
         :raises InvalidVersionError: if no published version exists for the location specified
         """
-        self._verify_branch_setting(ModuleStoreEnum.Branch.draft_preferred)
-        _verify_revision_is_published(location)
-
-        if location.block_type in DIRECT_ONLY_CATEGORIES:
-            return
-
-        if not self.has_item(location, revision=ModuleStoreEnum.RevisionOption.published_only):
-            raise InvalidVersionError(location)
-
-        def delete_draft_only(root_location):
-            """
-            Helper function that calls delete on the specified location if a draft version of the item exists.
-            If no draft exists, this function recursively calls itself on the children of the item.
-            """
-            query = root_location.to_deprecated_son(prefix='_id.')
-            del query['_id.revision']
-            versions_found = self.collection.find(
-                query, {'_id': True, 'definition.children': True}, sort=[SORT_REVISION_FAVOR_DRAFT]
-            )
-            versions_found = list(versions_found)
-            # If 2 versions versions exist, we can assume one is a published version. Go ahead and do the delete
-            # of the draft version.
-            if len(versions_found) > 1:
-                # Moving a child from published parent creates a draft of the parent and moved child.
-                published_version = [
-                    version
-                    for version in versions_found
-                    if version.get('_id').get('revision') != MongoRevisionKey.draft
-                ]
-                if len(published_version) > 0:
-                    # This change makes sure that parents are updated too i.e. an item will have only one parent.
-                    self.update_parent_if_moved(root_location, published_version[0], delete_draft_only, user_id)
-                self._delete_subtree(root_location, [as_draft], draft_only=True)
-            elif len(versions_found) == 1:
-                # Since this method cannot be called on something in DIRECT_ONLY_CATEGORIES and we call
-                # delete_subtree as soon as we find an item with a draft version, if there is only 1 version
-                # it must be published (since adding a child to a published item creates a draft of the parent).
-                item = versions_found[0]
-                assert item.get('_id').get('revision') != MongoRevisionKey.draft
-                for child in item.get('definition', {}).get('children', []):
-                    child_loc = BlockUsageLocator.from_string(child)
-                    delete_draft_only(child_loc)
-
-        delete_draft_only(location)
-
-    def update_parent_if_moved(self, original_parent_location, published_version, delete_draft_only, user_id):
+        raise NotImplementedError
+
+    def update_parent_if_moved(self, original_parent_location, published_version, delete_draft_only, user_id):  # lint-amnesty, pylint: disable=unused-argument
         """
         Update parent of an item if it has moved.
 
@@ -851,81 +423,21 @@ def update_parent_if_moved(self, original_parent_location, published_version, de
             delete_draft_only (function)    : A callback function to delete draft children if it was moved.
             user_id (int)   : User id
         """
-        for child_location in published_version.get('definition', {}).get('children', []):
-            item_location = UsageKey.from_string(child_location).map_into_course(original_parent_location.course_key)
-            try:
-                source_item = self.get_item(item_location)
-            except ItemNotFoundError:
-                log.error('Unable to find the item %s', str(item_location))
-                return
-
-            if source_item.parent and source_item.parent.block_id != original_parent_location.block_id:
-                if self.update_item_parent(item_location, original_parent_location, source_item.parent, user_id):
-                    delete_draft_only(BlockUsageLocator.from_string(child_location))
+        raise NotImplementedError
 
-    def _query_children_for_cache_children(self, course_key, items):
+    def _query_children_for_cache_children(self, course_key, items):  # lint-amnesty, pylint: disable=unused-argument
         # first get non-draft in a round-trip
-        to_process_non_drafts = super()._query_children_for_cache_children(course_key, items)  # lint-amnesty, pylint: disable=super-with-arguments
-
-        to_process_dict = {}
-        for non_draft in to_process_non_drafts:
-            to_process_dict[BlockUsageLocator._from_deprecated_son(non_draft["_id"], course_key.run)] = non_draft  # lint-amnesty, pylint: disable=protected-access
-
-        if self.get_branch_setting() == ModuleStoreEnum.Branch.draft_preferred:
-            # now query all draft content in another round-trip
-            query = []
-            for item in items:
-                item_usage_key = UsageKey.from_string(item).map_into_course(course_key)
-                if item_usage_key.block_type not in DIRECT_ONLY_CATEGORIES:
-                    query.append(as_draft(item_usage_key).to_deprecated_son())
-            if query:
-                query = {'_id': {'$in': query}}
-                to_process_drafts = list(self.collection.find(query))
-
-                # now we have to go through all drafts and replace the non-draft
-                # with the draft. This is because the semantics of the DraftStore is to
-                # always return the draft - if available
-                for draft in to_process_drafts:
-                    draft_loc = BlockUsageLocator._from_deprecated_son(draft["_id"], course_key.run)  # lint-amnesty, pylint: disable=protected-access
-                    draft_as_non_draft_loc = as_published(draft_loc)
-
-                    # does non-draft exist in the collection
-                    # if so, replace it
-                    if draft_as_non_draft_loc in to_process_dict:
-                        to_process_dict[draft_as_non_draft_loc] = draft
-
-        # convert the dict - which is used for look ups - back into a list
-        queried_children = list(to_process_dict.values())
-
-        return queried_children
-
-    def has_published_version(self, xblock):
+        raise NotImplementedError
+
+    def has_published_version(self, xblock):  # lint-amnesty, pylint: disable=unused-argument
         """
         Returns True if this xblock has an existing published version regardless of whether the
         published version is up to date.
         """
-        if getattr(xblock, 'is_draft', False):
-            published_xblock_location = as_published(xblock.location)
-            try:
-                xblock.runtime.lookup_item(published_xblock_location)
-            except ItemNotFoundError:
-                return False
-        return True
+        raise NotImplementedError
 
-    def _verify_branch_setting(self, expected_branch_setting):
+    def _verify_branch_setting(self, expected_branch_setting):  # lint-amnesty, pylint: disable=unused-argument
         """
         Raises an exception if the current branch setting does not match the expected branch setting.
         """
-        actual_branch_setting = self.get_branch_setting()
-        if actual_branch_setting != expected_branch_setting:
-            raise InvalidBranchSetting(
-                expected_setting=expected_branch_setting,
-                actual_setting=actual_branch_setting
-            )
-
-
-def _verify_revision_is_published(location):
-    """
-    Asserts that the revision set on the given location is MongoRevisionKey.published
-    """
-    assert location.branch == MongoRevisionKey.published
+        raise NotImplementedError
diff --git a/xmodule/modulestore/split_migrator.py b/xmodule/modulestore/split_migrator.py
deleted file mode 100644
index c773648bbbad..000000000000
--- a/xmodule/modulestore/split_migrator.py
+++ /dev/null
@@ -1,231 +0,0 @@
-'''
-Code for migrating from other modulestores to the split_mongo modulestore.
-
-Exists at the top level of modulestore b/c it needs to know about and access each modulestore.
-
-In general, it's strategy is to treat the other modulestores as read-only and to never directly
-manipulate storage but use existing api's.
-'''
-
-
-import logging
-
-from opaque_keys.edx.locator import CourseLocator
-from xblock.fields import Reference, ReferenceList, ReferenceValueDict
-
-from xmodule.modulestore import ModuleStoreEnum
-from xmodule.modulestore.exceptions import ItemNotFoundError
-
-log = logging.getLogger(__name__)
-
-
-class SplitMigrator:
-    """
-    Copies courses from old mongo to split mongo and sets up location mapping so any references to the old
-    name will be able to find the new elements.
-    """
-    def __init__(self, split_modulestore, source_modulestore):
-        super().__init__()
-        self.split_modulestore = split_modulestore
-        self.source_modulestore = source_modulestore
-
-    def migrate_mongo_course(
-            self, source_course_key, user_id, new_org=None, new_course=None, new_run=None, fields=None, **kwargs
-    ):
-        """
-        Create a new course in split_mongo representing the published and draft versions of the course from the
-        original mongo store. And return the new CourseLocator
-
-        If the new course already exists, this raises DuplicateItemError
-
-        :param source_course_key: which course to migrate
-        :param user_id: the user whose action is causing this migration
-        :param new_org, new_course, new_run: (optional) identifiers for the new course. Defaults to
-            the source_course_key's values.
-        """
-        # the only difference in data between the old and split_mongo xblocks are the locations;
-        # so, any field which holds a location must change to a Locator; otherwise, the persistence
-        # layer and kvs's know how to store it.
-        # locations are in location, children, conditionals, course.tab
-
-        # create the course: set fields to explicitly_set for each scope, id_root = new_course_locator, master_branch = 'production'  # lint-amnesty, pylint: disable=line-too-long
-        original_course = self.source_modulestore.get_course(source_course_key, **kwargs)
-        if original_course is None:
-            raise ItemNotFoundError(str(source_course_key))
-
-        if new_org is None:
-            new_org = source_course_key.org
-        if new_course is None:
-            new_course = source_course_key.course
-        if new_run is None:
-            new_run = source_course_key.run
-
-        new_course_key = CourseLocator(new_org, new_course, new_run, branch=ModuleStoreEnum.BranchName.published)
-        with self.split_modulestore.bulk_operations(new_course_key):
-            new_fields = self._get_fields_translate_references(original_course, new_course_key, None)
-            if fields:
-                new_fields.update(fields)
-            new_course = self.split_modulestore.create_course(
-                new_org, new_course, new_run, user_id,
-                fields=new_fields,
-                master_branch=ModuleStoreEnum.BranchName.published,
-                skip_auto_publish=True,
-                **kwargs
-            )
-
-            self._copy_published_modules_to_course(
-                new_course, original_course.location, source_course_key, user_id, **kwargs
-            )
-
-        # TODO: This should be merged back into the above transaction, but can't be until split.py
-        # is refactored to have more coherent access patterns
-        with self.split_modulestore.bulk_operations(new_course_key):
-
-            # create a new version for the drafts
-            self._add_draft_modules_to_course(new_course.location, source_course_key, user_id, **kwargs)
-
-        return new_course.id
-
-    def _copy_published_modules_to_course(self, new_course, old_course_loc, source_course_key, user_id, **kwargs):
-        """
-        Copy all of the modules from the 'direct' version of the course to the new split course.
-        """
-        course_version_locator = new_course.id.version_agnostic()
-
-        # iterate over published course elements. Wildcarding rather than descending b/c some elements are orphaned (e.g.,  # lint-amnesty, pylint: disable=line-too-long
-        # course about pages, conditionals)
-        for module in self.source_modulestore.get_items(
-            source_course_key, revision=ModuleStoreEnum.RevisionOption.published_only, **kwargs
-        ):
-            # don't copy the course again.
-            if module.location != old_course_loc:
-                # create split_xblock using split.create_item
-                # NOTE: the below auto populates the children when it migrates the parent; so,
-                # it doesn't need the parent as the first arg. That is, it translates and populates
-                # the 'children' field as it goes.
-                _new_module = self.split_modulestore.create_item(
-                    user_id,
-                    course_version_locator,
-                    module.location.block_type,
-                    block_id=module.location.block_id,
-                    fields=self._get_fields_translate_references(
-                        module, course_version_locator, new_course.location.block_id
-                    ),
-                    skip_auto_publish=True,
-                    **kwargs
-                )
-        # after done w/ published items, add version for DRAFT pointing to the published structure
-        index_info = self.split_modulestore.get_course_index_info(course_version_locator)
-        versions = index_info['versions']
-        versions[ModuleStoreEnum.BranchName.draft] = versions[ModuleStoreEnum.BranchName.published]
-        self.split_modulestore.update_course_index(course_version_locator, index_info)
-
-        # clean up orphans in published version: in old mongo, parents pointed to the union of their published and draft
-        # children which meant some pointers were to non-existent locations in 'direct'
-        self.split_modulestore.fix_not_found(course_version_locator, user_id)
-
-    def _add_draft_modules_to_course(self, published_course_usage_key, source_course_key, user_id, **kwargs):
-        """
-        update each draft. Create any which don't exist in published and attach to their parents.
-        """
-        # each true update below will trigger a new version of the structure. We may want to just have one new version
-        # but that's for a later date.
-        new_draft_course_loc = published_course_usage_key.course_key.for_branch(ModuleStoreEnum.BranchName.draft)
-        # to prevent race conditions of grandchilden being added before their parents and thus having no parent to
-        # add to
-        awaiting_adoption = {}
-        for module in self.source_modulestore.get_items(
-                source_course_key, revision=ModuleStoreEnum.RevisionOption.draft_only, **kwargs
-        ):
-            new_locator = new_draft_course_loc.make_usage_key(module.category, module.location.block_id)
-            if self.split_modulestore.has_item(new_locator):
-                # was in 'direct' so draft is a new version
-                split_module = self.split_modulestore.get_item(new_locator, **kwargs)
-                # need to remove any no-longer-explicitly-set values and add/update any now set values.
-                for name, field in split_module.fields.items():
-                    if field.is_set_on(split_module) and not module.fields[name].is_set_on(module):
-                        field.delete_from(split_module)
-                for field, value in self._get_fields_translate_references(
-                        module, new_draft_course_loc, published_course_usage_key.block_id, field_names=False
-                ).items():
-                    field.write_to(split_module, value)
-
-                _new_module = self.split_modulestore.update_item(split_module, user_id, **kwargs)
-            else:
-                # only a draft version (aka, 'private').
-                _new_module = self.split_modulestore.create_item(
-                    user_id, new_draft_course_loc,
-                    new_locator.block_type,
-                    block_id=new_locator.block_id,
-                    fields=self._get_fields_translate_references(
-                        module, new_draft_course_loc, published_course_usage_key.block_id
-                    ),
-                    **kwargs
-                )
-                awaiting_adoption[module.location] = new_locator
-        for draft_location, new_locator in awaiting_adoption.items():
-            parent_loc = self.source_modulestore.get_parent_location(
-                draft_location, revision=ModuleStoreEnum.RevisionOption.draft_preferred, **kwargs
-            )
-            if parent_loc is None:
-                log.warning('No parent found in source course for %s', draft_location)
-                continue
-            old_parent = self.source_modulestore.get_item(parent_loc, **kwargs)
-            split_parent_loc = new_draft_course_loc.make_usage_key(
-                parent_loc.block_type,
-                parent_loc.block_id if parent_loc.block_type != 'course' else published_course_usage_key.block_id
-            )
-            new_parent = self.split_modulestore.get_item(split_parent_loc, **kwargs)
-            # this only occurs if the parent was also awaiting adoption: skip this one, go to next
-            if any(new_locator.block_id == child.block_id for child in new_parent.children):
-                continue
-            # find index for module: new_parent may be missing quite a few of old_parent's children
-            new_parent_cursor = 0
-            for old_child_loc in old_parent.children:
-                if old_child_loc.block_id == draft_location.block_id:
-                    break  # moved cursor enough, insert it here
-                # sibling may move cursor
-                for idx in range(new_parent_cursor, len(new_parent.children)):
-                    if new_parent.children[idx].block_id == old_child_loc.block_id:
-                        new_parent_cursor = idx + 1
-                        break  # skipped sibs enough, pick back up scan
-            new_parent.children.insert(new_parent_cursor, new_locator)
-            new_parent = self.split_modulestore.update_item(new_parent, user_id)
-
-    def _get_fields_translate_references(self, xblock, new_course_key, course_block_id, field_names=True):
-        """
-        Return a dictionary of field: value pairs for explicitly set fields
-        but convert all references to their BlockUsageLocators
-        Args:
-            field_names: if Truthy, the dictionary keys are the field names. If falsey, the keys are the
-            field objects.
-        """
-        def get_translation(location):
-            """
-            Convert the location
-            """
-            return new_course_key.make_usage_key(
-                location.block_type,
-                location.block_id if location.block_type != 'course' else course_block_id
-            )
-
-        result = {}
-        for field_name, field in xblock.fields.items():
-            if field.is_set_on(xblock):
-                field_value = field.read_from(xblock)
-                field_key = field_name if field_names else field
-                if isinstance(field, Reference) and field_value is not None:
-                    result[field_key] = get_translation(field_value)
-                elif isinstance(field, ReferenceList):
-                    result[field_key] = [
-                        get_translation(ele) for ele in field_value
-                    ]
-                elif isinstance(field, ReferenceValueDict):
-                    result[field_key] = {
-                        key: get_translation(subvalue)
-                        for key, subvalue in field_value.items()
-                    }
-                else:
-                    result[field_key] = field_value
-
-        return result
diff --git a/xmodule/modulestore/tests/django_utils.py b/xmodule/modulestore/tests/django_utils.py
index f5e6ffb3483c..186ebce82ca3 100644
--- a/xmodule/modulestore/tests/django_utils.py
+++ b/xmodule/modulestore/tests/django_utils.py
@@ -127,7 +127,7 @@ def split_mongo_store_config(modulestore_options):
     """
     store = {
         'default': {
-            'NAME': 'draft',
+            'NAME': 'split',
             'ENGINE': 'xmodule.modulestore.split_mongo.split_draft.DraftVersioningModuleStore',
             'DOC_STORE_CONFIG': {
                 'host': MONGO_HOST,
diff --git a/xmodule/modulestore/tests/test_assetstore.py b/xmodule/modulestore/tests/test_assetstore.py
index 2d0ae75f9b9c..26dcb29ad976 100644
--- a/xmodule/modulestore/tests/test_assetstore.py
+++ b/xmodule/modulestore/tests/test_assetstore.py
@@ -20,8 +20,7 @@
 from xmodule.modulestore.exceptions import ItemNotFoundError
 from xmodule.modulestore.tests.factories import CourseFactory
 from xmodule.modulestore.tests.utils import (
-    MIXED_MODULESTORE_BOTH_SETUP,
-    MODULESTORE_SETUPS,
+    SPLIT_MODULESTORE_SETUP,
     MixedModulestoreBuilder,
     XmlModulestoreBuilder
 )
@@ -167,7 +166,7 @@ def setup_assets(self, course1_key, course2_key, store=None):
                 if store is not None and i not in (4, 5):
                     store.save_asset_metadata(asset_md, asset[4])
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_save_one_and_confirm(self, storebuilder):
         """
         Save the metadata in each store and retrieve it singularly, as all assets, and after deleting all.
@@ -185,7 +184,7 @@ def test_save_one_and_confirm(self, storebuilder):
             self._assert_metadata_equal(new_asset_md, found_asset_md)
             assert len(store.get_all_asset_metadata(course.id, 'asset')) == 1
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_delete(self, storebuilder):
         """
         Delete non-existent and existent metadata
@@ -202,7 +201,7 @@ def test_delete(self, storebuilder):
             assert store.delete_asset_metadata(new_asset_loc, ModuleStoreEnum.UserID.test) == 1
             assert len(store.get_all_asset_metadata(course.id, 'asset')) == 0
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_find_non_existing_assets(self, storebuilder):
         """
         Find a non-existent asset in an existing course.
@@ -214,7 +213,7 @@ def test_find_non_existing_assets(self, storebuilder):
             asset_md = store.find_asset_metadata(new_asset_loc)
             assert asset_md is None
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_get_all_non_existing_assets(self, storebuilder):
         """
         Get all assets in an existing course when no assets exist.
@@ -225,7 +224,7 @@ def test_get_all_non_existing_assets(self, storebuilder):
             asset_md = store.get_all_asset_metadata(course.id, 'asset')
             assert asset_md == []
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_find_assets_in_non_existent_course(self, storebuilder):
         """
         Find asset metadata from a non-existent course.
@@ -242,7 +241,7 @@ def test_find_assets_in_non_existent_course(self, storebuilder):
             with pytest.raises(ItemNotFoundError):
                 store.get_all_asset_metadata(fake_course_id, 'asset')
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_add_same_asset_twice(self, storebuilder):
         """
         Add an asset's metadata, then add it again.
@@ -259,7 +258,7 @@ def test_add_same_asset_twice(self, storebuilder):
             # Still one here?
             assert len(store.get_all_asset_metadata(course.id, 'asset')) == 1
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_different_asset_types(self, storebuilder):
         """
         Test saving assets with other asset types.
@@ -273,7 +272,7 @@ def test_different_asset_types(self, storebuilder):
             assert len(store.get_all_asset_metadata(course.id, 'vrml')) == 1
             assert len(store.get_all_asset_metadata(course.id, 'asset')) == 0
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_asset_types_with_other_field_names(self, storebuilder):
         """
         Test saving assets using an asset type of 'course_id'.
@@ -289,7 +288,7 @@ def test_asset_types_with_other_field_names(self, storebuilder):
             all_assets = store.get_all_asset_metadata(course.id, 'course_id')
             assert all_assets[0].asset_id.path == new_asset_loc.path
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_lock_unlock_assets(self, storebuilder):
         """
         Save multiple metadata in each store and retrieve it singularly, as all assets, and after deleting all.
@@ -337,7 +336,7 @@ def test_lock_unlock_assets(self, storebuilder):
         ('villain', 'Khan')
     )
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_set_all_attrs(self, storebuilder):
         """
         Save setting each attr one at a time
@@ -356,7 +355,7 @@ def test_set_all_attrs(self, storebuilder):
                 assert getattr(updated_asset_md, attribute, None) is not None
                 assert getattr(updated_asset_md, attribute, None) == value
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_set_disallowed_attrs(self, storebuilder):
         """
         setting disallowed attrs should fail
@@ -382,7 +381,7 @@ def test_set_disallowed_attrs(self, storebuilder):
                 else:
                     assert updated_attr_val == original_attr_val
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_set_unknown_attrs(self, storebuilder):
         """
         setting unknown attrs should fail
@@ -402,7 +401,7 @@ def test_set_unknown_attrs(self, storebuilder):
                 with pytest.raises(AttributeError):
                     assert getattr(updated_asset_md, attribute) == value
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_save_one_different_asset(self, storebuilder):
         """
         saving and deleting things which are not 'asset'
@@ -418,7 +417,7 @@ def test_save_one_different_asset(self, storebuilder):
             assert store.delete_asset_metadata(asset_key, ModuleStoreEnum.UserID.test) == 1
             assert len(store.get_all_asset_metadata(course.id, 'different')) == 0
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_find_different(self, storebuilder):
         """
         finding things which are of type other than 'asset'
@@ -443,7 +442,7 @@ def _check_asset_values(self, assets, orig):
             assert assets[idx].asset_id.asset_type == asset[0]
             assert assets[idx].asset_id.path == asset[1]
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_get_multiple_types(self, storebuilder):
         """
         getting all things which are of type other than 'asset'
@@ -479,7 +478,7 @@ def test_get_multiple_types(self, storebuilder):
             assert len(assets) == len(self.alls)
             self._check_asset_values(assets, self.alls)
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_save_metadata_list(self, storebuilder):
         """
         Save a list of asset metadata all at once.
@@ -518,7 +517,7 @@ def test_save_metadata_list(self, storebuilder):
             assert len(assets) == len(self.alls)
             self._check_asset_values(assets, self.alls)
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_save_metadata_list_with_mismatched_asset(self, storebuilder):
         """
         Save a list of asset metadata all at once - but with one asset's metadata from a different course.
@@ -560,7 +559,7 @@ def test_save_metadata_list_with_mismatched_asset(self, storebuilder):
             assert len(assets) == len(self.differents + self.vrmls)
             self._check_asset_values(assets, self.differents + self.vrmls)
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_delete_all_different_type(self, storebuilder):
         """
         deleting all assets of a given but not 'asset' type
@@ -587,7 +586,7 @@ def test_xml_not_yet_implemented(self, storebuilderName):
             assert store.find_asset_metadata(asset_key) is None
             assert store.get_all_asset_metadata(course_key, 'asset') == []
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_copy_all_assets_same_modulestore(self, storebuilder):
         """
         Create a course with assets, copy them all to another course in the same modulestore, and check on it.
@@ -607,7 +606,7 @@ def test_copy_all_assets_same_modulestore(self, storebuilder):
             assert all_assets[0].asset_id.path == 'pic1.jpg'
             assert all_assets[1].asset_id.path == 'shout.ogg'
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_copy_all_assets_from_course_with_no_assets(self, storebuilder):
         """
         Create a course with *no* assets, and try copy them all to another course in the same modulestore.
@@ -622,29 +621,3 @@ def test_copy_all_assets_from_course_with_no_assets(self, storebuilder):
                 course2.id, 'asset', sort=('displayname', ModuleStoreEnum.SortOrder.ascending)
             )
             assert len(all_assets) == 0
-
-    @ddt.data(
-        ('mongo', 'split'),
-        ('split', 'mongo'),
-    )
-    @ddt.unpack
-    def test_copy_all_assets_cross_modulestore(self, from_store, to_store):
-        """
-        Create a course with assets, copy them all to another course in a different modulestore, and check on it.
-        """
-        mixed_builder = MIXED_MODULESTORE_BOTH_SETUP
-        with mixed_builder.build() as (__, mixed_store):
-            with mixed_store.default_store(from_store):
-                course1 = CourseFactory.create(modulestore=mixed_store)
-            with mixed_store.default_store(to_store):
-                course2 = CourseFactory.create(modulestore=mixed_store)
-            self.setup_assets(course1.id, None, mixed_store)
-            assert len(mixed_store.get_all_asset_metadata(course1.id, 'asset')) == 2
-            assert len(mixed_store.get_all_asset_metadata(course2.id, 'asset')) == 0
-            mixed_store.copy_all_asset_metadata(course1.id, course2.id, ModuleStoreEnum.UserID.test * 102)
-            all_assets = mixed_store.get_all_asset_metadata(
-                course2.id, 'asset', sort=('displayname', ModuleStoreEnum.SortOrder.ascending)
-            )
-            assert len(all_assets) == 2
-            assert all_assets[0].asset_id.path == 'pic1.jpg'
-            assert all_assets[1].asset_id.path == 'shout.ogg'
diff --git a/xmodule/modulestore/tests/test_cross_modulestore_import_export.py b/xmodule/modulestore/tests/test_cross_modulestore_import_export.py
index 21d9ddccd51a..34f02a2ab30f 100644
--- a/xmodule/modulestore/tests/test_cross_modulestore_import_export.py
+++ b/xmodule/modulestore/tests/test_cross_modulestore_import_export.py
@@ -26,7 +26,6 @@
 from xmodule.modulestore import ModuleStoreEnum
 from xmodule.modulestore.tests.utils import (
     CONTENTSTORE_SETUPS,
-    MODULESTORE_SETUPS,
     SPLIT_MODULESTORE_SETUP,
     TEST_DATA_DIR,
     MongoContentstoreBuilder,
@@ -61,8 +60,8 @@ def setUp(self):
 
     @patch('xmodule.video_module.video_module.edxval_api', None)
     @ddt.data(*itertools.product(
-        MODULESTORE_SETUPS,
-        MODULESTORE_SETUPS,
+        (SPLIT_MODULESTORE_SETUP,),
+        (SPLIT_MODULESTORE_SETUP,),
         CONTENTSTORE_SETUPS,
         CONTENTSTORE_SETUPS,
         COURSE_DATA_NAMES,
diff --git a/xmodule/modulestore/tests/test_mixed_modulestore.py b/xmodule/modulestore/tests/test_mixed_modulestore.py
index 5d50dfb5adc0..4842886df159 100644
--- a/xmodule/modulestore/tests/test_mixed_modulestore.py
+++ b/xmodule/modulestore/tests/test_mixed_modulestore.py
@@ -40,14 +40,13 @@
     DuplicateCourseError,
     ItemNotFoundError,
     NoPathToItem,
-    ReferentialIntegrityError
 )
 from xmodule.modulestore.inheritance import InheritanceMixin
 from xmodule.modulestore.mixed import MixedModuleStore
 from xmodule.modulestore.search import navigation_index, path_to_location
 from xmodule.modulestore.split_mongo.split import SplitMongoModuleStore
 from xmodule.modulestore.store_utilities import DETACHED_XBLOCK_TYPES
-from xmodule.modulestore.tests.factories import check_exact_number_of_calls, check_mongo_calls, mongo_uses_error_check
+from xmodule.modulestore.tests.factories import check_exact_number_of_calls, check_mongo_calls
 from xmodule.modulestore.tests.mongo_connection import MONGO_HOST, MONGO_PORT_NUM
 from xmodule.modulestore.tests.test_asides import AsideTestType
 from xmodule.modulestore.tests.utils import MongoContentstoreBuilder, create_modulestore_instance
@@ -95,14 +94,14 @@ class CommonMixedModuleStoreSetup(CourseComparisonTest):
     OPTIONS = {
         'stores': [
             {
-                'NAME': ModuleStoreEnum.Type.mongo,
-                'ENGINE': 'xmodule.modulestore.mongo.draft.DraftModuleStore',
+                'NAME': ModuleStoreEnum.Type.split,
+                'ENGINE': 'xmodule.modulestore.split_mongo.split_draft.DraftVersioningModuleStore',
                 'DOC_STORE_CONFIG': DOC_STORE_CONFIG,
                 'OPTIONS': modulestore_options
             },
             {
-                'NAME': ModuleStoreEnum.Type.split,
-                'ENGINE': 'xmodule.modulestore.split_mongo.split_draft.DraftVersioningModuleStore',
+                'NAME': ModuleStoreEnum.Type.mongo,
+                'ENGINE': 'xmodule.modulestore.mongo.draft.DraftModuleStore',
                 'DOC_STORE_CONFIG': DOC_STORE_CONFIG,
                 'OPTIONS': modulestore_options
             },
@@ -306,7 +305,7 @@ class TestMixedModuleStore(CommonMixedModuleStoreSetup):
     """
     Tests of the MixedModulestore interface methods.
     """
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_get_modulestore_type(self, default_ms):
         """
         Make sure we get back the store type we expect for given mappings
@@ -316,7 +315,7 @@ def test_get_modulestore_type(self, default_ms):
         # try an unknown mapping, it should be the 'default' store
         assert self.store.get_modulestore_type(CourseKey.from_string('foo/bar/2012_Fall')) == default_ms
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_get_modulestore_cache(self, default_ms):
         """
         Make sure we cache discovered course mappings
@@ -331,7 +330,7 @@ def test_get_modulestore_cache(self, default_ms):
             assert self.store.default_modulestore == self.store._get_modulestore_for_courselike(course_key)  # pylint: disable=protected-access, line-too-long
 
     @ddt.data(*itertools.product(
-        (ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split),
+        (ModuleStoreEnum.Type.split,),
         (True, False)
     ))
     @ddt.unpack
@@ -347,7 +346,7 @@ def test_duplicate_course_error(self, default_ms, reset_mixed_mappings):
             with pytest.raises(DuplicateCourseError):
                 self.store.create_course('org_x', 'course_y', 'run_z', self.user_id)
 
-    @ddt.data(ModuleStoreEnum.Type.split, ModuleStoreEnum.Type.mongo)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_duplicate_course_error_with_different_case_ids(self, default_store):
         """
         Verify that course can not be created with same course_id with different case.
@@ -364,7 +363,7 @@ def test_duplicate_course_error_with_different_case_ids(self, default_store):
     #    fake: one w/ wildcard version
     # split: has one lookup for the course and then one for the course items
     #    but the active_versions check is done in MySQL
-    @ddt.data((ModuleStoreEnum.Type.mongo, [1, 1], 0), (ModuleStoreEnum.Type.split, [1, 1], 0))
+    @ddt.data((ModuleStoreEnum.Type.split, [1, 1], 0))
     @ddt.unpack
     def test_has_item(self, default_ms, max_find, max_send):
         self.initdb(default_ms)
@@ -387,7 +386,7 @@ def test_has_item(self, default_ms, max_find, max_send):
     # split:
     #   problem: active_versions, structure
     #   non-existent problem: ditto
-    @ddt.data((ModuleStoreEnum.Type.mongo, [0, 0], [3, 2], 0), (ModuleStoreEnum.Type.split, [1, 0], [1, 1], 0))
+    @ddt.data((ModuleStoreEnum.Type.split, [1, 0], [1, 1], 0))
     @ddt.unpack
     def test_get_item(self, default_ms, num_mysql, max_find, max_send):
         self.initdb(default_ms)
@@ -410,7 +409,7 @@ def test_get_item(self, default_ms, num_mysql, max_find, max_send):
     # Split:
     #    mysql: fetch course's active version from SplitModulestoreCourseIndex, spurious refetch x2
     #    find: get structure
-    @ddt.data((ModuleStoreEnum.Type.mongo, 0, 14, 0), (ModuleStoreEnum.Type.split, 2, 1, 0))
+    @ddt.data((ModuleStoreEnum.Type.split, 2, 1, 0))
     @ddt.unpack
     def test_get_items(self, default_ms, num_mysql, max_find, max_send):
         self.initdb(default_ms)
@@ -428,7 +427,7 @@ def test_get_items(self, default_ms, num_mysql, max_find, max_send):
                 revision=ModuleStoreEnum.RevisionOption.draft_preferred
             )
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_course_version_on_block(self, default_ms):
         self.initdb(default_ms)
         self._create_block_hierarchy()
@@ -451,7 +450,7 @@ def test_course_version_on_block(self, default_ms):
             cached_block = course.runtime.load_item(block.location)
             assert cached_block.course_version == block.course_version
 
-    @ddt.data((ModuleStoreEnum.Type.split, 2, False), (ModuleStoreEnum.Type.mongo, 3, True))
+    @ddt.data((ModuleStoreEnum.Type.split, 2, False))
     @ddt.unpack
     def test_get_items_include_orphans(self, default_ms, expected_items_in_tree, orphan_in_items):
         """
@@ -518,7 +517,7 @@ def test_get_items_include_orphans(self, default_ms, expected_items_in_tree, orp
     #    mysql: SplitModulestoreCourseIndex - select 2x (by course_id, by objectid), update, update historical record
     #    find: definitions (calculator field), structures
     #    sends: 2 sends to update index & structure (note, it would also be definition if a content field changed)
-    @ddt.data((ModuleStoreEnum.Type.mongo, 0, 7, 5), (ModuleStoreEnum.Type.split, 3, 2, 2))
+    @ddt.data((ModuleStoreEnum.Type.split, 3, 2, 2))
     @ddt.unpack
     def test_update_item(self, default_ms, num_mysql, max_find, max_send):
         """
@@ -535,7 +534,7 @@ def test_update_item(self, default_ms, num_mysql, max_find, max_send):
 
         assert problem.max_attempts == 2, "Update didn't persist"
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_has_changes_direct_only(self, default_ms):
         """
         Tests that has_changes() returns false when a new xblock in a direct only category is checked
@@ -556,7 +555,7 @@ def test_has_changes_direct_only(self, default_ms):
         assert not self.store.has_changes(test_course)
         assert not self.store.has_changes(chapter)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_has_changes(self, default_ms):
         """
         Tests that has_changes() only returns true when changes are present
@@ -591,7 +590,7 @@ def test_has_changes(self, default_ms):
         component = self.store.publish(component.location, self.user_id)
         assert not self.store.has_changes(component)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_unit_stuck_in_draft_mode(self, default_ms):
         """
         After revert_to_published() the has_changes() should return false if draft has no changes
@@ -623,7 +622,7 @@ def test_unit_stuck_in_draft_mode(self, default_ms):
         component = self.store.publish(component.location, self.user_id)
         assert not self.store.has_changes(component)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_unit_stuck_in_published_mode(self, default_ms):
         """
         After revert_to_published() the has_changes() should return true if draft has changes
@@ -660,7 +659,7 @@ def test_unit_stuck_in_published_mode(self, default_ms):
         # Verify that changes are present
         assert self.store.has_changes(component)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_unit_stuck_in_published_mode_after_delete(self, default_ms):
         """
         Test that a unit does not get stuck in published mode
@@ -703,7 +702,7 @@ def test_unit_stuck_in_published_mode_after_delete(self, default_ms):
         vertical = self.store.get_item(vertical.location)
         assert self._has_changes(vertical.location)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_publish_automatically_after_delete_unit(self, default_ms):
         """
         Check that sequential publishes automatically after deleting a unit
@@ -746,7 +745,7 @@ def setup_has_changes(self, default_ms):
 
         return locations
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_has_changes_ancestors(self, default_ms):
         """
         Tests that has_changes() returns true on ancestors when a child is changed
@@ -776,7 +775,7 @@ def test_has_changes_ancestors(self, default_ms):
         for key in locations:
             assert not self._has_changes(locations[key])
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_has_changes_publish_ancestors(self, default_ms):
         """
         Tests that has_changes() returns false after a child is published only if all children are unchanged
@@ -813,7 +812,7 @@ def test_has_changes_publish_ancestors(self, default_ms):
         assert not self._has_changes(locations['grandparent'])
         assert not self._has_changes(locations['parent'])
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_has_changes_add_remove_child(self, default_ms):
         """
         Tests that has_changes() returns true for the parent when a child with changes is added
@@ -846,7 +845,7 @@ def test_has_changes_add_remove_child(self, default_ms):
         assert not self._has_changes(locations['grandparent'])
         assert not self._has_changes(locations['parent'])
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_has_changes_non_direct_only_children(self, default_ms):
         """
         Tests that has_changes() returns true after editing the child of a vertical (both not direct only categories).
@@ -880,7 +879,7 @@ def test_has_changes_non_direct_only_children(self, default_ms):
         assert self._has_changes(child.location)
 
     @ddt.data(*itertools.product(
-        (ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split),
+        (ModuleStoreEnum.Type.split,),
         (ModuleStoreEnum.Branch.draft_preferred, ModuleStoreEnum.Branch.published_only)
     ))
     @ddt.unpack
@@ -913,15 +912,13 @@ def test_has_changes_missing_child(self, default_ms, default_branch):
     #   mysql: SplitModulestoreCourseIndex - select 2x (by course_id, by objectid), update, update historical record
     #   Find: active_versions, 2 structures (published & draft), definition (unnecessary)
     #   Sends: updated draft and published structures and active_versions
-    @ddt.data((ModuleStoreEnum.Type.mongo, 0, 7, 2), (ModuleStoreEnum.Type.split, 4, 2, 3))
+    @ddt.data((ModuleStoreEnum.Type.split, 4, 2, 3))
     @ddt.unpack
     def test_delete_item(self, default_ms, num_mysql, max_find, max_send):
         """
         Delete should reject on r/o db and work on r/w one
         """
         self.initdb(default_ms)
-        if default_ms == ModuleStoreEnum.Type.mongo and mongo_uses_error_check(self.store):
-            max_find += 1
 
         with self.store.branch_setting(ModuleStoreEnum.Branch.draft_preferred, self.writable_chapter_location.course_key):  # lint-amnesty, pylint: disable=line-too-long
             with check_mongo_calls(max_find, max_send), self.assertNumQueries(num_mysql):
@@ -942,7 +939,7 @@ def test_delete_item(self, default_ms, num_mysql, max_find, max_send):
     #    mysql: SplitModulestoreCourseIndex - select 2x (by course_id, by objectid), update, update historical record
     #    find: draft and published structures, definition (unnecessary)
     #    sends: update published (why?), draft, and active_versions
-    @ddt.data((ModuleStoreEnum.Type.mongo, 0, 9, 2), (ModuleStoreEnum.Type.split, 4, 3, 3))
+    @ddt.data((ModuleStoreEnum.Type.split, 4, 3, 3))
     @ddt.unpack
     def test_delete_private_vertical(self, default_ms, num_mysql, max_find, max_send):
         """
@@ -950,8 +947,6 @@ def test_delete_private_vertical(self, default_ms, num_mysql, max_find, max_send
         behavioral properties which this deletion test gets at.
         """
         self.initdb(default_ms)
-        if default_ms == ModuleStoreEnum.Type.mongo and mongo_uses_error_check(self.store):
-            max_find += 1
         # create and delete a private vertical with private children
         private_vert = self.store.create_child(
             # don't use course_location as it may not be the repr
@@ -996,7 +991,7 @@ def test_delete_private_vertical(self, default_ms, num_mysql, max_find, max_send
     #   mysql: SplitModulestoreCourseIndex - select 2x (by course_id, by objectid), update, update historical record
     #   find: structure (cached)
     #   send: update structure and active_versions
-    @ddt.data((ModuleStoreEnum.Type.mongo, 0, 4, 1), (ModuleStoreEnum.Type.split, 4, 1, 2))
+    @ddt.data((ModuleStoreEnum.Type.split, 4, 1, 2))
     @ddt.unpack
     def test_delete_draft_vertical(self, default_ms, num_mysql, max_find, max_send):
         """
@@ -1026,8 +1021,6 @@ def test_delete_draft_vertical(self, default_ms, num_mysql, max_find, max_send):
         private_leaf.display_name = 'change me'
         private_leaf = self.store.update_item(private_leaf, self.user_id)
         # test succeeds if delete succeeds w/o error
-        if default_ms == ModuleStoreEnum.Type.mongo and mongo_uses_error_check(self.store):
-            max_find += 1
         with check_mongo_calls(max_find, max_send), self.assertNumQueries(num_mysql):
             self.store.delete_item(private_leaf.location, self.user_id)
 
@@ -1039,7 +1032,7 @@ def test_delete_draft_vertical(self, default_ms, num_mysql, max_find, max_send):
     #          executed twice, possibly unnecessarily)
     #   find: 2 reads of structure, definition (s/b lazy; so, unnecessary),
     #         plus 1 wildcard find in draft mongo which has none
-    @ddt.data((ModuleStoreEnum.Type.mongo, 1, 2, 0), (ModuleStoreEnum.Type.split, 2, 3, 0))
+    @ddt.data((ModuleStoreEnum.Type.split, 2, 3, 0))
     @ddt.unpack
     def test_get_courses(self, default_ms, num_mysql, max_find, max_send):
         self.initdb(default_ms)
@@ -1056,7 +1049,7 @@ def test_get_courses(self, default_ms, num_mysql, max_find, max_send):
             published_courses = self.store.get_courses(remove_branch=True)
         assert [c.id for c in draft_courses] == [c.id for c in published_courses]
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_create_child_detached_tabs(self, default_ms):
         """
         test 'create_child' method with a detached category ('static_tab')
@@ -1079,7 +1072,7 @@ def test_create_child_detached_tabs(self, default_ms):
 
     # draft is 2: find out which ms owns course, get item
     # split: active_versions (mysql), structure, definition (to load course wiki string)
-    @ddt.data((ModuleStoreEnum.Type.mongo, 0, 2, 0), (ModuleStoreEnum.Type.split, 1, 2, 0))
+    @ddt.data((ModuleStoreEnum.Type.split, 1, 2, 0))
     @ddt.unpack
     def test_get_course(self, default_ms, num_mysql, max_find, max_send):
         """
@@ -1091,7 +1084,7 @@ def test_get_course(self, default_ms, num_mysql, max_find, max_send):
             course = self.store.get_item(self.course_locations[self.MONGO_COURSEID])
             assert course.id == self.course_locations[self.MONGO_COURSEID].course_key
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_get_library(self, default_ms):
         """
         Test that create_library and get_library work regardless of the default modulestore.
@@ -1116,7 +1109,7 @@ def test_get_library(self, default_ms):
     # still only 2)
     # Draft: get_parent
     # Split: active_versions, structure
-    @ddt.data((ModuleStoreEnum.Type.mongo, 0, 1, 0), (ModuleStoreEnum.Type.split, 1, 1, 0))
+    @ddt.data((ModuleStoreEnum.Type.split, 1, 1, 0))
     @ddt.unpack
     def test_get_parent_locations(self, default_ms, num_mysql, max_find, max_send):
         """
@@ -1182,7 +1175,7 @@ def verify_item_parent(self, item_location, expected_parent_location, old_parent
             assert item_location in expected_parent.children
             assert item_location not in old_parent.children
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_update_item_parent(self, store_type):
         """
         Test that when we move an item from old to new parent, the item should be present in new parent.
@@ -1208,7 +1201,7 @@ def test_update_item_parent(self, store_type):
             old_parent_location=old_parent_location
         )
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_move_revert(self, store_type):
         """
         Test that when we move an item to new parent and then discard the original parent, the item should be present
@@ -1245,7 +1238,7 @@ def test_move_revert(self, store_type):
             is_reverted=True
         )
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_move_delete_revert(self, store_type):
         """
         Test that when we move an item and delete it and then discard changes for original parent, item should be
@@ -1285,7 +1278,7 @@ def test_move_delete_revert(self, store_type):
             is_reverted=True
         )
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_move_revert_move(self, store_type):
         """
         Test that when we move an item to new parent and discard changes for the old parent, then the item should be
@@ -1335,7 +1328,7 @@ def test_move_revert_move(self, store_type):
             old_parent_location=old_parent_location
         )
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_move_edited_revert(self, store_type):
         """
         Test that when we move an edited item from old parent to new parent and then discard changes in old parent,
@@ -1381,7 +1374,7 @@ def test_move_edited_revert(self, store_type):
         reverted_problem = self.store.get_item(self.problem_x1a_1)  # lint-amnesty, pylint: disable=no-member
         assert orig_display_name == reverted_problem.display_name
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_move_1_moved_1_unchanged(self, store_type):
         """
         Test that when we move an item from an old parent which have multiple items then only moved item's parent
@@ -1417,7 +1410,7 @@ def test_move_1_moved_1_unchanged(self, store_type):
         assert problem_item2.parent == self.vertical_x1a  # lint-amnesty, pylint: disable=no-member
         assert problem_item2.location in problem_item2.get_parent().children
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_move_1_moved_1_edited(self, store_type):
         """
         Test that when we move an item inside an old parent having multiple items, we edit one item and move
@@ -1464,7 +1457,7 @@ def test_move_1_moved_1_edited(self, store_type):
         reverted_problem2 = self.store.get_item(problem_item2.location)
         assert orig_display_name == reverted_problem2.display_name
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_move_1_moved_1_deleted(self, store_type):
         """
         Test that when we move an item inside an old parent having multiple items, we delete one item and move
@@ -1509,7 +1502,7 @@ def test_move_1_moved_1_deleted(self, store_type):
         assert problem_item2.parent == self.vertical_x1a  # lint-amnesty, pylint: disable=no-member
         assert problem_item2.location in problem_item2.get_parent().children
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_get_parent_locations_moved_child(self, default_ms):
         self.initdb(default_ms)
         self._create_block_hierarchy()
@@ -1560,81 +1553,8 @@ def test_get_parent_locations_moved_child(self, default_ms):
             (child_to_move_location, new_parent_published_location, ModuleStoreEnum.RevisionOption.published_only),
         ])
 
-    @ddt.data(ModuleStoreEnum.Type.mongo)
-    def test_get_parent_locations_deleted_child(self, default_ms):
-        self.initdb(default_ms)
-        self._create_block_hierarchy()
-
-        # publish the course
-        self.store.publish(self.course.location, self.user_id)
-
-        # make draft of vertical
-        self.store.convert_to_draft(self.vertical_y1a, self.user_id)  # lint-amnesty, pylint: disable=no-member
-
-        # delete child problem_y1a_1
-        child_to_delete_location = self.problem_y1a_1  # lint-amnesty, pylint: disable=no-member
-        old_parent_location = self.vertical_y1a  # lint-amnesty, pylint: disable=no-member
-        self.store.delete_item(child_to_delete_location, self.user_id)
-
-        self.verify_get_parent_locations_results([
-            (child_to_delete_location, old_parent_location, None),
-            # Note: The following could be an unexpected result, but we want to avoid an extra database call
-            (child_to_delete_location, old_parent_location, ModuleStoreEnum.RevisionOption.draft_preferred),
-            (child_to_delete_location, old_parent_location, ModuleStoreEnum.RevisionOption.published_only),
-        ])
-
-        # publish the course again
-        self.store.publish(self.course.location, self.user_id)
-        self.verify_get_parent_locations_results([
-            (child_to_delete_location, None, None),
-            (child_to_delete_location, None, ModuleStoreEnum.RevisionOption.draft_preferred),
-            (child_to_delete_location, None, ModuleStoreEnum.RevisionOption.published_only),
-        ])
-
-    @ddt.data(ModuleStoreEnum.Type.mongo)
-    def test_get_parent_location_draft(self, default_ms):
-        """
-        Test that "get_parent_location" method returns first published parent
-        for a draft component, if it has many possible parents (including
-        draft parents).
-        """
-        self.initdb(default_ms)
-        course_id = self.course_locations[self.MONGO_COURSEID].course_key
-
-        # create parented children
-        self._create_block_hierarchy()
-        self.store.publish(self.course.location, self.user_id)
-
-        mongo_store = self.store._get_modulestore_for_courselike(course_id)  # pylint: disable=protected-access
-        # add another parent (unit) "vertical_x1b" for problem "problem_x1a_1"
-        mongo_store.collection.update_one(
-            self.vertical_x1b.to_deprecated_son('_id.'),  # lint-amnesty, pylint: disable=no-member
-            {'$push': {'definition.children': str(self.problem_x1a_1)}}  # lint-amnesty, pylint: disable=no-member
-        )
-
-        # convert first parent (unit) "vertical_x1a" of problem "problem_x1a_1" to draft
-        self.store.convert_to_draft(self.vertical_x1a, self.user_id)  # lint-amnesty, pylint: disable=no-member
-        item = self.store.get_item(self.vertical_x1a)  # lint-amnesty, pylint: disable=no-member
-        assert self.store.has_published_version(item)
-
-        # now problem "problem_x1a_1" has 3 parents [vertical_x1a (draft),
-        # vertical_x1a (published), vertical_x1b (published)]
-        # check that "get_parent_location" method of draft branch returns first
-        # published parent "vertical_x1a" without raising "AssertionError" for
-        # problem location revision
-        with self.store.branch_setting(ModuleStoreEnum.Branch.draft_preferred, course_id):
-            parent = mongo_store.get_parent_location(self.problem_x1a_1)  # lint-amnesty, pylint: disable=no-member
-            assert parent.for_branch(None) == self.vertical_x1a  # lint-amnesty, pylint: disable=no-member
-
-    # Draft:
-    #   Problem path:
-    #    1. Get problem
-    #    2-6. get parent and rest of ancestors up to course
-    #    7-8. get sequential, compute inheritance
-    #    8-9. get vertical, compute inheritance
-    #    10-11. get other vertical_x1b (why?) and compute inheritance
     # Split: loading structure from mongo (also loads active version from MySQL, not tracked here)
-    @ddt.data((ModuleStoreEnum.Type.mongo, [0, 0], [12, 3], 0), (ModuleStoreEnum.Type.split, [1, 0], [2, 1], 0))
+    @ddt.data((ModuleStoreEnum.Type.split, [1, 0], [2, 1], 0))
     @ddt.unpack
     def test_path_to_location(self, default_ms, num_mysql, num_finds, num_sends):
         """
@@ -1691,7 +1611,7 @@ def test_navigation_index(self):
         assert 5 == navigation_index('5_2')
         assert 7 == navigation_index('7_3_5_6_')
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_revert_to_published_root_draft(self, default_ms):
         """
         Test calling revert_to_published on draft vertical.
@@ -1723,7 +1643,7 @@ def test_revert_to_published_root_draft(self, default_ms):
         self.assertBlocksEqualByFields(reverted_parent, published_parent)
         assert not self._has_changes(self.vertical_x1a)  # lint-amnesty, pylint: disable=no-member
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_revert_to_published_root_published(self, default_ms):
         """
         Test calling revert_to_published on a published vertical with a draft child.
@@ -1743,7 +1663,7 @@ def test_revert_to_published_root_published(self, default_ms):
         reverted_problem = self.store.get_item(self.problem_x1a_1)  # lint-amnesty, pylint: disable=no-member
         assert orig_display_name == reverted_problem.display_name
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_revert_to_published_no_draft(self, default_ms):
         """
         Test calling revert_to_published on vertical with no draft content does nothing.
@@ -1758,7 +1678,7 @@ def test_revert_to_published_no_draft(self, default_ms):
 
         self.assertBlocksEqualByFields(orig_vertical, reverted_vertical)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_revert_to_published_no_published(self, default_ms):
         """
         Test calling revert_to_published on vertical with no published version errors.
@@ -1768,7 +1688,7 @@ def test_revert_to_published_no_published(self, default_ms):
         with pytest.raises(InvalidVersionError):
             self.store.revert_to_published(self.vertical_x1a, self.user_id)  # lint-amnesty, pylint: disable=no-member
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_revert_to_published_direct_only(self, default_ms):
         """
         Test calling revert_to_published on a direct-only item is a no-op.
@@ -1872,9 +1792,8 @@ def _get_split_modulestore(self):
                 return store
         assert False, "SplitMongoModuleStore was not found in MixedModuleStore"
 
-    # Draft: get all items which can be or should have parents
     # Split: active_versions (mysql), structure (mongo)
-    @ddt.data((ModuleStoreEnum.Type.mongo, 0, 1, 0), (ModuleStoreEnum.Type.split, 1, 1, 0))
+    @ddt.data((ModuleStoreEnum.Type.split, 1, 1, 0))
     @ddt.unpack
     def test_get_orphans(self, default_ms, num_mysql, max_find, max_send):
         """
@@ -1912,82 +1831,7 @@ def test_get_orphans(self, default_ms, num_mysql, max_find, max_send):
             found_orphans = self.store.get_orphans(self.course_locations[self.MONGO_COURSEID].course_key)
         self.assertCountEqual(found_orphans, orphan_locations)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo)
-    def test_get_non_orphan_parents(self, default_ms):
-        """
-        Test finding non orphan parents from many possible parents.
-        """
-        self.initdb(default_ms)
-        course_id = self.course_locations[self.MONGO_COURSEID].course_key
-
-        # create parented children
-        self._create_block_hierarchy()
-        self.store.publish(self.course.location, self.user_id)
-
-        # test that problem "problem_x1a_1" has only one published parent
-        mongo_store = self.store._get_modulestore_for_courselike(course_id)  # pylint: disable=protected-access
-        with self.store.branch_setting(ModuleStoreEnum.Branch.published_only, course_id):
-            parent = mongo_store.get_parent_location(self.problem_x1a_1)  # lint-amnesty, pylint: disable=no-member
-            assert parent == self.vertical_x1a  # lint-amnesty, pylint: disable=no-member
-
-        # add some published orphans
-        orphan_sequential = course_id.make_usage_key('sequential', 'OrphanSequential')
-        orphan_vertical = course_id.make_usage_key('vertical', 'OrphanVertical')
-        orphan_locations = [orphan_sequential, orphan_vertical]
-        for location in orphan_locations:
-            self.store.create_item(
-                self.user_id,
-                location.course_key,
-                location.block_type,
-                block_id=location.block_id
-            )
-            self.store.publish(location, self.user_id)
-
-        found_orphans = mongo_store.get_orphans(course_id)
-        assert set(found_orphans) == set(orphan_locations)
-        assert len(set(found_orphans)) == 2
-
-        # add orphan vertical and sequential as another parents of problem "problem_x1a_1"
-        mongo_store.collection.update_one(
-            orphan_sequential.to_deprecated_son('_id.'),
-            {'$push': {'definition.children': str(self.problem_x1a_1)}}  # lint-amnesty, pylint: disable=no-member
-        )
-        mongo_store.collection.update_one(
-            orphan_vertical.to_deprecated_son('_id.'),
-            {'$push': {'definition.children': str(self.problem_x1a_1)}}  # lint-amnesty, pylint: disable=no-member
-        )
-        # test that "get_parent_location" method of published branch still returns the correct non-orphan parent for
-        # problem "problem_x1a_1" since the two other parents are orphans
-        with self.store.branch_setting(ModuleStoreEnum.Branch.published_only, course_id):
-            parent = mongo_store.get_parent_location(self.problem_x1a_1)  # lint-amnesty, pylint: disable=no-member
-            assert parent == self.vertical_x1a  # lint-amnesty, pylint: disable=no-member
-
-        # now add valid published vertical as another parent of problem
-        mongo_store.collection.update_one(self.sequential_x1.to_deprecated_son('_id.'), {'$push': {'definition.children': str(self.problem_x1a_1)}})  # lint-amnesty, pylint: disable=no-member, line-too-long
-        # now check that "get_parent_location" method of published branch raises "ReferentialIntegrityError" for
-        # problem "problem_x1a_1" since it has now 2 valid published parents
-        with self.store.branch_setting(ModuleStoreEnum.Branch.published_only, course_id):
-            assert self.store.has_item(self.problem_x1a_1)  # lint-amnesty, pylint: disable=no-member
-            with pytest.raises(ReferentialIntegrityError):
-                self.store.get_parent_location(self.problem_x1a_1)  # lint-amnesty, pylint: disable=no-member
-
-    @ddt.data(ModuleStoreEnum.Type.mongo)
-    def test_create_item_from_parent_location(self, default_ms):
-        """
-        Test a code path missed by the above: passing an old-style location as parent but no
-        new location for the child
-        """
-        self.initdb(default_ms)
-        self.store.create_child(
-            self.user_id,
-            self.course_locations[self.MONGO_COURSEID],
-            'problem',
-            block_id='orphan'
-        )
-        orphans = self.store.get_orphans(self.course_locations[self.MONGO_COURSEID].course_key)
-        assert len(orphans) == 0, f'unexpected orphans: {orphans}'
-
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_create_item_populates_edited_info(self, default_ms):
         self.initdb(default_ms)
         block = self.store.create_item(
@@ -1998,7 +1842,7 @@ def test_create_item_populates_edited_info(self, default_ms):
         assert self.user_id == block.edited_by
         assert datetime.datetime.now(UTC) > block.edited_on
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_create_item_populates_subtree_edited_info(self, default_ms):
         self.initdb(default_ms)
         block = self.store.create_item(
@@ -2009,9 +1853,8 @@ def test_create_item_populates_subtree_edited_info(self, default_ms):
         assert self.user_id == block.subtree_edited_by
         assert datetime.datetime.now(UTC) > block.subtree_edited_on
 
-    # Draft: wildcard search of draft (find) and split (mysql)
     # Split: wildcard search of draft (find) and split (mysql)
-    @ddt.data((ModuleStoreEnum.Type.mongo, 1, 1, 0), (ModuleStoreEnum.Type.split, 1, 1, 0))
+    @ddt.data((ModuleStoreEnum.Type.split, 1, 1, 0))
     @ddt.unpack
     def test_get_courses_for_wiki(self, default_ms, num_mysql, max_find, max_send):
         """
@@ -2027,12 +1870,6 @@ def test_get_courses_for_wiki(self, default_ms, num_mysql, max_find, max_send):
         assert len(self.store.get_courses_for_wiki('edX.simple.2012_Fall')) == 0
         assert len(self.store.get_courses_for_wiki('no_such_wiki')) == 0
 
-    # Draft:
-    #    Find: find vertical, find children
-    #    Sends:
-    #      1. delete all of the published nodes in subtree
-    #      2. insert vertical as published (deleted in step 1) w/ the deleted problems as children
-    #      3-6. insert the 3 problems and 1 html as published
     # Split:
     #    MySQL SplitModulestoreCourseIndex:
     #      1. Select by course ID
@@ -2042,15 +1879,13 @@ def test_get_courses_for_wiki(self, default_ms, num_mysql, max_find, max_send):
     #    Sends:
     #      1. insert structure
     #      2. write index entry
-    @ddt.data((ModuleStoreEnum.Type.mongo, 0, 2, 6), (ModuleStoreEnum.Type.split, 4, 2, 2))
+    @ddt.data((ModuleStoreEnum.Type.split, 4, 2, 2))
     @ddt.unpack
     def test_unpublish(self, default_ms, num_mysql, max_find, max_send):
         """
         Test calling unpublish
         """
         self.initdb(default_ms)
-        if default_ms == ModuleStoreEnum.Type.mongo and mongo_uses_error_check(self.store):
-            max_find += 1
         self._create_block_hierarchy()
 
         # publish
@@ -2078,9 +1913,8 @@ def test_unpublish(self, default_ms, num_mysql, max_find, max_send):
         )
         assert draft_xblock is not None
 
-    # Draft: specific query for revision None
     # Split: active_versions from MySQL, structure from mongo
-    @ddt.data((ModuleStoreEnum.Type.mongo, 0, 1, 0), (ModuleStoreEnum.Type.split, 1, 1, 0))
+    @ddt.data((ModuleStoreEnum.Type.split, 1, 1, 0))
     @ddt.unpack
     def test_has_published_version(self, default_ms, mysql_queries, max_find, max_send):
         """
@@ -2121,7 +1955,7 @@ def test_has_published_version(self, default_ms, mysql_queries, max_find, max_se
         assert self.store.has_changes(item)
         assert self.store.has_published_version(item)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_update_edit_info_ancestors(self, default_ms):
         """
         Tests that edited_on, edited_by, subtree_edited_on, and subtree_edited_by are set correctly during update
@@ -2197,7 +2031,7 @@ def check_node(location_key, after, before, edited_by, subtree_after, subtree_be
         # Verify that others have unchanged edit info
         check_node(sibling.location, None, after_create, self.user_id, None, after_create, self.user_id)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_update_edit_info(self, default_ms):
         """
         Tests that edited_on and edited_by are set correctly during an update
@@ -2227,7 +2061,7 @@ def test_update_edit_info(self, default_ms):
         assert old_edited_on < updated_component.edited_on
         assert updated_component.edited_by == edit_user
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_update_published_info(self, default_ms):
         """
         Tests that published_on and published_by are set correctly
@@ -2261,7 +2095,7 @@ def test_update_published_info(self, default_ms):
         assert old_time <= updated_component.published_on
         assert updated_component.published_by == publish_user
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_auto_publish(self, default_ms):
         """
         Test that the correct things have been published automatically
@@ -2322,7 +2156,7 @@ def test_auto_publish(self, default_ms):
         chapter = self.store.get_item(chapter.location.for_branch(None))
         assert self.store.has_published_version(chapter)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_get_courses_for_wiki_shared(self, default_ms):
         """
         Test two courses sharing the same wiki
@@ -2360,7 +2194,7 @@ def test_get_courses_for_wiki_shared(self, default_ms):
         assert len(wiki_courses) == 0
         assert self.course_locations[self.MONGO_COURSEID].course_key.replace(branch=None) not in wiki_courses
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_branch_setting(self, default_ms):
         """
         Test the branch_setting context manager
@@ -2462,7 +2296,7 @@ def verify_default_store(self, store_type):
         course = self.store.create_course("org", "course{}".format(uuid4().hex[:5]), "run", self.user_id)
         assert course.system.modulestore.get_modulestore_type() == store_type
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_default_store(self, default_ms):
         """
         Test the default store context manager
@@ -2473,19 +2307,6 @@ def test_default_store(self, default_ms):
         with self.store.default_store(default_ms):
             self.verify_default_store(default_ms)
 
-    def test_default_store_nested(self):
-        """
-        Test the default store context manager, nested within one another
-        """
-        # initialize the mixed modulestore
-        self._initialize_mixed(mappings={})
-
-        with self.store.default_store(ModuleStoreEnum.Type.mongo):
-            self.verify_default_store(ModuleStoreEnum.Type.mongo)
-            with self.store.default_store(ModuleStoreEnum.Type.split):
-                self.verify_default_store(ModuleStoreEnum.Type.split)
-            self.verify_default_store(ModuleStoreEnum.Type.mongo)
-
     def test_default_store_fake(self):
         """
         Test the default store context manager, asking for a fake store
@@ -2509,8 +2330,6 @@ def save_asset(self, asset_key):
             self.store.contentstore.save(content)
 
     @ddt.data(
-        [ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.mongo],
-        [ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split],
         [ModuleStoreEnum.Type.split, ModuleStoreEnum.Type.split]
     )
     @ddt.unpack
@@ -2538,7 +2357,7 @@ def test_clone_course(self, source_modulestore, destination_modulestore):
             dest_store = self.store._get_modulestore_by_type(destination_modulestore)
             self.assertCoursesEqual(source_store, source_course_key, dest_store, dest_course_id)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_bulk_operations_signal_firing(self, default):
         """ Signals should be fired right before bulk_operations() exits. """
         with MongoContentstoreBuilder().build() as contentstore:
@@ -2584,7 +2403,7 @@ def _clear_bulk_ops_record(course_key):  # pylint: disable=unused-argument
 
                 signal_handler.send.assert_called_with('course_published', course_key=course.id)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_course_publish_signal_direct_firing(self, default):
         with MongoContentstoreBuilder().build() as contentstore:
             signal_handler = Mock(name='signal_handler')
@@ -2625,7 +2444,7 @@ def test_course_publish_signal_direct_firing(self, default):
                     self.store.publish(block.location, self.user_id)
                     signal_handler.send.assert_called_with('course_published', course_key=course.id)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_course_publish_signal_rerun_firing(self, default):
         with MongoContentstoreBuilder().build() as contentstore:
             signal_handler = Mock(name='signal_handler')
@@ -2655,7 +2474,7 @@ def test_course_publish_signal_rerun_firing(self, default):
                 self.store.clone_course(course_key, dest_course_id, self.user_id)
                 signal_handler.send.assert_called_with('course_published', course_key=dest_course_id)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_course_publish_signal_import_firing(self, default):
         with MongoContentstoreBuilder().build() as contentstore:
             signal_handler = Mock(name='signal_handler')
@@ -2688,7 +2507,7 @@ def test_course_publish_signal_import_firing(self, default):
                     call('course_published', course_key=self.store.make_course_key('edX', 'toy', '2012_Fall')),
                 ])
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_course_publish_signal_publish_firing(self, default):
         with MongoContentstoreBuilder().build() as contentstore:
             signal_handler = Mock(name='signal_handler')
@@ -2744,7 +2563,7 @@ def test_course_publish_signal_publish_firing(self, default):
                 self.store.delete_item(unit.location, self.user_id)
                 signal_handler.send.assert_called_with('course_published', course_key=course.id)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_bulk_course_publish_signal_direct_firing(self, default):
         with MongoContentstoreBuilder().build() as contentstore:
             signal_handler = Mock(name='signal_handler')
@@ -2786,7 +2605,7 @@ def test_bulk_course_publish_signal_direct_firing(self, default):
 
                 signal_handler.send.assert_called_with('course_published', course_key=course.id)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_bulk_course_publish_signal_publish_firing(self, default):
         with MongoContentstoreBuilder().build() as contentstore:
             signal_handler = Mock(name='signal_handler')
@@ -2855,7 +2674,7 @@ def test_bulk_course_publish_signal_publish_firing(self, default):
                     signal_handler.send.assert_not_called()
                 signal_handler.send.assert_not_called()
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_course_deleted_signal(self, default):
         with MongoContentstoreBuilder().build() as contentstore:
             signal_handler = Mock(name='signal_handler')
@@ -2883,7 +2702,7 @@ def test_course_deleted_signal(self, default):
                 # Verify that the signal was emitted
                 signal_handler.send.assert_called_with('course_deleted', course_key=course_key)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_delete_published_item_orphans(self, default_store):
         """
         Tests delete published item dont create any oprhans in course
@@ -2919,25 +2738,16 @@ def test_delete_published_item_orphans(self, default_store):
         assert len(course_orphans) == 0
         self.store.delete_item(vertical.location, self.user_id)
 
-        # No orphans in course after delete, except
-        # in old mongo, which still creates orphans
+        # No orphans in course after delete
         course_orphans = self.store.get_orphans(course_locator)
-        if default_store == ModuleStoreEnum.Type.mongo:
-            assert len(course_orphans) == 1
-        else:
-            assert len(course_orphans) == 0
+        assert len(course_orphans) == 0
 
         course_locator_publish = course_locator.for_branch(ModuleStoreEnum.BranchName.published)
-        # No published oprhans after delete, except
-        # in old mongo, which still creates orphans
+        # No published oprhans after delete
         course_publish_orphans = self.store.get_orphans(course_locator_publish)
+        assert len(course_publish_orphans) == 0
 
-        if default_store == ModuleStoreEnum.Type.mongo:
-            assert len(course_publish_orphans) == 1
-        else:
-            assert len(course_publish_orphans) == 0
-
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_delete_draft_item_orphans(self, default_store):
         """
         Tests delete draft item create no orphans in course
@@ -2978,23 +2788,14 @@ def test_delete_draft_item_orphans(self, default_store):
         assert self._has_changes(problem.location)
 
         self.store.delete_item(vertical.location, self.user_id)
-        # No orphans in course after delete, except
-        # in old mongo, which still creates them
+        # No orphans in course after delete
         course_orphans = self.store.get_orphans(course_locator)
-        if default_store == ModuleStoreEnum.Type.mongo:
-            assert len(course_orphans) == 1
-        else:
-            assert len(course_orphans) == 0
+        assert len(course_orphans) == 0
 
         course_locator_publish = course_locator.for_branch(ModuleStoreEnum.BranchName.published)
-        # No published orphans after delete, except
-        # in old mongo, which still creates them
+        # No published orphans after delete
         course_publish_orphans = self.store.get_orphans(course_locator_publish)
-
-        if default_store == ModuleStoreEnum.Type.mongo:
-            assert len(course_publish_orphans) == 1
-        else:
-            assert len(course_publish_orphans) == 0
+        assert len(course_publish_orphans) == 0
 
 
 @ddt.ddt
@@ -3051,7 +2852,7 @@ def _build_store(self, default_ms):
                 self._create_course(source_course_key)
                 yield contentstore, source_course_key
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_draft_has_changes_before_export_and_after_import(self, default_ms):
         """
         Tests that an unpublished unit remains with no changes across export and re-import.
@@ -3075,7 +2876,7 @@ def test_draft_has_changes_before_export_and_after_import(self, default_ms):
             # Verify that the imported block still is a draft, i.e. has changes.
             assert self._has_changes(draft_xblock.location)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_published_has_changes_before_export_and_after_import(self, default_ms):
         """
         Tests that an published unit remains published across export and re-import.
@@ -3102,7 +2903,7 @@ def test_published_has_changes_before_export_and_after_import(self, default_ms):
             # Verify that it still is published, i.e. has no changes.
             assert not self._has_changes(published_xblock.location)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_changed_published_has_changes_before_export_and_after_import(self, default_ms):
         """
         Tests that an published unit with an unpublished draft remains published across export and re-import.
@@ -3140,7 +2941,7 @@ def test_changed_published_has_changes_before_export_and_after_import(self, defa
                 component = self.store.get_item(published_xblock.location)
                 assert component.display_name == updated_display_name
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_seq_with_unpublished_vertical_has_changes_before_export_and_after_import(self, default_ms):
         """
         Tests that an published unit with an unpublished draft remains published across export and re-import.
@@ -3182,7 +2983,7 @@ def test_seq_with_unpublished_vertical_has_changes_before_export_and_after_impor
             assert self._has_changes(sequential.location)
             assert self._has_changes(vertical.location)
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_vertical_with_draft_and_published_unit_has_changes_before_export_and_after_import(self, default_ms):
         """
         Tests that an published unit with an unpublished draft remains published across export and re-import.
@@ -3264,7 +3065,7 @@ def test_vertical_with_draft_and_published_unit_has_changes_before_export_and_af
                 component = self.store.get_item(unit.location)
                 assert component.display_name == 'Text'
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     def test_vertical_with_published_unit_remains_published_before_export_and_after_import(self, default_ms):
         """
         Tests that an published unit remains published across export and re-import.
@@ -3324,7 +3125,7 @@ def test_vertical_with_published_unit_remains_published_before_export_and_after_
                 component = self.store.get_item(unit.location)
                 assert component.display_name == updated_display_name
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     @XBlockAside.register_temp_plugin(AsideTestType, 'test_aside')
     @patch('xmodule.modulestore.split_mongo.caching_descriptor_system.CachingDescriptorSystem.applicable_aside_types',
            lambda self, block: ['test_aside'])
@@ -3332,8 +3133,6 @@ def test_aside_crud(self, default_store):
         """
         Check that asides could be imported from XML and the modulestores handle asides crud
         """
-        if default_store == ModuleStoreEnum.Type.mongo:
-            pytest.skip("asides not supported in old mongo")
         with MongoContentstoreBuilder().build() as contentstore:
             self.store = MixedModuleStore(
                 contentstore=contentstore,
@@ -3398,13 +3197,11 @@ def check_block(block):
                 chapter_aside2 = new_chapter2.runtime.get_asides(new_chapter2)[0]
                 assert 'another one value' == chapter_aside2.data_field
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     @XBlockAside.register_temp_plugin(AsideTestType, 'test_aside')
     @patch('xmodule.modulestore.split_mongo.caching_descriptor_system.CachingDescriptorSystem.applicable_aside_types',
            lambda self, block: ['test_aside'])
     def test_export_course_with_asides(self, default_store):
-        if default_store == ModuleStoreEnum.Type.mongo:
-            pytest.skip("asides not supported in old mongo")
         with MongoContentstoreBuilder().build() as contentstore:
             self.store = MixedModuleStore(
                 contentstore=contentstore,
@@ -3485,13 +3282,11 @@ def check_block(block):
 
                 check_block(courses2[0])
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     @XBlockAside.register_temp_plugin(AsideTestType, 'test_aside')
     @patch('xmodule.modulestore.split_mongo.caching_descriptor_system.CachingDescriptorSystem.applicable_aside_types',
            lambda self, block: ['test_aside'])
     def test_export_course_after_creating_new_items_with_asides(self, default_store):  # pylint: disable=too-many-statements
-        if default_store == ModuleStoreEnum.Type.mongo:
-            pytest.skip("asides not supported in old mongo")
         with MongoContentstoreBuilder().build() as contentstore:
             self.store = MixedModuleStore(
                 contentstore=contentstore,
@@ -3618,7 +3413,7 @@ def setUp(self):
         field_data = KvsFieldData(key_store)
         self.runtime = TestRuntime(services={'field-data': field_data})
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     @XBlockAside.register_temp_plugin(AsideFoo, 'test_aside1')
     @XBlockAside.register_temp_plugin(AsideBar, 'test_aside2')
     @patch('xmodule.modulestore.split_mongo.caching_descriptor_system.CachingDescriptorSystem.applicable_aside_types',
@@ -3627,8 +3422,6 @@ def test_get_and_update_asides(self, default_store):
         """
         Tests that connected asides could be stored, received and updated along with connected course items
         """
-        if default_store == ModuleStoreEnum.Type.mongo:
-            pytest.skip("asides not supported in old mongo")
 
         self.initdb(default_store)
 
@@ -3683,7 +3476,7 @@ def _check_asides(asides, field11, field12, field21, field22):
         new_asides = new_component.runtime.get_asides(new_component)
         _check_asides(new_asides, 'other_value11', 'new_value12', 'new_value21', 'aside2_default_value2')
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     @XBlockAside.register_temp_plugin(AsideFoo, 'test_aside1')
     @patch('xmodule.modulestore.split_mongo.caching_descriptor_system.CachingDescriptorSystem.applicable_aside_types',
            lambda self, block: ['test_aside1'])
@@ -3691,9 +3484,6 @@ def test_clone_course_with_asides(self, default_store):
         """
         Tests that connected asides will be cloned together with the parent courses
         """
-        if default_store == ModuleStoreEnum.Type.mongo:
-            pytest.skip("asides not supported in old mongo")
-
         with MongoContentstoreBuilder().build() as contentstore:
             # initialize the mixed modulestore
             self._initialize_mixed(contentstore=contentstore, mappings={})
@@ -3731,7 +3521,7 @@ def test_clone_course_with_asides(self, default_store):
 
             assert chapter_is_found
 
-    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
+    @ddt.data(ModuleStoreEnum.Type.split)
     @XBlockAside.register_temp_plugin(AsideFoo, 'test_aside1')
     @patch('xmodule.modulestore.split_mongo.caching_descriptor_system.CachingDescriptorSystem.applicable_aside_types',
            lambda self, block: ['test_aside1'])
@@ -3739,9 +3529,6 @@ def test_delete_item_with_asides(self, default_store):
         """
         Tests that connected asides will be removed together with the connected items
         """
-        if default_store == ModuleStoreEnum.Type.mongo:
-            pytest.skip("asides not supported in old mongo")
-
         self.initdb(default_store)
 
         block_type1 = 'test_aside1'
@@ -3780,7 +3567,7 @@ def test_delete_item_with_asides(self, default_store):
         assert asides2[0].field11 == 'aside1_default_value1'
         assert asides2[0].field12 == 'aside1_default_value2'
 
-    @ddt.data((ModuleStoreEnum.Type.mongo, 1, 0), (ModuleStoreEnum.Type.split, 1, 0))
+    @ddt.data((ModuleStoreEnum.Type.split, 1, 0))
     @XBlockAside.register_temp_plugin(AsideFoo, 'test_aside1')
     @patch('xmodule.modulestore.split_mongo.caching_descriptor_system.CachingDescriptorSystem.applicable_aside_types',
            lambda self, block: ['test_aside1'])
@@ -3789,9 +3576,6 @@ def test_published_and_unpublish_item_with_asides(self, default_store, max_find,
         """
         Tests that public/unpublish doesn't affect connected stored asides
         """
-        if default_store == ModuleStoreEnum.Type.mongo:
-            pytest.skip("asides not supported in old mongo")
-
         self.initdb(default_store)
 
         block_type1 = 'test_aside1'
diff --git a/xmodule/modulestore/tests/test_mongo.py b/xmodule/modulestore/tests/test_mongo.py
index c4f61f1b05fe..3199ae6abe62 100644
--- a/xmodule/modulestore/tests/test_mongo.py
+++ b/xmodule/modulestore/tests/test_mongo.py
@@ -4,752 +4,21 @@
 
 
 import logging
-import shutil
-from datetime import datetime
-from tempfile import mkdtemp
-from unittest.mock import patch
-from uuid import uuid4
 
-import pymongo
 import pytest
 
 # pylint: disable=protected-access
 from django.test import TestCase
 # pylint: enable=E0611
-from opaque_keys.edx.keys import CourseKey, UsageKey
-from opaque_keys.edx.locator import AssetLocator, BlockUsageLocator, CourseLocator, LibraryLocator
-from path import Path as path
-from pytz import UTC
-from xblock.core import XBlock
+from opaque_keys.edx.keys import CourseKey
 from xblock.exceptions import InvalidScopeError
-from xblock.fields import Reference, ReferenceList, ReferenceValueDict, Scope
+from xblock.fields import Scope
 from xblock.runtime import KeyValueStore
 
-from xmodule.contentstore.mongo import MongoContentStore
-from xmodule.exceptions import NotFoundError
-from xmodule.modulestore import ModuleStoreEnum
-from xmodule.modulestore.draft import DraftModuleStore
-from xmodule.modulestore.edit_info import EditInfoMixin
-from xmodule.modulestore.exceptions import ItemNotFoundError
-from xmodule.modulestore.inheritance import InheritanceMixin
 from xmodule.modulestore.mongo import MongoKeyValueStore
-from xmodule.modulestore.mongo.base import as_draft
-from xmodule.modulestore.tests.mongo_connection import MONGO_HOST, MONGO_PORT_NUM
-from xmodule.modulestore.xml_exporter import export_course_to_xml
-from xmodule.modulestore.xml_importer import LocationMixin, import_course_from_xml, perform_xlint
-from xmodule.tests import DATA_DIR
-from xmodule.x_module import XModuleMixin
 
 log = logging.getLogger(__name__)
 
-HOST = MONGO_HOST
-PORT = MONGO_PORT_NUM
-DB = 'test_mongo_%s' % uuid4().hex[:5]
-COLLECTION = 'modulestore'
-ASSET_COLLECTION = 'assetstore'
-FS_ROOT = DATA_DIR  # TODO (vshnayder): will need a real fs_root for testing load_item
-DEFAULT_CLASS = 'xmodule.hidden_module.HiddenDescriptor'
-RENDER_TEMPLATE = lambda t_n, d, ctx=None, nsp='main': ''
-
-
-def assert_not_none(actual):
-    """
-    verify that item is None
-    """
-    assert actual is not None
-
-
-class ReferenceTestXBlock(XModuleMixin):
-    """
-    Test xblock type to test the reference field types
-    """
-    has_children = True
-    reference_link = Reference(default=None, scope=Scope.content)
-    reference_list = ReferenceList(scope=Scope.content)
-    reference_dict = ReferenceValueDict(scope=Scope.settings)
-
-
-class TestMongoModuleStoreBase(TestCase):
-    '''
-    Basic setup for all tests
-    '''
-    # Explicitly list the courses to load (don't want the big one)
-    courses = ['toy', 'simple', 'simple_with_draft', 'test_unicode']
-
-    @classmethod
-    def setUpClass(cls):  # lint-amnesty, pylint: disable=super-method-not-called
-        cls.connection = pymongo.MongoClient(
-            host=HOST,
-            port=PORT,
-            tz_aware=True,
-            document_class=dict,
-        )
-
-        # NOTE: Creating a single db for all the tests to save time.  This
-        # is ok only as long as none of the tests modify the db.
-        # If (when!) that changes, need to either reload the db, or load
-        # once and copy over to a tmp db for each test.
-        cls.content_store, cls.draft_store = cls.initdb()
-
-    @classmethod
-    def tearDownClass(cls):  # lint-amnesty, pylint: disable=super-method-not-called
-        if cls.connection:
-            cls.connection.drop_database(DB)
-            cls.connection.close()
-
-    @classmethod
-    def add_asset_collection(cls, doc_store_config):
-        """
-        No asset collection.
-        """
-        pass  # lint-amnesty, pylint: disable=unnecessary-pass
-
-    @classmethod
-    def initdb(cls):  # lint-amnesty, pylint: disable=missing-function-docstring
-        # connect to the db
-        doc_store_config = {
-            'host': HOST,
-            'port': PORT,
-            'db': DB,
-            'collection': COLLECTION,
-        }
-        cls.add_asset_collection(doc_store_config)
-
-        # since MongoModuleStore and MongoContentStore are basically assumed to be together, create this class
-        # as well
-        content_store = MongoContentStore(HOST, DB, port=PORT)
-        #
-        # Also test draft store imports
-        #
-        draft_store = DraftModuleStore(
-            content_store,
-            doc_store_config, FS_ROOT, RENDER_TEMPLATE,
-            default_class=DEFAULT_CLASS,
-            branch_setting_func=lambda: ModuleStoreEnum.Branch.draft_preferred,
-            xblock_mixins=(EditInfoMixin, InheritanceMixin, LocationMixin, XModuleMixin)
-
-        )
-
-        import_course_from_xml(
-            draft_store,
-            999,
-            DATA_DIR,
-            cls.courses,
-            static_content_store=content_store
-        )
-
-        # also test a course with no importing of static content
-        import_course_from_xml(
-            draft_store,
-            999,
-            DATA_DIR,
-            ['test_import_course'],
-            static_content_store=content_store,
-            do_import_static=False,
-            verbose=True
-        )
-
-        # also import a course under a different course_id (especially ORG)
-        import_course_from_xml(
-            draft_store,
-            999,
-            DATA_DIR,
-            ['test_import_course'],
-            static_content_store=content_store,
-            do_import_static=False,
-            verbose=True,
-            target_id=CourseKey.from_string('guestx/foo/bar')
-        )
-
-        # Import a course for `test_reference_converters` since it manipulates the saved course
-        # which can cause any other test using the same course to have a flakey error
-        import_course_from_xml(
-            draft_store,
-            999,
-            DATA_DIR,
-            ['test_import_course_2'],
-            static_content_store=content_store
-        )
-
-        return content_store, draft_store
-
-    @staticmethod
-    def destroy_db(connection):
-        # Destroy the test db.
-        connection.drop_database(DB)
-
-    def setUp(self):
-        super().setUp()
-        self.dummy_user = ModuleStoreEnum.UserID.test
-
-
-class TestMongoModuleStore(TestMongoModuleStoreBase):
-    '''Module store tests'''
-
-    @classmethod
-    def add_asset_collection(cls, doc_store_config):
-        """
-        No asset collection - it's not used in the tests below.
-        """
-        pass  # lint-amnesty, pylint: disable=unnecessary-pass
-
-    @classmethod
-    def setUpClass(cls):
-        super().setUpClass()
-
-    @classmethod
-    def tearDownClass(cls):
-        super().tearDownClass()
-
-    def test_init(self):
-        '''Make sure the db loads'''
-        ids = list(self.connection[DB][COLLECTION].find({}, {'_id': True}))
-        assert len(ids) > 12
-
-    def test_mongo_modulestore_type(self):
-        store = DraftModuleStore(
-            None,
-            {'host': HOST, 'db': DB, 'port': PORT, 'collection': COLLECTION},
-            FS_ROOT, RENDER_TEMPLATE, default_class=DEFAULT_CLASS
-        )
-        assert store.get_modulestore_type('') == ModuleStoreEnum.Type.mongo
-
-    def test_get_courses(self):
-        '''Make sure the course objects loaded properly'''
-        courses = self.draft_store.get_courses()
-
-        assert len(courses) == 7
-        course_ids = [course.id for course in courses]
-
-        for course_key in [
-
-            CourseKey.from_string('/'.join(fields))
-            for fields in [
-                ['edX', 'simple', '2012_Fall'],
-                ['edX', 'simple_with_draft', '2012_Fall'],
-                ['edX', 'test_import_course', '2012_Fall'],
-                ['edX', 'test_unicode', '2012_Fall'],
-                ['edX', 'toy', '2012_Fall'],
-                ['guestx', 'foo', 'bar'],
-                ['edX', 'test_import', '2014_Fall'],
-            ]
-        ]:
-            assert course_key in course_ids
-            course = self.draft_store.get_course(course_key)
-            assert course is not None
-            assert self.draft_store.has_course(course_key)
-            mix_cased = CourseKey.from_string(
-                '/'.join([course_key.org.upper(), course_key.course.upper(), course_key.run.lower()])
-            )
-            assert not self.draft_store.has_course(mix_cased)
-            assert self.draft_store.has_course(mix_cased, ignore_case=True)
-
-    def test_get_org_courses(self):
-        """
-        Make sure that we can query for a filtered list of courses for a given ORG
-        """
-
-        courses = self.draft_store.get_courses(org='guestx')
-        assert len(courses) == 1
-        course_ids = [course.id for course in courses]
-
-        for course_key in [
-            CourseKey.from_string('/'.join(fields))
-            for fields in [
-                ['guestx', 'foo', 'bar']
-            ]
-        ]:
-            assert course_key in course_ids
-
-        courses = self.draft_store.get_courses(org='edX')
-        assert len(courses) == 6
-        course_ids = [course.id for course in courses]
-
-        for course_key in [
-            CourseKey.from_string('/'.join(fields))
-            for fields in [
-                ['edX', 'simple', '2012_Fall'],
-                ['edX', 'simple_with_draft', '2012_Fall'],
-                ['edX', 'test_import_course', '2012_Fall'],
-                ['edX', 'test_unicode', '2012_Fall'],
-                ['edX', 'toy', '2012_Fall'],
-                ['edX', 'test_import', '2014_Fall'],
-            ]
-        ]:
-            assert course_key in course_ids
-
-    def test_no_such_course(self):
-        """
-        Test get_course and has_course with ids which don't exist
-        """
-        for course_key in [
-
-            CourseKey.from_string('/'.join(fields))
-            for fields in [
-                ['edX', 'simple', 'no_such_course'], ['edX', 'no_such_course', '2012_Fall'],
-                ['NO_SUCH_COURSE', 'Test_iMport_courSe', '2012_Fall'],
-            ]
-        ]:
-            course = self.draft_store.get_course(course_key)
-            assert course is None
-            assert not self.draft_store.has_course(course_key)
-            mix_cased = CourseKey.from_string(
-                '/'.join([course_key.org.lower(), course_key.course.upper(), course_key.run.upper()])
-            )
-            assert not self.draft_store.has_course(mix_cased)
-            assert not self.draft_store.has_course(mix_cased, ignore_case=True)
-
-    def test_get_mongo_course_with_split_course_key(self):
-        """
-        Test mongo course using split course_key will not able to access it.
-        """
-        course_key = CourseKey.from_string('course-v1:edX+simple+2012_Fall')
-
-        with pytest.raises(ItemNotFoundError):
-            self.draft_store.get_course(course_key)
-
-    def test_has_mongo_course_with_split_course_key(self):
-        """
-        Test `has course` using split course key would return False.
-        """
-        course_key = CourseKey.from_string('course-v1:edX+simple+2012_Fall')
-
-        assert not self.draft_store.has_course(course_key)
-
-    def test_has_course_with_library(self):
-        """
-        Test that has_course() returns False when called with a LibraryLocator.
-        This is required because MixedModuleStore will use has_course() to check
-        where a given library are stored.
-        """
-        lib_key = LibraryLocator("TestOrg", "TestLib")
-        result = self.draft_store.has_course(lib_key)
-        assert not result
-
-    def test_loads(self):
-        assert self.draft_store.get_item(BlockUsageLocator(CourseLocator('edX', 'toy', '2012_Fall', deprecated=True),
-                                                           'course', '2012_Fall', deprecated=True)) is not None
-
-        assert self.draft_store.get_item(BlockUsageLocator(CourseLocator('edX', 'simple', '2012_Fall', deprecated=True),
-                                                           'course', '2012_Fall', deprecated=True)) is not None
-
-        assert self.draft_store.get_item(BlockUsageLocator(CourseLocator('edX', 'toy', '2012_Fall', deprecated=True),
-                                                           'video', 'Welcome', deprecated=True)) is not None
-
-    def test_unicode_loads(self):
-        """
-        Test that getting items from the test_unicode course works
-        """
-        assert self.draft_store.get_item(
-            BlockUsageLocator(CourseLocator('edX', 'test_unicode', '2012_Fall', deprecated=True),
-                              'course', '2012_Fall', deprecated=True)) is not None
-        # All items with ascii-only filenames should load properly.
-        assert self.draft_store.get_item(
-            BlockUsageLocator(CourseLocator('edX', 'test_unicode', '2012_Fall', deprecated=True),
-                              'video', 'Welcome', deprecated=True)) is not None
-        assert self.draft_store.get_item(
-            BlockUsageLocator(CourseLocator('edX', 'test_unicode', '2012_Fall', deprecated=True),
-                              'video', 'Welcome', deprecated=True)) is not None
-        assert self.draft_store.get_item(
-            BlockUsageLocator(CourseLocator('edX', 'test_unicode', '2012_Fall', deprecated=True),
-                              'chapter', 'Overview', deprecated=True)) is not None
-
-    def test_find_one(self):
-        assert self.draft_store._find_one(
-            BlockUsageLocator(CourseLocator('edX', 'toy', '2012_Fall', deprecated=True),
-                              'course', '2012_Fall', deprecated=True)) is not None
-
-        assert self.draft_store._find_one(
-            BlockUsageLocator(CourseLocator('edX', 'simple', '2012_Fall', deprecated=True),
-                              'course', '2012_Fall', deprecated=True)) is not None
-
-        assert self.draft_store._find_one(BlockUsageLocator(CourseLocator('edX', 'toy', '2012_Fall', deprecated=True),
-                                          'video', 'Welcome', deprecated=True)) is not None
-
-    def test_xlinter(self):
-        '''
-        Run through the xlinter, we know the 'toy' course has violations, but the
-        number will continue to grow over time, so just check > 0
-        '''
-        assert perform_xlint(DATA_DIR, ['toy']) != 0
-
-    def test_get_courses_has_no_templates(self):
-        courses = self.draft_store.get_courses()
-        for course in courses:
-            assert not ((course.location.org == 'edx') and (course.location.course == 'templates')),\
-                f'{course} is a template course'
-
-    def test_contentstore_attrs(self):
-        """
-        Test getting, setting, and defaulting the locked attr and arbitrary attrs.
-        """
-        location = BlockUsageLocator(CourseLocator('edX', 'toy', '2012_Fall', deprecated=True),
-                                     'course', '2012_Fall', deprecated=True)
-        course_content, __ = self.content_store.get_all_content_for_course(location.course_key)
-        assert len(course_content) > 0
-        filter_params = _build_requested_filter('Images')
-        filtered_course_content, __ = self.content_store.get_all_content_for_course(
-            location.course_key, filter_params=filter_params)
-        assert len(filtered_course_content) < len(course_content)
-        # a bit overkill, could just do for content[0]
-        for content in course_content:
-            assert not content.get('locked', False)
-            asset_key = AssetLocator._from_deprecated_son(content.get('content_son', content['_id']), location.run)
-            assert not self.content_store.get_attr(asset_key, 'locked', False)
-            attrs = self.content_store.get_attrs(asset_key)
-            assert 'uploadDate' in attrs
-            assert not attrs.get('locked', False)
-            self.content_store.set_attr(asset_key, 'locked', True)
-            assert self.content_store.get_attr(asset_key, 'locked', False)
-            attrs = self.content_store.get_attrs(asset_key)
-            assert 'locked' in attrs
-            assert attrs['locked'] is True
-            self.content_store.set_attrs(asset_key, {'miscel': 99})
-            assert self.content_store.get_attr(asset_key, 'miscel') == 99
-
-        asset_key = AssetLocator._from_deprecated_son(
-            course_content[0].get('content_son', course_content[0]['_id']),
-            location.run
-        )
-        with pytest.raises(AttributeError):
-            self.content_store.set_attr(asset_key, 'md5', 'ff1532598830e3feac91c2449eaa60d6')
-        with pytest.raises(AttributeError):
-            self.content_store.set_attrs(asset_key, {'foo': 9, 'md5': 'ff1532598830e3feac91c2449eaa60d6'})
-        with pytest.raises(NotFoundError):
-            self.content_store.get_attr(
-                BlockUsageLocator(CourseLocator('bogus', 'bogus', 'bogus'), 'asset', 'bogus'),
-                'displayname'
-            )
-        with pytest.raises(NotFoundError):
-            self.content_store.set_attr(
-                BlockUsageLocator(CourseLocator('bogus', 'bogus', 'bogus'), 'asset', 'bogus'),
-                'displayname', 'hello'
-            )
-        with pytest.raises(NotFoundError):
-            self.content_store.get_attrs(BlockUsageLocator(CourseLocator('bogus', 'bogus', 'bogus'), 'asset', 'bogus'))
-        with pytest.raises(NotFoundError):
-            self.content_store.set_attrs(
-                BlockUsageLocator(CourseLocator('bogus', 'bogus', 'bogus'), 'asset', 'bogus'),
-                {'displayname': 'hello'}
-            )
-        with pytest.raises(NotFoundError):
-            self.content_store.set_attrs(
-                BlockUsageLocator(CourseLocator('bogus', 'bogus', 'bogus', deprecated=True),
-                                  'asset', None, deprecated=True),
-                {'displayname': 'hello'}
-            )
-
-    def test_get_courses_for_wiki(self):
-        """
-        Test the get_courses_for_wiki method
-        """
-        for course_number in self.courses:
-            course_locations = self.draft_store.get_courses_for_wiki(course_number)
-            assert len(course_locations) == 1
-            assert CourseKey.from_string('/'.join(['edX', course_number, '2012_Fall'])) == course_locations[0]
-
-        course_locations = self.draft_store.get_courses_for_wiki('no_such_wiki')
-        assert len(course_locations) == 0
-
-        # set toy course to share the wiki with simple course
-        toy_course = self.draft_store.get_course(CourseKey.from_string('edX/toy/2012_Fall'))
-        toy_course.wiki_slug = 'simple'
-        self.draft_store.update_item(toy_course, ModuleStoreEnum.UserID.test)
-
-        # now toy_course should not be retrievable with old wiki_slug
-        course_locations = self.draft_store.get_courses_for_wiki('toy')
-        assert len(course_locations) == 0
-
-        # but there should be two courses with wiki_slug 'simple'
-        course_locations = self.draft_store.get_courses_for_wiki('simple')
-        assert len(course_locations) == 2
-        for course_number in ['toy', 'simple']:
-            assert CourseKey.from_string('/'.join(['edX', course_number, '2012_Fall'])) in course_locations
-
-        # configure simple course to use unique wiki_slug.
-        simple_course = self.draft_store.get_course(CourseKey.from_string('edX/simple/2012_Fall'))
-        simple_course.wiki_slug = 'edX.simple.2012_Fall'
-        self.draft_store.update_item(simple_course, ModuleStoreEnum.UserID.test)
-        # it should be retrievable with its new wiki_slug
-        course_locations = self.draft_store.get_courses_for_wiki('edX.simple.2012_Fall')
-        assert len(course_locations) == 1
-        assert CourseKey.from_string('edX/simple/2012_Fall') in course_locations
-
-    @XBlock.register_temp_plugin(ReferenceTestXBlock, 'ref_test')
-    def test_reference_converters(self):
-        """
-        Test that references types get deserialized correctly
-        """
-        course_key = CourseKey.from_string('edX/test_import/2014_Fall')
-
-        def setup_test():
-            course = self.draft_store.get_course(course_key)
-            # can't use item factory as it depends on django settings
-            p1ele = self.draft_store.create_item(
-                99,
-                course_key,
-                'problem',
-                block_id='p1',
-                runtime=course.runtime
-            )
-            p2ele = self.draft_store.create_item(
-                99,
-                course_key,
-                'problem',
-                block_id='p2',
-                runtime=course.runtime
-            )
-            self.refloc = course.id.make_usage_key('ref_test', 'ref_test')  # lint-amnesty, pylint: disable=attribute-defined-outside-init
-            self.draft_store.create_item(
-                99,
-                self.refloc.course_key,
-                self.refloc.block_type,
-                block_id=self.refloc.block_id,
-                runtime=course.runtime,
-                fields={
-                    'reference_link': p1ele.location,
-                    'reference_list': [p1ele.location, p2ele.location],
-                    'reference_dict': {'p1': p1ele.location, 'p2': p2ele.location},
-                    'children': [p1ele.location, p2ele.location],
-                }
-            )
-
-        def check_xblock_fields():
-            def check_children(xblock):
-                for child in xblock.children:
-                    assert isinstance(child, UsageKey)
-
-            course = self.draft_store.get_course(course_key)
-            check_children(course)
-
-            refele = self.draft_store.get_item(self.refloc)
-            check_children(refele)
-            assert isinstance(refele.reference_link, UsageKey)
-            assert len(refele.reference_list) > 0
-            for ref in refele.reference_list:
-                assert isinstance(ref, UsageKey)
-            assert len(refele.reference_dict) > 0
-            for ref in refele.reference_dict.values():
-                assert isinstance(ref, UsageKey)
-
-        def check_mongo_fields():
-            def get_item(location):
-                return self.draft_store._find_one(as_draft(location))
-
-            def check_children(payload):
-                for child in payload['definition']['children']:
-                    assert isinstance(child, str)
-
-            refele = get_item(self.refloc)
-            check_children(refele)
-            assert isinstance(refele['definition']['data']['reference_link'], str)
-            assert len(refele['definition']['data']['reference_list']) > 0
-            for ref in refele['definition']['data']['reference_list']:
-                assert isinstance(ref, str)
-            assert len(refele['metadata']['reference_dict']) > 0
-            for ref in refele['metadata']['reference_dict'].values():
-                assert isinstance(ref, str)
-
-        setup_test()
-        check_xblock_fields()
-        check_mongo_fields()
-
-    @patch('xmodule.video_module.video_module.edxval_api', None)
-    def test_export_course_image(self):
-        """
-        Test to make sure that we have a course image in the contentstore,
-        then export it to ensure it gets copied to both file locations.
-        """
-        course_key = CourseKey.from_string('edX/simple/2012_Fall')
-        location = course_key.make_asset_key('asset', 'images_course_image.jpg')
-
-        # This will raise if the course image is missing
-        self.content_store.find(location)
-
-        root_dir = path(mkdtemp())
-        self.addCleanup(shutil.rmtree, root_dir)
-        export_course_to_xml(self.draft_store, self.content_store, course_key, root_dir, 'test_export')
-        assert path(root_dir / 'test_export/static/images/course_image.jpg').isfile()
-        assert path(root_dir / 'test_export/static/images_course_image.jpg').isfile()
-
-    @patch('xmodule.video_module.video_module.edxval_api', None)
-    def test_export_course_image_nondefault(self):
-        """
-        Make sure that if a non-default image path is specified that we
-        don't export it to the static default location
-        """
-        course = self.draft_store.get_course(CourseKey.from_string('edX/toy/2012_Fall'))
-        assert course.course_image == 'just_a_test.jpg'
-
-        root_dir = path(mkdtemp())
-        self.addCleanup(shutil.rmtree, root_dir)
-        export_course_to_xml(self.draft_store, self.content_store, course.id, root_dir, 'test_export')
-        assert path(root_dir / 'test_export/static/just_a_test.jpg').isfile()
-        assert not path(root_dir / 'test_export/static/images/course_image.jpg').isfile()
-
-    @patch('xmodule.video_module.video_module.edxval_api', None)
-    def test_course_without_image(self):
-        """
-        Make sure we elegantly passover our code when there isn't a static
-        image
-        """
-        course = self.draft_store.get_course(CourseKey.from_string('edX/simple_with_draft/2012_Fall'))
-        root_dir = path(mkdtemp())
-        self.addCleanup(shutil.rmtree, root_dir)
-        export_course_to_xml(self.draft_store, self.content_store, course.id, root_dir, 'test_export')
-        assert not path(root_dir / 'test_export/static/images/course_image.jpg').isfile()
-        assert not path(root_dir / 'test_export/static/images_course_image.jpg').isfile()
-
-    def _create_test_tree(self, name, user_id=None):
-        """
-        Creates and returns a tree with the following structure:
-        Grandparent
-            Parent Sibling
-            Parent
-                Child
-                Child Sibling
-
-        """
-        if user_id is None:
-            user_id = self.dummy_user
-
-        org = 'edX'
-        course = f'tree{name}'
-        run = name
-
-        if not self.draft_store.has_course(CourseKey.from_string('/'.join[org, course, run])):  # lint-amnesty, pylint: disable=unsubscriptable-object
-            self.draft_store.create_course(org, course, run, user_id)
-
-            locations = {
-                'grandparent': BlockUsageLocator(CourseLocator(org, course, run, deprecated=True),
-                                                 'chapter', 'grandparent', deprecated=True),
-                'parent_sibling': BlockUsageLocator(CourseLocator(org, course, run, deprecated=True),
-                                                    'sequential', 'parent_sibling', deprecated=True),
-                'parent': BlockUsageLocator(CourseLocator(org, course, run, deprecated=True),
-                                            'sequential', 'parent', deprecated=True),
-                'child_sibling': BlockUsageLocator(CourseLocator(org, course, run, deprecated=True),
-                                                   'vertical', 'child_sibling', deprecated=True),
-                'child': BlockUsageLocator(CourseLocator(org, course, run, deprecated=True),
-                                           'vertical', 'child', deprecated=True),
-            }
-
-            for key in locations:
-                self.draft_store.create_item(
-                    user_id,
-                    locations[key].course_key,
-                    locations[key].block_type,
-                    block_id=locations[key].block_id
-                )
-
-            grandparent = self.draft_store.get_item(locations['grandparent'])
-            grandparent.children += [locations['parent_sibling'], locations['parent']]
-            self.draft_store.update_item(grandparent, user_id=user_id)
-
-            parent = self.draft_store.get_item(locations['parent'])
-            parent.children += [locations['child_sibling'], locations['child']]
-            self.draft_store.update_item(parent, user_id=user_id)
-
-            self.draft_store.publish(locations['parent'], user_id)
-            self.draft_store.publish(locations['parent_sibling'], user_id)
-
-        return locations
-
-    def test_migrate_published_info(self):
-        """
-        Tests that blocks that were storing published_date and published_by through CMSBlockMixin are loaded correctly
-        """
-
-        # Insert the test block directly into the module store
-        location = BlockUsageLocator(CourseLocator('edX', 'migration', '2012_Fall', deprecated=True),
-                                     'html', 'test_html', deprecated=True)
-        published_date = datetime(1970, 1, 1, tzinfo=UTC)
-        published_by = 123
-        self.draft_store._update_single_item(
-            as_draft(location),
-            {
-                'definition.data': {},
-                'metadata': {
-                    # published_date was previously stored as a list of time components, not a datetime
-                    'published_date': list(published_date.timetuple()),
-                    'published_by': published_by,
-                },
-            },
-            allow_not_found=True,
-        )
-
-        # Retrieve the block and verify its fields
-        component = self.draft_store.get_item(location)
-        assert component.published_on == published_date
-        assert component.published_by == published_by
-
-    def test_draft_modulestore_create_child_with_position(self):
-        """
-        This test is designed to hit a specific set of use cases having to do with
-        the child positioning logic found in mongo/base.py:create_child()
-        """
-        # Set up the draft module store
-        course = self.draft_store.create_course("TestX", "ChildTest", "1234_A1", 1)
-        first_child = self.draft_store.create_child(
-            self.dummy_user,
-            course.location,
-            "chapter",
-            block_id=course.location.block_id
-        )
-        second_child = self.draft_store.create_child(
-            self.dummy_user,
-            course.location,
-            "chapter",
-            block_id=course.location.block_id,
-            position=0
-        )
-
-        # First child should have been moved to second position, and better child takes the lead
-        course = self.draft_store.get_course(course.id)
-        assert str(course.children[1]) == str(first_child.location)
-        assert str(course.children[0]) == str(second_child.location)
-
-        # Clean up the data so we don't break other tests which apparently expect a particular state
-        self.draft_store.delete_course(course.id, self.dummy_user)
-
-    def test_make_course_usage_key(self):
-        """Test that we get back the appropriate usage key for the root of a course key."""
-        course_key = CourseLocator(org="edX", course="101", run="2015")
-        root_block_key = self.draft_store.make_course_usage_key(course_key)
-        assert root_block_key.block_type == 'course'
-        assert root_block_key.block_id == '2015'
-
-
-class TestMongoModuleStoreWithNoAssetCollection(TestMongoModuleStore):  # lint-amnesty, pylint: disable=test-inherits-tests
-    '''
-    Tests a situation where no asset_collection is specified.
-    '''
-
-    @classmethod
-    def add_asset_collection(cls, doc_store_config):
-        """
-        No asset collection.
-        """
-        pass  # lint-amnesty, pylint: disable=unnecessary-pass
-
-    @classmethod
-    def setUpClass(cls):
-        super().setUpClass()
-
-    @classmethod
-    def tearDownClass(cls):
-        super().tearDownClass()
-
-    def test_no_asset_collection(self):
-        courses = self.draft_store.get_courses()
-        course = courses[0]
-        # Confirm that no specified asset collection name means empty asset metadata.
-        assert not self.draft_store.get_all_asset_metadata(course.id, 'asset')
-
-    def test_no_asset_invalid_key(self):
-        course_key = CourseLocator(org="edx3", course="test_course", run=None, deprecated=True)
-        # Confirm that invalid course key raises ItemNotFoundError
-        pytest.raises(ItemNotFoundError, (lambda: self.draft_store.get_all_asset_metadata(course_key, 'asset')[:1]))
-
 
 class TestMongoKeyValueStore(TestCase):
     """
@@ -821,37 +90,3 @@ def test_delete_invalid_scope(self):
         for scope in (Scope.preferences, Scope.user_info, Scope.user_state, Scope.parent):
             with pytest.raises(InvalidScopeError):
                 self.kvs.delete(KeyValueStore.Key(scope, None, None, 'foo'))
-
-
-def _build_requested_filter(requested_filter):
-    """
-    Returns requested filter_params string.
-    """
-
-    # Files and Uploads type filter values
-    all_filters = {
-        "Images": ['image/png', 'image/jpeg', 'image/jpg', 'image/gif', 'image/tiff', 'image/tif', 'image/x-icon'],
-        "Documents": [
-            'application/pdf',
-            'text/plain',
-            'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-            'application/vnd.openxmlformats-officedocument.wordprocessingml.template',
-            'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-            'application/vnd.openxmlformats-officedocument.presentationml.slideshow',
-            'application/vnd.openxmlformats-officedocument.presentationml.template',
-            'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-            'application/vnd.openxmlformats-officedocument.spreadsheetml.template',
-            'application/msword',
-            'application/vnd.ms-excel',
-            'application/vnd.ms-powerpoint',
-        ],
-    }
-    requested_file_types = all_filters.get(requested_filter, None)
-    filter_params = {
-        '$or': [{
-            'contentType': {
-                '$in': requested_file_types,
-            },
-        }]
-    }
-    return filter_params
diff --git a/xmodule/modulestore/tests/test_mongo_call_count.py b/xmodule/modulestore/tests/test_mongo_call_count.py
index ba618da8f329..3f5f0f36aad2 100644
--- a/xmodule/modulestore/tests/test_mongo_call_count.py
+++ b/xmodule/modulestore/tests/test_mongo_call_count.py
@@ -17,13 +17,11 @@
     TEST_DATA_DIR,
     MemoryCache,
     MixedModulestoreBuilder,
-    MongoModulestoreBuilder,
     VersioningModulestoreBuilder
 )
 from xmodule.modulestore.xml_exporter import export_course_to_xml
 from xmodule.modulestore.xml_importer import import_course_from_xml
 
-MIXED_OLD_MONGO_MODULESTORE_BUILDER = MixedModulestoreBuilder([('draft', MongoModulestoreBuilder())])
 MIXED_SPLIT_MODULESTORE_BUILDER = MixedModulestoreBuilder([('split', VersioningModulestoreBuilder())])
 
 
@@ -40,8 +38,7 @@ def setUp(self):
         self.addCleanup(rmtree, self.export_dir, ignore_errors=True)
 
     @ddt.data(
-        (MIXED_OLD_MONGO_MODULESTORE_BUILDER, 287, 779, 702, 702),
-        (MIXED_SPLIT_MODULESTORE_BUILDER, 37, 16, 190, 189),
+        (MIXED_SPLIT_MODULESTORE_BUILDER, 37, 16, 190, 189)
     )
     @ddt.unpack
     def test_import_export(self, store_builder, export_reads, import_reads, first_import_writes, second_import_writes):
@@ -141,19 +138,6 @@ def _import_course(self, content_store, modulestore):
     @ddt.data(
         # These two lines show the way this traversal *should* be done
         # (if you'll eventually access all the fields and load all the definitions anyway).
-        # 'lazy' does not matter in old Mongo.
-        (MIXED_OLD_MONGO_MODULESTORE_BUILDER, None, False, True, 175),
-        (MIXED_OLD_MONGO_MODULESTORE_BUILDER, None, True, True, 175),
-        (MIXED_OLD_MONGO_MODULESTORE_BUILDER, 0, False, True, 359),
-        (MIXED_OLD_MONGO_MODULESTORE_BUILDER, 0, True, True, 359),
-        # As shown in these two lines: whether or not the XBlock fields are accessed,
-        # the same number of mongo calls are made in old Mongo for depth=None.
-        (MIXED_OLD_MONGO_MODULESTORE_BUILDER, None, False, False, 175),
-        (MIXED_OLD_MONGO_MODULESTORE_BUILDER, None, True, False, 175),
-        (MIXED_OLD_MONGO_MODULESTORE_BUILDER, 0, False, False, 359),
-        (MIXED_OLD_MONGO_MODULESTORE_BUILDER, 0, True, False, 359),
-        # The line below shows the way this traversal *should* be done
-        # (if you'll eventually access all the fields and load all the definitions anyway).
         (MIXED_SPLIT_MODULESTORE_BUILDER, None, False, True, 2),
         (MIXED_SPLIT_MODULESTORE_BUILDER, None, True, True, 37),
         (MIXED_SPLIT_MODULESTORE_BUILDER, 0, False, True, 37),
@@ -177,7 +161,6 @@ def test_number_mongo_calls(self, store_builder, depth, lazy, access_all_block_f
                     self._traverse_blocks_in_course(start_block, access_all_block_fields)
 
     @ddt.data(
-        (MIXED_OLD_MONGO_MODULESTORE_BUILDER, 176),
         (MIXED_SPLIT_MODULESTORE_BUILDER, 3),
     )
     @ddt.unpack
diff --git a/xmodule/modulestore/tests/test_publish.py b/xmodule/modulestore/tests/test_publish.py
index c2a4b168487e..beccdfff7ea3 100644
--- a/xmodule/modulestore/tests/test_publish.py
+++ b/xmodule/modulestore/tests/test_publish.py
@@ -16,153 +16,17 @@
 import pytest
 import ddt
 
-from openedx.core.lib.tests import attr
 from xmodule.exceptions import InvalidVersionError
 from xmodule.modulestore import ModuleStoreEnum
 from xmodule.modulestore.exceptions import ItemNotFoundError
-from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory, check_mongo_calls, mongo_uses_error_check
-from xmodule.modulestore.tests.test_split_w_old_mongo import SplitWMongoCourseBootstrapper
+from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
 from xmodule.modulestore.tests.utils import (
-    DRAFT_MODULESTORE_SETUP,
-    MODULESTORE_SETUPS,
     SPLIT_MODULESTORE_SETUP,
     MongoContentstoreBuilder,
-    MongoModulestoreBuilder
 )
 from xmodule.modulestore.xml_exporter import export_course_to_xml
 
 
-@attr('mongo')
-class TestPublish(SplitWMongoCourseBootstrapper):
-    """
-    Test the publish code (primary causing orphans)
-    """
-    def _create_course(self):  # lint-amnesty, pylint: disable=arguments-differ
-        """
-        Create the course, publish all verticals
-        * some detached items
-        """
-        # There are 12 created items and 7 parent updates
-        # create course: finds: 1 to verify uniqueness, 1 to find parents
-        # sends: 1 to create course, 1 to create overview
-        with check_mongo_calls(4, 2):
-            super()._create_course(split=False)  # 2 inserts (course and overview)
-
-        # with bulk will delay all inheritance computations which won't be added into the mongo_calls
-        with self.draft_mongo.bulk_operations(self.old_course_key):
-            # finds: 1 for parent to add child and 2 to get ancestors
-            # sends: 1 for insert, 1 for parent (add child)
-            with check_mongo_calls(3, 2):
-                self._create_item('chapter', 'Chapter1', {}, {'display_name': 'Chapter 1'}, 'course', 'runid', split=False)  # lint-amnesty, pylint: disable=line-too-long
-
-            with check_mongo_calls(4, 2):
-                self._create_item('chapter', 'Chapter2', {}, {'display_name': 'Chapter 2'}, 'course', 'runid', split=False)  # lint-amnesty, pylint: disable=line-too-long
-            # For each vertical (2) created:
-            #   - load draft
-            #   - load non-draft
-            #   - get last error
-            #   - load parent
-            #   - get ancestors
-            #   - load inheritable data
-            with check_mongo_calls(15, 6):
-                self._create_item('vertical', 'Vert1', {}, {'display_name': 'Vertical 1'}, 'chapter', 'Chapter1', split=False)  # lint-amnesty, pylint: disable=line-too-long
-                self._create_item('vertical', 'Vert2', {}, {'display_name': 'Vertical 2'}, 'chapter', 'Chapter1', split=False)  # lint-amnesty, pylint: disable=line-too-long
-            # For each (4) item created
-            #   - try to find draft
-            #   - try to find non-draft
-            #   - compute what is parent
-            #   - load draft parent again & compute its parent chain up to course
-            # count for updates increased to 16 b/c of edit_info updating
-            with check_mongo_calls(36, 16):
-                self._create_item('html', 'Html1', "<p>Goodbye</p>", {'display_name': 'Parented Html'}, 'vertical', 'Vert1', split=False)  # lint-amnesty, pylint: disable=line-too-long
-                self._create_item(
-                    'discussion', 'Discussion1',
-                    "discussion discussion_category=\"Lecture 1\" discussion_id=\"a08bfd89b2aa40fa81f2c650a9332846\" discussion_target=\"Lecture 1\"/>\n",  # lint-amnesty, pylint: disable=line-too-long
-                    {
-                        "discussion_category": "Lecture 1",
-                        "discussion_target": "Lecture 1",
-                        "display_name": "Lecture 1 Discussion",
-                        "discussion_id": "a08bfd89b2aa40fa81f2c650a9332846"
-                    },
-                    'vertical', 'Vert1',
-                    split=False
-                )
-                self._create_item('html', 'Html2', "<p>Hello</p>", {'display_name': 'Hollow Html'}, 'vertical', 'Vert1', split=False)  # lint-amnesty, pylint: disable=line-too-long
-                self._create_item(
-                    'discussion', 'Discussion2',
-                    "discussion discussion_category=\"Lecture 2\" discussion_id=\"b08bfd89b2aa40fa81f2c650a9332846\" discussion_target=\"Lecture 2\"/>\n",  # lint-amnesty, pylint: disable=line-too-long
-                    {
-                        "discussion_category": "Lecture 2",
-                        "discussion_target": "Lecture 2",
-                        "display_name": "Lecture 2 Discussion",
-                        "discussion_id": "b08bfd89b2aa40fa81f2c650a9332846"
-                    },
-                    'vertical', 'Vert2',
-                    split=False
-                )
-
-            with check_mongo_calls(2, 2):
-                # 2 finds b/c looking for non-existent parents
-                self._create_item('static_tab', 'staticuno', "<p>tab</p>", {'display_name': 'Tab uno'}, None, None, split=False)  # lint-amnesty, pylint: disable=line-too-long
-                self._create_item('course_info', 'updates', "<ol><li><h2>Sep 22</h2><p>test</p></li></ol>", {}, None, None, split=False)  # lint-amnesty, pylint: disable=line-too-long
-
-    def test_publish_draft_delete(self):
-        """
-        To reproduce a bug (STUD-811) publish a vertical, convert to draft, delete a child, move a child, publish.
-        See if deleted and moved children still is connected or exists in db (bug was disconnected but existed)
-        """
-        vert_location = self.old_course_key.make_usage_key('vertical', block_id='Vert1')
-        item = self.draft_mongo.get_item(vert_location, 2)
-        # Finds:
-        #   1 get draft vert,
-        #   2 compute parent
-        #   3-14 for each child: (3 children x 4 queries each)
-        #      get draft, compute parent, and then published child
-        #      compute inheritance
-        #   15 get published vert
-        #   16-18 get ancestor chain
-        #   19 compute inheritance #   20-22 get draft and published vert, compute parent
-        # Sends:
-        #   delete the subtree of drafts (1 call),
-        #   update the published version of each node in subtree (4 calls),
-        #   update the ancestors up to course (2 calls)
-        if mongo_uses_error_check(self.draft_mongo):
-            max_find = 23
-        else:
-            max_find = 22
-        with check_mongo_calls(max_find, 7):
-            self.draft_mongo.publish(item.location, self.user_id)
-
-        # verify status
-        item = self.draft_mongo.get_item(vert_location, 0)
-        assert not getattr(item, 'is_draft', False), 'Item was published. Draft should not exist'
-        # however, children are still draft, but I'm not sure that's by design
-
-        # delete the draft version of the discussion
-        location = self.old_course_key.make_usage_key('discussion', block_id='Discussion1')
-        self.draft_mongo.delete_item(location, self.user_id)
-
-        draft_vert = self.draft_mongo.get_item(vert_location, 0)
-        assert getattr(draft_vert, 'is_draft', False), "Deletion didn't convert parent to draft"
-        assert location not in draft_vert.children
-        # move the other child
-        other_child_loc = self.old_course_key.make_usage_key('html', block_id='Html2')
-        draft_vert.children.remove(other_child_loc)
-        other_vert = self.draft_mongo.get_item(self.old_course_key.make_usage_key('vertical', block_id='Vert2'), 0)
-        other_vert.children.append(other_child_loc)
-        self.draft_mongo.update_item(draft_vert, self.user_id)
-        self.draft_mongo.update_item(other_vert, self.user_id)
-        # publish
-        self.draft_mongo.publish(vert_location, self.user_id)
-        item = self.draft_mongo.get_item(draft_vert.location, revision=ModuleStoreEnum.RevisionOption.published_only)
-        assert location not in item.children
-        assert self.draft_mongo.get_parent_location(location) is None
-        with pytest.raises(ItemNotFoundError):
-            self.draft_mongo.get_item(location)
-        assert other_child_loc not in item.children
-        assert self.draft_mongo.has_item(other_child_loc), 'Oops, lost moved item'
-
-
 @pytest.mark.django_db  # required if using split modulestore
 class DraftPublishedOpTestCourseSetup(unittest.TestCase):
     """
@@ -552,13 +416,6 @@ def is_split_modulestore(self):
         """
         return self.store.get_modulestore_type(self.course.id) == ModuleStoreEnum.Type.split
 
-    @property
-    def is_old_mongo_modulestore(self):
-        """
-        ``True`` when modulestore under test is a MongoModuleStore.
-        """
-        return self.store.get_modulestore_type(self.course.id) == ModuleStoreEnum.Type.mongo
-
     def _make_new_export_dir_name(self):
         """
         Make a unique name for the new export dir.
@@ -646,7 +503,7 @@ class ElementalPublishingTests(DraftPublishedOpBaseTestSetup):
     """
     Tests for the publish() operation.
     """
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_autopublished_chapters_sequentials(self, modulestore_builder):
         with self._setup_test(modulestore_builder):
             # When a course is created out of chapters/sequentials/verticals/units
@@ -665,15 +522,6 @@ def test_autopublished_chapters_sequentials(self, modulestore_builder):
             self.assertOLXIsPublishedOnly(block_list_autopublished)
             self.assertOLXIsDraftOnly(block_list_draft)
 
-    @ddt.data(DRAFT_MODULESTORE_SETUP, MongoModulestoreBuilder())
-    def test_publish_old_mongo_unit(self, modulestore_builder):
-        with self._setup_test(modulestore_builder):
-
-            # MODULESTORE_DIFFERENCE:
-            # In old Mongo, you can successfully publish an item whose parent
-            # isn't published.
-            self.publish((('html', 'html00'),))
-
     @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_publish_split_unit(self, modulestore_builder):
         with self._setup_test(modulestore_builder):
@@ -685,7 +533,7 @@ def test_publish_split_unit(self, modulestore_builder):
             with pytest.raises(ItemNotFoundError):
                 self.publish((('html', 'html00'),))
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_publish_multiple_verticals(self, modulestore_builder):
         with self._setup_test(modulestore_builder):
 
@@ -732,7 +580,7 @@ def test_publish_multiple_verticals(self, modulestore_builder):
             # Ensure that the untouched vertical and children are still untouched.
             self.assertOLXIsDraftOnly(block_list_untouched)
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_publish_single_sequential(self, modulestore_builder):
         """
         Sequentials are auto-published. But publishing them explictly publishes their children,
@@ -762,7 +610,7 @@ def test_publish_single_sequential(self, modulestore_builder):
             # Ensure that the verticals and their children are published in the exported OLX.
             self.assertOLXIsPublishedOnly(block_list)
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_publish_single_chapter(self, modulestore_builder):
         """
         Chapters are auto-published.
@@ -820,7 +668,7 @@ class ElementalUnpublishingTests(DraftPublishedOpBaseTestSetup):
     """
     Tests for the unpublish() operation.
     """
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_unpublish_draft_unit(self, modulestore_builder):
         with self._setup_test(modulestore_builder):
 
@@ -833,7 +681,7 @@ def test_unpublish_draft_unit(self, modulestore_builder):
             with pytest.raises(ItemNotFoundError):
                 self.unpublish(block_list_to_unpublish)
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_unpublish_published_units(self, modulestore_builder):
         with self._setup_test(modulestore_builder):
 
@@ -861,14 +709,10 @@ def test_unpublish_published_units(self, modulestore_builder):
                 # Split:
                 # The parent now has a draft *and* published item.
                 self.assertOLXIsDraftAndPublished(block_list_parent)
-            elif self.is_old_mongo_modulestore:
-                # Old Mongo:
-                # The parent remains published only.
-                self.assertOLXIsPublishedOnly(block_list_parent)
             else:
                 raise Exception("Must test either Old Mongo or Split modulestore!")
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_unpublish_draft_vertical(self, modulestore_builder):
         with self._setup_test(modulestore_builder):
 
@@ -881,7 +725,7 @@ def test_unpublish_draft_vertical(self, modulestore_builder):
             with pytest.raises(ItemNotFoundError):
                 self.unpublish(block_list_to_unpublish)
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_unpublish_published_vertical(self, modulestore_builder):
         with self._setup_test(modulestore_builder):
 
@@ -923,7 +767,7 @@ def test_unpublish_published_vertical(self, modulestore_builder):
             self.assertOLXIsDraftOnly(block_list_unpublished_children)
             self.assertOLXIsDraftOnly(block_list_untouched)
 
-    @ddt.data(SPLIT_MODULESTORE_SETUP, DRAFT_MODULESTORE_SETUP, MongoModulestoreBuilder())
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_unpublish_draft_sequential(self, modulestore_builder):
         with self._setup_test(modulestore_builder):
 
@@ -947,7 +791,7 @@ def _check_for_item_deletion(self, block_list, expected_result):
         assert_method(block_list)
 
     @ddt.data(*itertools.product(
-        MODULESTORE_SETUPS,
+        (SPLIT_MODULESTORE_SETUP,),
         (
             (ModuleStoreEnum.RevisionOption.published_only, 'assertOLXIsDraftOnly'),
             (ModuleStoreEnum.RevisionOption.all, 'assertOLXIsDeleted'),
@@ -965,12 +809,7 @@ def test_delete_draft_unit(self, modulestore_builder, revision_and_result):
             # The unit is a draft.
             self.assertOLXIsDraftOnly(block_list_to_delete)
             # MODULESTORE_DIFFERENCE:
-            if self.is_old_mongo_modulestore:
-                # Old Mongo throws no exception when trying to delete an item from the published branch
-                # that isn't yet published.
-                self.delete_item(block_list_to_delete, revision=revision)
-                self._check_for_item_deletion(block_list_to_delete, result)
-            elif self.is_split_modulestore:
+            if self.is_split_modulestore:
                 if revision in (ModuleStoreEnum.RevisionOption.published_only, ModuleStoreEnum.RevisionOption.all):
                     # Split throws an exception when trying to delete an item from the published branch
                     # that isn't yet published.
@@ -982,47 +821,6 @@ def test_delete_draft_unit(self, modulestore_builder, revision_and_result):
             else:
                 raise Exception("Must test either Old Mongo or Split modulestore!")
 
-    @ddt.data(*itertools.product(
-        (DRAFT_MODULESTORE_SETUP, MongoModulestoreBuilder()),
-        (
-            # MODULESTORE_DIFFERENCE: This first line is different between old Mongo and Split for verticals.
-            # Old Mongo deletes the draft vertical even when published_only is specified.
-            (ModuleStoreEnum.RevisionOption.published_only, 'assertOLXIsDeleted'),
-            (ModuleStoreEnum.RevisionOption.all, 'assertOLXIsDeleted'),
-            (None, 'assertOLXIsDeleted'),
-        )
-    ))
-    @ddt.unpack
-    def test_old_mongo_delete_draft_vertical(self, modulestore_builder, revision_and_result):
-        with self._setup_test(modulestore_builder):
-
-            block_list_to_delete = (
-                ('vertical', 'vertical03'),
-            )
-            block_list_children = (
-                ('html', 'html06'),
-                ('html', 'html07'),
-            )
-            (revision, result) = revision_and_result
-            # The vertical is a draft.
-            self.assertOLXIsDraftOnly(block_list_to_delete)
-            # MODULESTORE_DIFFERENCE:
-            # Old Mongo throws no exception when trying to delete an item from the published branch
-            # that isn't yet published.
-            self.delete_item(block_list_to_delete, revision=revision)
-            self._check_for_item_deletion(block_list_to_delete, result)
-            # MODULESTORE_DIFFERENCE:
-            # Weirdly, this is a difference between old Mongo -and- old Mongo wrapped with a mixed modulestore.
-            # When the code attempts and fails to delete the draft vertical using the published_only revision,
-            # the draft children are still around in one case and not in the other? Needs investigation.
-            if (
-                isinstance(modulestore_builder, MongoModulestoreBuilder) and
-                revision == ModuleStoreEnum.RevisionOption.published_only
-            ):
-                self.assertOLXIsDraftOnly(block_list_children)
-            else:
-                self.assertOLXIsDeleted(block_list_children)
-
     @ddt.data(*itertools.product(
         (SPLIT_MODULESTORE_SETUP,),
         (
@@ -1059,7 +857,7 @@ def test_split_delete_draft_vertical(self, modulestore_builder, revision_and_res
                 self.assertOLXIsDeleted(block_list_children)
 
     @ddt.data(*itertools.product(
-        MODULESTORE_SETUPS,
+        (SPLIT_MODULESTORE_SETUP,),
         (
             (ModuleStoreEnum.RevisionOption.published_only, 'assertOLXIsDeleted'),
             (ModuleStoreEnum.RevisionOption.all, 'assertOLXIsDeleted'),
@@ -1089,7 +887,7 @@ def test_delete_sequential(self, modulestore_builder, revision_and_result):
             self.assertOLXIsDeleted(block_list_children)
 
     @ddt.data(*itertools.product(
-        MODULESTORE_SETUPS,
+        (SPLIT_MODULESTORE_SETUP,),
         (
             (ModuleStoreEnum.RevisionOption.published_only, 'assertOLXIsDeleted'),
             (ModuleStoreEnum.RevisionOption.all, 'assertOLXIsDeleted'),
@@ -1135,7 +933,7 @@ class ElementalConvertToDraftTests(DraftPublishedOpBaseTestSetup):
     """
     Tests for the convert_to_draft() operation.
     """
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_convert_to_draft_published_vertical(self, modulestore_builder):
         with self._setup_test(modulestore_builder):
 
@@ -1155,14 +953,10 @@ def test_convert_to_draft_published_vertical(self, modulestore_builder):
                 # Split:
                 # This operation is a no-op is Split since there's always a draft version maintained.
                 self.assertOLXIsPublishedOnly(block_list_to_convert)
-            elif self.is_old_mongo_modulestore:
-                # Old Mongo:
-                # A draft -and- a published block now exists.
-                self.assertOLXIsDraftAndPublished(block_list_to_convert)
             else:
                 raise Exception("Must test either Old Mongo or Split modulestore!")
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_convert_to_draft_autopublished_sequential(self, modulestore_builder):
         with self._setup_test(modulestore_builder):
 
@@ -1178,11 +972,6 @@ def test_convert_to_draft_autopublished_sequential(self, modulestore_builder):
                 self.convert_to_draft(block_list_to_convert)
                 # This operation is a no-op is Split since there's always a draft version maintained.
                 self.assertOLXIsPublishedOnly(block_list_to_convert)
-            elif self.is_old_mongo_modulestore:
-                # Old Mongo:
-                # Direct-only categories are never allowed to be converted to draft.
-                with pytest.raises(InvalidVersionError):
-                    self.convert_to_draft(block_list_to_convert)
             else:
                 raise Exception("Must test either Old Mongo or Split modulestore!")
 
@@ -1192,7 +981,7 @@ class ElementalRevertToPublishedTests(DraftPublishedOpBaseTestSetup):
     """
     Tests for the revert_to_published() operation.
     """
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_revert_to_published_unpublished_vertical(self, modulestore_builder):
         with self._setup_test(modulestore_builder):
 
@@ -1206,7 +995,7 @@ def test_revert_to_published_unpublished_vertical(self, modulestore_builder):
             with pytest.raises(InvalidVersionError):
                 self.revert_to_published(block_list_to_revert)
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_revert_to_published_published_vertical(self, modulestore_builder):
         with self._setup_test(modulestore_builder):
 
@@ -1224,7 +1013,7 @@ def test_revert_to_published_published_vertical(self, modulestore_builder):
             # Basically a no-op - there was no draft version to revert.
             self.assertOLXIsPublishedOnly(block_list_to_revert)
 
-    @ddt.data(*MODULESTORE_SETUPS)
+    @ddt.data(SPLIT_MODULESTORE_SETUP)
     def test_revert_to_published_vertical(self, modulestore_builder):
         with self._setup_test(modulestore_builder):
 
diff --git a/xmodule/modulestore/tests/test_semantics.py b/xmodule/modulestore/tests/test_semantics.py
index ade0927ccfc8..4c12712d5aaf 100644
--- a/xmodule/modulestore/tests/test_semantics.py
+++ b/xmodule/modulestore/tests/test_semantics.py
@@ -19,7 +19,7 @@
 from xmodule.modulestore.draft_and_published import DIRECT_ONLY_CATEGORIES
 from xmodule.modulestore.exceptions import ItemNotFoundError
 from xmodule.modulestore.tests.factories import CourseFactory
-from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase, TEST_DATA_MONGO_MODULESTORE
+from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
 
 DETACHED_BLOCK_TYPES = dict(XBlock.load_tagged_classes('detached'))
 
@@ -403,13 +403,7 @@ def test_delete_child(self, block_type, child_published):
         self.assertCoursePointsToBlock(block_usage_key)
         self.assertNotParentOf(block_usage_key, child_usage_key)
 
-        if child_published and self.store.get_modulestore_type(self.course.id) == ModuleStoreEnum.Type.mongo:
-            # N.B. This block is being left as an orphan in old-mongo. This test will
-            # fail when that is fixed. At that time, this condition should just be removed,
-            # as SplitMongo and OldMongo will have the same semantics.
-            self.assertBlockHasContent(child_usage_key, 'data', child_data)
-        else:
-            self.assertBlockDoesntExist(child_usage_key)
+        self.assertBlockDoesntExist(child_usage_key)
 
 
 @ddt.ddt
@@ -444,19 +438,3 @@ def test_update_asides(self, block_type):
 
         self.assertBlockHasContent(block_usage_key, test_data.field_name, test_data.initial,
                                    self.ASIDE_DATA_FIELD.field_name, self.ASIDE_DATA_FIELD.updated)
-
-
-@ddt.ddt
-class TestMongoDirectOnlyCategorySemantics(DirectOnlyCategorySemantics):
-    """
-    Verify DIRECT_ONLY_CATEGORY semantics against the MongoModulestore
-    """
-    MODULESTORE = TEST_DATA_MONGO_MODULESTORE
-    __test__ = True
-
-    @ddt.data(ModuleStoreEnum.Branch.draft_preferred, ModuleStoreEnum.Branch.published_only)
-    def test_course_summaries(self, branch):
-        """ Test that `get_course_summaries` method in modulestore work as expected. """
-        with self.store.branch_setting(branch_setting=branch):
-            course_summaries = self.store.get_course_summaries()
-            assert len(course_summaries) == 1
diff --git a/xmodule/modulestore/tests/test_split_migrator.py b/xmodule/modulestore/tests/test_split_migrator.py
deleted file mode 100644
index a322e2b3962f..000000000000
--- a/xmodule/modulestore/tests/test_split_migrator.py
+++ /dev/null
@@ -1,190 +0,0 @@
-"""
-Tests for split_migrator
-
-"""
-
-
-import random
-import uuid
-from unittest import mock
-
-from xblock.fields import UNIQUE_ID, Reference, ReferenceList, ReferenceValueDict
-
-from openedx.core.lib.tests import attr
-from xmodule.modulestore.split_migrator import SplitMigrator
-from xmodule.modulestore.tests.test_split_w_old_mongo import SplitWMongoCourseBootstrapper
-
-
-@attr('mongo')
-class TestMigration(SplitWMongoCourseBootstrapper):
-    """
-    Test the split migrator
-    """
-
-    def setUp(self):
-        super().setUp()
-        self.migrator = SplitMigrator(self.split_mongo, self.draft_mongo)
-
-    def _create_course(self):  # lint-amnesty, pylint: disable=arguments-differ
-        """
-        A course testing all of the conversion mechanisms:
-        * some inheritable settings
-        * sequences w/ draft and live intermixed children to ensure all get to the draft but
-        only the live ones get to published. Some are only draft, some are both, some are only live.
-        * about, static_tab, and conditional documents
-        """
-        super()._create_course(split=False)
-
-        # chapters
-        chapter1_name = uuid.uuid4().hex
-        self._create_item('chapter', chapter1_name, {}, {'display_name': 'Chapter 1'}, 'course', 'runid', split=False)
-        chap2_loc = self.old_course_key.make_usage_key('chapter', uuid.uuid4().hex)
-        self._create_item(
-            chap2_loc.block_type, chap2_loc.block_id, {}, {'display_name': 'Chapter 2'}, 'course', 'runid', split=False
-        )
-        # vertical in live only
-        live_vert_name = uuid.uuid4().hex
-        self._create_item(
-            'vertical', live_vert_name, {}, {'display_name': 'Live vertical'}, 'chapter', chapter1_name,
-            draft=False, split=False
-        )
-        self.create_random_units(False, self.old_course_key.make_usage_key('vertical', live_vert_name))
-        # vertical in both live and draft
-        both_vert_loc = self.old_course_key.make_usage_key('vertical', uuid.uuid4().hex)
-        self._create_item(
-            both_vert_loc.block_type, both_vert_loc.block_id, {}, {'display_name': 'Both vertical'}, 'chapter', chapter1_name,  # lint-amnesty, pylint: disable=line-too-long
-            draft=False, split=False
-        )
-        self.create_random_units(False, both_vert_loc)
-        draft_both = self.draft_mongo.get_item(both_vert_loc)
-        draft_both.display_name = 'Both vertical renamed'
-        self.draft_mongo.update_item(draft_both, self.user_id)
-        self.create_random_units(True, both_vert_loc)
-        # vertical in draft only (x2)
-        draft_vert_loc = self.old_course_key.make_usage_key('vertical', uuid.uuid4().hex)
-        self._create_item(
-            draft_vert_loc.block_type, draft_vert_loc.block_id, {}, {'display_name': 'Draft vertical'}, 'chapter', chapter1_name,  # lint-amnesty, pylint: disable=line-too-long
-            draft=True, split=False
-        )
-        self.create_random_units(True, draft_vert_loc)
-        draft_vert_loc = self.old_course_key.make_usage_key('vertical', uuid.uuid4().hex)
-        self._create_item(
-            draft_vert_loc.block_type, draft_vert_loc.block_id, {}, {'display_name': 'Draft vertical2'}, 'chapter', chapter1_name,  # lint-amnesty, pylint: disable=line-too-long
-            draft=True, split=False
-        )
-        self.create_random_units(True, draft_vert_loc)
-
-        # and finally one in live only (so published has to skip 2 preceding sibs)
-        live_vert_loc = self.old_course_key.make_usage_key('vertical', uuid.uuid4().hex)
-        self._create_item(
-            live_vert_loc.block_type, live_vert_loc.block_id, {}, {'display_name': 'Live vertical end'}, 'chapter', chapter1_name,  # lint-amnesty, pylint: disable=line-too-long
-            draft=False, split=False
-        )
-        self.create_random_units(False, live_vert_loc)
-
-        # now the other chapter w/ the conditional
-        # create pointers to children (before the children exist)
-        indirect1_loc = self.old_course_key.make_usage_key('discussion', uuid.uuid4().hex)
-        indirect2_loc = self.old_course_key.make_usage_key('html', uuid.uuid4().hex)
-        conditional_loc = self.old_course_key.make_usage_key('conditional', uuid.uuid4().hex)
-        self._create_item(
-            conditional_loc.block_type, conditional_loc.block_id,
-            {
-                'show_tag_list': [indirect1_loc, indirect2_loc],
-                'sources_list': [live_vert_loc, ],
-            },
-            {
-                'xml_attributes': {
-                    'completed': True,
-                },
-            },
-            chap2_loc.block_type, chap2_loc.block_id,
-            draft=False, split=False
-        )
-        # create the children
-        self._create_item(
-            indirect1_loc.block_type, indirect1_loc.block_id, {'data': ""}, {'display_name': 'conditional show 1'},
-            conditional_loc.block_type, conditional_loc.block_id,
-            draft=False, split=False
-        )
-        self._create_item(
-            indirect2_loc.block_type, indirect2_loc.block_id, {'data': ""}, {'display_name': 'conditional show 2'},
-            conditional_loc.block_type, conditional_loc.block_id,
-            draft=False, split=False
-        )
-
-        # add direct children
-        self.create_random_units(False, conditional_loc)
-
-        # and the ancillary docs (not children)
-        self._create_item(
-            'static_tab', uuid.uuid4().hex, {'data': ""}, {'display_name': 'Tab uno'},
-            None, None, draft=False, split=False
-        )
-        self._create_item(
-            'about', 'overview', {'data': "<p>test</p>"}, {},
-            None, None, draft=False, split=False
-        )
-        self._create_item(
-            'course_info', 'updates', {'data': "<ol><li><h2>Sep 22</h2><p>test</p></li></ol>"}, {},
-            None, None, draft=False, split=False
-        )
-
-    def create_random_units(self, draft, parent_loc):
-        """
-        Create a random selection of units under the given parent w/ random names & attrs
-        :param store: which store (e.g., direct/draft) to create them in
-        :param parent: the parent to have point to them
-        (only makes sense if store is 'direct' and this is 'draft' or vice versa)
-        """
-        for _ in range(random.randrange(6)):
-            location = parent_loc.replace(
-                category=random.choice(['html', 'video', 'problem', 'discussion']),
-                name=uuid.uuid4().hex
-            )
-            metadata = {'display_name': str(uuid.uuid4()), 'graded': True}
-            data = {}
-            self._create_item(
-                location.block_type, location.block_id, data, metadata, parent_loc.block_type, parent_loc.block_id,
-                draft=draft, split=False
-            )
-
-    def compare_courses(self, presplit, new_course_key, published):  # lint-amnesty, pylint: disable=missing-function-docstring
-        # descend via children to do comparison
-        old_root = presplit.get_course(self.old_course_key)
-        new_root = self.split_mongo.get_course(new_course_key)
-        self.compare_dags(presplit, old_root, new_root, published)
-
-        # grab the detached items to compare they should be in both published and draft
-        for category in ['conditional', 'about', 'course_info', 'static_tab']:
-            for conditional in presplit.get_items(self.old_course_key, qualifiers={'category': category}):
-                locator = new_course_key.make_usage_key(category, conditional.location.block_id)
-                self.compare_dags(presplit, conditional, self.split_mongo.get_item(locator), published)
-
-    def compare_dags(self, presplit, presplit_dag_root, split_dag_root, published):  # lint-amnesty, pylint: disable=missing-function-docstring
-        if split_dag_root.category != 'course':
-            assert presplit_dag_root.location.block_id == split_dag_root.location.block_id
-        # compare all fields but references
-        for name, field in presplit_dag_root.fields.items():
-            # fields generated from UNIQUE_IDs are unique to an XBlock's scope,
-            # so if such a field is unset on an XBlock, we don't expect it
-            # to persist across courses
-            field_generated_from_unique_id = not field.is_set_on(presplit_dag_root) and field.default == UNIQUE_ID
-            should_check_field = not (
-                field_generated_from_unique_id or isinstance(field, (Reference, ReferenceList, ReferenceValueDict))
-            )
-            if should_check_field:
-                assert getattr(presplit_dag_root, name) == getattr(split_dag_root, name), f'{split_dag_root.location}/{name}: {getattr(presplit_dag_root, name)} != {getattr(split_dag_root, name)}'  # pylint: disable=line-too-long
-
-        # compare children
-        if presplit_dag_root.has_children:
-            assert len(presplit_dag_root.get_children()) == len(split_dag_root.children), f"{presplit_dag_root.category} '{presplit_dag_root.display_name}': children  {presplit_dag_root.children} != {split_dag_root.children}"  # pylint: disable=line-too-long
-            for pre_child, split_child in zip(presplit_dag_root.get_children(), split_dag_root.get_children()):
-                self.compare_dags(presplit, pre_child, split_child, published)
-
-    def test_migrator(self):
-        user = mock.Mock(id=1)
-        new_course_key = self.migrator.migrate_mongo_course(self.old_course_key, user.id, new_run='new_run')
-        # now compare the migrated to the original course
-        self.compare_courses(self.draft_mongo, new_course_key, True)  # published
-        self.compare_courses(self.draft_mongo, new_course_key, False)  # draft
diff --git a/xmodule/modulestore/tests/test_xml_importer.py b/xmodule/modulestore/tests/test_xml_importer.py
index 6e0e69dc861b..edb8e245da08 100644
--- a/xmodule/modulestore/tests/test_xml_importer.py
+++ b/xmodule/modulestore/tests/test_xml_importer.py
@@ -9,7 +9,6 @@
 from uuid import uuid4
 from unittest import mock
 
-import pytest
 from opaque_keys.edx.keys import CourseKey
 from opaque_keys.edx.locator import BlockUsageLocator, CourseLocator
 from path import Path as path
@@ -19,7 +18,7 @@
 from xmodule.modulestore import ModuleStoreEnum
 from xmodule.modulestore.inheritance import InheritanceMixin
 from xmodule.modulestore.tests.mongo_connection import MONGO_HOST, MONGO_PORT_NUM
-from xmodule.modulestore.xml_importer import StaticContentImporter, _update_and_import_module, _update_module_location
+from xmodule.modulestore.xml_importer import StaticContentImporter, _update_module_location
 from xmodule.tests import DATA_DIR
 from xmodule.x_module import XModuleMixin
 
@@ -125,121 +124,6 @@ class StubXBlock(XModuleMixin, InheritanceMixin):
     )
 
 
-class RemapNamespaceTest(ModuleStoreNoSettings):
-    """
-    Test that remapping the namespace from import to the actual course location.
-    """
-
-    def setUp(self):
-        """
-        Create a stub XBlock backed by in-memory storage.
-        """
-        self.runtime = mock.MagicMock(Runtime)
-        self.field_data = KvsFieldData(kvs=DictKeyValueStore())
-        self.scope_ids = ScopeIds('Bob', 'stubxblock', '123', 'import')
-        self.xblock = StubXBlock(self.runtime, self.field_data, self.scope_ids)
-        super().setUp()
-
-    def test_remap_namespace_native_xblock(self):
-
-        # Set the XBlock's location
-        self.xblock.location = BlockUsageLocator(CourseLocator("org", "import", "run"), "category", "stubxblock")
-
-        # Explicitly set the content and settings fields
-        self.xblock.test_content_field = "Explicitly set"
-        self.xblock.test_settings_field = "Explicitly set"
-        self.xblock.save()
-
-        # Move to different runtime w/ different course id
-        target_location_namespace = CourseKey.from_string("org/course/run")
-        new_version = _update_and_import_module(
-            self.xblock,
-            modulestore(),
-            999,
-            self.xblock.location.course_key,
-            target_location_namespace,
-            do_import_static=False
-        )
-
-        # Check the XBlock's location
-        assert new_version.location.course_key == target_location_namespace
-
-        # Check the values of the fields.
-        # The content and settings fields should be preserved
-        assert new_version.test_content_field == 'Explicitly set'
-        assert new_version.test_settings_field == 'Explicitly set'
-
-        # Expect that these fields are marked explicitly set
-        assert 'test_content_field' in new_version.get_explicitly_set_fields_by_scope(scope=Scope.content)
-        assert 'test_settings_field' in new_version.get_explicitly_set_fields_by_scope(scope=Scope.settings)
-
-    def test_remap_namespace_native_xblock_default_values(self):
-
-        # Set the XBlock's location
-        self.xblock.location = BlockUsageLocator(CourseLocator("org", "import", "run"), "category", "stubxblock")
-
-        # Do NOT set any values, so the fields should use the defaults
-        self.xblock.save()
-
-        # Remap the namespace
-        target_location_namespace = BlockUsageLocator(CourseLocator("org", "course", "run"), "category", "stubxblock")
-        new_version = _update_and_import_module(
-            self.xblock,
-            modulestore(),
-            999,
-            self.xblock.location.course_key,
-            target_location_namespace.course_key,
-            do_import_static=False
-        )
-
-        # Check the values of the fields.
-        # The content and settings fields should be the default values
-        assert new_version.test_content_field == 'default value'
-        assert new_version.test_settings_field == 'default value'
-
-        # The fields should NOT appear in the explicitly set fields
-        assert 'test_content_field' not in new_version.get_explicitly_set_fields_by_scope(scope=Scope.content)
-        assert 'test_settings_field' not in new_version.get_explicitly_set_fields_by_scope(scope=Scope.settings)
-
-    def test_remap_namespace_native_xblock_inherited_values(self):
-
-        # Set the XBlock's location
-        self.xblock.location = BlockUsageLocator(CourseLocator("org", "import", "run"), "category", "stubxblock")
-        self.xblock.save()
-
-        # Remap the namespace
-        target_location_namespace = BlockUsageLocator(CourseLocator("org", "course", "run"), "category", "stubxblock")
-        new_version = _update_and_import_module(
-            self.xblock,
-            modulestore(),
-            999,
-            self.xblock.location.course_key,
-            target_location_namespace.course_key,
-            do_import_static=False
-        )
-
-        # Inherited fields should NOT be explicitly set
-        assert 'start' not in new_version.get_explicitly_set_fields_by_scope(scope=Scope.settings)
-        assert 'graded' not in new_version.get_explicitly_set_fields_by_scope(scope=Scope.settings)
-
-    def test_xblock_invalid_field_value_type(self):
-        # Setting the wrong field-value in Xblock-field will raise TypeError.
-        # Example if xblock-field is of 'Dictionary' type by setting the 'List' value in that dict-type will raise
-        # TypeError.
-
-        # Set the XBlock's location
-        self.xblock.location = BlockUsageLocator(CourseLocator("org", "import", "run"), "category", "stubxblock")
-        # Explicitly set the content field
-        self.xblock.test_content_field = ['Explicitly set']
-        self.xblock.save()
-
-        # clearing the dirty fields and removing value from cache will fetch the value from field-data.
-        self.xblock._dirty_fields = {}  # pylint: disable=protected-access
-        self.xblock.fields['test_content_field']._del_cached_value(self.xblock)  # lint-amnesty, pylint: disable=protected-access, unsubscriptable-object
-        with pytest.raises(TypeError):
-            self.xblock.get_explicitly_set_fields_by_scope(scope=Scope.content)
-
-
 class StubXBlockWithMutableFields(StubXBlock):
     """
     Stub XBlock used for testing mutable fields and children
diff --git a/xmodule/modulestore/tests/utils.py b/xmodule/modulestore/tests/utils.py
index 78e2760ab291..be32d35741b9 100644
--- a/xmodule/modulestore/tests/utils.py
+++ b/xmodule/modulestore/tests/utils.py
@@ -431,14 +431,14 @@ def asset_collection(self):
 
 
 MIXED_MODULESTORE_BOTH_SETUP = MixedModulestoreBuilder([
-    ('draft', MongoModulestoreBuilder()),
-    ('split', VersioningModulestoreBuilder())
+    ('split', VersioningModulestoreBuilder()),
+    ('draft', MongoModulestoreBuilder())
 ])
 DRAFT_MODULESTORE_SETUP = MixedModulestoreBuilder([('draft', MongoModulestoreBuilder())])
 SPLIT_MODULESTORE_SETUP = MixedModulestoreBuilder([('split', VersioningModulestoreBuilder())])
 MIXED_MODULESTORE_SETUPS = (
-    DRAFT_MODULESTORE_SETUP,
     SPLIT_MODULESTORE_SETUP,
+    DRAFT_MODULESTORE_SETUP,
 )
 MIXED_MS_SETUPS_SHORT = (
     'mixed_mongo',