R: update test calls

rsconcept/backend/apps/library/tests/s_views/t_library.py

@@ -43,7 +43,7 @@ class TestLibraryViewset(EndpointTester):
             'title': 'Title',
             'alias': 'alias',
         }
-        response = self.executeCreated(data=data)
+        response = self.executeCreated(data)
         self.assertEqual(response.data['owner'], self.user.pk)
         self.assertEqual(response.data['item_type'], LibraryItemType.RSFORM)
         self.assertEqual(response.data['title'], data['title'])
@@ -57,7 +57,7 @@ class TestLibraryViewset(EndpointTester):
             'visible': False,
             'read_only': True
         }
-        response = self.executeCreated(data=data)
+        response = self.executeCreated(data)
         oss = LibraryItem.objects.get(pk=response.data['id'])
         self.assertEqual(oss.owner, self.user)
         self.assertEqual(response.data['owner'], self.user.pk)
@@ -70,25 +70,25 @@ class TestLibraryViewset(EndpointTester):
 
         self.logout()
         data = {'title': 'Title2'}
-        self.executeForbidden(data=data)
+        self.executeForbidden(data)
 
 
     @decl_endpoint('/api/library/{item}', method='patch')
     def test_update(self):
         data = {'title': 'New Title'}
-        self.executeNotFound(data=data, item=self.invalid_item)
-        self.executeForbidden(data=data, item=self.unowned.pk)
+        self.executeNotFound(data, item=self.invalid_item)
+        self.executeForbidden(data, item=self.unowned.pk)
 
         self.toggle_editor(self.unowned, True)
-        response = self.executeOK(data=data, item=self.unowned.pk)
+        response = self.executeOK(data, item=self.unowned.pk)
         self.assertEqual(response.data['title'], data['title'])
 
         self.unowned.access_policy = AccessPolicy.PRIVATE
         self.unowned.save()
-        self.executeForbidden(data=data, item=self.unowned.pk)
+        self.executeForbidden(data, item=self.unowned.pk)
 
         data = {'title': 'New Title'}
-        response = self.executeOK(data=data, item=self.owned.pk)
+        response = self.executeOK(data, item=self.owned.pk)
         self.assertEqual(response.data['title'], data['title'])
         self.assertEqual(response.data['alias'], self.owned.alias)
 
@@ -98,7 +98,7 @@ class TestLibraryViewset(EndpointTester):
             'access_policy': AccessPolicy.PROTECTED,
             'location': LocationHead.LIBRARY
         }
-        response = self.executeOK(data=data, item=self.owned.pk)
+        response = self.executeOK(data, item=self.owned.pk)
         self.assertEqual(response.data['title'], data['title'])
         self.assertEqual(response.data['owner'], self.owned.owner.pk)
         self.assertEqual(response.data['access_policy'], self.owned.access_policy)
@@ -111,22 +111,22 @@ class TestLibraryViewset(EndpointTester):
         time_update = self.owned.time_update
 
         data = {'user': self.user.pk}
-        self.executeNotFound(data=data, item=self.invalid_item)
-        self.executeForbidden(data=data, item=self.unowned.pk)
-        self.executeOK(data=data, item=self.owned.pk)
+        self.executeNotFound(data, item=self.invalid_item)
+        self.executeForbidden(data, item=self.unowned.pk)
+        self.executeOK(data, item=self.owned.pk)
         self.owned.refresh_from_db()
         self.assertEqual(self.owned.owner, self.user)
 
         data = {'user': self.user2.pk}
-        self.executeOK(data=data, item=self.owned.pk)
+        self.executeOK(data, item=self.owned.pk)
         self.owned.refresh_from_db()
         self.assertEqual(self.owned.owner, self.user2)
         self.assertEqual(self.owned.time_update, time_update)
-        self.executeForbidden(data=data, item=self.owned.pk)
+        self.executeForbidden(data, item=self.owned.pk)
 
         self.toggle_admin(True)
         data = {'user': self.user.pk}
-        self.executeOK(data=data, item=self.owned.pk)
+        self.executeOK(data, item=self.owned.pk)
         self.owned.refresh_from_db()
         self.assertEqual(self.owned.owner, self.user)
 
@@ -135,20 +135,20 @@ class TestLibraryViewset(EndpointTester):
         time_update = self.owned.time_update
 
         data = {'access_policy': 'invalid'}
-        self.executeBadData(data=data, item=self.owned.pk)
+        self.executeBadData(data, item=self.owned.pk)
 
         data = {'access_policy': AccessPolicy.PRIVATE}
-        self.executeNotFound(data=data, item=self.invalid_item)
-        self.executeForbidden(data=data, item=self.unowned.pk)
-        self.executeOK(data=data, item=self.owned.pk)
+        self.executeNotFound(data, item=self.invalid_item)
+        self.executeForbidden(data, item=self.unowned.pk)
+        self.executeOK(data, item=self.owned.pk)
         self.owned.refresh_from_db()
         self.assertEqual(self.owned.access_policy, data['access_policy'])
 
         self.toggle_editor(self.unowned, True)
-        self.executeForbidden(data=data, item=self.unowned.pk)
+        self.executeForbidden(data, item=self.unowned.pk)
 
         self.toggle_admin(True)
-        self.executeOK(data=data, item=self.unowned.pk)
+        self.executeOK(data, item=self.unowned.pk)
         self.unowned.refresh_from_db()
         self.assertEqual(self.unowned.access_policy, data['access_policy'])
 
@@ -157,29 +157,29 @@ class TestLibraryViewset(EndpointTester):
         time_update = self.owned.time_update
 
         data = {'location': 'invalid'}
-        self.executeBadData(data=data, item=self.owned.pk)
+        self.executeBadData(data, item=self.owned.pk)
 
         data = {'location': '/U/temp'}
-        self.executeNotFound(data=data, item=self.invalid_item)
-        self.executeForbidden(data=data, item=self.unowned.pk)
-        self.executeOK(data=data, item=self.owned.pk)
+        self.executeNotFound(data, item=self.invalid_item)
+        self.executeForbidden(data, item=self.unowned.pk)
+        self.executeOK(data, item=self.owned.pk)
         self.owned.refresh_from_db()
         self.assertEqual(self.owned.location, data['location'])
 
         data = {'location': LocationHead.LIBRARY}
-        self.executeForbidden(data=data, item=self.owned.pk)
+        self.executeForbidden(data, item=self.owned.pk)
 
         data = {'location': '/U/temp'}
         self.toggle_editor(self.unowned, True)
-        self.executeForbidden(data=data, item=self.unowned.pk)
+        self.executeForbidden(data, item=self.unowned.pk)
 
         self.toggle_admin(True)
         data = {'location': LocationHead.LIBRARY}
-        self.executeOK(data=data, item=self.owned.pk)
+        self.executeOK(data, item=self.owned.pk)
         self.owned.refresh_from_db()
         self.assertEqual(self.owned.location, data['location'])
 
-        self.executeOK(data=data, item=self.unowned.pk)
+        self.executeOK(data, item=self.unowned.pk)
         self.unowned.refresh_from_db()
         self.assertEqual(self.unowned.location, data['location'])
 
@@ -201,12 +201,12 @@ class TestLibraryViewset(EndpointTester):
             'new_location': '/S/temp2'
         }
 
-        self.executeBadData(data={})
-        self.executeBadData(data={'target:': '/S/temp'})
-        self.executeBadData(data={'new_location:': '/S/temp'})
-        self.executeBadData(data={'target:': 'invalid', 'new_location': '/S/temp'})
-        self.executeBadData(data={'target:': '/S/temp', 'new_location': 'invalid'})
-        self.executeOK(data=data)
+        self.executeBadData({})
+        self.executeBadData({'target:': '/S/temp'})
+        self.executeBadData({'new_location:': '/S/temp'})
+        self.executeBadData({'target:': 'invalid', 'new_location': '/S/temp'})
+        self.executeBadData({'target:': '/S/temp', 'new_location': 'invalid'})
+        self.executeOK(data)
         self.owned.refresh_from_db()
         self.unowned.refresh_from_db()
         owned2.refresh_from_db()
@@ -215,7 +215,7 @@ class TestLibraryViewset(EndpointTester):
         self.assertEqual(owned2.location, '/S/temp2/123')
 
         self.toggle_admin(True)
-        self.executeOK(data=data)
+        self.executeOK(data)
         self.unowned.refresh_from_db()
         self.assertEqual(self.unowned.location, '/S/temp2')
 
@@ -232,7 +232,7 @@ class TestLibraryViewset(EndpointTester):
         }
 
         self.toggle_admin(True)
-        self.executeOK(data=data)
+        self.executeOK(data)
         self.owned.refresh_from_db()
         self.unowned.refresh_from_db()
         self.assertEqual(self.owned.location, '/U/temp2')
@@ -243,30 +243,30 @@ class TestLibraryViewset(EndpointTester):
         time_update = self.owned.time_update
 
         data = {'users': [self.invalid_user]}
-        self.executeBadData(data=data, item=self.owned.pk)
+        self.executeBadData(data, item=self.owned.pk)
 
         data = {'users': [self.user.pk]}
-        self.executeNotFound(data=data, item=self.invalid_item)
-        self.executeForbidden(data=data, item=self.unowned.pk)
+        self.executeNotFound(data, item=self.invalid_item)
+        self.executeForbidden(data, item=self.unowned.pk)
 
-        self.executeOK(data=data, item=self.owned.pk)
+        self.executeOK(data, item=self.owned.pk)
         self.owned.refresh_from_db()
         self.assertEqual(self.owned.time_update, time_update)
         self.assertEqual(list(self.owned.getQ_editors()), [self.user])
 
-        self.executeOK(data=data)
+        self.executeOK(data)
         self.assertEqual(list(self.owned.getQ_editors()), [self.user])
 
         data = {'users': [self.user2.pk]}
-        self.executeOK(data=data)
+        self.executeOK(data)
         self.assertEqual(list(self.owned.getQ_editors()), [self.user2])
 
         data = {'users': []}
-        self.executeOK(data=data)
+        self.executeOK(data)
         self.assertEqual(list(self.owned.getQ_editors()), [])
 
         data = {'users': [self.user2.pk, self.user.pk]}
-        self.executeOK(data=data)
+        self.executeOK(data)
         self.assertEqual(set(self.owned.getQ_editors()), set([self.user2, self.user]))
 
 
@@ -345,10 +345,10 @@ class TestLibraryViewset(EndpointTester):
         )
 
         data = {'item_data': {'title': 'Title1337'}, 'items': []}
-        self.executeNotFound(data=data, item=self.invalid_item)
-        self.executeCreated(data=data, item=self.unowned.pk)
+        self.executeNotFound(data, item=self.invalid_item)
+        self.executeCreated(data, item=self.unowned.pk)
 
-        response = self.executeCreated(data=data, item=self.owned.pk)
+        response = self.executeCreated(data, item=self.owned.pk)
         self.assertEqual(response.data['title'], data['item_data']['title'])
         self.assertEqual(len(response.data['items']), 2)
         self.assertEqual(response.data['items'][0]['alias'], x12.alias)
@@ -358,12 +358,12 @@ class TestLibraryViewset(EndpointTester):
         self.assertEqual(response.data['items'][1]['term_resolved'], d2.term_resolved)
 
         data = {'item_data': {'title': 'Title1340'}, 'items': []}
-        response = self.executeCreated(data=data, item=self.owned.pk)
+        response = self.executeCreated(data, item=self.owned.pk)
         self.assertEqual(response.data['title'], data['item_data']['title'])
         self.assertEqual(len(response.data['items']), 2)
 
         data = {'item_data': {'title': 'Title1341'}, 'items': [x12.pk]}
-        response = self.executeCreated(data=data, item=self.owned.pk)
+        response = self.executeCreated(data, item=self.owned.pk)
         self.assertEqual(response.data['title'], data['item_data']['title'])
         self.assertEqual(len(response.data['items']), 1)
         self.assertEqual(response.data['items'][0]['alias'], x12.alias)

rsconcept/backend/apps/library/tests/s_views/t_versions.py

@@ -32,11 +32,11 @@ class TestVersionViews(EndpointTester):
         invalid_id = 1338
         data = {'version': '1.0.0', 'description': 'test'}
 
-        self.executeNotFound(data=data, schema=invalid_id)
-        self.executeForbidden(data=data, schema=self.unowned_id)
-        self.executeBadData(data=invalid_data, schema=self.owned_id)
+        self.executeNotFound(data, schema=invalid_id)
+        self.executeForbidden(data, schema=self.unowned_id)
+        self.executeBadData(invalid_data, schema=self.owned_id)
 
