import json
import uuid

from typing import Any

import base64

import pytest
import datetime

from Reco import (
    RecoClient,
    fetch_incidents,
    map_reco_score_to_demisto_score,
    get_max_fetch,
    get_risky_users_from_reco,
    add_risky_user_label,
    get_assets_user_has_access,
    get_sensitive_assets_by_name,
    get_sensitive_assets_by_id, get_link_to_user_overview_page, get_sensitive_assets_shared_with_public_link,
    get_3rd_parties_list, get_files_shared_with_3rd_parties, map_reco_alert_score_to_demisto_score
)

from test_data.structs import (
    TableData,
    RowData,
    KeyValuePair,
    RiskLevel,
    GetTableResponse,
    GetIncidentTableResponse,
)

DUMMY_RECO_API_DNS_NAME = "https://dummy.reco.ai/api"
INCIDET_ID_UUID = "87799f2f-c012-43b6-ace2-78ec984427f3"
ALERT_ID = "ee593dc2-a50e-415e-bed0-8403c18b26ca"
INCIDENT_DESCRIPTION = "Sensitive files are accessible to anyone who has their link"
ENCODING = "utf-8"
INCIDENT_STATUS = "INCIDENT_STATE_UNMARKED"
TIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ"


def get_random_table_response() -> GetIncidentTableResponse:
    return GetIncidentTableResponse(
        get_table_response=GetTableResponse(
            data=TableData(
                rows=[
                    RowData(
                        cells=[
                            KeyValuePair(
                                key="incident_id",
                                value=base64.b64encode(
                                    INCIDET_ID_UUID.encode(ENCODING)
                                ).decode(ENCODING),
                            ),
                            KeyValuePair(
                                key="incident_description",
                                value=base64.b64encode(
                                    INCIDENT_DESCRIPTION.encode(ENCODING)
                                ).decode(ENCODING),
                            ),
                            KeyValuePair(
                                key="risk_level",
                                value=base64.b64encode(
                                    str(RiskLevel.HIGH.value).encode(ENCODING)
                                ).decode(ENCODING),
                            ),
                            KeyValuePair(
                                key="event_time",
                                value=base64.b64encode(
                                    datetime.datetime.now()
                                    .strftime(TIME_FORMAT)
                                    .encode(ENCODING)
                                ).decode(ENCODING),
                            ),
                            KeyValuePair(
                                key="updated_at",
                                value=base64.b64encode(
                                    datetime.datetime.now()
                                    .strftime(TIME_FORMAT)
                                    .encode(ENCODING)
                                ).decode(ENCODING),
                            ),
                            KeyValuePair(
                                key="status",
                                value=base64.b64encode(
                                    INCIDENT_STATUS.encode(ENCODING)
                                ).decode(ENCODING),
                            ),
                        ]
                    )
                ]
            ),
            total_number_of_results=1,
            table_definition="",
            dynamic_table_definition="",
            token="",
        ),
    )


