如何使用自定义存储属性在django中模拟媒体文件目录？

Question

django version: 1.11, python version: 3.6.3

According to this two blogs/articles:

https://joeray.me/mocking-files-and-file-storage-for-testing-django-models.html https://www.caktusgroup.com/blog/2013/06/26/media-root-and-django-tests/

we would, ideally, use a temporary directory to upload the mock-files. Now, mocking the files is easy. But mocking the directory and using a temporary directory is not working with custom storage property

in settings.py i have a protected root to upload non public images:

MEDIA_URL = '/media/'

MEDIA_ROOT=os.path.join(BASE_DIR, "cdn", "media")
PROTECTED_ROOT = os.path.join(BASE_DIR, "cdn", "protected")

in products/models.py i have:

from django.conf import settings
from django.db import models
from django.core.files.storage import FileSystemStorage

class Product(models.Model):
    media = models.ImageField(
            # custom storage property
            storage=FileSystemStorage(location=settings.PROTECTED_ROOT)
        )

and the test in products/tests/test_views.py :

from django.test import TestCase
from unittest import mock
from products.models import Product
from django.core.files import File

class ProductViewSetup(TestCase):                                                                                                                                        

    @classmethod                                                                                                                                                         
    def setUpTestData(cls):
        file_mock = mock.MagicMock(spec=File, name='FileMock')                                                                                                           
        file_mock.name = 'test.jpg'
        cls.product = Product.objects.create(
                media=file_mock
            )

i thought i could just customize the code described in caktusgroup blog to:

class TempMediaMixin(object):                                                                                                                                            
    "Mixin to create MEDIA_ROOT in temp and tear down when complete."                                                                                                    

    def setup_test_environment(self):                                                                                                                                    
        "Create temp directory and update MEDIA_ROOT and default storage."                                                                                               
        super(TempMediaMixin, self).setup_test_environment()                                                                                                             
        settings._original_media_root = settings.MEDIA_ROOT                                                                                                              
        settings._original_file_storage = settings.DEFAULT_FILE_STORAGE                                                                                                  
        settings._original_protected_root = settings.PROTECTED_ROOT                                                                                                      
        self._temp_media = tempfile.mkdtemp()                                                                                                                            
        self._temp_protected = tempfile.mkdtemp()                                                                                                                        
        settings.MEDIA_ROOT = self._temp_media                                                                                                                           
        settings.PROTECTED_ROOT = self._temp_protected                                                                                                                   
        settings.DEFAULT_FILE_STORAGE = 'django.core.files.storage.FileSystemStorage'                                                                                    

    def teardown_test_environment(self):                                                                                                                                 
        "Delete temp storage."                                                                                                                                           
        super(TempMediaMixin, self).teardown_test_environment()                                                                                                          
        shutil.rmtree(self._temp_media, ignore_errors=True)                                                                                                              
        shutil.rmtree(self._temp_protected, ignore_errors=True)                                                                                                          
        settings.MEDIA_ROOT = settings._original_media_root                                                                                                              
        del settings._original_media_root                                                                                                                                
        settings.PROTECTED_ROOT = settings._original_protected_root                                                                                                      
        del settings._original_protected_root                                                                                                                            
        settings.DEFAULT_FILE_STORAGE = settings._original_file_storage                                                                                                  
        del settings._original_file_storage                                                                                                                              


class CustomTestSuiteRunner(TempMediaMixin, DiscoverRunner):                                                                                                             
    "Local test suite runner."  

i added TEST_RUNNER to settings.py , and the CustomTestSuiteRunner is working. The temporary directory is also used, but still files are added to my PROTECTED_ROOT , how do i fix this?

Answer 1

It seems like the custom test runner works fine when I overwrite the storage location in setUpTestData() :

Product.media.field.storage.location = settings.PROTECTED_ROOT

This way it will use the temporary directory when using the custom test runner.

If you don't overwrite the storage location, it will use the storage defined in models.py .