-        response = self.executeCreated(data=data, schema=self.owned_id)
+        response = self.executeCreated(data, schema=self.owned_id)
         self.assertTrue('version' in response.data)
         self.assertTrue('schema' in response.data)
         self.assertTrue(response.data['version'] in [v['id'] for v in response.data['schema']['versions']])
@@ -46,7 +46,7 @@ class TestVersionViews(EndpointTester):
     def test_create_version_filter(self):
         x2 = self.owned.insert_last('X2')
         data = {'version': '1.0.0', 'description': 'test', 'items': [x2.pk]}
-        response = self.executeCreated(data=data, schema=self.owned_id)
+        response = self.executeCreated(data, schema=self.owned_id)
         version = Version.objects.get(pk=response.data['version'])
         items = version.data['items']
         self.assertTrue('version' in response.data)
@@ -102,7 +102,7 @@ class TestVersionViews(EndpointTester):
     @decl_endpoint('/api/versions/{version}', method='get')
     def test_access_version(self):
         data = {'version': '1.0.0', 'description': 'test'}
-        version_id = self._create_version(data=data)
+        version_id = self._create_version(data)
         invalid_id = version_id + 1337
 
         self.executeNotFound(version=invalid_id)
@@ -116,14 +116,14 @@ class TestVersionViews(EndpointTester):
 
         data = {'version': '1.2.0', 'description': 'test1'}
         self.method = 'patch'
-        self.executeForbidden(data=data)
+        self.executeForbidden(data)
 
         self.method = 'delete'
         self.executeForbidden()
 
         self.client.force_authenticate(user=self.user)
         self.method = 'patch'
-        self.executeOK(data=data)
+        self.executeOK(data)
         response = self.get()
         self.assertEqual(response.data['version'], data['version'])
         self.assertEqual(response.data['description'], data['description'])
@@ -157,7 +157,7 @@ class TestVersionViews(EndpointTester):
         x2 = self.owned.insert_last('X2')
         d1 = self.owned.insert_last('D1', term_raw='TestTerm')
         data = {'version': '1.0.0', 'description': 'test'}
-        version_id = self._create_version(data=data)
+        version_id = self._create_version(data)
         invalid_id = version_id + 1337
 
         Constituenta.objects.get(pk=d1.pk).delete()
@@ -186,7 +186,7 @@ class TestVersionViews(EndpointTester):
     def _create_version(self, data) -> int:
         response = self.client.post(
             f'/api/library/{self.owned_id}/create-version',
-            data=data, format='json'
+            data, format='json'
         )
         self.assertEqual(response.status_code, status.HTTP_201_CREATED)
         return response.data['version']  # type: ignore

rsconcept/backend/apps/oss/tests/s_propagation/t_attributes.py

@@ -73,7 +73,7 @@ class TestChangeAttributes(EndpointTester):
     def test_set_owner(self):
         data = {'user': self.user3.pk}
 
-        self.executeOK(data=data, item=self.owned_id)
+        self.executeOK(data, item=self.owned_id)
 
         self.owned.model.refresh_from_db()
         self.ks1.model.refresh_from_db()
@@ -89,7 +89,7 @@ class TestChangeAttributes(EndpointTester):
     def test_set_location(self):
         data = {'location': '/U/temp'}
 
-        self.executeOK(data=data, item=self.owned_id)
+        self.executeOK(data, item=self.owned_id)
 
         self.owned.model.refresh_from_db()
         self.ks1.model.refresh_from_db()
@@ -105,7 +105,7 @@ class TestChangeAttributes(EndpointTester):
     def test_set_access_policy(self):
         data = {'access_policy': AccessPolicy.PROTECTED}
 
-        self.executeOK(data=data, item=self.owned_id)
+        self.executeOK(data, item=self.owned_id)
 
         self.owned.model.refresh_from_db()
         self.ks1.model.refresh_from_db()
@@ -124,7 +124,7 @@ class TestChangeAttributes(EndpointTester):
         Editor.set(self.ks3.model.pk, [self.user2.pk, self.user.pk])
         data = {'users': [self.user3.pk]}
 
-        self.executeOK(data=data, item=self.owned_id)
+        self.executeOK(data, item=self.owned_id)
 
         self.owned.model.refresh_from_db()
         self.ks1.model.refresh_from_db()
@@ -140,7 +140,7 @@ class TestChangeAttributes(EndpointTester):
     def test_sync_from_result(self):
         data = {'alias': 'KS111', 'title': 'New Title', 'description': 'New description'}
 
-        self.executeOK(data=data, item=self.ks1.model.pk)
+        self.executeOK(data, item=self.ks1.model.pk)
         self.operation1.refresh_from_db()
 
         self.assertEqual(self.operation1.result, self.ks1.model)
@@ -161,7 +161,7 @@ class TestChangeAttributes(EndpointTester):
             'layout': self.layout_data
         }
 
-        response = self.executeOK(data=data, item=self.owned_id)
+        response = self.executeOK(data, item=self.owned_id)
         self.ks3.model.refresh_from_db()
         self.assertEqual(self.ks3.model.alias, data['item_data']['alias'])
         self.assertEqual(self.ks3.model.title, data['item_data']['title'])

rsconcept/backend/apps/oss/tests/s_propagation/t_constituents.py

@@ -102,7 +102,7 @@ class TestChangeConstituents(EndpointTester):
             'cst_type': CstType.BASE,
             'definition_formal': 'X4 = X5'
         }
-        response = self.executeCreated(data=data, schema=self.ks1.model.pk)
+        response = self.executeCreated(data, schema=self.ks1.model.pk)
         new_cst = Constituenta.objects.get(pk=response.data['new_cst']['id'])
         inherited_cst = Constituenta.objects.get(as_child__parent_id=new_cst.pk)
         self.assertEqual(self.ks1.constituentsQ().count(), 3)
@@ -125,7 +125,7 @@ class TestChangeConstituents(EndpointTester):
                 'crucial': True,
             }
         }
-        response = self.executeOK(data=data, schema=self.ks1.model.pk)
+        response = self.executeOK(data, schema=self.ks1.model.pk)
         self.ks1X1.refresh_from_db()
         d2.refresh_from_db()
         inherited_cst = Constituenta.objects.get(as_child__parent_id=self.ks1X1.pk)
@@ -145,7 +145,7 @@ class TestChangeConstituents(EndpointTester):
     @decl_endpoint('/api/rsforms/{schema}/delete-multiple-cst', method='patch')
     def test_delete_constituenta(self):
         data = {'items': [self.ks2X1.pk]}
-        response = self.executeOK(data=data, schema=self.ks2.model.pk)
+        response = self.executeOK(data, schema=self.ks2.model.pk)
         inherited_cst = Constituenta.objects.get(as_child__parent_id=self.ks2D1.pk)
         self.ks2D1.refresh_from_db()
         self.assertEqual(self.ks2.constituentsQ().count(), 1)
@@ -161,7 +161,7 @@ class TestChangeConstituents(EndpointTester):
             'original': self.ks1X1.pk,
             'substitution': self.ks1X2.pk
         }]}
-        self.executeOK(data=data, schema=self.ks1.model.pk)
+        self.executeOK(data, schema=self.ks1.model.pk)
         self.ks1X2.refresh_from_db()
         d2.refresh_from_db()
         self.assertEqual(self.ks1.constituentsQ().count(), 1)

rsconcept/backend/apps/oss/tests/s_propagation/t_operations.py

@@ -133,7 +133,7 @@ class TestChangeOperations(EndpointTester):
             'layout': self.layout_data,
             'target': self.operation2.pk
         }
-        self.executeOK(data=data, item=self.owned_id)
+        self.executeOK(data, item=self.owned_id)
         self.ks4D1.refresh_from_db()
         self.ks4D2.refresh_from_db()
         self.ks5D4.refresh_from_db()
@@ -155,7 +155,7 @@ class TestChangeOperations(EndpointTester):
             'target': self.operation2.pk,
             'input': None
         }
-        self.executeOK(data=data, item=self.owned_id)
+        self.executeOK(data, item=self.owned_id)
         self.ks4D1.refresh_from_db()
         self.ks4D2.refresh_from_db()
         self.ks5D4.refresh_from_db()
@@ -188,7 +188,7 @@ class TestChangeOperations(EndpointTester):
             'target': self.operation2.pk,
             'input': ks6.model.pk
         }
-        self.executeOK(data=data, item=self.owned_id)
+        self.executeOK(data, item=self.owned_id)
         ks4Dks6 = Constituenta.objects.get(as_child__parent_id=ks6D1.pk)
         self.ks4D1.refresh_from_db()
         self.ks4D2.refresh_from_db()
@@ -234,7 +234,7 @@ class TestChangeOperations(EndpointTester):
             'delete_schema': True
         }
 
-        self.executeOK(data=data, item=self.owned_id)
+        self.executeOK(data, item=self.owned_id)
         self.ks4D2.refresh_from_db()
         self.ks5D4.refresh_from_db()
         subs1_2 = self.operation4.getQ_substitutions()
@@ -256,7 +256,7 @@ class TestChangeOperations(EndpointTester):
             'delete_schema': True
         }
 
-        self.executeOK(data=data, item=self.owned_id)
+        self.executeOK(data, item=self.owned_id)
         self.ks4D2.refresh_from_db()
         self.ks5D4.refresh_from_db()
         subs1_2 = self.operation4.getQ_substitutions()
@@ -278,7 +278,7 @@ class TestChangeOperations(EndpointTester):
             'delete_schema': False
         }
 
-        self.executeOK(data=data, item=self.owned_id)
+        self.executeOK(data, item=self.owned_id)
         self.ks1.model.refresh_from_db()
         self.ks4D2.refresh_from_db()
         self.ks5D4.refresh_from_db()
@@ -317,7 +317,7 @@ class TestChangeOperations(EndpointTester):
             ]
         }
 
-        self.executeOK(data=data, item=self.owned_id)
+        self.executeOK(data, item=self.owned_id)
         self.ks4D2.refresh_from_db()
         self.ks5D4.refresh_from_db()
         subs1_2 = self.operation4.getQ_substitutions()
@@ -343,7 +343,7 @@ class TestChangeOperations(EndpointTester):
             'arguments': [self.operation1.pk],
         }
 
-        self.executeOK(data=data, item=self.owned_id)
+        self.executeOK(data, item=self.owned_id)
         self.ks4D2.refresh_from_db()
         self.ks5D4.refresh_from_db()
         subs1_2 = self.operation4.getQ_substitutions()
@@ -356,7 +356,7 @@ class TestChangeOperations(EndpointTester):
         self.assertEqual(self.ks5D4.definition_formal, r'DEL DEL X3 DEL D1 D2 D3')
 
         data['arguments'] = [self.operation1.pk, self.operation2.pk]
-        self.executeOK(data=data, item=self.owned_id)
+        self.executeOK(data, item=self.owned_id)
         self.ks4D2.refresh_from_db()
         self.ks5D4.refresh_from_db()
         subs1_2 = self.operation4.getQ_substitutions()
@@ -381,7 +381,7 @@ class TestChangeOperations(EndpointTester):
             'target': self.operation4.pk,
             'layout': self.layout_data
         }
-        self.executeOK(data=data, item=self.owned_id)
+        self.executeOK(data, item=self.owned_id)
         self.operation4.refresh_from_db()
         self.ks5.model.refresh_from_db()
         self.assertNotEqual(self.operation4.result, None)
@@ -408,7 +408,7 @@ class TestChangeOperations(EndpointTester):
             'items': [ks6A1.pk]
         }
 
-        self.executeOK(data=data)
+        self.executeOK(data)
         ks6.model.refresh_from_db()
         self.ks1.model.refresh_from_db()
         self.ks4.model.refresh_from_db()
@@ -438,7 +438,7 @@ class TestChangeOperations(EndpointTester):
             'items': [self.ks1X2.pk]
         }
 
-        self.executeOK(data=data)
+        self.executeOK(data)
         ks6.model.refresh_from_db()
         self.ks1.model.refresh_from_db()
         self.ks4.model.refresh_from_db()

rsconcept/backend/apps/oss/tests/s_propagation/t_references.py

@@ -139,7 +139,7 @@ class ReferencePropagationTestCase(EndpointTester):
             'layout': self.layout_data,
             'target': self.operation1.pk
         }
-        self.executeOK(data=data, item=self.owned_id)
+        self.executeOK(data, item=self.owned_id)
         self.assertEqual(self.ks6.constituentsQ().count(), 4)
         self.assertEqual(self.ks5.constituentsQ().count(), 5)
 
