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 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 test_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_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()
req3 = Requirement('''Name: C
Type: requirement
Depends on: A B''', 'C', None, imod, config)
reqset.add_node(RequirementDNode(req3))
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() == ["C", "B"])
assert(reqset.get_requirement("B").get_incoming_as_named_list() == ["A"])
assert(reqset.get_requirement("B").get_outgoing_as_named_list() == ["C"])
assert(reqset.get_requirement("C").get_incoming_as_named_list() == ["A", "B"])
assert(reqset.get_requirement("C").get_outgoing_as_named_list() == [])
def main_impl(args, mstdout, mstderr):
opts, config, mods = MainHelper.main_setup(args, mstdout, mstderr,
parse_cmd_line_opts)
rs = RequirementSet(mods, opts, config)
return rs.read_from_filesystem(opts.args[0]) \
and rs.normalize_dependencies() \
and rs.write_to_filesystem(opts.args[0])
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 main_impl(args, mstdout, mstderr):
config, mods = MainHelper.main_setup(args, mstdout, mstderr)
rs = RequirementSet(mods, config)
command_line_args = config.get_value('general.command_line_arguments')
return rs.read_from_filesystem(command_line_args[0]) \
and rs.normalize_dependencies() \
and rs.write_to_filesystem(command_line_args[0])
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 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()
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_simple_07(self):
"RequirementSet: Module which renders set as errornous"
mods = Modules(os.path.join(mod_base_dir, "modules07"),
{}, {}, [], mods_list("modules07", mod_base_dir))
reqs = RequirementSet(mods, None, None)
reqs.handle_modules()
assert(reqs.state==RequirementSet.er_error)
sout = StringIO.StringIO()
reqs.write_log(sout)
assert(sout.getvalue()=="+++ Error: 43:there was a problem handling the requirement set modules\n")
def __read_requirement_set(self):
'''Reads in the requirement set.
First checks if this is already available in the object cache.'''
req_set_vcs_id = \
self.__input_handler.get_vcs_id_with_type(
self.__commit, "requirements")
req_set = self.__object_cache.get("RequirementSet", req_set_vcs_id)
if req_set == None:
req_set = RequirementSet(self._config)
req_set.read_requirements(self.__input_handler, self.__commit,
self.__input_mods, self.__object_cache)
self.__object_cache.add(req_set_vcs_id, "RequirementSet", req_set)
self._adapt_usablility(req_set)
self.__complete_requirement_set = req_set
def create_continuum_from_file(self):
rs = RequirementSet(self.mods, self.config)
#print("UNICODE???? [%s]" % self.config.get_value('requirements.input.directory'))
# TODO: Check if this is really unicode (already)
# TODO: Add a test case.
req_input_dir = self.config.get_value('requirements.input.directory')
if type(req_input_dir) == StringType:
req_input_dir = unicode(req_input_dir, "utf-8")
rs.read_from_filesystem(req_input_dir)
# rs.read_from_filesystem(
# self.config.get_value('requirements.input.directory'))
self.continuum_add("FILES", rs)
def main_impl(args, mstdout, mstderr):
tracer.debug("Called.")
config, mods = MainHelper.main_setup(args, mstdout, mstderr)
file_system_if = FileSystem(config)
object_cache = ObjectCache()
rs = RequirementSet(config)
command_line_args = config.get_rvalue('general.command_line_arguments')
rs.read_requirements(file_system_if, None, mods, object_cache)
return rs.normalize_dependencies() \
and rs.write_to_filesystem(command_line_args[0])
def __read_requirement_set(self):
'''Reads in the requirement set.
First checks if this is already available in the object cache.'''
req_set_vcs_id = \
self.__input_handler.get_vcs_id_with_type(
self.__commit, "requirements")
req_set = self.__object_cache.get("RequirementSet", req_set_vcs_id)
if req_set is None:
req_set = RequirementSet(self._config)
req_set.read_requirements(self.__input_handler, self.__commit,
self.__input_mods, self.__object_cache)
self.__object_cache.add(req_set_vcs_id,
"RequirementSet", req_set)
self._adapt_usablility(req_set)
self.__complete_requirement_set = req_set
def rmttest_neg_01(self):
"LaTeX output: check invalid tag in topic"
tcfg = TestConfig()
tcfg.set_output_cfg()
tvcs = TestVCS(tcfg)
tfile = tvcs.get_tfile1()
topic = Topic(None, u"TName", tvcs, None, tfile, None)
topic.t = [
RecordEntry(u"CompleteleOther", u"My content"),
]
rset = RequirementSet(tcfg)
ttopic_set = TestTopicSet(rset)
mconfig = self.__def_mconfig
req_proc = latex2(mconfig)
try:
req_proc.topic_set_pre(ttopic_set)
topic.execute(req_proc, "")
assert False
except RMTException:
pass
req_proc.topic_set_post(ttopic_set)
def rmttest_neg_01(self):
"LaTeX output: check invalid tag in topic"
tcfg = TestConfig()
tcfg.set_output_cfg()
tvcs = TestVCS(tcfg)
tfile = tvcs.get_tfile1()
topic = Topic(None, u"TName", tvcs, None, tfile, None)
topic.t = [
RecordEntry(u"CompleteleOther", u"My content"),
]
tmpdir = create_tmp_dir()
rset = RequirementSet(tcfg)
ttopic_set = TestTopicSet(rset)
mconfig = {
"output_filename": os.path.join(tmpdir, "TestLateX2Out.tex")
}
out_l2 = latex2(mconfig)
try:
out_l2.topic_set_pre(ttopic_set)
topic.execute(out_l2, "")
assert False
except RMTException:
pass
out_l2.topic_set_post(ttopic_set)
delete_tmp_dir(tmpdir)
def rmttest_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_requirement(req1)
config.set_depends_on()
rdep = RDepDependsOn(config)
status = rdep.rewrite(reqset)
assert not status
def test_simple_07(self):
"RequirementSet: Module which renders set as errornous"
mstderr = StringIO.StringIO()
init_logger(mstderr)
mods = InputModules(os.path.join(mod_base_dir, "modules07"), {}, [],
mods_list("modules07", mod_base_dir))
reqs = RequirementSet(None)
reqs._handle_modules(mods)
self.assertEqual(reqs.is_usable(), False)
lstderr = hide_lineno(hide_timestamp(mstderr.getvalue()))
tear_down_log_handler()
expected_result = "===DATETIMESTAMP===;rmtoo;ERROR;RequirementSet;" \
"_handle_modules;===SOURCELINENO===; 43:there was a problem handling the " \
"requirement set modules\n"
self.assertEqual(lstderr, expected_result)
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 main_func(args, mstdout, mstderr):
"""The 'real' main function.
Sets up everything, reads in the requirements and
writes out everything.
"""
tracer.debug("Called.")
config, mods = MainHelper.main_setup(args, mstdout, mstderr)
file_system_if = FileSystem(config)
object_cache = ObjectCache()
req_set = RequirementSet(config)
command_line_args = config.get_rvalue('general.command_line_arguments')
req_set.read_requirements(file_system_if, None, mods, object_cache)
return req_set.normalize_dependencies() \
and req_set.write_to_filesystem(command_line_args[0])
def test_simple_07(self):
"RequirementSet: Module which renders set as errornous"
mstderr = StringIO.StringIO()
init_logger(mstderr)
mods = InputModules(os.path.join(mod_base_dir, "modules07"),
{}, [], mods_list("modules07", mod_base_dir))
reqs = RequirementSet(None)
reqs._handle_modules(mods)
self.assertEqual(reqs.is_usable(), False)
lstderr = hide_lineno(hide_timestamp(mstderr.getvalue()))
tear_down_log_handler()
expected_result = "===DATETIMESTAMP===;rmtoo;ERROR;RequirementSet;" \
"_handle_modules;===SOURCELINENO===; 43:there was a problem handling the " \
"requirement set modules\n"
self.assertEqual(lstderr, expected_result)
def rmttest_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_requirement(req1)
req2 = Requirement('''Name: B
Type: requirement''', 'B', None, imod, config)
reqset.add_requirement(req2)
config.set_depends_on()
rdep = RDepDependsOn(config)
status = rdep.rewrite(reqset)
assert not status
def test_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_node(RequirementDNode(req1))
req2 = Requirement('''Name: B
Type: requirement
Depends on: B''', '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_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 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_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 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):
"""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 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(
r"^===DATETIMESTAMP===;rmtoo;ERROR;RequirementSet;"
r"__all_tags_handled;===LINENO===; 57:InvalidTagReq:"
r"No tag handler found "
r"for tag\(s\) '\[.*\]' - Hint: typo in tag\(s\)\?$",
lstderr_last_two_lines[0])
result1 \
= re.match(
r"^===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 rh_one_commit(self, cs, ci):
rs = RequirementSet(cs.mods, cs.opts, cs.config)
rs.set_version_id(ci.hexsha)
try:
files = ci.tree[self.reqs_subdir].blobs
except KeyError, ke:
# This means, that at this point of time the directory was
# not available.
rs.log(46, MemLog.error, "Path '%s' not available" %
self.reqs_subdir)
rs.not_usable()
return
def main_impl(args, mstdout, mstderr):
tracer.debug("Called.")
config, mods = MainHelper.main_setup(args, mstdout, mstderr)
file_system_if = FileSystem(config)
object_cache = ObjectCache()
rs = RequirementSet(config)
command_line_args = config.get_rvalue('general.command_line_arguments')
rs.read_requirements(file_system_if, None, mods, object_cache)
return rs.normalize_dependencies() \
and rs.write_to_filesystem(command_line_args[0])
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)
assert [] == reqset.get_requirement("A").incoming_as_named_list()
assert ["B"] == reqset.get_requirement("A").outgoing_as_named_list()
assert ["A"] == reqset.get_requirement("B").incoming_as_named_list()
assert [] == reqset.get_requirement("B").outgoing_as_named_list()
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"
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 test_positive_01(self):
"Requirement contains a tag where no handler exists"
mods = Modules(os.path.join(mod_base_dir, "modules08"),
{}, {}, [], mods_list("modules08", mod_base_dir))
sio = StringIO.StringIO("Hubbel: bubbel")
req = Requirement(sio, "hubbel", None, mods, None, TestConfig())
reqs = RequirementSet(mods, None, None)
reqs.add_req(req)
reqs.handle_modules()
assert(reqs.mls()==MemLogStore.create_mls(
[[57, MemLog.error, "No tag handler found for tag(s) "
"'['Hubbel']' - Hint: typo in tag(s)?", 'hubbel'],
[56, MemLog.error, "There were errors encountered during "
"parsing and checking - can't continue"] ] ))
def main_func(args, mstdout, mstderr):
"""The 'real' main function.
Sets up everything, reads in the requirements and
writes out everything.
"""
tracer.debug("Called.")
config, mods = MainHelper.main_setup(args, mstdout, mstderr)
file_system_if = FileSystem(config)
object_cache = ObjectCache()
req_set = RequirementSet(config)
command_line_args = config.get_rvalue('general.command_line_arguments')
req_set.read_requirements(file_system_if, None, mods, object_cache)
return req_set.normalize_dependencies() \
and req_set.write_to_filesystem(command_line_args[0])
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 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 test_positive_02(self):
"Requirement contains a tag where no handler exists - multiple tags"
mods = Modules(os.path.join(mod_base_dir, "modules08"),
{}, {}, [], mods_list("modules08", mod_base_dir))
sio = StringIO.StringIO("Hubbel: bubbel\nSiebel: do")
req = Requirement(sio, "InvalidTagReq", None, mods, None, TestConfig())
reqs = RequirementSet(mods, None, None)
reqs.add_req(req)
reqs.handle_modules()
#o = StringIO.StringIO()
#reqs.write_log(o)
#print("HHHHHHHHHHH %s" % o.getvalue())
assert(reqs.mls()==MemLogStore.create_mls(
[[57, MemLog.error, "No tag handler found for tag(s) "
"'['Siebel', 'Hubbel']' - Hint: typo in tag(s)?",
'InvalidTagReq'],
[56, MemLog.error, "There were errors encountered during "
"parsing and checking - can't continue"]] ))
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 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 test_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_node(RequirementDNode(req1))
req2 = Requirement('''Name: B
Type: requirement
Solved by: C''', 'B', None, None, None)
reqset.add_node(RequirementDNode(req2))
req3 = Requirement('''Name: C
Type: requirement''', 'C', None, None, None)
reqset.add_node(RequirementDNode(req3))
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)
reqset.find("C").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.8)
assert (
reqset.find("C").get_requirement().get_value("Priority") == 0.4)
def rmttest_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_requirement(req1)
req2 = Requirement('''Name: B
Type: requirement''', 'B', None, None, None)
reqset.add_requirement(req2)
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)
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")
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_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_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 rmttest_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_requirement(req1)
req2 = Requirement('''Name: B
Type: requirement
Solved by: D''', 'B', None, None, None)
reqset.add_requirement(req2)
req3 = Requirement('''Name: C
Type: requirement
Solved by: D''', 'C', None, None, None)
reqset.add_requirement(req3)
req4 = Requirement('''Name: D
Type: requirement''', 'D', None, None, None)
reqset.add_requirement(req4)
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.2)
reqset.get_named_node("C").set_value("Factor", 0.4)
reqset.get_named_node("D").set_value("Factor", 0.5)
rdep = RDepPriority(config)
rdep.rewrite(reqset)
assert 1.0 == reqset.get_named_node("A").get_value("Priority")
assert 0.2 == reqset.get_named_node("B").get_value("Priority")
assert 0.4 == reqset.get_named_node("C").get_value("Priority")
assert 0.2 == reqset.get_named_node("D").get_value("Priority")
def create_continuum_from_file(self):
rs = RequirementSet(self.mods, self.opts, self.config)
rs.read_from_filesystem(
unicode(self.config.reqs_spec["directory"], "utf-8"))
self.continuum_add("FILES", rs)