def get_alerts_and_table_response() -> tuple[GetIncidentTableResponse, dict[str, Any]]:
    alert = {
        "alert": {
            "id": INCIDET_ID_UUID,
            "policyId": "7f174580-81b6-4349-a4ca-ca8873b48b78",
            "workspaceId": "f4be4202-4a6e-4bf7-b058-5d33a3146df7",
            "description": "1 sensitive file exposed publicly by t@acme.ai (part of ACME IL)",
            "aggregationRulesToKeys": {
                "aggregationRuleToKey": [
                    {
                        "aggregationRule": {
                            "aggregationKeyJsonataQuery": "enriched.actor.email_account"
                        },
                        "aggregationKey": {"stringKey": '"t@acme.ai"'},
                    },
                    {
                        "aggregationRule": {"aggregationDuration": "3600s"},
                        "aggregationKey": {"timeKey": "2023-05-03T10:21:04.078627293Z"},
                    },
                ]
            },
            "status": "ALERT_STATUS_NEW",
            "riskLevel": "HIGH",
            "policyViolations": [
                {
                    "id": "75123c18-5ea2-4511-b9c0-1aad67e8b2ff",
                    "policyId": "7f174580-81b6-4349-a4ca-ca8873b48b78",
                    "workspaceId": "f4be4202-4a6e-4bf7-b058-5d33a3146df7",
                    "jsonData": "{"id": "91bef1de-566d-4daf-88db-1a44044ca577", "payload": {"id": {"time": "2023-05-03T10:20:55.754Z", "customerId": "C02mckshm", "applicationName": "drive", "uniqueQualifier": "2619910948680356260"}, "etag": "\"cJMm5BbBYdq2_4lefkjdgzwtzpg/X5SghOJMCA5j4Q2CEMVt9xJaWZ8\"", "kind": "admin#reports#activity", "actor": {"email": "gal@reco.ai", "profileId": "100034389570503923556"}, "events": [{"name": "edit", "type": "access", "parameters": [{"name": "primary_event", "boolValue": false}, {"name": "billable", "boolValue": true}, {"name": "owner_is_team_drive", "boolValue": false}, {"name": "owner", "value": "gal@reco.ai"}, {"name": "doc_id", "value": "1-GFA96ZEszHht9RI-GI10zi4AAQDb2q24eFb215DbNA"}, {"name": "doc_type", "value": "document"}, {"name": "is_encrypted", "boolValue": false}, {"name": "doc_title", "value": "Copy of sensitive file"}, {"name": "dlp_info", "value": ""}, {"name": "visibility", "value": "people_with_link"}, {"name": "originating_app_id", "value": "211604355607"}, {"name": "actor_is_collaborator_account", "boolValue": false}]}, {"name": "change_document_visibility", "type": "acl_change", "parameters": [{"name": "primary_event", "boolValue": true}, {"name": "billable", "boolValue": true}, {"name": "visibility_change", "value": "external"}, {"name": "target_domain", "value": "all"}, {"name": "old_value", "multiValue": ["private"]}, {"name": "new_value", "multiValue": ["people_with_link"]}, {"name": "old_visibility", "value": "private"}, {"name": "owner_is_team_drive", "boolValue": false}, {"name": "owner", "value": "gal@reco.ai"}, {"name": "doc_id", "value": "1-GFA96ZEszHht9RI-GI10zi4AAQDb2q24eFb215DbNA"}, {"name": "doc_type", "value": "document"}, {"name": "is_encrypted", "boolValue": false}, {"name": "doc_title", "value": "Copy of sensitive file"}, {"name": "dlp_info", "value": ""}, {"name": "visibility", "value": "people_with_link"}, {"name": "originating_app_id", "value": "211604355607"}, {"name": "actor_is_collaborator_account", "boolValue": false}]}, {"name": "change_document_access_scope", "type": "acl_change", "parameters": [{"name": "primary_event", "boolValue": true}, {"name": "billable", "boolValue": true}, {"name": "visibility_change", "value": "external"}, {"name": "target_domain", "value": "all"}, {"name": "old_value", "multiValue": ["none"]}, {"name": "new_value", "multiValue": ["can_view"]}, {"name": "old_visibility", "value": "private"}, {"name": "owner_is_team_drive", "boolValue": false}, {"name": "owner", "value": "gal@reco.ai"}, {"name": "doc_id", "value": "1-GFA96ZEszHht9RI-GI10zi4AAQDb2q24eFb215DbNA"}, {"name": "doc_type", "value": "document"}, {"name": "is_encrypted", "boolValue": false}, {"name": "doc_title", "value": "Copy of sensitive file"}, {"name": "dlp_info", "value": ""}, {"name": "visibility", "value": "people_with_link"}, {"name": "originating_app_id", "value": "211604355607"}, {"name": "actor_is_collaborator_account", "boolValue": false}]}], "ipAddress": "212.199.47.186"}, "enriched": {"actor": {"domain": "@reco.ai", "labels": [{"label": {"name": "Leaving Org User", "type": "LABEL_TYPE_INFORMATIVE", "tooltip": "leaving employee", "created_by": 10, "risk_level": 0, "description": "Leaving employee"}}], "category": "internal_primary_email", "full_name": "Gal Nakash", "user_json": [{"user": {"name": "Gal Nakash", "email": "gal@reco.ai", "profile_photo": "https://lh3.googleusercontent.com/a/AGNmyxamQOapfJUioeUuapX4zTCYyvjbDBCs6e-kWwM2=s100"}}], "department": "", "email_account": "gal@reco.ai", "ordered_groups": ["Reco IL", "Reco All", "Group RND", "reco-all", "Group GTM", "Team DevOps", "Founders", "Everyone"], "p_50_downloads": 0, "p_90_downloads": 2.4000000000000026, "average_downloads": 0.9666666666666667}, "asset": {"labels": [{"label": {"name": "Confidential General", "type": "LABEL_TYPE_BUSINESS_IMPACT", "tooltip": "Data assets regardless of their type, defined as sensitive because that terms such as \"confidential\", \"private\", \"sensitive\" were detected in the asset name", "created_by": 10, "risk_level": 40, "description": "Data assets regardless of their type, defined as sensitive because that terms such as \"confidential\", \"private\", \"sensitive\" were detected in the asset name", "data_category": "Confidential - Global"}}], "source": "GSUITE_GDRIVE_AUDIT_LOG_API", "file_id": "1-GFA96ZEszHht9RI-GI10zi4AAQDb2q24eFb215DbNA", "file_url": [{"asset": {"link": "https://drive.google.com/file/d/1-GFA96ZEszHht9RI-GI10zi4AAQDb2q24eFb215DbNA", "value": "Copy of sensitive file"}, "asset_id": "1-GFA96ZEszHht9RI-GI10zi4AAQDb2q24eFb215DbNA", "data_source": "GSUITE_GDRIVE_AUDIT_LOG_API"}], "location": "gal@reco.ai", "file_name": "Copy of sensitive file", "file_size": 0, "file_type": "document", "file_owner": "gal@reco.ai", "visibility": "PERMISSION_TYPE_PEOPLE_WITH_LINK", "delete_state": "active", "data_categories": ["Confidential - Global"], "last_update_time": "2023-04-20T18:32:32+00:00", "sensitivity_level": 40, "currently_permitted_users": ["gal@reco.ai"]}}, "policy_id": "7f174580-81b6-4349-a4ca-ca8873b48b78", "violation": {"enriched.asset.sensitivity_level in [30, 40, \"30\", \"40\"] or enriched.asset.risk_level in [30, 40, \"30\", \"40\"]": true, "$count(payload.events.parameters[name=\"visibility\" and value=\"people_with_link\"]) > 0 and $count(payload.events.parameters[name=\"old_visibility\" and value=\"people_with_link\"]) <= 0 and $count(payload.events.parameters[name=\"visibility_change\" and value=\"external\"]) > 0": true, "($count(payload.events[type=\"acl_change\"]) > 0   or $count(payload.events[name=\"change_document_visibility\"]) > 0   or $count(payload.events[name=\"change_document_access_scope\"])) and (       payload.events[type=\"acl_change\"].parameters[name=\"primary_event\"].boolValue       or        payload.events[name=\"change_document_visibility\"].parameters[name=\"primary_event\"].boolValue       or       payload.events[name=\"change_document_access_scope\"].parameters[name=\"primary_event\"].boolValue)": true}, "policy_tags": ["Reco Recommended", ""], "policy_title": "Sensitive assets in Google Drive exposed publicly", "workspace_id": "f4be4202-4a6e-4bf7-b058-5d33a3146df7", "additional_data": {"x-real-ip": "10.2.172.102", ":authority": "gsuite-extractor-service:50051", "user-agent": "grpc-go/1.54.0", "content-type": "application/grpc", "x-amzn-trace-id": "Root=1-64523588-3352b53c0f584c3868691502", "x-forwarded-for": "74.125.210.190,74.125.210.190, 10.2.111.172", "x-forwarded-host": "demo.reco.ai", "x-forwarded-port": "443", "x-forwarded-proto": "https", "x-goog-channel-id": "814e0909-e042-429f-a7e6-b21cffab1364", "grpcgateway-accept": "*/*", "x-goog-resource-id": "URC10CatzM5Wl0yo-i0ms4lagsU", "x-goog-resource-uri": "https://admin.googleapis.com/admin/reports/v1/activity/users/all/applications/drive?alt=json&orgUnitID&prettyPrint=false", "x-goog-channel-token": "Lrwiu1zoOQEa5Ja59o980qC5SjFucVIGO2IkcIXZIP2wQCsBO-1tWrH3soAEBfNLYgZP4nkJg94UeQ0dyMCqHN9J--6MCWZKVu98WoxAbe5qaF3VyAeOiqTC0rdo4AHJ", "x-goog-message-number": "7926378", "x-goog-resource-state": "edit", "grpcgateway-user-agent": "APIs-Google; (+https://developers.google.com/webmasters/APIs-Google.html)", "grpcgateway-content-type": "application/json; charset=UTF-8", "x-goog-channel-expiration": "Wed, 03 May 2023 13:08:48 GMT"}, "extraction_time": {"nanos": 792365101, "millis": 1683109256792, "seconds": 1683109256, "timestamp": "2023-05-03T10:20:56.792365101Z"}, "extraction_source": 10, "extraction_source_upper_case": "GSUITE_GDRIVE_AUDIT_LOG_API"}",  # noqa
                    "createdAt": "2023-05-03T10:21:03.926534Z",
                    "policyStatusOnViolationCreation": "POLICY_STATUS_ON",
                }
            ],
            "createdAt": "2023-05-03T10:21:04.765477Z",
            "updatedAt": "2023-05-03T10:21:04.078627Z",
        }
    }
    alerts_table = GetIncidentTableResponse(
        get_table_response=GetTableResponse(
            data=TableData(
                rows=[
                    RowData(
                        cells=[
                            KeyValuePair(
                                key="id",
                                value=base64.b64encode(
                                    "ZWU1OTNkYzItYTUwZS00MTVlLWJlZDAtODQwM2MxOGIyNmNh".encode(ENCODING)
                                ).decode(ENCODING),
                            ),
                            KeyValuePair(
                                key="description",
                                value=base64.b64encode(
                                    INCIDENT_DESCRIPTION.encode(ENCODING)
                                ).decode(ENCODING),
                            ),
                            KeyValuePair(
                                key="risk_level",
                                value=base64.b64encode(
                                    "HIGH".encode(ENCODING)
                                ).decode(ENCODING),
                            ),
                            KeyValuePair(
                                key="created_at",
                                value=base64.b64encode(
                                    datetime.datetime.now()
                                    .strftime(TIME_FORMAT)
                                    .encode(ENCODING)
                                ).decode(ENCODING),
                            ),
                            KeyValuePair(
                                key="updated_at",
                                value=base64.b64encode(
                                    datetime.datetime.now()
                                    .strftime(TIME_FORMAT)
                                    .encode(ENCODING)
                                ).decode(ENCODING),
                            ),
                            KeyValuePair(
                                key="status",
                                value=base64.b64encode(
                                    INCIDENT_STATUS.encode(ENCODING)
                                ).decode(ENCODING),
                            ),
                        ]
                    )
                ]
            ),
            total_number_of_results=1,
            table_definition="",
            dynamic_table_definition="",
            token="",
        ),
    )
    return alerts_table, alert


