def test_change_var_name(self):
for version_slug, version_tag in VERSION_TAGS.items():
args = utils.HanforArgumentParser(app).parse_args(
[VERSION_TAGS[version_slug], '-c', self.csv_files[version_slug]]
)
self.startup_hanfor(args, user_mock_answers=[])
self.app.post(
'api/var/update',
data={
'name': 'foo_bar',
'name_old': 'foo',
'type': 'bool',
'const_val': '',
'const_val_old': '',
'type_old': 'unknown',
'occurrences': 'SysRS FooXY_42',
'constraints': json.dumps({}),
'updated_constraints': False,
'enumerators': json.dumps([])
}
)
updated_affected_req = self.app.get('api/req/get?id=SysRS FooXY_42&row_idx=0')
self.assertEqual(
'Globally, it is never the case that "foo_bar!=bar" holds',
updated_affected_req.json['formal'][0]
)
def test_no_affect_of_deleting_used_variable(self):
args = utils.HanforArgumentParser(app).parse_args(
['test_delete_variable'])
self.startup_hanfor(args, user_mock_answers=[])
# Get the available requirements.
var_gets = self.app.get('api/var/gets')
self.assertEqual(
{
'spam', 'spam_ham', 'foo', 'egg', 'spam_egg', 'spam', 'bar',
'ham'
}, {
var[key]
for var in var_gets.json['data']
for key in var if key == 'name'
})
del_ham_result = self.app.post('api/var/multi_update',
data={
'change_type': '',
'selected_vars':
json.dumps(["foo"]),
'del': 'true'
})
self.assertEqual(True, del_ham_result.json['success'])
var_gets = self.app.get('api/var/gets')
self.assertEqual(
{
'spam', 'spam_ham', 'foo', 'egg', 'spam_egg', 'spam', 'bar',
'ham'
}, {
var[key]
for var in var_gets.json['data']
for key in var if key == 'name'
})
def test_adding_tags(self):
for version_slug, version_tag in VERSION_TAGS.items():
args = utils.HanforArgumentParser(app).parse_args(
[VERSION_TAGS[version_slug], '-c', self.csv_files[version_slug]]
)
self.startup_hanfor(args, user_mock_answers=[])
update = {
"0":{
"id":"0",
"scope":"GLOBALLY",
"pattern":"Absence",
"expression_mapping":{"P":"","Q":"","R":"foo!= bar","S":"","T":"","U":""}
}
}
add_formalization = self.app.post(
'api/req/update',
data={
'id': 'SysRS FooXY_42',
'row_idx': '0',
'update_formalization': 'false',
'tags': 'yolo',
'status': 'Todo',
'formalizations': json.dumps(update)
}
)
self.assertEqual('200 OK', add_formalization.status)
self.assertEqual('application/json', add_formalization.mimetype)
updated_reqs = self.app.get('api/req/gets')
self.assertEqual(
['yolo'],
updated_reqs.json['data'][0]['tags'],
)
def test_changed_description(self):
"""
### Status in old Revision:
* No formalization
### Changes in CSV
* Changed description of requirement.
### Desired state in New Revision:
* No Formalization
* Changed description to new one.
* Add Tag: migrated_description
* Change Status -> To do.
"""
# Create the first initial revision.
args = utils.HanforArgumentParser(app).parse_args(
[TEST_TAGS['simple'], '-c', CSV_FILES['simple']])
self.startup_hanfor(args, user_mock_answers=[2, 0, 1, 3])
# Get the available requirements.
initial_req_gets = self.app.get('api/req/gets')
self.assertEqual(initial_req_gets.json['data'][1]['desc'],
'always look on the bright side of life')
self.assertListEqual(initial_req_gets.json['data'][1]['tags'], [])
# Create the second revision.
args = utils.HanforArgumentParser(app).parse_args([
TEST_TAGS['simple'], '--revision', '-c',
CSV_FILES['simple_changed_desc']
])
self.startup_hanfor(args, user_mock_answers=[0, 0])
# Load the second revision.
args = utils.HanforArgumentParser(app).parse_args(
[TEST_TAGS['simple'], '-c', CSV_FILES['simple_changed_desc']])
self.startup_hanfor(args, user_mock_answers=[1])
# Get available requirements from new revision.
new_revision_req_gets = self.app.get('api/req/gets')
self.assertEqual(new_revision_req_gets.json['data'][1]['desc'],
'Mostly look on the bright side of life')
self.assertListEqual(new_revision_req_gets.json['data'][1]['tags'], [
'revision_0_to_revision_1_data_changed',
'revision_0_to_revision_1_description_changed'
])
self.assertListEqual(new_revision_req_gets.json['data'][0]['tags'], [])
def test_csv_file_after_migrations(self):
# Starting each version to trigger migrations.
for version_slug, version_tag in VERSION_TAGS.items():
args = utils.HanforArgumentParser(app).parse_args(
[VERSION_TAGS[version_slug], '-c', self.csv_files[version_slug]]
)
self.startup_hanfor(args, user_mock_answers=[])
# Test generated req_file consistency.
csv_file_content = self.app.get('/api/tools/csv_file').data.decode('utf-8').replace('\r\n', '\n')
self.assertEqual(self.expected_csv_files[version_slug], csv_file_content)
def test_migrations(self):
# Starting each version to trigger migrations.
for version_slug, version_tag in VERSION_TAGS.items():
args = utils.HanforArgumentParser(app).parse_args(
[VERSION_TAGS[version_slug], '-c', self.csv_files[version_slug]]
)
self.startup_hanfor(args, user_mock_answers=[])
# Get the available requirements.
initial_req_gets = self.app.get('api/req/gets')
self.assertEqual('always look on the bright side of life', initial_req_gets.json['data'][1]['desc'])
self.assertListEqual(['unseen'], initial_req_gets.json['data'][1]['tags'])
def test_new_session_from_csv(self):
"""
Creates a new session.
"""
# Create the first initial revision.
args = utils.HanforArgumentParser(app).parse_args([TEST_TAGS['simple'], '-c', CSV_FILES['simple']])
self.startup_hanfor(args, user_mock_answers=[2, 0, 1, 3])
# Get the available requirements.
initial_req_gets = self.app.get('api/req/gets')
self.assertEqual(initial_req_gets.json['data'][1]['desc'], 'always look on the bright side of life')
self.assertListEqual(initial_req_gets.json['data'][1]['tags'], [])
def startup_hanfor(self, csv_file, session_tag, user_mock_answers):
global mock_results
global count
count = -1
csv_file = os.path.join(self.test_session_base_folder, session_tag,
csv_file)
args = utils.HanforArgumentParser(app).parse_args(
[session_tag, '-c', csv_file])
mock_results = user_mock_answers
startup_hanfor(args, self.here)
app.config['TEMPLATES_FOLDER'] = os.path.join(self.here, '..',
'templates')
def test_created_diff(self):
"""
"""
# Create the first initial revision.
args = utils.HanforArgumentParser(app).parse_args(
[TEST_TAGS['real'], '-c', CSV_FILES['test_real_rev_0']])
self.startup_hanfor(args, user_mock_answers=[1, 5, 27, 8, 0])
# Get the available requirements.
initial_req_gets = self.app.get('api/req/gets')
self.assertEqual('DySok ASPDOJ_123',
initial_req_gets.json['data'][0]['id'])
self.assertListEqual([], initial_req_gets.json['data'][0]['tags'])
# Create the second revision.
args = utils.HanforArgumentParser(app).parse_args([
TEST_TAGS['real'], '--revision', '-c', CSV_FILES['test_real_rev_1']
])
self.startup_hanfor(args, user_mock_answers=[0, 0])
# Load the second revision.
args = utils.HanforArgumentParser(app).parse_args(
[TEST_TAGS['real'], '-c', CSV_FILES['test_real_rev_1']])
self.startup_hanfor(args, user_mock_answers=[1])
# Get available requirements from new revision.
new_revision_req_gets = self.app.get('api/req/gets')
# Do tests
self.assertListEqual(
['FWEPOFKWPFOK'],
list(
new_revision_req_gets.json['data'][0]['revision_diff'].keys()),
'Only a diff with changes at key FWEPOFKWPFOK')
self.assertEqual(
'- 1.2.3\n? ^\n\n+ 1.2.4\n? ^\n',
new_revision_req_gets.json['data'][0]['revision_diff']
['FWEPOFKWPFOK'])
self.assertListEqual(['revision_0_to_revision_1_data_changed'],
new_revision_req_gets.json['data'][0]['tags'])
def test_variable_with_constraint_deletion(self):
args = utils.HanforArgumentParser(app).parse_args(
['test_delete_variable'])
self.startup_hanfor(args, user_mock_answers=[])
# Get the available requirements.
var_gets = self.app.get('api/var/gets')
self.assertIn(
{
'name':
'ham',
'constraints':
['Globally, it is never the case that "ham != foo" holds'],
'type_inference_errors': {},
'script_results':
'',
'used_by': ['Constraint_ham_0'],
'const_val':
None,
'tags': [],
'type':
'bool',
'belongs_to_enum':
''
}, var_gets.json['data'])
self.assertEqual(
{
'spam', 'spam_ham', 'foo', 'egg', 'spam_egg', 'spam', 'bar',
'ham'
}, {
var[key]
for var in var_gets.json['data']
for key in var if key == 'name'
})
del_ham_result = self.app.post('api/var/multi_update',
data={
'change_type': '',
'selected_vars':
json.dumps(["ham"]),
'del': 'true'
})
self.assertEqual(True, del_ham_result.json['success'])
var_gets = self.app.get('api/var/gets')
self.assertEqual(
{'spam', 'spam_ham', 'foo', 'egg', 'spam_egg', 'spam', 'bar'}, {
var[key]
for var in var_gets.json['data']
for key in var if key == 'name'
})
def test_1_init_from_csv(self):
args = utils.HanforArgumentParser(app).parse_args(
[TEST_TAG, '-c', TEST_CSV])
self.startup_hanfor(args, [2, 0, 1, 3, 0])
self.assertTrue(os.path.isdir(os.path.join(TESTS_BASE_FOLDER,
TEST_TAG)),
msg='No session folder created.')
self.assertTrue(os.path.isdir(
os.path.join(TESTS_BASE_FOLDER, TEST_TAG, 'revision_0')),
msg='No revision folder created.')
# Check contents.
for file in [
'SysRS FooXY_42.pickle', 'SysRS FooXY_91.pickle',
'session_status.pickle'
]:
self.assertTrue(os.path.exists(
os.path.join(TESTS_BASE_FOLDER, TEST_TAG, 'revision_0', file)),
msg='Missing file: {}'.format(file))
def test_removing_formalization(self):
for version_slug, version_tag in VERSION_TAGS.items():
args = utils.HanforArgumentParser(app).parse_args(
[VERSION_TAGS[version_slug], '-c', self.csv_files[version_slug]]
)
self.startup_hanfor(args, user_mock_answers=[])
reqs = self.app.get('api/req/gets')
self.assertEqual('Globally, it is never the case that "foo != bar" holds', reqs.json['data'][0]['formal'][0])
add_formalization = self.app.post(
'api/req/del_formalization',
data={
'requirement_id': 'SysRS FooXY_42',
'formalization_id': 0,
}
)
self.assertEqual('200 OK', add_formalization.status)
self.assertEqual('application/json', add_formalization.mimetype)
reqs = self.app.get('api/req/gets')
self.assertEqual([], reqs.json['data'][0]['formal'])
def test_simple_script(self):
# Starting each version to trigger migrations.
for version_slug, version_tag in VERSION_TAGS.items():
args = utils.HanforArgumentParser(app).parse_args([
VERSION_TAGS[version_slug], '-c', self.csv_files[version_slug]
])
for test_name, settings in SCRIPT_EVALUATIONS[version_slug].items(
):
app.config['SCRIPT_EVALUATIONS'] = settings['script_config']
self.startup_hanfor(args, user_mock_answers=[])
# Let the background task do its work.
time.sleep(0.5)
# Get the available requirements.
var_gets = self.app.get('api/var/gets')
self.assertEqual(5, len(var_gets.json['data']))
for result in var_gets.json['data']:
self.assertEqual(
settings['expected_result'].replace(
'$VAR_NAME', result['name']),
result['script_results'])
def test_2_get_requirements(self):
args = utils.HanforArgumentParser(app).parse_args(
[TEST_TAG, '-c', TEST_CSV])
self.startup_hanfor(args, [2, 0, 1, 3, 0])
result = self.app.get('api/req/gets')
self.maxDiff = None
desired_reqs = [{
'formal': [],
'pattern': 'None',
'status': 'Todo',
'pos': 1,
'revision_diff': {},
'vars': [],
'scope': 'None',
'tags': [],
'desc': 'Dont worry, be happy',
'csv_data': {
'formal_header':
'Globally, it is never the case, that WORRY holds; Globally, it is always the case, that HAPPY holds.',
'id_header': 'SysRS FooXY_42',
'type_header': 'req',
'desc_header': 'Dont worry, be happy'
},
'id': 'SysRS FooXY_42',
'type_inference_errors': {},
'type': 'req'
}, {
'formal': [],
'status': 'Todo',
'pattern': 'None',
'pos': 0,
'revision_diff': {},
'vars': [],
'scope': 'None',
'tags': [],
'desc': 'always look on the bright side of life',
'csv_data': {
'formal_header':
'Globally, it is always the case that POINT_OF_VIEW==BRIGHT_SIDE_OF_LIVE',
'id_header': 'SysRS FooXY_91',
'type_header': 'req',
'desc_header': 'always look on the bright side of life'
},
'id': 'SysRS FooXY_91',
'type_inference_errors': {},
'type': 'req'
}]
self.assertListEqual(result.json['data'], desired_reqs)
result = self.app.get('api/req/get?id=SysRS FooXY_42')
desired_req = {
'id': 'SysRS FooXY_42',
'type_inference_errors': {},
'csv_data': {
'type_header':
'req',
'id_header':
'SysRS FooXY_42',
'desc_header':
'Dont worry, be happy',
'formal_header':
'Globally, it is never the case, that WORRY holds; Globally, it is always the case, that HAPPY holds.'
},
'status': 'Todo',
'available_vars': [],
'additional_static_available_vars': ['abs()'],
'desc': 'Dont worry, be happy',
'formal': [],
'vars': [],
'tags': [],
'pattern': 'None',
'pos': 1,
'scope': 'None',
'type': 'req',
'formalizations_html': '',
'revision_diff': {}
}
self.assertDictEqual(result.json, desired_req)
def test_generating_a_new_import_session(self):
for version_slug, version_tag in VERSION_TAGS.items():
# Cleanup test_env in each iteration to be consistent.
self.clean_folders()
self.create_temp_data()
args = utils.HanforArgumentParser(app).parse_args(
[VERSION_TAGS[version_slug], '-c', self.csv_files[version_slug]]
)
self.startup_hanfor(args, user_mock_answers=[])
# Test correct variable import session infos
import_session_details = self.app.post(
'api/var/var_import_info',
data={
'sess_name': 'simple_0_0_0_var_import_source',
'sess_revision': 'revision_0'
}
)
self.assertEqual(
{"new_vars": 6, "tot_vars": 11},
import_session_details.json
)
# Start a new import session.
start_import_session_result = self.app.post(
'api/var/start_import_session',
data={
'sess_name': 'simple_0_0_0_var_import_source',
'sess_revision': 'revision_0'
}
)
self.assertEqual(
{
"errormsg": "",
"session_id": 0,
"success": True
},
start_import_session_result.json
)
# Check import session consistency.
import_session_data = self.app.post(
'variable_import/api/0/get_table_data',
data={
'sess_name': 'simple_0_0_0_var_import_source',
'sess_revision': 'revision_0'
}
)
self.assertEqual(
11,
len(import_session_data.json['data'])
)
# Mark variables to be imported.
self.app.post(
'variable_import/api/0/store_table',
data={'rows': json.dumps({"enum_with_constraint":{"action":"source"}})}
)
# Mark variables to be imported.
self.app.post('variable_import/api/0/apply_import', data={})
# Check consistency of for imported variables.
new_var_collection_contents = self.app.get('api/var/gets')
self.assertIn(
{
'used_by': ['Constraint_enum_with_constraint_0'],
'type_inference_errors': {},
'constraints': [
'Globally, it is never the case that "0 < enum_with_constraint && enum_with_constraint < 3" holds'
],
'const_val': None,
'tags': [],
'type': 'ENUM_INT',
'name': 'enum_with_constraint',
'script_results': '',
'belongs_to_enum': ''
},
new_var_collection_contents.json['data']
)
def test_variable_add_constraint_and_change_type_at_the_same_time(self):
args = utils.HanforArgumentParser(app).parse_args(
['test_variable_manipulation_edge_cases']
)
self.startup_hanfor(args, user_mock_answers=[])
# Get the available requirements.
var_gets = self.app.get('api/var/gets')
self.assertIn(
{
'name': 'egg',
'constraints': [],
'type_inference_errors': {},
'script_results': '',
'used_by': ['SysRS FooXY_91'],
'const_val': None,
'tags': [],
'type': 'bool',
'belongs_to_enum': ''
},
var_gets.json['data']
)
add_constraint = self.app.post(
'api/var/new_constraint',
data={'name': 'egg'}
)
self.assertEqual(True, add_constraint.json['success'])
change_type = self.app.post(
'api/var/update',
data={
'name': 'egg',
'name_old': 'egg',
'type': 'ENUM_INT',
'const_val': '',
'const_val_old': '',
'type_old': 'bool',
'occurrences': 'SysRS+FooXY_91',
'constraints': json.dumps(
{
"0":{
"id":"0",
"scope":"GLOBALLY",
"pattern":"Universality",
"expression_mapping":{"P":"","Q":"","R":"egg > 10","S":"","T":"","U":""}
}
}),
'updated_constraints': 'true',
'enumerators': json.dumps([])
}
)
self.assertEqual(True, change_type.json['success'])
var_gets = self.app.get('api/var/gets')
print(var_gets.json['data'])
self.assertIn(
{
'name': 'egg',
'constraints': ['Globally, it is always the case that "egg > 10" holds'],
'used_by': ['Constraint_egg_0', 'SysRS FooXY_91'],
'tags': [],
'type_inference_errors': {},
'const_val': None,
'type': 'ENUM_INT',
'script_results': '',
'belongs_to_enum': ''
},
var_gets.json['data']
)
