1 """

     2 Tests the core api for sessions

     3 """

     4 import logging

     5 from uuid import uuid4

     6 

     7 from django.contrib.auth import get_user_model

     8 from django.urls import reverse

     9 from django.utils import timezone

    10 from rest_framework import status

    11 from rest_framework.test import APITransactionTestCase

    12 

    13 from notes.models import Session, Note

    14 

    15 logger = logging.getLogger(__name__)

    16 

    17 class NoteApiTests(APITransactionTestCase):

    18 

    19     def setUp(self):

    20         User = get_user_model()

    21         user1 = User.objects.create_user(

    22             username='test_user1',

    23             email='test_user@emial.com',

    24             password='top_secret'

    25         )

    26         user2 = User.objects.create_user(

    27             username='test_user2',

    28             email='test_user@emial.com',

    29             password='top_secret'

    30         )

    31         user3 = User.objects.create_user(

    32             username='test_user3',

    33             email='test_user@emial.com',

    34             password='top_secret'

    35         )

    36 

    37         self.session1 = Session.objects.create(

    38             title="a new session 1",

    39             description="Description 1",

    40             protocol="[]",

    41             owner=user1

    42         )

    43 

    44         self.session2 = Session.objects.create(

    45             title="a new session 2",

    46             description="Description 2",

    47             protocol="[]",

    48             owner=user2

    49         )

    50 

    51         Session.objects.create(

    52             title="a new session 3",

    53             description="Description 3",

    54             protocol="[]",

    55             owner=user3

    56         )

    57 

    58         Note.objects.create(

    59             tc_start=timezone.now(),

    60             tc_end=timezone.now(),

    61             session=self.session1,

    62             plain="example note 1",

    63             html="<i>example note 1</i>",

    64             raw="<i>example note 1</i>",

    65             margin_note="margin note 1",

    66             categorization="[]"

    67         )

    68 

    69         Note.objects.create(

    70             tc_start=timezone.now(),

    71             tc_end=timezone.now(),

    72             session=self.session2,

    73             plain="example note 2",

    74             html="<i>example note</i>",

    75             raw="<i>example note</i>",

    76             margin_note="margin note",

    77             categorization="[]"

    78         )

    79 

    80 

    81     def test_create_note_no_user(self):

    82         url = reverse('notes:notes-list', kwargs={'session_ext_id': self.session1.ext_id})

    83         response = self.client.post(url, {

    84             'tc_start': timezone.now(),

    85             'tc_end': timezone.now(),

    86             'plain': "example note 2",

    87             'html': "<i>example note</i>",

    88             'raw': "<i>example note</i>",

    89             'margin_note': "margin note",

    90             'categorization': "[]"

    91         }, format='json')

    92 

    93         self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)

    94 

    95 

    96     def test_create_note(self):

    97         url = reverse('notes:notes-list', kwargs={'session_ext_id': self.session1.ext_id})

    98         self.client.login(username='test_user1', password='top_secret')

    99         response = self.client.post(url, {

   100             'tc_start': timezone.now(),

   101             'tc_end': timezone.now(),

   102             'plain': "example note 2",

   103             'html': "<i>example note</i>",

   104             'raw': "<i>example note</i>",

   105             'margin_note': "margin note",

   106             'categorization': "[]"

   107         }, format='json')

   108 

   109         self.assertEqual(response.status_code, status.HTTP_201_CREATED)

   110         json = response.json()

   111         self.assertIn('ext_id', json)

   112         note = Note.objects.get(ext_id=json['ext_id'], session__id=self.session1.id)

   113         self.assertTrue(note)

   114 

   115     def test_create_note_with_ext_id(self):

   116         url = reverse('notes:notes-list', kwargs={'session_ext_id': self.session1.ext_id})

   117         self.client.login(username='test_user1', password='top_secret')

   118         ext_id = str(uuid4())

   119         response = self.client.post(url, {

   120             'ext_id': ext_id,

   121             'tc_start': timezone.now(),

   122             'tc_end': timezone.now(),

   123             'plain': "example note 2",

   124             'html': "<i>example note</i>",

   125             'raw': "<i>example note</i>",

   126             'margin_note': "margin note",

   127             'categorization': "[]"

   128         }, format='json')

   129 

   130         self.assertEqual(response.status_code, status.HTTP_201_CREATED)

   131         json = response.json()

   132         self.assertIn('ext_id', json)

   133         self.assertEqual(json['ext_id'], ext_id)

   134         note = Note.objects.get(ext_id=ext_id)

   135         self.assertTrue(note)