Skip to content

Migrate unit/test_deserialize.py from unittest from pytest #117

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 3 commits into from
Dec 17, 2018
Merged

Migrate unit/test_deserialize.py from unittest from pytest #117

Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
3e3e701
Migrating unit/test_deserialize.py from unittest from pytest
Dec 13, 2018
ff83528
Added yield and teardown function in apply_fixtures and removed unuse…
Dec 17, 2018
41e6420
Lintering issues, fixed with tox -re autoformat
Dec 17, 2018
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
67 changes: 41 additions & 26 deletions test/unit/test_deserialize.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -13,10 +13,8 @@
"""Unit test suite for aws_encryption_sdk.deserialize"""
import io
import struct
import unittest

import pytest
import six
from cryptography.exceptions import InvalidTag
from mock import MagicMock, patch, sentinel

Expand Down Expand Up @@ -56,8 +54,9 @@ def test_deserialize_tag():
assert parsed_tag == tag


class TestDeserialize(unittest.TestCase):
def setUp(self):
class TestDeserialize(object):
@pytest.fixture(autouse=True)
def apply_fixtures(self):
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Same as #127 : need to run teardown actions.

self.mock_wrapping_algorithm = MagicMock()
self.mock_wrapping_algorithm.algorithm.iv_len = VALUES["iv_len"]

Expand All @@ -80,8 +79,8 @@ def setUp(self):
# Set up mock verifier
self.mock_verifier = MagicMock()
self.mock_verifier.update.return_value = None

def tearDown(self):
yield
# Run tearDown
self.mock_decrypt_patcher.stop()
self.mock_deserialize_ec_patcher.stop()