def get_random_assets_user_has_access_to_response() -> GetIncidentTableResponse:
    return GetIncidentTableResponse(
        get_table_response=GetTableResponse(
            data=TableData(
                rows=[
                    RowData(
                        cells=[
                            KeyValuePair(
                                key="source",
                                value=base64.b64encode(
                                    "GDRIVE_ACCESS_LOG_AP".encode(ENCODING)
                                ).decode(ENCODING),
                            ),
                            KeyValuePair(
                                key="file_type",
                                value=base64.b64encode(
                                    "document".encode(ENCODING)
                                ).decode(ENCODING),
                            ),
                            KeyValuePair(
                                key="currently_permitted_users",
                                value=base64.b64encode(
                                    json.dumps(["a", "b", "c", "d", "e"]).encode(
                                        ENCODING
                                    )
                                ).decode(ENCODING),
                            ),
                            KeyValuePair(
                                key="labels",
                                value=base64.b64encode(
                                    json.dumps(["a", "b", "c", "d", "e"]).encode(
                                        ENCODING
                                    )
                                ).decode(ENCODING),
                            ),
                            KeyValuePair(
                                key="delete_state",
                                value=base64.b64encode(
                                    "active".encode(ENCODING)
                                ).decode(ENCODING),
                            ),
                            KeyValuePair(
                                key="file_size",
                                value=base64.b64encode("0".encode(ENCODING)).decode(
                                    ENCODING
                                ),
                            ),
                            KeyValuePair(
                                key="file_name",
                                value=base64.b64encode(
                                    "User Activity Report".encode(ENCODING)
                                ).decode(ENCODING),
                            ),
                            KeyValuePair(
                                key="visibility",
                                value=base64.b64encode(
                                    "shared_internally".encode(ENCODING)
                                ).decode(ENCODING),
                            ),
                            KeyValuePair(
                                key="asset_id",
                                value=base64.b64encode("1".encode(ENCODING)).decode(
                                    ENCODING
                                ),
                            ),
                            KeyValuePair(
                                key="file_owner",
                                value=base64.b64encode("a".encode(ENCODING)).decode(
                                    ENCODING
                                ),
                            ),
                        ],
                    )
                ],
            ),
            total_number_of_results=1,
            table_definition="",
            dynamic_table_definition="",
            token="",
        ),
    )


