W mojej aplikacji django mam widok, który umożliwia przesyłanie plików, a fragment rdzenia wygląda tak

...
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)

Chciałbym przetestować widok jednostkowy. Planuję przetestować zarówno ścieżkę szczęśliwą, jak i ścieżkę niepowodzenia ... tj. Przypadek, w którym request.FILESplik nie ma klucza, przypadek, w którym request.FILES['file']ma None...

Jak skonfigurować dane posta dla szczęśliwej ścieżki? Czy ktoś może mi powiedzieć?

Z dokumentacji Django na Client.post:

Przesyłanie plików to szczególny przypadek. Aby POSTOWAĆ plik, wystarczy podać nazwę pola pliku jako klucz i uchwyt pliku do pliku, który chcesz przesłać jako wartość. Na przykład:

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

Kiedyś robiłem to samo, with open('some_file.txt') as fp:ale potem potrzebowałem obrazów, filmów i innych prawdziwych plików w repozytorium, a także testowałem część podstawowego komponentu Django, który jest dobrze przetestowany, więc obecnie robię to:

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 ...

W Pythonie 3.5+ musisz użyć bytesobject zamiast str. Zmiana"file_content" nab"file_content"

Działa dobrze, SimpleUploadedFiletworzy plik, InMemoryFilektóry zachowuje się jak zwykłe przesyłanie i możesz wybrać nazwę, zawartość i typ treści.

Polecam zapoznać się z Django RequestFactory . To najlepszy sposób na mockowanie danych podanych w żądaniu.

Powiedział, że znalazłem kilka błędów w twoim kodzie.

• Testowanie „jednostkowe” oznacza testowanie tylko jednej „jednostki” funkcjonalności. Tak więc, jeśli chcesz przetestować ten widok, przetestowałbyś widok i system plików, ergo, a nie tak naprawdę test jednostkowy. Aby to wyjaśnić. Jeśli uruchomisz ten test, a widok działa dobrze, ale nie masz uprawnień do zapisania tego pliku, test zakończy się niepowodzeniem.
• Inną ważną rzeczą jest szybkość testowania . Jeśli robisz coś takiego jak TDD, szybkość wykonywania testów jest naprawdę ważna. Dostęp do dowolnego wejścia / wyjścia nie jest dobrym pomysłem .

Dlatego zalecam zmianę widoku, aby użyć funkcji takiej jak:

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

I zrób z tego trochę kpin. Możesz użyć Python Mock .

PS: Możesz także użyć klienta testowego Django. Ale to oznaczałoby, że dodajesz jeszcze jedną rzecz do testowania, ponieważ ten klient korzysta z sesji, oprogramowania pośredniego itp. Nie ma nic podobnego do testowania jednostkowego.

Robię coś takiego dla mojej własnej aplikacji związanej z wydarzeniami, ale powinieneś mieć więcej niż wystarczającą ilość kodu, aby zająć się własnym przypadkiem użycia

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)

Zrobiłem coś takiego:

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')

Funkcja create_image utworzy obraz, więc nie musisz podawać statycznej ścieżki obrazu.

Uwaga: możesz zaktualizować kod zgodnie z kodem. Ten kod dla Pythona 3.6.

W Django 1.7 występuje problem z TestCase, który można rozwiązać za pomocą open (filepath, 'rb'), ale podczas korzystania z klienta testowego nie mamy nad nim kontroli. Myślę, że prawdopodobnie najlepiej jest upewnić się, że funkcja file.read () zwraca zawsze bajty.

źródło: https://code.djangoproject.com/ticket/23912 , KevinEtienne

Bez opcji rb generowany jest błąd TypeError:

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)

Jak wspomniano w oficjalnej dokumentacji Django :

Przesyłanie plików to szczególny przypadek. Aby POSTOWAĆ plik, wystarczy podać nazwę pola pliku jako klucz i uchwyt pliku do pliku, który chcesz przesłać jako wartość. Na przykład:

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

Więcej informacji: Jak sprawdzić, czy plik jest przekazywany jako argument do jakiejś funkcji?

Podczas testowania czasami chcemy się upewnić, że plik jest przekazywany jako argument do jakiejś funkcji.

na przykład

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

W testach użyj makiety Pythona, czegoś takiego:

# 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})

Mam nadzieję że to pomoże.

Używam Pythona == 3.8.2, Django == 3.0.4, djangorestframework == 3.11.0

Próbowałem, self.client.postale dostałem Resolver404wyjątek.

Pracowały dla mnie następujące:

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'}
    )