Expand Down Expand Up @@ -109,29 +108,32 @@ def test_validate_header_invalid(self):
as expected for a valid header.
"""
self.mock_decrypt.side_effect = InvalidTag()
with six.assertRaisesRegex(self, SerializationError, "Header authorization failed"):
with pytest.raises(SerializationError) as excinfo:
aws_encryption_sdk.internal.formatting.deserialize.validate_header(
header=VALUES["deserialized_header_block"],
header_auth=VALUES["deserialized_header_auth_block"],
raw_header=VALUES["header"],
data_key=VALUES["data_key_obj"],
)
excinfo.match("Header authorization failed")

def test_deserialize_header_unknown_object_type(self):
"""Validate that the deserialize_header function behaves
as expected for an unknown object type.
"""
with six.assertRaisesRegex(self, NotSupportedError, "Unsupported type *"):
with pytest.raises(NotSupportedError) as excinfo:
stream = io.BytesIO(VALUES["serialized_header_invalid_object_type"])
aws_encryption_sdk.internal.formatting.deserialize.deserialize_header(stream)
excinfo.match("Unsupported type *")

def test_deserialize_header_unknown_version(self):
"""Validate that the deserialize_header function behaves
as expected for an unknown message version.
"""
with six.assertRaisesRegex(self, NotSupportedError, "Unsupported version *"):
with pytest.raises(NotSupportedError) as excinfo:
stream = io.BytesIO(VALUES["serialized_header_invalid_version"])
aws_encryption_sdk.internal.formatting.deserialize.deserialize_header(stream)
excinfo.match("Unsupported version *")

@patch("aws_encryption_sdk.internal.formatting.deserialize.AlgorithmSuite.get_by_id")
def test_deserialize_header_unsupported_data_encryption_algorithm(self, mock_algorithm_get):
Expand All @@ -141,65 +143,70 @@ def test_deserialize_header_unsupported_data_encryption_algorithm(self, mock_alg
mock_unsupported_algorithm = MagicMock()
mock_unsupported_algorithm.allowed = False
mock_algorithm_get.return_value = mock_unsupported_algorithm
with six.assertRaisesRegex(self, NotSupportedError, "Unsupported algorithm *"):
with pytest.raises(NotSupportedError) as excinfo:
stream = io.BytesIO(VALUES["serialized_header_disallowed_algorithm"])
aws_encryption_sdk.internal.formatting.deserialize.deserialize_header(stream)
excinfo.match("Unsupported algorithm *")

@patch("aws_encryption_sdk.internal.formatting.deserialize.AlgorithmSuite.get_by_id")
def test_deserialize_header_unknown_data_encryption_algorithm(self, mock_algorithm_get):
"""Validate that the deserialize_header function behaves
as expected for an unknown algorithm.
"""
mock_algorithm_get.side_effect = KeyError()
with six.assertRaisesRegex(self, UnknownIdentityError, "Unknown algorithm *"):
with pytest.raises(UnknownIdentityError) as excinfo:
stream = io.BytesIO(VALUES["serialized_header_invalid_algorithm"])
aws_encryption_sdk.internal.formatting.deserialize.deserialize_header(stream)
excinfo.match("Unknown algorithm *")

def test_deserialize_header_unknown_content_type(self):
"""Validate that the deserialize_header function behaves
as expected for an unknown content type.
"""
with six.assertRaisesRegex(self, UnknownIdentityError, "Unknown content type *"):
with pytest.raises(UnknownIdentityError) as excinfo:
stream = io.BytesIO(VALUES["serialized_header_unknown_content_type"])
aws_encryption_sdk.internal.formatting.deserialize.deserialize_header(stream)
excinfo.match("Unknown content type *")

def test_deserialize_header_invalid_reserved_space(self):
"""Validate that the deserialize_header function behaves
as expected for an invalid value in the reserved
space (formerly content AAD).
"""
with six.assertRaisesRegex(
self, SerializationError, "Content AAD length field is currently unused, its value must be always 0"
):
with pytest.raises(SerializationError) as excinfo:
stream = io.BytesIO(VALUES["serialized_header_bad_reserved_space"])
aws_encryption_sdk.internal.formatting.deserialize.deserialize_header(stream)
excinfo.match("Content AAD length field is currently unused, its value must be always 0")

def test_deserialize_header_bad_iv_len(self):
"""Validate that the deserialize_header function behaves
as expected for bad IV length (incompatible with
specified algorithm).
"""
with six.assertRaisesRegex(self, SerializationError, "Specified IV length *"):
with pytest.raises(SerializationError) as excinfo:
stream = io.BytesIO(VALUES["serialized_header_bad_iv_len"])
aws_encryption_sdk.internal.formatting.deserialize.deserialize_header(stream)
excinfo.match("Specified IV length *")

def test_deserialize_header_framed_bad_frame_length(self):
"""Validate that the deserialize_header function behaves
as expected for bad frame length values (greater than
the default maximum).
"""
with six.assertRaisesRegex(self, SerializationError, "Specified frame length larger than allowed maximum: *"):
with pytest.raises(SerializationError) as excinfo:
stream = io.BytesIO(VALUES["serialized_header_bad_frame_len"])
aws_encryption_sdk.internal.formatting.deserialize.deserialize_header(stream)
excinfo.match("Specified frame length larger than allowed maximum: *")

def test_deserialize_header_non_framed_bad_frame_length(self):
"""Validate that the deserialize_header function behaves
as expected for bad frame length values for non-framed
messages (non-zero).
"""
with six.assertRaisesRegex(self, SerializationError, "Non-zero frame length found for non-framed message"):
with pytest.raises(SerializationError) as excinfo:
stream = io.BytesIO(VALUES["serialized_non_framed_header_bad_frame_len"])
aws_encryption_sdk.internal.formatting.deserialize.deserialize_header(stream)
excinfo.match("Non-zero frame length found for non-framed message")

def test_deserialize_header_valid(self):
"""Validate that the deserialize_header function behaves
Expand Down Expand Up @@ -247,10 +254,11 @@ def test_deserialize_body_frame_final_invalid_final_frame_length(self):
behaves as expected for a valid final body frame.
"""
stream = io.BytesIO(VALUES["serialized_final_frame_bad_length"])
with six.assertRaisesRegex(self, SerializationError, "Invalid final frame length: *"):
with pytest.raises(SerializationError) as excinfo:
aws_encryption_sdk.internal.formatting.deserialize.deserialize_frame(
stream=stream, header=VALUES["deserialized_header_frame"]
)
excinfo.match("Invalid final frame length: *")

def test_deserialize_footer_no_verifier(self):
"""Vaidate that the deserialize_footer function behaves
Expand All @@ -275,8 +283,9 @@ def test_deserialize_footer_verifier_no_footer(self):
with no footer.
"""
stream = io.BytesIO(b"")
with six.assertRaisesRegex(self, SerializationError, "No signature found in message"):
with pytest.raises(SerializationError) as excinfo:
aws_encryption_sdk.internal.formatting.deserialize.deserialize_footer(stream, self.mock_verifier)
excinfo.match("No signature found in message")

@patch("aws_encryption_sdk.internal.formatting.deserialize.struct")
def test_unpack_values(self, mock_struct):
Expand Down Expand Up @@ -328,59 +337,65 @@ def test_deserialize_wrapped_key_symmetric(self):
)

def test_deserialize_wrapped_key_symmetric_wrapping_key_mismatch(self):
with six.assertRaisesRegex(self, SerializationError, "Master Key mismatch for wrapped data key"):
with pytest.raises(SerializationError) as excinfo:
aws_encryption_sdk.internal.formatting.deserialize.deserialize_wrapped_key(
wrapping_algorithm=self.mock_wrapping_algorithm,
wrapping_key_id=b"asifuhasjaskldjfhlsakdfj",
wrapped_encrypted_key=VALUES["wrapped_keys"]["structures"]["wrapped_encrypted_data_key_asymmetric"],
)
excinfo.match("Master Key mismatch for wrapped data key")

def test_deserialize_wrapped_key_symmetric_wrapping_algorithm_incomplete_info(self):
with six.assertRaisesRegex(self, SerializationError, "Malformed key info: key info missing data"):
with pytest.raises(SerializationError) as excinfo:
aws_encryption_sdk.internal.formatting.deserialize.deserialize_wrapped_key(
wrapping_algorithm=self.mock_wrapping_algorithm,
wrapping_key_id=VALUES["wrapped_keys"]["raw"]["key_info"],
wrapped_encrypted_key=VALUES["wrapped_keys"]["structures"][
"wrapped_encrypted_data_key_symmetric_incomplete_info"
],
)
excinfo.match("Malformed key info: key info missing data")

def test_deserialize_wrapped_key_symmetric_wrapping_algorithm_iv_len_mismatch(self):
with six.assertRaisesRegex(self, SerializationError, "Wrapping AlgorithmSuite mismatch for wrapped data key"):
with pytest.raises(SerializationError) as excinfo:
aws_encryption_sdk.internal.formatting.deserialize.deserialize_wrapped_key(
wrapping_algorithm=self.mock_wrapping_algorithm,
wrapping_key_id=VALUES["wrapped_keys"]["raw"]["key_info"],
wrapped_encrypted_key=VALUES["wrapped_keys"]["structures"][
"wrapped_encrypted_data_key_symmetric_bad_iv_len"
],
)
excinfo.match("Wrapping AlgorithmSuite mismatch for wrapped data key")

def test_deserialize_wrapped_key_symmetric_wrapping_algorithm_incomplete_iv(self):
with six.assertRaisesRegex(self, SerializationError, "Malformed key info: incomplete iv"):
with pytest.raises(SerializationError) as excinfo:
aws_encryption_sdk.internal.formatting.deserialize.deserialize_wrapped_key(
wrapping_algorithm=self.mock_wrapping_algorithm,
wrapping_key_id=VALUES["wrapped_keys"]["raw"]["key_info"],
wrapped_encrypted_key=VALUES["wrapped_keys"]["structures"][
"wrapped_encrypted_data_key_symmetric_incomplete_iv"
],
)
excinfo.match("Malformed key info: incomplete iv")

def test_deserialize_wrapped_key_symmetric_wrapping_algorithm_incomplete_tag(self):
with six.assertRaisesRegex(self, SerializationError, "Malformed key info: incomplete ciphertext or tag"):
with pytest.raises(SerializationError) as excinfo:
aws_encryption_sdk.internal.formatting.deserialize.deserialize_wrapped_key(
wrapping_algorithm=self.mock_wrapping_algorithm,
wrapping_key_id=VALUES["wrapped_keys"]["raw"]["key_info"],
wrapped_encrypted_key=VALUES["wrapped_keys"]["structures"][
"wrapped_encrypted_data_key_symmetric_incomplete_tag"
],
)
excinfo.match("Malformed key info: incomplete ciphertext or tag")

def test_deserialize_wrapped_key_symmetric_wrapping_algorithm_incomplete_tag2(self):
with six.assertRaisesRegex(self, SerializationError, "Malformed key info: incomplete ciphertext or tag"):
with pytest.raises(SerializationError) as excinfo:
aws_encryption_sdk.internal.formatting.deserialize.deserialize_wrapped_key(
wrapping_algorithm=self.mock_wrapping_algorithm,
wrapping_key_id=VALUES["wrapped_keys"]["raw"]["key_info"],
wrapped_encrypted_key=VALUES["wrapped_keys"]["structures"][
"wrapped_encrypted_data_key_symmetric_incomplete_tag2"
],
)
excinfo.match("Malformed key info: incomplete ciphertext or tag")