@@ -150,7 +150,7 @@ class ReferencePropagationTestCase(EndpointTester):
             'alias': 'X3',
             'cst_type': CstType.BASE,
         }
-        response = self.executeCreated(data=data, schema=self.ks1.model.pk)
+        response = self.executeCreated(data, schema=self.ks1.model.pk)
         new_cst = Constituenta.objects.get(pk=response.data['new_cst']['id'])
         inherited = Constituenta.objects.filter(as_child__parent_id=new_cst.pk)
         self.assertEqual(self.ks1.constituentsQ().count(), 4)
@@ -163,7 +163,7 @@ class ReferencePropagationTestCase(EndpointTester):
     @decl_endpoint('/api/rsforms/{schema}/delete-multiple-cst', method='patch')
     def test_delete_constituenta(self):
         data = {'items': [self.ks1X1.pk]}
-        response = self.executeOK(data=data, schema=self.ks1.model.pk)
+        response = self.executeOK(data, schema=self.ks1.model.pk)
         self.ks4D2.refresh_from_db()
         self.ks5D4.refresh_from_db()
         self.ks6D2.refresh_from_db()
@@ -183,7 +183,7 @@ class ReferencePropagationTestCase(EndpointTester):
             'keep_connections': True,
             'keep_constituents': False
         }
-        self.executeOK(data=data, item=self.owned_id)
+        self.executeOK(data, item=self.owned_id)
         self.assertEqual(self.ks4.constituentsQ().count(), 6)
         self.assertEqual(self.ks5.constituentsQ().count(), 9)
         self.assertEqual(self.ks6.constituentsQ().count(), 6)
@@ -199,7 +199,7 @@ class ReferencePropagationTestCase(EndpointTester):
         ks5X4 = Constituenta.objects.get(schema=self.ks5.model, alias='X4')
         self.assertEqual(Inheritance.objects.filter(child=ks5X4).count(), 1)
 
-        self.executeOK(data=data, item=self.owned_id)
+        self.executeOK(data, item=self.owned_id)
         self.assertEqual(self.ks4.constituentsQ().count(), 6)
         self.assertEqual(self.ks5.constituentsQ().count(), 9)
         self.assertEqual(self.ks6.constituentsQ().count(), 7)

rsconcept/backend/apps/oss/tests/s_propagation/t_substitutions.py

@@ -134,7 +134,7 @@ class TestChangeSubstitutions(EndpointTester):
             'original': self.ks1X1.pk,
             'substitution': self.ks1X2.pk
         }]}
-        self.executeOK(data=data, schema=self.ks1.model.pk)
+        self.executeOK(data, schema=self.ks1.model.pk)
         self.ks4D1.refresh_from_db()
         self.ks4D2.refresh_from_db()
         self.ks5D4.refresh_from_db()
@@ -159,7 +159,7 @@ class TestChangeSubstitutions(EndpointTester):
                 'substitution': self.ks2X1.pk
             }]
         }
-        self.executeOK(data=data, schema=self.ks2.model.pk)
+        self.executeOK(data, schema=self.ks2.model.pk)
         self.ks4D1.refresh_from_db()
         self.ks4D2.refresh_from_db()
         self.ks5D4.refresh_from_db()
@@ -179,7 +179,7 @@ class TestChangeSubstitutions(EndpointTester):
     @decl_endpoint('/api/rsforms/{schema}/delete-multiple-cst', method='patch')
     def test_delete_original(self):
         data = {'items': [self.ks1X1.pk, self.ks1D1.pk]}
-        self.executeOK(data=data, schema=self.ks1.model.pk)
+        self.executeOK(data, schema=self.ks1.model.pk)
         self.ks4D2.refresh_from_db()
         self.ks5D4.refresh_from_db()
         subs1_2 = self.operation4.getQ_substitutions()
@@ -194,7 +194,7 @@ class TestChangeSubstitutions(EndpointTester):
     @decl_endpoint('/api/rsforms/{schema}/delete-multiple-cst', method='patch')
     def test_delete_substitution(self):
         data = {'items': [self.ks2S1.pk, self.ks2X2.pk]}
-        self.executeOK(data=data, schema=self.ks2.model.pk)
+        self.executeOK(data, schema=self.ks2.model.pk)
         self.ks4D1.refresh_from_db()
         self.ks4D2.refresh_from_db()
         self.ks5D4.refresh_from_db()

rsconcept/backend/apps/oss/tests/s_views/t_blocks.py

@@ -81,9 +81,9 @@ class TestOssBlocks(EndpointTester):
             'children_operations': [],
             'children_blocks': []
         }
-        self.executeNotFound(data=data, item=self.invalid_id)
+        self.executeNotFound(data, item=self.invalid_id)
 
-        response = self.executeCreated(data=data, item=self.owned_id)
+        response = self.executeCreated(data, item=self.owned_id)
         self.assertEqual(len(response.data['oss']['blocks']), 3)
         new_block = response.data['new_block']
         layout = response.data['oss']['layout']
@@ -94,9 +94,9 @@ class TestOssBlocks(EndpointTester):
         self.assertEqual(block_node['height'], data['position']['height'])
         self.operation1.refresh_from_db()
 
-        self.executeForbidden(data=data, item=self.unowned_id)
+        self.executeForbidden(data, item=self.unowned_id)
         self.toggle_admin(True)
-        self.executeCreated(data=data, item=self.unowned_id)
+        self.executeCreated(data, item=self.unowned_id)
 
 
     @decl_endpoint('/api/oss/{item}/create-block', method='post')
@@ -118,13 +118,13 @@ class TestOssBlocks(EndpointTester):
             'children_operations': [],
             'children_blocks': []
         }
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data, item=self.owned_id)
 
         data['item_data']['parent'] = self.block3.pk
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data['item_data']['parent'] = self.block1.pk
-        response = self.executeCreated(data=data)
+        response = self.executeCreated(data)
         new_block = response.data['new_block']
         block_data = next((block for block in response.data['oss']['blocks'] if block['id'] == new_block), None)
         self.assertEqual(block_data['parent'], self.block1.pk)
@@ -148,20 +148,20 @@ class TestOssBlocks(EndpointTester):
             'children_operations': [self.invalid_id],
             'children_blocks': []
         }
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data, item=self.owned_id)
 
         data['children_operations'] = [self.operation3.pk]
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data['children_operations'] = [self.block1.pk]
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data['children_operations'] = [self.operation1.pk]
         data['children_blocks'] = [self.operation1.pk]
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data['children_blocks'] = [self.block1.pk]
-        response = self.executeCreated(data=data)
+        response = self.executeCreated(data)
         new_block = response.data['new_block']
         self.operation1.refresh_from_db()
         self.block1.refresh_from_db()
@@ -188,13 +188,13 @@ class TestOssBlocks(EndpointTester):
             'children_operations': [],
             'children_blocks': [self.block1.pk]
         }
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data, item=self.owned_id)
 
         data['item_data']['parent'] = self.block1.pk
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data['children_blocks'] = [self.block2.pk]
-        self.executeCreated(data=data)
+        self.executeCreated(data)
 
 
     @decl_endpoint('/api/oss/{item}/delete-block', method='patch')
@@ -206,26 +206,26 @@ class TestOssBlocks(EndpointTester):
         data = {
             'layout': self.layout_data
         }
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data['target'] = self.operation1.pk
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data['target'] = self.block3.pk
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data['target'] = self.block2.pk
         self.logout()
-        self.executeForbidden(data=data)
+        self.executeForbidden(data)
 
         self.login()
-        response = self.executeOK(data=data)
+        response = self.executeOK(data)
         self.operation2.refresh_from_db()
         self.assertEqual(len(response.data['blocks']), 1)
         self.assertEqual(self.operation2.parent.pk, self.block1.pk)
 
         data['target'] = self.block1.pk
-        response = self.executeOK(data=data)
+        response = self.executeOK(data)
         self.operation1.refresh_from_db()
         self.operation2.refresh_from_db()
         self.assertEqual(len(response.data['blocks']), 0)
@@ -246,25 +246,25 @@ class TestOssBlocks(EndpointTester):
                 'parent': None
             },
         }
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data['target'] = self.block3.pk
         self.toggle_admin(True)
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data['target'] = self.block2.pk
         self.logout()
-        self.executeForbidden(data=data)
+        self.executeForbidden(data)
 
         self.login()
-        response = self.executeOK(data=data)
+        response = self.executeOK(data)
         self.block2.refresh_from_db()
         self.assertEqual(self.block2.title, data['item_data']['title'])
         self.assertEqual(self.block2.description, data['item_data']['description'])
         self.assertEqual(self.block2.parent, data['item_data']['parent'])
 
         data['layout'] = self.layout_data
-        self.executeOK(data=data)
+        self.executeOK(data)
 
 
     @decl_endpoint('/api/oss/{item}/update-block', method='patch')
@@ -280,13 +280,13 @@ class TestOssBlocks(EndpointTester):
                 'parent': self.block2.pk
             },
         }
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data, item=self.owned_id)
 
         # Create a deeper hierarchy: block1 -> block2 -> block3
         self.block3 = self.owned.create_block(title='3', parent=self.block2)
         # Try to set block1's parent to block3 (should fail, indirect cycle)
         data['item_data']['parent'] = self.block3.pk
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data, item=self.owned_id)
 
         # Setting block2's parent to block1 (valid, as block1 is not a descendant)
         data = {
@@ -297,4 +297,4 @@ class TestOssBlocks(EndpointTester):
                 'parent': self.block1.pk
             },
         }
-        self.executeOK(data=data, item=self.owned_id)
+        self.executeOK(data, item=self.owned_id)

rsconcept/backend/apps/oss/tests/s_views/t_operations.py

@@ -95,9 +95,9 @@ class TestOssOperations(EndpointTester):
                 'height': 50
             }
         }
-        self.executeNotFound(data=data, item=self.invalid_id)
+        self.executeNotFound(data, item=self.invalid_id)
 
-        response = self.executeCreated(data=data, item=self.owned_id)
+        response = self.executeCreated(data, item=self.owned_id)
         self.assertEqual(len(response.data['oss']['operations']), 4)
         new_operation_id = response.data['new_operation']
         new_operation = next(op for op in response.data['oss']['operations'] if op['id'] == new_operation_id)
@@ -122,9 +122,9 @@ class TestOssOperations(EndpointTester):
         self.assertEqual(schema.location, self.owned.model.location)
         self.assertIn(self.user2, schema.getQ_editors())
 
-        self.executeForbidden(data=data, item=self.unowned_id)
+        self.executeForbidden(data, item=self.unowned_id)
         self.toggle_admin(True)
-        self.executeCreated(data=data, item=self.unowned_id)
+        self.executeCreated(data, item=self.unowned_id)
 
 
     @decl_endpoint('/api/oss/{item}/clone-schema', method='post')
@@ -141,10 +141,10 @@ class TestOssOperations(EndpointTester):
                 'height': 60
             }
         }
-        self.executeNotFound(data=data, item=self.invalid_id)
-        self.executeForbidden(data=data, item=self.unowned_id)
+        self.executeNotFound(data, item=self.invalid_id)
+        self.executeForbidden(data, item=self.unowned_id)
 
-        response = self.executeCreated(data=data, item=self.owned_id)
+        response = self.executeCreated(data, item=self.owned_id)
         self.assertIn('new_operation', response.data)
         self.assertIn('oss', response.data)
         new_operation_id = response.data['new_operation']
@@ -171,7 +171,7 @@ class TestOssOperations(EndpointTester):
 
         unrelated_data = dict(data)
         unrelated_data['source_operation'] = self.unowned_operation.pk
-        self.executeBadData(data=unrelated_data, item=self.owned_id)
+        self.executeBadData(unrelated_data, item=self.owned_id)
 
 
     @decl_endpoint('/api/oss/{item}/create-schema', method='post')
@@ -194,15 +194,15 @@ class TestOssOperations(EndpointTester):
             }
 
         }
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data, item=self.owned_id)
 
         block_unowned = self.unowned.create_block(title='TestBlock1')
         data['item_data']['parent'] = block_unowned.id
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data, item=self.owned_id)
 
         block_owned = self.owned.create_block(title='TestBlock2')
         data['item_data']['parent'] = block_owned.id
-        response = self.executeCreated(data=data, item=self.owned_id)
+        response = self.executeCreated(data, item=self.owned_id)
         new_operation_id = response.data['new_operation']
         new_operation = next(op for op in response.data['oss']['operations'] if op['id'] == new_operation_id)
         self.assertEqual(len(response.data['oss']['operations']), 4)
