def test_plugin_ses_attachments(mock_post):
"""
NotifySES() Attachment Checks
"""
# Disable Throttling to speed testing
plugins.NotifySES.request_rate_per_sec = 0
# Prepare Mock return object
response = mock.Mock()
response.content = AWS_SES_GOOD_RESPONSE
response.status_code = requests.codes.ok
mock_post.return_value = response
# prepare our attachment
attach = AppriseAttachment(os.path.join(TEST_VAR_DIR, 'apprise-test.gif'))
# Test our markdown
obj = Apprise.instantiate('ses://%s/%s/%s/%s/' %
('*****@*****.**', TEST_ACCESS_KEY_ID,
TEST_ACCESS_KEY_SECRET, TEST_REGION))
# Send a good attachment
assert obj.notify(body="test", attach=attach) is True
# Reset our mock object
mock_post.reset_mock()
# Add another attachment so we drop into the area of the PushBullet code
# that sends remaining attachments (if more detected)
attach.add(os.path.join(TEST_VAR_DIR, 'apprise-test.gif'))
# Send our attachments
assert obj.notify(body="test", attach=attach) is True
# Test our call count
assert mock_post.call_count == 1
# Reset our mock object
mock_post.reset_mock()
# An invalid attachment will cause a failure
path = os.path.join(TEST_VAR_DIR, '/invalid/path/to/an/invalid/file.jpg')
attach = AppriseAttachment(path)
assert obj.notify(body="test", attach=attach) is False
def test_pushbullet_attachments(mock_post):
"""
API: NotifyPushBullet() Attachment Checks
"""
# Disable Throttling to speed testing
plugins.NotifyBase.request_rate_per_sec = 0
# Initialize some generic (but valid) tokens
access_token = 't' * 32
# Prepare Mock return object
response = mock.Mock()
response.content = dumps({
"file_name": "cat.jpg",
"file_type": "image/jpeg",
"file_url": "https://dl.pushb.com/abc/cat.jpg",
"upload_url": "https://upload.pushbullet.com/abcd123",
})
response.status_code = requests.codes.ok
mock_post.return_value = response
# prepare our attachment
attach = AppriseAttachment(os.path.join(TEST_VAR_DIR, 'apprise-test.gif'))
# Test our markdown
obj = Apprise.instantiate(
'pbul://{}/?format=markdown'.format(access_token))
# Send a good attachment
assert obj.notify(body="test", attach=attach) is True
# Add another attachment so we drop into the area of the PushBullet code
# that sends remaining attachments (if more detected)
attach.add(os.path.join(TEST_VAR_DIR, 'apprise-test.gif'))
# Send our attachments
assert obj.notify(body="test", attach=attach) is True
# An invalid attachment will cause a failure
path = os.path.join(TEST_VAR_DIR, '/invalid/path/to/an/invalid/file.jpg')
attach = AppriseAttachment(path)
assert obj.notify(body="test", attach=attach) is False
# Throw an exception on the first call to requests.post()
mock_post.return_value = None
mock_post.side_effect = requests.RequestException()
# We'll fail now because of an internal exception
assert obj.send(body="test", attach=attach) is False
# Throw an exception on the second call to requests.post()
mock_post.side_effect = [response, OSError()]
# We'll fail now because of an internal exception
assert obj.send(body="test", attach=attach) is False
# Throw an exception on the third call to requests.post()
mock_post.side_effect = [
response, response, requests.RequestException()]
# We'll fail now because of an internal exception
assert obj.send(body="test", attach=attach) is False
# Throw an exception on the forth call to requests.post()
mock_post.side_effect = [
response, response, response, requests.RequestException()]
# We'll fail now because of an internal exception
assert obj.send(body="test", attach=attach) is False
# Test case where we don't get a valid response back
response.content = '}'
mock_post.side_effect = response
# We'll fail because of an invalid json object
assert obj.send(body="test", attach=attach) is False
#
# Test bad responses
#
# Prepare a bad response
response.content = dumps({
"file_name": "cat.jpg",
"file_type": "image/jpeg",
"file_url": "https://dl.pushb.com/abc/cat.jpg",
"upload_url": "https://upload.pushbullet.com/abcd123",
})
bad_response = mock.Mock()
bad_response.content = response.content
bad_response.status_code = 400
# Throw an exception on the third call to requests.post()
mock_post.return_value = bad_response
# prepare our attachment
attach = AppriseAttachment(os.path.join(TEST_VAR_DIR, 'apprise-test.gif'))
# We'll fail now because we were unable to send the attachment
assert obj.send(body="test", attach=attach) is False
# Throw an exception on the second call
mock_post.side_effect = [response, bad_response, response]
assert obj.send(body="test", attach=attach) is False
# Throw an OSError
mock_post.side_effect = [response, OSError()]
assert obj.send(body="test", attach=attach) is False
# Throw an exception on the third call
mock_post.side_effect = [response, response, bad_response]
assert obj.send(body="test", attach=attach) is False
# Throw an exception on the fourth call
mock_post.side_effect = [response, response, response, bad_response]
assert obj.send(body="test", attach=attach) is False
# A good message
mock_post.side_effect = [response, response, response, response]
assert obj.send(body="test", attach=attach) is True
def test_plugin_pushover_attachments(mock_post, tmpdir):
"""
NotifyPushover() Attachment Checks
"""
# Disable Throttling to speed testing
plugins.NotifyBase.request_rate_per_sec = 0
# Initialize some generic (but valid) tokens
user_key = 'u' * 30
api_token = 'a' * 30
# Prepare a good response
response = mock.Mock()
response.content = dumps(
{"status": 1, "request": "647d2300-702c-4b38-8b2f-d56326ae460b"})
response.status_code = requests.codes.ok
# Prepare a bad response
bad_response = mock.Mock()
response.content = dumps(
{"status": 1, "request": "647d2300-702c-4b38-8b2f-d56326ae460b"})
bad_response.status_code = requests.codes.internal_server_error
# Assign our good response
mock_post.return_value = response
# prepare our attachment
attach = AppriseAttachment(os.path.join(TEST_VAR_DIR, 'apprise-test.gif'))
# Instantiate our object
obj = Apprise.instantiate(
'pover://{}@{}/'.format(user_key, api_token))
assert isinstance(obj, plugins.NotifyPushover)
# Test our attachment
assert obj.notify(body="test", attach=attach) is True
# Test our call count
assert mock_post.call_count == 1
assert mock_post.call_args_list[0][0][0] == \
'https://api.pushover.net/1/messages.json'
# Reset our mock object for multiple tests
mock_post.reset_mock()
# Test multiple attachments
assert attach.add(os.path.join(TEST_VAR_DIR, 'apprise-test.gif'))
assert obj.notify(body="test", attach=attach) is True
# Test our call count
assert mock_post.call_count == 2
assert mock_post.call_args_list[0][0][0] == \
'https://api.pushover.net/1/messages.json'
assert mock_post.call_args_list[1][0][0] == \
'https://api.pushover.net/1/messages.json'
# Reset our mock object for multiple tests
mock_post.reset_mock()
image = tmpdir.mkdir("pover_image").join("test.jpg")
image.write('a' * plugins.NotifyPushover.attach_max_size_bytes)
attach = AppriseAttachment.instantiate(str(image))
assert obj.notify(body="test", attach=attach) is True
# Test our call count
assert mock_post.call_count == 1
assert mock_post.call_args_list[0][0][0] == \
'https://api.pushover.net/1/messages.json'
# Reset our mock object for multiple tests
mock_post.reset_mock()
# Add 1 more byte to the file (putting it over the limit)
image.write('a' * (plugins.NotifyPushover.attach_max_size_bytes + 1))
attach = AppriseAttachment.instantiate(str(image))
assert obj.notify(body="test", attach=attach) is False
# Test our call count
assert mock_post.call_count == 0
# Test case when file is missing
attach = AppriseAttachment.instantiate(
'file://{}?cache=False'.format(str(image)))
os.unlink(str(image))
assert obj.notify(
body='body', title='title', attach=attach) is False
# Test our call count
assert mock_post.call_count == 0
# Test unsuported files:
image = tmpdir.mkdir("pover_unsupported").join("test.doc")
image.write('a' * 256)
attach = AppriseAttachment.instantiate(str(image))
# Content is silently ignored
assert obj.notify(body="test", attach=attach) is True
# prepare our attachment
attach = AppriseAttachment(os.path.join(TEST_VAR_DIR, 'apprise-test.gif'))
# Throw an exception on the first call to requests.post()
for side_effect in (requests.RequestException(), OSError(), bad_response):
mock_post.side_effect = [side_effect, side_effect]
# We'll fail now because of our error handling
assert obj.send(body="test", attach=attach) is False
# Same case without an attachment
assert obj.send(body="test") is False
def test_plugin_pushbullet_attachments(mock_post):
"""
NotifyPushBullet() Attachment Checks
"""
# Disable Throttling to speed testing
plugins.NotifyPushBullet.request_rate_per_sec = 0
# Initialize some generic (but valid) tokens
access_token = 't' * 32
# Prepare Mock return object
response = mock.Mock()
response.content = dumps({
"file_name":
"cat.jpg",
"file_type":
"image/jpeg",
"file_url":
"https://dl.pushb.com/abc/cat.jpg",
"upload_url":
"https://upload.pushbullet.com/abcd123",
})
response.status_code = requests.codes.ok
mock_post.return_value = response
# prepare our attachment
attach = AppriseAttachment(os.path.join(TEST_VAR_DIR, 'apprise-test.gif'))
# Test our markdown
obj = Apprise.instantiate(
'pbul://{}/?format=markdown'.format(access_token))
# Send a good attachment
assert obj.notify(body="test", attach=attach) is True
# Test our call count
assert mock_post.call_count == 4
# Image Prep
assert mock_post.call_args_list[0][0][0] == \
'https://api.pushbullet.com/v2/upload-request'
assert mock_post.call_args_list[1][0][0] == \
'https://upload.pushbullet.com/abcd123'
# Message
assert mock_post.call_args_list[2][0][0] == \
'https://api.pushbullet.com/v2/pushes'
# Image Send
assert mock_post.call_args_list[3][0][0] == \
'https://api.pushbullet.com/v2/pushes'
# Reset our mock object
mock_post.reset_mock()
# Add another attachment so we drop into the area of the PushBullet code
# that sends remaining attachments (if more detected)
attach.add(os.path.join(TEST_VAR_DIR, 'apprise-test.gif'))
# Send our attachments
assert obj.notify(body="test", attach=attach) is True
# Test our call count
assert mock_post.call_count == 7
# Image Prep
assert mock_post.call_args_list[0][0][0] == \
'https://api.pushbullet.com/v2/upload-request'
assert mock_post.call_args_list[1][0][0] == \
'https://upload.pushbullet.com/abcd123'
assert mock_post.call_args_list[2][0][0] == \
'https://api.pushbullet.com/v2/upload-request'
assert mock_post.call_args_list[3][0][0] == \
'https://upload.pushbullet.com/abcd123'
# Message
assert mock_post.call_args_list[4][0][0] == \
'https://api.pushbullet.com/v2/pushes'
# Image Send
assert mock_post.call_args_list[5][0][0] == \
'https://api.pushbullet.com/v2/pushes'
assert mock_post.call_args_list[6][0][0] == \
'https://api.pushbullet.com/v2/pushes'
# Reset our mock object
mock_post.reset_mock()
# An invalid attachment will cause a failure
path = os.path.join(TEST_VAR_DIR, '/invalid/path/to/an/invalid/file.jpg')
attach = AppriseAttachment(path)
assert obj.notify(body="test", attach=attach) is False
# Test our call count
assert mock_post.call_count == 0
# prepare our attachment
attach = AppriseAttachment(os.path.join(TEST_VAR_DIR, 'apprise-test.gif'))
# Prepare a bad response
bad_response = mock.Mock()
bad_response.content = dumps({
"file_name":
"cat.jpg",
"file_type":
"image/jpeg",
"file_url":
"https://dl.pushb.com/abc/cat.jpg",
"upload_url":
"https://upload.pushbullet.com/abcd123",
})
bad_response.status_code = requests.codes.internal_server_error
# Prepare a bad response
bad_json_response = mock.Mock()
bad_json_response.content = '}'
bad_json_response.status_code = requests.codes.ok
# Throw an exception on the first call to requests.post()
mock_post.return_value = None
for side_effect in (requests.RequestException(), OSError(), bad_response):
mock_post.side_effect = side_effect
# We'll fail now because of our error handling
assert obj.send(body="test", attach=attach) is False
# Throw an exception on the second call to requests.post()
for side_effect in (requests.RequestException(), OSError(), bad_response):
mock_post.side_effect = [response, side_effect]
# We'll fail now because of our error handling
assert obj.send(body="test", attach=attach) is False
# Throw an exception on the third call to requests.post()
for side_effect in (requests.RequestException(), OSError(), bad_response):
mock_post.side_effect = [response, response, side_effect]
# We'll fail now because of our error handling
assert obj.send(body="test", attach=attach) is False
# Throw an exception on the forth call to requests.post()
for side_effect in (requests.RequestException(), OSError(), bad_response):
mock_post.side_effect = [response, response, response, side_effect]
# We'll fail now because of our error handling
assert obj.send(body="test", attach=attach) is False
# Test case where we don't get a valid response back
mock_post.side_effect = bad_json_response
# We'll fail because of an invalid json object
assert obj.send(body="test", attach=attach) is False
def test_notify_pushsafer_plugin(mock_post):
"""
API: NotifyPushSafer() Tests
"""
# Disable Throttling to speed testing
plugins.NotifyBase.request_rate_per_sec = 0
# Private Key
privatekey = 'abc123'
# Prepare Mock
mock_post.return_value = requests.Request()
mock_post.return_value.status_code = requests.codes.ok
mock_post.return_value.content = dumps({
'status': 1,
'success': "okay",
})
# Exception should be thrown about the fact no private key was specified
with pytest.raises(TypeError):
plugins.NotifyPushSafer(privatekey=None)
# Multiple Attachment Support
path = os.path.join(TEST_VAR_DIR, 'apprise-test.gif')
attach = AppriseAttachment()
for _ in range(0, 4):
attach.add(path)
obj = plugins.NotifyPushSafer(privatekey=privatekey)
assert obj.notify(
body='body', title='title', notify_type=NotifyType.INFO,
attach=attach) is True
# Test error reading attachment from disk
with mock.patch('io.open', side_effect=OSError):
obj.notify(
body='body', title='title', notify_type=NotifyType.INFO,
attach=attach)
# Test unsupported mime type
attach = AppriseAttachment(path)
attach[0]._mimetype = 'application/octet-stream'
# We gracefully just don't send the attachment in these cases;
# The notify itself will still be successful
mock_post.reset_mock()
assert obj.notify(
body='body', title='title', notify_type=NotifyType.INFO,
attach=attach) is True
# the 'p', 'p2', and 'p3' are the data variables used when including an
# image.
assert 'data' in mock_post.call_args[1]
assert 'p' not in mock_post.call_args[1]['data']
assert 'p2' not in mock_post.call_args[1]['data']
assert 'p3' not in mock_post.call_args[1]['data']
# Invalid file path
path = os.path.join(TEST_VAR_DIR, '/invalid/path/to/an/invalid/file.jpg')
assert obj.notify(
body='body', title='title', notify_type=NotifyType.INFO,
attach=path) is False
def test_pushover_attachments(mock_post, tmpdir):
"""
API: NotifyPushover() Attachment Checks
"""
# Disable Throttling to speed testing
plugins.NotifyBase.request_rate_per_sec = 0
# Initialize some generic (but valid) tokens
user_key = 'u' * 30
api_token = 'a' * 30
# Prepare Mock return object
response = mock.Mock()
response.content = dumps({
"status": 1,
"request": "647d2300-702c-4b38-8b2f-d56326ae460b"
})
response.status_code = requests.codes.ok
mock_post.return_value = response
# prepare our attachment
attach = AppriseAttachment(os.path.join(TEST_VAR_DIR, 'apprise-test.gif'))
# Instantiate our object
obj = Apprise.instantiate('pover://{}@{}/'.format(user_key, api_token))
assert isinstance(obj, plugins.NotifyPushover)
# Test our attachment
assert obj.notify(body="test", attach=attach) is True
# Test multiple attachments
assert attach.add(os.path.join(TEST_VAR_DIR, 'apprise-test.gif'))
assert obj.notify(body="test", attach=attach) is True
image = tmpdir.mkdir("pover_image").join("test.jpg")
image.write('a' * plugins.NotifyPushover.attach_max_size_bytes)
attach = AppriseAttachment.instantiate(str(image))
assert obj.notify(body="test", attach=attach) is True
# Add 1 more byte to the file (putting it over the limit)
image.write('a' * (plugins.NotifyPushover.attach_max_size_bytes + 1))
attach = AppriseAttachment.instantiate(str(image))
assert obj.notify(body="test", attach=attach) is False
# Test case when file is missing
attach = AppriseAttachment.instantiate('file://{}?cache=False'.format(
str(image)))
os.unlink(str(image))
assert obj.notify(body='body', title='title', attach=attach) is False
# Test unsuported files:
image = tmpdir.mkdir("pover_unsupported").join("test.doc")
image.write('a' * 256)
attach = AppriseAttachment.instantiate(str(image))
# Content is silently ignored
assert obj.notify(body="test", attach=attach) is True
# Throw an exception on the second call to requests.post()
mock_post.side_effect = OSError()
# prepare our attachment
attach = AppriseAttachment(os.path.join(TEST_VAR_DIR, 'apprise-test.gif'))
assert obj.notify(body="test", attach=attach) is False
def test_plugin_ntfy_attachments(mock_post):
"""
NotifyNtfy() Attachment Checks
"""
# Disable Throttling to speed testing
plugins.NotifyNtfy.request_rate_per_sec = 0
# Prepare Mock return object
response = mock.Mock()
response.content = GOOD_RESPONSE_TEXT
response.status_code = requests.codes.ok
mock_post.return_value = response
# Test how the notifications work without attachments as they use the
# JSON type posting instead
# Reset our mock object
mock_post.reset_mock()
# Prepare our object
obj = Apprise.instantiate('ntfy://*****:*****@localhost:8080/topic')
# Send a good attachment
assert obj.notify(title="hello", body="world")
assert mock_post.call_count == 1
assert mock_post.call_args_list[0][0][0] == \
'http://*****:*****@localhost:8084/topic')
# Send a good attachment
assert obj.notify(body="test", attach=attach) is True
# Test our call count; includes both image and message
assert mock_post.call_count == 1
assert mock_post.call_args_list[0][0][0] == \
'http://localhost:8084/topic'
assert mock_post.call_args_list[0][1]['params']['message'] == 'test'
assert 'title' not in mock_post.call_args_list[0][1]['params']
assert mock_post.call_args_list[0][1]['params']['filename'] == \
'apprise-test.gif'
# Reset our mock object
mock_post.reset_mock()
# Add another attachment so we drop into the area of the PushBullet code
# that sends remaining attachments (if more detected)
attach.add(os.path.join(TEST_VAR_DIR, 'apprise-test.png'))
# Send our attachments
assert obj.notify(body="test", title="wonderful", attach=attach) is True
# Test our call count
assert mock_post.call_count == 2
# Image + Message sent
assert mock_post.call_args_list[0][0][0] == \
'http://localhost:8084/topic'
assert mock_post.call_args_list[0][1]['params']['message'] == \
'test'
assert mock_post.call_args_list[0][1]['params']['title'] == \
'wonderful'
assert mock_post.call_args_list[0][1]['params']['filename'] == \
'apprise-test.gif'
# Image no 2 (no message)
assert mock_post.call_args_list[1][0][0] == \
'http://localhost:8084/topic'
assert 'message' not in mock_post.call_args_list[1][1]['params']
assert 'title' not in mock_post.call_args_list[1][1]['params']
assert mock_post.call_args_list[1][1]['params']['filename'] == \
'apprise-test.png'
# Reset our mock object
mock_post.reset_mock()
# An invalid attachment will cause a failure
path = os.path.join(TEST_VAR_DIR, '/invalid/path/to/an/invalid/file.jpg')
attach = AppriseAttachment(path)
assert obj.notify(body="test", attach=attach) is False
# Test our call count
assert mock_post.call_count == 0
# prepare our attachment
attach = AppriseAttachment(os.path.join(TEST_VAR_DIR, 'apprise-test.gif'))
# Throw an exception on the first call to requests.post()
mock_post.return_value = None
for side_effect in (requests.RequestException(), OSError()):
mock_post.side_effect = side_effect
# We'll fail now because of our error handling
assert obj.send(body="test", attach=attach) is False
