def test_get_filtered_tags(self, mock_gmp: GmpMockFactory):
mock_gmp.mock_response('get_tags', self.xml)
self.login('foo', 'bar')
response = self.query('''
query {
tags (
filterString: "lorem",
) {
nodes {
id
name
comment
value
}
}
}
''')
json = response.json()
self.assertResponseNoErrors(response)
tags = json['data']['tags']['nodes']
self.assertEqual(len(tags), 2)
tag1 = tags[0]
tag2 = tags[1]
self.assertEqual(tag1['name'], 'cat')
self.assertEqual(tag1['comment'], "dog")
self.assertEqual(tag1['id'], 'e9b98e26-9fff-4ee8-9378-bc44fe3d6f2b')
self.assertEqual(tag1['value'], "goat")
self.assertEqual(tag2['name'], 'fooTag')
self.assertEqual(tag2['comment'], None)
self.assertEqual(tag2['id'], '85787cbb-a737-463d-94b8-fcc348225f3b')
self.assertEqual(tag2['value'], "bar")
def test_create_alert_event_assigned_ticket_changed(
self, mock_gmp: GmpMockFactory):
mock_gmp.mock_response(self.cmd, self.xml)
self.login('foo', 'bar')
response = self.query(
self.compose_event_query('ASSIGNED_TICKET_CHANGED'))
self.assertResponseNoErrors(response)
mock_gmp.gmp_protocol.create_alert.assert_called_with(
"foo",
AlertCondition.ALWAYS,
AlertEvent.ASSIGNED_TICKET_CHANGED,
AlertMethod.START_TASK,
comment=None,
method_data=None,
event_data=None,
condition_data=None,
filter_id=None,
)
def test_create_alert_event_updated_secinfo(self,
mock_gmp: GmpMockFactory):
mock_gmp.mock_response(self.cmd, self.xml)
self.login('foo', 'bar')
response = self.query(
self.compose_event_query('UPDATED_SECINFO_ARRIVED'))
self.assertResponseNoErrors(response)
mock_gmp.gmp_protocol.create_alert.assert_called_with(
"foo",
AlertCondition.ALWAYS,
AlertEvent.UPDATED_SECINFO_ARRIVED,
AlertMethod.START_TASK,
comment=None,
method_data=None,
event_data={'secinfo_type': 'dfn_cert_adv'},
condition_data=None,
filter_id=None,
)
def test_get_filtered_reports(self, mock_gmp: GmpMockFactory):
mock_gmp.mock_response('get_reports', self.resp)
self.login('foo', 'bar')
response = self.query(self.qu)
json = response.json()
self.assertResponseNoErrors(response)
reports = json['data']['reports']['nodes']
self.assertEqual(len(reports), 2)
report1 = reports[0]
report2 = reports[1]
self.assertEqual(report1['name'], 'a')
self.assertEqual(report1['id'], '1f3261c9-e47c-4a21-b677-826ea92d1d59')
self.assertEqual(report2['name'], 'b')
self.assertEqual(report2['id'], '83c907a4-b2e4-403e-a5ba-9f831092b106')
def test_login_success_with_session_timeout(self,
mock_gmp: GmpMockFactory):
mock_gmp.mock_response(
'authenticate',
'''
<authenticate>
</authenticate>
''',
)
now = datetime.datetime.now()
session = self.client.session
session.set_expiry(300)
session.save()
response = self.query('''
mutation {
login(username: "******", password: "******") {
ok
sessionTimeout
}
}
''')
self.assertResponseStatusCode(response, 200)
mock_gmp.assert_authenticated_with('foo', 'bar')
json = response.json()
self.assertResponseNoErrors(response)
timeout = json['data']['login']['sessionTimeout']
timeout_read = datetime.datetime.strptime(timeout,
'%Y-%m-%dT%H:%M:%S.%f')
diff_time = timeout_read - now
self.assertEqual(diff_time.seconds, settings.SESSION_COOKIE_AGE)
def test(self, mock_gmp: GmpMockFactory):
mock_gmp.mock_response(
gmp_cmd, compose_mock_response(gmp_name, no_plural)
)
self.login('foo', 'bar')
response = self.query(compose_mock_query(plural_selene_name))
self.assertResponseNoErrors(response)
json = response.json()
entities = json['data'][plural_selene_name]['nodes']
self.assertEqual(len(entities), 2)
counts = json['data'][plural_selene_name]['counts']
self.assertEqual(counts['filtered'], 2)
self.assertEqual(counts['total'], 2)
self.assertEqual(counts['offset'], 0)
self.assertEqual(counts['limit'], 10)
self.assertEqual(counts['length'], 2)
def test_create_filter(self, mock_gmp: GmpMockFactory):
mock_gmp.mock_response(
'create_filter',
'''
<create_filter_response status="201" status_text="OK,
resource created" id="e1438fb2-ab2c-4f4a-ad6b-de97005256e8"/>
''',
)
self.login('foo', 'bar')
response = self.query('''
mutation {
createFilter (
input: {
term: "foo bar"
type: ALERT
comment: "moo"
name: "phew"
}
) {
id
}
}
''')
json = response.json()
self.assertResponseNoErrors(response)
filter_id = json['data']['createFilter']['id']
self.assertEqual(filter_id, 'e1438fb2-ab2c-4f4a-ad6b-de97005256e8')
mock_gmp.gmp_protocol.create_filter.assert_called_with(
name="phew",
term="foo bar",
filter_type=get_filter_type_from_string('alert'),
comment="moo",
)
def test_modify_alert_condition_data_without_condition(
self, mock_gmp: GmpMockFactory):
mock_gmp.mock_response(self.cmd, self.xml)
self.login('foo', 'bar')
response = self.query(self.compose_no_condition_query())
self.assertResponseNoErrors(response)
mock_gmp.gmp_protocol.modify_alert.assert_called_with(
alert_id=str(self.alert_id),
name="foo",
condition=None,
event=AlertEvent.TASK_RUN_STATUS_CHANGED,
method=AlertMethod.START_TASK,
comment=None,
method_data=None,
event_data=None,
condition_data=None,
filter_id=None,
)
def test_modify_alert_condition_severity_changed(self,
mock_gmp: GmpMockFactory):
mock_gmp.mock_response(self.cmd, self.xml)
self.login('foo', 'bar')
response = self.query(self.compose_condition_query('SEVERITY_CHANGED'))
self.assertResponseNoErrors(response)
mock_gmp.gmp_protocol.modify_alert.assert_called_with(
alert_id=str(self.alert_id),
name="foo",
condition=AlertCondition.SEVERITY_CHANGED,
event=AlertEvent.TASK_RUN_STATUS_CHANGED,
method=AlertMethod.START_TASK,
comment=None,
method_data=None,
event_data=None,
condition_data={'direction': 'decreased'},
filter_id=None,
)
def test_get_filtered_tickets(self, mock_gmp: GmpMockFactory):
mock_gmp.mock_response('get_tickets', self.xml)
self.login('foo', 'bar')
response = self.query(
'''
query {
tickets (
filterString: "lorem",
) {
nodes {
id
name
comment
}
}
}
'''
)
json = response.json()
self.assertResponseNoErrors(response)
tickets = json['data']['tickets']['nodes']
self.assertEqual(len(tickets), 2)
ticket1 = tickets[0]
ticket2 = tickets[1]
self.assertEqual(ticket1['id'], '08b69003-5fc2-4037-a479-93b440211c73')
self.assertEqual(ticket1['name'], 'foo')
self.assertEqual(ticket1['comment'], 'bar')
self.assertEqual(ticket2['id'], '6b2db524-9fb0-45b8-9b56-d958f84cb546')
self.assertEqual(ticket2['name'], 'lorem')
self.assertEqual(ticket2['comment'], 'ipsum')
def test(self, mock_gmp: GmpMockFactory):
gmp_commands = return_gmp_methods(mock_gmp.gmp_protocol)
mock_gmp.mock_response(gmp_cmd, compose_mock_response(gmp_name))
self.login('foo', 'bar')
response = self.query(compose_mock_query(plural_selene_name))
json = response.json()
self.assertResponseNoErrors(response)
get_entities = gmp_commands[gmp_cmd]
get_entities.assert_called_with(
filter_string='lorem rows=15 first=323', **kwargs
)
entities = json['data'][plural_selene_name]['nodes']
self.assertEqual(len(entities), 2)
def test_get_tag(self, mock_gmp: GmpMockFactory):
tag_id = uuid4()
mock_gmp.mock_response(
'get_tag',
f'''
<get_tags_response>
<tag id="{tag_id}">
<name>cat</name>
<comment>dog</comment>
<value>goat</value>
</tag>
</get_tags_response>
''',
)
self.login('foo', 'bar')
response = self.query(
f'''
query {{
tag(id: "{tag_id}") {{
id
name
value
comment
}}
}}
'''
)
json = response.json()
self.assertResponseNoErrors(response)
tag = json['data']['tag']
self.assertEqual(tag['id'], str(tag_id))
self.assertEqual(tag['name'], 'cat')
self.assertEqual(tag['comment'], 'dog')
self.assertEqual(tag['value'], 'goat')
def test_delete_by_ids_invalid(self, mock_gmp: GmpMockFactory):
self.login('foo', 'bar')
id1 = uuid4()
id2 = uuid4()
# Return only one policy instead of the queried two.
mock_gmp.mock_response(
'get_policies',
f'''
<get_config_response status="200" status_text="OK">
<config id="{id1}">
</config>
</get_config_response>
''',
)
response = self.query(
f'''
mutation {{
deletePoliciesByIds(ids: ["{id1}", "{id2}"],
ultimate:true)
{{
ok
}}
}}
'''
)
json = response.json()
self.assertResponseNoErrors(response)
ok = json['data']['deletePoliciesByIds']['ok']
self.assertFalse(ok)
mock_gmp.gmp_protocol.get_policies.assert_called_with(
filter=f'uuid={id1} uuid={id2} '
)
def test_modify_ticket(self, mock_gmp: GmpMockFactory):
mock_gmp.mock_response(
'modify_ticket',
'''
<modify_ticket_response status="200" status_text="OK"/>
''',
)
self.login('foo', 'bar')
response = self.query(f'''
mutation {{
modifyTicket(input: {{
id: "{self.ticket_id}"
ticketStatus: CLOSED
comment: "glurp"
note: "bar"
assignedToUserId: "{self.assignee_id}"
}}) {{
ok
}}
}}
''')
json = response.json()
self.assertResponseNoErrors(response)
ok = json['data']['modifyTicket']['ok']
self.assertEqual(ok, True)
mock_gmp.gmp_protocol.modify_ticket.assert_called_with(
str(self.ticket_id),
note="bar",
comment="glurp",
assigned_to_user_id=str(self.assignee_id),
status=get_ticket_status_from_string('closed'),
)
def test_get_user_setting(self, mock_gmp: GmpMockFactory):
mock_gmp.mock_response(
'get_setting',
'''
<get_settings_response>
<setting id="75d23ba8-3d23-11ea-858e-b7c2cb43e815">
<name>a</name>
<comment>b</comment>
<value>1</value>
</setting>
</get_settings_response>
''',
)
self.login('foo', 'bar')
response = self.query(
'''
query {
userSetting(id: "75d23ba8-3d23-11ea-858e-b7c2cb43e815") {
id
name
comment
value
}
}
'''
)
json = response.json()
self.assertResponseNoErrors(response)
setting = json['data']['userSetting']
self.assertEqual(setting['name'], 'a')
self.assertEqual(setting['id'], '75d23ba8-3d23-11ea-858e-b7c2cb43e815')
self.assertEqual(setting['comment'], 'b')
self.assertEqual(setting['value'], '1')
def test_modify_alert_event_owned_ticket_changed(self,
mock_gmp: GmpMockFactory):
mock_gmp.mock_response(self.cmd, self.xml)
self.login('foo', 'bar')
response = self.query(self.compose_event_query('OWNED_TICKET_CHANGED'))
self.assertResponseNoErrors(response)
mock_gmp.gmp_protocol.modify_alert.assert_called_with(
alert_id=str(self.alert_id),
name="foo",
condition=AlertCondition.ALWAYS,
event=AlertEvent.OWNED_TICKET_CHANGED,
method=AlertMethod.START_TASK,
comment=None,
method_data=None,
event_data=None,
condition_data=None,
filter_id=None,
)
def test_modify_scan_config_set_nvt_prefernce(self,
mock_gmp: GmpMockFactory):
mock_gmp.mock_response(
'modify_config_set_nvt_preference',
'''
<modify_config_response status="200" status_text="OK"/>
''',
)
self.login('foo', 'bar')
response = self.query(f'''
mutation {{
modifyScanConfigSetNvtPreference(input:{{
id: "{self.id1}",
name: "{self.name}",
nvtOid: "1.3.6.1.4.1.25623.1.0.100315",
value: "yes"}})
{{
ok
}}
}}
''')
json = response.json()
self.assertResponseNoErrors(response)
ok = json['data']['modifyScanConfigSetNvtPreference']['ok']
self.assertEqual(ok, True)
# pylint: disable=line-too-long
mock_gmp.gmp_protocol.modify_config_set_nvt_preference.assert_called_with(
config_id=str(self.id1),
name=self.name,
nvt_oid="1.3.6.1.4.1.25623.1.0.100315",
value="yes",
)
def test_get_roles(self, mock_gmp: GmpMockFactory):
mock_gmp.mock_response('get_roles', self.resp)
self.login('foo', 'bar')
response = self.query('''
query {
roles{
nodes {
id
name
users
}
}
}
''')
json = response.json()
self.assertResponseNoErrors(response)
roles = json['data']['roles']['nodes']
self.assertEqual(len(roles), 2)
role1 = roles[0]
role2 = roles[1]
# Role 1
self.assertEqual(role1['name'], 'test1')
self.assertEqual(role1['id'], f'{self.id1}')
self.assertEqual(role1['users'], ['hyperion_test_user', 'myuser'])
# Role 2
self.assertEqual(role2['name'], 'test2')
self.assertEqual(role2['id'], f'{self.id2}')
self.assertEqual(role2['users'], ['hyperion_test_user', 'myuser'])
mock_gmp.gmp_protocol.get_roles.assert_called_with(filter=None)
def test_export_cert_bund_advisories_by_filter(self,
mock_gmp: GmpMockFactory):
self.login('foo', 'bar')
id1 = uuid4()
id2 = uuid4()
mock_xml = ('<get_info_list_response status="200" status_text="OK">'
f'<port_list id="{id1}">'
'<name>some_name1</name>'
'</port_list>'
f'<port_list id="{id2}">'
'<name>some_name2</name>'
'</port_list>'
'</get_info_list_response>')
mock_gmp.mock_response('get_info_list', bytes(mock_xml, 'utf-8'))
response = self.query('''
mutation {
exportCertBundAdvisoriesByFilter
(filterString: "uuid={id1} uuid={id2}") {
exportedEntities
}
}
''')
json = response.json()
self.assertResponseNoErrors(response)
xml = json['data']['exportCertBundAdvisoriesByFilter'][
'exportedEntities']
self.assertEqual(mock_xml, xml)
mock_gmp.gmp_protocol.get_info_list.assert_called_with(
filter="uuid={id1} uuid={id2}",
details=True,
info_type=GvmInfoType.CERT_BUND_ADV,
)
def test_bulk_tag_by_filter(self, mock_gmp: GmpMockFactory):
mock_gmp.mock_response(
'modify_tag',
'''
<modify_tag_response status="200" status_text="OK"/>
''',
)
self.login('foo', 'bar')
response = self.query(
f'''
mutation {{
bulkTag(input: {{
id: "{self.tag_id}",
resourceFilter: "foo",
resourceType: OPERATING_SYSTEM,
resourceIds: ["{self.resource1}", "{self.resource2}"],
}}) {{
ok
}}
}}
'''
)
json = response.json()
self.assertResponseNoErrors(response)
ok = json['data']['bulkTag']['ok']
self.assertEqual(ok, True)
mock_gmp.gmp_protocol.modify_tag.assert_called_with(
str(self.tag_id),
resource_filter="foo",
resource_type=get_entity_type_from_string('os'),
resource_action="add",
)
def test_export_schedules_by_filter(self, mock_gmp: GmpMockFactory):
self.login('foo', 'bar')
id1 = uuid4()
id2 = uuid4()
mock_xml = (
'<get_schedules_response status="200" status_text="OK">'
f'<schedule id="{id1}">'
'<name>some_name1</name>'
'</schedule>'
f'<schedule id="{id2}">'
'<name>some_name2</name>'
'</schedule>'
'</get_schedules_response>'
)
mock_gmp.mock_response('get_schedules', bytes(mock_xml, 'utf-8'))
response = self.query(
'''
mutation {
exportSchedulesByFilter
(filterString: "uuid={id1} uuid={id2}") {
exportedEntities
}
}
'''
)
json = response.json()
self.assertResponseNoErrors(response)
xml = json['data']['exportSchedulesByFilter']['exportedEntities']
self.assertEqual(mock_xml, xml)
mock_gmp.gmp_protocol.get_schedules.assert_called_with(
filter="uuid={id1} uuid={id2}"
)
def test_export_tls_certificates_by_ids(self, mock_gmp: GmpMockFactory):
self.login('foo', 'bar')
mock_xml = (
'<get_tls_certificates_response status="200" status_text="OK">'
f'<tls_certificate id="{self.id1}">'
'<name>some_name1</name>'
'</tls_certificate>'
f'<tls_certificate id="{self.id2}">'
'<name>some_name2</name>'
'</tls_certificate>'
'</get_tls_certificates_response>'
)
mock_gmp.mock_response('get_tls_certificates', mock_xml)
response = self.query(
f'''
mutation {{
exportTlsCertificatesByIds(ids: ["{self.id1}", "{self.id2}"])
{{
exportedEntities
}}
}}
'''
)
json = response.json()
self.assertResponseNoErrors(response)
tls_certificates_xml = json['data']['exportTlsCertificatesByIds'][
'exportedEntities'
]
self.assertEqual(mock_xml, tls_certificates_xml)
mock_gmp.gmp_protocol.get_tls_certificates.assert_called_with(
filter_string=f'uuid={self.id1} uuid={self.id2} '
)
def test_export_empty_tls_certificate_ids_array(self,
mock_gmp: GmpMockFactory):
self.login('foo', 'bar')
mock_xml = (
'<get_tls_certificates_response status=\"200\" status_text=\"OK\">'
'<filters id=\"\"><term>uuid= first=1 rows=10 sort=name</term>'
'<keywords><keyword><column>uuid</column><relation>=</relation>'
'<value /></keyword><keyword><column>first</column><relation>'
'=</relation><value>1</value></keyword><keyword><column>rows'
'</column><relation>=</relation><value>10</value></keyword>'
'<keyword><column>sort</column><relation>=</relation><value>name'
'</value></keyword></keywords></filters><sort><field>name<order>'
'ascending</order></field></sort><tls_certificates max=\"10\" '
'start=\"1\" /><tls_certificate_count>16<filtered>0</filtered>'
'<page>0</page></tls_certificate_count>'
'</get_tls_certificates_response>')
mock_gmp.mock_response('get_tls_certificates',
bytes(mock_xml, 'utf-8'))
response = self.query('''
mutation {
exportTlsCertificatesByIds(ids: []) {
exportedEntities
}
}
''')
json = response.json()
self.assertResponseNoErrors(response)
tls_certificates_xml = json['data']['exportTlsCertificatesByIds'][
'exportedEntities']
self.assertEqual(mock_xml, tls_certificates_xml)
mock_gmp.gmp_protocol.get_tls_certificates.assert_called_with(
filter='uuid= ')
def test_export_cert_bund_advisories_empty_ids_array(
self, mock_gmp: GmpMockFactory):
self.login('foo', 'bar')
mock_xml = (
'<get_info_list_response status=\"200\" status_text=\"OK\">'
'<filters id=\"\"><term>uuid= first=1 rows=10 sort=name</term>'
'<keywords><keyword><column>uuid</column><relation>=</relation>'
'<value/></keyword><keyword><column>first</column><relation>'
'=</relation><value>1</value></keyword><keyword><column>rows'
'</column><relation>=</relation><value>10</value></keyword>'
'<keyword><column>sort</column><relation>=</relation><value>name'
'</value></keyword></keywords></filters><sort><field>name<order>'
'ascending</order></field></sort><info_list max=\"10\" '
'start=\"1\"/><info_count>16<filtered>0</filtered>'
'<page>0</page></info_count></get_info_list_response>')
mock_gmp.mock_response('get_info_list', bytes(mock_xml, 'utf-8'))
response = self.query('''
mutation {
exportCertBundAdvisoriesByIds(ids: []) {
exportedEntities
}
}
''')
json = response.json()
self.assertResponseNoErrors(response)
oval_definitions_xml = json['data']['exportCertBundAdvisoriesByIds'][
'exportedEntities']
self.assertEqual(mock_xml, oval_definitions_xml)
mock_gmp.gmp_protocol.get_info_list.assert_called_with(
filter_string='',
details=True,
info_type=GvmInfoType.CERT_BUND_ADV)
def test_delete_tasks(self, mock_gmp: GmpMockFactory):
self.login('foo', 'bar')
id1 = uuid4()
id2 = uuid4()
mock_gmp.mock_response(
'get_tasks',
f'''
<get_tasks_response status="200" status_text="OK">
<task id="{id1}">
</task>
<task id="{id2}">
</task>
</get_tasks_response>
''',
)
response = self.query(f'''
mutation {{
deleteTasksByIds(ids: ["{id1}", "{id2}"]) {{
ok
}}
}}
''')
json = response.json()
self.assertResponseNoErrors(response)
ok = json['data']['deleteTasksByIds']['ok']
self.assertTrue(ok)
mock_gmp.gmp_protocol.get_tasks.assert_called_with(
filter=f'uuid={id1} uuid={id2} ')
mock_gmp.gmp_protocol.delete_task.assert_any_call(task_id=str(id1))
mock_gmp.gmp_protocol.delete_task.assert_any_call(task_id=str(id2))
def test_delete_operating_systems_invalid(self, mock_gmp: GmpMockFactory):
self.login('foo', 'bar')
id1 = uuid4()
id2 = uuid4()
# Only one of the requested operating_systems is found.
mock_gmp.mock_response(
'get_assets',
f'''
<get_assets_response status="200" status_text="OK">
<asset id="{id1}">
<name>Foo Clone 1</name>
</asset>
</get_assets_response>
''',
)
response = self.query(f'''
mutation {{
deleteOperatingSystemsByIds(
ids: ["{id1}", "{id2}"]
) {{
ok
}}
}}
''')
json = response.json()
self.assertResponseNoErrors(response)
ok = json['data']['deleteOperatingSystemsByIds']['ok']
self.assertFalse(ok)
mock_gmp.gmp_protocol.get_assets.assert_called_with(
filter=f'uuid={id1} uuid={id2} ',
asset_type=GvmAssetType.OPERATING_SYSTEM,
)
def test_create_alert_condition_severity_at_least(
self, mock_gmp: GmpMockFactory):
mock_gmp.mock_response(self.cmd, self.xml)
self.login('foo', 'bar')
response = self.query(
self.compose_condition_query('SEVERITY_AT_LEAST'))
self.assertResponseNoErrors(response)
mock_gmp.gmp_protocol.create_alert.assert_called_with(
"foo",
AlertCondition.SEVERITY_AT_LEAST,
AlertEvent.TASK_RUN_STATUS_CHANGED,
AlertMethod.START_TASK,
comment=None,
method_data=None,
event_data=None,
condition_data={'severity': '0.1'},
filter_id=None,
)
def test_get_override_with_no_hosts(self, mock_gmp: GmpMockFactory):
mock_gmp.mock_response(
'get_override',
'''
<get_override_response>
<override id="08b69003-5fc2-4037-a479-93b440211c73">
<text>Han shot first</text>
<owner><name>Han</name></owner>
<creation_time>2020-06-30T09:16:25Z</creation_time>
<modification_time>2020-07-30T09:16:25Z</modification_time>
<writable>1</writable>
<in_use>1</in_use>
<active>1</active>
<orphan>0</orphan>
<nvt><name>Greedo</name></nvt>
<severity>5.5</severity>
<new_severity>10</new_severity>
</override>
</get_override_response>
''',
)
self.login('foo', 'bar')
response = self.query('''
query {
override(id: "08b69003-5fc2-4037-a479-93b440211c73") {
hosts
}
}
''')
json = response.json()
self.assertResponseNoErrors(response)
override = json['data']['override']
self.assertListEqual(override['hosts'], [])
def test_create_alert_event_task_status_changed(self,
mock_gmp: GmpMockFactory):
mock_gmp.mock_response(self.cmd, self.xml)
self.login('foo', 'bar')
response = self.query(
self.compose_event_query('TASK_RUN_STATUS_CHANGED'))
self.assertResponseNoErrors(response)
mock_gmp.gmp_protocol.create_alert.assert_called_with(
"foo",
AlertCondition.ALWAYS,
AlertEvent.TASK_RUN_STATUS_CHANGED,
AlertMethod.START_TASK,
comment=None,
method_data=None,
event_data={'status': 'Stop Requested'},
condition_data=None,
filter_id=None,
)
def test_delete_reports_invalid(self, mock_gmp: GmpMockFactory):
self.login('foo', 'bar')
id1 = uuid4()
id2 = uuid4()
# Only one of the requested reports is found.
mock_gmp.mock_response(
'get_reports',
f'''
<get_reports_response status="200" status_text="OK">
<apply_overrides>0</apply_overrides>
<report id="{id1}">
<name>Foo Clone 1</name>
</report>
</get_reports_response>
''',
)
response = self.query(
f'''
mutation {{
deleteReportsByIds(ids: ["{id1}", "{id2}"]) {{
ok
}}
}}
'''
)
json = response.json()
self.assertResponseNoErrors(response)
ok = json['data']['deleteReportsByIds']['ok']
self.assertFalse(ok)
mock_gmp.gmp_protocol.get_reports.assert_called_with(
filter=f'uuid={id1} uuid={id2} '
)