@@ -222,13 +222,13 @@ class TestOssOperations(EndpointTester):
                 'height': 40
             }
         }
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data, item=self.owned_id)
 
         data['target'] = self.unowned_operation.pk
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data, item=self.owned_id)
 
         data['target'] = self.operation1.pk
-        response = self.executeCreated(data=data, item=self.owned_id)
+        response = self.executeCreated(data, item=self.owned_id)
         self.owned.model.refresh_from_db()
         new_operation_id = response.data['new_operation']
         new_operation = next(op for op in response.data['oss']['operations'] if op['id'] == new_operation_id)
@@ -260,7 +260,7 @@ class TestOssOperations(EndpointTester):
             'arguments': [self.operation1.pk, self.operation3.pk],
             'substitutions': []
         }
-        response = self.executeCreated(data=data, item=self.owned_id)
+        response = self.executeCreated(data, item=self.owned_id)
         self.owned.model.refresh_from_db()
         new_operation_id = response.data['new_operation']
         new_operation = next(op for op in response.data['oss']['operations'] if op['id'] == new_operation_id)
@@ -292,13 +292,13 @@ class TestOssOperations(EndpointTester):
             'arguments': [self.operation1.pk, operation4.pk],
             'substitutions': []
         }
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data, item=self.owned_id)
 
         data['arguments'] = [operation4.pk, operation5.pk]
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data, item=self.owned_id)
 
         data['arguments'] = [operation4.pk, self.operation3.pk]
-        self.executeCreated(data=data, item=self.owned_id)
+        self.executeCreated(data, item=self.owned_id)
 
 
     @decl_endpoint('/api/oss/{item}/delete-operation', method='patch')
@@ -310,19 +310,19 @@ class TestOssOperations(EndpointTester):
         data = {
             'layout': self.layout_data
         }
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data['target'] = self.unowned_operation.pk
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data, item=self.owned_id)
 
         data['target'] = self.operation1.pk
         self.toggle_admin(True)
-        self.executeBadData(data=data, item=self.unowned_id)
+        self.executeBadData(data, item=self.unowned_id)
         self.logout()
-        self.executeForbidden(data=data, item=self.owned_id)
+        self.executeForbidden(data, item=self.owned_id)
 
         self.login()
-        response = self.executeOK(data=data)
+        response = self.executeOK(data)
         layout = response.data['layout']
         deleted_items = [item for item in layout if item['nodeID'] == 'o' + str(data['target'])]
         self.assertEqual(len(response.data['operations']), 2)
@@ -337,7 +337,7 @@ class TestOssOperations(EndpointTester):
             'layout': self.layout_data,
             'target': reference_operation.pk
         }
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data, item=self.owned_id)
 
 
     @decl_endpoint('/api/oss/{item}/delete-replica', method='patch')
@@ -347,18 +347,18 @@ class TestOssOperations(EndpointTester):
             'layout': self.layout_data,
             'target': self.invalid_id
         }
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data, item=self.owned_id)
 
         reference_operation = self.owned.create_replica(self.operation1)
         self.assertEqual(len(self.operation1.getQ_replicas()), 1)
         data['target'] = reference_operation.pk
-        self.executeForbidden(data=data, item=self.unowned_id)
+        self.executeForbidden(data, item=self.unowned_id)
 
         data['target'] = self.operation1.pk
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data, item=self.owned_id)
 
         data['target'] = reference_operation.pk
-        self.executeOK(data=data, item=self.owned_id)
+        self.executeOK(data, item=self.owned_id)
         self.assertEqual(len(self.operation1.getQ_replicas()), 0)
 
 
@@ -370,22 +370,22 @@ class TestOssOperations(EndpointTester):
         data = {
             'layout': self.layout_data
         }
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data['target'] = self.operation1.pk
         self.toggle_admin(True)
-        self.executeBadData(data=data, item=self.unowned_id)
+        self.executeBadData(data, item=self.unowned_id)
         self.logout()
-        self.executeForbidden(data=data, item=self.owned_id)
+        self.executeForbidden(data, item=self.owned_id)
 
         self.login()
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data, item=self.owned_id)
 
         self.operation1.result = None
         self.operation1.description = 'TestComment'
         self.operation1.title = 'TestTitle'
         self.operation1.save()
-        response = self.executeOK(data=data)
+        response = self.executeOK(data)
         self.operation1.refresh_from_db()
 
         new_schema = response.data['new_schema']
@@ -395,10 +395,10 @@ class TestOssOperations(EndpointTester):
         self.assertEqual(new_schema['description'], self.operation1.description)
 
         data['target'] = self.operation3.pk
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data['target'] = self.unowned_operation.pk
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data, item=self.owned_id)
 
 
     @decl_endpoint('/api/oss/{item}/set-input', method='patch')
@@ -409,17 +409,17 @@ class TestOssOperations(EndpointTester):
         data = {
             'layout': self.layout_data
         }
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data['target'] = self.operation1.pk
         data['input'] = None
         self.toggle_admin(True)
-        self.executeBadData(data=data, item=self.unowned_id)
+        self.executeBadData(data, item=self.unowned_id)
         self.logout()
-        self.executeForbidden(data=data, item=self.owned_id)
+        self.executeForbidden(data, item=self.owned_id)
 
         self.login()
-        response = self.executeOK(data=data)
+        response = self.executeOK(data)
         self.operation1.refresh_from_db()
         self.assertEqual(self.operation1.result, None)
 
@@ -428,7 +428,7 @@ class TestOssOperations(EndpointTester):
         self.ks1.model.title = 'Test421'
         self.ks1.model.description = 'TestComment42'
         self.ks1.model.save()
-        response = self.executeOK(data=data)
+        response = self.executeOK(data)
         self.operation1.refresh_from_db()
         self.assertEqual(self.operation1.result, self.ks1.model)
         self.assertEqual(self.operation1.alias, self.ks1.model.alias)
@@ -446,7 +446,7 @@ class TestOssOperations(EndpointTester):
             'target': self.operation1.pk,
             'input': self.ks2.model.pk
         }
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data, item=self.owned_id)
 
         self.ks2.model.visible = False
         self.ks2.model.save(update_fields=['visible'])
@@ -455,7 +455,7 @@ class TestOssOperations(EndpointTester):
             'target': self.operation2.pk,
             'input': None
         }
-        self.executeOK(data=data, item=self.owned_id)
+        self.executeOK(data, item=self.owned_id)
         self.operation2.refresh_from_db()
         self.ks2.model.refresh_from_db()
         self.assertEqual(self.operation2.result, None)
@@ -466,7 +466,7 @@ class TestOssOperations(EndpointTester):
             'target': self.operation1.pk,
             'input': self.ks2.model.pk
         }
-        self.executeOK(data=data, item=self.owned_id)
+        self.executeOK(data, item=self.owned_id)
         self.operation1.refresh_from_db()
         self.assertEqual(self.operation1.result, self.ks2.model)
 
@@ -494,16 +494,16 @@ class TestOssOperations(EndpointTester):
                 }
             ]
         }
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data['substitutions'][0]['substitution'] = self.ks2X1.pk
         self.toggle_admin(True)
-        self.executeBadData(data=data, item=self.unowned_id)
+        self.executeBadData(data, item=self.unowned_id)
         self.logout()
-        self.executeForbidden(data=data, item=self.owned_id)
+        self.executeForbidden(data, item=self.owned_id)
 
         self.login()
-        response = self.executeOK(data=data)
+        response = self.executeOK(data)
         self.operation3.refresh_from_db()
         self.assertEqual(self.operation3.alias, data['item_data']['alias'])
         self.assertEqual(self.operation3.title, data['item_data']['title'])
@@ -518,11 +518,11 @@ class TestOssOperations(EndpointTester):
         self.assertEqual(sub.substitution.pk, data['substitutions'][0]['substitution'])
 
         data['layout'] = self.layout_data
-        self.executeOK(data=data)
+        self.executeOK(data)
 
         data_bad = dict(data)
         data_bad['target'] = self.unowned_operation.pk
-        self.executeBadData(data=data_bad, item=self.owned_id)
+        self.executeBadData(data_bad, item=self.owned_id)
 
 
     @decl_endpoint('/api/oss/{item}/update-operation', method='patch')
@@ -539,10 +539,10 @@ class TestOssOperations(EndpointTester):
             },
             'layout': self.layout_data
         }
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data, item=self.owned_id)
 
         data['target'] = self.operation1.pk
-        response = self.executeOK(data=data)
+        response = self.executeOK(data)
         self.operation1.refresh_from_db()
         self.assertEqual(self.operation1.alias, data['item_data']['alias'])
         self.assertEqual(self.operation1.title, data['item_data']['title'])
@@ -554,7 +554,7 @@ class TestOssOperations(EndpointTester):
         # Try to update an operation from an unrelated OSS (should fail)
         data_bad = dict(data)
         data_bad['target'] = self.unowned_operation.pk
-        self.executeBadData(data=data_bad, item=self.owned_id)
+        self.executeBadData(data_bad, item=self.owned_id)
 
 
     @decl_endpoint('/api/oss/{item}/update-operation', method='patch')
@@ -583,7 +583,7 @@ class TestOssOperations(EndpointTester):
                 }
             ]
         }
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data, item=self.owned_id)
 
 
     @decl_endpoint('/api/oss/{item}/execute-operation', method='post')
@@ -595,19 +595,19 @@ class TestOssOperations(EndpointTester):
             'layout': self.layout_data,
             'target': self.operation1.pk
         }
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data['target'] = self.unowned_operation.pk
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data, item=self.owned_id)
 
         data['target'] = self.operation3.pk
         self.toggle_admin(True)
-        self.executeBadData(data=data, item=self.unowned_id)
+        self.executeBadData(data, item=self.unowned_id)
         self.logout()
-        self.executeForbidden(data=data, item=self.owned_id)
+        self.executeForbidden(data, item=self.owned_id)
 
         self.login()
-        self.executeOK(data=data)
+        self.executeOK(data)
         self.operation3.refresh_from_db()
         schema = self.operation3.result
         self.assertEqual(schema.alias, self.operation3.alias)
@@ -644,7 +644,7 @@ class TestOssOperations(EndpointTester):
             'source': target_ks.model.pk,
             'clone_source': False
         }
-        response = self.executeCreated(data=data, item=self.owned_id)
+        response = self.executeCreated(data, item=self.owned_id)
         new_operation_id = response.data['new_operation']
         new_operation = next(op for op in response.data['oss']['operations'] if op['id'] == new_operation_id)
         layout = response.data['oss']['layout']
@@ -684,7 +684,7 @@ class TestOssOperations(EndpointTester):
             'source': self.ks2.model.pk,
             'clone_source': True
         }
-        response = self.executeCreated(data=data, item=self.owned_id)
+        response = self.executeCreated(data, item=self.owned_id)
         new_operation_id = response.data['new_operation']
         new_operation = next(op for op in response.data['oss']['operations'] if op['id'] == new_operation_id)
         layout = response.data['oss']['layout']
@@ -725,13 +725,13 @@ class TestOssOperations(EndpointTester):
             # 'source' missing
             'clone_source': False
         }
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data, item=self.owned_id)
         # Invalid source
         data['source'] = self.invalid_id
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data, item=self.owned_id)
         # Invalid OSS
         data['source'] = self.ks1.model.pk
-        self.executeNotFound(data=data, item=self.invalid_id)
+        self.executeNotFound(data, item=self.invalid_id)
 
     @decl_endpoint('/api/oss/{item}/import-schema', method='post')
     def test_import_schema_permissions(self):
@@ -752,8 +752,8 @@ class TestOssOperations(EndpointTester):
         }
         # Not an editor
         self.logout()
-        self.executeForbidden(data=data, item=self.owned_id)
+        self.executeForbidden(data, item=self.owned_id)
         # As admin
         self.login()
         self.toggle_admin(True)
-        self.executeCreated(data=data, item=self.owned_id)
+        self.executeCreated(data, item=self.owned_id)

rsconcept/backend/apps/oss/tests/s_views/t_oss.py

@@ -126,7 +126,7 @@ class TestOssViewset(EndpointTester):
         self.executeBadData(item=self.owned_id)
 
         data = {'data': []}
-        self.executeOK(data=data)
+        self.executeOK(data)
 
         data = {'data': [
             {'nodeID': 'o' + str(self.operation1.pk), 'x': 42.1, 'y': 1337, 'width': 150, 'height': 40},
@@ -134,15 +134,15 @@ class TestOssViewset(EndpointTester):
             {'nodeID': 'o' + str(self.operation3.pk), 'x': 36.1, 'y': 1435, 'width': 150, 'height': 40}
         ]}
         self.toggle_admin(True)