def get_random_risky_users_response() -> GetIncidentTableResponse:
    return GetIncidentTableResponse(
        get_table_response=GetTableResponse(
            data=TableData(
                rows=[
                    RowData(
                        cells=[
                            KeyValuePair(
                                key="full_name",
                                value=base64.b64encode(
                                    "John Doe".encode(ENCODING)
                                ).decode(ENCODING),
                            ),
                            KeyValuePair(
                                key="email_account",
                                value=base64.b64encode(
                                    f"{uuid.uuid4()}@acme.com".encode(ENCODING)
                                ).decode(ENCODING),
                            ),
                            KeyValuePair(
                                key="risk_level",
                                value=base64.b64encode(
                                    str(RiskLevel.HIGH.value).encode(ENCODING)
                                ).decode(ENCODING),
                            ),
                            KeyValuePair(
                                key="added_by",
                                value=base64.b64encode(
                                    "system".encode(ENCODING)
                                ).decode(ENCODING),
                            ),
                            KeyValuePair(
                                key="created_at",
                                value=base64.b64encode(
                                    datetime.datetime.now()
                                    .strftime(TIME_FORMAT)
                                    .encode(ENCODING)
                                ).decode(ENCODING),
                            ),
                        ]
                    )
                ]
            ),
            total_number_of_results=1,
            table_definition="",
            dynamic_table_definition="",
            token="",
        ),
    )


