mirror of
https://github.com/IRBorisov/ConceptPortal.git
synced 2025-06-26 13:00:39 +03:00
291 lines
12 KiB
Python
291 lines
12 KiB
Python
''' Testing models '''
|
||
import json
|
||
from django.test import TestCase
|
||
from django.db.utils import IntegrityError
|
||
from django.forms import ValidationError
|
||
|
||
from apps.rsform.models import (
|
||
RSForm,
|
||
Constituenta,
|
||
CstType,
|
||
User
|
||
)
|
||
|
||
|
||
class TestConstituenta(TestCase):
|
||
def setUp(self):
|
||
self.schema1 = RSForm.objects.create(title='Test1')
|
||
self.schema2 = RSForm.objects.create(title='Test2')
|
||
|
||
def test_str(self):
|
||
testStr = 'X1'
|
||
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',
|
||
schema=self.schema1,
|
||
order=1
|
||
)
|
||
self.assertEqual(cst.schema, self.schema1)
|
||
self.assertEqual(cst.order, 1)
|
||
self.assertEqual(cst.alias, 'X1')
|
||
self.assertEqual(cst.cst_type, CstType.BASE)
|
||
self.assertEqual(cst.convention, '')
|
||
self.assertEqual(cst.definition_formal, '')
|
||
self.assertEqual(cst.term_raw, '')
|
||
self.assertEqual(cst.term_resolved, '')
|
||
self.assertEqual(cst.term_forms, [])
|
||
self.assertEqual(cst.definition_resolved, '')
|
||
self.assertEqual(cst.definition_raw, '')
|
||
|
||
|
||
class TestRSForm(TestCase):
|
||
def setUp(self):
|
||
self.user1 = User.objects.create(username='User1')
|
||
self.user2 = User.objects.create(username='User2')
|
||
self.assertNotEqual(self.user1, self.user2)
|
||
|
||
def test_str(self):
|
||
testStr = 'Test123'
|
||
schema = RSForm.objects.create(title=testStr, owner=self.user1, alias='КС1')
|
||
self.assertEqual(str(schema), testStr)
|
||
|
||
def test_url(self):
|
||
testStr = 'Test123'
|
||
schema = RSForm.objects.create(title=testStr, owner=self.user1, alias='КС1')
|
||
self.assertEqual(schema.get_absolute_url(), f'/api/rsforms/{schema.id}/')
|
||
|
||
def test_create_default(self):
|
||
schema = RSForm.objects.create(title='Test')
|
||
self.assertIsNone(schema.owner)
|
||
self.assertEqual(schema.title, 'Test')
|
||
self.assertEqual(schema.alias, '')
|
||
self.assertEqual(schema.comment, '')
|
||
self.assertEqual(schema.is_common, False)
|
||
|
||
def test_create(self):
|
||
schema = RSForm.objects.create(
|
||
title='Test',
|
||
owner=self.user1,
|
||
alias='KS1',
|
||
comment='Test comment',
|
||
is_common=True
|
||
)
|
||
self.assertEqual(schema.owner, self.user1)
|
||
self.assertEqual(schema.title, 'Test')
|
||
self.assertEqual(schema.alias, 'KS1')
|
||
self.assertEqual(schema.comment, 'Test comment')
|
||
self.assertEqual(schema.is_common, True)
|
||
|
||
def test_constituents(self):
|
||
schema1 = RSForm.objects.create(title='Test1')
|
||
schema2 = RSForm.objects.create(title='Test2')
|
||
self.assertFalse(schema1.constituents().exists())
|
||
self.assertFalse(schema2.constituents().exists())
|
||
|
||
Constituenta.objects.create(alias='X1', schema=schema1, order=1)
|
||
Constituenta.objects.create(alias='X2', schema=schema1, order=2)
|
||
self.assertTrue(schema1.constituents().exists())
|
||
self.assertFalse(schema2.constituents().exists())
|
||
self.assertEqual(schema1.constituents().count(), 2)
|
||
|
||
def test_insert_at(self):
|
||
schema = RSForm.objects.create(title='Test')
|
||
cst1 = schema.insert_at(1, 'X1', CstType.BASE)
|
||
self.assertEqual(cst1.order, 1)
|
||
self.assertEqual(cst1.schema, schema)
|
||
|
||
cst2 = schema.insert_at(1, 'X2', CstType.BASE)
|
||
cst1.refresh_from_db()
|
||
self.assertEqual(cst2.order, 1)
|
||
self.assertEqual(cst2.schema, schema)
|
||
self.assertEqual(cst1.order, 2)
|
||
|
||
cst3 = schema.insert_at(4, 'X3', CstType.BASE)
|
||
cst2.refresh_from_db()
|
||
cst1.refresh_from_db()
|
||
self.assertEqual(cst3.order, 3)
|
||
self.assertEqual(cst3.schema, schema)
|
||
self.assertEqual(cst2.order, 1)
|
||
self.assertEqual(cst1.order, 2)
|
||
|
||
cst4 = schema.insert_at(3, 'X4', CstType.BASE)
|
||
cst3.refresh_from_db()
|
||
cst2.refresh_from_db()
|
||
cst1.refresh_from_db()
|
||
self.assertEqual(cst4.order, 3)
|
||
self.assertEqual(cst4.schema, schema)
|
||
self.assertEqual(cst3.order, 4)
|
||
self.assertEqual(cst2.order, 1)
|
||
self.assertEqual(cst1.order, 2)
|
||
|
||
with self.assertRaises(ValidationError):
|
||
schema.insert_at(0, 'X5', CstType.BASE)
|
||
|
||
def test_insert_at_reorder(self):
|
||
schema = RSForm.objects.create(title='Test')
|
||
schema.insert_at(1, 'X1', CstType.BASE)
|
||
d1 = schema.insert_at(2, 'D1', CstType.TERM)
|
||
d2 = schema.insert_at(1, 'D2', CstType.TERM)
|
||
d1.refresh_from_db()
|
||
self.assertEqual(d1.order, 3)
|
||
self.assertEqual(d2.order, 2)
|
||
|
||
x2 = schema.insert_at(4, 'X2', CstType.BASE)
|
||
self.assertEqual(x2.order, 2)
|
||
|
||
def test_insert_last(self):
|
||
schema = RSForm.objects.create(title='Test')
|
||
cst1 = schema.insert_last('X1', CstType.BASE)
|
||
self.assertEqual(cst1.order, 1)
|
||
self.assertEqual(cst1.schema, schema)
|
||
|
||
cst2 = schema.insert_last('X2', CstType.BASE)
|
||
self.assertEqual(cst2.order, 2)
|
||
self.assertEqual(cst2.schema, schema)
|
||
self.assertEqual(cst1.order, 1)
|
||
|
||
def test_create_cst_resolve(self):
|
||
schema = RSForm.objects.create(title='Test')
|
||
cst1 = schema.insert_last('X1', CstType.BASE)
|
||
cst1.term_raw = '@{X2|datv}'
|
||
cst1.definition_raw = '@{X1|datv} @{X2|datv}'
|
||
cst1.save()
|
||
cst2 = schema.create_cst({
|
||
'alias': 'X2',
|
||
'cst_type': CstType.BASE,
|
||
'term_raw': 'слон',
|
||
'definition_raw': '@{X1|plur} @{X2|plur}'
|
||
})
|
||
cst1.refresh_from_db()
|
||
self.assertEqual(cst1.term_resolved, 'слону')
|
||
self.assertEqual(cst1.definition_resolved, 'слону слону')
|
||
self.assertEqual(cst2.term_resolved, 'слон')
|
||
self.assertEqual(cst2.definition_resolved, 'слонам слоны')
|
||
|
||
def test_delete_cst(self):
|
||
schema = RSForm.objects.create(title='Test')
|
||
x1 = schema.insert_last('X1', CstType.BASE)
|
||
x2 = schema.insert_last('X2', CstType.BASE)
|
||
d1 = schema.insert_last('D1', CstType.TERM)
|
||
d2 = schema.insert_last('D2', CstType.TERM)
|
||
schema.delete_cst([x2, d1])
|
||
x1.refresh_from_db()
|
||
d2.refresh_from_db()
|
||
schema.refresh_from_db()
|
||
self.assertEqual(schema.constituents().count(), 2)
|
||
self.assertEqual(x1.order, 1)
|
||
self.assertEqual(d2.order, 2)
|
||
|
||
def test_move_cst(self):
|
||
schema = RSForm.objects.create(title='Test')
|
||
x1 = schema.insert_last('X1', CstType.BASE)
|
||
x2 = schema.insert_last('X2', CstType.BASE)
|
||
d1 = schema.insert_last('D1', CstType.TERM)
|
||
d2 = schema.insert_last('D2', CstType.TERM)
|
||
schema.move_cst([x2, d2], 1)
|
||
x1.refresh_from_db()
|
||
x2.refresh_from_db()
|
||
d1.refresh_from_db()
|
||
d2.refresh_from_db()
|
||
self.assertEqual(x1.order, 2)
|
||
self.assertEqual(x2.order, 1)
|
||
self.assertEqual(d1.order, 4)
|
||
self.assertEqual(d2.order, 3)
|
||
|
||
def test_move_cst_down(self):
|
||
schema = RSForm.objects.create(title='Test')
|
||
x1 = schema.insert_last('X1', CstType.BASE)
|
||
x2 = schema.insert_last('X2', CstType.BASE)
|
||
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_to_trs(self):
|
||
schema = RSForm.objects.create(title='Test', alias='KS1', comment='Test')
|
||
x1 = schema.insert_at(4, 'X1', CstType.BASE)
|
||
x2 = schema.insert_at(1, 'X2', CstType.BASE)
|
||
expected = json.loads(
|
||
f'{{"type": "rsform", "title": "Test", "alias": "KS1", '
|
||
f'"comment": "Test", "items": '
|
||
f'[{{"entityUID": {x2.id}, "type": "constituenta", "cstType": "basic", "alias": "X2", "convention": "", '
|
||
f'"term": {{"raw": "", "resolved": "", "forms": []}}, '
|
||
f'"definition": {{"formal": "", "text": {{"raw": "", "resolved": ""}}}}}}, '
|
||
f'{{"entityUID": {x1.id}, "type": "constituenta", "cstType": "basic", "alias": "X1", "convention": "", '
|
||
f'"term": {{"raw": "", "resolved": "", "forms": []}}, '
|
||
f'"definition": {{"formal": "", "text": {{"raw": "", "resolved": ""}}}}}}]}}'
|
||
)
|
||
self.assertEqual(schema.to_trs(), expected)
|
||
|
||
def test_create_from_trs(self):
|
||
input = json.loads(
|
||
'{"type": "rsform", "title": "Test", "alias": "KS1", '
|
||
'"comment": "Test", "items": '
|
||
'[{"entityUID": 1337, "type": "constituenta", "cstType": "basic", "alias": "X1", "convention": "", '
|
||
'"term": {"raw": "", "resolved": ""}, '
|
||
'"definition": {"formal": "123", "text": {"raw": "", "resolved": ""}}}, '
|
||
'{"entityUID": 55, "type": "constituenta", "cstType": "basic", "alias": "X2", "convention": "", '
|
||
'"term": {"raw": "", "resolved": ""}, '
|
||
'"definition": {"formal": "", "text": {"raw": "", "resolved": ""}}}]}'
|
||
)
|
||
schema = RSForm.create_from_trs(self.user1, input, False)
|
||
self.assertEqual(schema.owner, self.user1)
|
||
self.assertEqual(schema.title, 'Test')
|
||
self.assertEqual(schema.alias, 'KS1')
|
||
self.assertEqual(schema.is_common, False)
|
||
constituents = schema.constituents().order_by('order')
|
||
self.assertEqual(constituents.count(), 2)
|
||
self.assertEqual(constituents[0].alias, 'X1')
|
||
self.assertEqual(constituents[0].definition_formal, '123')
|
||
|
||
def test_load_trs(self):
|
||
schema = RSForm.objects.create(title='Test', owner=self.user1, alias='КС1')
|
||
x2 = schema.insert_last('X2', CstType.BASE)
|
||
schema.insert_last('X3', CstType.BASE)
|
||
input = json.loads(
|
||
'{"title": "Test1", "alias": "KS1", '
|
||
'"comment": "Test", "items": '
|
||
'[{"entityUID": "' + str(x2.id) + '", "cstType": "basic", "alias": "X1", "convention": "test", '
|
||
'"term": {"raw": "t1", "resolved": "t2"}, '
|
||
'"definition": {"formal": "123", "text": {"raw": "@{X1|datv}", "resolved": "t4"}}}]}'
|
||
)
|
||
schema.load_trs(input, sync_metadata=True, skip_update=True)
|
||
x2.refresh_from_db()
|
||
self.assertEqual(schema.constituents().count(), 1)
|
||
self.assertEqual(schema.title, input['title'])
|
||
self.assertEqual(schema.alias, input['alias'])
|
||
self.assertEqual(schema.comment, input['comment'])
|
||
self.assertEqual(x2.alias, input['items'][0]['alias'])
|
||
self.assertEqual(x2.convention, input['items'][0]['convention'])
|
||
self.assertEqual(x2.term_raw, input['items'][0]['term']['raw'])
|
||
self.assertEqual(x2.term_resolved, input['items'][0]['term']['raw'])
|
||
self.assertEqual(x2.definition_formal, input['items'][0]['definition']['formal'])
|
||
self.assertEqual(x2.definition_raw, input['items'][0]['definition']['text']['raw'])
|
||
self.assertEqual(x2.definition_resolved, input['items'][0]['term']['raw'])
|