def test_raises_on_wrong_identifier(self):
"""Fails to initialize on wrong identifier"""
# Arrange
wrong_identifier = '???'
# Act - Assert
with self.assertRaises(NoTagError):
TagHeader(wrong_identifier, 0, 0, TagHeader.Flags(0), 0)
def test_raises_on_unsupported_version(self):
"""Fails to initialize on unsupported version"""
# Arrange
wrong_identifier = 'ID3'
unsupported_version = 2
flags = TagHeader.Flags(0)
# Act - Assert
with self.assertRaises(UnsupportedError):
TagHeader(wrong_identifier, unsupported_version, 0, flags, 0)
def test_raises_on_unsynchronization_tags(self):
"""Rejects tags using unsychronization"""
# Arrange
flags = TagHeader.Flags.Sync
# Act - Assert
with self.assertRaises(UnsupportedError):
TagHeader('ID3', 3, 0, flags, 0)
def test_handles_padding(self):
"""Stops on first padding frame"""
# Arrange
header = FrameHeader("TALB", 9, FrameHeader.Flags.Compression, False)
fields = b'\x00thealbum'
stream = BytesIO(bytes(header) + fields)
frame = PRIV.read(stream)
padding = b'\x00' * 81
tag_header = TagHeader('ID3', 3, 0, TagHeader.Flags(0), 100)
byte_string = bytes(frame) + padding
# Act
frames = Frames.read(BytesIO(byte_string), tag_header)
# Assert
self.assertEqual(len(frames), 1)
self.assertEqual(frames[0].id(), 'TALB')
self.assertEqual(frames[0].text, 'thealbum')
def test_reads_frames_from_file(self):
# Arrange
header_a = FrameHeader("TALB", 9, FrameHeader.Flags.Compression, False)
frame_a = PRIV.read(BytesIO(bytes(header_a) + b'\x00thealbum'))
header_b = FrameHeader("TIT2", 10, FrameHeader.Flags.Encryption, False)
frame_b = PRIV.read(BytesIO(bytes(header_b) + b'\x00theartist'))
tag_header = TagHeader('ID3', 3, 0, TagHeader.Flags(0), 39)
byte_string = bytes(frame_a) + bytes(frame_b)
stream = BytesIO(byte_string)
# Act
frames = Frames.read(stream, tag_header)
# Assert
self.assertEqual(len(frames), 2)
self.assertEqual(frames[0].id(), 'TALB')
self.assertEqual(frames[0].text, 'thealbum')
self.assertEqual(frames[1].id(), 'TIT2')
self.assertEqual(frames[1].text, 'theartist')
def test_serialization(self):
"""Deserializes from bytes and serializes back to bytes"""
# Arrange
byte_string = b'ID3\x03\x01\x60\x00\x00\x00\x0A'
# System under test / Act
header = TagHeader.read(BytesIO(byte_string))
# Act
serialized = bytes(header)
# Assert
self.assertEqual(serialized, byte_string)
def test_initializes(self):
# Arrange
size = 10000
flags = TagHeader.Flags.Experimental
header = TagHeader('ID3', 3, 2, flags, 10000)
frames = Frames([])
# System under test
tag = Tag(header, frames)
self.assertEqual(tag.header(), header)
self.assertEqual(list(tag), frames)
self.assertEqual(len(tag), size + 10)
def test_exposes_fields(self):
"""Exposes all relevant fields"""
# Arrange
identifier = 'ID3'
major, minor = (3, 0)
flags = TagHeader.Flags.Experimental
tag_size = 1000
# System under test
header = TagHeader(identifier, major, minor, flags, tag_size)
# Assert
self.assertEqual(len(header), 10)
self.assertEqual(header.tag_size, 1000)
self.assertEqual(header.major, major)
self.assertEqual(header.minor, minor)
self.assertEqual(header.flags, flags)
def test_serialize_to_bytes(self):
# Arrange
padding = 80
flags = TagHeader.Flags.Experimental
codec = Codec.default()
header = FrameHeader('TALB', 10, 0, False)
frame = TextFrame(header, b'\x00sometext\x00', codec, "sometext")
tag_header = TagHeader('ID3', 3, 2, flags, 20 + padding)
expected_bytes = bytes(tag_header) + bytes(frame) + padding * b'\x00'
# System under test
tag = Tag(tag_header, Frames([frame]))
# Act
byte_string = bytes(tag)
self.assertEqual(byte_string, expected_bytes)
def test_deserializes(self):
"""Deserializes from bytes"""
# Arrange
f = TagHeader.Flags # for brevity's sake
byte_string = b'ID3\x03\x01\x60\x00\x00\x0A\x0A'
flags = f.Experimental | f.Extended
major = 3
minor = 1
expected_tag_size = unsynchsafe(0x0A0A)
# System under test / Act
header = TagHeader.read(BytesIO(byte_string))
# Assert
self.assertEqual(len(header), 10)
self.assertEqual(header.tag_size, expected_tag_size)
self.assertEqual(header.major, major)
self.assertEqual(header.minor, minor)
self.assertEqual(header.flags, flags)
self.assertEqual(bytes(header), byte_string)