def test_get_agent_full_disk_access_state_calls_get_agent_state_with_arguments(
self, mock_connection, successful_response, mocker):
mock_connection.get.return_value = successful_response
service = DeviceService(mock_connection)
service.get_agent_state = mocker.Mock()
service.get_agent_full_disk_access_state("DEVICE_ID")
service.get_agent_state.assert_called_once_with(
"DEVICE_ID", "fullDiskAccess")
def test_get_by_id_calls_get_with_uri_and_params(self, mock_connection,
successful_response):
mock_connection.get.return_value = successful_response
service = DeviceService(mock_connection)
service.get_by_id("DEVICE_ID", include_backup_usage=True)
expected_params = {"incBackupUsage": True}
uri = "{}/{}".format(COMPUTER_URI, "DEVICE_ID")
mock_connection.get.assert_called_once_with(uri,
params=expected_params)
def test_get_agent_state_calls_get_with_uri_and_params(
self, mock_connection, successful_response):
mock_connection.get.return_value = successful_response
service = DeviceService(mock_connection)
service.get_agent_state("DEVICE_ID", property_name="KEY")
expected_params = {"deviceGuid": "DEVICE_ID", "propertyName": "KEY"}
uri = u"/api/v14/agent-state/view-by-device-guid"
mock_connection.get.assert_called_once_with(uri,
params=expected_params)
def test_get_all_calls_get_with_uri_and_params(self, mock_connection,
mock_get_all_response):
service = DeviceService(mock_connection)
mock_connection.get.return_value = mock_get_all_response
for _ in service.get_all(q="TEST-HOSTNAME"):
break
expected_params = DEFAULT_GET_DEVICES_PARAMS
expected_params["q"] = "TEST-HOSTNAME"
first_call = mock_connection.get.call_args_list[0]
assert first_call[0][0] == COMPUTER_URI
assert first_call[1]["params"] == DEFAULT_GET_DEVICES_PARAMS
def test_unicode_hostname_get_devices_calls_get_with_unicode_q_param(
self, mock_connection, mock_get_all_response):
unicode_hostname = u"您已经发现了秘密信息"
service = DeviceService(mock_connection)
mock_connection.get.return_value = mock_get_all_response
for _ in service.get_all(q=unicode_hostname):
break
first_call = mock_connection.get.call_args_list[0]
assert first_call[0][0] == COMPUTER_URI
params = DEFAULT_GET_DEVICES_PARAMS
params["q"] = unicode_hostname
assert first_call[1]["params"] == params
def test_get_all_calls_get_expected_number_of_times(
self, mock_connection, mock_get_all_response,
mock_get_all_empty_response):
py42.settings.items_per_page = 1
service = DeviceService(mock_connection)
mock_connection.get.side_effect = [
mock_get_all_response,
mock_get_all_response,
mock_get_all_empty_response,
]
for _ in service.get_all():
pass
py42.settings.items_per_page = 500
assert mock_connection.get.call_count == 3
def test_get_page_when_org_not_found_raises_expected_error(
self, mocker, mock_connection
):
text = '[{"name":"SYSTEM","description":"Unable to find org"}]'
mock_connection.get.side_effect = create_mock_error(
Py42BadRequestError, mocker, text
)
service = DeviceService(mock_connection)
with pytest.raises(Py42OrgNotFoundError) as err:
service.get_page(1, org_uid="TestOrgUid")
assert "The organization with UID 'TestOrgUid' was not found." in str(err.value)
assert err.value.org_uid == "TestOrgUid"
def _init_services(main_connection, main_auth):
alert_rules_key = u"FedObserver-API_URL"
alerts_key = u"AlertService-API_URL"
file_events_key = u"FORENSIC_SEARCH-API_URL"
preservation_data_key = u"PRESERVATION-DATA-SERVICE_API-URL"
employee_case_mgmt_key = u"employeecasemanagement-API_URL"
kv_prefix = u"simple-key-value-store"
audit_logs_key = u"AUDIT-LOG_API-URL"
kv_connection = Connection.from_microservice_prefix(
main_connection, kv_prefix)
kv_service = KeyValueStoreService(kv_connection)
alert_rules_conn = Connection.from_microservice_key(kv_service,
alert_rules_key,
auth=main_auth)
alerts_conn = Connection.from_microservice_key(kv_service,
alerts_key,
auth=main_auth)
file_events_conn = Connection.from_microservice_key(kv_service,
file_events_key,
auth=main_auth)
pds_conn = Connection.from_microservice_key(kv_service,
preservation_data_key,
auth=main_auth)
ecm_conn = Connection.from_microservice_key(kv_service,
employee_case_mgmt_key,
auth=main_auth)
audit_logs_conn = Connection.from_microservice_key(kv_service,
audit_logs_key,
auth=main_auth)
user_svc = UserService(main_connection)
administration_svc = AdministrationService(main_connection)
file_event_svc = FileEventService(file_events_conn)
user_ctx = UserContext(administration_svc)
user_profile_svc = DetectionListUserService(ecm_conn, user_ctx, user_svc)
services = Services(
administration=administration_svc,
archive=ArchiveService(main_connection),
devices=DeviceService(main_connection),
legalhold=LegalHoldService(main_connection),
orgs=OrgService(main_connection),
securitydata=SecurityDataService(main_connection),
users=UserService(main_connection),
alertrules=AlertRulesService(alert_rules_conn, user_ctx,
user_profile_svc),
alerts=AlertService(alerts_conn, user_ctx),
fileevents=file_event_svc,
savedsearch=SavedSearchService(file_events_conn, file_event_svc),
preservationdata=PreservationDataService(pds_conn),
departingemployee=DepartingEmployeeService(ecm_conn, user_ctx,
user_profile_svc),
highriskemployee=HighRiskEmployeeService(ecm_conn, user_ctx,
user_profile_svc),
userprofile=user_profile_svc,
auditlogs=AuditLogsService(audit_logs_conn),
)
return services, user_ctx
def test_deactivate_when_user_in_legal_hold_raises_active_legal_hold_error(
self, mocker, mock_connection):
def side_effect(url, json):
if u"computer-deactivation" in url:
base_err = mocker.MagicMock(spec=HTTPError)
base_err.response = mocker.MagicMock(spec=Response)
base_err.response.text = u"ACTIVE_LEGAL_HOLD"
raise Py42BadRequestError(base_err)
mock_connection.post.side_effect = side_effect
client = DeviceService(mock_connection)
with pytest.raises(Py42ActiveLegalHoldError) as err:
client.deactivate(1234)
expected = u"Cannot deactivate the device with ID 1234 as the device is involved in a legal hold matter."
assert str(err.value) == expected
def test_get_page_calls_get_with_expected_url_and_params(self, mock_connection):
service = DeviceService(mock_connection)
service.get_page(20, True, True, "org", "user", "dest", True, True, 1000)
mock_connection.get.assert_called_once_with(
"/api/v1/Computer",
params={
"active": True,
"blocked": True,
"orgUid": "org",
"userUid": "user",
"targetComputerGuid": "dest",
"incBackupUsage": True,
"incCounts": True,
"pgNum": 20,
"pgSize": 1000,
"q": None,
},
)
def _init_services(main_connection, main_auth):
# services are imported within function to prevent circular imports when a service
# imports anything from py42.sdk.queries
from py42.services import Services
from py42.services._keyvaluestore import KeyValueStoreService
from py42.services.administration import AdministrationService
from py42.services.alertrules import AlertRulesService
from py42.services.alerts import AlertService
from py42.services.archive import ArchiveService
from py42.services.auditlogs import AuditLogsService
from py42.services.cases import CasesService
from py42.services.casesfileevents import CasesFileEventsService
from py42.services.detectionlists.departing_employee import DepartingEmployeeService
from py42.services.detectionlists.high_risk_employee import HighRiskEmployeeService
from py42.services.detectionlists.user_profile import DetectionListUserService
from py42.services.devices import DeviceService
from py42.services.fileevent import FileEventService
from py42.services.legalhold import LegalHoldService
from py42.services.orgs import OrgService
from py42.services.preservationdata import PreservationDataService
from py42.services.savedsearch import SavedSearchService
from py42.services.trustedactivities import TrustedActivitiesService
from py42.services.users import UserService
alert_rules_key = "FedObserver-API_URL"
alerts_key = "AlertService-API_URL"
file_events_key = "FORENSIC_SEARCH-API_URL"
preservation_data_key = "PRESERVATION-DATA-SERVICE_API-URL"
employee_case_mgmt_key = "employeecasemanagementV2-API_URL"
kv_prefix = "simple-key-value-store"
audit_logs_key = "AUDIT-LOG_API-URL"
cases_key = "CASES_API-URL"
trusted_activities_key = "TRUSTED-DOMAINS_API-URL"
kv_connection = Connection.from_microservice_prefix(
main_connection, kv_prefix)
kv_service = KeyValueStoreService(kv_connection)
alert_rules_conn = Connection.from_microservice_key(kv_service,
alert_rules_key,
auth=main_auth)
alerts_conn = Connection.from_microservice_key(kv_service,
alerts_key,
auth=main_auth)
file_events_conn = Connection.from_microservice_key(kv_service,
file_events_key,
auth=main_auth)
pds_conn = Connection.from_microservice_key(kv_service,
preservation_data_key,
auth=main_auth)
ecm_conn = Connection.from_microservice_key(kv_service,
employee_case_mgmt_key,
auth=main_auth)
audit_logs_conn = Connection.from_microservice_key(kv_service,
audit_logs_key,
auth=main_auth)
user_svc = UserService(main_connection)
administration_svc = AdministrationService(main_connection)
file_event_svc = FileEventService(file_events_conn)
user_ctx = UserContext(administration_svc)
user_profile_svc = DetectionListUserService(ecm_conn, user_ctx, user_svc)
cases_conn = Connection.from_microservice_key(kv_service,
cases_key,
auth=main_auth)
trusted_activities_conn = Connection.from_microservice_key(
kv_service, trusted_activities_key, auth=main_auth)
services = Services(
administration=administration_svc,
archive=ArchiveService(main_connection),
devices=DeviceService(main_connection),
legalhold=LegalHoldService(main_connection),
orgs=OrgService(main_connection),
users=UserService(main_connection),
alertrules=AlertRulesService(alert_rules_conn, user_ctx,
user_profile_svc),
alerts=AlertService(alerts_conn, user_ctx),
fileevents=file_event_svc,
savedsearch=SavedSearchService(file_events_conn, file_event_svc),
preservationdata=PreservationDataService(pds_conn),
departingemployee=DepartingEmployeeService(ecm_conn, user_ctx,
user_profile_svc),
highriskemployee=HighRiskEmployeeService(ecm_conn, user_ctx,
user_profile_svc),
userprofile=user_profile_svc,
auditlogs=AuditLogsService(audit_logs_conn),
cases=CasesService(cases_conn),
casesfileevents=CasesFileEventsService(cases_conn),
trustedactivities=TrustedActivitiesService(trusted_activities_conn),
)
return services, user_ctx