-        self.executeOK(data=data, item=self.unowned_id)
+        self.executeOK(data, item=self.unowned_id)
 
         self.toggle_admin(False)
-        self.executeOK(data=data, item=self.owned_id)
+        self.executeOK(data, item=self.owned_id)
         self.owned.model.refresh_from_db()
         self.assertEqual(OperationSchema.layoutQ(self.owned_id).data, data['data'])
 
-        self.executeForbidden(data=data, item=self.unowned_id)
-        self.executeForbidden(data=data, item=self.private_id)
+        self.executeForbidden(data, item=self.unowned_id)
+        self.executeForbidden(data, item=self.private_id)
 
 
     @decl_endpoint('/api/oss/get-predecessor', method='post')
@@ -155,13 +155,13 @@ class TestOssViewset(EndpointTester):
         self.ks3 = RSForm(self.operation3.result)
         self.ks3X2 = Constituenta.objects.get(as_child__parent_id=self.ks1X2.pk)
 
-        self.executeBadData(data={'target': self.invalid_id})
+        self.executeBadData({'target': self.invalid_id})
 
-        response = self.executeOK(data={'target': self.ks1X1.pk})
+        response = self.executeOK({'target': self.ks1X1.pk})
         self.assertEqual(response.data['id'], self.ks1X1.pk)
         self.assertEqual(response.data['schema'], self.ks1.model.pk)
 
-        response = self.executeOK(data={'target': self.ks3X2.pk})
+        response = self.executeOK({'target': self.ks3X2.pk})
         self.assertEqual(response.data['id'], self.ks1X2.pk)
         self.assertEqual(response.data['schema'], self.ks1.model.pk)
 
@@ -180,10 +180,10 @@ class TestOssViewset(EndpointTester):
             'operations': [self.operation1.pk, self.operation2.pk],
             'destination': block2.pk
         }
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data['destination'] = block1.pk
-        self.executeOK(data=data)
+        self.executeOK(data)
         self.operation1.refresh_from_db()
         self.operation2.refresh_from_db()
         block2.refresh_from_db()
@@ -193,7 +193,7 @@ class TestOssViewset(EndpointTester):
         self.assertEqual(block2.parent.pk, block1.pk)
 
         data['destination'] = None
-        self.executeOK(data=data)
+        self.executeOK(data)
         self.operation1.refresh_from_db()
         self.operation2.refresh_from_db()
         block2.refresh_from_db()
@@ -217,7 +217,7 @@ class TestOssViewset(EndpointTester):
             'operations': [],
             'destination': block3.pk
         }
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
 
     @decl_endpoint('/api/oss/relocate-constituents', method='post')
@@ -236,35 +236,35 @@ class TestOssViewset(EndpointTester):
             'destination': self.invalid_id,
             'items': []
         }
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         # empty items
         data = {
             'destination': self.ks1.model.pk,
             'items': []
         }
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         # source == destination
         data = {
             'destination': self.ks1.model.pk,
             'items': [self.ks1X1.pk]
         }
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         # moving inherited
         data = {
             'destination': self.ks1.model.pk,
             'items': [self.ks3X2.pk]
         }
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         # source and destination are not connected
         data = {
             'destination': self.ks2.model.pk,
             'items': [self.ks1X1.pk]
         }
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data = {
             'destination': self.ks3.model.pk,
@@ -272,14 +272,14 @@ class TestOssViewset(EndpointTester):
         }
         self.ks3X2.refresh_from_db()
         self.assertEqual(self.ks3X2.convention, 'test')
-        self.executeOK(data=data)
+        self.executeOK(data)
         self.assertFalse(Constituenta.objects.filter(as_child__parent_id=self.ks1X2.pk).exists())
 
         data = {
             'destination': self.ks1.model.pk,
             'items': [self.ks3X10.pk]
         }
-        self.executeOK(data=data)
+        self.executeOK(data)
         self.assertTrue(Constituenta.objects.filter(as_parent__child_id=self.ks3X10.pk).exists())
         self.ks1X3 = Constituenta.objects.get(as_parent__child_id=self.ks3X10.pk)
         self.assertEqual(self.ks1X3.convention, 'test2')

rsconcept/backend/apps/oss/views/oss.py

