def rmttest_positive_02(self):
"Three node one edge digraph B -> A, C -> A and C -> B"
config = TestConfig()
imod = InputModules(config)
reqset = RequirementSet(config)
req1 = Requirement('''Name: A
Type: master requirement''', 'A', None, imod, config)
reqset.add_requirement(req1)
req2 = Requirement('''Name: B
Type: requirement
Depends on: A''', 'B', None, imod, config)
reqset.add_requirement(req2)
config.set_depends_on()
req3 = Requirement('''Name: C
Type: requirement
Depends on: A B''', 'C', None, imod, config)
reqset.add_requirement(req3)
config.set_depends_on()
rdep = RDepDependsOn(config)
rdep.rewrite(reqset)
assert [] == reqset.get_requirement("A").incoming_as_named_list()
# There are two possible valid results
assert reqset.get_requirement("A").outgoing_as_named_list() \
in [["C", "B"], ["B", "C"]]
assert ["A"] == reqset.get_requirement("B").incoming_as_named_list()
assert ["C"] == reqset.get_requirement("B").outgoing_as_named_list()
assert ["A",
"B"] == reqset.get_requirement("C").incoming_as_named_list()
assert [] == reqset.get_requirement("C").outgoing_as_named_list()
def __read_one_requirement(self, fileinfo, input_mods, object_cache):
'''Read in one requirement from the file info.'''
tracer.debug("Called.")
# Check for correct filename
if not fileinfo.get_filename().endswith(".req"):
tracer.info("skipping file [%s]", fileinfo.get_filename())
return
# Handle caching.
vcs_id = fileinfo.get_vcs_id()
rid = fileinfo.get_filename_sub_part()[:-4]
req = object_cache.get("Requirement", vcs_id)
tracer.info("Reading requirement [%s]", rid)
if req is None:
file_content = fileinfo.get_content()
req = Requirement(file_content, rid, fileinfo.get_filename(),
input_mods, self._config)
# Add the requirement to the cache.
object_cache.add(vcs_id, "Requirement", req)
self._adapt_usablility(req)
if req.is_usable():
# Store in the map, so that it is easy to access the
# node by id.
self.add_requirement(req)
# Also store it in the digraph's node list for simple
# access to the digraph algorithms.
# self.nodes.append(req)
else:
logger.error(LogFormatter.format(
45, "could not be parsed", req.get_id()))
tracer.debug("Finished.")
def rmttest_positive_02(self):
"Three node digraph C -> B -> A"
config = TestConfig()
reqset = RequirementSet(config)
req1 = Requirement('''Name: A
Type: master requirement
Solved by: B''', 'A', None, None, None)
reqset.add_requirement(req1)
req2 = Requirement('''Name: B
Type: requirement
Solved by: C''', 'B', None, None, None)
reqset.add_requirement(req2)
req3 = Requirement('''Name: C
Type: requirement''', 'C', None, None, None)
reqset.add_requirement(req3)
reqset.resolve_solved_by()
reqset.find_master_nodes()
reqset.build_named_nodes()
reqset.graph_master_node = reqset.get_named_node("A")
reqset.get_named_node("A").set_value("Factor", 1.0)
reqset.get_named_node("B").set_value("Factor", 0.8)
reqset.get_named_node("C").set_value("Factor", 0.5)
rdep = RDepPriority(config)
rdep.rewrite(reqset)
assert 1.0 == reqset.get_named_node("A").get_value("Priority")
assert 0.8 == reqset.get_named_node("B").get_value("Priority")
assert 0.4 == reqset.get_named_node("C").get_value("Priority")
def rmttest_neg_solved_by_to_nonex_req(self):
"'Solved by' points to a non existing requirement"
mstderr = StringIO()
init_logger(mstderr)
config = TestConfig()
reqset = RequirementSet(config)
req1 = Requirement('''Name: A
Type: master requirement''', 'A', None, None, None)
reqset.add_requirement(req1)
req2 = Requirement('''Name: B
Type: requirement
Solved by: C''', 'B', None, None, None)
reqset.add_requirement(req2)
config.set_solved_by()
rdep = RDepSolvedBy(config)
status = rdep.rewrite(reqset)
self.assertFalse(status)
lstderr = hide_volatile(mstderr.getvalue())
tear_down_log_handler()
result_expected \
= "===DATETIMESTAMP===;rmtoo;ERROR;RequirementSet;" \
"__resolve_solved_by_one_req_deps;===LINENO===; " \
"74:B:'Solved by' points to a non-existing requirement 'C'\n"
self.assertEquals(result_expected, lstderr)
def __read_one_requirement(self, fileinfo, input_mods, object_cache):
'''Read in one requirement from the file info.'''
tracer.debug("Called.")
# Check for correct filename
if not fileinfo.get_filename().endswith(".req"):
tracer.info("skipping file [%s]" % fileinfo.get_filename())
return
# Handle caching.
vcs_id = fileinfo.get_vcs_id()
rid = fileinfo.get_filename_sub_part()[:-4]
req = object_cache.get("Requirement", vcs_id)
tracer.info("Reading requirement [%s]" % rid)
if req == None:
file_content = fileinfo.get_content()
req = Requirement(file_content, rid, fileinfo.get_filename(),
input_mods, self._config)
# Add the requirement to the cache.
object_cache.add(vcs_id, "Requirement", req)
self._adapt_usablility(req)
if req.is_usable():
dnreq = RequirementDNode(req)
# Store in the map, so that it is easy to access the
# node by id.
### ToDo: needed self._add_requirement(req)
self.add_node(dnreq)
# Also store it in the digraph's node list for simple
# access to the digraph algorithms.
# self.nodes.append(req)
else:
logger.error(LogFormatter.format(
45, "could not be parsed", req.id))
tracer.debug("Finished.")
def test_positive_01(self):
"Two node one edge digraph B -> A"
config = TestConfig()
imod = InputModules("..", config)
reqset = RequirementSet(config)
req1 = Requirement('''Name: A
Type: master requirement''', 'A', None, imod, config)
reqset.add_node(RequirementDNode(req1))
req2 = Requirement('''Name: B
Type: requirement
Depends on: A''', 'B', None, imod, config)
reqset.add_node(RequirementDNode(req2))
config.set_depends_on()
rdep = RDepDependsOn(config)
rdep.rewrite(reqset)
assert (reqset.get_requirement("A").get_incoming_as_named_list() == [])
assert (reqset.get_requirement("A").get_outgoing_as_named_list() == [
"B"
])
assert (reqset.get_requirement("B").get_incoming_as_named_list() == [
"A"
])
assert (reqset.get_requirement("B").get_outgoing_as_named_list() == [])
def test_neg_point_to_self(self):
"'Solved by' points to same requirement"
mstderr = StringIO.StringIO()
init_logger(mstderr)
config = TestConfig()
reqset = RequirementSet(config)
req1 = Requirement('''Name: A
Type: master requirement''', 'A', None, None, None)
reqset.add_node(RequirementDNode(req1))
req2 = Requirement('''Name: B
Type: requirement
Solved by: B''', 'B', None, None, None)
reqset.add_node(RequirementDNode(req2))
config.set_solved_by()
rdep = RDepSolvedBy(config)
status = rdep.rewrite(reqset)
self.assertFalse(status)
lstderr = hide_lineno(hide_timestamp(mstderr.getvalue()))
tear_down_log_handler()
result_expected = "===DATETIMESTAMP===;rmtoo;ERROR;RequirementSet;" \
"__resolve_solved_by_one_req;===SOURCELINENO===; 75:B:'Solved by' " \
"points to the requirement itself\n"
self.assertEquals(result_expected, lstderr)
def rmttest_positive_01(self):
"Two node one edge digraph B -> A"
config = TestConfig()
imod = InputModules(config)
reqset = RequirementSet(config)
req1 = Requirement('''Name: A
Type: master requirement''', 'A', None, imod, config)
reqset.add_requirement(req1)
req2 = Requirement('''Name: B
Type: requirement
Depends on: A''', 'B', None, imod, config)
reqset.add_requirement(req2)
config.set_depends_on()
rdep = RDepDependsOn(config)
rdep.rewrite(reqset)
self.assertEqual([],
reqset.get_requirement("A").incoming_as_named_list())
self.assertEqual(["B"],
reqset.get_requirement("A").outgoing_as_named_list())
self.assertEqual(["A"],
reqset.get_requirement("B").incoming_as_named_list())
self.assertEqual([],
reqset.get_requirement("B").outgoing_as_named_list())
def test_positive_01(self):
"Two node one edge digraph B -> A"
config = TestConfig()
reqset = RequirementSet(config)
req1 = Requirement('''Name: A
Type: master requirement
Solved by: B''', 'A', None, None, None)
reqset.add_node(RequirementDNode(req1))
req2 = Requirement('''Name: B
Type: requirement''', 'B', None, None, None)
reqset.add_node(RequirementDNode(req2))
reqset.resolve_solved_by()
reqset.find_master_nodes()
reqset.graph_master_node = reqset.find("A")
reqset.find("A").get_requirement().set_value("Factor", 1.0)
reqset.find("B").get_requirement().set_value("Factor", 0.8)
rdep = RDepPriority(config)
rdep.rewrite(reqset)
assert (
reqset.find("A").get_requirement().get_value("Priority") == 1.0)
assert (
reqset.find("B").get_requirement().get_value("Priority") == 0.8)
def rmttest_neg_point_to_self(self):
"'Solved by' points to same requirement"
mstderr = StringIO()
init_logger(mstderr)
config = TestConfig()
reqset = RequirementSet(config)
req1 = Requirement('''Name: A
Type: master requirement''', 'A', None, None, None)
reqset.add_requirement(req1)
req2 = Requirement('''Name: B
Type: requirement
Solved by: B''', 'B', None, None, None)
reqset.add_requirement(req2)
config.set_solved_by()
rdep = RDepSolvedBy(config)
status = rdep.rewrite(reqset)
assert not status
lstderr = hide_volatile(mstderr.getvalue())
tear_down_log_handler()
result_expected \
= "===DATETIMESTAMP===;rmtoo;ERROR;RequirementSet;" \
"__resolve_solved_by_one_req_deps;===LINENO===; " \
"75:B:'Solved by' points to the requirement itself\n"
assert result_expected == lstderr
def rmttest_def_req(self):
"LaTeX output: compare output to defined value"
exp_value = r"""
\paragraph{my name}
\hypertarget{TestReq}{TestReq}
\label{TestReq}
my desc
\textbf{Rationale:}
\textbf{Note:}
\par{\small \begin{center}
\begin{tabular}{rlrlrl}
Id: & TestReq & Priority: & & Owner: & \\
Invented on: & & Invented by: & & Status: & finished (meiner, 2011-04-15, 4 h) \\
Class: & implementable
\end{tabular}\end{center}
}
""" # noqa
tcfg = TestConfig()
tcfg.set_output_cfg()
mconfig = self.__def_mconfig
mconfig['req_attributes'] = ["Status", "Class", "DoesNotExists"]
req_proc = latex2(mconfig)
req = Requirement(None, u"TestReq", None, None, None)
req.values = {}
req.values[u"Name"] = RecordEntry(u"Name", u"my name")
req.values[u"Type"] = RequirementType.requirement
req.values[u"Description"] = RecordEntry(u"Description", u"my desc")
req.values[u"Status"] = RequirementStatusFinished(
None, u"rid", u"finished:meiner:2011-04-15:4h")
req.values[u"Class"] = ClassTypeImplementable()
ce3set = CE3Set()
ce3 = CE3()
ce3set.insert(u"TestReq", ce3)
''' This is here for future? use.
rset = RequirementSet(tcfg)
ttopic_set = TestTopicSet(rset)
'''
req_text = req_proc._get_requirement(req)
try:
assert req_text == exp_value
except AssertionError:
import difflib
diff = difflib.ndiff(req_text.splitlines(True),
exp_value.splitlines(True))
print(''.join(diff))
raise Exception("The template is not equal to it's expected value")
def rmttest_positive_01(self):
"""Requirement contains a tag where no handler exists"""
mstderr = StringIO()
init_logger(mstderr)
test_config = TestConfig()
test_config.set_solved_by()
mods = InputModules(test_config)
reqs = RequirementSet(None)
req = Requirement("Hubbel: bubbel", "hubbel", reqs, mods, test_config)
reqs.add_requirement(req)
reqs._handle_modules(mods)
lstderr = hide_volatile(mstderr.getvalue())
tear_down_log_handler()
result_expected \
= ["===DATETIMESTAMP===;rmtoo;ERROR;RequirementSet;"
"__all_tags_handled;===LINENO===; 57:hubbel:No tag handler "
"found for "
"tag(s) '[\"Hubbel\"]' - Hint: typo in tag(s)?",
"===DATETIMESTAMP===;rmtoo;ERROR;"
"RequirementSet;_handle_modules;"
"===LINENO===; 56:There were errors encountered during parsing "
"and checking - can't continue."]
lstderr_last_two_lines = lstderr.split("\n")[-3:-1]
assert result_expected == lstderr_last_two_lines
def test_simple_05(self):
"Module test with dependent modules"
mstderr = StringIO.StringIO()
init_logger(mstderr)
mods = InputModules(os.path.join(mod_base_dir, "modules05"), {}, [],
mods_list("modules05", mod_base_dir))
req = Requirement("Name: t\n", 77, None, mods, TestConfig())
lstderr = hide_lineno(hide_timestamp(mstderr.getvalue()))
tear_down_log_handler()
self.assertEqual(req.is_usable(), False)
expected_result = "===DATETIMESTAMP===;rmtoo;ERROR;BaseRMObject;" \
"handle_modules_tag;===SOURCELINENO===; 54:77:" \
"tag [SameTag] already defined\n"
self.assertEqual(lstderr, expected_result)
def test_positive_02(self):
"Requirement contains a tag where no handler exists - multiple tags"
mstderr = StringIO.StringIO()
init_logger(mstderr)
mods = InputModules(os.path.join(mod_base_dir, "modules08"), {}, [],
mods_list("modules08", mod_base_dir))
reqs = RequirementSet(None)
req = Requirement("Hubbel: bubbel\nSiebel: do", "InvalidTagReq", reqs,
mods, TestConfig())
reqs.add_node(RequirementDNode(req))
reqs._handle_modules(mods)
lstderr = hide_timestamp(mstderr.getvalue())
lstderr = hide_lineno(lstderr)
tear_down_log_handler()
result_expected = "===DATETIMESTAMP===;rmtoo;ERROR;RequirementSet;" \
"__all_tags_handled;===SOURCELINENO===; 57:InvalidTagReq:No tag " \
"handler found " \
"for tag(s) '['Siebel', 'Hubbel']' - Hint: typo in tag(s)?\n" \
"===DATETIMESTAMP===;rmtoo;ERROR;RequirementSet;_handle_modules;" \
"===SOURCELINENO===; 56:There were errors encountered during parsing " \
"and checking " \
"- can't continue.\n"
self.assertEquals(result_expected, lstderr)
def rmttest_treat_newlines_correctly(self, dest_dir):
tmpdir = dest_dir['requirements_dirs'][0]
config = dict(self.config)
tmp_fn = os.path.join(tmpdir, 'test-reqs.xlsx')
distutils.file_util.copy_file(config[u'import_filename'], tmp_fn)
config[u'import_filename'] = tmp_fn
importer = XlsImport(config, dest_dir)
importer.run()
newlines_filename = os.path.join(tmpdir, 'TestNewlines.req')
assert os.path.isfile(newlines_filename)
with codecs.open(newlines_filename, encoding='utf-8') as nl_fh:
req_content = nl_fh.read()
nl_req = Requirement(req_content, 'TestNewlines.req',
newlines_filename, None, None)
# Test Description
parsed_desc = "\n".join(nl_req.record[2].
get_content_trimmed_with_nl())
assert parsed_desc == LIPSUM + "\n\nASDF"
parsed_note = "\n".join(nl_req.record[10].
get_content_trimmed_with_nl())
assert parsed_note == "Lipsum\n\nHandle it well"
parsed_invon = "\n".join(nl_req.record[7].
get_content_trimmed_with_nl())
assert parsed_invon == "2010-03-06"
def test_simple_05(self):
"Module test with dependent modules"
mstderr = StringIO.StringIO()
init_logger(mstderr)
mods = InputModules(os.path.join(mod_base_dir, "modules05"),
{}, [], mods_list("modules05", mod_base_dir))
req = Requirement("Name: t\n", 77, None, mods, TestConfig())
lstderr = hide_lineno(hide_timestamp(mstderr.getvalue()))
tear_down_log_handler()
self.assertEqual(req.is_usable(), False)
expected_result = "===DATETIMESTAMP===;rmtoo;ERROR;BaseRMObject;" \
"handle_modules_tag;===SOURCELINENO===; 54:77:" \
"tag [SameTag] already defined\n"
self.assertEqual(lstderr, expected_result)
def rh_one_rs(self, cs, rs, files):
for f in files:
# Only files which end in .req are used
m = re.match("^.*\.req$", f.name)
if m==None:
continue
rid = f.name[:-4]
req = Requirement(f.data_stream, rid, rs,
cs.mods, cs.opts, cs.config)
if req.ok():
rs.add_req(req)
else:
rs.not_usable()
# Modules must only be handled when there are some requirements.
if len(rs.reqs)>0:
rs.handle_modules()
def test_simple_06(self):
"Requirement: Module test with exception thrown"
mstderr = StringIO.StringIO()
init_logger(mstderr)
mods = InputModules(os.path.join(mod_base_dir, "modules06"), {}, [],
mods_list("modules06", mod_base_dir))
req = Requirement("Name: t\n", 77, None, mods, TestConfig())
lstderr = hide_lineno(hide_timestamp(mstderr.getvalue()))
tear_down_log_handler()
self.assertEqual(req.is_usable(), False)
expected_result = "===DATETIMESTAMP===;rmtoo;ERROR;BaseRMObject;" \
"handle_modules_tag;===SOURCELINENO===; 55:TCExcept\n" \
"===DATETIMESTAMP===;rmtoo;ERROR;BaseRMObject;handle_modules_tag;" \
"===SOURCELINENO===; 41:77:" \
"semantic error occurred in module [Module01]\n"
self.assertEqual(lstderr, expected_result)
def rmttest_positive_01(self):
"Requirement: parser returns error"
try:
Requirement("DTag: content1\n"
"DTag: content2\n", "1", None, None, TestConfig())
assert (False)
except RMTException as rmte:
assert (rmte.get_id() == 81)
def test_simple_06(self):
"Requirement: Module test with exception thrown"
mstderr = StringIO.StringIO()
init_logger(mstderr)
mods = InputModules(os.path.join(mod_base_dir, "modules06"),
{}, [], mods_list("modules06", mod_base_dir))
req = Requirement("Name: t\n", 77, None, mods, TestConfig())
lstderr = hide_lineno(hide_timestamp(mstderr.getvalue()))
tear_down_log_handler()
self.assertEqual(req.is_usable(), False)
expected_result = "===DATETIMESTAMP===;rmtoo;ERROR;BaseRMObject;" \
"handle_modules_tag;===SOURCELINENO===; 55:TCExcept\n" \
"===DATETIMESTAMP===;rmtoo;ERROR;BaseRMObject;handle_modules_tag;" \
"===SOURCELINENO===; 41:77:" \
"semantic error occurred in module [Module01]\n"
self.assertEqual(lstderr, expected_result)
def test_negative_03(self):
"Normal requirement has no 'Depends on'"
config = TestConfig()
imod = InputModules("..", config)
reqset = RequirementSet(config)
req1 = Requirement('''Name: A
Type: master requirement''', 'A', None, imod, config)
reqset.add_node(RequirementDNode(req1))
req2 = Requirement('''Name: B
Type: requirement''', 'B', None, imod, config)
reqset.add_node(RequirementDNode(req2))
config.set_depends_on()
rdep = RDepDependsOn(config)
status = rdep.rewrite(reqset)
assert (status == False)
def rmttest_negative_04(self):
"Normal requirement has empty 'Depends on'"
config = TestConfig()
imod = InputModules(config)
reqset = RequirementSet(config)
req1 = Requirement('''Name: A
Type: master requirement''', 'A', None, imod, config)
reqset.add_requirement(req1)
req2 = Requirement('''Name: B
Type: requirement
Depends on:''', 'B', None, imod, config)
reqset.add_requirement(req2)
config.set_depends_on()
rdep = RDepDependsOn(config)
status = rdep.rewrite(reqset)
self.assertFalse(status)
def rmttest_negative_07(self):
"'Depends on' points to same requirement"
config = TestConfig()
imod = InputModules(config)
reqset = RequirementSet(config)
req1 = Requirement('''Name: A
Type: master requirement''', 'A', None, imod, config)
reqset.add_requirement(req1)
req2 = Requirement('''Name: B
Type: requirement
Depends on: B''', 'B', None, imod, config)
reqset.add_requirement(req2)
config.set_depends_on()
rdep = RDepDependsOn(config)
status = rdep.rewrite(reqset)
assert not status
def __read_requirements(self, input_handler, commit):
'''Reads in all the requirements from the input_handler.'''
tracer.debug("called")
filenames = input_handler.get_file_names(commit, "requirements")
print("FILENAMES [%s]" % filenames)
for filename in filenames:
# Check for correct filename
m = re.match("^.*\.req$", filename)
if m == None:
tracer.info("skipping file [%s]" % filename)
continue
# Handle caching.
vcs_id = input_handler.get_vcs_id(commit, filename)
rid = filename[:-4]
print("RID [%s]" % rid)
assert False
req = self.__object_cache.get("Requirement", vcs_id)
if req != None:
# Double check the id
if req.get_id() != rid:
# TODO: exception
assert False
else:
fd = input_handler.get_fd(commit, filename)
req = Requirement(fd, rid, self, self.__input_mods, self.__config)
# Add the requirement to the cache.
self.__object_cache.add(vcs_id, "Requirement", req)
if req.ok():
# Store in the map, so that it is easy to access the
# node by id.
self.__requirements[req.get_id()] = req
# Also store it in the digraph's node list for simple
# access to the digraph algorithms.
# TODO: self.nodes.append(req)
else:
self.error(45, "could not be parsed", req.id)
everythings_fine = False
def rmttest_neg_02(self):
"LaTeX output: check invalid tag in requirement output config"
tcfg = TestConfig()
tcfg.set_output_cfg()
# ToDo: is this needed? tvcs = TestVCS(tcfg)
# ToDo: is this needed? tfile = tvcs.get_tfile1()
tmpdir = create_tmp_dir()
mconfig = {
"req_attributes": ["Status", "Class", "DoesNotExists"],
"output_filename": os.path.join(tmpdir, "TestLateX2Out.tex")
}
out_l2 = latex2(mconfig)
req = Requirement(None, u"TestReq", None, None, None)
req.values = {}
req.values[u"Name"] = RecordEntry(u"Name", u"my name")
req.values[u"Type"] = RequirementType.requirement
req.values[u"Description"] = RecordEntry(u"Description", u"my desc")
req.values[u"Status"] = RequirementStatusFinished(
None, u"rid", u"finished:meiner:2011-04-15:4h")
req.values[u"Class"] = ClassTypeImplementable()
ce3set = CE3Set()
ce3 = CE3()
ce3set.insert(u"TestReq", ce3)
rset = RequirementSet(tcfg)
ttopic_set = TestTopicSet(rset)
try:
out_l2.topic_set_pre(None)
req.execute(out_l2, "")
assert False
except RMTException:
pass
out_l2.topic_set_post(ttopic_set)
delete_tmp_dir(tmpdir)
def test_neg_02(self):
"LaTeX output: check invalid tag in requirement output config"
fd = StringIO.StringIO()
mconfig = { "req_attributes": ["Status", "Class", "DoesNotExists"],
"output_filename": "/please/ignore/me"}
l2 = latex2(None, mconfig)
req = Requirement(None, "TestReq", None, None, None)
req.values = {}
req.values["Name"] = RecordEntry("Name", "my name")
req.values["Description"] = RecordEntry("Description", "my desc")
req.values["Status"] = RequirementStatusFinished(
None, "rid", "finished:meiner:2011-04-15:4h")
req.values["Class"] = ClassTypeImplementable()
ce3set = CE3Set()
ce3 = CE3()
ce3set.insert("TestReq", ce3)
try:
l2.output_requirement(fd, req, 2, ce3set)
assert(False)
except RMTException, rmte:
pass
def test_positive_03(self):
"Four node digraph D -> B -> A and D -> C -> A"
config = TestConfig()
reqset = RequirementSet(config)
req1 = Requirement(
'''Name: A
Type: master requirement
Solved by: B C''', 'A', None, None, None)
reqset.add_node(RequirementDNode(req1))
req2 = Requirement('''Name: B
Type: requirement
Solved by: D''', 'B', None, None, None)
reqset.add_node(RequirementDNode(req2))
req3 = Requirement('''Name: C
Type: requirement
Solved by: D''', 'C', None, None, None)
reqset.add_node(RequirementDNode(req3))
req4 = Requirement('''Name: D
Type: requirement''', 'D', None, None, None)
reqset.add_node(RequirementDNode(req4))
reqset.resolve_solved_by()
reqset.find_master_nodes()
reqset.graph_master_node = reqset.find("A")
reqset.find("A").get_requirement().set_value("Factor", 1.0)
reqset.find("B").get_requirement().set_value("Factor", 0.2)
reqset.find("C").get_requirement().set_value("Factor", 0.4)
reqset.find("D").get_requirement().set_value("Factor", 0.5)
rdep = RDepPriority(config)
rdep.rewrite(reqset)
assert (
reqset.find("A").get_requirement().get_value("Priority") == 1.0)
assert (
reqset.find("B").get_requirement().get_value("Priority") == 0.2)
assert (
reqset.find("C").get_requirement().get_value("Priority") == 0.4)
assert (
reqset.find("D").get_requirement().get_value("Priority") == 0.2)
def deprecated_read(self, directory):
everythings_fine = True
files = os.listdir(directory)
for f in files:
m = re.match("^.*\.req$", f)
if m == None:
continue
rid = f[:-4]
fd = codecs.open(os.path.join(directory, f), "r", "utf-8")
req = Requirement(fd, rid, self, self.mods, self.config)
if req.ok():
# Store in the map, so that it is easy to access the
# node by id.
self.reqs[req.id] = req
# Also store it in the digraph's node list for simple
# access to the digraph algorithms.
self.nodes.append(req)
else:
self.error(45, "could not be parsed", req.id)
everythings_fine = False
self.ts = time.time()
return everythings_fine
def rmttest_neg_02(self):
"LaTeX output: check invalid tag in requirement output config"
tcfg = TestConfig()
tcfg.set_output_cfg()
# ToDo: is this needed? tvcs = TestVCS(tcfg)
# ToDo: is this needed? tfile = tvcs.get_tfile1()
tmpdir = create_tmp_dir()
mconfig = {"req_attributes": ["Status", "Class", "DoesNotExists"],
"output_filename":
os.path.join(tmpdir, "TestLateX2Out.tex")}
out_l2 = latex2(mconfig)
req = Requirement(None, u"TestReq", None, None, None)
req.values = {}
req.values[u"Name"] = RecordEntry(u"Name", u"my name")
req.values[u"Type"] = RequirementType.requirement
req.values[u"Description"] = RecordEntry(u"Description", u"my desc")
req.values[u"Status"] = RequirementStatusFinished(
None, u"rid", u"finished:meiner:2011-04-15:4h")
req.values[u"Class"] = ClassTypeImplementable()
ce3set = CE3Set()
ce3 = CE3()
ce3set.insert(u"TestReq", ce3)
rset = RequirementSet(tcfg)
ttopic_set = TestTopicSet(rset)
try:
out_l2.topic_set_pre(None)
req.execute(out_l2, "")
assert False
except RMTException:
pass
out_l2.topic_set_post(ttopic_set)
delete_tmp_dir(tmpdir)
def test_negative_01(self):
"Master requirement with Depends on field"
config = TestConfig()
imod = InputModules("..", config)
reqset = RequirementSet(config)
req1 = Requirement(
'''Name: A
Type: master requirement
Depends on: A''', 'A', None, imod, config)
reqset.add_node(RequirementDNode(req1))
config.set_depends_on()
rdep = RDepDependsOn(config)
status = rdep.rewrite(reqset)
assert (status == False)
def create_req(req_id):
req_txt_items = {}
inv_date = datetime.strptime('1970-01-01', "%Y-%m-%d").date()
req_values = {
'Name': 'Aston Martin DB5',
'Topic': 'Escape Routes',
'Description': "Flying out the roof",
'Priority': 'development',
'Owner': '007',
'Invented on': inv_date.isoformat(),
'Invented by': 'Q',
'Status': 'not done',
'Class': 'requirement'
}
req = Requirement(u"", req_id, None, None, TestConfig())
for key, value in req_values.items():
req.record.append(MockRecordEntry(key, value))
req_txt_items[key] = MockRecordEntry(None, value)
req_txt_items['Invented on'] = inv_date
req.values.update(req_txt_items)
return req
def test_neg_02(self):
"LaTeX output: check invalid tag in requirement output config"
tcfg = TestConfig()
tcfg.set_output_cfg()
tvcs = TestVCS(tcfg)
tfile = tvcs.get_tfile1()
tmpdir = create_tmp_dir()
mconfig = { "req_attributes": ["Status", "Class", "DoesNotExists"],
"output_filename": os.path.join(tmpdir, "TestLateX2Out.tex")}
l2 = latex2(mconfig)
req = Requirement(None, "TestReq", None, None, None)
req.values = {}
req.values["Name"] = RecordEntry("Name", "my name")
req.values["Type"] = Requirement.rt_requirement
req.values["Description"] = RecordEntry("Description", "my desc")
req.values["Status"] = RequirementStatusFinished(
None, "rid", "finished:meiner:2011-04-15:4h")
req.values["Class"] = ClassTypeImplementable()
dnreq = RequirementDNode(req)
ce3set = CE3Set()
ce3 = CE3()
ce3set.insert("TestReq", ce3)
rset = RequirementSet(tcfg)
ttopic_set = TestTopicSet(rset)
try:
l2.topic_set_pre(None)
dnreq.execute(l2, "")
assert(False)
except RMTException, rmte:
pass
def rmttest_positive_02(self):
"Requirement contains a tag where no handler exists - multiple tags"
mstderr = StringIO()
init_logger(mstderr)
tc = TestConfig()
tc.set_solved_by()
mods = InputModules(tc)
reqs = RequirementSet(None)
req = Requirement("Hubbel: bubbel\nSiebel: do", "InvalidTagReq", reqs,
mods, tc)
reqs.add_requirement(req)
reqs._handle_modules(mods)
lstderr = hide_volatile(mstderr.getvalue())
tear_down_log_handler()
lstderr_last_two_lines = lstderr.split("\n")[-3:-1]
result0 \
= re.match(
"^===DATETIMESTAMP===;rmtoo;ERROR;RequirementSet;"
"__all_tags_handled;===LINENO===; 57:InvalidTagReq:"
"No tag handler found "
"for tag\(s\) '\[.*\]' - Hint: typo in tag\(s\)\?$",
lstderr_last_two_lines[0])
result1 \
= re.match(
"^===DATETIMESTAMP===;rmtoo;ERROR;RequirementSet;"
"_handle_modules;"
"===LINENO===; 56:There were errors encountered "
"during parsing "
"and checking - can't continue.$",
lstderr_last_two_lines[1])
assert result0
assert result1
def __init__(self, d=None):
Digraph.__init__(
self, d, lambda nname: Requirement(None, nname, None, None, None))
def rmttest_def_req(self):
"LaTeX output: compare output to defined value"
exp_value = r"""
\paragraph{my name}
\hypertarget{TestReq}{TestReq}
\label{TestReq}
my desc
\textbf{Rationale:}
\textbf{Note:}
\par{\small \begin{center}
\begin{tabular}{rlrlrl}
Id: & TestReq & Priority: & & Owner: & \\
Invented on: & & Invented by: & & Status: & finished (meiner, 2011-04-15, 4 h) \\
Class: & implementable
\end{tabular}\end{center}
}
""" # noqa
tcfg = TestConfig()
tcfg.set_output_cfg()
mconfig = self.__def_mconfig
mconfig['req_attributes'] = ["Status", "Class", "DoesNotExists"]
req_proc = latex2(mconfig)
req = Requirement(None, u"TestReq", None, None, None)
req.values = {}
req.values[u"Name"] = RecordEntry(u"Name", u"my name")
req.values[u"Type"] = RequirementType.requirement
req.values[u"Description"] = RecordEntry(u"Description", u"my desc")
req.values[u"Status"] = RequirementStatusFinished(
None, u"rid", u"finished:meiner:2011-04-15:4h")
req.values[u"Class"] = ClassTypeImplementable()
ce3set = CE3Set()
ce3 = CE3()
ce3set.insert(u"TestReq", ce3)
''' This is here for future? use.
rset = RequirementSet(tcfg)
ttopic_set = TestTopicSet(rset)
'''
req_text = req_proc._get_requirement(req)
try:
assert req_text == exp_value
except AssertionError:
import difflib
diff = difflib.ndiff(
req_text.splitlines(True),
exp_value.splitlines(True))
print(''.join(diff))
raise Exception("The template is not equal to it's expected value")
def requirement(self, req):
'''Write out one requirement.'''
self.__fd.write("%% REQ '%s'\n" % req.get_name())
self.__fd.write("\%s{%s}\label{%s}\n\\textbf{Description:} %s\n"
% (self.level_names[self.__level + 1],
req.get_requirement().get_value("Name").get_content(),
latex2.__strescape(req.get_name()),
req.get_requirement().get_value("Description").get_content()))
if req.get_requirement().is_val_av_and_not_null("Rationale"):
self.__fd.write("\n\\textbf{Rationale:} %s\n"
% req.get_requirement().get_value("Rationale").get_content())
if req.get_requirement().is_val_av_and_not_null("Note"):
self.__fd.write("\n\\textbf{Note:} %s\n"
% req.get_requirement().get_value("Note").get_content())
# Only output the depends on when there are fields for output.
if req.get_outgoing_cnt() > 0:
# Create links to the corresponding labels.
self.__fd.write("\n\\textbf{Depends on:} ")
self.__fd.write(", ".join(["\\ref{%s} \\nameref{%s}" %
(latex2.__strescape(d.get_name()),
latex2.__strescape(d.get_name()))
for d in sorted(req.get_iter_outgoing(),
key=lambda r: r.get_name())]))
self.__fd.write("\n")
if req.get_incoming_cnt() > 0:
# Create links to the corresponding dependency nodes.
self.__fd.write("\n\\textbf{Solved by:} ")
# No comma at the end.
self.__fd.write(", ".join(["\\ref{%s} \\nameref{%s}" %
(latex2.__strescape(d.get_name()),
latex2.__strescape(d.get_name()))
for d in sorted(req.get_iter_incoming(),
key=lambda r: r.get_name())]))
self.__fd.write("\n")
tracer.debug("Output constraints")
if self.__ce3set != None:
cnstrt = self.__ce3set.get(req.get_name())
tracer.debug("Constraints are available [%s]" % cnstrt)
tracer.debug("Check constraint header output [%s]" %
cnstrt.len())
if cnstrt != None and cnstrt.len() > 0:
tracer.debug("Output constraint header")
self.__fd.write("\n\\textbf{Constraints:} ")
cstrs = []
for key, val in sorted(cnstrt.get_values().iteritems()):
refid = latex2.__strescape(key)
tracer.debug("Output constraint [%s]" % refid)
refctr = "\\ref{CONSTRAINT%s} \\nameref{CONSTRAINT%s}" \
% (refid, refid)
description = val.description()
if description != None:
refctr += " [" + description + "] "
cstrs.append(refctr)
# Also put a reference (for later use) in the
# constraints to requirements ref.
self.__add_constraint_req_ref(refid,
req.get_requirement().get_id())
self.__fd.write(", ".join(cstrs))
self.__fd.write("\n")
testcases = req.get_requirement().get_value_default("Test Cases")
if testcases != None:
self.__fd.write("\n\\textbf{Test Cases:} ")
tcout = []
for testcase in testcases:
refid = latex2.__strescape(testcase)
refctr = "\\ref{TESTCASE%s} \\nameref{TESTCASE%s}" \
% (refid, refid)
tcout.append(refctr)
self.__fd.write(", ".join(tcout))
self.__fd.write("\n")
status = req.get_requirement().get_value("Status").get_output_string()
clstr = req.get_requirement().get_value("Class").get_output_string()
rtype = Requirement.get_type_as_str(req.get_requirement().get_value("Type"))
self.__fd.write("\n\\par\n{\small \\begin{center}"
"\\begin{tabular}{rlrlrl}\n")
# Put mostly three things in a line.
i = 0
for rattr in self._config.get_value("req_attributes"):
if rattr == "Id":
self.__fd.write("\\textbf{Id:} & %s " % req.get_name())
elif rattr == "Priority":
self.__fd.write("\\textbf{Priority:} & %4.2f "
% (req.get_requirement().get_value("Priority") * 10))
elif rattr == "Owner":
self.__fd.write("\\textbf{Owner:} & %s" %
req.get_requirement().get_value("Owner"))
elif rattr == "Invented on":
self.__fd.write("\\textbf{Invented on:} & %s "
% req.get_requirement().get_value("Invented on").strftime("%Y-%m-%d"))
elif rattr == "Invented by":
self.__fd.write("\\textbf{Invented by:} & %s "
% req.get_requirement().get_value("Invented by"))
elif rattr == "Status":
self.__fd.write("\\textbf{Status:} & %s " % status)
elif rattr == "Class":
self.__fd.write("\\textbf{Class:} & %s " % clstr)
elif rattr == "Type":
self.__fd.write("\\textbf{Type:} & %s " % rtype)
else:
# This only happens when a wrong configuration is supllied.
raise RMTException(85, "Wrong latex2 output configuration "
"supplied: unknown tag [%s]" % rattr)
i += 1
if i == 3:
i = 0
self.__fd.write("\\\ \n")
else:
self.__fd.write(" & ")
while i < 2:
self.__fd.write("& & ")
i += 1
self.__fd.write("\end{tabular}\end{center} }\n\n")
def requirement(self, req):
"""Write out one requirement."""
self.__fd.write("%% REQ '%s'\n" % req.id)
self.__fd.write(
"\%s{%s}\label{%s}\n\\textbf{Description:} %s\n"
% (
self.level_names[self.__level + 1],
req.get_value("Name").get_content(),
latex2.__strescape(req.id),
req.get_value("Description").get_content(),
)
)
if req.is_val_av_and_not_null("Rationale"):
self.__fd.write("\n\\textbf{Rationale:} %s\n" % req.get_value("Rationale").get_content())
if req.is_val_av_and_not_null("Note"):
self.__fd.write("\n\\textbf{Note:} %s\n" % req.get_value("Note").get_content())
# Only output the depends on when there are fields for output.
if len(req.incoming) > 0:
# Create links to the corresponding labels.
self.__fd.write("\n\\textbf{Depends on:} ")
self.__fd.write(
", ".join(
[
"\\ref{%s} \\nameref{%s}" % (latex2.__strescape(d.id), latex2.__strescape(d.id))
for d in sorted(req.incoming, key=lambda r: r.id)
]
)
)
self.__fd.write("\n")
if len(req.outgoing) > 0:
# Create links to the corresponding dependency nodes.
self.__fd.write("\n\\textbf{Solved by:} ")
# No comma at the end.
self.__fd.write(
", ".join(
[
"\\ref{%s} \\nameref{%s}" % (latex2.__strescape(d.id), latex2.__strescape(d.id))
for d in sorted(req.outgoing, key=lambda r: r.id)
]
)
)
self.__fd.write("\n")
if self.__ce3set != None:
cnstrt = self.__ce3set.get(req.get_id())
if cnstrt != None and cnstrt.len() > 0:
self.__fd.write("\n\\textbf{Constraints:} ")
cstrs = []
for key, val in sorted(cnstrt.get_values().iteritems()):
refid = latex2.__strescape(key)
refctr = "\\ref{CONSTRAINT%s} \\nameref{CONSTRAINT%s}" % (refid, refid)
description = val.description()
if description != None:
refctr += " [" + description + "] "
cstrs.append(refctr)
self.__fd.write(", ".join(cstrs))
self.__fd.write("\n")
testcases = req.get_value_default("Test Cases")
if testcases != None:
self.__fd.write("\n\\textbf{Test Cases:} ")
tcout = []
for testcase in testcases:
refid = latex2.__strescape(testcase)
refctr = "\\ref{TESTCASE%s} \\nameref{TESTCASE%s}" % (refid, refid)
tcout.append(refctr)
self.__fd.write(", ".join(tcout))
self.__fd.write("\n")
status = req.get_value("Status").get_output_string()
# HACK: Remove annoying parenthesis
status = status.split("(")[0]
clstr = req.get_value("Class").get_output_string()
rtype = Requirement.get_type_as_str(req.get_value("Type"))
self.__fd.write("\n\\textbf{Status:} %s" % status)
def requirement(self, req):
'''Write out one requirement.'''
self.__fd.write("%% REQ '%s'\n" % req.id)
self.__fd.write(
"\%s{%s}\label{%s}\n\\textbf{Description:} %s\n" %
(self.level_names[self.__level + 1],
req.get_value("Name").get_content(), latex2.__strescape(
req.id), req.get_value("Description").get_content()))
if req.is_val_av_and_not_null("Rationale"):
self.__fd.write("\n\\textbf{Rationale:} %s\n" %
req.get_value("Rationale").get_content())
if req.is_val_av_and_not_null("Note"):
self.__fd.write("\n\\textbf{Note:} %s\n" %
req.get_value("Note").get_content())
# Only output the depends on when there are fields for output.
if len(req.incoming) > 0:
# Create links to the corresponding labels.
self.__fd.write("\n\\textbf{Depends on:} ")
self.__fd.write(", ".join([
"\\ref{%s} \\nameref{%s}" %
(latex2.__strescape(d.id), latex2.__strescape(d.id))
for d in sorted(req.incoming, key=lambda r: r.id)
]))
self.__fd.write("\n")
if len(req.outgoing) > 0:
# Create links to the corresponding dependency nodes.
self.__fd.write("\n\\textbf{Solved by:} ")
# No comma at the end.
self.__fd.write(", ".join([
"\\ref{%s} \\nameref{%s}" %
(latex2.__strescape(d.id), latex2.__strescape(d.id))
for d in sorted(req.outgoing, key=lambda r: r.id)
]))
self.__fd.write("\n")
if self.__ce3set != None:
cnstrt = self.__ce3set.get(req.get_id())
if cnstrt != None and cnstrt.len() > 0:
self.__fd.write("\n\\textbf{Constraints:} ")
cstrs = []
for key, val in sorted(cnstrt.get_values().iteritems()):
refid = latex2.__strescape(key)
refctr = "\\ref{CONSTRAINT%s} \\nameref{CONSTRAINT%s}" \
% (refid, refid)
description = val.description()
if description != None:
refctr += " [" + description + "] "
cstrs.append(refctr)
self.__fd.write(", ".join(cstrs))
self.__fd.write("\n")
testcases = req.get_value_default("Test Cases")
if testcases != None:
self.__fd.write("\n\\textbf{Test Cases:} ")
tcout = []
for testcase in testcases:
refid = latex2.__strescape(testcase)
refctr = "\\ref{TESTCASE%s} \\nameref{TESTCASE%s}" \
% (refid, refid)
tcout.append(refctr)
self.__fd.write(", ".join(tcout))
self.__fd.write("\n")
status = req.get_value("Status").get_output_string()
# HACK: Remove annoying parenthesis
status = status.split('(')[0]
clstr = req.get_value("Class").get_output_string()
rtype = Requirement.get_type_as_str(req.get_value("Type"))
self.__fd.write("\n\\textbf{Status:} %s" % status)
