Refactoring: update test formatting and improve readability

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

@@ -11,6 +11,7 @@ class TestNaturalLanguageViews(EndpointTester):
     def _assert_tags(self, actual: str, expected: str):
         self.assertEqual(set(split_grams(actual)), set(split_grams(expected)))
 
+
     @decl_endpoint(endpoint='/api/cctext/parse', method='post')
     def test_parse_text(self):
         data = {'text': 'синим слонам'}
@@ -18,6 +19,7 @@ class TestNaturalLanguageViews(EndpointTester):
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         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'}
@@ -25,6 +27,7 @@ class TestNaturalLanguageViews(EndpointTester):
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertEqual(response.data['result'], 'синим слонам')
 
+
     @decl_endpoint(endpoint='/api/cctext/generate-lexeme', method='post')
     def test_generate_lexeme(self):
         data = {'text': 'синий слон'}

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

@@ -41,6 +41,7 @@ class TestConstituentaAPI(EndpointTester):
         )
         self.invalid_cst = self.cst3.pk + 1337
 
+
     @decl_endpoint('/api/constituents/{item}', method='get')
     def test_retrieve(self):
         self.assertNotFound(item=self.invalid_cst)
@@ -49,6 +50,7 @@ class TestConstituentaAPI(EndpointTester):
         self.assertEqual(response.data['alias'], self.cst1.alias)
         self.assertEqual(response.data['convention'], self.cst1.convention)
 
+
     @decl_endpoint('/api/constituents/{item}', method='patch')
     def test_partial_update(self):
         data = {'convention': 'tt'}
@@ -66,6 +68,7 @@ class TestConstituentaAPI(EndpointTester):
 
         self.assertOK(data, item=self.cst1.id)
 