@@ -140,10 +140,7 @@ class OssViewSet(viewsets.GenericViewSet, generics.ListAPIView, generics.Retriev
     def create_block(self, request: Request, pk) -> HttpResponse:
         ''' Create Block. '''
         item = self._get_item()
-        serializer = s.CreateBlockSerializer(
-            data=request.data,
-            context={'oss': item}
-        )
+        serializer = s.CreateBlockSerializer(data=request.data, context={'oss': item})
         serializer.is_valid(raise_exception=True)
         layout = serializer.validated_data['layout']
         position = serializer.validated_data['position']
@@ -194,10 +191,7 @@ class OssViewSet(viewsets.GenericViewSet, generics.ListAPIView, generics.Retriev
     def update_block(self, request: Request, pk) -> HttpResponse:
         ''' Update Block. '''
         item = self._get_item()
-        serializer = s.UpdateBlockSerializer(
-            data=request.data,
-            context={'oss': item}
-        )
+        serializer = s.UpdateBlockSerializer(data=request.data, context={'oss': item})
         serializer.is_valid(raise_exception=True)
         block: m.Block = cast(m.Block, serializer.validated_data['target'])
 
@@ -234,10 +228,7 @@ class OssViewSet(viewsets.GenericViewSet, generics.ListAPIView, generics.Retriev
     def delete_block(self, request: Request, pk) -> HttpResponse:
         ''' Endpoint: Delete Block. '''
         item = self._get_item()
-        serializer = s.DeleteBlockSerializer(
-            data=request.data,
-            context={'oss': item}
-        )
+        serializer = s.DeleteBlockSerializer(data=request.data, context={'oss': item})
         serializer.is_valid(raise_exception=True)
         block = cast(m.Block, serializer.validated_data['target'])
         layout = serializer.validated_data['layout']
@@ -269,10 +260,7 @@ class OssViewSet(viewsets.GenericViewSet, generics.ListAPIView, generics.Retriev
     def move_items(self, request: Request, pk) -> HttpResponse:
         ''' Move items to another parent. '''
         item = self._get_item()
-        serializer = s.MoveItemsSerializer(
-            data=request.data,
-            context={'oss': item}
-        )
+        serializer = s.MoveItemsSerializer(data=request.data, context={'oss': item})
         serializer.is_valid(raise_exception=True)
         layout = serializer.validated_data['layout']
 
@@ -306,10 +294,7 @@ class OssViewSet(viewsets.GenericViewSet, generics.ListAPIView, generics.Retriev
     def create_schema(self, request: Request, pk) -> HttpResponse:
         ''' Create schema. '''
         item = self._get_item()
-        serializer = s.CreateSchemaSerializer(
-            data=request.data,
-            context={'oss': item}
-        )
+        serializer = s.CreateSchemaSerializer(data=request.data, context={'oss': item})
         serializer.is_valid(raise_exception=True)
         layout = serializer.validated_data['layout']
         position = serializer.validated_data['position']
@@ -354,10 +339,7 @@ class OssViewSet(viewsets.GenericViewSet, generics.ListAPIView, generics.Retriev
     def clone_schema(self, request: Request, pk) -> HttpResponse:
         ''' Clone schema. '''
         item = self._get_item()
-        serializer = s.CloneSchemaSerializer(
-            data=request.data,
-            context={'oss': item}
-        )
+        serializer = s.CloneSchemaSerializer(data=request.data, context={'oss': item})
         serializer.is_valid(raise_exception=True)
         layout = serializer.validated_data['layout']
         position = serializer.validated_data['position']
@@ -424,10 +406,7 @@ class OssViewSet(viewsets.GenericViewSet, generics.ListAPIView, generics.Retriev
     def import_schema(self, request: Request, pk) -> HttpResponse:
         ''' Create operation with existing schema. '''
         item = self._get_item()
-        serializer = s.ImportSchemaSerializer(
-            data=request.data,
-            context={'oss': item}
-        )
+        serializer = s.ImportSchemaSerializer(data=request.data, context={'oss': item})
         serializer.is_valid(raise_exception=True)
         layout = serializer.validated_data['layout']
         position = serializer.validated_data['position']
@@ -479,10 +458,7 @@ class OssViewSet(viewsets.GenericViewSet, generics.ListAPIView, generics.Retriev
     def create_replica(self, request: Request, pk) -> HttpResponse:
         ''' Replicate schema. '''
         item = self._get_item()
-        serializer = s.CreateReplicaSerializer(
-            data=request.data,
-            context={'oss': item}
-        )
+        serializer = s.CreateReplicaSerializer(data=request.data, context={'oss': item})
         serializer.is_valid(raise_exception=True)
         layout = serializer.validated_data['layout']
         position = serializer.validated_data['position']
@@ -524,10 +500,7 @@ class OssViewSet(viewsets.GenericViewSet, generics.ListAPIView, generics.Retriev
     def create_synthesis(self, request: Request, pk) -> HttpResponse:
         ''' Create Synthesis operation from arguments. '''
         item = self._get_item()
-        serializer = s.CreateSynthesisSerializer(
-            data=request.data,
-            context={'oss': item}
-        )
+        serializer = s.CreateSynthesisSerializer(data=request.data, context={'oss': item})
         serializer.is_valid(raise_exception=True)
         layout = serializer.validated_data['layout']
         position = serializer.validated_data['position']
@@ -573,10 +546,7 @@ class OssViewSet(viewsets.GenericViewSet, generics.ListAPIView, generics.Retriev
     def update_operation(self, request: Request, pk) -> HttpResponse:
         ''' Update Operation arguments and parameters. '''
         item = self._get_item()
-        serializer = s.UpdateOperationSerializer(
-            data=request.data,
-            context={'oss': item}
-        )
+        serializer = s.UpdateOperationSerializer(data=request.data, context={'oss': item})
         serializer.is_valid(raise_exception=True)
         operation: m.Operation = cast(m.Operation, serializer.validated_data['target'])
 
@@ -628,10 +598,7 @@ class OssViewSet(viewsets.GenericViewSet, generics.ListAPIView, generics.Retriev
     def delete_operation(self, request: Request, pk) -> HttpResponse:
         ''' Endpoint: Delete Operation. '''
         item = self._get_item()
-        serializer = s.DeleteOperationSerializer(
-            data=request.data,
-            context={'oss': item}
-        )
+        serializer = s.DeleteOperationSerializer(data=request.data, context={'oss': item})
         serializer.is_valid(raise_exception=True)
         operation = cast(m.Operation, serializer.validated_data['target'])
         old_schema = operation.result
@@ -671,10 +638,7 @@ class OssViewSet(viewsets.GenericViewSet, generics.ListAPIView, generics.Retriev
     def delete_replica(self, request: Request, pk) -> HttpResponse:
         ''' Endpoint: Delete Replica Operation. '''
         item = self._get_item()
-        serializer = s.DeleteReplicaSerializer(
-            data=request.data,
-            context={'oss': item}
-        )
+        serializer = s.DeleteReplicaSerializer(data=request.data, context={'oss': item})
         serializer.is_valid(raise_exception=True)
         operation = cast(m.Operation, serializer.validated_data['target'])
         keep_connections = serializer.validated_data['keep_connections']
@@ -708,10 +672,7 @@ class OssViewSet(viewsets.GenericViewSet, generics.ListAPIView, generics.Retriev
     def create_input(self, request: Request, pk) -> HttpResponse:
         ''' Create input RSForm. '''
         item = self._get_item()
-        serializer = s.TargetOperationSerializer(
-            data=request.data,
-            context={'oss': item}
-        )
+        serializer = s.TargetOperationSerializer(data=request.data, context={'oss': item})
         serializer.is_valid(raise_exception=True)
         operation: m.Operation = cast(m.Operation, serializer.validated_data['target'])
         if len(operation.getQ_arguments()) > 0:
@@ -752,10 +713,7 @@ class OssViewSet(viewsets.GenericViewSet, generics.ListAPIView, generics.Retriev
     def set_input(self, request: Request, pk) -> HttpResponse:
         ''' Set input schema for target operation. '''
         item = self._get_item()
-        serializer = s.SetOperationInputSerializer(
-            data=request.data,
-            context={'oss': item}
-        )
+        serializer = s.SetOperationInputSerializer(data=request.data, context={'oss': item})
         serializer.is_valid(raise_exception=True)
 
         layout = serializer.validated_data['layout']
@@ -804,10 +762,7 @@ class OssViewSet(viewsets.GenericViewSet, generics.ListAPIView, generics.Retriev
     def execute_operation(self, request: Request, pk) -> HttpResponse:
         ''' Execute operation. '''
         item = self._get_item()
-        serializer = s.TargetOperationSerializer(
-            data=request.data,
-            context={'oss': item}
-        )
+        serializer = s.TargetOperationSerializer(data=request.data, context={'oss': item})
         serializer.is_valid(raise_exception=True)
         operation: m.Operation = cast(m.Operation, serializer.validated_data['target'])
         if operation.operation_type != m.OperationType.SYNTHESIS:

rsconcept/backend/apps/prompt/tests/t_prompts.py

@@ -24,7 +24,7 @@ class TestPromptTemplateViewSet(EndpointTester):
             'text': 'prompt text',
             'is_shared': False
         }
-        response = self.executeCreated(data=data)
+        response = self.executeCreated(data)
         self.assertEqual(response.data['label'], 'Test')
         self.assertEqual(response.data['owner'], self.user.pk)
 
@@ -38,7 +38,7 @@ class TestPromptTemplateViewSet(EndpointTester):
             'text': 'prompt text',
             'is_shared': True
         }
-        response = self.executeCreated(data=data)
+        response = self.executeCreated(data)
         self.assertTrue(response.data['is_shared'])
 
 
@@ -50,21 +50,21 @@ class TestPromptTemplateViewSet(EndpointTester):
             'text': 'prompt text',
             'is_shared': True
         }
-        response = self.executeBadData(data=data)
+        response = self.executeBadData(data)
         self.assertIn('is_shared', response.data)
 
 
     @decl_endpoint('/api/prompts/{item}/', method='patch')
     def test_update_prompt_owner(self):
         prompt = PromptTemplate.objects.create(owner=self.user, label='ToUpdate', description='', text='t')
-        response = self.executeOK(data={'label': 'Updated'}, item=prompt.id)
+        response = self.executeOK({'label': 'Updated'}, item=prompt.id)
         self.assertEqual(response.data['label'], 'Updated')
 
 
     @decl_endpoint('/api/prompts/{item}/', method='patch')
     def test_update_prompt_not_owner_forbidden(self):
         prompt = PromptTemplate.objects.create(owner=self.admin, label='Other', description='', text='t')
-        response = self.executeForbidden(data={'label': 'Updated'}, item=prompt.id)
+        response = self.executeForbidden({'label': 'Updated'}, item=prompt.id)
 
 
     @decl_endpoint('/api/prompts/{item}/', method='delete')
@@ -112,4 +112,4 @@ class TestPromptTemplateViewSet(EndpointTester):
             is_shared=True
         )
         self.client.force_authenticate(user=self.user)
-        response = self.executeForbidden(data={'label': 'Nope'}, item=prompt.id)
+        response = self.executeForbidden({'label': 'Nope'}, item=prompt.id)

rsconcept/backend/apps/rsform/serializers/data_access.py

@@ -121,6 +121,11 @@ class CstCreateSerializer(StrictModelSerializer):
     )
     alias = serializers.CharField(max_length=8)
     cst_type = serializers.ChoiceField(CstType.choices)
+    associations = PKField(
+        many=True,
+        required=False,
+        queryset=Constituenta.objects.all().only('schema_id', 'pk')
+    )
 
     class Meta:
         ''' serializer metadata. '''
@@ -128,7 +133,22 @@ class CstCreateSerializer(StrictModelSerializer):
         fields = \
             'alias', 'cst_type', 'convention', 'crucial', \
             'term_raw', 'definition_raw', 'definition_formal', \
-            'insert_after', 'term_forms'
+            'insert_after', 'term_forms', 'associations'
+
+    def validate(self, attrs):
+        schema = cast(LibraryItem, self.context['schema'])
+        insert_after = attrs.get('insert_after')
+        if insert_after and insert_after.schema_id != schema.pk:
+            raise serializers.ValidationError({
+                'insert_after': msg.constituentaNotInRSform(schema.title)
+            })
+        associations = attrs.get('associations', [])
+        for assoc in associations:
+            if assoc.schema_id != schema.pk:
+                raise serializers.ValidationError({
+                    'associations': msg.constituentaNotInRSform(schema.title)
+                })
+        return attrs
 
 
 class RSFormSerializer(StrictModelSerializer):

rsconcept/backend/apps/rsform/tests/s_models/t_RSFormCached.py

@@ -48,7 +48,7 @@ class TestRSFormCached(DBTester):
 
         x1 = self.schema.insert_last('X1')
         x2 = self.schema.insert_last('X2')
-        x3 = self.schema.create_cst(data=data, insert_after=x1)
+        x3 = self.schema.create_cst(data, insert_after=x1)
         x2.refresh_from_db()
 
         self.assertEqual(x3.alias, data['alias'])

rsconcept/backend/apps/rsform/tests/s_views/__init__.py

@@ -1,4 +1,5 @@
 ''' Tests for REST API. '''
 from .t_cctext import *
+from .t_constituenta import *
 from .t_rsforms import *
 from .t_rslang import *

rsconcept/backend/apps/rsform/tests/s_views/t_cctext.py

@@ -14,20 +14,20 @@ class TestNaturalLanguageViews(EndpointTester):
     @decl_endpoint(endpoint='/api/cctext/parse', method='post')
     def test_parse_text(self):
         data = {'text': 'синим слонам'}
-        response = self.executeOK(data=data)
+        response = self.executeOK(data)
         self._assert_tags(response.data['result'], 'datv,NOUN,plur,anim,masc')
 
 
     @decl_endpoint(endpoint='/api/cctext/inflect', method='post')
     def test_inflect(self):
         data = {'text': 'синий слон', 'grams': 'plur,datv'}
-        response = self.executeOK(data=data)
+        response = self.executeOK(data)
         self.assertEqual(response.data['result'], 'синим слонам')
 
 
     @decl_endpoint(endpoint='/api/cctext/generate-lexeme', method='post')
     def test_generate_lexeme(self):
         data = {'text': 'синий слон'}
-        response = self.executeOK(data=data)
+        response = self.executeOK(data)
         self.assertEqual(len(response.data['items']), 12)
         self.assertEqual(response.data['items'][0]['text'], 'синий слон')

rsconcept/backend/apps/rsform/tests/s_views/t_constituenta.py

@@ -0,0 +1,139 @@
+''' Testing API: Constituenta editing. '''
+from apps.rsform.models import Constituenta, CstType, RSForm
+from shared.EndpointTester import EndpointTester, decl_endpoint
+
+
+class TestConstituentaAPI(EndpointTester):
+    ''' Testing Constituenta view. '''
+
+    def setUp(self):
+        super().setUp()
+        self.owned = RSForm.create(title='Test', alias='T1', owner=self.user)
+        self.owned_id = self.owned.model.pk
+        self.unowned = RSForm.create(title='Test2', alias='T2')
+        self.unowned_id = self.unowned.model.pk
+        self.cst1 = Constituenta.objects.create(
+            alias='X1',
+            cst_type=CstType.BASE,
+            schema=self.owned.model,
+            order=0,
+            convention='Test',
+            term_raw='Test1',
+            term_resolved='Test1R',
+            term_forms=[{'text': 'form1', 'tags': 'sing,datv'}])
+        self.cst2 = Constituenta.objects.create(
+            alias='X2',
+            cst_type=CstType.BASE,
+            schema=self.unowned.model,
+            order=0,
+            convention='Test1',
+            term_raw='Test2',
+            term_resolved='Test2R'
+        )
+        self.cst3 = Constituenta.objects.create(
+            alias='X3',
+            schema=self.owned.model,
+            order=1,
+            term_raw='Test3',
+            term_resolved='Test3',
+            definition_raw='Test1',
+            definition_resolved='Test2'
+        )
+        self.invalid_cst = self.cst3.pk + 1337
+
+    @decl_endpoint('/api/rsforms/{schema}/update-cst', method='patch')
+    def test_partial_update(self):
+        data = {'target': self.cst1.pk, 'item_data': {'convention': 'tt'}}
+        self.executeForbidden(data, schema=self.unowned_id)
+
+        self.logout()
+        self.executeForbidden(data, schema=self.owned_id)
+
+        self.login()
+        self.executeOK(data)
+        self.cst1.refresh_from_db()
+        self.assertEqual(self.cst1.convention, 'tt')
+
+        self.executeOK(data)
+
+
+    @decl_endpoint('/api/rsforms/{schema}/update-cst', method='patch')
+    def test_partial_update_rename(self):
+        data = {'target': self.cst1.pk, 'item_data': {'alias': self.cst3.alias}}
+        self.executeBadData(data, schema=self.owned_id)
+
+        d1 = self.owned.insert_last(
+            alias='D1',
+            term_raw='@{X1|plur}',
+            definition_formal='X1'
+        )
+        self.assertEqual(self.cst1.order, 0)
+        self.assertEqual(self.cst1.alias, 'X1')
+        self.assertEqual(self.cst1.cst_type, CstType.BASE)
+
+        data = {'target': self.cst1.pk, 'item_data': {'alias': 'D2', 'cst_type': CstType.TERM}}
+        self.executeOK(data, schema=self.owned_id)
+        d1.refresh_from_db()
+        self.cst1.refresh_from_db()
+        self.assertEqual(d1.term_resolved, '')
+        self.assertEqual(d1.term_raw, '@{D2|plur}')
+        self.assertEqual(self.cst1.order, 0)
+        self.assertEqual(self.cst1.alias, 'D2')
+        self.assertEqual(self.cst1.cst_type, CstType.TERM)
+
+
+    @decl_endpoint('/api/rsforms/{schema}/update-cst', method='patch')
+    def test_update_resolved_no_refs(self):
+        data = {
+            'target': self.cst3.pk,
+            'item_data': {
+                'term_raw': 'New term',
+                'definition_raw': 'New def'
+            }
+        }
+        self.executeOK(data, schema=self.owned_id)
+        self.cst3.refresh_from_db()
+        self.assertEqual(self.cst3.term_resolved, 'New term')
+        self.assertEqual(self.cst3.definition_resolved, 'New def')
+
+
+    @decl_endpoint('/api/rsforms/{schema}/update-cst', method='patch')
+    def test_update_resolved_refs(self):
+        data = {
+            'target': self.cst3.pk,
+            'item_data': {
+                'term_raw': '@{X1|nomn,sing}',
+                'definition_raw': '@{X1|nomn,sing} @{X1|sing,datv}'
+            }
+        }
+        self.executeOK(data, schema=self.owned_id)
+        self.cst3.refresh_from_db()
+        self.assertEqual(self.cst3.term_resolved, self.cst1.term_resolved)
+        self.assertEqual(self.cst3.definition_resolved, f'{self.cst1.term_resolved} form1')
+
+    @decl_endpoint('/api/rsforms/{schema}/update-cst', method='patch')
+    def test_update_term_forms(self):
+        data = {
+            'target': self.cst3.pk,
+            'item_data': {
+                'definition_raw': '@{X3|sing,datv}',
+                'term_forms': [{'text': 'form1', 'tags': 'sing,datv'}]
+            }
+        }
+        self.executeOK(data, schema=self.owned_id)
+        self.cst3.refresh_from_db()
+        self.assertEqual(self.cst3.definition_resolved, 'form1')
+        self.assertEqual(self.cst3.term_forms, data['item_data']['term_forms'])
+
+    @decl_endpoint('/api/rsforms/{schema}/update-crucial', method='patch')
+    def test_update_crucial(self):
+        data = {'target': [self.cst1.pk], 'value': True}
+        self.executeForbidden(data, schema=self.unowned_id)
+
+        self.logout()
+        self.executeForbidden(data, schema=self.owned_id)
+
+        self.login()
+        self.executeOK(data, schema=self.owned_id)
+        self.cst1.refresh_from_db()
+        self.assertEqual(self.cst1.crucial, True)

rsconcept/backend/apps/rsform/tests/s_views/t_rsforms.py

@@ -36,11 +36,11 @@ class TestRSFormViewset(EndpointTester):
             'access_policy': AccessPolicy.PROTECTED,
             'visible': False
         }
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         with open(f'{work_dir}/data/sample-rsform.trs', 'rb') as file:
             data['file'] = file
-            response = self.client.post(self.endpoint, data=data, format='multipart')
+            response = self.client.post(self.endpoint, data, format='multipart')
         self.assertEqual(response.status_code, status.HTTP_201_CREATED)
         self.assertEqual(response.data['owner'], self.user.pk)
         self.assertEqual(response.data['title'], data['title'])
@@ -117,21 +117,21 @@ class TestRSFormViewset(EndpointTester):
     def test_check_expression(self):
         self.owned.insert_last('X1')
         data = {'expression': 'X1=X1'}
-        response = self.executeOK(data=data, item=self.owned_id)
+        response = self.executeOK(data, item=self.owned_id)
         self.assertEqual(response.data['parseResult'], True)
         self.assertEqual(response.data['syntax'], 'math')
         self.assertEqual(response.data['astText'], '[=[X1][X1]]')
         self.assertEqual(response.data['typification'], 'LOGIC')
         self.assertEqual(response.data['valueClass'], 'value')
 
-        self.executeOK(data=data, item=self.unowned_id)
+        self.executeOK(data, item=self.unowned_id)
 
 
     @decl_endpoint('/api/rsforms/{item}/check-constituenta', method='post')
     def test_check_constituenta(self):
         self.owned.insert_last('X1')
         data = {'definition_formal': 'X1=X1', 'alias': 'A111', 'cst_type': CstType.AXIOM}
-        response = self.executeOK(data=data, item=self.owned_id)
+        response = self.executeOK(data, item=self.owned_id)
         self.assertEqual(response.data['parseResult'], True)
         self.assertEqual(response.data['syntax'], 'math')
         self.assertEqual(response.data['astText'], '[:==[A111][=[X1][X1]]]')
@@ -143,7 +143,7 @@ class TestRSFormViewset(EndpointTester):
     def test_check_constituenta_error(self):
         self.owned.insert_last('X1')
         data = {'definition_formal': 'X1=X1', 'alias': 'D111', 'cst_type': CstType.TERM}
-        response = self.executeOK(data=data, item=self.owned_id)
+        response = self.executeOK(data, item=self.owned_id)
         self.assertEqual(response.data['parseResult'], False)
 
 
@@ -155,7 +155,7 @@ class TestRSFormViewset(EndpointTester):
         )
 
         data = {'text': '@{1|редкий} @{X1|plur,datv}'}
-        response = self.executeOK(data=data, item=self.owned_id)
+        response = self.executeOK(data, item=self.owned_id)
         self.assertEqual(response.data['input'], '@{1|редкий} @{X1|plur,datv}')
         self.assertEqual(response.data['output'], 'редким синим слонам')
         self.assertEqual(len(response.data['refs']), 2)
@@ -182,7 +182,7 @@ class TestRSFormViewset(EndpointTester):
         work_dir = os.path.dirname(os.path.abspath(__file__))
         with open(f'{work_dir}/data/sample-rsform.trs', 'rb') as file:
             data = {'file': file}
-            response = self.client.post(self.endpoint, data=data, format='multipart')
+            response = self.client.post(self.endpoint, data, format='multipart')
         self.assertEqual(response.status_code, status.HTTP_201_CREATED)
         self.assertEqual(response.data['owner'], self.user.pk)
         self.assertTrue(response.data['title'] != '')
@@ -203,19 +203,19 @@ class TestRSFormViewset(EndpointTester):
     @decl_endpoint('/api/rsforms/{item}/create-cst', method='post')
     def test_create_constituenta(self):
         data = {'alias': 'X3', 'cst_type': CstType.BASE}
-        self.executeForbidden(data=data, item=self.unowned_id)
+        self.executeForbidden(data, item=self.unowned_id)
 
         data = {'alias': 'X3'}
         self.owned.insert_last('X1')
         x2 = self.owned.insert_last('X2')
         self.executeBadData(item=self.owned_id)
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data)
 
         data['cst_type'] = 'invalid'
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data)
 
         data['cst_type'] = CstType.BASE
-        response = self.executeCreated(data=data, item=self.owned_id)
+        response = self.executeCreated(data)
         self.assertEqual(response.data['new_cst']['alias'], 'X3')
         x3 = Constituenta.objects.get(alias=response.data['new_cst']['alias'])
         self.assertEqual(x3.order, 2)
@@ -229,7 +229,7 @@ class TestRSFormViewset(EndpointTester):
             'definition_formal': 'invalid',
             'crucial': True
         }
-        response = self.executeCreated(data=data, item=self.owned_id)
+        response = self.executeCreated(data)
         self.assertEqual(response.data['new_cst']['alias'], data['alias'])
         x4 = Constituenta.objects.get(alias=response.data['new_cst']['alias'])
         self.assertEqual(x4.order, 2)
@@ -244,13 +244,14 @@ class TestRSFormViewset(EndpointTester):
             'insert_after': None,
             'term_raw': 'test5'
         }
-        response = self.executeCreated(data=data, item=self.owned_id)
+        response = self.executeCreated(data)
         self.assertEqual(response.data['new_cst']['alias'], data['alias'])
 
 
     @decl_endpoint('/api/rsforms/{item}/substitute', method='patch')
     def test_substitute_multiple(self):
         self.set_params(item=self.owned_id)
+
         x1 = self.owned.insert_last('X1')
         x2 = self.owned.insert_last('X2')
         d1 = self.owned.insert_last('D1')
@@ -261,7 +262,7 @@ class TestRSFormViewset(EndpointTester):
         )
 
         data = {'substitutions': []}
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data = {'substitutions': [
             {
@@ -273,7 +274,7 @@ class TestRSFormViewset(EndpointTester):
                 'substitution': d2.pk
             }
         ]}
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data = {'substitutions': [
             {
@@ -285,7 +286,7 @@ class TestRSFormViewset(EndpointTester):
                 'substitution': d2.pk
             }
         ]}
-        response = self.executeOK(data=data, item=self.owned_id)
+        response = self.executeOK(data, item=self.owned_id)
         d3.refresh_from_db()
         self.assertEqual(d3.definition_formal, r'D1 \ D2')
 
@@ -300,7 +301,7 @@ class TestRSFormViewset(EndpointTester):
             'definition_formal': '3',
             'definition_raw': '4'
         }
-        response = self.executeCreated(data=data, item=self.owned_id)
+        response = self.executeCreated(data, item=self.owned_id)
         self.assertEqual(response.data['new_cst']['alias'], 'X3')
         self.assertEqual(response.data['new_cst']['cst_type'], CstType.BASE)
         self.assertEqual(response.data['new_cst']['convention'], '1')
@@ -316,13 +317,13 @@ class TestRSFormViewset(EndpointTester):
         self.set_params(item=self.owned_id)
 
         data = {'items': [1337]}
-        self.executeBadData(data=data)
+        self.executeBadData(data, item=self.owned_id)
 
         x1 = self.owned.insert_last('X1')
         x2 = self.owned.insert_last('X2')
 
         data = {'items': [x1.pk]}
-        response = self.executeOK(data=data)
+        response = self.executeOK(data)
         x2.refresh_from_db()
         self.owned.model.refresh_from_db()
         self.assertEqual(len(response.data['items']), 1)
@@ -332,7 +333,7 @@ class TestRSFormViewset(EndpointTester):
 
         x3 = self.unowned.insert_last('X1')
         data = {'items': [x3.pk]}
-        self.executeBadData(data=data, item=self.owned_id)
+        self.executeBadData(data, item=self.owned_id)
 
 
     @decl_endpoint('/api/rsforms/{item}/move-cst', method='patch')
@@ -340,13 +341,13 @@ class TestRSFormViewset(EndpointTester):
         self.set_params(item=self.owned_id)
 
         data = {'items': [1337], 'move_to': 0}
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         x1 = self.owned.insert_last('X1')
         x2 = self.owned.insert_last('X2')
 
         data = {'items': [x2.pk], 'move_to': 0}
-        response = self.executeOK(data=data)
+        response = self.executeOK(data)
         x1.refresh_from_db()
         x2.refresh_from_db()
         self.assertEqual(response.data['id'], self.owned_id)
@@ -355,7 +356,7 @@ class TestRSFormViewset(EndpointTester):
 
         x3 = self.unowned.insert_last('X1')
         data = {'items': [x3.pk], 'move_to': 0}
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
 
     @decl_endpoint('/api/rsforms/{item}/reset-aliases', method='patch')
@@ -392,7 +393,7 @@ class TestRSFormViewset(EndpointTester):
         work_dir = os.path.dirname(os.path.abspath(__file__))
         with open(f'{work_dir}/data/sample-rsform.trs', 'rb') as file:
             data = {'file': file, 'load_metadata': False}
-            response = self.client.patch(self.endpoint, data=data, format='multipart')
+            response = self.client.patch(self.endpoint, data, format='multipart')
         self.owned.model.refresh_from_db()
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertEqual(self.owned.model.title, 'Test11')
@@ -432,7 +433,7 @@ class TestRSFormViewset(EndpointTester):
         self.executeBadData({'target': s2.pk})
 
         # Testing simple structure
-        response = self.executeOK(data={'target': s1.pk})
+        response = self.executeOK({'target': s1.pk})
         result = response.data['schema']
         items = [item for item in result['items'] if item['id'] in response.data['cst_list']]
         self.assertEqual(len(items), 2)
@@ -441,7 +442,7 @@ class TestRSFormViewset(EndpointTester):
 
         # Testing complex structure
         s3.refresh_from_db()
-        response = self.executeOK(data={'target': s3.pk})
+        response = self.executeOK({'target': s3.pk})
         result = response.data['schema']
         items = [item for item in result['items'] if item['id'] in response.data['cst_list']]
         self.assertEqual(len(items), 8)
@@ -449,151 +450,15 @@ class TestRSFormViewset(EndpointTester):
 
         # Testing function
         f1.refresh_from_db()
-        response = self.executeOK(data={'target': f1.pk})
+        response = self.executeOK({'target': f1.pk})
         result = response.data['schema']
         items = [item for item in result['items'] if item['id'] in response.data['cst_list']]
         self.assertEqual(len(items), 2)
         self.assertEqual(items[0]['definition_formal'], '[α∈X1, β∈X1] Pr1(F10[α,β])')
 
 
-class TestConstituentaAPI(EndpointTester):
-    ''' Testing Constituenta view. '''
-
-    def setUp(self):
-        super().setUp()
-        self.owned = RSForm.create(title='Test', alias='T1', owner=self.user)
-        self.owned_id = self.owned.model.pk
-        self.unowned = RSForm.create(title='Test2', alias='T2')
-        self.unowned_id = self.unowned.model.pk
-        self.cst1 = Constituenta.objects.create(
-            alias='X1',
-            cst_type=CstType.BASE,
-            schema=self.owned.model,
-            order=0,
-            convention='Test',
-            term_raw='Test1',
-            term_resolved='Test1R',
-            term_forms=[{'text': 'form1', 'tags': 'sing,datv'}])
-        self.cst2 = Constituenta.objects.create(
-            alias='X2',
-            cst_type=CstType.BASE,
-            schema=self.unowned.model,
-            order=0,
-            convention='Test1',
-            term_raw='Test2',
-            term_resolved='Test2R'
-        )
-        self.cst3 = Constituenta.objects.create(
-            alias='X3',
-            schema=self.owned.model,
-            order=1,
-            term_raw='Test3',
-            term_resolved='Test3',
-            definition_raw='Test1',
-            definition_resolved='Test2'
-        )
-        self.invalid_cst = self.cst3.pk + 1337
-
-    @decl_endpoint('/api/rsforms/{schema}/update-cst', method='patch')
-    def test_partial_update(self):
-        data = {'target': self.cst1.pk, 'item_data': {'convention': 'tt'}}
-        self.executeForbidden(data=data, schema=self.unowned_id)
-
-        self.logout()
-        self.executeForbidden(data=data, schema=self.owned_id)
-
-        self.login()
-        self.executeOK(data=data, schema=self.owned_id)
-        self.cst1.refresh_from_db()
-        self.assertEqual(self.cst1.convention, 'tt')
-
-        self.executeOK(data=data, schema=self.owned_id)
-
-
-    @decl_endpoint('/api/rsforms/{schema}/update-cst', method='patch')
-    def test_partial_update_rename(self):
-        data = {'target': self.cst1.pk, 'item_data': {'alias': self.cst3.alias}}
-        self.executeBadData(data=data, schema=self.owned_id)
-
-        d1 = self.owned.insert_last(
-            alias='D1',
-            term_raw='@{X1|plur}',
-            definition_formal='X1'
-        )
-        self.assertEqual(self.cst1.order, 0)
-        self.assertEqual(self.cst1.alias, 'X1')
-        self.assertEqual(self.cst1.cst_type, CstType.BASE)
-
-        data = {'target': self.cst1.pk, 'item_data': {'alias': 'D2', 'cst_type': CstType.TERM}}
-        self.executeOK(data=data, schema=self.owned_id)
-        d1.refresh_from_db()
-        self.cst1.refresh_from_db()
-        self.assertEqual(d1.term_resolved, '')
-        self.assertEqual(d1.term_raw, '@{D2|plur}')
-        self.assertEqual(self.cst1.order, 0)
-        self.assertEqual(self.cst1.alias, 'D2')
-        self.assertEqual(self.cst1.cst_type, CstType.TERM)
-
-
-    @decl_endpoint('/api/rsforms/{schema}/update-cst', method='patch')
-    def test_update_resolved_no_refs(self):
-        data = {
-            'target': self.cst3.pk,
-            'item_data': {
-                'term_raw': 'New term',
-                'definition_raw': 'New def'
-            }
-        }
-        self.executeOK(data=data, schema=self.owned_id)
-        self.cst3.refresh_from_db()
-        self.assertEqual(self.cst3.term_resolved, 'New term')
-        self.assertEqual(self.cst3.definition_resolved, 'New def')
-
-
-    @decl_endpoint('/api/rsforms/{schema}/update-cst', method='patch')
-    def test_update_resolved_refs(self):
-        data = {
-            'target': self.cst3.pk,
-            'item_data': {
-                'term_raw': '@{X1|nomn,sing}',
-                'definition_raw': '@{X1|nomn,sing} @{X1|sing,datv}'
-            }
-        }
-        self.executeOK(data=data, schema=self.owned_id)
-        self.cst3.refresh_from_db()
-        self.assertEqual(self.cst3.term_resolved, self.cst1.term_resolved)
-        self.assertEqual(self.cst3.definition_resolved, f'{self.cst1.term_resolved} form1')
-
-    @decl_endpoint('/api/rsforms/{schema}/update-cst', method='patch')
-    def test_update_term_forms(self):
-        data = {
-            'target': self.cst3.pk,
-            'item_data': {
-                'definition_raw': '@{X3|sing,datv}',
-                'term_forms': [{'text': 'form1', 'tags': 'sing,datv'}]
-            }
-        }
-        self.executeOK(data=data, schema=self.owned_id)
-        self.cst3.refresh_from_db()
-        self.assertEqual(self.cst3.definition_resolved, 'form1')
-        self.assertEqual(self.cst3.term_forms, data['item_data']['term_forms'])
-
-    @decl_endpoint('/api/rsforms/{schema}/update-crucial', method='patch')
-    def test_update_crucial(self):
-        data = {'target': [self.cst1.pk], 'value': True}
-        self.executeForbidden(data=data, schema=self.unowned_id)
-
-        self.logout()
-        self.executeForbidden(data=data, schema=self.owned_id)
-
-        self.login()
-        self.executeOK(data=data, schema=self.owned_id)
-        self.cst1.refresh_from_db()
-        self.assertEqual(self.cst1.crucial, True)
-
-
 class TestInlineSynthesis(EndpointTester):
-    ''' Testing Operations endpoints. '''
+    ''' Testing Inline synthesis. '''
 
 
     @decl_endpoint('/api/rsforms/inline-synthesis', method='patch')
@@ -612,20 +477,20 @@ class TestInlineSynthesis(EndpointTester):
             'items': [],
             'substitutions': []
         }
-        self.executeForbidden(data=data)
+        self.executeForbidden(data)
 
         data['receiver'] = invalid_id
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data['receiver'] = self.schema1.model.pk
         data['source'] = invalid_id
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data['source'] = self.schema1.model.pk
-        self.executeOK(data=data)
+        self.executeOK(data)
 
         data['items'] = [invalid_id]
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
 
     def test_inline_synthesis(self):
@@ -654,7 +519,7 @@ class TestInlineSynthesis(EndpointTester):
                 }
             ]
         }
