Em meu aplicativo django, eu tenho uma visão que realiza o upload de arquivos. O snippet principal é assim

...
if  (request.method == 'POST'):
    if request.FILES.has_key('file'):
        file = request.FILES['file']
        with open(settings.destfolder+'/%s' % file.name, 'wb+') as dest:
            for chunk in file.chunks():
                dest.write(chunk)

Eu gostaria de fazer o teste de unidade da visualização. Estou planejando testar o caminho feliz, bem como o caminho da falha ... ou seja, o caso em que o request.FILESnão tem 'arquivo' de chave, caso em que request.FILES['file']tem None..

Como faço para configurar os dados de postagem para o caminho feliz? Alguém pode me dizer?

Da documentação do Django em Client.post:

O envio de arquivos é um caso especial. Para POSTAR um arquivo, você precisa apenas fornecer o nome do campo do arquivo como uma chave e um identificador de arquivo para o arquivo que deseja enviar como um valor. Por exemplo:

c = Client()
with open('wishlist.doc') as fp:
  c.post('/customers/wishes/', {'name': 'fred', 'attachment': fp})

Eu costumava fazer o mesmo, with open('some_file.txt') as fp:mas depois precisava de imagens, vídeos e outros arquivos reais no repo e também estava testando uma parte de um componente principal do Django que foi bem testado, então, atualmente, é o que tenho feito:

from django.core.files.uploadedfile import SimpleUploadedFile

def test_upload_video(self):
    video = SimpleUploadedFile("file.mp4", "file_content", content_type="video/mp4")
    self.client.post(reverse('app:some_view'), {'video': video})
    # some important assertions ...

Em Python 3.5+ você precisa usar o bytesobjeto em vez de str. Mudar "file_content"parab"file_content"

Está funcionando bem, SimpleUploadedFilecria um InMemoryFileque se comporta como um upload normal e você pode escolher o nome, o conteúdo e o tipo de conteúdo.

Eu recomendo que você dê uma olhada no Django RequestFactory . É a melhor maneira de simular os dados fornecidos na solicitação.

Dito isso, encontrei várias falhas no seu código.

• teste de "unidade" significa testar apenas um "unidade" de funcionalidade. Portanto, se você quiser testar essa visualização, estará testando a visualização e o sistema de arquivos, ergo, não realmente um teste de unidade. Para deixar este ponto mais claro. Se você executar esse teste e a visualização funcionar bem, mas você não tiver permissões para salvar o arquivo, seu teste falhará por causa disso.
• Outra coisa importante é a velocidade do teste . Se você estiver fazendo algo como TDD, a velocidade de execução de seus testes é muito importante. Acessar qualquer I / O não é uma boa ideia .

Então, eu recomendo que você refatore sua visão para usar uma função como:

def upload_file_to_location(request, location=None): # Can use the default configured

E zombe disso. Você pode usar Python Mock .

PS: Você também poderia usar o Django Test Client. Mas isso significaria que você está adicionando outra coisa a mais para testar, porque esse cliente faz uso de Sessões, middlewares, etc. Nada semelhante ao Teste de Unidade.

Eu faço algo assim para meu próprio aplicativo relacionado a eventos, mas você deve ter código mais do que suficiente para continuar com seu próprio caso de uso

import tempfile, csv, os

class UploadPaperTest(TestCase):

    def generate_file(self):
        try:
            myfile = open('test.csv', 'wb')
            wr = csv.writer(myfile)
            wr.writerow(('Paper ID','Paper Title', 'Authors'))
            wr.writerow(('1','Title1', 'Author1'))
            wr.writerow(('2','Title2', 'Author2'))
            wr.writerow(('3','Title3', 'Author3'))
        finally:
            myfile.close()

        return myfile

    def setUp(self):
        self.user = create_fuser()
        self.profile = ProfileFactory(user=self.user)
        self.event = EventFactory()
        self.client = Client()
        self.module = ModuleFactory()
        self.event_module = EventModule.objects.get_or_create(event=self.event,
                module=self.module)[0]
        add_to_admin(self.event, self.user)

    def test_paper_upload(self):
        response = self.client.login(username=self.user.email, password='foz')
        self.assertTrue(response)

        myfile = self.generate_file()
        file_path = myfile.name
        f = open(file_path, "r")

        url = reverse('registration_upload_papers', args=[self.event.slug])

        # post wrong data type
        post_data = {'uploaded_file': i}
        response = self.client.post(url, post_data)
        self.assertContains(response, 'File type is not supported.')

        post_data['uploaded_file'] = f
        response = self.client.post(url, post_data)

        import_file = SubmissionImportFile.objects.all()[0]
        self.assertEqual(SubmissionImportFile.objects.all().count(), 1)
        #self.assertEqual(import_file.uploaded_file.name, 'files/registration/{0}'.format(file_path))

        os.remove(myfile.name)
        file_path = import_file.uploaded_file.path
        os.remove(file_path)