def get_mock_assets() -> list[dict[str, Any]]:
    return {
        "assets": [
            {
                "entityId": "1Fk-_IB4nAWh5TRkG7bV7LKj15ZQP0DimklY2fr5fKX1",
                "name": "Untitled document",
                "link": "https://drive.google.com/file/d/1Fk-_IB4nAWh5TRkG7bV7LKj15ZQP0DimklY2fr5fKX1",
                "dataSource": "GSUITE_GDRIVE_AUDIT_LOG_API",
                "type": "ASSET_TYPE_FILE",
                "attributes": {},
                "owner": "test@acme.com",
            }
        ]
    }


def test_test_module_success(requests_mock, reco_client: RecoClient) -> None:
    mock_response = {"dataSources": {"tablesMetadata": [{"name": "table1"}]}}
    requests_mock.get(
        f"{DUMMY_RECO_API_DNS_NAME}/data-sources", json=mock_response
    )

    res = reco_client.validate_api_key()
    assert res == "ok"


@pytest.fixture
def reco_client() -> RecoClient:
    api_token = "dummy api key"
    return RecoClient(
        api_token=api_token, base_url=DUMMY_RECO_API_DNS_NAME, verify=True, proxy=True
    )


def test_fetch_incidents_should_succeed(requests_mock, reco_client: RecoClient) -> None:
    random_incidents = get_random_table_response()
    assets = get_mock_assets()
    requests_mock.put(f"{DUMMY_RECO_API_DNS_NAME}/incident", json=random_incidents)
    requests_mock.get(
        f"{DUMMY_RECO_API_DNS_NAME}/incident/assets/{INCIDET_ID_UUID}", json=assets
    )
    random_alerts_response, alert = get_alerts_and_table_response()
    requests_mock.get(f"{DUMMY_RECO_API_DNS_NAME}/alert-inbox/{ALERT_ID}", json=alert)
    requests_mock.put(
        f"{DUMMY_RECO_API_DNS_NAME}/alert-inbox/table", json=random_alerts_response
    )
    last_run, fetched_incidents = fetch_incidents(
        reco_client=reco_client,
        risk_level=40,
        source="test",
        before=datetime.datetime.now(),
        last_run={},
        max_fetch=1,
    )
    expected_count = (random_incidents.getTableResponse.total_number_of_results
                      + random_alerts_response.getTableResponse.total_number_of_results)

    assert (len(fetched_incidents) == expected_count)
    assert fetched_incidents[0].get("name") == INCIDENT_DESCRIPTION
    assert fetched_incidents[0].get("dbotMirrorId") == INCIDET_ID_UUID
    res_json = json.loads(fetched_incidents[0].get("rawJSON"))
    assert res_json.get("assets", {}) == assets.get("assets")


def test_fetch_same_incidents(requests_mock, reco_client: RecoClient) -> None:
    random_incidents = get_random_table_response()
    assets = get_mock_assets()
    requests_mock.put(f"{DUMMY_RECO_API_DNS_NAME}/incident", json=random_incidents)
    requests_mock.get(
        f"{DUMMY_RECO_API_DNS_NAME}/incident/assets/{INCIDET_ID_UUID}", json=assets
    )
    random_alerts_response, alert = get_alerts_and_table_response()
    requests_mock.get(f"{DUMMY_RECO_API_DNS_NAME}/alert-inbox/{ALERT_ID}", json=alert)
    requests_mock.put(
        f"{DUMMY_RECO_API_DNS_NAME}/alert-inbox/table", json=random_alerts_response
    )
    last_run, fetched_incidents = fetch_incidents(
        reco_client=reco_client,
        risk_level=40,
        before=datetime.datetime.now(),
        last_run={},
        max_fetch=1,
    )
    expected_count = (random_incidents.getTableResponse.total_number_of_results
                      + random_alerts_response.getTableResponse.total_number_of_results)

    assert (len(fetched_incidents) == expected_count)
    last_run, incidents = fetch_incidents(
        reco_client=reco_client,
        risk_level=40,
        before=datetime.datetime.now(),
        last_run=last_run,
        max_fetch=1,
    )
    assert len(incidents) == 0