-        response = self.executeOK(data=data)
+        response = self.executeOK(data)
         result = {item['alias']: item for item in response.data['items']}
         self.assertEqual(len(result), 6)
         self.assertEqual(result['S1']['definition_formal'], 'X2')

rsconcept/backend/apps/rsform/tests/s_views/t_rslang.py

@@ -8,30 +8,30 @@ class TestRSLanguageViews(EndpointTester):
     @decl_endpoint('/api/rslang/to-ascii', method='post')
     def test_convert_to_ascii(self):
         data = {'data': '1=1'}
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data = {'expression': '1=1'}
-        response = self.executeOK(data=data)
+        response = self.executeOK(data)
         self.assertEqual(response.data['result'], r'1 \eq 1')
 
 
     @decl_endpoint('/api/rslang/to-math', method='post')
     def test_convert_to_math(self):
         data = {'data': r'1 \eq 1'}
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data = {'expression': r'1 \eq 1'}
-        response = self.executeOK(data=data)
+        response = self.executeOK(data)
         self.assertEqual(response.data['result'], r'1=1')
 
 
     @decl_endpoint('/api/rslang/parse-expression', method='post')
     def test_parse_expression(self):
         data = {'data': r'1=1'}
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data = {'expression': r'1=1'}
-        response = self.executeOK(data=data)
+        response = self.executeOK(data)
         self.assertEqual(response.data['parseResult'], True)
         self.assertEqual(response.data['syntax'], 'math')
         self.assertEqual(response.data['astText'], '[=[1][1]]')

