darkhelm/notifications-admin
1
0
Fork 0
mirror of https://github.com/GSA/notifications-admin.git synced 2026-07-16 19:30:13 -04:00
Code Issues Packages Projects Releases Wiki Activity

remove easy targets

Browse Source
This commit is contained in:
Kenneth Kehl
2024-05-20 10:45:34 -07:00
parent 5bc652db9e
commit d045ecfa21
11 changed files with 1 additions and 681 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
tests/notifications_utils/clients/antivirus/test_antivirus_client.py
View File

@@ -1,71 +0,0 @@
import io
import pytest
import requests
from notifications_utils.clients.antivirus.antivirus_client import (
AntivirusClient,
AntivirusError,
)
@pytest.fixture()
def antivirus(app, mocker):
client = AntivirusClient()
app.config["ANTIVIRUS_API_HOST"] = "https://antivirus"
app.config["ANTIVIRUS_API_KEY"] = "test-antivirus-key"
client.init_app(app)
return client
def test_scan_document(antivirus, rmock):
document = io.BytesIO(b"filecontents")
rmock.request(
"POST",
"https://antivirus/scan",
json={"ok": True},
request_headers={
"Authorization": "Bearer test-antivirus-key",
},
status_code=200,
)
resp = antivirus.scan(document)
assert resp
assert "filecontents" in rmock.last_request.text
assert document.tell() == 0
def test_should_raise_for_status(antivirus, rmock):
with pytest.raises(AntivirusError) as excinfo:
_test_one_statement_for_status(antivirus, rmock)
assert excinfo.value.message == "Antivirus error"
assert excinfo.value.status_code == 400
def _test_one_statement_for_status(antivirus, rmock):
rmock.request(
"POST",
"https://antivirus/scan",
json={"error": "Antivirus error"},
status_code=400,
)
antivirus.scan(io.BytesIO(b"document"))
def test_should_raise_for_connection_errors(antivirus, rmock):
with pytest.raises(AntivirusError) as excinfo:
_test_one_statement_for_connection_errors(antivirus, rmock)
assert excinfo.value.message == "connection error"
assert excinfo.value.status_code == 503
def _test_one_statement_for_connection_errors(antivirus, rmock):
rmock.request(
"POST", "https://antivirus/scan", exc=requests.exceptions.ConnectTimeout
)
antivirus.scan(io.BytesIO(b"document"))

88
tests/notifications_utils/clients/encryption/test_encryption_client.py
View File

@@ -1,88 +0,0 @@
import pytest
from notifications_utils.clients.encryption.encryption_client import (
Encryption,
EncryptionError,
)
@pytest.fixture()
def encryption_client(app):
client = Encryption()
app.config["SECRET_KEY"] = "test-notify-secret-key"
app.config["DANGEROUS_SALT"] = "test-notify-salt"
client.init_app(app)
return client
def test_should_ensure_shared_salt_security(app):
client = Encryption()
app.config["SECRET_KEY"] = "test-notify-secret-key"
app.config["DANGEROUS_SALT"] = "too-short"
with pytest.raises(EncryptionError):
client.init_app(app)
def test_should_ensure_custom_salt_security(encryption_client):
with pytest.raises(EncryptionError):
encryption_client.encrypt("this", salt="too-short")
def test_should_encrypt_strings(encryption_client):
encrypted = encryption_client.encrypt("this")
assert encrypted != "this"
assert isinstance(encrypted, str)
def test_should_encrypt_dicts(encryption_client):
to_encrypt = {"hello": "world"}
encrypted = encryption_client.encrypt(to_encrypt)
assert encrypted != to_encrypt
assert encryption_client.decrypt(encrypted) == to_encrypt
def test_encryption_is_nondeterministic(encryption_client):
first_run = encryption_client.encrypt("this")
second_run = encryption_client.encrypt("this")
assert first_run != second_run
def test_should_decrypt_content(encryption_client):
encrypted = encryption_client.encrypt("this")
assert encryption_client.decrypt(encrypted) == "this"
def test_should_decrypt_content_with_custom_salt(encryption_client):
salt = "different-salt-value"
encrypted = encryption_client.encrypt("this", salt=salt)
assert encryption_client.decrypt(encrypted, salt=salt) == "this"
def test_should_verify_decryption(encryption_client):
encrypted = encryption_client.encrypt("this")
with pytest.raises(EncryptionError):
encryption_client.decrypt(encrypted, salt="different-salt-value")
def test_should_sign_and_serialize_string(encryption_client):
signed = encryption_client.sign("this")
assert signed != "this"
def test_should_verify_signature_and_deserialize_string(encryption_client):
signed = encryption_client.sign("this")
assert encryption_client.verify_signature(signed) == "this"
def test_should_raise_encryption_error_on_bad_salt(encryption_client):
signed = encryption_client.sign("this")
with pytest.raises(EncryptionError):
encryption_client.verify_signature(signed, salt="different-salt-value")
def test_should_sign_and_serialize_json(encryption_client):
signed = encryption_client.sign({"this": "that"})
assert encryption_client.verify_signature(signed) == {"this": "that"}

227
tests/notifications_utils/clients/zendesk/test_zendesk_client.py
View File