def test_fetch_incidents_without_assets_info(
    requests_mock, reco_client: RecoClient
) -> None:
    random_incidents = get_random_table_response()
    requests_mock.put(f"{DUMMY_RECO_API_DNS_NAME}/incident", json=random_incidents)
    requests_mock.get(
        f"{DUMMY_RECO_API_DNS_NAME}/incident/assets/{INCIDET_ID_UUID}", json={}
    )
    random_alerts_response, alert = get_alerts_and_table_response()
    requests_mock.get(f"{DUMMY_RECO_API_DNS_NAME}/alert-inbox/{ALERT_ID}", json=alert)
    requests_mock.put(f"{DUMMY_RECO_API_DNS_NAME}/alert-inbox/table", json=random_alerts_response)
    last_run, fetched_incidents = fetch_incidents(
        reco_client=reco_client, last_run={}, source="GOOGLE_DRIVE", max_fetch=1
    )

    expected_count = (random_incidents.getTableResponse.total_number_of_results
                      + random_alerts_response.getTableResponse.total_number_of_results)

    assert (len(fetched_incidents) == expected_count)
    assert fetched_incidents[0].get("name") == INCIDENT_DESCRIPTION
    assert fetched_incidents[0].get("dbotMirrorId") == INCIDET_ID_UUID
    res_json = json.loads(fetched_incidents[0].get("rawJSON"))
    assert res_json.get("assets", {}) == []


def test_fetch_assets_with_empty_response(
    requests_mock, reco_client: RecoClient
) -> None:
    incident_id = uuid.uuid1()
    requests_mock.get(
        f"{DUMMY_RECO_API_DNS_NAME}/incident/assets/{incident_id}", json={}
    )
    assets = reco_client.get_incidents_assets(incident_id=incident_id)
    assert assets == []


def test_empty_response(requests_mock, reco_client: RecoClient) -> None:
    table_empty = GetIncidentTableResponse(
        get_table_response=GetTableResponse(
            data=TableData(rows=[]),
            total_number_of_results=0,
            table_definition="",
            dynamic_table_definition="",
            token="",
        )
    )
    requests_mock.put(
        f"{DUMMY_RECO_API_DNS_NAME}/incident",
        json=table_empty,
    )
    requests_mock.put(f"{DUMMY_RECO_API_DNS_NAME}/alert-inbox/table", json=table_empty)
    last_run, fetched_incidents = fetch_incidents(
        reco_client=reco_client, last_run={}, max_fetch=1
    )

    assert len(fetched_incidents) == 0
    assert last_run is not None


def test_empty_valid_response(requests_mock, reco_client: RecoClient) -> None:
    table_empty = GetIncidentTableResponse(
        get_table_response=GetTableResponse(
            data=TableData(rows=[]),
            total_number_of_results=0,
            table_definition="",
            dynamic_table_definition="",
            token="",
        )
    )
    requests_mock.put(
        f"{DUMMY_RECO_API_DNS_NAME}/incident",
        json=table_empty,
    )
    requests_mock.put(f"{DUMMY_RECO_API_DNS_NAME}/alert-inbox/table", json=table_empty)
    last_run, fetched_incidents = fetch_incidents(
        reco_client=reco_client, last_run={}, max_fetch=1
    )

    assert len(fetched_incidents) == 0
    assert last_run is not None


def test_invalid_response(requests_mock, reco_client: RecoClient) -> None:
    requests_mock.put(f"{DUMMY_RECO_API_DNS_NAME}/incident", json={"getTableResponse": {}})
    requests_mock.put(f"{DUMMY_RECO_API_DNS_NAME}/alert-inbox/table", json={
        "getTableResponse": {}
    })
    last_run, fetched_incidents = fetch_incidents(
        reco_client=reco_client,
        last_run={},
        max_fetch=1,
        risk_level=str(RiskLevel.HIGH),
        source="GSUITE_GDRIVE_AUDIT_LOG_API",
    )

    assert len(fetched_incidents) == 0
    assert last_run is not None


def test_risk_level_mapper():
    risk_level_high = 40
    assert map_reco_score_to_demisto_score(risk_level_high) == 4


def test_alert_mapper():
    assert map_reco_alert_score_to_demisto_score("CRITICAL") == 4


def test_get_max_fetch_bigger():
    big_number_max_fetch = 600
    result = get_max_fetch(big_number_max_fetch)
    assert result == 500


def test_max_fetch():
    max_fetch = 200
    result = get_max_fetch(max_fetch)
    assert result == max_fetch


def test_update_reco_incident_timeline(requests_mock, reco_client: RecoClient) -> None:
    incident_id = uuid.uuid1()
    requests_mock.put(
        f"{DUMMY_RECO_API_DNS_NAME}/incident-timeline/{str(incident_id)}",
        json={},
        status_code=200,
    )
    res = reco_client.update_reco_incident_timeline(
        incident_id=str(incident_id), comment="test"
    )
    assert res == {}