rsconcept/backend/apps/rsform/views/rsforms.py

@@ -79,7 +79,7 @@ class RSFormViewSet(viewsets.GenericViewSet, generics.ListAPIView, generics.Retr
     def create_cst(self, request: Request, pk) -> HttpResponse:
         ''' Create Constituenta. '''
         item = self._get_item()
-        serializer = s.CstCreateSerializer(data=request.data)
+        serializer = s.CstCreateSerializer(data=request.data, context={'schema': item})
         serializer.is_valid(raise_exception=True)
         data = serializer.validated_data
         if 'insert_after' not in data:
@@ -232,10 +232,7 @@ class RSFormViewSet(viewsets.GenericViewSet, generics.ListAPIView, generics.Retr
     def substitute(self, request: Request, pk) -> HttpResponse:
         ''' Substitute occurrences of constituenta with another one. '''
         item = self._get_item()
-        serializer = s.CstSubstituteSerializer(
-            data=request.data,
-            context={'schema': item}
-        )
+        serializer = s.CstSubstituteSerializer(data=request.data, context={'schema': item})
         serializer.is_valid(raise_exception=True)
         substitutions: list[tuple[m.Constituenta, m.Constituenta]] = []
 
@@ -269,10 +266,7 @@ class RSFormViewSet(viewsets.GenericViewSet, generics.ListAPIView, generics.Retr
     def delete_multiple_cst(self, request: Request, pk) -> HttpResponse:
         ''' Endpoint: Delete multiple Constituents. '''
         item = self._get_item()
-        serializer = s.CstListSerializer(
-            data=request.data,
-            context={'schema': item}
-        )
+        serializer = s.CstListSerializer(data=request.data, context={'schema': item})
         serializer.is_valid(raise_exception=True)
         cst_list: list[m.Constituenta] = serializer.validated_data['items']
 
@@ -302,10 +296,7 @@ class RSFormViewSet(viewsets.GenericViewSet, generics.ListAPIView, generics.Retr
     def move_cst(self, request: Request, pk) -> HttpResponse:
         ''' Endpoint: Move multiple Constituents. '''
         item = self._get_item()
-        serializer = s.CstMoveSerializer(
-            data=request.data,
-            context={'schema': item}
-        )
+        serializer = s.CstMoveSerializer(data=request.data, context={'schema': item})
         serializer.is_valid(raise_exception=True)
 
         with transaction.atomic():
@@ -397,10 +388,7 @@ class RSFormViewSet(viewsets.GenericViewSet, generics.ListAPIView, generics.Retr
             )
         data['id'] = item.pk
 
-        serializer = s.RSFormTRSSerializer(
-            data=data,
-            context={'load_meta': load_metadata}
-        )
+        serializer = s.RSFormTRSSerializer(data=data, context={'load_meta': load_metadata})
         serializer.is_valid(raise_exception=True)
         result: m.RSForm = serializer.save()
         return Response(
@@ -558,10 +546,7 @@ class TrsImportView(views.APIView):
             )
         owner = cast(User, self.request.user)
         _prepare_rsform_data(data, request, owner)
-        serializer = s.RSFormTRSSerializer(
-            data=data,
-            context={'load_meta': True}
-        )
+        serializer = s.RSFormTRSSerializer(data=data, context={'load_meta': True})
         serializer.is_valid(raise_exception=True)
         schema: m.RSForm = serializer.save()
         return Response(
@@ -640,10 +625,7 @@ def _prepare_rsform_data(data: dict, request: Request, owner: Union[User, None])
 @api_view(['PATCH'])
 def inline_synthesis(request: Request) -> HttpResponse:
     ''' Endpoint: Inline synthesis. '''
-    serializer = s.InlineSynthesisSerializer(
-        data=request.data,
-        context={'user': request.user}
-    )
+    serializer = s.InlineSynthesisSerializer(data=request.data, context={'user': request.user})
     serializer.is_valid(raise_exception=True)
 
     receiver = m.RSFormCached(serializer.validated_data['receiver'])

rsconcept/backend/apps/users/tests/t_views.py

@@ -16,15 +16,15 @@ class TestUserAPIViews(EndpointTester):
     def test_login(self):
         self.logout()
         data = {'username': self.user.username, 'password': 'invalid'}
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data = {'username': self.user.username, 'password': 'password'}
-        self.executeAccepted(data=data)
-        self.executeAccepted(data=data)
+        self.executeAccepted(data)
+        self.executeAccepted(data)
 
         self.logout()
         data = {'username': self.user.email, 'password': 'password'}
-        self.executeAccepted(data=data)
+        self.executeAccepted(data)
 
 
     @decl_endpoint('/users/api/logout', method='post')
@@ -82,7 +82,7 @@ class TestUserUserProfileAPIView(EndpointTester):
             'first_name': 'firstName',
             'last_name': 'lastName',
         }
-        response = self.executeOK(data=data)
+        response = self.executeOK(data)
         self.user.refresh_from_db()
         self.assertEqual(response.data['email'], '123@mail.ru')
         self.assertEqual(self.user.email, '123@mail.ru')
@@ -96,13 +96,13 @@ class TestUserUserProfileAPIView(EndpointTester):
             'first_name': 'new',
             'last_name': 'new2',
         }
-        self.executeOK(data=data)
+        self.executeOK(data)
 
         data = {'email': self.user2.email}
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data = {'username': 'new_username'}
-        response = self.executeOK(data=data)
+        response = self.executeOK(data)
         self.assertNotEqual(response.data['username'], data['username'])
 
         self.logout()
@@ -115,14 +115,14 @@ class TestUserUserProfileAPIView(EndpointTester):
             'old_password': 'invalid',
             'new_password': 'password2'
         }
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data = {
             'old_password': 'password',
             'new_password': 'password2'
         }
         oldHash = self.user.password
-        response = self.executeNoContent(data=data)
+        response = self.executeNoContent(data)
         self.user.refresh_from_db()
         self.assertNotEqual(self.user.password, oldHash)
         self.assertTrue(self.client.login(username=self.user.username, password='password2'))
@@ -155,7 +155,7 @@ class TestSignupAPIView(EndpointTester):
             'first_name': 'firstName',
             'last_name': 'lastName'
         }
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data = {
             'username': 'NewUser',
@@ -165,7 +165,7 @@ class TestSignupAPIView(EndpointTester):
             'first_name': 'firstName',
             'last_name': 'lastName'
         }
-        response = self.executeCreated(data=data)
+        response = self.executeCreated(data)
         self.assertTrue('id' in response.data)
         self.assertEqual(response.data['username'], data['username'])
         self.assertEqual(response.data['email'], data['email'])
@@ -180,7 +180,7 @@ class TestSignupAPIView(EndpointTester):
             'first_name': 'firstName',
             'last_name': 'lastName'
         }
-        self.executeBadData(data=data)
+        self.executeBadData(data)
 
         data = {
             'username': 'NewUser2',
@@ -190,4 +190,4 @@ class TestSignupAPIView(EndpointTester):
             'first_name': 'firstName',
             'last_name': 'lastName'
         }
-        self.executeBadData(data=data)
+        self.executeBadData(data)

rsconcept/backend/shared/utility.py

@@ -21,5 +21,5 @@ def write_zipped_json(json_data: dict, json_filename: str) -> bytes:
     content = BytesIO()
     data = json.dumps(json_data, indent=4, ensure_ascii=False)
     with ZipFile(content, 'w') as archive:
-        archive.writestr(json_filename, data=data)
+        archive.writestr(json_filename, data)
     return content.getvalue()