[1.6.x] Merge pull request #1582 from rca/12756-missing-yaml-module-serializer-error-message

Fixed #12756: Improved error message when yaml module is missing.

Backport of 4f5faa1916 from master.

tests/serializers/tests.py

@@ -1,17 +1,24 @@
+# -*- coding: utf-8 -*-
 from __future__ import absolute_import, unicode_literals
 
-# -*- coding: utf-8 -*-
 import json
 from datetime import datetime
 from xml.dom import minidom
 
+try:
+    import yaml
+    HAS_YAML = True
+except ImportError:
+    HAS_YAML = False
+
 from django.conf import settings
-from django.core import serializers
+from django.core import management, serializers
 from django.db import transaction, connection
 from django.test import TestCase, TransactionTestCase, Approximate
 from django.utils import six
 from django.utils.six import StringIO
 from django.utils import unittest
+from django.utils import importlib
 
 from .models import (Category, Author, Article, AuthorProfile, Actor, Movie,
     Score, Player, Team)
@@ -420,14 +427,74 @@ class JsonSerializerTransactionTestCase(SerializersTransactionTestBase, Transact
         }
     }]"""
 
-try:
-    import yaml
-except ImportError:
-    pass
-else:
-    class YamlSerializerTestCase(SerializersTestBase, TestCase):
-        serializer_name = "yaml"
-        fwd_ref_str = """- fields:
+
+YAML_IMPORT_ERROR_MESSAGE = r'No module named yaml'
+class YamlImportModuleMock(object):
+    """Provides a wrapped import_module function to simulate yaml ImportError
+
+    In order to run tests that verify the behavior of the YAML serializer
+    when run on a system that has yaml installed (like the django CI server),
+    mock import_module, so that it raises an ImportError when the yaml
+    serializer is being imported.  The importlib.import_module() call is
+    being made in the serializers.register_serializer().
+
+    Refs: #12756
+    """
+    def __init__(self):
+        self._import_module = importlib.import_module
+
+    def import_module(self, module_path):
+        if module_path == serializers.BUILTIN_SERIALIZERS['yaml']:
+            raise ImportError(YAML_IMPORT_ERROR_MESSAGE)
+
+        return self._import_module(module_path)
+
+
+class NoYamlSerializerTestCase(TestCase):
+    """Not having pyyaml installed provides a misleading error
+
+    Refs: #12756
+    """
+    @classmethod
+    def setUpClass(cls):
+        """Removes imported yaml and stubs importlib.import_module"""
+        super(NoYamlSerializerTestCase, cls).setUpClass()
+
+        cls._import_module_mock = YamlImportModuleMock()
+        importlib.import_module = cls._import_module_mock.import_module
+
+        # clear out cached serializers to emulate yaml missing
+        serializers._serializers = {}
+
+    @classmethod
+    def tearDownClass(cls):
+        """Puts yaml back if necessary"""
+        super(NoYamlSerializerTestCase, cls).tearDownClass()
+
+        importlib.import_module = cls._import_module_mock._import_module
+
+        # clear out cached serializers to clean out BadSerializer instances
+        serializers._serializers = {}
+
+    def test_serializer_pyyaml_error_message(self):
+        """Using yaml serializer without pyyaml raises ImportError"""
+        jane = Author(name="Jane")
+        self.assertRaises(ImportError, serializers.serialize, "yaml", [jane])
+
+    def test_deserializer_pyyaml_error_message(self):
+        """Using yaml deserializer without pyyaml raises ImportError"""
+        self.assertRaises(ImportError, serializers.deserialize, "yaml", "")
+
+    def test_dumpdata_pyyaml_error_message(self):
+        """Calling dumpdata produces an error when yaml package missing"""
+        self.assertRaisesRegexp(management.CommandError, YAML_IMPORT_ERROR_MESSAGE,
+                management.call_command, 'dumpdata', format='yaml')
+
+
+@unittest.skipUnless(HAS_YAML, "No yaml library detected")
+class YamlSerializerTestCase(SerializersTestBase, TestCase):
+    serializer_name = "yaml"
+    fwd_ref_str = """- fields:
     headline: Forward references pose no problem
     pub_date: 2006-06-16 15:00:00
     categories: [1]
@@ -443,7 +510,7 @@ else:
   pk: 1
   model: serializers.author"""
 
-        pkless_str = """- fields:
+    pkless_str = """- fields:
     name: Reference
   pk: null
   model: serializers.category
@@ -451,42 +518,44 @@ else:
     name: Non-fiction
   model: serializers.category"""
 
-        @staticmethod
-        def _validate_output(serial_str):
-            try:
-                yaml.safe_load(StringIO(serial_str))
-            except Exception:
-                return False
-            else:
-                return True
+    @staticmethod
+    def _validate_output(serial_str):
+        try:
+            yaml.safe_load(StringIO(serial_str))
+        except Exception:
+            return False
+        else:
+            return True
 
-        @staticmethod
-        def _get_pk_values(serial_str):
-            ret_list = []
-            stream = StringIO(serial_str)
-            for obj_dict in yaml.safe_load(stream):
-                ret_list.append(obj_dict["pk"])
-            return ret_list
+    @staticmethod
+    def _get_pk_values(serial_str):
+        ret_list = []
+        stream = StringIO(serial_str)
+        for obj_dict in yaml.safe_load(stream):
+            ret_list.append(obj_dict["pk"])
+        return ret_list
 
-        @staticmethod
-        def _get_field_values(serial_str, field_name):
-            ret_list = []
-            stream = StringIO(serial_str)
-            for obj_dict in yaml.safe_load(stream):
-                if "fields" in obj_dict and field_name in obj_dict["fields"]:
-                    field_value = obj_dict["fields"][field_name]
-                    # yaml.safe_load will return non-string objects for some
-                    # of the fields we are interested in, this ensures that
-                    # everything comes back as a string
-                    if isinstance(field_value, six.string_types):
-                        ret_list.append(field_value)
-                    else:
-                        ret_list.append(str(field_value))
-            return ret_list
+    @staticmethod
+    def _get_field_values(serial_str, field_name):
+        ret_list = []
+        stream = StringIO(serial_str)
+        for obj_dict in yaml.safe_load(stream):
+            if "fields" in obj_dict and field_name in obj_dict["fields"]:
+                field_value = obj_dict["fields"][field_name]
+                # yaml.safe_load will return non-string objects for some
+                # of the fields we are interested in, this ensures that
+                # everything comes back as a string
+                if isinstance(field_value, six.string_types):
+                    ret_list.append(field_value)
+                else:
+                    ret_list.append(str(field_value))
+        return ret_list
 
-    class YamlSerializerTransactionTestCase(SerializersTransactionTestBase, TransactionTestCase):
-        serializer_name = "yaml"
-        fwd_ref_str = """- fields:
+
+@unittest.skipUnless(HAS_YAML, "No yaml library detected")
+class YamlSerializerTransactionTestCase(SerializersTransactionTestBase, TransactionTestCase):
+    serializer_name = "yaml"
+    fwd_ref_str = """- fields:
     headline: Forward references pose no problem
     pub_date: 2006-06-16 15:00:00
     categories: [1]