def test_update_reco_incident_timeline_error(
    capfd, requests_mock, reco_client: RecoClient
) -> None:
    incident_id = uuid.uuid1()
    requests_mock.put(
        f"{DUMMY_RECO_API_DNS_NAME}/incident-timeline/{str(incident_id)}",
        json={},
        status_code=404,
    )
    with capfd.disabled(), pytest.raises(Exception):
        reco_client.update_reco_incident_timeline(
            incident_id=str(incident_id), comment="test"
        )


def test_resolve_visibility_event(requests_mock, reco_client: RecoClient) -> None:
    entry_id = uuid.uuid1()
    requests_mock.put(
        f"{DUMMY_RECO_API_DNS_NAME}/set-label-status", json={}, status_code=200
    )
    res = reco_client.resolve_visibility_event(
        entity_id=str(entry_id), label_name="Accessible by all"
    )
    assert res == {}


def test_resolve_visibility_event_error(
    capfd, requests_mock, reco_client: RecoClient
) -> None:
    entry_id = uuid.uuid1()
    requests_mock.put(
        f"{DUMMY_RECO_API_DNS_NAME}/set-label-status", json={}, status_code=404
    )
    with capfd.disabled(), pytest.raises(Exception):
        reco_client.resolve_visibility_event(
            entity_id=str(entry_id), label_name="Accessible by all"
        )


def test_get_risky_users(requests_mock, reco_client: RecoClient) -> None:
    raw_result = get_random_risky_users_response()
    requests_mock.put(
        f"{DUMMY_RECO_API_DNS_NAME}/risk-management/get-risk-management-table",
        json=raw_result,
        status_code=200,
    )
    actual_result = get_risky_users_from_reco(reco_client=reco_client)
    assert len(actual_result.outputs) == len(raw_result.getTableResponse.data.rows)
    assert "@" in actual_result.outputs[0].get("email_account")


def test_get_risky_users_bad_response(
    capfd, requests_mock, reco_client: RecoClient
) -> None:
    requests_mock.put(
        f"{DUMMY_RECO_API_DNS_NAME}/risk-management/get-risk-management-table",
        json={},
        status_code=200,
    )
    with capfd.disabled(), pytest.raises(Exception):
        get_risky_users_from_reco(reco_client=reco_client)


def test_add_risky_user_label(requests_mock, reco_client: RecoClient) -> None:
    label_id = f"{uuid.uuid1()}@gmail.com"
    requests_mock.put(
        f"{DUMMY_RECO_API_DNS_NAME}/entry-label-relations", json={}, status_code=200
    )
    res = add_risky_user_label(reco_client=reco_client, email_address=label_id)
    assert "labeled as risky" in res.readable_output


def test_get_assets_user_has_access_to(requests_mock, reco_client: RecoClient) -> None:
    raw_result = get_random_assets_user_has_access_to_response()
    requests_mock.post(
        f"{DUMMY_RECO_API_DNS_NAME}/asset-management", json=raw_result, status_code=200
    )
    actual_result = get_assets_user_has_access(
        reco_client=reco_client,
        email_address=f"{uuid.uuid1()}@gmail.com",
        only_sensitive=False,
    )
    assert len(actual_result.outputs) == len(raw_result.getTableResponse.data.rows)
    assert actual_result.outputs[0].get("source") is not None


def test_get_assets_user_bad_response(
    capfd, requests_mock, reco_client: RecoClient
) -> None:
    requests_mock.post(
        f"{DUMMY_RECO_API_DNS_NAME}/asset-management", json={}, status_code=200
    )
    with capfd.disabled(), pytest.raises(Exception):
        get_assets_user_has_access(
            reco_client=reco_client, email_address="test", only_sensitive=False
        )


def test_get_sensitive_assets_by_name(requests_mock, reco_client: RecoClient) -> None:
    raw_result = get_random_assets_user_has_access_to_response()
    requests_mock.post(
        f"{DUMMY_RECO_API_DNS_NAME}/asset-management", json=raw_result, status_code=200
    )
    actual_result = get_sensitive_assets_by_name(
        reco_client=reco_client, asset_name="test", regex_search=True
    )
    assert len(actual_result.outputs) == len(raw_result.getTableResponse.data.rows)
    assert actual_result.outputs[0].get("source") is not None


def test_get_sensitive_assets_by_id(requests_mock, reco_client: RecoClient) -> None:
    raw_result = get_random_assets_user_has_access_to_response()
    requests_mock.post(
        f"{DUMMY_RECO_API_DNS_NAME}/asset-management", json=raw_result, status_code=200
    )
    actual_result = get_sensitive_assets_by_id(
        reco_client=reco_client, asset_id="asset-id"
    )
    assert len(actual_result.outputs) == len(raw_result.getTableResponse.data.rows)
    assert actual_result.outputs[0].get("source") is not None


