# -*- coding: utf-8 -*-

#

# test_phys_pkg.py

#

# Copyright (C) 2013 Steve Canny scanny@cisco.com

#

# This module is part of python-opc and is released under the MIT License:

# http://www.opensource.org/licenses/mit-license.php

"""Test suite for opc.phys_pkg module."""

try:

from io import BytesIO # Python 3

except ImportError:

from StringIO import StringIO as BytesIO

import hashlib

from zipfile import ZIP_DEFLATED, ZipFile

from opc.packuri import PACKAGE_URI, PackURI

from opc.phys_pkg import (

PhysPkgReader, PhysPkgWriter, ZipPkgReader, ZipPkgWriter

)

import pytest

from mock import Mock

from .unitutil import abspath, class_mock

test_pptx_path = abspath('test_files/test.pptx')

@pytest.fixture

def ZipFile_(request):

return class_mock('opc.phys_pkg.ZipFile', request)

class DescribePhysPkgReader(object):

@pytest.fixture

def ZipPkgReader_(self, request):

return class_mock('opc.phys_pkg.ZipPkgReader', request)

def it_constructs_a_pkg_reader_instance(self, ZipPkgReader_):

# mockery ----------------------

pkg_file = Mock(name='pkg_file')

# exercise ---------------------

phys_pkg_reader = PhysPkgReader(pkg_file)

# verify -----------------------

ZipPkgReader_.assert_called_once_with(pkg_file)

assert phys_pkg_reader == ZipPkgReader_.return_value

class DescribePhysPkgWriter(object):

@pytest.fixture

def ZipPkgWriter_(self, request):

return class_mock('opc.phys_pkg.ZipPkgWriter', request)

def it_constructs_a_pkg_writer_instance(self, ZipPkgWriter_):

# mockery ----------------------

pkg_file = Mock(name='pkg_file')

# exercise ---------------------

phys_pkg_writer = PhysPkgWriter(pkg_file)

# verify -----------------------

ZipPkgWriter_.assert_called_once_with(pkg_file)

assert phys_pkg_writer == ZipPkgWriter_.return_value

class DescribeZipPkgReader(object):

@pytest.fixture(scope='class')

def phys_reader(self, request):

phys_reader = ZipPkgReader(test_pptx_path)

request.addfinalizer(phys_reader.close)

return phys_reader

def it_opens_pkg_file_zip_on_construction(self, ZipFile_):

pkg_file = Mock(name='pkg_file')

ZipPkgReader(pkg_file)

ZipFile_.assert_called_once_with(pkg_file, 'r')

def it_can_be_closed(self, ZipFile_):

# mockery ----------------------

zipf = ZipFile_.return_value

zip_pkg_reader = ZipPkgReader(None)

# exercise ---------------------

zip_pkg_reader.close()

# verify -----------------------

zipf.close.assert_called_once_with()

def it_can_retrieve_the_blob_for_a_pack_uri(self, phys_reader):

pack_uri = PackURI('/ppt/presentation.xml')

blob = phys_reader.blob_for(pack_uri)

sha1 = hashlib.sha1(blob).hexdigest()

assert sha1 == 'efa7bee0ac72464903a67a6744c1169035d52a54'

def it_has_the_content_types_xml(self, phys_reader):

sha1 = hashlib.sha1(phys_reader.content_types_xml).hexdigest()

assert sha1 == '9604a4fb3bf9626f5ad59a4e82029b3a501f106a'

def it_can_retrieve_rels_xml_for_source_uri(self, phys_reader):

rels_xml = phys_reader.rels_xml_for(PACKAGE_URI)

sha1 = hashlib.sha1(rels_xml).hexdigest()

assert sha1 == 'e31451d4bbe7d24adbe21454b8e9fdae92f50de5'

def it_returns_none_when_part_has_no_rels_xml(self, phys_reader):

partname = PackURI('/ppt/viewProps.xml')

rels_xml = phys_reader.rels_xml_for(partname)

assert rels_xml is None

class DescribeZipPkgWriter(object):

@pytest.fixture

def pkg_file(self, request):

pkg_file = BytesIO()

request.addfinalizer(pkg_file.close)

return pkg_file

def it_opens_pkg_file_zip_on_construction(self, ZipFile_):

pkg_file = Mock(name='pkg_file')

ZipPkgWriter(pkg_file)

ZipFile_.assert_called_once_with(pkg_file, 'w',

compression=ZIP_DEFLATED)

def it_can_be_closed(self, ZipFile_):

# mockery ----------------------

zipf = ZipFile_.return_value

zip_pkg_writer = ZipPkgWriter(None)

# exercise ---------------------

zip_pkg_writer.close()

# verify -----------------------

zipf.close.assert_called_once_with()

def it_can_write_a_blob(self, pkg_file):

# setup ------------------------

pack_uri = PackURI('/part/name.xml')

blob = '<BlobbityFooBlob/>'.encode('utf-8')

# exercise ---------------------

pkg_writer = PhysPkgWriter(pkg_file)

pkg_writer.write(pack_uri, blob)

pkg_writer.close()

# verify -----------------------

written_blob_sha1 = hashlib.sha1(blob).hexdigest()

zipf = ZipFile(pkg_file, 'r')

retrieved_blob = zipf.read(pack_uri.membername)

zipf.close()

retrieved_blob_sha1 = hashlib.sha1(retrieved_blob).hexdigest()

assert retrieved_blob_sha1 == written_blob_sha1