+
     @decl_endpoint('/api/constituents/{item}', method='patch')
     def test_update_resolved_no_refs(self):
         data = {
@@ -80,6 +83,7 @@ class TestConstituentaAPI(EndpointTester):
         self.assertEqual(response.data['definition_resolved'], 'New def')
         self.assertEqual(self.cst3.definition_resolved, 'New def')
 
+
     @decl_endpoint('/api/constituents/{item}', method='patch')
     def test_update_resolved_refs(self):
         data = {
@@ -94,6 +98,7 @@ class TestConstituentaAPI(EndpointTester):
         self.assertEqual(self.cst3.definition_resolved, f'{self.cst1.term_resolved} form1')
         self.assertEqual(response.data['definition_resolved'], f'{self.cst1.term_resolved} form1')
 
+
     @decl_endpoint('/api/constituents/{item}', method='patch')
     def test_readonly_cst_fields(self):
         data = {'alias': 'X33', 'order': 10}

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

@@ -32,6 +32,7 @@ class TestLibraryViewset(EndpointTester):
             is_common=True
         )
 
+
     @decl_endpoint('/api/library', method='post')
     def test_create(self):
         data = {'title': 'Title'}
@@ -44,6 +45,7 @@ class TestLibraryViewset(EndpointTester):
         data = {'title': 'Title2'}
         self.assertForbidden(data)
 
+
     @decl_endpoint('/api/library/{item}', method='patch')
     def test_update(self):
         data = {'id': self.unowned.id, 'title': 'New title'}
@@ -55,6 +57,7 @@ class TestLibraryViewset(EndpointTester):
         self.assertEqual(response.data['title'], 'New title')
         self.assertEqual(response.data['alias'], self.owned.alias)
 
+
     @decl_endpoint('/api/library/{item}', method='delete')
     def test_destroy(self):
         response = self.execute(item=self.owned.id)
@@ -65,6 +68,7 @@ class TestLibraryViewset(EndpointTester):
         response = self.execute(item=self.unowned.id)
         self.assertTrue(response.status_code in [status.HTTP_202_ACCEPTED, status.HTTP_204_NO_CONTENT])
 
+
     @decl_endpoint('/api/library/{item}/claim', method='post')
     def test_claim(self):
         self.assertForbidden(item=self.owned.id)
@@ -87,6 +91,7 @@ class TestLibraryViewset(EndpointTester):
         self.logout()
         self.assertForbidden(item=self.owned.id)
 
+
     @decl_endpoint('/api/library/active', method='get')
     def test_retrieve_common(self):
         response = self.execute()
@@ -102,6 +107,7 @@ class TestLibraryViewset(EndpointTester):
         self.assertFalse(response_contains(response, self.unowned))
         self.assertFalse(response_contains(response, self.owned))
 
+
     @decl_endpoint('/api/library/active', method='get')
     def test_retrieve_subscribed(self):
         response = self.execute()
@@ -118,6 +124,7 @@ class TestLibraryViewset(EndpointTester):
         self.assertTrue(response_contains(response, self.unowned))
         self.assertEqual(len(response.data), 3)
 
+
     @decl_endpoint('/api/library/{item}/subscribe', method='post')
     def test_subscriptions(self):
         response = self.client.delete(f'/api/library/{self.unowned.id}/unsubscribe')
@@ -136,6 +143,7 @@ class TestLibraryViewset(EndpointTester):
         self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
         self.assertFalse(self.user in self.unowned.subscribers())
 
+
     @decl_endpoint('/api/library/templates', method='get')
     def test_retrieve_templates(self):
         response = self.execute()
@@ -151,6 +159,7 @@ class TestLibraryViewset(EndpointTester):
         self.assertTrue(response_contains(response, self.unowned))
         self.assertFalse(response_contains(response, self.owned))
 
+
     @decl_endpoint('/api/library/{item}/clone', method='post')
     def test_clone_rsform(self):
         x12 = self.schema.insert_new(

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

@@ -12,6 +12,7 @@ from apps.rsform.models import (
 class TestInlineSynthesis(EndpointTester):
     ''' Testing Operations endpoints. '''
 
+
     @decl_endpoint('/api/operations/inline-synthesis', method='patch')
     def setUp(self):
         super().setUp()
@@ -19,6 +20,7 @@ class TestInlineSynthesis(EndpointTester):
         self.schema2 = RSForm.create(title='Test2', alias='T2', owner=self.user)
         self.unowned = RSForm.create(title='Test3', alias='T3')
 
+
     def test_inline_synthesis_inputs(self):
         invalid_id = 1338
         data = {
@@ -42,6 +44,7 @@ class TestInlineSynthesis(EndpointTester):
         data['items'] = [invalid_id]
         self.assertBadData(data)
 
+
     def test_inline_synthesis(self):
         ks1_x1 = self.schema1.insert_new('X1', term_raw='KS1X1') # -> delete
         ks1_x2 = self.schema1.insert_new('X2', term_raw='KS1X2') # -> X2

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

@@ -27,6 +27,7 @@ class TestRSFormViewset(EndpointTester):
         self.unowned = RSForm.create(title='Test2', alias='T2')
         self.unowned_id = self.unowned.item.id
 
+
     @decl_endpoint('/api/rsforms/create-detailed', method='post')
     def test_create_rsform_file(self):
         work_dir = os.path.dirname(os.path.abspath(__file__))
@@ -39,6 +40,7 @@ class TestRSFormViewset(EndpointTester):
         self.assertEqual(response.data['alias'], 'ks1')
         self.assertEqual(response.data['comment'], '123')
 
+
     @decl_endpoint('/api/rsforms/create-detailed', method='post')
     def test_create_rsform_json(self):
         data = {'title': 'Test123', 'comment': '123', 'alias': 'ks1'}
@@ -49,6 +51,7 @@ class TestRSFormViewset(EndpointTester):
         self.assertEqual(response.data['alias'], 'ks1')
         self.assertEqual(response.data['comment'], '123')
 
+
     @decl_endpoint('/api/rsforms', method='get')
     def test_list(self):
         non_schema = LibraryItem.objects.create(
@@ -67,23 +70,27 @@ class TestRSFormViewset(EndpointTester):
         self.assertTrue(response_contains(response, self.unowned.item))
         self.assertTrue(response_contains(response, self.schema.item))
 
+
     @decl_endpoint('/api/rsforms/{item}/contents', method='get')
     def test_contents(self):
         schema = RSForm.create(title='Title1')
         schema.insert_new('X1')
         self.assertOK(item=schema.item.id)
 
+
     @decl_endpoint('/api/rsforms/{item}/details', method='get')
     def test_details(self):
         schema = RSForm.create(title='Test', owner=self.user)
-        x1 = schema.insert_new('X1')
+        x1 = schema.insert_new(
-        x2 = schema.insert_new('X2')
+            alias='X1',
-        x1.term_raw = 'человек'
+            term_raw='человек',
-        x1.term_resolved = 'человек'
+            term_resolved = 'человек'
-        x2.term_raw = '@{X1|plur}'
+        )
-        x2.term_resolved = 'люди'
+        x2 = schema.insert_new(
-        x1.save()
+            alias='X2',
-        x2.save()
+            term_raw='@{X1|plur}',
+            term_resolved = 'люди'
+        )
 
         response = self.execute(item=schema.item.id)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -98,6 +105,7 @@ class TestRSFormViewset(EndpointTester):
         self.assertEqual(response.data['items'][1]['term_resolved'], x2.term_resolved)
         self.assertEqual(response.data['subscribers'], [self.user.pk])
 
+
     @decl_endpoint('/api/rsforms/{item}/check', method='post')
     def test_check(self):
         schema = RSForm.create(title='Test')
@@ -113,12 +121,14 @@ class TestRSFormViewset(EndpointTester):
 
         self.assertOK(data, item=self.unowned_id)
 
+
     @decl_endpoint('/api/rsforms/{item}/resolve', method='post')
     def test_resolve(self):
         schema = RSForm.create(title='Test')
-        x1 = schema.insert_new('X1')
+        x1 = schema.insert_new(
-        x1.term_resolved = 'синий слон'
+            alias='X1',
-        x1.save()
+            term_resolved='синий слон'
+        )
 
         data = {'text': '@{1|редкий} @{X1|plur,datv}'}
         response = self.execute(data, item=schema.item.id)
@@ -143,6 +153,7 @@ class TestRSFormViewset(EndpointTester):
         self.assertEqual(response.data['refs'][1]['pos_output']['start'], 7)
         self.assertEqual(response.data['refs'][1]['pos_output']['finish'], 19)
 
+
     @decl_endpoint('/api/rsforms/import-trs', method='post')
     def test_import_trs(self):
         work_dir = os.path.dirname(os.path.abspath(__file__))
@@ -153,6 +164,7 @@ class TestRSFormViewset(EndpointTester):
         self.assertEqual(response.data['owner'], self.user.pk)
         self.assertTrue(response.data['title'] != '')
 
+
     @decl_endpoint('/api/rsforms/{item}/export-trs', method='get')
     def test_export_trs(self):
         schema = RSForm.create(title='Test')
@@ -165,6 +177,7 @@ class TestRSFormViewset(EndpointTester):
                 self.assertIsNone(zipped_file.testzip())
                 self.assertIn('document.json', zipped_file.namelist())
 
+
     @decl_endpoint('/api/rsforms/{item}/cst-create', method='post')
     def test_create_constituenta(self):
         data = {'alias': 'X3', 'cst_type':  CstType.BASE}
@@ -194,6 +207,7 @@ class TestRSFormViewset(EndpointTester):
         self.assertEqual(x4.term_raw, data['term_raw'])
         self.assertEqual(x4.term_forms, data['term_forms'])
 
+
     @decl_endpoint('/api/rsforms/{item}/cst-rename', method='patch')
     def test_rename_constituenta(self):
         x1 = self.schema.insert_new(
@@ -244,6 +258,7 @@ class TestRSFormViewset(EndpointTester):
         self.assertEqual(x1.alias, 'D2')
         self.assertEqual(x1.cst_type, CstType.TERM)
 
+
     @decl_endpoint('/api/rsforms/{item}/cst-substitute', method='patch')
     def test_substitute_constituenta(self):
         x1 = self.schema.insert_new(
@@ -283,6 +298,7 @@ class TestRSFormViewset(EndpointTester):
         self.assertEqual(d1.term_resolved, 'form1')
         self.assertEqual(d1.definition_formal, 'X2')
 
+
     @decl_endpoint('/api/rsforms/{item}/cst-create', method='post')
     def test_create_constituenta_data(self):
         data = {
@@ -304,6 +320,7 @@ class TestRSFormViewset(EndpointTester):
         self.assertEqual(response.data['new_cst']['definition_raw'], '4')
         self.assertEqual(response.data['new_cst']['definition_resolved'], '4')
 
+
     @decl_endpoint('/api/rsforms/{item}/cst-delete-multiple', method='patch')
     def test_delete_constituenta(self):
         self.set_params(item=self.schema_id)
@@ -328,6 +345,7 @@ class TestRSFormViewset(EndpointTester):
         data = {'items': [x3.id]}
         self.assertBadData(data, item=self.schema_id)
 
+
     @decl_endpoint('/api/rsforms/{item}/cst-moveto', method='patch')
     def test_move_constituenta(self):
         self.set_params(item=self.schema_id)
@@ -351,6 +369,7 @@ class TestRSFormViewset(EndpointTester):
         data = {'items': [x3.id], 'move_to': 1}
         self.assertBadData(data)
 
+
     @decl_endpoint('/api/rsforms/{item}/reset-aliases', method='patch')
     def test_reset_aliases(self):
         self.set_params(item=self.schema_id)
@@ -377,6 +396,7 @@ class TestRSFormViewset(EndpointTester):
 
         self.assertOK()
 
+
     @decl_endpoint('/api/rsforms/{item}/load-trs', method='patch')
     def test_load_trs(self):
         self.set_params(item=self.schema_id)
@@ -394,6 +414,7 @@ class TestRSFormViewset(EndpointTester):
         self.assertEqual(self.schema.constituents().count(), 25)
         self.assertFalse(Constituenta.objects.filter(pk=x1.id).exists())
 
+
     @decl_endpoint('/api/rsforms/{item}/cst-produce-structure', method='patch')
     def test_produce_structure(self):
         self.set_params(item=self.schema_id)

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

@@ -7,6 +7,8 @@ from .EndpointTester import decl_endpoint, EndpointTester
 
 class TestRSLanguageViews(EndpointTester):
     ''' Test RS language endpoints. '''
+
+
     @decl_endpoint('/api/rslang/to-ascii', method='post')
     def test_convert_to_ascii(self):
         data = {'data': '1=1'}
@@ -17,6 +19,7 @@ class TestRSLanguageViews(EndpointTester):
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         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'}
@@ -27,6 +30,7 @@ class TestRSLanguageViews(EndpointTester):
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         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'}

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

@@ -24,6 +24,7 @@ class TestVersionViews(EndpointTester):
             order=1
         )
 
+
     @decl_endpoint('/api/rsforms/{schema}/versions/create', method='post')
     def test_create_version(self):
         invalid_data = {'description': 'test'}
@@ -40,6 +41,7 @@ class TestVersionViews(EndpointTester):
         self.assertTrue('schema' in response.data)
         self.assertTrue(response.data['version'] in [v['id'] for v in response.data['schema']['versions']])
 
+
     @decl_endpoint('/api/rsforms/{schema}/versions/{version}', method='get')
     def test_retrieve_version(self):
         version_id = self._create_version({'version': '1.0.0', 'description': 'test'})
@@ -61,6 +63,7 @@ class TestVersionViews(EndpointTester):
         self.assertNotEqual(response.data['items'][0]['alias'], self.x1.alias)
         self.assertEqual(response.data['version'], version_id)
 
+
     @decl_endpoint('/api/versions/{version}', method='get')
     def test_access_version(self):
         data = {'version': '1.0.0', 'description': 'test'}
@@ -96,6 +99,7 @@ class TestVersionViews(EndpointTester):
         response = self.get()
         self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
 
+
     @decl_endpoint('/api/rsforms/{schema}/versions/{version}', method='get')
     def test_retrieve_version_details(self):
         a1 = Constituenta.objects.create(
@@ -115,6 +119,7 @@ class TestVersionViews(EndpointTester):
         self.assertEqual(loaded_a1['definition_formal'], 'X1=X1')
         self.assertEqual(loaded_a1['parse']['status'], 'verified')
 
+
     @decl_endpoint('/api/versions/{version}/export-file', method='get')
     def test_export_version(self):
         invalid_id = 1338
@@ -132,6 +137,7 @@ class TestVersionViews(EndpointTester):
                 self.assertIsNone(zipped_file.testzip())
                 self.assertIn('document.json', zipped_file.namelist())
 
+
     def _create_version(self, data) -> int:
         response = self.client.post(
             f'/api/rsforms/{self.owned.id}/versions/create',

rsconcept/backend/apps/rsform/tests/t_graph.py

@@ -26,6 +26,7 @@ class TestGraph(unittest.TestCase):
         self.assertTrue(graph.has_edge('X1', 'X3'))
         self.assertTrue(graph.has_edge('X2', 'X1'))
 
+
     def test_expand_outputs(self):
         graph = Graph({
             'X1': ['X2'],
@@ -40,6 +41,7 @@ class TestGraph(unittest.TestCase):
         self.assertEqual(graph.expand_outputs(['X7']), [])
         self.assertEqual(graph.expand_outputs(['X2', 'X5']), ['X3', 'X6', 'X1'])
 
+
     def test_topological_order(self):
         self.assertEqual(Graph().topological_order(), [])
         graph = Graph({

rsconcept/backend/apps/rsform/tests/t_imports.py

@@ -6,30 +6,37 @@ import json
 
 
 class TestIntegrations(TestCase):
+
+
     def test_convert_to_ascii(self):
         ''' Test converting to ASCII syntax '''
         self.assertEqual(pc.convert_to_ascii(''), '')
         self.assertEqual(pc.convert_to_ascii('\u212c(X1)'), r'B(X1)')
 
+
     def test_convert_to_math(self):
         ''' Test converting to MATH syntax '''
         self.assertEqual(pc.convert_to_math(''), '')
         self.assertEqual(pc.convert_to_math(r'B(X1)'), '\u212c(X1)')
 
+
     def test_parse_expression(self):
         ''' Test parsing expression '''
         out = json.loads(pc.parse_expression('X1=X2'))
         self.assertEqual(out['parseResult'], True)
         self.assertEqual(out['syntax'], 'math')
 
+
     def test_empty_schema(self):
         with self.assertRaises(RuntimeError):
             pc.check_schema('')
 
+
     def test_check_schema(self):
         schema = self._default_schema()
         self.assertTrue(pc.check_schema(schema) != '')
 
+
     def test_check_expression(self):
         schema = self._default_schema()
         out1 = json.loads(pc.check_expression(schema, 'X1=X1'))
@@ -39,6 +46,7 @@ class TestIntegrations(TestCase):
         out2 = json.loads(pc.check_expression(schema, 'X1=X2'))
         self.assertFalse(out2['parseResult'])
 
+
     def test_reset_aliases(self):
         ''' Test reset aliases in schema '''
         schema = self._default_schema()
@@ -46,6 +54,7 @@ class TestIntegrations(TestCase):
         self.assertTrue(len(fixedSchema['items']) > 2)
         self.assertEqual(fixedSchema['items'][2]['alias'], 'S1')
 
+
     def _default_schema(self):
         return '''{
     "type": "rsform",

rsconcept/backend/apps/rsform/tests/t_models.py

@@ -22,28 +22,34 @@ class TestConstituenta(TestCase):
         cst = Constituenta.objects.create(alias=testStr, schema=self.schema1, order=1, convention='Test')
         self.assertEqual(str(cst), testStr)
 
+
     def test_url(self):
         testStr = 'X1'
         cst = Constituenta.objects.create(alias=testStr, schema=self.schema1, order=1, convention='Test')
         self.assertEqual(cst.get_absolute_url(), f'/api/constituents/{cst.id}')
 
+
     def test_order_not_null(self):
         with self.assertRaises(IntegrityError):
             Constituenta.objects.create(alias='X1', schema=self.schema1)
 
+
     def test_order_positive_integer(self):
         with self.assertRaises(IntegrityError):
             Constituenta.objects.create(alias='X1', schema=self.schema1, order=-1)
 
+
     def test_order_min_value(self):
         with self.assertRaises(ValidationError):
             cst = Constituenta.objects.create(alias='X1', schema=self.schema1, order=0)
             cst.full_clean()
 
+
     def test_schema_not_null(self):
         with self.assertRaises(IntegrityError):
             Constituenta.objects.create(alias='X1', order=1)
 
+
     def test_create_default(self):
         cst = Constituenta.objects.create(
             alias='X1',
@@ -70,18 +76,29 @@ class TestLibraryItem(TestCase):
         self.user2 = User.objects.create(username='User2')
         self.assertNotEqual(self.user1, self.user2)
 
+
     def test_str(self):
         testStr = 'Test123'
-        item = LibraryItem.objects.create(item_type=LibraryItemType.RSFORM,
+        item = LibraryItem.objects.create(
-                                    title=testStr, owner=self.user1, alias='КС1')
+            item_type=LibraryItemType.RSFORM,
+            title=testStr,
+            owner=self.user1,
+            alias='КС1'
+        )
         self.assertEqual(str(item), testStr)
 
+
     def test_url(self):
         testStr = 'Test123'
-        item = LibraryItem.objects.create(item_type=LibraryItemType.RSFORM,
+        item = LibraryItem.objects.create(
-                                  title=testStr, owner=self.user1, alias='КС1')
+            item_type=LibraryItemType.RSFORM,
+            title=testStr,
+            owner=self.user1,
+            alias='КС1'
+        )
         self.assertEqual(item.get_absolute_url(), f'/api/library/{item.id}')
 
+
     def test_create_default(self):
         item = LibraryItem.objects.create(item_type=LibraryItemType.RSFORM, title='Test')
         self.assertIsNone(item.owner)
@@ -91,6 +108,7 @@ class TestLibraryItem(TestCase):
         self.assertEqual(item.is_common, False)
         self.assertEqual(item.is_canonical, False)
 
+
     def test_create(self):
         item = LibraryItem.objects.create(
             item_type=LibraryItemType.RSFORM,
@@ -109,6 +127,7 @@ class TestLibraryItem(TestCase):
         self.assertEqual(item.is_canonical, True)
         self.assertTrue(Subscription.objects.filter(user=item.owner, item=item).exists())
 
+
     def test_subscribe(self):
         item = LibraryItem.objects.create(item_type=LibraryItemType.RSFORM, title='Test')
         self.assertEqual(len(item.subscribers()), 0)
@@ -128,6 +147,7 @@ class TestLibraryItem(TestCase):
         self.user1.delete()
         self.assertEqual(len(item.subscribers()), 1)
 
+
     def test_unsubscribe(self):
         item = LibraryItem.objects.create(item_type=LibraryItemType.RSFORM, title='Test')
         self.assertFalse(Subscription.unsubscribe(self.user1, item))
@@ -141,6 +161,7 @@ class TestLibraryItem(TestCase):
 
         self.assertFalse(Subscription.unsubscribe(self.user1, item))
 
+
 class TestRSForm(TestCase):
     ''' Testing RSForm wrapper. '''
     def setUp(self):
@@ -148,6 +169,7 @@ class TestRSForm(TestCase):
         self.user2 = User.objects.create(username='User2')
         self.assertNotEqual(self.user1, self.user2)
 
+
     def test_constituents(self):
         schema1 = RSForm.create(title='Test1')
         schema2 = RSForm.create(title='Test2')
@@ -160,6 +182,7 @@ class TestRSForm(TestCase):
         self.assertFalse(schema2.constituents().exists())
         self.assertEqual(schema1.constituents().count(), 2)
 
+
     def test_get_max_index(self):
         schema1 = RSForm.create(title='Test1')
         Constituenta.objects.create(alias='X1', schema=schema1.item, order=1)
@@ -168,97 +191,107 @@ class TestRSForm(TestCase):
         self.assertEqual(schema1.get_max_index(CstType.TERM), 2)
         self.assertEqual(schema1.get_max_index(CstType.AXIOM), 0)
 
+
     def test_insert_at(self):
         schema = RSForm.create(title='Test')
-        cst1 = schema.insert_new('X1', CstType.BASE, 1)
+        x1 = schema.insert_new('X1')
-        self.assertEqual(cst1.order, 1)
+        self.assertEqual(x1.order, 1)
-        self.assertEqual(cst1.schema, schema.item)
+        self.assertEqual(x1.schema, schema.item)
 
-        cst2 = schema.insert_new('X2', CstType.BASE, 1)
+        x2 = schema.insert_new('X2', position=1)
-        cst1.refresh_from_db()
+        x1.refresh_from_db()
-        self.assertEqual(cst2.order, 1)
+        self.assertEqual(x2.order, 1)
-        self.assertEqual(cst2.schema, schema.item)
+        self.assertEqual(x2.schema, schema.item)
-        self.assertEqual(cst1.order, 2)
+        self.assertEqual(x1.order, 2)
 
-        cst3 = schema.insert_new('X3', CstType.BASE, 4)
+        x3 = schema.insert_new('X3', position=4)
-        cst2.refresh_from_db()
+        x2.refresh_from_db()
-        cst1.refresh_from_db()
+        x1.refresh_from_db()
-        self.assertEqual(cst3.order, 3)
+        self.assertEqual(x3.order, 3)
-        self.assertEqual(cst3.schema, schema.item)
+        self.assertEqual(x3.schema, schema.item)
-        self.assertEqual(cst2.order, 1)
+        self.assertEqual(x2.order, 1)
-        self.assertEqual(cst1.order, 2)
+        self.assertEqual(x1.order, 2)
+
+        x4 = schema.insert_new('X4', position=3)
+        x3.refresh_from_db()
+        x2.refresh_from_db()
+        x1.refresh_from_db()
+        self.assertEqual(x4.order, 3)
+        self.assertEqual(x4.schema, schema.item)
+        self.assertEqual(x3.order, 4)
+        self.assertEqual(x2.order, 1)
+        self.assertEqual(x1.order, 2)
 
-        cst4 = schema.insert_new('X4', CstType.BASE, 3)
-        cst3.refresh_from_db()
-        cst2.refresh_from_db()
-        cst1.refresh_from_db()
-        self.assertEqual(cst4.order, 3)
-        self.assertEqual(cst4.schema, schema.item)
-        self.assertEqual(cst3.order, 4)
-        self.assertEqual(cst2.order, 1)
-        self.assertEqual(cst1.order, 2)
 
     def test_insert_at_invalid_position(self):
         schema = RSForm.create(title='Test')
         with self.assertRaises(ValidationError):
-            schema.insert_new('X5', CstType.BASE, 0)
+            schema.insert_new('X5', position=0)
+
 
     def test_insert_at_invalid_alias(self):
         schema = RSForm.create(title='Test')
-        schema.insert_new('X1', CstType.BASE, 1)
+        schema.insert_new('X1')
         with self.assertRaises(ValidationError):
-            schema.insert_new('X1', CstType.BASE, 2)
+            schema.insert_new('X1')
+
 
     def test_insert_at_reorder(self):
         schema = RSForm.create(title='Test')
-        schema.insert_new('X1', CstType.BASE, 1)
+        schema.insert_new('X1')
-        d1 = schema.insert_new('D1', CstType.TERM, 2)
+        d1 = schema.insert_new('D1')
-        d2 = schema.insert_new('D2', CstType.TERM, 1)
+        d2 = schema.insert_new('D2',position=1)
         d1.refresh_from_db()
         self.assertEqual(d1.order, 3)
         self.assertEqual(d2.order, 1)
 
-        x2 = schema.insert_new('X2', CstType.BASE, 4)
+        x2 = schema.insert_new('X2', position=4)
         self.assertEqual(x2.order, 4)
 
+
     def test_insert_last(self):
         schema = RSForm.create(title='Test')
-        cst1 = schema.insert_new('X1', CstType.BASE)
+        x1 = schema.insert_new('X1')
-        self.assertEqual(cst1.order, 1)
+        self.assertEqual(x1.order, 1)
-        self.assertEqual(cst1.schema, schema.item)
+        self.assertEqual(x1.schema, schema.item)
+
+        x2 = schema.insert_new('X2')
+        self.assertEqual(x2.order, 2)
+        self.assertEqual(x2.schema, schema.item)
+        self.assertEqual(x1.order, 1)
 
-        cst2 = schema.insert_new('X2', CstType.BASE)
-        self.assertEqual(cst2.order, 2)
-        self.assertEqual(cst2.schema, schema.item)
-        self.assertEqual(cst1.order, 1)
 
     def test_create_cst_resolve(self):
         schema = RSForm.create(title='Test')
-        cst1 = schema.insert_new('X1', CstType.BASE)
+        x1 = schema.insert_new(
-        cst1.term_raw = '@{X2|datv}'
+            alias='X1',
-        cst1.definition_raw = '@{X1|datv} @{X2|datv}'
+            term_raw='@{X2|datv}',
-        cst1.save()
+            definition_raw='@{X1|datv} @{X2|datv}'
-        cst2 = schema.create_cst({
+        )
+        x2 = schema.create_cst({
             'alias': 'X2', 
             'cst_type': CstType.BASE,
             'term_raw': 'слон',
             'definition_raw': '@{X1|plur} @{X2|plur}'
         })
-        cst1.refresh_from_db()
+        x1.refresh_from_db()
-        self.assertEqual(cst1.term_resolved, 'слону')
+        self.assertEqual(x1.term_resolved, 'слону')
-        self.assertEqual(cst1.definition_resolved, 'слону слону')
+        self.assertEqual(x1.definition_resolved, 'слону слону')
-        self.assertEqual(cst2.term_resolved, 'слон')
+        self.assertEqual(x2.term_resolved, 'слон')
-        self.assertEqual(cst2.definition_resolved, 'слонам слоны')
+        self.assertEqual(x2.definition_resolved, 'слонам слоны')
+
 
     def test_insert_copy(self):
         schema = RSForm.create(title='Test')
-        x1 = schema.insert_new('X10', CstType.BASE)
+        x1 = schema.insert_new(
-        s1 = schema.insert_new('S11', CstType.STRUCTURED)
+            alias='X10',
-        x1.convention = 'Test'
+            convention='Test'
-        s1.definition_formal = x1.alias
+        )
-        s1.definition_raw = '@{X10|plur}'
+        s1 = schema.insert_new(
-        x1.save()
+            alias='S11',
-        s1.save()
+            definition_formal=x1.alias,
+            definition_raw='@{X10|plur}'
+        )
 
         result = schema.insert_copy([s1, x1], 2)
         self.assertEqual(len(result), 2)
@@ -279,16 +312,18 @@ class TestRSForm(TestCase):
         self.assertEqual(s2.definition_formal, x2.alias)
         self.assertEqual(s2.definition_raw, '@{X11|plur}')
 
+
     def test_apply_mapping(self):
         schema = RSForm.create(title='Test')
-        x1 = schema.insert_new('X1', CstType.BASE)
+        x1 = schema.insert_new('X1')
-        x2 = schema.insert_new('X11', CstType.BASE)
+        x2 = schema.insert_new('X11')
-        d1 = schema.insert_new('D1', CstType.TERM)
+        d1 = schema.insert_new(
-        d1.definition_formal = 'X1 = X11 = X2'
+            alias='D1',
-        d1.definition_raw = '@{X11|sing}'
+            definition_formal='X1 = X11 = X2',
-        d1.convention = 'X1'
+            definition_raw='@{X11|sing}',
-        d1.term_raw = '@{X1|plur}'
+            convention='X1',
-        d1.save()
+            term_raw='@{X1|plur}'
+        )
     
         schema.apply_mapping({x1.alias: 'X3', x2.alias: 'X4'})
         d1.refresh_from_db()
@@ -299,17 +334,21 @@ class TestRSForm(TestCase):
         self.assertEqual(d1.term_resolved, '', msg='Do not run resolve on mapping')
         self.assertEqual(d1.definition_resolved, '', msg='Do not run resolve on mapping')
 
+
     def test_substitute(self):
         schema = RSForm.create(title='Test')
-        x1 = schema.insert_new('X1', CstType.BASE)
+        x1 = schema.insert_new(
-        x2 = schema.insert_new('X2', CstType.BASE)
+            alias='X1',
-        d1 = schema.insert_new('D1', CstType.TERM)
+            term_raw='Test'
-        d1.definition_formal = x1.alias
+        )
-        d1.save()
+        x2 = schema.insert_new(
-        x1.term_raw = 'Test'
+            alias='X2',
-        x1.save()
+            term_raw='Test2'
-        x2.term_raw = 'Test2'
+        )
-        x2.save()
+        d1 = schema.insert_new(
+            alias='D1',
+            definition_formal=x1.alias
+        )
 
         schema.substitute(x1, x2, True)
         x2.refresh_from_db()
@@ -318,12 +357,13 @@ class TestRSForm(TestCase):
         self.assertEqual(x2.term_raw, 'Test')
         self.assertEqual(d1.definition_formal, x2.alias)
 
+
     def test_move_cst(self):
         schema = RSForm.create(title='Test')
-        x1 = schema.insert_new('X1', CstType.BASE)
+        x1 = schema.insert_new('X1')
-        x2 = schema.insert_new('X2', CstType.BASE)
+        x2 = schema.insert_new('X2')
-        d1 = schema.insert_new('D1', CstType.TERM)
+        d1 = schema.insert_new('D1')
-        d2 = schema.insert_new('D2', CstType.TERM)
+        d2 = schema.insert_new('D2')
         schema.move_cst([x2, d2], 1)
         x1.refresh_from_db()
         x2.refresh_from_db()
@@ -334,30 +374,34 @@ class TestRSForm(TestCase):
         self.assertEqual(d1.order, 4)
         self.assertEqual(d2.order, 2)
 
+
     def test_move_cst_down(self):
         schema = RSForm.create(title='Test')
-        x1 = schema.insert_new('X1', CstType.BASE)
+        x1 = schema.insert_new('X1')
-        x2 = schema.insert_new('X2', CstType.BASE)
+        x2 = schema.insert_new('X2')
         schema.move_cst([x1], 2)
         x1.refresh_from_db()
         x2.refresh_from_db()
         self.assertEqual(x1.order, 2)
         self.assertEqual(x2.order, 1)
 
+
     def test_reset_aliases(self):
         schema = RSForm.create(title='Test')
-        x1 = schema.insert_new('X11', CstType.BASE)
+        x1 = schema.insert_new(
-        x2 = schema.insert_new('X21', CstType.BASE)
+            alias='X11',
-        d1 = schema.insert_new('D11', CstType.TERM)
+            term_raw='человек',
-        x1.term_raw = 'человек'
+            term_resolved='человек'
-        x1.term_resolved = 'человек'
+        )
-        d1.convention = 'D11 - cool'
+        x2 = schema.insert_new('X21')
-        d1.definition_formal = 'X21=X21'
+        d1 = schema.insert_new(
-        d1.term_raw = '@{X21|sing}'
+            alias='D11',
-        d1.definition_raw = '@{X11|datv}'
+            convention='D11 - cool',
-        d1.definition_resolved = 'test'
+            definition_formal='X21=X21',
-        d1.save()
+            term_raw='@{X21|sing}',
-        x1.save()
+            definition_raw='@{X11|datv}',
+            definition_resolved='test'
+        )
 
         schema.reset_aliases()
         x1.refresh_from_db()

rsconcept/backend/apps/rsform/tests/t_serializers.py

@@ -7,11 +7,13 @@ class TestExpressionSerializer(TestCase):
     def setUp(self):
         pass
 
+
     def test_validate(self):
         serializer = ExpressionSerializer(data={'expression': 'X1=X1'})
         self.assertTrue(serializer.is_valid(raise_exception=False))
         self.assertEqual(serializer.validated_data['expression'], 'X1=X1')
 
+
     def test_missing_data(self):
         serializer = ExpressionSerializer(data={})
         self.assertFalse(serializer.is_valid(raise_exception=False))

rsconcept/backend/apps/rsform/tests/t_utils.py

@@ -7,6 +7,8 @@ from apps.rsform.utils import apply_pattern, fix_old_references
 
 class TestUtils(unittest.TestCase):
     ''' Test various utility functions. '''
+
+
     def test_apply_mapping_patter(self):
         mapping = {'X101': 'X20'}
         pattern = re.compile(r'(X[0-9]+)')
@@ -15,6 +17,7 @@ class TestUtils(unittest.TestCase):
         self.assertEqual(apply_pattern('X101', mapping, pattern), 'X20')
         self.assertEqual(apply_pattern('asdf X101 asdf', mapping, pattern), 'asdf X20 asdf')
 
+
     def test_fix_old_references(self):
         self.assertEqual(fix_old_references(''), '')
         self.assertEqual(fix_old_references('X20'), 'X20')