Eu fiz algo assim:

from django.core.files.uploadedfile import SimpleUploadedFile
from django.test import TestCase
from django.core.urlresolvers import reverse
from django.core.files import File
from django.utils.six import BytesIO

from .forms import UploadImageForm

from PIL import Image
from io import StringIO


def create_image(storage, filename, size=(100, 100), image_mode='RGB', image_format='PNG'):
   """
   Generate a test image, returning the filename that it was saved as.

   If ``storage`` is ``None``, the BytesIO containing the image data
   will be passed instead.
   """
   data = BytesIO()
   Image.new(image_mode, size).save(data, image_format)
   data.seek(0)
   if not storage:
       return data
   image_file = ContentFile(data.read())
   return storage.save(filename, image_file)


class UploadImageTests(TestCase):
   def setUp(self):
       super(UploadImageTests, self).setUp()


   def test_valid_form(self):
       '''
       valid post data should redirect
       The expected behavior is to show the image
       '''
       url = reverse('image')
       avatar = create_image(None, 'avatar.png')
       avatar_file = SimpleUploadedFile('front.png', avatar.getvalue())
       data = {'image': avatar_file}
       response = self.client.post(url, data, follow=True)
       image_src = response.context.get('image_src')

       self.assertEquals(response.status_code, 200)
       self.assertTrue(image_src)
       self.assertTemplateUsed('content_upload/result_image.html')

A função create_image criará a imagem, então você não precisa fornecer o caminho estático da imagem.

Nota: Você pode atualizar o código de acordo com o seu código. Este código para Python 3.6.

No Django 1.7 há um problema com o TestCase que pode ser resolvido usando open (filepath, 'rb'), mas ao usar o cliente de teste não temos controle sobre ele. Acho que provavelmente é melhor garantir que file.read () retorne sempre bytes.

fonte: https://code.djangoproject.com/ticket/23912 , por KevinEtienne

Sem a opção rb, um TypeError é gerado:

TypeError: sequence item 4: expected bytes, bytearray, or an object with the buffer interface, str found

from rest_framework.test import force_authenticate
from rest_framework.test import APIRequestFactory

factory = APIRequestFactory()
user = User.objects.get(username='#####')
view = <your_view_name>.as_view()
with open('<file_name>.pdf', 'rb') as fp:
    request=factory.post('<url_path>',{'file_name':fp})
force_authenticate(request, user)
response = view(request)

Conforme mencionado na documentação oficial do Django :

O envio de arquivos é um caso especial. Para POSTAR um arquivo, você só precisa fornecer o nome do campo do arquivo como uma chave e um identificador de arquivo para o arquivo que deseja enviar como um valor. Por exemplo:

c = Client()
with open('wishlist.doc') as fp:
    c.post('/customers/wishes/', {'name': 'fred', 'attachment': fp})

Maiores Informações: Como verificar se o arquivo é passado como argumento para alguma função?

Durante o teste, às vezes queremos ter certeza de que o arquivo é passado como um argumento para alguma função.

por exemplo

...
class AnyView(CreateView):
    ...
    def post(self, request, *args, **kwargs):
        attachment = request.FILES['attachment']
        # pass the file as an argument
        my_function(attachment)
        ...

Nos testes, use o mock do Python algo assim:

# Mock 'my_function' and then check the following:

response = do_a_post_request()

self.assertEqual(mock_my_function.call_count, 1)
self.assertEqual(
    mock_my_function.call_args,
    call(response.wsgi_request.FILES['attachment']),
)

from django.test import Client
from requests import Response

client = Client()
with open(template_path, 'rb') as f:
    file = SimpleUploadedFile('Name of the django file', f.read())
    response: Response = client.post(url, format='multipart', data={'file': file})

Espero que isto ajude.

Estou usando Python == 3.8.2, Django == 3.0.4, djangorestframework == 3.11.0

Eu tentei, self.client.postmas encontrei uma Resolver404exceção.

O seguinte funcionou para mim:

import requests
upload_url='www.some.com/oaisjdoasjd' # your url to upload
with open('/home/xyz/video1.webm', 'rb') as video_file:
    # if it was a text file we would perhaps do
    # file = video_file.read()
    response_upload = requests.put(
        upload_url,
        data=video_file,
        headers={'content-type': 'video/webm'}
    )