diff --git a/Tst/codeblockreusefeature/add_dummy_data.py b/Tst/codeblockreusefeature/add_dummy_data.py
index b5de674e7f25a3494e6fe0589a4027f8828c9fc1..35dd3ab8a5158dc698a153edb90a9a276f0c7d2a 100644
--- a/Tst/codeblockreusefeature/add_dummy_data.py
+++ b/Tst/codeblockreusefeature/add_dummy_data.py
@@ -1,53 +1,70 @@
import db_schema
-from db_schema import CodeBlock, CodeTestSpec, CodeStep
+#from db_schema import CodeBlock, CodeTestSpec, CodeStep
+from db_schema import CodeBlock, Pre_Post_Con
# from db_schema import CodeBlock, CodeKind
# import db_interaction
def dummy_data_code_block():
session.add_all([
- CodeBlock(code_type="snippet",
- description="Use TC(3,6) to disable the generation of the IFSW_HK housekeeping report",
- command_code="# sending a TC(3,6) to disable IFSW_HK housekeeping\ntc_dis = ccs.Tcsend_DB('DPU_IFSW_DIS_HK_DR_GEN', 1, ack='0b1011', pool_name=pool_name)\ntc_id = tcid.TcId(st=3, sst=6, apid=tc_dis[0], ssc=tc_dis[1], timestamp=tc_dis[2])\n'"),
- CodeBlock(code_type="snippet",
- description="Enable the HK",
- command_code="# send TC(3,5)\nccs.Tcsend_DB('DPU_IFSW_ENB_HK_DR_GEN', 1, ack='0b1011', pool_name=pool_name)\n# send TC(3,131)\nccs.Tcsend_DB('DPU_IFSW_SET_HK_REP_FREQ', 1, 8*4, ack='0b1011', pool_name=pool_name)\n"),
- CodeBlock(code_type="snippet",
- description="verify that all three acknowledgements are received",
- command_code="tc_dis = tc_id.tc_id_tuple()\n# check if the TC was successful\nresult = tm.check_acknowledgement(ccs=ccs, pool_name=pool_name, tc_identifier=tc_dis)"),
+ #CodeBlock(code_type="snippet",
+ # description="Use TC(3,6) to disable the generation of the IFSW_HK housekeeping report",
+ # command_code="# sending a TC(3,6) to disable IFSW_HK housekeeping\ntc_dis = ccs.Tcsend_DB('DPU_IFSW_DIS_HK_DR_GEN', 1, ack='0b1011', pool_name=pool_name)\ntc_id = tcid.TcId(st=3, sst=6, apid=tc_dis[0], ssc=tc_dis[1], timestamp=tc_dis[2])\n'"),
+ #CodeBlock(code_type="snippet",
+ # description="Enable the HK",
+ # command_code="# send TC(3,5)\nccs.Tcsend_DB('DPU_IFSW_ENB_HK_DR_GEN', 1, ack='0b1011', pool_name=pool_name)\n# send TC(3,131)\nccs.Tcsend_DB('DPU_IFSW_SET_HK_REP_FREQ', 1, 8*4, ack='0b1011', pool_name=pool_name)\n"),
+ #CodeBlock(code_type="snippet",
+ # description="verify that all three acknowledgements are received",
+ # command_code="tc_dis = tc_id.tc_id_tuple()\n# check if the TC was successful\nresult = tm.check_acknowledgement(ccs=ccs, pool_name=pool_name, tc_identifier=tc_dis)"),
CodeBlock(code_type="step",
description="A step consists out ouf command and verification",
- command_code="tc_dis = tc_id.tc_id_tuple()\n",
- verification_code="# check if the TC was successful\nresult = tm.check_acknowledgement(ccs=ccs, pool_name=pool_name, tc_identifier=tc_dis)")
- ])
-
+ comment="This is just a comment for this step",
+ command_code="print('This is the command code')\n",
+ verification_code="print('This is the verification code')",
+ verification_descr="I am describing the verifcation"),
+ CodeBlock(code_type="snippet",
+ description="Increase the HK Frequency",
+ comment="Increase the Frequncy to 1 HK per second",
+ command_code="cfl.Tcsend_DB('SASW ModHkPeriodCmd', 1, 8, pool_name='new_tmtc_pool')"),
+ Pre_Post_Con(type="pre",
+ name="None",
+ description="No Pre-Condition needed",
+ condition="logger.info('No pre-conditions have been given')\nsuccess = True"),
+ Pre_Post_Con(type="post",
+ name="None",
+ description="No Post-Condition needed",
+ condition="logger.info('No post-conditions have been given')\nsuccess = True")
-def dummy_data_steps():
- session.add_all([
- CodeStep(
- code_type="snippet",
- description="Use TC(3,6) to disable the generation of the IFSW_HK housekeeping report",
- command_code="# sending a TC(3,6) to disable IFSW_HK housekeeping\ntc_dis = ccs.Tcsend_DB('DPU_IFSW_DIS_HK_DR_GEN', 1, ack='0b1011', pool_name=pool_name)\ntc_id = tcid.TcId(st=3, sst=6, apid=tc_dis[0], ssc=tc_dis[1], timestamp=tc_dis[2])\n'",
- test_spec=1),
- CodeStep(
- code_type="snippet",
- description="Enable the HK",
- command_code="# send TC(3,5)\nccs.Tcsend_DB('DPU_IFSW_ENB_HK_DR_GEN', 1, ack='0b1011', pool_name=pool_name)\n# send TC(3,131)\nccs.Tcsend_DB('DPU_IFSW_SET_HK_REP_FREQ', 1, 8*4, ack='0b1011', pool_name=pool_name)\n",
- test_spec=1),
- CodeStep(
- code_type="snippet",
- description="verify that all three acknowledgements are received",
- command_code="tc_dis = tc_id.tc_id_tuple()\n# check if the TC was successful\nresult = tm.check_acknowledgement(ccs=ccs, pool_name=pool_name, tc_identifier=tc_dis)",
- test_spec=1),
- CodeStep(
- code_type="step",
- description="A step consists out ouf command and verification",
- command_code="tc_dis = tc_id.tc_id_tuple()\n",
- verification_code="# check if the TC was successful\nresult = tm.check_acknowledgement(ccs=ccs, pool_name=pool_name, tc_identifier=tc_dis)",
- test_spec=1)
])
+# No longer used, everything in codeblocks data table
+#def dummy_data_steps():
+# session.add_all([
+# CodeStep(
+# code_type="snippet",
+# description="Use TC(3,6) to disable the generation of the IFSW_HK housekeeping report",
+# command_code="# sending a TC(3,6) to disable IFSW_HK housekeeping\ntc_dis = ccs.Tcsend_DB('DPU_IFSW_DIS_HK_DR_GEN', 1, ack='0b1011', pool_name=pool_name)\ntc_id = tcid.TcId(st=3, sst=6, apid=tc_dis[0], ssc=tc_dis[1], timestamp=tc_dis[2])\n'",
+# test_spec=1),
+# CodeStep(
+# code_type="snippet",
+# description="Enable the HK",
+# command_code="# send TC(3,5)\nccs.Tcsend_DB('DPU_IFSW_ENB_HK_DR_GEN', 1, ack='0b1011', pool_name=pool_name)\n# send TC(3,131)\nccs.Tcsend_DB('DPU_IFSW_SET_HK_REP_FREQ', 1, 8*4, ack='0b1011', pool_name=pool_name)\n",
+# test_spec=1),
+# CodeStep(
+# code_type="snippet",
+# description="verify that all three acknowledgements are received",
+# command_code="tc_dis = tc_id.tc_id_tuple()\n# check if the TC was successful\nresult = tm.check_acknowledgement(ccs=ccs, pool_name=pool_name, tc_identifier=tc_dis)",
+# test_spec=1),
+# CodeStep(
+# code_type="step",
+# description="A step consists out ouf command and verification",
+# command_code="tc_dis = tc_id.tc_id_tuple()\n",
+# verification_code="# check if the TC was successful\nresult = tm.check_acknowledgement(ccs=ccs, pool_name=pool_name, tc_identifier=tc_dis)",
+# test_spec=1)
+# ])
+'''
+# Basic idea of saving Test Specification is good, but is not needed now
def dummy_data_test_spec():
session.add_all([
CodeTestSpec(
@@ -56,7 +73,7 @@ def dummy_data_test_spec():
version="1.0"
)
])
-
+'''
def query_return_all():
result = session.query(CodeBlock).all()
@@ -66,5 +83,5 @@ def query_return_all():
if __name__ == '__main__':
with db_schema.session_scope() as session:
dummy_data_code_block()
- dummy_data_test_spec()
- dummy_data_steps()
+ #dummy_data_test_spec()
+ #dummy_data_steps()
diff --git a/Tst/codeblockreusefeature/codeblockreuse.py b/Tst/codeblockreusefeature/codeblockreuse.py
index cd03145b366f6be2b57889d48498a2e30d24aebe..6053be017a19e88769dc9b64e65e772ba129d6ef 100755
--- a/Tst/codeblockreusefeature/codeblockreuse.py
+++ b/Tst/codeblockreusefeature/codeblockreuse.py
@@ -396,8 +396,11 @@ class CBRSearch(Gtk.Box):
self.input_buffer.connect('inserted-text', self.on_search_text_inserted)
self.input_buffer.connect('deleted-text', self.on_search_text_deleted)
- self.pane = Gtk.Paned()
- self.pane.set_orientation(Gtk.Orientation.VERTICAL)
+ self.pane = Gtk.VPaned()
+
+ self.codeblocks_grid = Gtk.Grid()
+ self.codeblocks_grid.set_column_homogeneous(True)
+ self.codeblocks_grid.set_row_homogeneous(True)
# tree view for the showing the log messages
scroller = Gtk.ScrolledWindow()
@@ -436,12 +439,34 @@ class CBRSearch(Gtk.Box):
self.lm = GtkSource.LanguageManager()
self.style_manager = GtkSource.StyleSchemeManager.get_default()
+ self.comment_command_paned = Gtk.HPaned()
+ # source view for the comment ---------------------
+ self.comment_box = Gtk.VBox()
+ self.comment_label_box = Gtk.Box()
+ self.comment_label_box.set_orientation(Gtk.Orientation.HORIZONTAL)
+ self.comment_label = Gtk.Label()
+ self.comment_label.set_text(_('Comment:'))
+ self.comment_label_box.pack_start(self.comment_label, False, False, 0)
+
+ self.comment_scrolled_window = Gtk.ScrolledWindow()
+ self.comment_code_view = GtkSource.View()
+ self.comment_code_view_buffer = self.comment_code_view.get_buffer()
+ self.comment_code_view_buffer.set_language(self.lm.get_language('json'))
+ self.comment_code_view_buffer.set_style_scheme(self.style_manager.get_scheme('darcula'))
+ self.comment_scrolled_window.add(self.comment_code_view)
+
+ self.comment_box.pack_start(self.comment_label_box, False, False, 0)
+ self.comment_box.pack_start(self.comment_scrolled_window, True, True, 0)
+ self.comment_command_paned.pack2(self.comment_box)
+
# source view for the command code ---------------------
self.cc_box = Gtk.Box()
self.cc_box.set_orientation(Gtk.Orientation.VERTICAL)
-
+ self.cc_label_box = Gtk.Box()
+ self.cc_label_box.set_orientation(Gtk.Orientation.HORIZONTAL)
self.cc_label = Gtk.Label()
self.cc_label.set_text(_('Command code:'))
+ self.cc_label_box.pack_start(self.cc_label, False, False, 0)
self.cc_scrolled_window = Gtk.ScrolledWindow()
self.cc_code_view = GtkSource.View()
@@ -450,15 +475,19 @@ class CBRSearch(Gtk.Box):
self.cc_code_view_buffer.set_style_scheme(self.style_manager.get_scheme('darcula'))
self.cc_scrolled_window.add(self.cc_code_view)
- self.cc_box.pack_start(self.cc_label, False, False, 0)
+ self.cc_box.pack_start(self.cc_label_box, False, False, 0)
self.cc_box.pack_start(self.cc_scrolled_window, True, True, 0)
+ self.comment_command_paned.pack1(self.cc_box)
+ self.verification_paned = Gtk.HPaned()
# source view for the verification code ---------------------
self.vc_box = Gtk.Box()
self.vc_box.set_orientation(Gtk.Orientation.VERTICAL)
-
+ self.vc_label_box = Gtk.Box()
+ self.vc_label_box.set_orientation(Gtk.Orientation.HORIZONTAL)
self.vc_label = Gtk.Label()
self.vc_label.set_text(_('Verification code:'))
+ self.vc_label_box.pack_start(self.vc_label, False, False, 0)
self.vc_scrolled_window = Gtk.ScrolledWindow()
self.vc_code_view = GtkSource.View()
@@ -467,16 +496,37 @@ class CBRSearch(Gtk.Box):
self.vc_code_view_buffer.set_style_scheme(self.style_manager.get_scheme('darcula'))
self.vc_scrolled_window.add(self.vc_code_view)
- self.vc_box.pack_start(self.vc_label, False, False, 0)
+ self.vc_box.pack_start(self.vc_label_box, False, False, 0)
self.vc_box.pack_start(self.vc_scrolled_window, True, True, 0)
+ self.verification_paned.pack1(self.vc_box)
+
+ # source view for the Verification Description ---------------------
+ self.vrc_descr_box = Gtk.VBox()
+ self.vrc_descr_label_box = Gtk.Box()
+ self.vrc_descr_label_box.set_orientation(Gtk.Orientation.HORIZONTAL)
+ self.vrc_descr_label = Gtk.Label()
+ self.vrc_descr_label.set_text(_('Verification Description:'))
+ self.vrc_descr_label_box.pack_start(self.vrc_descr_label, False, False, 0)
+
+ self.vrc_descr_scrolled_window = Gtk.ScrolledWindow()
+ self.vrc_descr_code_view = GtkSource.View()
+ self.vrc_descr_code_view_buffer = self.vrc_descr_code_view.get_buffer()
+ self.vrc_descr_code_view_buffer.set_language(self.lm.get_language('json'))
+ self.vrc_descr_code_view_buffer.set_style_scheme(self.style_manager.get_scheme('darcula'))
+ self.vrc_descr_scrolled_window.add(self.vrc_descr_code_view)
+
+ self.vrc_descr_box.pack_start(self.vrc_descr_label_box, False, False, 0)
+ self.vrc_descr_box.pack_start(self.vrc_descr_scrolled_window, True, True, 0)
+ self.verification_paned.pack2(self.vrc_descr_box)
+
+ self.code_view_pane = Gtk.VPaned()
+ self.code_view_pane.pack1(self.comment_command_paned)
+ self.code_view_pane.pack2(self.verification_paned)
- self.code_view_pane = Gtk.Paned()
- self.code_view_pane.set_orientation(Gtk.Orientation.VERTICAL)
- self.code_view_pane.pack1(self.cc_box)
- self.code_view_pane.pack2(self.vc_box)
self.pane.pack2(self.code_view_pane)
self.pack_start(self.pane, True, True, 0)
+
self.right_click_menu = TreeRightClickMenu(cruf=self)
# set the position of the Paned widget using the configuration file
@@ -485,6 +535,9 @@ class CBRSearch(Gtk.Box):
# set the position of the paned of the widget self.codeblockreuse
paned_position_cc = confignator.get_option('codereuse-preferences', 'paned-position-command-code')
self.set_code_view_pane_position(int(paned_position_cc))
+ # set teh position of the comment and vrc description windows
+ paned_position_comment = confignator.get_option('codereuse-preferences', 'paned-position-comment')
+ self.set_comment_pane_position(int(paned_position_comment))
self.show_all()
@@ -495,14 +548,19 @@ class CBRSearch(Gtk.Box):
drag_source_type = data['data_type']
step_number = data['step_number']
description = data['description']
+ comment = data['comment']
command_code = data['command_code']
verification_code = data['verification_code']
+ verification_descr = data['verification_descr']
if drag_source_type == dnd_data_parser.data_type_step:
db_interaction.write_into_db_step(description=description,
command_code=command_code,
- verification_code=verification_code)
+ comment=comment,
+ verification_code=verification_code,
+ verification_descr=verification_descr)
if drag_source_type == dnd_data_parser.data_type_snippet:
db_interaction.write_into_db_snippet(description=description,
+ comment=comment,
code_block=command_code)
self.reload_data()
self.show_all()
@@ -526,9 +584,11 @@ class CBRSearch(Gtk.Box):
path = model.get_path(my_iter)
# retrieve the data from the tree-view row and build a string to set into the selection data object
desc = model[path][2]
- command_code = model[path][3]
- verification_code = model[path][4]
- data_string = dnd_data_parser.create_datastring(dnd_data_parser.data_type_snippet, description=desc, command_code=command_code, verification_code=verification_code, logger=self.logger)
+ comment = model[path][3]
+ command_code = model[path][4]
+ verification_code = model[path][5]
+ verification_descr = model[path][6]
+ data_string = dnd_data_parser.create_datastring(dnd_data_parser.data_type_snippet, description=desc, comment=comment, command_code=command_code, verification_code=verification_code, verification_descr=verification_descr, logger=self.logger)
# set the data into the selection data object
selection_data.set_text(data_string, -1)
@@ -559,6 +619,18 @@ class CBRSearch(Gtk.Box):
def get_code_view_pane_position(self):
return self.code_view_pane.get_position()
+ def set_comment_pane_position(self, position):
+ # set the position of Paned widget. If no position is provided, -1 (as not set) is set.
+ if position is None:
+ position = -1
+ self.verification_paned.set_position(position)
+ self.comment_command_paned.set_position(position)
+
+ def get_comment_pane_position(self):
+ return self.verification_paned.get_position()
+
+
+
def save_panes_positions(self):
"""
save the position of the pane widgets
@@ -567,6 +639,8 @@ class CBRSearch(Gtk.Box):
str(self.get_paned_position()))
confignator.save_option('codereuse-preferences', 'paned-position-command-code',
str(self.get_code_view_pane_position()))
+ confignator.save_option('codereuse-preferences', 'paned-position-comment',
+ str(self.get_comment_pane_position()))
# @property
# def filter_columns(self):
@@ -667,14 +741,18 @@ class CBRSearch(Gtk.Box):
"""
tree_view_model = tree_view.get_model()
tree_model_row = tree_view_model[path]
- command_code = tree_model_row[3]
- verification_code = tree_model_row[4]
+ comment = tree_model_row[3]
+ command_code = tree_model_row[4]
+ verification_code = tree_model_row[5]
+ verification_descr = tree_model_row[6]
+ self.comment_code_view_buffer.set_text(comment)
self.cc_code_view_buffer.set_text(command_code)
self.vc_code_view_buffer.set_text(verification_code)
+ self.vrc_descr_code_view_buffer.set_text(verification_descr)
def load_data_into_liststore(self, data: list):
# how many columns are in a row
- column_cnt = [int, str, str, str, str]
+ column_cnt = [int, str, str, str, str, str, str]
# column_cnt.append(str) # for background color
self.data_filtered = Gtk.TreeStore(*column_cnt)
diff --git a/Tst/codeblockreusefeature/codeblockreusefeature.cfg b/Tst/codeblockreusefeature/codeblockreusefeature.cfg
index 20a76df21c9b298275adedb6eb303d1b2aefe336..d8992698553e661fc1eb43616c7459b79f43f842 100644
--- a/Tst/codeblockreusefeature/codeblockreusefeature.cfg
+++ b/Tst/codeblockreusefeature/codeblockreusefeature.cfg
@@ -24,6 +24,7 @@ threadname = True
[codereuse-preferences]
main-window-height = 791
main-window-width = 612
-paned-position-search = 309
-paned-position-command-code = 186
+paned-position-search = 406
+paned-position-command-code = 105
+paned-position-comment = 462
diff --git a/Tst/codeblockreusefeature/db_interaction.py b/Tst/codeblockreusefeature/db_interaction.py
index 62b1e9c6dc318091ea3d2007fd924a1d5e3c2a80..170030bc9aeef746f967acedda80f8973e2cb96f 100644
--- a/Tst/codeblockreusefeature/db_interaction.py
+++ b/Tst/codeblockreusefeature/db_interaction.py
@@ -1,5 +1,5 @@
import db_schema
-from db_schema import CodeBlock
+from db_schema import CodeBlock, Pre_Post_Con
def query_get_all_entries():
@@ -9,16 +9,16 @@ def query_get_all_entries():
return data
-def write_into_db_step(description, command_code, verification_code):
+def write_into_db_step(description, comment, command_code, verification_code, verification_descr):
with db_schema.session_scope() as session:
- new_db_row = CodeBlock(code_type='step', description=description, command_code=command_code, verification_code=verification_code)
+ new_db_row = CodeBlock(code_type='step', description=description, comment=comment, command_code=command_code, verification_code=verification_code, verification_descr=verification_descr)
session.add(new_db_row)
return
-def write_into_db_snippet(description, code_block):
+def write_into_db_snippet(description, comment, code_block):
with db_schema.session_scope() as session:
- new_db_row = CodeBlock(code_type='snippet', description=description, command_code=code_block)
+ new_db_row = CodeBlock(code_type='snippet', description=description, comment=comment, command_code=code_block)
session.add(new_db_row)
return
@@ -42,6 +42,33 @@ def query_code_types():
session.expunge_all()
return data
+# -------------- Pre-Post Condition -------------------
+
+def write_into_pre_post_con(code_type, name, description, code_block):
+ # Check if the name already exists
+ data = get_pre_post_con(code_type)
+ for condition in data:
+ if name == condition.name: # If name exists delete it
+ delete_db_row_pre_post(condition.id)
+ with db_schema.session_scope() as session:
+ new_db_row = Pre_Post_Con(type=code_type, name=name, description=description, condition=code_block)
+ session.add(new_db_row)
+ return
+
+
+def delete_db_row_pre_post(id):
+ with db_schema.session_scope() as session:
+ session.query(Pre_Post_Con).filter_by(id=id).delete()
+ return
+
+
+def get_pre_post_con(code_type):
+ with db_schema.session_scope() as session:
+ data = session.query(Pre_Post_Con).filter(Pre_Post_Con.type.contains(code_type)).all()
+ session.expunge_all()
+ return data
+
+
if __name__ == '__main__':
query_code_types()
diff --git a/Tst/codeblockreusefeature/db_schema.py b/Tst/codeblockreusefeature/db_schema.py
index 7fe70387b5def9c7d9c83c8be1a5640289119954..2db22035cb02c9142f0dc2cb496af7ee5ae9193c 100644
--- a/Tst/codeblockreusefeature/db_schema.py
+++ b/Tst/codeblockreusefeature/db_schema.py
@@ -12,7 +12,7 @@ user = cfg.get('database', 'user')
pw = cfg.get('database', 'password')
mysql_connection_string = 'mysql://{}:{}@localhost'.format(user, pw)
-schema_name = 'codeblocks'
+schema_name = 'tst'
def crt_ngn():
@@ -72,8 +72,10 @@ class CodeBlock(Base):
# code_type = relationship('CodeKind')
code_type = Column(String(20), default='')
description = Column(Text(10000), default='')
+ comment = Column(Text(10000), default='')
command_code = Column(Text(10000), default='')
verification_code = Column(Text(10000), default='')
+ verification_descr = Column(Text(10000), default='')
# TC
# is_step
# is_command_code_block
@@ -82,13 +84,32 @@ class CodeBlock(Base):
# verification IDs
def __repr__(self):
- return '<CodeSnippet(code_type="{}", description="{}", command_code_block="{}", verification_code_block="{}")>'\
- .format(self.code_type, self.description, self.command_code, self.verification_code)
+ return '<CodeSnippet(code_type="{}", description="{}", comment="{}" command_code_block="{}", verification_code_block="{}", verification_descr="{}")>'\
+ .format(self.code_type, self.description, self.comment, self.command_code, self.verification_code, self.verification_descr)
def data_as_list(self):
- return [self.id, self.code_type, self.description, self.command_code, self.verification_code]
+ return [self.id, self.code_type, self.description, self.comment, self.command_code, self.verification_code, self.verification_descr]
+class Pre_Post_Con(Base):
+ __tablename__ = 'pre-post-conditions'
+
+ id = Column(Integer, primary_key=True)
+ type = Column(String(20), default='')
+ name = Column(Text(10000), default='')
+ description = Column(Text(10000), default='')
+ condition = Column(Text(10000), default='')
+
+ def __repr__(self):
+ return '<CodeSnippet(code_type="{}", description="{}", condition="{}")>'\
+ .format(self.code_type, self.description, self.condition)
+
+ def data_as_list(self):
+ return [self.id, self.code_type, self.description, self.condition]
+
+'''
+# This was never used therefore it is no longer used, but the basic idea may be interesting in the future, therefore kept in the code
+# Basic IDEA: SAving a Test Specification (Test Description, Name, Version)
class CodeTestSpec(Base):
__tablename__ = 'testspecs'
@@ -99,17 +120,19 @@ class CodeTestSpec(Base):
primary_counter_locked = Column(Boolean(), default=False)
steps = relationship('CodeStep')
+'''
-class CodeStep(Base):
- __tablename__ = 'steps'
-
- id = Column(Integer, primary_key=True)
-
- code_type = Column(String(20), default='')
- description = Column(Text(10000), default='')
- command_code = Column(Text(10000), default='')
- verification_code = Column(Text(10000), default='')
- test_spec = Column(ForeignKey('testspecs.id'))
+# This is no longer used, since all steps are in codeblocks data table
+#class CodeStep(Base):
+# __tablename__ = 'steps'
+#
+# id = Column(Integer, primary_key=True)#
+#
+# code_type = Column(String(20), default='')
+# description = Column(Text(10000), default='')
+# command_code = Column(Text(10000), default='')
+# verification_code = Column(Text(10000), default='')
+# test_spec = Column(ForeignKey('testspecs.id'))
# TC
# is_step
# is_command_code_block
@@ -117,13 +140,12 @@ class CodeStep(Base):
# requirement IDs
# verification IDs
- def __repr__(self):
- return '<CodeSnippet(code_type="{}", description="{}", command_code_block="{}", verification_code_block="{}")>'\
- .format(self.code_type, self.description, self.command_code, self.verification_code)
-
- def data_as_list(self):
- return [self.id, self.code_type, self.description, self.command_code, self.verification_code]
+# def __repr__(self):
+# return '<CodeSnippet(code_type="{}", description="{}", command_code_block="{}", verification_code_block="{}")>'\
+# .format(self.code_type, self.description, self.command_code, self.verification_code)
+# def data_as_list(self):
+# return [self.id, self.code_type, self.description, self.command_code, self.verification_code]
# class CodeKind(Base):
# __tablename__ = 'codekinds'
diff --git a/Tst/test_specs/test.json b/Tst/test_specs/test.json
deleted file mode 100644
index 91c21b97a51b03736ea7ec81ac54771219899d15..0000000000000000000000000000000000000000
--- a/Tst/test_specs/test.json
+++ /dev/null
@@ -1,58 +0,0 @@
-{
- "_name": "test",
- "_description": "Testing the TST",
- "_version": "2",
- "_primary_counter_locked": false,
- "_precon": "",
- "_postcon": "",
- "sequences": [
- {
- "_sequence": 0,
- "_name": "",
- "_description": "",
- "_version": "",
- "_primary_counter_locked": false,
- "steps": [
- {
- "_primary_counter": 1,
- "_secondary_counter": 0,
- "_step_number": "1.0",
- "_description": "Increase the HK Frequncy",
- "_comment": "",
- "_command_code": "cfl.Tcsend_DB('SASW ModHkPeriodCmd', 1, 8, pool_name='new_tmtc_pool')\n",
- "_verification_code": "print('Verification')",
- "_is_active": true,
- "_verified_item": [],
- "_start_sequence": null,
- "_stop_sequence": null
- },
- {
- "_primary_counter": 2,
- "_secondary_counter": 0,
- "_step_number": "2.0",
- "_description": "This is supposed to be a very long text just to seeeeee how the Progress Viewer View will handle something like this, definetly do not read any further, these are just some random words, the person reading is just wasting time. Now we reached the end. Tahnks for listening",
- "_comment": "",
- "_command_code": "print('A Lot of code')\nprint('Just some lines')\nprint('get some lines in here')\nprint('There we go')\nprint(' This line is not needed')\nprint('senseless line')\nprint(' This is a verrrrrrrrry long line that doesnt make any sense execept to see how the progress viewer will show this, thanks for reading')\n",
- "_verification_code": "print('Verification')\nprint('A Lot of code')\nprint('Just some lines')\nprint('get some lines in here')\nprint('There we go')\nprint(' This line is not needed')\nprint('senseless line')",
- "_is_active": true,
- "_verified_item": [],
- "_start_sequence": null,
- "_stop_sequence": null
- },
- {
- "_primary_counter": 3,
- "_secondary_counter": 0,
- "_step_number": "3.0",
- "_description": "Duration Test, Is Progress Viewer automatically updating?",
- "_comment": "",
- "_command_code": "import time\ntime.sleep(30)",
- "_verification_code": "print('Test is working, Progress Viewer is updating')\n",
- "_is_active": true,
- "_verified_item": [],
- "_start_sequence": null,
- "_stop_sequence": null
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/Tst/testing_library/testlib/analyse_command_log.py b/Tst/testing_library/testlib/analyse_command_log.py
index 39010f6ff85b0e0de8c2862e7b77f494e0732d7c..521d9e5ca239f3c3596b2dba37f7510e6106ddea 100644
--- a/Tst/testing_library/testlib/analyse_command_log.py
+++ b/Tst/testing_library/testlib/analyse_command_log.py
@@ -144,6 +144,7 @@ def get_steps_and_commands(filename):
new_step['descr'] = step_start_info['descr']
new_step['run_id'] = step_start_info['run_id']
new_step['step_id'] = step_start_info['step_id']
+ new_step['comment'] = step_start_info['comment']
#try:
# new_step['general_run_info'] = general_step_info
#except:
diff --git a/Tst/testing_library/testlib/analyse_test_run.py b/Tst/testing_library/testlib/analyse_test_run.py
index d44fb4e77f5e1a778518c8c896ae352aaee2bfcf..282eee7286d83f6360a1dc40fb0a3b7dd4d9ab99 100644
--- a/Tst/testing_library/testlib/analyse_test_run.py
+++ b/Tst/testing_library/testlib/analyse_test_run.py
@@ -50,7 +50,7 @@ def save_result_to_file(test_name, log_file_path=None, output_file_path=None, js
if not output_file_path:
output_file_path = basic_output_file_path
if not json_file_path:
- json_file_path = basic_json_file_path + test_name + '.json'
+ json_file_path = basic_json_file_path + '/' + test_name + '.json'
cmd_log_file = log_file_path + test_name + cmd_log_file_end
vrc_log_file = log_file_path + test_name + vrc_log_file_end
@@ -115,9 +115,9 @@ def save_result_to_file(test_name, log_file_path=None, output_file_path=None, js
# write date line
date_format = '%Y-%m-%d'
- exec_date = datetime.datetime.fromtimestamp(os.stat(json_file_path).st_mtime) if os.path.isfile() else '---' # When was the last time the json file was changed?
- time_now = datetime.datetime.strftime(datetime.datetime.now(), date_format) # TODO: Check which time should be shown here
- writer.writerow(['Date', '', exec_date, time_now]) # TODO: Make sure which dates should be shown, ok to take time from first step? Only checking left
+ specification_date = datetime.datetime.strftime(datetime.datetime.fromtimestamp(os.stat(json_file_path).st_mtime), date_format) if os.path.isfile(json_file_path) else '' # When was the last time the json file was changed?
+ time_execution = datetime.datetime.strftime(cmd_steps[0]['exec_date'], date_format)
+ writer.writerow(['Date', '', specification_date, time_execution])
# write Precon line
writer.writerow(['Precon.', 'This has still to be solved', '', '']) # TODO: What should be shown of the Precon
@@ -138,7 +138,9 @@ def save_result_to_file(test_name, log_file_path=None, output_file_path=None, js
step_number_secondary) == 0 else '{}.{}'.format(step_number_primary,
step_number_secondary)
step_desc = 'Step ' + str(step_number_shown)
- writer.writerow([step_desc, step['descr'], 'Probably some VRC description', test_result]) # TODO: Third coloumn is what?
+ writer.writerow([step_desc, step['descr'], vrc_step['vrc_descr'], test_result]) # TODO: Third coloumn is what?
+ if step['comment']:
+ writer.writerow(['Comment', step['comment'], '', ''])
# write Postcon line
writer.writerow(['Postcon.', 'This has still to be solved', '', '']) # TODO: What should be shown of the Postcon
@@ -236,5 +238,5 @@ def show_basic_results(test_name, log_file_path=None):
return
if __name__ == '__main__':
- save_result_to_file(test_name, run_id='20210713140200')
+ save_result_to_file(test_name, run_id='20210721092439')
#show_basic_results(test_name)
diff --git a/Tst/testing_library/testlib/analyse_verification_log.py b/Tst/testing_library/testlib/analyse_verification_log.py
index 1e6973aac7188388173dbc62589323a47fc49d86..1340f4b37c9542018525e8e87d311dc3e47f8e1c 100644
--- a/Tst/testing_library/testlib/analyse_verification_log.py
+++ b/Tst/testing_library/testlib/analyse_verification_log.py
@@ -56,6 +56,7 @@ def get_verification_steps(filename):
new_vrc_step['start_timestamp'] = item['timestamp']
new_vrc_step['exec_date'] = item['exec_date']
new_vrc_step['version'] = item['version']
+ new_vrc_step['vrc_descr'] = item['vrc_descr']
new_vrc_step['descr'] = item['descr']
new_vrc_step['run_id'] = item['run_id']
new_vrc_step['step_id'] = item['step_id']
diff --git a/Tst/testing_library/testlib/report.py b/Tst/testing_library/testlib/report.py
index 89acb67ef2e67b59ae27d3c054d0fe50abadc796..aff11197168f58f7b1ca74ca2502990d6949fc0d 100644
--- a/Tst/testing_library/testlib/report.py
+++ b/Tst/testing_library/testlib/report.py
@@ -26,6 +26,8 @@ cmd_test_start_keyword = '#START TEST'
cmd_step_keyword = '#COMMAND STEP'
cmd_step_exception_keyword = 'EXCEPTION IN STEP'
cmd_step_keyword_done = '#STEP DONE' # ATTENTION! The _done keyword must not contain the start keyword
+cmd_precon_keyword = '#PRECONDITION'
+cmd_postcon_keyword = '#POSTCONDITION'
vrc_step_keyword = '#VERIFICATION FOR STEP'
vrc_step_exception_keyword = 'EXCEPTION IN STEP'
vrc_step_keyword_done = '#VERIFICATION STEP DONE' # ATTENTION! The _done keyword must not contain the start keyword
@@ -47,7 +49,7 @@ def key_word_found(line, key_word):
return found
-def encode_to_json_string(step_number, timestamp, step_version=None, step_result=None, descr=None, run_id=None, step_id=None, comment=None):
+def encode_to_json_string(step_number, timestamp, step_version=None, step_result=None, descr=None, run_id=None, step_id=None, comment=None, vrc_descr=None):
"""
Make a JSON string out of the step number and timestamp
:param step_number: number of the step
@@ -61,6 +63,8 @@ def encode_to_json_string(step_number, timestamp, step_version=None, step_result
od['version'] = step_version
if step_result is not None:
od['result'] = step_result
+ if vrc_descr is not None:
+ od['vrc_descr'] = vrc_descr
if descr is not None:
od['descr'] = descr
if run_id is not None:
@@ -148,13 +152,11 @@ def verification_step_begin(step_param, script_version, pool_name, step_start_cu
encode_to_json_string(step_number=step_param['step_no'],
timestamp=step_start_cuc,
step_version=script_version,
+ vrc_descr=step_param['vrc_descr'],
run_id=run_id,
step_id=step_id,
descr=step_param['descr'])))
logger.info(step_param['descr'])
- if 'comment' in step_param:
- if len(step_param['comment']) > 0:
- logger.info('Comment: {}'.format(step_param['comment']))
def verification_step_exception(step_param, step_id=None):
@@ -290,23 +292,32 @@ def print_event_data_tuple(tm_packets):
logger.debug('Event {}: {} -> {}'.format(event_id, src, dest))
-def write_precondition_outcome(result):
+def write_precondition_outcome(result, step_id, precon_descr):
"""
Logs the outcome of the establish_preconditions function in a test script.
:param result: bool
True if all precondition could be established successfully
"""
+
+ logger.info('{} {}'.format(cmd_precon_keyword, make_json_string(result=result,
+ precon_desc=precon_descr,
+ step_id=step_id)))
if result is True:
logger.info('Preconditions are fulfilled.\n')
else:
logger.warning('Preconditions are NOT fulfilled.\n')
-def write_postcondition_outcome(result):
+
+def write_postcondition_outcome(result, step_id, postcon_descr):
"""
Logs the outcome of the establish_postconditions function in a test script.
:param result: bool
True if all postcondition could be established successfully
"""
+
+ logger.info('{} {}'.format(cmd_postcon_keyword, make_json_string(result=result,
+ postcon_desc=postcon_descr,
+ step_id=step_id)))
if result is True:
logger.info('Postconditions are fulfilled.\n')
else:
diff --git a/Tst/tst/data_model.py b/Tst/tst/data_model.py
index 0ce76a591f08ede071c90929d7bc1e3b5c7ec56b..24ea10b9dc0bc5ea24509d31e2c3a69ae3be7303 100644
--- a/Tst/tst/data_model.py
+++ b/Tst/tst/data_model.py
@@ -112,9 +112,9 @@ class Step:
self._step_number = ''
self._description = ''
self._command_code = ''
- self._command_comment = ''
+ self._step_comment = ''
self._verification_code = ''
- self._verification_comment = ''
+ self._verification_description = ''
self._is_active = True
self._verified_item = []
self._start_sequence = None
@@ -143,9 +143,9 @@ class Step:
new_step.secondary_counter = copy.copy(self.secondary_counter)
new_step.description = copy.copy(self.description)
new_step.command_code = copy.copy(self.command_code)
- new_step.command_comment = copy.copy(self.command_comment)
+ new_step.step_comment = copy.copy(self.step_comment)
new_step.verification_code = copy.copy(self.verification_code)
- new_step.verification_comment = copy.copy(self.verification_comment)
+ new_step.verification_description = copy.copy(self.verification_description)
new_step.is_active = copy.copy(self.is_active)
new_step.start_sequence = copy.copy(self.start_sequence)
new_step.stop_sequence = copy.copy(self.stop_sequence)
@@ -216,13 +216,13 @@ class Step:
self._command_code = value
@property
- def command_comment(self):
- return self._command_comment
+ def step_comment(self):
+ return self._step_comment
- @command_comment.setter
- def command_comment(self, value: str):
+ @step_comment.setter
+ def step_comment(self, value: str):
assert isinstance(value, str)
- self._command_comment = value
+ self._step_comment = value
@property
def verification_code(self):
@@ -234,13 +234,13 @@ class Step:
self._verification_code = value
@property
- def verification_comment(self):
- return self._verification_comment
+ def verification_description(self):
+ return self._verification_description
- @verification_comment.setter
- def verification_comment(self, value: str):
+ @verification_description.setter
+ def verification_description(self, value: str):
assert isinstance(value, str)
- self._verification_comment = value
+ self._verification_description = value
@property
def is_active(self):
@@ -287,9 +287,9 @@ class Step:
self.secondary_counter = step['_secondary_counter']
self.description = step['_description']
self.command_code = step['_command_code']
- self.command_comment = step['_command_comment']
+ self.step_comment = step['_step_comment']
self.verification_code = step['_verification_code']
- self.verification_comment = step['_verification_comment']
+ self.verification_description = step['_verification_description']
self.is_active = step['_is_active']
except KeyError as error:
self.logger.error('KeyError: no {} could be found in the loaded data'.format(error))
@@ -902,8 +902,12 @@ class TestSpecification:
self._description = ''
self._version = ''
self._primary_counter_locked = False
- self._precon = ''
- self._postcon = ''
+ self._precon_name = ''
+ self._precon_code = ''
+ self._precon_descr = ''
+ self._postcon_name = ''
+ self._postcon_code = ''
+ self._postcon_descr = ''
self._comment = ''
self.sequences = []
@@ -918,8 +922,12 @@ class TestSpecification:
new_testspec.description = copy.copy(self.description)
new_testspec.version = copy.copy(self.version)
new_testspec.primary_counter_locked = copy.copy(self.primary_counter_locked)
- new_testspec.precon = copy.copy(self.precon)
- new_testspec.postcon = copy.copy(self.postcon)
+ new_testspec.precon_name = copy.copy(self.precon_name)
+ new_testspec.precon_code = copy.copy(self.precon_code)
+ new_testspec.precon_descr = copy.copy(self.precon_descr)
+ new_testspec.postcon_name = copy.copy(self.postcon_name)
+ new_testspec.postcon_code = copy.copy(self.postcon_code)
+ new_testspec.postcon_descr = copy.copy(self.postcon_descr)
new_testspec.comment = copy.copy(self.comment)
return new_testspec
@@ -965,22 +973,58 @@ class TestSpecification:
self._version = value
@property
- def precon(self):
- return self._precon
+ def precon_name(self):
+ return self._precon_name
- @precon.setter
- def precon(self, value: str):
+ @precon_name.setter
+ def precon_name(self, value: str):
assert isinstance(value, str)
- self._precon = value
+ self._precon_name = value
@property
- def postcon(self):
- return self._postcon
+ def precon_code(self):
+ return self._precon_code
- @postcon.setter
- def postcon(self, value: str):
+ @precon_code.setter
+ def precon_code(self, value: str):
assert isinstance(value, str)
- self._postcon = value
+ self._precon_code = value
+
+ @property
+ def precon_descr(self):
+ return self._precon_descr
+
+ @precon_descr.setter
+ def precon_descr(self, value: str):
+ assert isinstance(value, str)
+ self._precon_descr = value
+
+ @property
+ def postcon_name(self):
+ return self._postcon_name
+
+ @postcon_name.setter
+ def postcon_name(self, value: str):
+ assert isinstance(value, str)
+ self._postcon_name = value
+
+ @property
+ def postcon_code(self):
+ return self._postcon_code
+
+ @postcon_code.setter
+ def postcon_code(self, value: str):
+ assert isinstance(value, str)
+ self._postcon_code = value
+
+ @property
+ def postcon_descr(self):
+ return self._postcon_descr
+
+ @postcon_descr.setter
+ def postcon_descr(self, value: str):
+ assert isinstance(value, str)
+ self._postcon_descr = value
@property
def comment(self):
@@ -1008,8 +1052,12 @@ class TestSpecification:
self.description = json_data['_description']
self.version = json_data['_version']
self.primary_counter_locked = json_data['_primary_counter_locked']
- self.precon = json_data['_precon']
- self.postcon = json_data['_postcon']
+ self.precon_name = json_data['_precon_name']
+ self.precon_code = json_data['_precon_code']
+ self.precon_descr = json_data['_precon_descr']
+ self.postcon_name = json_data['_postcon_name']
+ self.postcon_code = json_data['_postcon_code']
+ self.postcon_descr = json_data['_postcon_descr']
self.comment = json_data['_comment']
except KeyError as keyerror:
self.logger.error('KeyError: no {} could be found in the loaded data'.format(keyerror))
diff --git a/Tst/tst/dnd_data_parser.py b/Tst/tst/dnd_data_parser.py
index e86fea912e0aae8286ede50e43cb045bdc389f48..8f0661af3c19564183617c62f4693087729ebb11 100644
--- a/Tst/tst/dnd_data_parser.py
+++ b/Tst/tst/dnd_data_parser.py
@@ -17,7 +17,7 @@ data_type_snippet = 'snippet'
data_type_step = 'step'
-def create_datastring(data_type, sequence='', step_number='', description='', command_code='', verification_code='', logger=logger):
+def create_datastring(data_type, sequence='', step_number='', description='', comment='', command_code='', verification_code='', verification_descr='', logger=logger):
if data_type == data_type_snippet:
step_number = ''
# build the data string
@@ -26,8 +26,10 @@ def create_datastring(data_type, sequence='', step_number='', description='', co
data_string += separator + str(sequence)
data_string += separator + step_number
data_string += separator + description
+ data_string += separator + comment
data_string += separator + command_code
data_string += separator + verification_code
+ data_string += separator + verification_descr
except Exception as excep:
logger.exception(excep)
raise excep
@@ -46,15 +48,19 @@ def read_datastring(data_string: str, logger=logger) -> dict:
sequence = data[1]
step_number = data[2]
description = data[3]
- command_code = data[4]
- verification_code = data[5]
+ comment = data[4]
+ command_code = data[5]
+ verification_code = data[6]
+ verification_descr = data[7]
data_dict = {
'data_type': data_type,
'sequence': sequence,
'step_number': step_number,
'description': description,
+ 'comment': comment,
'command_code': command_code,
- 'verification_code': verification_code
+ 'verification_code': verification_code,
+ 'verification_descr' : verification_descr
}
except Exception as excep:
logger.exception(excep)
diff --git a/Tst/tst/generator.py b/Tst/tst/generator.py
index d12011594cf75676d108b0b999f6a44acff886c1..94f78c644a1b47a4dac1b4fa139015095b7384c8 100644
--- a/Tst/tst/generator.py
+++ b/Tst/tst/generator.py
@@ -1,6 +1,12 @@
import os
import string
import data_model
+import confignator
+import sys
+sys.path.append(confignator.get_option('paths', 'ccs'))
+import ccs_function_lib as cfl
+cfl.add_tst_import_paths()
+import db_interaction
cmd_scrpt_auxiliary = '_command.py'
vrc_scrpt_auxiliary = '_verification.py'
@@ -9,20 +15,18 @@ run_scrpt_auxiliary = '_run.py'
co_header_path = os.path.normpath(os.path.join(os.path.dirname(__file__), 'generator_templates/co_header.py'))
co_class_path = os.path.normpath(os.path.join(os.path.dirname(__file__), 'generator_templates/co_class.py'))
co_pre_cond_path = os.path.normpath(os.path.join(os.path.dirname(__file__), 'generator_templates/co_pre_condition.py'))
-co_pre_cond_entry_path = os.path.normpath(os.path.join(os.path.dirname(__file__), 'generator_templates/co_pre_condition_entry.py'))
co_step_path = os.path.normpath(os.path.join(os.path.dirname(__file__), 'generator_templates/co_step.py'))
co_post_cond_path = os.path.normpath(os.path.join(os.path.dirname(__file__), 'generator_templates/co_post_condition.py'))
-co_post_cond_entry_path = os.path.normpath(os.path.join(os.path.dirname(__file__), 'generator_templates/co_post_condition_entry.py'))
co_footer_path = os.path.normpath(os.path.join(os.path.dirname(__file__), 'generator_templates/co_footer.py'))
run_header_path = os.path.normpath(os.path.join(os.path.dirname(__file__), 'generator_templates/run_header.py'))
run_step_path = os.path.normpath(os.path.join(os.path.dirname(__file__), 'generator_templates/run_step.py'))
+run_footer_path = os.path.normpath(os.path.join(os.path.dirname(__file__), 'generator_templates/run_footer.py'))
ver_header_path = os.path.normpath(os.path.join(os.path.dirname(__file__), 'generator_templates/ver_header.py'))
ver_class_path = os.path.normpath(os.path.join(os.path.dirname(__file__), 'generator_templates/ver_class.py'))
ver_step_path = os.path.normpath(os.path.join(os.path.dirname(__file__), 'generator_templates/ver_step.py'))
-
def create_file_name(name):
"""
Take the name of the test specification and make a valid file name out of it
@@ -58,42 +62,6 @@ def get_product_file_paths(model_name):
paths.append(create_script_path(name=model_name, auxiliary=run_scrpt_auxiliary))
return paths
-def get_precon_sections():
- pre_con_sections = {} # Name of section points to beginning line and ending line
- pre_con_number_sections = [] # Save section name and appearence line number here, to get it to pre con sections
- with open(co_pre_cond_entry_path, 'r') as pre_con_entry_obj:
- for count, line in enumerate(pre_con_entry_obj):
- if line.startswith('#####-'):
- pre_con_number_sections.append([line[6:-7], count+1]) # Save section name and line number
- pre_con_number_sections.append(['Last line', count+1]) # Add the last line count to have an end for last section
- pre_con_entry_obj.close()
- for i, sections in enumerate(pre_con_number_sections): # Format it niceline in pre con sections
- try:
- pre_con_sections[sections[0]] = [int(sections[1]), int(pre_con_number_sections[i+1][1])]
- except:
- # This just catches the last line which was only added to get end for last section
- pass
-
- return pre_con_sections
-
-def get_postcon_sections():
- post_con_sections = {} # Name of section points to beginning line and ending line
- post_con_number_sections = [] # Save section name and appearence line number here, to get it to post con sections
- with open(co_post_cond_entry_path, 'r') as post_con_entry_obj:
- for count, line in enumerate(post_con_entry_obj):
- if line.startswith('#####-'):
- post_con_number_sections.append([line[6:-7], count+1]) # Save section name and line number
- post_con_number_sections.append(['Last line', count+1]) # Add the last line count to have an end for last section
- post_con_entry_obj.close()
- for i, sections in enumerate(post_con_number_sections): # Format it niceline in post con sections
- try:
- post_con_sections[sections[0]] = [int(sections[1]), int(post_con_number_sections[i+1][1])]
- except:
- # This just catches the last line which was only added to get end for last section
- pass
-
- return post_con_sections
-
def strip_file_extension(name):
assert type(name) is str
return name.rsplit('.', 1)[0]
@@ -139,33 +107,20 @@ def make_command_script(model, model_spec):
testSpecName=model_spec.name,
testSpecDescription=model_spec.description,
testSpecVersion=model_spec.version,
- testPreCondition=model_spec.precon,
- testPostCondition=model_spec.postcon,
+ testPreCondition=model_spec.precon_name,
+ testPostCondition=model_spec.postcon_name,
testComment=model_spec.comment)
# add the header string
content += '\n\n' + cls
# add the pre condition function
- with open(co_pre_cond_path, 'r') as pre_cond_file_obj, open(co_pre_cond_entry_path, 'r') as pre_cond_entry_file_obj:
+ with open(co_pre_cond_path, 'r') as pre_cond_file_obj:
pre_cond_template_str = pre_cond_file_obj.read()
pre_cond_file_obj.close()
- # Get the needed section and read only those lines
- all_precon_sections = get_precon_sections()
- precon_position = all_precon_sections[model_spec.precon]
- pre_cond_entry_array = pre_cond_entry_file_obj.readlines()[precon_position[0]: precon_position[1]]
- pre_cond_entry = ''
- # Make a string to combine it with the co_pre_conditions file, add tabs for the additonal lines in form of space so the CCS can read it
- for count, line in enumerate(pre_cond_entry_array):
- if count > 0:
- pre_cond_entry += ' '*8
- pre_cond_entry += line
- else:
- pre_cond_entry += line
- pre_cond_entry_file_obj.close()
-
pre_cond_template = string.Template(pre_cond_template_str)
- pre_cond_combined = pre_cond_template.substitute(testpreconentry=pre_cond_entry)
+ pre_cond_combined = pre_cond_template.substitute(TestPreconEntry=model_spec.precon_code,
+ TestPreconDescription=model_spec.precon_descr)
# add the header string
content += '\n' + pre_cond_combined
@@ -181,7 +136,7 @@ def make_command_script(model, model_spec):
command_code_w_indents = 'pass'
step = step_str.substitute(testStepNumber=step.step_number_test_format,
testStepDescription=step.description,
- testStepCommandComment=step.command_comment,
+ testStepComment=step.step_comment,
testStepCommandCode=command_code_w_indents,
testSpecFileName=create_file_name(model_spec.name),
testSpecClassName=create_class_name(model_spec.name))
@@ -189,26 +144,13 @@ def make_command_script(model, model_spec):
content += '\n' + step
# add the post condition function
- with open(co_post_cond_path, 'r') as post_cond_file_obj, open(co_post_cond_entry_path, 'r') as post_cond_entry_file_obj:
+ with open(co_post_cond_path, 'r') as post_cond_file_obj:
post_cond_template_str = post_cond_file_obj.read()
post_cond_file_obj.close()
- # Get the needed section and read only those lines
- all_postcon_sections = get_postcon_sections()
- postcon_position = all_postcon_sections[model_spec.postcon]
- post_cond_entry_array = post_cond_entry_file_obj.readlines()[postcon_position[0]: postcon_position[1]]
- post_cond_entry = ''
- # Make a string to combine it with the co_post_conditions file, add tabs for the additonal lines in form of space so the CCS can read it
- for count, line in enumerate(post_cond_entry_array):
- if count > 0:
- post_cond_entry += ' '*8
- post_cond_entry += line
- else:
- post_cond_entry += line
- post_cond_entry_file_obj.close()
-
post_cond_template = string.Template(post_cond_template_str)
- post_cond_combined = post_cond_template.substitute(testpostconentry=post_cond_entry)
+ post_cond_combined = post_cond_template.substitute(TestPostconEntry=model_spec.postcon_code,
+ TestPostconDescr=model_spec.description)
# add the header string
content += '\n' + post_cond_combined
@@ -270,6 +212,14 @@ def make_command_run_script(model, model_spec):
# add the string for a steps
content += '\n' + step
+ # add the step definitions
+ with open(run_footer_path, 'r') as step_file_obj:
+ step_template_str = step_file_obj.read()
+ step_file_obj.close()
+ header_template_str = string.Template(header_template)
+
+ content += '\n' + header_template_str
+
# create the new file
file_path = create_script_path(name=model_spec.name, auxiliary=run_scrpt_auxiliary)
with open(file_path, 'w') as command_script:
@@ -330,11 +280,19 @@ def make_verification_script(model, model_spec):
# testStepVerificationCode=verification_code_w_indents)
step = step_str.substitute(testStepNumber=step.step_number_test_format,
testStepDescription=step.description,
- testStepVerificationComment=step.verification_comment,
+ testStepVerificationDescription=step.verification_description,
testStepVerificationCode=verification_code_w_indents)
# add the string for a steps
content += '\n' + step
+ # add the footer (logger_setup)
+ #with open(ver_footer_path, 'r') as footer_file_obj:
+ # footer_template_str = footer_file_obj.read()
+ # footer_file_obj.close()
+
+ # add the header string
+ # content += footer_template_str
+
# # add the post condition function
# with open(post_cond_path, 'r') as post_cond_file_obj:
# post_cond_template_str = post_cond_file_obj.read()
diff --git a/Tst/tst/generator_templates/co_post_condition.py b/Tst/tst/generator_templates/co_post_condition.py
index 6a8a27d2f4433c654c1d50412a2011006a52a33a..18b0c4d8883c80cc3fd46d60c2486e74e05da3e4 100644
--- a/Tst/tst/generator_templates/co_post_condition.py
+++ b/Tst/tst/generator_templates/co_post_condition.py
@@ -44,12 +44,14 @@
:rtype: bool
"""
testing_logger.cmd_log_handler(__name__)
+ step_id = self.check_run_and_step_id(pool_name=pool_name)
+ postcon_descr = '$TestPostconDescr'
success = False
logger.info('establishing postconditions started')
- $testpostconentry
+ $TestPostconEntry
logger.info('establishing postconditions finished')
- report.write_postcondition_outcome(success)
+ report.write_postcondition_outcome(success, step_id, postcon_descr)
return success
diff --git a/Tst/tst/generator_templates/co_post_condition_entry.py b/Tst/tst/generator_templates/co_post_condition_entry.py
deleted file mode 100644
index 2a8786a88969c3e4073ec412c65ff0f69f59e2dd..0000000000000000000000000000000000000000
--- a/Tst/tst/generator_templates/co_post_condition_entry.py
+++ /dev/null
@@ -1,15 +0,0 @@
-# Explanation:
-# In the test always one choosen section is entered into the postconditions, the start and finish functions are always
-# the same and given in co_post_condition. py file
-# A section can be added if it starts with the format #####-Nameofthepostcon-##### and will than be shown in the TST
-# At the end of the file exactly 2 empty lines should exist
-
-#####-None-#####
-logger.info('No post-conditions have been given')
-success = True
-
-#####-Example-#####
-print('Hello, I am the whole post-condition')
-#reset = tc.reset_all_housekeepings(pool_name=pool_name)
-success = True
-
diff --git a/Tst/tst/generator_templates/co_pre_condition.py b/Tst/tst/generator_templates/co_pre_condition.py
index 05272b6a2db6c2fa3343e2c836eb499612e259bf..7dbfdd2aac9e655952578cb6720ecca6fc8efdb9 100644
--- a/Tst/tst/generator_templates/co_pre_condition.py
+++ b/Tst/tst/generator_templates/co_pre_condition.py
@@ -8,13 +8,15 @@
True if the preconditions are fulfilled
"""
testing_logger.cmd_log_handler(__name__)
+ step_id = self.check_run_and_step_id(pool_name=pool_name)
+ precon_descr = '$TestPreconDescription'
success = False
logger.info('establishing preconditions started')
- $testpreconentry
+ $TestPreconEntry
logger.info('establishing preconditions finished')
- report.write_precondition_outcome(success)
+ report.write_precondition_outcome(success, step_id, precon_descr)
return success
# INITIALIZE every step --------------------------------------------------------------------------------------------
diff --git a/Tst/tst/generator_templates/co_pre_condition_entry.py b/Tst/tst/generator_templates/co_pre_condition_entry.py
deleted file mode 100644
index 1270098b6ce29fab9f0400f8bb2eda6ca51f18f2..0000000000000000000000000000000000000000
--- a/Tst/tst/generator_templates/co_pre_condition_entry.py
+++ /dev/null
@@ -1,14 +0,0 @@
-# Explanation:
-# In the test always one choosen section is entered into the precondition, the start and finish functions are always
-# the same and given in co_pre_condition. py file
-# A section can be added if it starts with the format #####-Nameoftheprecon-##### and will than be shown in the TST
-# At the end of the file exactly 2 empty lines should exist
-
-#####-None-#####
-logger.info('No pre-conditions have been given')
-success = True
-
-#####-Example-#####
-print('No pre-conditions have been given')
-success = True
-
diff --git a/Tst/tst/generator_templates/co_step.py b/Tst/tst/generator_templates/co_step.py
index ba1a7552dc53d4d6b13653f4918e5157e012c7c5..87902bf120cea252302a5ec6237357e3198d54d3 100644
--- a/Tst/tst/generator_templates/co_step.py
+++ b/Tst/tst/generator_templates/co_step.py
@@ -3,7 +3,7 @@
param = {
'step_no': '$testStepNumber',
'descr': '$testStepDescription',
- 'comment': '$testStepCommandComment'
+ 'comment': '$testStepComment'
}
step_start_cuc, summary, step_id = self.begin_steps(pool_name=pool_name, param=param)
diff --git a/Tst/tst/generator_templates/run_footer.py b/Tst/tst/generator_templates/run_footer.py
new file mode 100644
index 0000000000000000000000000000000000000000..18e43411b411a8fdfc42d869f0960bb586da35f8
--- /dev/null
+++ b/Tst/tst/generator_templates/run_footer.py
@@ -0,0 +1,3 @@
+ #! CCS.BREAKPOINT
+ # Execute the Post Conditions
+ threading.Thread(target=testinstance.post_condition, kwargs = {'pool_name': pool_name}, daemon = True).start()
\ No newline at end of file
diff --git a/Tst/tst/generator_templates/ver_step.py b/Tst/tst/generator_templates/ver_step.py
index b5a3370a5e742c5b03510da5bd8e23bdeb15ff93..ef34a6a75b35e8bbe1bb65acf57bbda39f6953a2 100644
--- a/Tst/tst/generator_templates/ver_step.py
+++ b/Tst/tst/generator_templates/ver_step.py
@@ -4,7 +4,7 @@
param = {
'step_no': '$testStepNumber',
'descr': '$testStepDescription',
- 'comment': '$testStepVerificationComment'
+ 'vrc_descr': '$testStepVerificationDescription'
}
self.vrc_step_begin(pool_name=pool_name, param=param, run_id=run_id, step_id=step_id)
diff --git a/Tst/tst/tst.py b/Tst/tst/tst.py
index 7ffa48a8a68fc99beb6a3aac1892c46f7adafe36..4bb532d77f0edcf82694e139714a2e0bb937f504 100755
--- a/Tst/tst/tst.py
+++ b/Tst/tst/tst.py
@@ -527,6 +527,7 @@ class TstAppWindow(Gtk.ApplicationWindow):
# get the data model of the current notebook page
current_test = self.current_test_instance()
current_model = self.current_model()
+ #current_model2=current_model.serialize(current_model)
if current_model is not None and current_test.filename is None:
self.save_as_file_dialog()
elif current_model is not None:
diff --git a/Tst/tst/view.py b/Tst/tst/view.py
index ae446950016aed5c20bee00249a534bf3215a73a..b657b34db17b68b4a5726bd165a87ec724eeedf6 100644
--- a/Tst/tst/view.py
+++ b/Tst/tst/view.py
@@ -2,6 +2,10 @@ import os
import logging
import gettext
import gi
+import time
+
+import db_interaction
+
gi.require_version('Gtk', '3.0')
gi.require_version('GtkSource', '3.0')
from gi.repository import Gtk, Gdk, GtkSource
@@ -158,15 +162,15 @@ class Board(Gtk.Box):
self.lbl_box_comment = Gtk.Box()
self.lbl_box_comment.set_orientation(Gtk.Orientation.HORIZONTAL)
self.label_comment = Gtk.Label.new()
- self.label_comment.set_text(_('Comment'))
+ self.label_comment.set_text(_('Test Comment:'))
self.lbl_box_comment.pack_start(self.label_comment, False, False, 0)
# Make the area where the real command is entered
self.comment_scrolled_window = Gtk.ScrolledWindow()
- #self.commands_comment_scrolled_window.set_size_request(200, 100)
+ #self.comment_scrolled_window.set_size_request(200, 100)
self.test_meta_data_comment = Gtk.TextView.new()
self.comment_scrolled_window.add(self.test_meta_data_comment)
- self.test_comment_box.pack_start(self.lbl_box_comment, True, True, 0)
+ self.test_comment_box.pack_start(self.lbl_box_comment, False, False, 0)
self.test_comment_box.pack_start(self.comment_scrolled_window, True, True, 0)
@@ -255,10 +259,10 @@ class Board(Gtk.Box):
# set the version of the test specification from the data model
self.test_meta_data_version.set_text(self.model.version)
# set the pre-condition name
- if self.model.precon:
+ if self.model.precon_name:
found = False
for index, precon_name in enumerate(self.precon_selection.get_model()):
- if precon_name[0] == self.model.precon:
+ if precon_name[0] == self.model.precon_name:
found = True
self.precon_selection.set_active(index)
if not found:
@@ -268,10 +272,10 @@ class Board(Gtk.Box):
self.on_precon_changed(self.precon_selection)
# set the post-condition name
- if self.model.postcon:
+ if self.model.postcon_name:
found = False
for index, postcon_name in enumerate(self.postcon_selection.get_model()):
- if postcon_name[0] == self.model.postcon:
+ if postcon_name[0] == self.model.postcon_name:
found = True
self.postcon_selection.set_active(index)
if not found:
@@ -335,11 +339,14 @@ class Board(Gtk.Box):
self.update_widget_data()
self.app.update_model_viewer()
- def set_precon_model(self):
- section_dict = generator.get_precon_sections()
- for section_name in section_dict.keys():
- self.precon_selection.append_text(section_name)
- self.precon_selection.set_active(0)
+ def set_precon_model(self, active_name=None):
+ section_dict = db_interaction.get_pre_post_con('pre')
+ active_nbr = 0
+ for count, condition in enumerate(section_dict):
+ self.precon_selection.append_text(condition.name)
+ if active_name == condition.name:
+ active_nbr = count
+ self.precon_selection.set_active(active_nbr)
self.on_precon_changed(self.precon_selection)
return
@@ -347,7 +354,13 @@ class Board(Gtk.Box):
# get the name out of the widget
precon_name = widget.get_active_text()
# update the model
- self.model.precon = precon_name
+ self.model.precon_name = precon_name
+ # Set the Precon Description
+ section_dict = db_interaction.get_pre_post_con('pre')
+ for condition in section_dict:
+ if condition.name == precon_name:
+ self.model.precon_descr = condition.description
+ self.model.precon_code = condition.condition
# update the data model viewer
self.app.update_model_viewer()
#current_model = self.app.current_model()
@@ -355,11 +368,14 @@ class Board(Gtk.Box):
# current_model.precon = precon_name
return
- def set_postcon_model(self):
- section_dict = generator.get_postcon_sections()
- for section_name in section_dict.keys():
- self.postcon_selection.append_text(section_name)
- self.postcon_selection.set_active(0)
+ def set_postcon_model(self, active_name=None):
+ section_dict = db_interaction.get_pre_post_con('post')
+ active_nbr = 0
+ for count, condition in enumerate(section_dict):
+ self.postcon_selection.append_text(condition.name)
+ if active_name == condition.name:
+ active_nbr = count
+ self.postcon_selection.set_active(active_nbr)
self.on_postcon_changed(self.postcon_selection)
return
@@ -367,7 +383,13 @@ class Board(Gtk.Box):
# get the name out of the widget
postcon_name = widget.get_active_text()
# update the model
- self.model.postcon = postcon_name
+ self.model.postcon_name = postcon_name
+ # Set the Postcon Description
+ section_dict = db_interaction.get_pre_post_con('post')
+ for condition in section_dict:
+ if condition.name == postcon_name:
+ self.model.postcon_descr = condition.description
+ self.model.postcon_code = condition.condition
# update the data model viewer
self.app.update_model_viewer()
#current_model = self.app.current_model()
@@ -375,10 +397,14 @@ class Board(Gtk.Box):
# current_model.postcon = postcon_name
return
+
+
def precon_edit_clicked(self, widget):
dialog = Edit_Pre_Post_Con_Dialog(self, 'pre', self.precon_selection.get_active())
response = dialog.run()
if response == Gtk.ResponseType.OK:
+ self.precon_selection.remove_all()
+ self.set_precon_model(dialog.selection.get_active_text())
dialog.destroy()
elif response == Gtk.ResponseType.CANCEL:
dialog.destroy()
@@ -387,6 +413,8 @@ class Board(Gtk.Box):
dialog = Edit_Pre_Post_Con_Dialog(self, 'post', self.postcon_selection.get_active())
response = dialog.run()
if response == Gtk.ResponseType.OK:
+ self.postcon_selection.remove_all()
+ self.set_postcon_model(dialog.selection.get_active_text())
dialog.destroy()
elif response == Gtk.ResponseType.CANCEL:
dialog.destroy()
@@ -598,9 +626,12 @@ class StepWidget(Gtk.EventBox):
self.set_hexpand(True)
+ # area for the commands
+ self.whole_description_box = Gtk.Grid()
+ self.whole_description_box.set_column_homogeneous(True)
+ #self.whole_commands_box.set_orientation(Gtk.Orientation.HORIZONTAL)
+
# field for the description
- self.desc_box = Gtk.Box()
- self.desc_box.set_orientation(Gtk.Orientation.VERTICAL)
self.lbl_box_desc = Gtk.Box()
self.lbl_box_desc.set_orientation(Gtk.Orientation.HORIZONTAL)
self.desc_label = Gtk.Label.new()
@@ -616,19 +647,35 @@ class StepWidget(Gtk.EventBox):
self.desc_scrolled_window.add(self.desc_text_view)
self.desc_text_buffer = self.desc_text_view.get_buffer()
- self.desc_box.pack_start(self.lbl_box_desc, True, True, 0)
- self.desc_box.pack_start(self.desc_scrolled_window, True, True, 0)
- self.detail_box.pack_start(self.desc_box, True, True, 0)
+ # Step Comment Area
+ # Make the label, inside a own Box to show it on the left end
+ self.lbl_box_step_comment = Gtk.Box()
+ self.lbl_box_step_comment.set_orientation(Gtk.Orientation.HORIZONTAL)
+ self.step_label_comment = Gtk.Label.new()
+ self.step_label_comment.set_text(_('Step Comment'))
+ self.lbl_box_step_comment.pack_start(self.step_label_comment, False, False, 0)
+ # Make the area where the real command is entered
+ self.step_comment_scrolled_window = Gtk.ScrolledWindow()
+ #self.step_comment_scrolled_window.set_size_request(200, 100)
+ self.step_comment_view = GtkSource.View()
+ self.step_comment_view.set_show_line_numbers(False)
+ self.step_comment_scrolled_window.add(self.step_comment_view)
+ self.step_comment_buffer = self.step_comment_view.get_buffer()
+
+ #ADD everything to the whole grid
+ self.whole_description_box.set_column_spacing(10)
+ self.whole_description_box.attach(self.lbl_box_desc, 0, 0, 3, 1)
+ self.whole_description_box.attach(self.desc_scrolled_window, 0, 1, 3, 5)
+ self.whole_description_box.attach_next_to(self.lbl_box_step_comment, self.lbl_box_desc, Gtk.PositionType.RIGHT, 1, 1)
+ self.whole_description_box.attach_next_to(self.step_comment_scrolled_window, self.desc_scrolled_window, Gtk.PositionType.RIGHT, 1, 5)
+ self.detail_box.pack_start(self.whole_description_box, True, True, 0)
# fields for commands and verification
lm = GtkSource.LanguageManager()
- # area for the commands
- self.whole_commands_box = Gtk.Grid()
- self.whole_commands_box.set_column_homogeneous(True)
- #self.whole_commands_box.set_orientation(Gtk.Orientation.HORIZONTAL)
-
- # Left side of the commands area, where the commands a entered
+ # Area for the commands
+ self.whole_commands_box = Gtk.Box()
+ self.whole_commands_box.set_orientation(Gtk.Orientation.VERTICAL)
# Make the label, inside a own Box to show it on the left side
self.lbl_box_commands = Gtk.Box()
self.lbl_box_commands.set_orientation(Gtk.Orientation.HORIZONTAL)
@@ -654,32 +701,9 @@ class StepWidget(Gtk.EventBox):
# self.commands_buffer.set_style_scheme(self.board.current_scheme)
self.commands_scrolled_window.add(self.commands_view)
- # Right side of the commands area, the comment box
- # Make the label, inside a own Box to show it on the left end
- self.lbl_box_commands_comment = Gtk.Box()
- self.lbl_box_commands_comment.set_orientation(Gtk.Orientation.HORIZONTAL)
- self.commands_label_comment = Gtk.Label.new()
- self.commands_label_comment.set_text(_('Comment'))
- self.lbl_box_commands_comment.pack_start(self.commands_label_comment, False, False, 0)
- # Make the area where the real command is entered
- self.commands_comment_scrolled_window = Gtk.ScrolledWindow()
- #self.commands_comment_scrolled_window.set_size_request(200, 100)
- self.commands_comment_view = GtkSource.View()
- self.commands_comment_view.set_show_line_numbers(False)
- self.commands_comment_scrolled_window.add(self.commands_comment_view)
- self.commands_comment_buffer = self.commands_comment_view.get_buffer()
-
- #self.commands_comment_box.pack_start(self.lbl_box_commands_comment, True, True, 0)
- #self.commands_comment_box.pack_start(self.commands_comment_scrolled_window, True, True, 0)
-
- #ADD everything to the whole grid
- self.whole_commands_box.set_column_spacing(10)
- self.whole_commands_box.attach(self.lbl_box_commands, 0, 0, 3, 1)
- self.whole_commands_box.attach(self.commands_scrolled_window, 0, 1, 3, 5)
- self.whole_commands_box.attach_next_to(self.lbl_box_commands_comment, self.lbl_box_commands, Gtk.PositionType.RIGHT, 1, 1)
- self.whole_commands_box.attach_next_to(self.commands_comment_scrolled_window, self.commands_scrolled_window, Gtk.PositionType.RIGHT, 1, 5)
+ self.whole_commands_box.pack_start(self.lbl_box_commands, False, False, 0)
+ self.whole_commands_box.pack_start(self.commands_scrolled_window, True, True, 0)
self.detail_box.pack_start(self.whole_commands_box, True, True, 0)
-
# area for the verification
self.whole_verification_box = Gtk.Grid()
self.whole_verification_box.set_column_homogeneous(True)
@@ -711,25 +735,25 @@ class StepWidget(Gtk.EventBox):
# Right side of the verification area, the comment box
# Make the label, inside a own Box to show it on the left end
- self.lbl_box_verification_comment = Gtk.Box()
- self.lbl_box_verification_comment.set_orientation(Gtk.Orientation.HORIZONTAL)
- self.verification_label_comment = Gtk.Label.new()
- self.verification_label_comment.set_text(_('Comment'))
- self.lbl_box_verification_comment.pack_start(self.verification_label_comment, False, False, 0)
+ self.lbl_box_verification_description = Gtk.Box()
+ self.lbl_box_verification_description.set_orientation(Gtk.Orientation.HORIZONTAL)
+ self.verification_label_description = Gtk.Label.new()
+ self.verification_label_description.set_text(_('Verification Description'))
+ self.lbl_box_verification_description.pack_start(self.verification_label_description, False, False, 0)
# Make the area where the real command is entered
- self.verification_comment_scrolled_window = Gtk.ScrolledWindow()
- #self.commands_comment_scrolled_window.set_size_request(200, 100)
- self.verification_comment_view = GtkSource.View()
- self.verification_comment_view.set_show_line_numbers(False)
- self.verification_comment_scrolled_window.add(self.verification_comment_view)
- self.verification_comment_buffer = self.verification_comment_view.get_buffer()
+ self.verification_description_scrolled_window = Gtk.ScrolledWindow()
+ #self.verification_comment_scrolled_window.set_size_request(200, 100)
+ self.verification_description_view = GtkSource.View()
+ self.verification_description_view.set_show_line_numbers(False)
+ self.verification_description_scrolled_window.add(self.verification_description_view)
+ self.verification_description_buffer = self.verification_description_view.get_buffer()
#ADD everything to the whole grid
self.whole_verification_box.set_column_spacing(10)
self.whole_verification_box.attach(self.lbl_box_verification, 0, 0, 3, 1)
self.whole_verification_box.attach(self.verification_scrolled_window, 0, 1, 3, 5)
- self.whole_verification_box.attach_next_to(self.lbl_box_verification_comment, self.lbl_box_verification, Gtk.PositionType.RIGHT, 1, 1)
- self.whole_verification_box.attach_next_to(self.verification_comment_scrolled_window, self.verification_scrolled_window, Gtk.PositionType.RIGHT, 1, 5)
+ self.whole_verification_box.attach_next_to(self.lbl_box_verification_description, self.lbl_box_verification, Gtk.PositionType.RIGHT, 1, 1)
+ self.whole_verification_box.attach_next_to(self.verification_description_scrolled_window, self.verification_scrolled_window, Gtk.PositionType.RIGHT, 1, 5)
self.detail_box.pack_start(self.whole_verification_box, True, True, 0)
# fill the step with data before connecting the signals (!)
@@ -764,9 +788,9 @@ class StepWidget(Gtk.EventBox):
# connect the signals
self.desc_text_buffer.connect('changed', self.on_description_buffer_changed)
self.commands_buffer.connect('changed', self.on_commands_buffer_changed)
- self.commands_comment_buffer.connect('changed', self.on_commands_comment_buffer_changed)
+ self.step_comment_buffer.connect('changed', self.on_step_comment_buffer_changed)
self.verification_buffer.connect('changed', self.on_verification_buffer_changed)
- self.verification_comment_buffer.connect('changed', self.on_verification_comment_buffer_changed)
+ self.verification_description_buffer.connect('changed', self.on_verification_description_buffer_changed)
Gtk.StyleContext.add_class(self.get_style_context(), 'step-widget')
@@ -862,9 +886,9 @@ class StepWidget(Gtk.EventBox):
self.set_is_active_in_widget()
self.set_description_in_widget()
self.set_commands_in_widget()#
- self.set_commands_comment_in_widget()
+ self.set_step_comment_in_widget()
self.set_verification_in_widget()
- self.set_verification_comment_in_widget()
+ self.set_verification_description_in_widget()
self.set_start_sequence_in_widget()
self.set_stop_sequence_in_widget()
return
@@ -895,11 +919,11 @@ class StepWidget(Gtk.EventBox):
self.commands_buffer.set_text(commands)
return
- def set_commands_comment_in_widget(self):
+ def set_step_comment_in_widget(self):
""" gets the commands comment from the model and sets it in the commands comment buffer in order to display it """
stp_ndx = self.model.get_sequence(self.sequence).get_step_index(self.step_number)
- commands_comment = self.model.get_sequence(self.sequence).steps[stp_ndx].command_comment
- self.commands_comment_buffer.set_text(commands_comment)
+ step_comment = self.model.get_sequence(self.sequence).steps[stp_ndx].step_comment
+ self.step_comment_buffer.set_text(step_comment)
return
def set_verification_in_widget(self):
@@ -909,11 +933,11 @@ class StepWidget(Gtk.EventBox):
self.verification_buffer.set_text(verification)
return
- def set_verification_comment_in_widget(self):
+ def set_verification_description_in_widget(self):
""" gets the commands comment from the model and sets it in the commands comment buffer in order to display it """
stp_ndx = self.model.get_sequence(self.sequence).get_step_index(self.step_number)
- verification_comment = self.model.get_sequence(self.sequence).steps[stp_ndx].verification_comment
- self.verification_comment_buffer.set_text(verification_comment)
+ verification_description = self.model.get_sequence(self.sequence).steps[stp_ndx].verification_description
+ self.verification_description_buffer.set_text(verification_description)
return
def set_start_sequence_in_widget(self):
@@ -986,15 +1010,19 @@ class StepWidget(Gtk.EventBox):
assert isinstance(step, data_model.Step)
step_number = step.step_number
description = step.description
+ comment = step.step_comment
command_code = step.command_code
verification_code = step.verification_code
+ verification_descr = step.verification_description
data_type = dnd_data_parser.data_type_step if verification_code else dnd_data_parser.data_type_snippet
data_string = dnd_data_parser.create_datastring(data_type,
self.sequence,
step_number,
description,
+ comment,
command_code,
verification_code,
+ verification_descr,
logger=self.logger)
# set the text in the selection data object
data.set_text(data_string, -1)
@@ -1069,7 +1097,9 @@ class StepWidget(Gtk.EventBox):
# set the data into the test script data model
step.description = data['description']
step.command_code = data['command_code']
+ step.step_comment = data['comment']
step.verification_code = data['verification_code']
+ step.verification_description = data['verification_descr']
if drag_source_type == dnd_data_parser.data_type_step: # a step is moved
step_number = data['step_number']
dragged_step_idx = self.model.get_sequence(self.sequence).get_step_index(step_number)
@@ -1151,19 +1181,19 @@ class StepWidget(Gtk.EventBox):
# update the data model viewer
self.app.update_model_viewer()
- def on_commands_comment_buffer_changed(self, text_buffer):
+ def on_step_comment_buffer_changed(self, text_buffer):
"""
Signal 'changed' for the commands comment buffer
"""
# get the text of the commands comment out of the buffer of the widget
- commands_comment = self.read_out_text_buffer(text_buffer)
+ step_comment = self.read_out_text_buffer(text_buffer)
# Setting the commands string for a step in the data model
# find the correct step within the data model
stp_ndx = self.model.get_sequence(self.sequence).get_step_index(self.step_number)
step_in_data_model = self.model.get_sequence(self.sequence).steps[stp_ndx]
# use the setter of the data model
if isinstance(step_in_data_model, data_model.Step):
- step_in_data_model.command_comment = commands_comment
+ step_in_data_model.step_comment = step_comment
else:
self.logger('step with the step number {} could not be found'.format(self.step_number))
# update the data model viewer
@@ -1187,19 +1217,19 @@ class StepWidget(Gtk.EventBox):
# update the data model viewer
self.app.update_model_viewer()
- def on_verification_comment_buffer_changed(self, text_buffer):
+ def on_verification_description_buffer_changed(self, text_buffer):
"""
- Signal 'changed' for the verification comment buffer
+ Signal 'changed' for the verification description buffer
"""
# get the code of the verification out of the buffer of the widget
- verification_comment = self.read_out_text_buffer(text_buffer)
+ verification_description = self.read_out_text_buffer(text_buffer)
# Setting the verification string for a step in the data model
# find the correct step within the data model
stp_ndx = self.model.get_sequence(self.sequence).get_step_index(self.step_number)
step_in_data_model = self.model.get_sequence(self.sequence).steps[stp_ndx]
# use the setter of the data model
if isinstance(step_in_data_model, data_model.Step):
- step_in_data_model.verification_comment = verification_comment
+ step_in_data_model.verification_description = verification_description
else:
self.logger('step with the step number {} could not be found'.format(self.step_number))
# update the data model viewer
@@ -1480,8 +1510,10 @@ class InterStepWidget(Gtk.Box):
new_step = self.model.get_sequence(self.sequence).add_step_below(reference_step_position=dest_step_above_number)
# set the data into the test script data model
new_step.description = data['description']
+ new_step.step_comment = data['comment']
new_step.command_code = data['command_code']
new_step.verification_code = data['verification_code']
+ new_step.verification_description = data['verification_descr']
if drag_source_type == dnd_data_parser.data_type_step: # a step is moved
source_sequence = int(data['sequence'])
source_step_number = data['step_number']
@@ -1502,8 +1534,10 @@ class InterStepWidget(Gtk.Box):
new_step = self.model.get_sequence(dest_step_above_sequence).add_step_below(reference_step_position=dest_step_above_number)
# set the data into the test script data model
new_step.description = data['description']
+ new_step.step_comment = data['comment']
new_step.command_code = data['command_code']
new_step.verification_code = data['verification_code']
+ new_step.verification_description = data['verification_descr']
# ToDo
# remove it from the old sequence
dragged_from_seq = self.model.get_sequence(source_sequence)
@@ -1552,15 +1586,19 @@ class Edit_Pre_Post_Con_Dialog(Gtk.Dialog):
self.win = parent
self.file_path = os.path.join(confignator.get_option('paths', 'tst'),
'tst/generator_templates/co_'+pre_post+'_condition_entry.py')
+ self.pre_post = pre_post
- if pre_post == 'pre':
- self.section_dict = generator.get_precon_sections()
- else:
- self.section_dict = generator.get_postcon_sections()
- self.view()
+ self.make_section_dict()
+ self.view()
self.show_all()
+ def make_section_dict(self):
+ if self.pre_post == 'pre':
+ self.section_dict = db_interaction.get_pre_post_con('pre')
+ else:
+ self.section_dict = db_interaction.get_pre_post_con('post')
+
def view(self):
self.main_box = Gtk.Box()
self.main_box.set_orientation(Gtk.Orientation.VERTICAL)
@@ -1568,133 +1606,136 @@ class Edit_Pre_Post_Con_Dialog(Gtk.Dialog):
self.selection_box = Gtk.Box()
self.selection_box.set_orientation(Gtk.Orientation.HORIZONTAL)
+ self.make_description_viewer()
self.make_text_viewer()
- self.selection = Gtk.ComboBox.new_with_model_and_entry(self.get_con_sections_model())
+ self.selection = Gtk.ComboBoxText.new_with_entry()
+ self.make_con_sections_model()
self.selection.connect("changed", self.on_name_combo_changed)
self.selection.set_entry_text_column(0)
self.selection.set_active(self.first_entry)
self.save_button = Gtk.Button.new_with_label('Save')
- self.save_button.connect("clicked", self.save_button_clicked)
+ self.save_button.connect("clicked", self.on_save_button)
+
+ self.delete_button = Gtk.Button.new_with_label('Delete')
+ self.delete_button.connect("clicked", self.on_delete_button)
self.selection_box.pack_start(self.selection, False, True, 0)
self.selection_box.pack_start(self.save_button, False, True, 0)
+ self.selection_box.pack_start(self.delete_button, False, True, 0)
box = self.get_content_area()
box.pack_start(self.selection_box, False, True, 0)
- box.pack_start(self.scrolled_window, True, True, 0)
+ box.pack_start(self.descr_lbl_box, False, False, 0)
+ box.pack_start(self.descr_scrolled_window, False, False, 0)
+ box.pack_start(self.con_lbl_box, False, False, 0)
+ box.pack_start(self.con_scrolled_window, True, True, 0)
#box.add(self.selection_box)
#box.pack_end(self.scrolled_window, True, True, 0)
- def get_con_sections_model(self):
- data_model = Gtk.ListStore(str, int, int)
- for section_name in self.section_dict.keys():
-
- data_model.append([section_name, self.section_dict[section_name][0], self.section_dict[section_name][1]])
-
- return data_model
+ def make_con_sections_model(self):
+ for condition in self.section_dict:
+ self.selection.append_text(condition.name)
+ return
def on_name_combo_changed(self, widget):
- buffer = self.textview.get_buffer()
- tree_iter = widget.get_active_iter()
- if tree_iter is not None:
- model = widget.get_model()
- name = model[tree_iter][0]
+ name = widget.get_active_text()
+
+ if name:
+ for condition in self.section_dict:
+ if condition.name == name:
+ self.descr_textview.get_buffer().set_text(condition.description)
+ self.con_buffer.set_text(condition.condition)
else:
- #entry = widget.get_child()
- #name = entry.get_text()
- name = None
- self.read_section(name)
- buffer.set_text(self.read_section(name))
+ self.descr_textview.get_buffer().set_text('')
+ self.con_buffer.set_text('')
+
return
- def save_button_clicked(self, widget):
- buffer = self.textview.get_buffer()
- tree_iter = self.selection.get_active_iter()
- if tree_iter is not None:
- model = self.selection.get_model()
- name, start_line, end_line = model[tree_iter]
- new = False
- else:
- entry = self.selection.get_child()
- name = entry.get_text()
- new = True
+ def on_save_button(self, widget):
+ descr_buffer = self.descr_textview.get_buffer()
+ name = self.selection.get_active_text()
if not name:
return
- buf = buffer.get_text(buffer.get_start_iter(), buffer.get_end_iter(), True)
+ descr = descr_buffer.get_text(descr_buffer.get_start_iter(), descr_buffer.get_end_iter(), True)
+ condition = self.con_buffer.get_text(self.con_buffer.get_start_iter(), self.con_buffer.get_end_iter(), True)
+ db_interaction.write_into_pre_post_con(code_type=self.pre_post, name=name, description=descr, code_block=condition)
- if new:
- with open(self.file_path, 'a') as entry_file_obj:
- entry_file_obj.write('#####-'+name+'-#####\n')
- entry_file_obj.write(buf + '\n')
- entry_file_obj.close()
- else:
- with open(self.file_path, 'r') as entry_file_obj:
- file_lines = entry_file_obj.readlines()
- entry_file_obj.close()
- file_lines[start_line:end_line-1] = buf
-
- with open(self.file_path, 'w') as entry_file_obj:
- file_lines = "".join(file_lines)
- entry_file_obj.write(file_lines)
- entry_file_obj.close()
-
- add_lines_count = 0
- with open(self.file_path, 'r') as entry_file_obj:
- file_lines = entry_file_obj.readlines()
- if file_lines[-1]:
- add_lines_count = 2
- elif file_lines[-2]:
- add_lines_count = 1
- entry_file_obj.close()
- if add_lines_count > 0:
- with open(self.file_path, 'a') as entry_file_obj:
- entry_file_obj.write('\n'*add_lines_count)
- entry_file_obj.close()
+ time.sleep(0.1) # Sleep shorty so the condition can be written to the database
+ # Refresh the combo box entries
+ self.make_section_dict()
+ self.selection.remove_all()
+ self.make_con_sections_model()
+ return
+
+ def on_delete_button(self, widget):
+ name = self.selection.get_active_text()
+ for con in self.section_dict:
+ if con.name == name:
+ db_interaction.delete_db_row_pre_post(con.id)
+ time.sleep(0.1) # Sleep shorty so the condition can be deleted from the database
+ # Refresh the combo box entries
+ self.make_section_dict()
+ self.selection.remove_all()
+ self.make_con_sections_model()
+ self.selection.set_active(0)
return
- def make_text_viewer(self):
+ def make_description_viewer(self):
+ # Label in a Box to have it on the left boarder
+ self.descr_lbl_box = Gtk.HBox()
+ descr_lbl = Gtk.Label()
+ descr_lbl.set_text('Description: ')
+ self.descr_lbl_box.pack_start(descr_lbl, False, False, 0)
+
# a scrollbar for the child widget (that is going to be the textview)
- self.scrolled_window = Gtk.ScrolledWindow()
- self.scrolled_window.set_border_width(5)
+ self.descr_scrolled_window = Gtk.ScrolledWindow()
+ self.descr_scrolled_window.set_border_width(5)
# we scroll only if needed
- self.scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
+ self.descr_scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
# a text buffer (stores text)
buffer = Gtk.TextBuffer()
# a textview (displays the buffer)
- self.textview = Gtk.TextView(buffer=buffer)
+ self.descr_textview = Gtk.TextView(buffer=buffer)
# wrap the text, if needed, breaking lines in between words
- self.textview.set_wrap_mode(Gtk.WrapMode.WORD)
+ self.descr_textview.set_wrap_mode(Gtk.WrapMode.WORD)
# textview is scrolled
- self.scrolled_window.add(self.textview)
+ self.descr_scrolled_window.add(self.descr_textview)
+
+ def make_text_viewer(self):
+ # Label in a Box to have it on the left boarder
+ self.con_lbl_box = Gtk.HBox()
+ con_lbl = Gtk.Label()
+ con_lbl.set_text('Condition: ')
+ self.con_lbl_box.pack_start(con_lbl, False, False, 0)
+
+ self.con_scrolled_window = Gtk.ScrolledWindow()
+ #self.commands_scrolled_window.set_size_request(50, 100)
+ self.con_view = GtkSource.View()
+ self.con_view.set_auto_indent(True)
+ self.con_view.set_show_line_numbers(False)
+ # self.commands_view.set_show_right_margin(True)
+ self.con_view.set_highlight_current_line(True)
+ self.con_view.set_indent_on_tab(True)
+ self.con_view.set_insert_spaces_instead_of_tabs(True)
+ self.con_buffer = self.con_view.get_buffer()
+ self.con_buffer.set_language(lngg)
+ # self.commands_buffer.set_style_scheme(self.board.current_scheme)
+ self.con_scrolled_window.add(self.con_view)
#box = self.get_content_area()
#box.add(self.selection_box)
return
- def read_section(self, name=None):
- if not name:
- return ''
-
- # add the condition function
- with open(self.file_path,'r') as entry_file_obj:
- # Get the needed section and read only those lines
- position = self.section_dict[name]
- entry_array = entry_file_obj.readlines()[position[0]: position[1]-1]
- entry = ''
- # Make a string to combine it with the co_conditions file, add tabs for the additonal lines in form of space so the CCS can read it
- for count, line in enumerate(entry_array):
- entry += line
- entry_file_obj.close()
- return entry
+