@@ -1,227 +0,0 @@
from base64 import b64decode
import pytest
from notifications_utils.clients.zendesk.zendesk_client import (
NotifySupportTicket,
ZendeskClient,
ZendeskError,
)
@pytest.fixture()
def zendesk_client(app):
client = ZendeskClient()
app.config["ZENDESK_API_KEY"] = "testkey"
client.init_app(app)
return client
def test_zendesk_client_send_ticket_to_zendesk(zendesk_client, app, mocker, rmock):
rmock.request(
"POST",
ZendeskClient.ZENDESK_TICKET_URL,
status_code=201,
json={
"ticket": {
"id": 12345,
"subject": "Something is wrong",
}
},
)
mock_logger = mocker.patch.object(app.logger, "info")
ticket = NotifySupportTicket("subject", "message", "incident")
zendesk_client.send_ticket_to_zendesk(ticket)
assert rmock.last_request.headers["Authorization"][:6] == "Basic "
b64_auth = rmock.last_request.headers["Authorization"][6:]
assert (
b64decode(b64_auth.encode()).decode()
== "zd-api-notify@digital.cabinet-office.gov.uk/token:testkey"
)
assert rmock.last_request.json() == ticket.request_data
mock_logger.assert_called_once_with("Zendesk create ticket 12345 succeeded")
def test_zendesk_client_send_ticket_to_zendesk_error(
zendesk_client, app, mocker, rmock
):
rmock.request(
"POST", ZendeskClient.ZENDESK_TICKET_URL, status_code=401, json={"foo": "bar"}
)
mock_logger = mocker.patch.object(app.logger, "error")
ticket = NotifySupportTicket("subject", "message", "incident")
with pytest.raises(ZendeskError):
zendesk_client.send_ticket_to_zendesk(ticket)
mock_logger.assert_called_with(
"Zendesk create ticket request failed with 401 '{'foo': 'bar'}'"
)
@pytest.mark.parametrize(
("p1_arg", "expected_tags", "expected_priority"),
[
(
{},
["govuk_notify_support"],
"normal",
),
(
{
"p1": False,
},
["govuk_notify_support"],
"normal",
),
(
{
"p1": True,
},
["govuk_notify_emergency"],
"urgent",
),
],
)
def test_notify_support_ticket_request_data(p1_arg, expected_tags, expected_priority):
notify_ticket_form = NotifySupportTicket("subject", "message", "question", **p1_arg)
assert notify_ticket_form.request_data == {
"ticket": {
"subject": "subject",
"comment": {
"body": "message",
"public": True,
},
"group_id": NotifySupportTicket.NOTIFY_GROUP_ID,
"organization_id": NotifySupportTicket.NOTIFY_ORG_ID,
"ticket_form_id": NotifySupportTicket.NOTIFY_TICKET_FORM_ID,
"priority": expected_priority,
"tags": expected_tags,
"type": "question",
"custom_fields": [
{"id": "1900000744994", "value": "notify_ticket_type_non_technical"},
{"id": "360022836500", "value": []},
{"id": "360022943959", "value": None},
{"id": "360022943979", "value": None},
{"id": "1900000745014", "value": None},
],
}
}
def test_notify_support_ticket_request_data_with_message_hidden_from_requester():
notify_ticket_form = NotifySupportTicket(
"subject", "message", "problem", requester_sees_message_content=False
)
assert notify_ticket_form.request_data["ticket"]["comment"]["public"] is False
@pytest.mark.parametrize(
("name", "zendesk_name"), [("Name", "Name"), (None, "(no name supplied)")]
)
def test_notify_support_ticket_request_data_with_user_name_and_email(
name, zendesk_name
):
notify_ticket_form = NotifySupportTicket(
"subject", "message", "question", user_name=name, user_email="user@example.com"
)
assert (
notify_ticket_form.request_data["ticket"]["requester"]["email"]
== "user@example.com"
)
assert (
notify_ticket_form.request_data["ticket"]["requester"]["name"] == zendesk_name
)
@pytest.mark.parametrize(
(
"custom_fields",
"tech_ticket_tag",
"categories",
"org_id",
"org_type",
"service_id",
),
[
(
{"technical_ticket": True},
"notify_ticket_type_technical",
[],
None,
None,
None,
),
(
{"technical_ticket": False},
"notify_ticket_type_non_technical",
[],
None,
None,
None,
),
(
{"ticket_categories": ["notify_billing", "notify_bug"]},
"notify_ticket_type_non_technical",
["notify_billing", "notify_bug"],
None,
None,
None,
),
(
{"org_id": "1234", "org_type": "local"},
"notify_ticket_type_non_technical",
[],
"1234",
"notify_org_type_local",
None,
),
(
{"service_id": "abcd", "org_type": "nhs"},
"notify_ticket_type_non_technical",
[],
None,
"notify_org_type_nhs",
"abcd",
),
],
)
def test_notify_support_ticket_request_data_custom_fields(
custom_fields,
tech_ticket_tag,
categories,
org_id,
org_type,
service_id,
):
notify_ticket_form = NotifySupportTicket(
"subject", "message", "question", **custom_fields
)
assert notify_ticket_form.request_data["ticket"]["custom_fields"] == [
{"id": "1900000744994", "value": tech_ticket_tag},
{"id": "360022836500", "value": categories},
{"id": "360022943959", "value": org_id},
{"id": "360022943979", "value": org_type},
{"id": "1900000745014", "value": service_id},
]
def test_notify_support_ticket_request_data_email_ccs():
notify_ticket_form = NotifySupportTicket(
"subject", "message", "question", email_ccs=["someone@example.com"]
)
assert notify_ticket_form.request_data["ticket"]["email_ccs"] == [
{"user_email": "someone@example.com", "action": "put"},
]