def test_get_link_to_user_overview_page(requests_mock, reco_client: RecoClient) -> None:
    entity_id = f"{uuid.uuid1()}@gmail.com"
    link_type = "RM_LINK_TYPE_USER"
    link_res = str(uuid.uuid1())
    requests_mock.get(
        f"{DUMMY_RECO_API_DNS_NAME}/risk-management/risk-management/link?link_type={link_type}&param={entity_id}",
        json={"link": link_res}, status_code=200
    )
    actual_result = get_link_to_user_overview_page(
        reco_client=reco_client, entity=entity_id, link_type=link_type
    )
    assert actual_result.outputs_prefix == "Reco.Link"
    assert actual_result.outputs.get("link") == link_res


def test_get_link_to_user_overview_page_error(capfd, requests_mock, reco_client: RecoClient) -> None:
    entity_id = f"{uuid.uuid1()}@gmail.com"
    link_type = "RM_LINK_TYPE_USER"
    requests_mock.get(
        f"{DUMMY_RECO_API_DNS_NAME}/risk-management/risk-management/link?link_type={link_type}&param={entity_id}",
        json={}, status_code=200
    )
    with capfd.disabled(), pytest.raises(Exception):
        get_link_to_user_overview_page(reco_client=reco_client, entity=entity_id, link_type=link_type)


def test_get_exposed_publicly(requests_mock, reco_client: RecoClient) -> None:
    raw_result = get_random_assets_user_has_access_to_response()
    requests_mock.put(
        f"{DUMMY_RECO_API_DNS_NAME}/risk-management/get-data-risk-management-table", json=raw_result, status_code=200
    )
    actual_result = get_sensitive_assets_shared_with_public_link(
        reco_client=reco_client
    )
    assert len(actual_result.outputs) == len(raw_result.getTableResponse.data.rows)
    assert actual_result.outputs[0].get("source") is not None


def test_get_exposed_publicly_page_error(capfd, requests_mock, reco_client: RecoClient) -> None:
    requests_mock.put(
        f"{DUMMY_RECO_API_DNS_NAME}/risk-management/get-data-risk-management-table", json={}, status_code=200)
    with capfd.disabled(), pytest.raises(Exception):
        get_sensitive_assets_shared_with_public_link(
            reco_client=reco_client
        )


def test_get_3rd_parties_list_error(capfd, requests_mock, reco_client: RecoClient) -> None:
    requests_mock.put(
        f"{DUMMY_RECO_API_DNS_NAME}/risk-management/get-data-risk-management-table", json={}, status_code=200)
    with capfd.disabled(), pytest.raises(Exception):
        get_3rd_parties_list(
            reco_client=reco_client,
            last_interaction_time_in_days=30,
        )


def test_get_3rd_parties_list(requests_mock, reco_client: RecoClient) -> None:
    raw_result = get_random_assets_user_has_access_to_response()
    requests_mock.put(
        f"{DUMMY_RECO_API_DNS_NAME}/risk-management/get-data-risk-management-table", json=raw_result, status_code=200
    )
    actual_result = get_3rd_parties_list(
        reco_client=reco_client,
        last_interaction_time_in_days=30,
    )
    assert len(actual_result.outputs) == len(raw_result.getTableResponse.data.rows)


def test_get_files_shared_with_3rd_parties(requests_mock, reco_client: RecoClient) -> None:
    raw_result = get_random_assets_user_has_access_to_response()
    requests_mock.put(
        f"{DUMMY_RECO_API_DNS_NAME}/risk-management/get-data-risk-management-table", json=raw_result, status_code=200
    )
    actual_result = get_files_shared_with_3rd_parties(
        reco_client=reco_client,
        domain="data",
        last_interaction_time_before_in_days=30,
    )
    assert len(actual_result.outputs) == len(raw_result.getTableResponse.data.rows)


def test_date_formatting(reco_client: RecoClient) -> None:
    date = reco_client.get_date_time_before_days_formatted(30)
    assert ".999Z" in date


def test_add_exclusion_filter(requests_mock, reco_client: RecoClient) -> None:
    requests_mock.post(
        f"{DUMMY_RECO_API_DNS_NAME}/algo/add_values_to_data_type_exclude_analyzer", json={}, status_code=200
    )
    reco_client.add_exclusion_filter("key", ["val1", "val2"])


def test_change_alert_status(requests_mock, reco_client: RecoClient) -> None:
    alert_id = uuid.uuid1()
    status = 'ALERT_STATUS_CLOSED'
    requests_mock.put(
        f"{DUMMY_RECO_API_DNS_NAME}/alert-inbox/{str(alert_id)}/status/{status}",
        json={},
        status_code=200,
    )
    res = reco_client.change_alert_status(alert_id=str(alert_id),
                                          status=status)
    assert res == {}
