def test_process(build_selector_mock, get_actions_mock):
# Arrange
concrete_state = {
'widgets': {
'key_1': {
'key': 'key_1',
'properties': {
'tagName': 'A'
}
},
'key_2': {
'key': 'key_2',
'properties': {
'tagName': 'INPUT'
}
},
'key_3': {
'key': 'key_3',
'properties': {
'tagName': 'SOMETHING'
}
},
'key_4': {
'key': 'key_4',
'properties': {
'tagName': 'INPUT'
}
},
}
}
state_abstracter = StateAbstracter()
# Act
result = state_abstracter.process(concrete_state)
# Assert
assert len(result.widgets) == 2
assert result.widgets[0]['selector'] == 'selector_1'
assert result.widgets[1]['selector'] == 'selector_2'
assert len(result.static_widgets) == 1
assert result.static_widgets[0]['key'] == 'key_3'
assert build_selector_mock.call_count == 3
assert get_actions_mock.call_count == 3
assert result.hash != 0
def __init__(self,
sut_url,
runner_url,
form_expert_client=None,
runner_client=None,
page_analysis_client=None,
flow_generator_client=None,
flow_publisher=None,
flow_executor=None):
""" Initializes the AgentLoop class.
:param sut_url: The URL of the SUT.
:param runner_url: The URL to the runner resource to be used for driving the SUT.
"""
self.sut_url = sut_url
self.runner_url = runner_url
self.mapper = StateAbstracter()
self.label_extracter = LabelExtraction()
self.form_expert = form_expert_client if form_expert_client else FormExpertClient(
)
self.memory = PriorityMemory()
self.observer = StateObserver()
self.seq_parser = SequenceParser()
self.flow_planner = FlowPlanner()
self.defect_rep = DefectReporter()
self.flow_publish = flow_publisher if flow_publisher else PlannedFlowPublisher(
)
self.runner = runner_client if runner_client else RunnerClient(
self.runner_url)
self.page_analyzer = page_analysis_client if page_analysis_client else PageAnalysisClient(
)
self.flow_generator = flow_generator_client if flow_generator_client else FlowGeneratorClient(
)
self.flow_executer = flow_executor if flow_executor else FlowExecutor(
self.form_expert, self.page_analyzer, self.mapper,
self.label_extracter, self.observer, self.defect_rep)
def test_unable_to_perform_runner_click_action():
# Arrange.
form_expert = Mock()
page_analyzer = Mock()
state_abstracter = StateAbstracter()
label_extracter = LabelExtraction()
observer = StateObserver()
defect_rep = Mock()
flow_executor = FlowExecutor(form_expert, page_analyzer, state_abstracter,
label_extracter, observer, defect_rep)
flow_executor.form_fill_strategy = Mock()
to_parse = "OBSERVE TEXTBOX EMAIL TRY VALID EMAIL CLICK COMMIT NOTOBSERVE ERRORMESSAGE"
parser = SequenceParser()
abstract_flow = parser.parse(to_parse)
flow_planner = FlowPlanner()
page_analysis = {
'analysis': {
'labelCandidates': ['Label_Email'],
'COMMIT': ['C1'],
'ERRORMESSAGE': ['E1'],
'errorMessages': ['E1']
}
}
page_analyzer.run_analysis.return_value = page_analysis
abstract_state = ActionableState()
widget_email_label = {
'key': 'Label_Email',
'label': 'EmailLabel',
'actions': [],
'selector': '#lblEmail',
'properties': {
'tagName': 'LABEL',
'text': 'E-mail',
'x': 10,
'y': 10
}
}
widget_email = {
'key': 'EMAIL',
'label': 'Email',
'actions': ['set'],
'selector': '#email',
'properties': {
'tagName': 'INPUT',
'x': 20,
'y': 20
}
}
widget_save = {
'key': 'C1',
'label': 'Save',
'actions': ['click'],
'selector': '#save',
'properties': {
'tagName': 'BUTTON',
'x': 40,
'y': 40
}
}
widget_error = {
'key': 'E1',
'label': 'Error',
'properties': {
'tagName': 'LABEL',
'x': 60,
'y': 60
}
}
abstract_state.add_widget(widget_email_label)
abstract_state.add_widget(widget_email)
abstract_state.add_widget(widget_save)
abstract_state.add_widget(widget_error)
target_concrete_state = {
'widgets': {
'Label_Email': widget_email_label,
'EMAIL': widget_email,
'C1': widget_save,
'E1': widget_error
}
}
runner_mock = Mock()
runner_mock.concrete_state.return_value = target_concrete_state
def click_side_effect(*args, **kwargs):
if args[1] == 'click':
return False
return True
runner_mock.perform_action.side_effect = click_side_effect
planned = flow_planner.plan(abstract_state, page_analysis, abstract_flow)
planned_flow = planned[0]
# Act.
resp = flow_executor.execute(abstract_state, runner_mock, planned_flow)
# Assert.
assert resp is False
