def __init__(self,
database,
database_name,
repository_directory: str = ""):
self.db = DB(database, database_name, assertions=True)
self.scope_vars: Dict[str, Callable] = {
"commands": self.help,
"runs": self.runs,
"issues": self.issues,
"set_run": self.set_run,
"set_issue": self.set_issue,
"show": self.show,
"trace": self.trace,
"next": self.next_cursor_location,
"n": self.next_cursor_location,
"prev": self.prev_cursor_location,
"p": self.prev_cursor_location,
"expand": self.expand,
"branch": self.branch,
"list": self.list_source_code,
}
self.repository_directory = repository_directory or os.getcwd()
self.current_issue_id: int = -1
self.sources: Set[str] = set()
self.sinks: Set[str] = set()
# Tuples representing the trace of the current issue
self.trace_tuples: List[TraceTuple] = []
# Active trace frame of the current trace
self.current_trace_frame_index: int = -1
self.root_trace_frame_index: int = -1
# The current issue id when 'trace' was last run
self.trace_tuples_id: int = -1
def setUp(self) -> None:
self.db = DB("memory")
self.interactive = Interactive("memory", "")
self.interactive.db = self.db # we need the tool to refer to the same db
self.stdout = StringIO()
self.stderr = StringIO()
sys.stdout = self.stdout # redirect output
sys.stderr = self.stderr # redirect output
def cli(ctx: click.Context, repository: str, database_name: str,
database_engine: DBType):
ctx.obj = Context(
repository=repository,
database=DB(database_engine, database_name, assertions=True),
parser_class=Parser,
)
logger.debug(f"Context: {ctx.obj}")
def _save(self, database: DB, cls, pk_gen: PrimaryKeyGenerator):
# We sort keys because bulk insert uses executemany, but it can only
# group together sequential items with the same keys. If we are scattered
# then it does far more executemany calls, and it kills performance.
with database.make_session() as session:
items = sorted(
cls.prepare(session, pk_gen, consume(self.saving[cls.__name__])),
key=lambda k: list(k.keys()),
)
# bulk_insert_mappings should only be used for new objects.
# To update an existing object, just modify its attribute(s)
# and call session.commit()
for group in split_every(self.BATCH_SIZE, items):
with database.make_session() as session:
session.bulk_insert_mappings(cls, group, render_nulls=True)
session.commit()
def __init__(self, database, database_name, repository_directory: str = ""):
self.db = DB(database, database_name, assertions=True)
self.scope_vars: Dict[str, Union[Callable, TraceKind]] = {
"precondition": TraceKind.PRECONDITION,
"postcondition": TraceKind.POSTCONDITION,
"commands": self.help,
"state": self.state,
"runs": self.runs,
"issues": self.issues,
"set_run": self.set_run,
"set_issue": self.set_issue,
"show": self.show,
"trace": self.trace,
"next": self.next_cursor_location,
"n": self.next_cursor_location,
"prev": self.prev_cursor_location,
"p": self.prev_cursor_location,
"expand": self.expand,
"branch": self.branch,
"list": self.list_source_code,
"frames": self.frames,
"set_frame": self.set_frame,
}
self.repository_directory = repository_directory or os.getcwd()
self.current_run_id: int = -1
# Trace exploration relies on either of these
self.current_issue_id: int = -1
self.current_frame_id: int = -1
self.sources: Set[str] = set()
self.sinks: Set[str] = set()
# Tuples representing the trace of the current issue
self.trace_tuples: List[TraceTuple] = []
# Active trace frame of the current trace
self.current_trace_frame_index: int = -1
def analyze(
ctx: Context,
run_kind,
branch,
commit_hash,
job_id,
differential_id,
previous_issue_handles,
previous_input,
linemap,
store_unused_models,
input_file,
):
# Store all options in the right places
summary_blob = {
"run_kind": run_kind,
"compress": lambda x: x,
"repository": ctx.repository,
"branch": branch,
"commit_hash": commit_hash,
"old_linemap_file": linemap,
"store_unused_models": store_unused_models,
}
if job_id is None and differential_id is not None:
job_id = "user_input_" + str(differential_id)
summary_blob["job_id"] = job_id
if previous_issue_handles:
summary_blob["previous_issue_handles"] = AnalysisOutput.from_file(
previous_issue_handles)
elif previous_input:
previous_input = AnalysisOutput.from_file(previous_input)
# Construct pipeline
input_files = (AnalysisOutput.from_file(input_file), previous_input)
pipeline_steps = [
Parser(),
ModelGenerator(),
TrimTraceGraph(),
DatabaseSaver(
DB(ctx.database_engine, ctx.database_name, assertions=True),
PrimaryKeyGenerator(),
),
]
pipeline = Pipeline(pipeline_steps)
pipeline.run(input_files, summary_blob)
def save_all(self, database: DB, use_lock=False, dbname=""):
saving_classes = [
cls
for cls in self.SAVING_CLASSES_ORDER
if len(self.saving[cls.__name__]) is not 0
]
item_counts = {
cls.__name__: len(self.get_items_to_add(cls)) for cls in saving_classes
}
with database.make_session() as session:
pk_gen = self.primary_key_generator.reserve(
session, saving_classes, item_counts
)
for cls in saving_classes:
log.info("Saving %s...", cls.__name__)
self._save(database, cls, pk_gen)
class Interactive:
# @lint-ignore FBPYTHON2
list_string = "list()"
help_message = f"""
Commands =======================================================================
commands() show this message
help(COMAMND) more info about a command
runs() list all completed static analysis runs
set_run(ID) select a specific run for browsing issues
issues() list all issues for the selected run
set_issue(ID) select a specific issue for browsing a trace
show() show info about selected issue
trace() show a trace of the selected issue
prev()/p() move backward within the trace
next()/n() move forward within the trace
expand() show alternative trace branches
branch(INDEX) select a trace branch
{list_string} show source code at the current trace frame
"""
welcome_message = "Interactive issue exploration. Type 'commands()' for help."
LEAF_NAMES = {"source", "sink", "leaf"}
def __init__(self,
database,
database_name,
repository_directory: str = ""):
self.db = DB(database, database_name, assertions=True)
self.scope_vars: Dict[str, Callable] = {
"commands": self.help,
"runs": self.runs,
"issues": self.issues,
"set_run": self.set_run,
"set_issue": self.set_issue,
"show": self.show,
"trace": self.trace,
"next": self.next_cursor_location,
"n": self.next_cursor_location,
"prev": self.prev_cursor_location,
"p": self.prev_cursor_location,
"expand": self.expand,
"branch": self.branch,
"list": self.list_source_code,
}
self.repository_directory = repository_directory or os.getcwd()
self.current_issue_id: int = -1
self.sources: Set[str] = set()
self.sinks: Set[str] = set()
# Tuples representing the trace of the current issue
self.trace_tuples: List[TraceTuple] = []
# Active trace frame of the current trace
self.current_trace_frame_index: int = -1
self.root_trace_frame_index: int = -1
# The current issue id when 'trace' was last run
self.trace_tuples_id: int = -1
def setup(self) -> Dict[str, Callable]:
with self.db.make_session() as session:
latest_run_id = (session.query(func.max(
Run.id)).filter(Run.status == RunStatus.FINISHED).scalar())
if latest_run_id.resolved() is None:
self.warning(
"No runs found. "
f"Try running '{os.path.basename(sys.argv[0])} analyze' first."
)
self.current_run_id = latest_run_id
print("=" * len(self.welcome_message))
print(self.welcome_message)
print("=" * len(self.welcome_message))
return self.scope_vars
def help(self):
print(self.help_message)
print(f"State {'=' * 74}\n")
print(f" Database: {self.db.dbtype}:{self.db.dbname}")
print(f" Current run: {self.current_run_id}")
print(f"Current issue: {self.current_issue_id}")
def runs(self, use_pager=None):
pager = self._resolve_pager(use_pager)
with self.db.make_session() as session:
runs = session.query(Run).filter(
Run.status == RunStatus.FINISHED).all()
run_strings = [
"\n".join([f"Run {run.id}", f"Date: {run.date}", "-" * 80])
for run in runs
]
run_output = "\n".join(run_strings)
pager(run_output)
print(f"Found {len(runs)} runs.")
def set_run(self, run_id):
with self.db.make_session() as session:
selected_run = (session.query(Run).filter(
Run.status == RunStatus.FINISHED).filter(
Run.id == run_id).scalar())
if selected_run is None:
self.warning(f"Run {run_id} doesn't exist or is not finished. "
"Type 'runs()' for available runs.")
return
self.current_run_id = selected_run.id
print(f"Set run to {run_id}.")
def set_issue(self, issue_id):
with self.db.make_session() as session:
selected_issue = (session.query(IssueInstance).filter(
IssueInstance.id == issue_id).scalar())
if selected_issue is None:
self.warning(f"Issue {issue_id} doesn't exist. "
"Type 'issues()' for available issues.")
return
self.sources = set(
self._get_leaves(session, selected_issue,
SharedTextKind.SOURCE))
self.sinks = set(
self._get_leaves(session, selected_issue, SharedTextKind.SINK))
self.current_issue_id = selected_issue.id
self.current_trace_frame_index = 1 # first one after the source
print(f"Set issue to {issue_id}.")
self.show()
def show(self):
""" More details about the selected issue.
"""
if not self._verify_issue_selected():
return
with self.db.make_session() as session:
issue_instance, issue = self._get_current_issue(session)
sources = self._get_leaves(session, issue_instance,
SharedTextKind.SOURCE)
sinks = self._get_leaves(session, issue_instance,
SharedTextKind.SINK)
page.display_page(
self._create_issue_output_string(issue_instance, issue, sources,
sinks))
def issues(
self,
use_pager: bool = None,
*,
codes: Optional[List[int]] = None,
callables: Optional[List[str]] = None,
filenames: Optional[List[str]] = None,
):
"""Lists issues for the selected run.
Parameters (all optional):
use_pager: bool use a unix style pager for output
codes: list[int] issue codes to filter on
callables: list[str] callables to filter on (supports wildcards)
filenames: list[str] filenames to filter on (supports wildcards)
String filters support LIKE wildcards (%, _) from SQL:
% matches anything (like .* in regex)
_ matches 1 character (like . in regex)
For example:
callables=[
"%occurs.anywhere%",
"%at.end",
"at.start%",
"etc.",
])
"""
pager = self._resolve_pager(use_pager)
with self.db.make_session() as session:
query = (session.query(IssueInstance, Issue).filter(
IssueInstance.run_id == self.current_run_id).join(
Issue, IssueInstance.issue_id == Issue.id))
# Process filters
if codes is not None:
if not isinstance(codes, list):
self.warning("'codes' should be a list.")
return
query = query.filter(Issue.code.in_(codes))
if callables is not None:
if not isinstance(callables, list):
self.warning("'callables' should be a list.")
return
query = query.filter(
or_(*[
Issue.callable.like(callable) for callable in callables
]))
if filenames is not None:
if not isinstance(filenames, list):
self.warning("'filenames' should be a list.")
return
query = query.filter(
or_(*[
Issue.filename.like(filename) for filename in filenames
]))
issues = query.options(joinedload(IssueInstance.message)).all()
sources_list = [
self._get_leaves(session, issue_instance,
SharedTextKind.SOURCE)
for issue_instance, _ in issues
]
sinks_list = [
self._get_leaves(session, issue_instance, SharedTextKind.SINK)
for issue_instance, _ in issues
]
issue_strings = [
self._create_issue_output_string(issue_instance, issue, sources,
sinks)
for (
issue_instance,
issue), sources, sinks in zip(issues, sources_list, sinks_list)
]
issue_output = f"\n{'-' * 80}\n".join(issue_strings)
pager(issue_output)
print(f"Found {len(issues)} issues with run_id {self.current_run_id}.")
def trace(self):
"""Show a trace for the selected issue.
The '-->' token points to the currently active trace frame within the
trace.
Trace output has 4 columns:
- branches: the number of siblings a node has (including itself)
[indicates that the trace branches into multiple paths]
- callable: the name of the object that was called
- port/condition: a description of the type of trace frame
- source: where data originally comes from
- root: the main callable through which the data propagates
- sink: where data eventually flows to
- location: the relative location of the trace frame's source code
Example output:
[branches] [callable] [port] [location]
+ 2 leaf source module/main.py:26|4|8
--> module.main root module/helper.py:76|5|10
module.helper.process root module/helper.py:76|5|10
+ 3 leaf sink module/main.py:74|1|9
"""
if not self._verify_issue_selected():
return
self._generate_trace()
self._output_trace_tuples(self.trace_tuples)
def _generate_trace(self):
if self.trace_tuples_id == self.current_issue_id:
return # already generated
with self.db.make_session() as session:
issue_instance, issue = self._get_current_issue(session)
postcondition_navigation = self._navigate_trace_frames(
session,
self._initial_trace_frames(session, issue_instance.id,
TraceKind.POSTCONDITION),
)
precondition_navigation = self._navigate_trace_frames(
session,
self._initial_trace_frames(session, issue_instance.id,
TraceKind.PRECONDITION),
)
self.trace_tuples = (
self._create_trace_tuples(reversed(postcondition_navigation)) + [
TraceTuple(trace_frame=TraceFrame(
callee=issue.callable,
callee_port="root",
filename=issue_instance.filename,
callee_location=issue_instance.location,
))
] + self._create_trace_tuples(precondition_navigation))
self.trace_tuples_id = self.current_issue_id
self.root_trace_frame_index = len(postcondition_navigation)
self.current_trace_frame_index = self.root_trace_frame_index
def next_cursor_location(self):
"""Move cursor to the next trace frame.
"""
if not self._verify_issue_selected():
return
self._generate_trace() # make sure self.trace_tuples exists
self.current_trace_frame_index = min(
self.current_trace_frame_index + 1,
len(self.trace_tuples) - 1)
self.trace()
def prev_cursor_location(self):
"""Move cursor to the previous trace frame.
"""
if not self._verify_issue_selected():
return
self._generate_trace() # make sure self.trace_tuples exists
self.current_trace_frame_index = max(
self.current_trace_frame_index - 1, 0)
self.trace()
def expand(self):
"""Show and select branches for a branched trace.
- [*] signifies the current branch that is selected
Example output:
Suppose we have the trace output:
[branches] [callable] [port] [location]
--> + 2 leaf source module/main.py:26|4|8
module.main root module/helper.py:76|5|10
module.helper.process root module/helper.py:76|5|10
+ 3 leaf sink module/main.py:74|1|9
Calling expand will result in the output:
[*] leaf
[0 hops: source]
[module/main.py:26|4|8]
[1] module.helper.preprocess
[1 hops: source]
[module/main.py:21|4|8]
"""
if not self._verify_issue_selected(
) or not self._verify_multiple_branches():
return
current_trace_tuple = self.trace_tuples[self.current_trace_frame_index]
filter_leaves = (self.sources if current_trace_tuple.trace_frame.kind
== TraceKind.POSTCONDITION else self.sinks)
with self.db.make_session() as session:
branches = self._get_trace_frame_branches(session)
leaves_strings = [
", ".join([
leaf.contents for leaf in frame.leaves
if leaf.contents in filter_leaves
]) for frame in branches
]
self._output_trace_expansion(branches, leaves_strings)
def branch(self, selected_index: int) -> None:
"""Selects a branch when there are multiple possible traces to follow.
The trace output that follows includes the new branch and its children
frames.
Parameters:
selected_index: int branch index from expand() output
"""
if not self._verify_issue_selected(
) or not self._verify_multiple_branches():
return
with self.db.make_session() as session:
branches = self._get_trace_frame_branches(session)
if selected_index < 0 or selected_index >= len(branches):
self.warning(
"Branch index out of bounds "
f"(expected 0-{len(branches) - 1} but got {selected_index})."
)
return
new_navigation = self._navigate_trace_frames(
session, branches, selected_index)
new_trace_tuples = self._create_trace_tuples(new_navigation)
if self._is_before_root():
new_trace_tuples.reverse()
self.trace_tuples = (
new_trace_tuples +
self.trace_tuples[self.current_trace_frame_index + 1:])
# If length of prefix changes, it will change some indices
trace_frame_index_delta = (len(new_navigation) -
self.current_trace_frame_index - 1)
self.current_trace_frame_index += trace_frame_index_delta
self.root_trace_frame_index += trace_frame_index_delta
else:
self.trace_tuples = (
self.trace_tuples[:self.current_trace_frame_index] +
new_trace_tuples)
self.trace()
def list_source_code(self, context: int = 5) -> None:
"""Show source code around the current trace frame location.
Parameters:
context: int number of lines to show above and below trace location
(default: 5)
"""
if not self._verify_issue_selected():
return
self._generate_trace()
current_trace_frame = self.trace_tuples[
self.current_trace_frame_index].trace_frame
filename = os.path.join(self.repository_directory,
current_trace_frame.filename)
file_lines: List[str] = []
try:
# Use readlines instead of enumerate(file) because mock_open
# doesn't support __iter__ until python 3.7.1.
with open(filename, "r") as file:
file_lines = file.readlines()
except FileNotFoundError:
self.warning(f"Couldn't open {filename}.")
return
self._output_file_lines(current_trace_frame, file_lines, context)
def warning(self, message: str) -> None:
print(message, file=sys.stderr)
def _get_trace_frame_branches(self, session: Session) -> List[TraceFrame]:
delta_from_parent = 1 if self._is_before_root() else -1
parent_index = self.current_trace_frame_index + delta_from_parent
if parent_index == self.root_trace_frame_index:
kind = (TraceKind.POSTCONDITION
if self._is_before_root() else TraceKind.PRECONDITION)
return self._initial_trace_frames(session, self.current_issue_id,
kind)
parent_trace_frame = self.trace_tuples[parent_index].trace_frame
return self._next_trace_frames(session, parent_trace_frame)
def _is_before_root(self) -> bool:
return self.current_trace_frame_index < self.root_trace_frame_index
def _current_branch_index(self, branches: List[TraceFrame]) -> int:
selected_branch_id = int(
self.trace_tuples[self.current_trace_frame_index].trace_frame.id)
for i, branch in enumerate(branches):
if selected_branch_id == int(branch.id):
return i
return -1
def _output_file_lines(self, trace_frame: TraceFrame,
file_lines: List[str], context: int) -> None:
print(f"{trace_frame.filename}:{trace_frame.callee_location}")
center_line_number = trace_frame.callee_location.line_no
line_number_width = len(str(center_line_number + context))
for i in range(
max(center_line_number - context, 1),
min(center_line_number + context, len(file_lines)) + 1,
):
line = file_lines[i - 1]
prefix = " --> " if i == center_line_number else " " * 5
prefix += f"{i:<{line_number_width}} "
if sys.stdout.isatty():
line = highlight(
line,
get_lexer_for_filename(trace_frame.filename),
TerminalFormatter(),
)
print(f"{prefix} {line}", end="")
def _output_trace_expansion(self, trace_frames: List[TraceFrame],
leaves_strings: List[str]) -> None:
for i, (frame, leaves) in enumerate(zip(trace_frames, leaves_strings)):
prefix = ("[*]" if i == self._current_branch_index(trace_frames)
else f"[{i}]")
print(f"{prefix} {frame.callee} : {frame.callee_port}")
print(
f"{' ' * 8}[{frame.leaf_assoc[0].trace_length} hops: {leaves}]"
)
print(f"{' ' * 8}[{frame.filename}:{frame.callee_location}]")
def _output_trace_tuples(self, trace_tuples):
expand = "+ "
max_length_callable = max(
max(
len(trace_tuple.trace_frame.callee)
for trace_tuple in trace_tuples),
len("[callable]"),
)
max_length_condition = max(
max(
len(trace_tuple.trace_frame.callee_port)
for trace_tuple in trace_tuples),
len("[port]"),
)
max_length_branches = max(
max(
len(str(trace_tuple.branches)) + len(expand)
for trace_tuple in trace_tuples),
len("[branches]"),
)
print( # table header
f"{' ' * 5}"
f"{'[branches]':{max_length_branches}}"
f" {'[callable]':{max_length_callable}}"
f" {'[port]':{max_length_condition}}"
f" [location]")
for i, trace_tuple in enumerate(trace_tuples):
prefix = "-->" if i == self.current_trace_frame_index else " " * 3
if trace_tuple.missing:
output_string = (
f" {prefix}"
f" [Missing trace frame: {trace_tuple.trace_frame.callee}:"
f"{trace_tuple.trace_frame.callee_port}]")
else:
branches_string = (
f"{expand}"
f"{str(trace_tuple.branches):{max_length_branches - len(expand)}}"
if trace_tuple.branches > 1 else " " * max_length_branches)
output_string = (
f" {prefix}"
f" {branches_string}"
f" {trace_tuple.trace_frame.callee:{max_length_callable}}"
f" {trace_tuple.trace_frame.callee_port:{max_length_condition}}"
f" {trace_tuple.trace_frame.filename}"
f":{trace_tuple.trace_frame.callee_location}")
print(output_string)
def _create_trace_tuples(self, navigation):
return [
TraceTuple(
trace_frame=trace_frame,
branches=branches,
missing=trace_frame.caller is None,
) for trace_frame, branches in navigation
]
def _initial_trace_frames(self, session, issue_instance_id, kind):
return (session.query(TraceFrame).filter(
TraceFrame.issue_instances.any(id=issue_instance_id)).filter(
TraceFrame.kind == kind).join(TraceFrame.leaf_assoc).group_by(
TraceFrame.id).order_by(TraceFrameLeafAssoc.trace_length,
TraceFrame.callee_location).all())
def _navigate_trace_frames(self,
session: Session,
initial_trace_frames: List[TraceFrame],
index: int = 0) -> List[Tuple[TraceFrame, int]]:
if not initial_trace_frames:
return []
trace_frames = [(initial_trace_frames[index],
len(initial_trace_frames))]
while not self._is_leaf(trace_frames[-1]):
trace_frame, branches = trace_frames[-1]
next_nodes = self._next_trace_frames(session, trace_frame)
if len(next_nodes) == 0:
# Denote a missing frame by setting caller to None
trace_frames.append((
TraceFrame( # pyre-ignore: T41318465
callee=trace_frame.callee,
callee_port=trace_frame.callee_port,
caller=None,
),
0,
))
return trace_frames
trace_frames.append((next_nodes[0], len(next_nodes)))
return trace_frames
def _is_leaf(self, node: Tuple[TraceFrame, int]) -> bool:
trace_frame, branches = node
return trace_frame.callee_port in self.LEAF_NAMES
def _next_trace_frames(self, session, trace_frame):
results = (
session.query(TraceFrame).filter(
TraceFrame.run_id == self.current_run_id).filter(
TraceFrame.caller !=
TraceFrame.callee) # skip recursive calls for now
.filter(TraceFrame.caller == trace_frame.callee).filter(
TraceFrame.caller_port == trace_frame.callee_port).join(
TraceFrame.leaf_assoc).group_by(TraceFrame.id).order_by(
TraceFrameLeafAssoc.trace_length,
TraceFrame.callee_location).all())
filter_leaves = (self.sources if trace_frame.kind
== TraceKind.POSTCONDITION else self.sinks)
filtered_results = [
frame for frame in results if filter_leaves.intersection(
{leaf.contents
for leaf in frame.leaves})
]
return filtered_results
def _create_issue_output_string(self, issue_instance, issue, sources,
sinks):
sources_output = f"\n{' ' * 10}".join(sources)
sinks_output = f"\n{' ' * 10}".join(sinks)
return "\n".join([
f"Issue {issue_instance.id}",
f" Code: {issue.code}",
f" Message: {issue_instance.message.contents}",
f"Callable: {issue.callable}",
f" Sources: {sources_output if sources_output else 'No sources'}",
f" Sinks: {sinks_output if sinks_output else 'No sinks'}",
(f"Location: {issue_instance.filename}"
f":{SourceLocation.to_string(issue_instance.location)}"),
])
def _resolve_pager(self, use_pager):
use_pager = sys.stdout.isatty() if use_pager is None else use_pager
return page.page if use_pager else page.display_page
def _get_current_issue(self, session):
return (session.query(
IssueInstance,
Issue).filter(IssueInstance.id == self.current_issue_id).join(
Issue, IssueInstance.issue_id == Issue.id).options(
joinedload(IssueInstance.message)).first())
def _get_leaves(self, session: Session, issue_instance: IssueInstance,
kind: SharedTextKind) -> List[str]:
return [
leaf for leaf, in session.query(distinct(SharedText.contents)).
join(SharedText.shared_text_issue_instance).filter(
SharedText.issue_instances.any(id=issue_instance.id)).filter(
SharedText.kind == kind).all()
]
def _verify_issue_selected(self) -> bool:
if self.current_issue_id == -1:
self.warning("Use 'set_issue(ID)' to select an issue first.")
return False
return True
def _verify_multiple_branches(self) -> bool:
self._generate_trace() # make sure self.trace_tuples exists
current_trace_tuple = self.trace_tuples[self.current_trace_frame_index]
if current_trace_tuple.branches < 2:
self.warning("This trace frame has no alternate branches to take.")
return False
return True
class InteractiveTest(TestCase):
def setUp(self) -> None:
self.db = DB("memory")
self.interactive = Interactive("memory", "")
self.interactive.db = self.db # we need the tool to refer to the same db
self.stdout = StringIO()
self.stderr = StringIO()
sys.stdout = self.stdout # redirect output
sys.stderr = self.stderr # redirect output
def tearDown(self) -> None:
sys.stdout = sys.__stdout__ # reset redirect
sys.stderr = sys.__stderr__ # reset redirect
def _clear_stdout(self):
self.stdout = StringIO()
sys.stdout = self.stdout
def _add_to_session(self, session, data):
if not isinstance(data, list):
session.add(data)
return
for row in data:
session.add(row)
def _generic_issue(
self, id: int = 1, callable: str = "call1", filename: str = "file.py"
) -> Issue:
return Issue( # pyre-ignore: T41318465
id=id,
handle=str(id),
first_seen=datetime.now(),
code=1000 + id - 1,
callable=callable,
filename=filename,
)
def _generic_issue_instance(
self, id: int = 1, run_id: int = 1, issue_id: int = 1
) -> IssueInstance:
return IssueInstance( # pyre-ignore: T41318465
id=id,
run_id=run_id,
message_id=1,
filename="file.py",
location=SourceLocation(1, 2, 3),
issue_id=issue_id,
)
def testListIssuesBasic(self):
issues = [
self._generic_issue(id=1, callable="module.function1"),
self._generic_issue(id=2, callable="module.function2"),
]
message = SharedText(id=1, contents="message1")
run = Run(id=1, date=datetime.now())
issue_instance = self._generic_issue_instance()
with self.db.make_session() as session:
self._add_to_session(session, issues)
session.add(message)
session.add(run)
session.add(issue_instance)
session.commit()
self.interactive.setup()
self.interactive.issues()
output = self.stdout.getvalue().strip()
self.assertIn("Issue 1", output)
self.assertIn("Code: 1000", output)
self.assertIn("Message: message1", output)
self.assertIn("Callable: module.function1", output)
self.assertIn("Location: file.py:1|2|3", output)
self.assertNotIn("module.function2", output)
def testListIssuesFromLatestRun(self):
issue = self._generic_issue()
message = SharedText(id=1, contents="message1")
runs = [
Run(id=1, date=datetime.now(), status=RunStatus.FINISHED),
Run(id=2, date=datetime.now(), status=RunStatus.FINISHED),
]
issue_instances = [
self._generic_issue_instance(id=1, run_id=1),
self._generic_issue_instance(id=2, run_id=2),
]
with self.db.make_session() as session:
session.add(issue)
session.add(message)
self._add_to_session(session, runs)
self._add_to_session(session, issue_instances)
session.commit()
self.interactive.setup()
self.interactive.issues()
output = self.stdout.getvalue().strip()
self.assertNotIn("Issue 1", output)
self.assertIn("Issue 2", output)
def _list_issues_filter_setup(self):
run = Run(id=1, date=datetime.now(), status=RunStatus.FINISHED)
issues = [
self._generic_issue(
id=1, callable="module.sub.function1", filename="module/sub.py"
),
self._generic_issue(
id=2, callable="module.sub.function2", filename="module/sub.py"
),
self._generic_issue(
id=3, callable="module.function3", filename="module/__init__.py"
),
]
issue_instances = [
self._generic_issue_instance(id=1, issue_id=1),
self._generic_issue_instance(id=2, issue_id=2),
self._generic_issue_instance(id=3, issue_id=3),
]
with self.db.make_session() as session:
session.add(run)
self._add_to_session(session, issues)
self._add_to_session(session, issue_instances)
session.commit()
def testListIssuesFilterCodes(self):
self._list_issues_filter_setup()
self.interactive.setup()
self.interactive.issues(codes=1000)
stderr = self.stderr.getvalue().strip()
self.assertIn("'codes' should be a list", stderr)
self.interactive.issues(codes=[1000])
output = self.stdout.getvalue().strip()
self.assertIn("Issue 1", output)
self.assertNotIn("Issue 2", output)
self.assertNotIn("Issue 3", output)
self._clear_stdout()
self.interactive.issues(codes=[1001, 1002])
output = self.stdout.getvalue().strip()
self.assertNotIn("Issue 1", output)
self.assertIn("Issue 2", output)
self.assertIn("Issue 3", output)
def testListIssuesFilterCallables(self):
self._list_issues_filter_setup()
self.interactive.setup()
self.interactive.issues(callables="function3")
stderr = self.stderr.getvalue().strip()
self.assertIn("'callables' should be a list", stderr)
self.interactive.issues(callables=["%sub%"])
output = self.stdout.getvalue().strip()
self.assertIn("Issue 1", output)
self.assertIn("Issue 2", output)
self.assertNotIn("Issue 3", output)
self._clear_stdout()
self.interactive.issues(callables=["%function3"])
output = self.stdout.getvalue().strip()
self.assertNotIn("Issue 1", output)
self.assertNotIn("Issue 2", output)
self.assertIn("Issue 3", output)
def testListIssuesFilterFilenames(self):
self._list_issues_filter_setup()
self.interactive.setup()
self.interactive.issues(filenames="hello.py")
stderr = self.stderr.getvalue().strip()
self.assertIn("'filenames' should be a list", stderr)
self.interactive.issues(filenames=["module/s%"])
output = self.stdout.getvalue().strip()
self.assertIn("Issue 1", output)
self.assertIn("Issue 2", output)
self.assertNotIn("Issue 3", output)
self._clear_stdout()
self.interactive.issues(filenames=["%__init__.py"])
output = self.stdout.getvalue().strip()
self.assertNotIn("Issue 1", output)
self.assertNotIn("Issue 2", output)
self.assertIn("Issue 3", output)
def testNoRunsFound(self):
self.interactive.setup()
stderr = self.stderr.getvalue().strip()
self.assertIn("No runs found.", stderr)
def testListRuns(self):
runs = [
Run(id=1, date=datetime.now(), status=RunStatus.FINISHED),
Run(id=2, date=datetime.now(), status=RunStatus.INCOMPLETE),
Run(id=3, date=datetime.now(), status=RunStatus.FINISHED),
]
with self.db.make_session() as session:
self._add_to_session(session, runs)
session.commit()
self.interactive.setup()
self.interactive.runs()
output = self.stdout.getvalue().strip()
self.assertIn("Run 1", output)
self.assertNotIn("Run 2", output)
self.assertIn("Run 3", output)
def testSetRun(self):
runs = [
Run(id=1, date=datetime.now(), status=RunStatus.FINISHED),
Run(id=2, date=datetime.now(), status=RunStatus.FINISHED),
]
issue = self._generic_issue()
issue_instances = [
self._generic_issue_instance(id=1, run_id=1),
self._generic_issue_instance(id=2, run_id=2),
]
with self.db.make_session() as session:
self._add_to_session(session, runs)
self._add_to_session(session, issue_instances)
session.add(issue)
session.commit()
self.interactive.setup()
self.interactive.set_run(1)
self.interactive.issues()
output = self.stdout.getvalue().strip()
self.assertIn("Issue 1", output)
self.assertNotIn("Issue 2", output)
def testSetRunNonExistent(self):
runs = [
Run(id=1, date=datetime.now(), status=RunStatus.FINISHED),
Run(id=2, date=datetime.now(), status=RunStatus.INCOMPLETE),
]
with self.db.make_session() as session:
self._add_to_session(session, runs)
session.commit()
self.interactive.setup()
self.interactive.set_run(2)
self.interactive.set_run(3)
stderr = self.stderr.getvalue().strip()
self.assertIn("Run 2 doesn't exist", stderr)
self.assertIn("Run 3 doesn't exist", stderr)
def testSetIssue(self):
run = Run(id=1, date=datetime.now(), status=RunStatus.FINISHED)
issue = self._generic_issue()
issue_instances = [
self._generic_issue_instance(id=1, run_id=1),
self._generic_issue_instance(id=2, run_id=2),
self._generic_issue_instance(id=3, run_id=3),
]
with self.db.make_session() as session:
session.add(run)
session.add(issue)
self._add_to_session(session, issue_instances)
session.commit()
self.interactive.setup()
self.interactive.set_issue(2)
self.interactive.show()
stdout = self.stdout.getvalue().strip()
self.assertNotIn("Issue 1", stdout)
self.assertIn("Issue 2", stdout)
self.assertNotIn("Issue 3", stdout)
self.interactive.set_issue(1)
self.interactive.show()
stdout = self.stdout.getvalue().strip()
self.assertIn("Issue 1", stdout)
self.assertNotIn("Issue 3", stdout)
def testSetIssueNonExistent(self):
run = Run(id=1, date=datetime.now(), status=RunStatus.FINISHED)
with self.db.make_session() as session:
session.add(run)
session.commit()
self.interactive.setup()
self.interactive.set_issue(1)
stderr = self.stderr.getvalue().strip()
self.assertIn("Issue 1 doesn't exist", stderr)
def testGetSources(self):
issue_instance = self._generic_issue_instance()
sources = [
SharedText(id=1, contents="source1", kind=SharedTextKind.SOURCE),
SharedText(id=2, contents="source2", kind=SharedTextKind.SOURCE),
SharedText(id=3, contents="source3", kind=SharedTextKind.SOURCE),
]
assocs = [
IssueInstanceSharedTextAssoc(shared_text_id=1, issue_instance_id=1),
IssueInstanceSharedTextAssoc(shared_text_id=2, issue_instance_id=1),
]
with self.db.make_session() as session:
session.add(issue_instance)
self._add_to_session(session, sources)
self._add_to_session(session, assocs)
session.commit()
sources = self.interactive._get_leaves(
session, issue_instance, SharedTextKind.SOURCE
)
self.assertEqual(len(sources), 2)
self.assertIn("source1", sources)
self.assertIn("source2", sources)
def testGetSinks(self):
return
issue_instance = self._generic_issue_instance()
sinks = [
SharedText(id=1, contents="sink1", kind=SharedTextKind.SINK),
SharedText(id=2, contents="sink2", kind=SharedTextKind.SINK),
SharedText(id=3, contents="sink3", kind=SharedTextKind.SINK),
]
assocs = [
IssueInstanceSharedTextAssoc(shared_text_id=1, issue_instance_id=1),
IssueInstanceSharedTextAssoc(shared_text_id=2, issue_instance_id=1),
]
with self.db.make_session() as session:
session.add(issue_instance)
self._add_to_session(session, sinks)
self._add_to_session(session, assocs)
session.commit()
sinks = self.interactive._get_leaves(
session, issue_instance, SharedTextKind.SINK
)
self.assertEqual(len(sinks), 2)
self.assertIn("sink1", sinks)
self.assertIn("sink2", sinks)
def _basic_trace_frames(self):
return [
TraceFrame(
id=1,
kind=TraceKind.PRECONDITION,
caller="call1",
caller_port="root",
callee="call2",
callee_port="param0",
callee_location=SourceLocation(1, 1),
filename="file.py",
run_id=1,
),
TraceFrame(
id=2,
kind=TraceKind.PRECONDITION,
caller="call2",
caller_port="param0",
callee="leaf",
callee_port="sink",
callee_location=SourceLocation(1, 2),
filename="file.py",
run_id=1,
),
]
def testNextTraceFrames(self):
run = Run(id=1, date=datetime.now(), status=RunStatus.FINISHED)
trace_frames = self._basic_trace_frames()
sink = SharedText(id=1, contents="sink1", kind=SharedTextKind.SINK)
assoc = TraceFrameLeafAssoc(trace_frame_id=2, leaf_id=1, trace_length=1)
with self.db.make_session() as session:
self._add_to_session(session, trace_frames)
session.add(run)
session.add(sink)
session.add(assoc)
session.commit()
self.interactive.setup()
self.interactive.sinks = {"sink1"}
next_frames = self.interactive._next_trace_frames(session, trace_frames[0])
self.assertEqual(len(next_frames), 1)
self.assertEqual(int(next_frames[0].id), int(trace_frames[1].id))
def testNextTraceFramesMultipleRuns(self):
runs = [
Run(id=1, date=datetime.now(), status=RunStatus.FINISHED),
Run(id=2, date=datetime.now(), status=RunStatus.FINISHED),
]
trace_frames_run1 = self._basic_trace_frames()
trace_frames_run2 = self._basic_trace_frames()
trace_frames_run2[0].id = 3
trace_frames_run2[0].run_id = 2
trace_frames_run2[1].id = 4
trace_frames_run2[1].run_id = 2
sink = SharedText(id=1, contents="sink1", kind=SharedTextKind.SINK)
assocs = [
TraceFrameLeafAssoc(trace_frame_id=2, leaf_id=1, trace_length=0),
TraceFrameLeafAssoc(trace_frame_id=4, leaf_id=1, trace_length=0),
]
with self.db.make_session() as session:
self._add_to_session(session, trace_frames_run1)
self._add_to_session(session, trace_frames_run2)
self._add_to_session(session, runs)
self._add_to_session(session, assocs)
session.add(sink)
session.commit()
self.interactive.setup()
self.interactive.sinks = {"sink1"}
next_frames = self.interactive._next_trace_frames(
session, trace_frames_run2[0]
)
self.assertEqual(len(next_frames), 1)
self.assertEqual(int(next_frames[0].id), int(trace_frames_run2[1].id))
def testNavigateTraceFrames(self):
run = Run(id=1, date=datetime.now(), status=RunStatus.FINISHED)
trace_frames = self._basic_trace_frames()
sink = SharedText(id=1, contents="sink1", kind=SharedTextKind.SINK)
assoc = TraceFrameLeafAssoc(trace_frame_id=2, leaf_id=1, trace_length=1)
with self.db.make_session() as session:
self._add_to_session(session, trace_frames)
session.add(run)
session.add(sink)
session.add(assoc)
session.commit()
self.interactive.setup()
self.interactive.sinks = {"sink1"}
result = self.interactive._navigate_trace_frames(session, [trace_frames[0]])
self.assertEqual(len(result), 2)
self.assertEqual(int(result[0][0].id), 1)
self.assertEqual(int(result[1][0].id), 2)
def testCreateTraceTuples(self):
# reverse order
postcondition_traces = [
(
TraceFrame(
callee="call3",
callee_port="result",
filename="file3.py",
callee_location=SourceLocation(1, 1, 3),
caller="main",
caller_port="root",
),
1,
),
(
TraceFrame(
callee="call2",
callee_port="result",
caller="dummy caller",
filename="file2.py",
callee_location=SourceLocation(1, 1, 2),
),
2,
),
(
TraceFrame(
callee="leaf",
callee_port="source",
caller="dummy caller",
filename="file1.py",
callee_location=SourceLocation(1, 1, 1),
),
3,
),
]
trace_tuples = self.interactive._create_trace_tuples(postcondition_traces)
self.assertEqual(len(trace_tuples), 3)
self.assertEqual(
trace_tuples,
[
TraceTuple(postcondition_traces[0][0], 1),
TraceTuple(postcondition_traces[1][0], 2),
TraceTuple(postcondition_traces[2][0], 3),
],
)
def testOutputTraceTuples(self):
trace_tuples = [
TraceTuple(
trace_frame=TraceFrame(
callee="leaf",
callee_port="source",
filename="file1.py",
callee_location=SourceLocation(1, 1, 1),
)
),
TraceTuple(
trace_frame=TraceFrame(
callee="call2",
callee_port="result",
filename="file2.py",
callee_location=SourceLocation(1, 1, 2),
)
),
TraceTuple(
trace_frame=TraceFrame(
callee="call3",
callee_port="result",
filename="file3.py",
callee_location=SourceLocation(1, 1, 3),
)
),
TraceTuple(
trace_frame=TraceFrame(
callee="main",
callee_port="root",
filename="file4.py",
callee_location=SourceLocation(1, 1, 4),
)
),
TraceTuple(
trace_frame=TraceFrame(
callee="call4",
callee_port="param0",
filename="file4.py",
callee_location=SourceLocation(1, 1, 4),
)
),
TraceTuple(
trace_frame=TraceFrame(
callee="call5",
callee_port="param1",
filename="file5.py",
callee_location=SourceLocation(1, 1, 5),
)
),
TraceTuple(
trace_frame=TraceFrame(
callee="leaf",
callee_port="sink",
filename="file6.py",
callee_location=SourceLocation(1, 1, 6),
)
),
]
self.interactive.current_trace_frame_index = 1
self.interactive._output_trace_tuples(trace_tuples)
output = self.stdout.getvalue()
self.assertEqual(
output.split("\n"),
[
" [branches] [callable] [port] [location]",
" leaf source file1.py:1|1|1",
" --> call2 result file2.py:1|1|2",
" call3 result file3.py:1|1|3",
" main root file4.py:1|1|4",
" call4 param0 file4.py:1|1|4",
" call5 param1 file5.py:1|1|5",
" leaf sink file6.py:1|1|6",
"",
],
)
self._clear_stdout()
self.interactive.current_trace_frame_index = 4
self.interactive._output_trace_tuples(trace_tuples)
output = self.stdout.getvalue()
self.assertEqual(
output.split("\n"),
[
" [branches] [callable] [port] [location]",
" leaf source file1.py:1|1|1",
" call2 result file2.py:1|1|2",
" call3 result file3.py:1|1|3",
" main root file4.py:1|1|4",
" --> call4 param0 file4.py:1|1|4",
" call5 param1 file5.py:1|1|5",
" leaf sink file6.py:1|1|6",
"",
],
)
def testTrace(self):
run = Run(id=1, date=datetime.now(), status=RunStatus.FINISHED)
issue = self._generic_issue()
issue_instance = self._generic_issue_instance()
trace_frames = [
TraceFrame(
id=1,
kind=TraceKind.POSTCONDITION,
caller="call1",
caller_port="root",
callee="leaf",
callee_port="source",
callee_location=SourceLocation(1, 1, 1),
filename="file.py",
run_id=1,
),
TraceFrame(
id=2,
kind=TraceKind.PRECONDITION,
caller="call1",
caller_port="root",
callee="leaf",
callee_port="sink",
callee_location=SourceLocation(1, 1, 2),
filename="file.py",
run_id=1,
),
]
assocs = [
IssueInstanceTraceFrameAssoc(trace_frame_id=1, issue_instance_id=1),
IssueInstanceTraceFrameAssoc(trace_frame_id=2, issue_instance_id=1),
TraceFrameLeafAssoc(trace_frame_id=1, leaf_id=1),
TraceFrameLeafAssoc(trace_frame_id=2, leaf_id=1),
]
with self.db.make_session() as session:
session.add(run)
session.add(issue)
session.add(issue_instance)
self._add_to_session(session, trace_frames)
self._add_to_session(session, assocs)
session.commit()
self.interactive.setup()
self.interactive.trace()
stderr = self.stderr.getvalue().strip()
self.assertIn("Use 'set_issue(ID)' to select an issue first.", stderr)
self.interactive.set_issue(1)
self.interactive.trace()
output = self.stdout.getvalue().strip()
self.assertIn(" leaf source file.py:1|1|1", output)
self.assertIn(" --> call1 root file.py:1|2|3", output)
self.assertIn(" leaf sink file.py:1|1|2", output)
def testTraceMissingFrames(self):
run = Run(id=1, date=datetime.now(), status=RunStatus.FINISHED)
issue = self._generic_issue()
issue_instance = self._generic_issue_instance()
trace_frames = [
TraceFrame(
id=1,
kind=TraceKind.POSTCONDITION,
caller="call1",
caller_port="root",
callee="leaf",
callee_port="source",
callee_location=SourceLocation(1, 1, 1),
filename="file.py",
run_id=1,
),
TraceFrame(
id=2,
kind=TraceKind.PRECONDITION,
caller="call1",
caller_port="root",
callee="call2",
callee_port="param0",
callee_location=SourceLocation(1, 1, 1),
filename="file.py",
run_id=1,
),
]
assocs = [
IssueInstanceTraceFrameAssoc(trace_frame_id=1, issue_instance_id=1),
IssueInstanceTraceFrameAssoc(trace_frame_id=2, issue_instance_id=1),
TraceFrameLeafAssoc(trace_frame_id=1, leaf_id=1),
TraceFrameLeafAssoc(trace_frame_id=2, leaf_id=1),
]
with self.db.make_session() as session:
session.add(run)
session.add(issue)
session.add(issue_instance)
self._add_to_session(session, trace_frames)
self._add_to_session(session, assocs)
session.commit()
self.interactive.setup()
self.interactive.set_issue(1)
self.interactive.trace()
stdout = self.stdout.getvalue().strip()
self.assertIn("Missing trace frame: call2:param0", stdout)
def testTraceCursorLocation(self):
run = Run(id=1, date=datetime.now(), status=RunStatus.FINISHED)
issue = self._generic_issue()
issue_instance = self._generic_issue_instance()
trace_frames = [
TraceFrame(
id=1,
kind=TraceKind.POSTCONDITION,
caller="call1",
caller_port="root",
callee="leaf",
callee_port="source",
callee_location=SourceLocation(1, 1),
filename="file.py",
run_id=1,
),
TraceFrame(
id=2,
kind=TraceKind.PRECONDITION,
caller="call1",
caller_port="root",
callee="leaf",
callee_port="sink",
callee_location=SourceLocation(1, 2),
filename="file.py",
run_id=1,
),
]
assocs = [
IssueInstanceTraceFrameAssoc(trace_frame_id=1, issue_instance_id=1),
IssueInstanceTraceFrameAssoc(trace_frame_id=2, issue_instance_id=1),
TraceFrameLeafAssoc(trace_frame_id=1, leaf_id=1),
TraceFrameLeafAssoc(trace_frame_id=2, leaf_id=1),
]
with self.db.make_session() as session:
session.add(run)
session.add(issue)
session.add(issue_instance)
self._add_to_session(session, trace_frames)
self._add_to_session(session, assocs)
session.commit()
self.interactive.setup()
self.interactive.set_issue(1)
self.assertEqual(self.interactive.current_trace_frame_index, 1)
self.interactive.next_cursor_location()
self.assertEqual(self.interactive.current_trace_frame_index, 2)
self.interactive.next_cursor_location()
self.assertEqual(self.interactive.current_trace_frame_index, 2)
self.interactive.prev_cursor_location()
self.assertEqual(self.interactive.current_trace_frame_index, 1)
self.interactive.prev_cursor_location()
self.assertEqual(self.interactive.current_trace_frame_index, 0)
self.interactive.prev_cursor_location()
self.assertEqual(self.interactive.current_trace_frame_index, 0)
def testTraceNoSinks(self):
run = Run(id=1, date=datetime.now(), status=RunStatus.FINISHED)
issue = self._generic_issue()
issue_instance = self._generic_issue_instance()
trace_frame = TraceFrame(
id=1,
kind=TraceKind.POSTCONDITION,
caller="call1",
caller_port="root",
callee="leaf",
callee_port="source",
callee_location=SourceLocation(1, 1),
filename="file.py",
run_id=1,
)
source = SharedText(id=1, contents="source1", kind=SharedTextKind.SOURCE)
assocs = [
IssueInstanceTraceFrameAssoc(trace_frame_id=1, issue_instance_id=1),
TraceFrameLeafAssoc(trace_frame_id=1, leaf_id=1),
]
with self.db.make_session() as session:
session.add(run)
session.add(issue)
session.add(issue_instance)
session.add(trace_frame)
session.add(source)
self._add_to_session(session, assocs)
session.commit()
self.interactive.setup()
self.interactive.sources = {"source1"}
self.interactive.set_issue(1)
self._clear_stdout()
self.interactive.trace()
self.assertEqual(
self.stdout.getvalue().split("\n"),
[
" [branches] [callable] [port] [location]",
" leaf source file.py:1|1|1",
" --> call1 root file.py:1|2|3",
"",
],
)
def _set_up_branched_trace(self):
run = Run(id=1, date=datetime.now(), status=RunStatus.FINISHED)
issue = self._generic_issue()
issue_instance = self._generic_issue_instance()
messages = [
SharedText(id=1, contents="source1", kind=SharedTextKind.SOURCE),
SharedText(id=2, contents="sink1", kind=SharedTextKind.SINK),
]
trace_frames = []
assocs = [
IssueInstanceSharedTextAssoc(issue_instance_id=1, shared_text_id=1),
IssueInstanceSharedTextAssoc(issue_instance_id=1, shared_text_id=2),
]
for i in range(6):
trace_frames.append(
TraceFrame(
id=i + 1,
caller="call1",
caller_port="root",
filename="file.py",
callee_location=SourceLocation(i, i, i),
run_id=1,
)
)
if i < 2: # 2 postconditions
trace_frames[i].kind = TraceKind.POSTCONDITION
trace_frames[i].callee = "leaf"
trace_frames[i].callee_port = "source"
assocs.append(
TraceFrameLeafAssoc(trace_frame_id=i + 1, leaf_id=1, trace_length=0)
)
assocs.append(
IssueInstanceTraceFrameAssoc(
trace_frame_id=i + 1, issue_instance_id=1
)
)
elif i < 4:
trace_frames[i].kind = TraceKind.PRECONDITION
trace_frames[i].callee = "call2"
trace_frames[i].callee_port = "param2"
assocs.append(
TraceFrameLeafAssoc(trace_frame_id=i + 1, leaf_id=2, trace_length=1)
)
assocs.append(
IssueInstanceTraceFrameAssoc(
trace_frame_id=i + 1, issue_instance_id=1
)
)
else:
trace_frames[i].kind = TraceKind.PRECONDITION
trace_frames[i].caller = "call2"
trace_frames[i].caller_port = "param2"
trace_frames[i].callee = "leaf"
trace_frames[i].callee_port = "sink"
assocs.append(
TraceFrameLeafAssoc(trace_frame_id=i + 1, leaf_id=2, trace_length=0)
)
with self.db.make_session() as session:
session.add(run)
session.add(issue)
session.add(issue_instance)
self._add_to_session(session, messages)
self._add_to_session(session, trace_frames)
self._add_to_session(session, assocs)
session.commit()
def testTraceBranchNumber(self):
self._set_up_branched_trace()
self.interactive.setup()
self.interactive.set_issue(1)
self.assertEqual(self.interactive.sources, {"source1"})
self.assertEqual(self.interactive.sinks, {"sink1"})
self.interactive.trace()
output = self.stdout.getvalue().strip()
self.assertIn(" + 2 leaf source file.py:0|0|0", output)
self.assertIn(" --> call1 root file.py:1|2|3", output)
self.assertIn(" + 2 call2 param2 file.py:2|2|2", output)
self.assertIn(" + 2 leaf sink file.py:4|4|4", output)
def testExpand(self):
self._set_up_branched_trace()
self.interactive.setup()
self.interactive.set_issue(1)
# Parent at root
self.interactive.prev_cursor_location()
self.interactive.expand()
output = self.stdout.getvalue().strip()
self.assertIn(
"[*] leaf : source\n [0 hops: source1]\n [file.py:0|0|0]",
output,
)
self.assertIn(
"[1] leaf : source\n [0 hops: source1]\n [file.py:1|1|1]",
output,
)
self._clear_stdout()
# Move to call2:param2
self.interactive.next_cursor_location()
self.interactive.next_cursor_location()
self.interactive.expand()
output = self.stdout.getvalue().strip()
self.assertIn(
"[*] call2 : param2\n [1 hops: sink1]\n [file.py:2|2|2]",
output,
)
self.assertIn(
"[1] call2 : param2\n [1 hops: sink1]\n [file.py:3|3|3]",
output,
)
self._clear_stdout()
# Move to leaf:sink
self.interactive.next_cursor_location()
self.interactive.expand()
output = self.stdout.getvalue().strip()
self.assertIn(
"[*] leaf : sink\n [0 hops: sink1]\n [file.py:4|4|4]", output
)
self.assertIn(
"[1] leaf : sink\n [0 hops: sink1]\n [file.py:5|5|5]", output
)
def testGetTraceFrameBranches(self):
self._set_up_branched_trace()
self.interactive.setup()
self.interactive.set_issue(1)
# Parent at root
self.interactive.prev_cursor_location()
with self.db.make_session() as session:
branches = self.interactive._get_trace_frame_branches(session)
self.assertEqual(len(branches), 2)
self.assertEqual(int(branches[0].id), 1)
self.assertEqual(int(branches[1].id), 2)
# Parent is no longer root
self.interactive.next_cursor_location()
self.interactive.next_cursor_location()
self.interactive.next_cursor_location()
branches = self.interactive._get_trace_frame_branches(session)
self.assertEqual(len(branches), 2)
self.assertEqual(int(branches[0].id), 5)
self.assertEqual(int(branches[1].id), 6)
def testBranch(self):
self._set_up_branched_trace()
self.interactive.setup()
self.interactive.set_issue(1)
self.interactive.prev_cursor_location()
# We are testing for the source location, which differs between branches
self._clear_stdout()
self.interactive.branch(1) # location 0|0|0 -> 1|1|1
output = self.stdout.getvalue().strip()
self.assertIn(" --> + 2 leaf source file.py:1|1|1", output)
self._clear_stdout()
self.interactive.branch(0) # location 1|1|1 -> 0|0|0
output = self.stdout.getvalue().strip()
self.assertIn(" --> + 2 leaf source file.py:0|0|0", output)
self.interactive.next_cursor_location()
self.interactive.next_cursor_location()
self._clear_stdout()
self.interactive.branch(1) # location 2|2|2 -> 3|3|3
output = self.stdout.getvalue().strip()
self.assertIn(" --> + 2 call2 param2 file.py:3|3|3", output)
self.interactive.next_cursor_location()
self._clear_stdout()
self.interactive.branch(1) # location 4|4|4 -> 5|5|5
output = self.stdout.getvalue().strip()
self.assertIn(" + 2 call2 param2 file.py:3|3|3", output)
self.assertIn(" --> + 2 leaf sink file.py:5|5|5", output)
self.interactive.branch(2) # location 4|4|4 -> 5|5|5
stderr = self.stderr.getvalue().strip()
self.assertIn("out of bounds", stderr)
def testBranchPrefixLengthChanges(self):
run = Run(id=1, date=datetime.now(), status=RunStatus.FINISHED)
issue = self._generic_issue()
issue_instance = self._generic_issue_instance()
messages = [
SharedText(id=1, contents="source1", kind=SharedTextKind.SOURCE),
SharedText(id=2, contents="sink1", kind=SharedTextKind.SINK),
]
trace_frames = [
TraceFrame(
id=1,
kind=TraceKind.POSTCONDITION,
caller="call1",
caller_port="root",
callee="leaf",
callee_port="source",
callee_location=SourceLocation(1, 1),
filename="file.py",
run_id=1,
),
TraceFrame(
id=2,
kind=TraceKind.POSTCONDITION,
caller="call1",
caller_port="root",
callee="prev_call",
callee_port="result",
callee_location=SourceLocation(1, 1),
filename="file.py",
run_id=1,
),
TraceFrame(
id=3,
kind=TraceKind.POSTCONDITION,
caller="prev_call",
caller_port="result",
callee="leaf",
callee_port="source",
callee_location=SourceLocation(1, 1),
filename="file.py",
run_id=1,
),
TraceFrame(
id=4,
kind=TraceKind.PRECONDITION,
caller="call1",
caller_port="root",
callee="leaf",
callee_port="sink",
callee_location=SourceLocation(1, 2),
filename="file.py",
run_id=1,
),
]
assocs = [
IssueInstanceSharedTextAssoc(issue_instance_id=1, shared_text_id=1),
IssueInstanceSharedTextAssoc(issue_instance_id=1, shared_text_id=2),
IssueInstanceTraceFrameAssoc(issue_instance_id=1, trace_frame_id=1),
IssueInstanceTraceFrameAssoc(issue_instance_id=1, trace_frame_id=2),
IssueInstanceTraceFrameAssoc(issue_instance_id=1, trace_frame_id=4),
TraceFrameLeafAssoc(trace_frame_id=1, leaf_id=1, trace_length=0),
TraceFrameLeafAssoc(trace_frame_id=2, leaf_id=1, trace_length=1),
TraceFrameLeafAssoc(trace_frame_id=3, leaf_id=1, trace_length=0),
TraceFrameLeafAssoc(trace_frame_id=4, leaf_id=2, trace_length=0),
]
with self.db.make_session() as session:
session.add(run)
session.add(issue)
session.add(issue_instance)
self._add_to_session(session, messages)
self._add_to_session(session, trace_frames)
self._add_to_session(session, assocs)
session.commit()
self.interactive.setup()
self.interactive.set_issue(1)
self._clear_stdout()
self.interactive.prev_cursor_location()
self.assertEqual(
self.stdout.getvalue().split("\n"),
[
" [branches] [callable] [port] [location]",
" --> + 2 leaf source file.py:1|1|1",
" call1 root file.py:1|2|3",
" leaf sink file.py:1|2|2",
"",
],
)
self._clear_stdout()
self.interactive.branch(1)
self.assertEqual(
self.stdout.getvalue().split("\n"),
[
" [branches] [callable] [port] [location]",
" leaf source file.py:1|1|1",
" --> + 2 prev_call result file.py:1|1|1",
" call1 root file.py:1|2|3",
" leaf sink file.py:1|2|2",
"",
],
)
self._clear_stdout()
self.interactive.expand()
output = self.stdout.getvalue().strip()
self.assertIn("[*] prev_call : result", output)
self.assertIn(" [1 hops: source1]", output)
def testCurrentBranchIndex(self):
trace_frames = [TraceFrame(id=1), TraceFrame(id=2), TraceFrame(id=3)]
self.interactive.current_trace_frame_index = 0
self.interactive.trace_tuples = [TraceTuple(trace_frame=TraceFrame(id=1))]
self.assertEqual(0, self.interactive._current_branch_index(trace_frames))
self.interactive.trace_tuples[0].trace_frame.id = 2
self.assertEqual(1, self.interactive._current_branch_index(trace_frames))
self.interactive.trace_tuples[0].trace_frame.id = 3
self.assertEqual(2, self.interactive._current_branch_index(trace_frames))
self.interactive.trace_tuples[0].trace_frame.id = 4
self.assertEqual(-1, self.interactive._current_branch_index(trace_frames))
def testVerifyIssueSelected(self):
self.interactive.current_issue_id = -1
self.assertFalse(self.interactive._verify_issue_selected())
self.interactive.current_issue_id = 1
self.assertTrue(self.interactive._verify_issue_selected())
def testVerifyMultipleBranches(self):
# Leads to no-op on _generate_trace
self.interactive.trace_tuples_id = 1
self.interactive.current_issue_id = 1
self.interactive.current_trace_frame_index = 0
self.interactive.trace_tuples = [
TraceTuple(trace_frame=TraceFrame(id=1), branches=1),
TraceTuple(trace_frame=TraceFrame(id=2), branches=2),
]
self.assertFalse(self.interactive._verify_multiple_branches())
self.interactive.current_trace_frame_index = 1
self.assertTrue(self.interactive._verify_multiple_branches())
def testCreateIssueOutputStringNoSourcesNoSinks(self):
issue = Issue(code=1000, callable="module.function1")
issue_instance = IssueInstance(
id=1,
message=SharedText(contents="leaf"),
filename="module.py",
location=SourceLocation(1, 2, 3),
)
sources = []
sinks = ["sink1", "sink2"]
result = self.interactive._create_issue_output_string(
issue_instance, issue, sources, sinks
)
self.assertIn("Sources: No sources", result)
self.assertIn("Sinks: sink1", result)
sources = ["source1", "source2"]
sinks = []
result = self.interactive._create_issue_output_string(
issue_instance, issue, sources, sinks
)
self.assertIn("Sources: source1", result)
self.assertIn("Sinks: No sinks", result)
def testListSourceCode(self):
mock_data = """if this_is_true:
print("This was true")
else:
print("This was false")
"""
self.interactive.setup()
self.interactive.current_issue_id = 1
self.interactive.trace_tuples_id = 1
self.interactive.current_trace_frame_index = 0
self.interactive.trace_tuples = [
TraceTuple(
trace_frame=TraceFrame(
filename="file.py", callee_location=SourceLocation(2, 1, 1)
)
)
]
with patch("builtins.open", mock_open(read_data=mock_data)) as mock_file:
self._clear_stdout()
self.interactive.list_source_code(2)
mock_file.assert_called_once_with(f"{os.getcwd()}/file.py", "r")
output = self.stdout.getvalue()
self.assertEqual(
output.split("\n"),
[
"file.py:2|1|1",
" 1 if this_is_true:",
' --> 2 print("This was true")',
" 3 else:",
' 4 print("This was false")',
"",
],
)
mock_file.reset_mock()
self._clear_stdout()
self.interactive.list_source_code(1)
mock_file.assert_called_once_with(f"{os.getcwd()}/file.py", "r")
output = self.stdout.getvalue()
self.assertEqual(
output.split("\n"),
[
"file.py:2|1|1",
" 1 if this_is_true:",
' --> 2 print("This was true")',
" 3 else:",
"",
],
)
def testListSourceCodeFileNotFound(self):
self.interactive.setup()
self.interactive.current_issue_id = 1
self.interactive.trace_tuples_id = 1
self.interactive.current_trace_frame_index = 0
self.interactive.trace_tuples = [
TraceTuple(
trace_frame=TraceFrame(
filename="file.py", callee_location=SourceLocation(2, 1, 1)
)
)
]
with patch("builtins.open", mock_open(read_data="not read")) as mock_file:
mock_file.side_effect = FileNotFoundError()
self.interactive.list_source_code()
self.assertIn("Couldn't open", self.stderr.getvalue())
self.assertNotIn("file.py", self.stdout.getvalue())
def mock_pager(self, output_string):
self.pager_calls += 1
def testPager(self):
run = Run(id=1, date=datetime.now(), status=RunStatus.FINISHED)
issue = self._generic_issue()
issue_instance = self._generic_issue_instance()
with self.db.make_session() as session:
session.add(run)
session.add(issue)
session.add(issue_instance)
session.commit()
# Default is no pager in tests
self.pager_calls = 0
with patch("IPython.core.page.page", self.mock_pager):
self.interactive.setup()
self.interactive.issues()
self.interactive.runs()
self.assertEqual(self.pager_calls, 0)
self.pager_calls = 0
with patch("IPython.core.page.page", self.mock_pager):
self.interactive.setup()
self.interactive.issues(use_pager=True)
self.interactive.runs(use_pager=True)
self.assertEqual(self.pager_calls, 2)
