gcloud 0.0.7 → 0.1.0

data/packages/gsutil/boto/tests/unit/glacier/test_job.py

@@ -1,60 +0,0 @@
-# Copyright (c) 2013 Amazon.com, Inc. or its affiliates.  All Rights Reserved
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish, dis-
-# tribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the fol-
-# lowing conditions:
-#
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
-# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-#
-from tests.unit import unittest
-import mock
-
-from boto.glacier.job import Job
-from boto.glacier.layer1 import Layer1
-from boto.glacier.response import GlacierResponse
-from boto.glacier.exceptions import TreeHashDoesNotMatchError
-
-
-class TestJob(unittest.TestCase):
-    def setUp(self):
-        self.api = mock.Mock(spec=Layer1)
-        self.vault = mock.Mock()
-        self.vault.layer1 = self.api
-        self.job = Job(self.vault)
-
-    def test_get_job_validate_checksum_success(self):
-        response = GlacierResponse(mock.Mock(), None)
-        response['TreeHash'] = 'tree_hash'
-        self.api.get_job_output.return_value = response
-        with mock.patch('boto.glacier.job.tree_hash_from_str') as t:
-            t.return_value = 'tree_hash'
-            self.job.get_output(byte_range=(1, 1024), validate_checksum=True)
-
-    def test_get_job_validation_fails(self):
-        response = GlacierResponse(mock.Mock(), None)
-        response['TreeHash'] = 'tree_hash'
-        self.api.get_job_output.return_value = response
-        with mock.patch('boto.glacier.job.tree_hash_from_str') as t:
-            t.return_value = 'BAD_TREE_HASH_VALUE'
-            with self.assertRaises(TreeHashDoesNotMatchError):
-                # With validate_checksum set to True, this call fails.
-                self.job.get_output(byte_range=(1, 1024), validate_checksum=True)
-            # With validate_checksum set to False, this call succeeds.
-            self.job.get_output(byte_range=(1, 1024), validate_checksum=False)
-
-
-if __name__ == '__main__':
-    unittest.main()

data/packages/gsutil/boto/tests/unit/glacier/test_layer1.py

@@ -1,98 +0,0 @@
-import json
-import copy
-import tempfile
-
-from tests.unit import AWSMockServiceTestCase
-from boto.glacier.layer1 import Layer1
-
-
-class GlacierLayer1ConnectionBase(AWSMockServiceTestCase):
-    connection_class = Layer1
-
-    def setUp(self):
-        super(GlacierLayer1ConnectionBase, self).setUp()
-        self.json_header = [('Content-Type', 'application/json')]
-        self.vault_name = u'examplevault'
-        self.vault_arn = 'arn:aws:glacier:us-east-1:012345678901:vaults/' + \
-                          self.vault_name
-        self.vault_info = {u'CreationDate': u'2012-03-16T22:22:47.214Z',
-                           u'LastInventoryDate': u'2012-03-21T22:06:51.218Z',
-                           u'NumberOfArchives': 2,
-                           u'SizeInBytes': 12334,
-                           u'VaultARN': self.vault_arn,
-                           u'VaultName': self.vault_name}
-
-
-class GlacierVaultsOperations(GlacierLayer1ConnectionBase):
-
-    def test_create_vault_parameters(self):
-        self.set_http_response(status_code=201)
-        self.service_connection.create_vault(self.vault_name)
-
-    def test_list_vaults(self):
-        content = {u'Marker': None,
-                   u'RequestId': None,
-                   u'VaultList': [self.vault_info]}
-        self.set_http_response(status_code=200, header=self.json_header,
-                               body=json.dumps(content))
-        api_response = self.service_connection.list_vaults()
-        self.assertDictEqual(content, api_response)
-
-    def test_describe_vaults(self):
-        content = copy.copy(self.vault_info)
-        content[u'RequestId'] = None
-        self.set_http_response(status_code=200, header=self.json_header,
-                               body=json.dumps(content))
-        api_response = self.service_connection.describe_vault(self.vault_name)
-        self.assertDictEqual(content, api_response)
-
-    def test_delete_vault(self):
-        self.set_http_response(status_code=204)
-        self.service_connection.delete_vault(self.vault_name)
-
-
-class GlacierJobOperations(GlacierLayer1ConnectionBase):
-
-    def setUp(self):
-        super(GlacierJobOperations, self).setUp()
-        self.job_content = 'abc' * 1024
-
-    def test_initiate_archive_job(self):
-        content = {u'Type': u'archive-retrieval',
-                   u'ArchiveId': u'AAABZpJrTyioDC_HsOmHae8EZp_uBSJr6cnGOLKp_XJCl-Q',
-                   u'Description': u'Test Archive',
-                   u'SNSTopic': u'Topic',
-                   u'JobId': None,
-                   u'Location': None,
-                   u'RequestId': None}
-        self.set_http_response(status_code=202, header=self.json_header,
-                               body=json.dumps(content))
-        api_response = self.service_connection.initiate_job(self.vault_name,
-                                                            self.job_content)
-        self.assertDictEqual(content, api_response)
-
-    def test_get_archive_output(self):
-        header = [('Content-Type', 'application/octet-stream')]
-        self.set_http_response(status_code=200, header=header,
-                               body=self.job_content)
-        response = self.service_connection.get_job_output(self.vault_name,
-                                                         'example-job-id')
-        self.assertEqual(self.job_content, response.read())
-
-
-class GlacierUploadArchiveResets(GlacierLayer1ConnectionBase):
-    def test_upload_archive(self):
-        fake_data = tempfile.NamedTemporaryFile()
-        fake_data.write('foobarbaz')
-        # First seek to a non zero offset.
-        fake_data.seek(2)
-        self.set_http_response(status_code=201)
-        # Simulate reading the request body when we send the request.
-        self.service_connection.connection.request.side_effect = \
-                lambda *args: fake_data.read()
-        self.service_connection.upload_archive('vault_name', fake_data, 'linear_hash',
-                                               'tree_hash')
-        # Verify that we seek back to the original offset after making
-        # a request.  This ensures that if we need to resend the request we're
-        # back at the correct location within the file.
-        self.assertEqual(fake_data.tell(), 2)

data/packages/gsutil/boto/tests/unit/glacier/test_layer2.py

@@ -1,266 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright (c) 2012 Thomas Parslow http://almostobsolete.net/
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish, dis-
-# tribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the fol-
-# lowing conditions:
-#
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
-# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-#
-
-from tests.unit import unittest
-
-from mock import call, Mock, patch, sentinel
-
-from boto.glacier.layer1 import Layer1
-from boto.glacier.layer2 import Layer2
-import boto.glacier.vault
-from boto.glacier.vault import Vault
-from boto.glacier.vault import Job
-
-from StringIO import StringIO
-
-# Some fixture data from the Glacier docs
-FIXTURE_VAULT = {
-  "CreationDate" : "2012-02-20T17:01:45.198Z",
-  "LastInventoryDate" : "2012-03-20T17:03:43.221Z",
-  "NumberOfArchives" : 192,
-  "SizeInBytes" : 78088912,
-  "VaultARN" : "arn:aws:glacier:us-east-1:012345678901:vaults/examplevault",
-  "VaultName" : "examplevault"
-}
-
-FIXTURE_ARCHIVE_JOB = {
-  "Action": "ArchiveRetrieval",
-  "ArchiveId": ("NkbByEejwEggmBz2fTHgJrg0XBoDfjP4q6iu87-TjhqG6eGoOY9Z8i1_AUyUs"
-                "uhPAdTqLHy8pTl5nfCFJmDl2yEZONi5L26Omw12vcs01MNGntHEQL8MBfGlqr"
-                "EXAMPLEArchiveId"),
-  "ArchiveSizeInBytes": 16777216,
-  "Completed": False,
-  "CreationDate": "2012-05-15T17:21:39.339Z",
-  "CompletionDate": "2012-05-15T17:21:43.561Z",
-  "InventorySizeInBytes": None,
-  "JobDescription": "My ArchiveRetrieval Job",
-  "JobId": ("HkF9p6o7yjhFx-K3CGl6fuSm6VzW9T7esGQfco8nUXVYwS0jlb5gq1JZ55yHgt5v"
-            "P54ZShjoQzQVVh7vEXAMPLEjobID"),
-  "SHA256TreeHash": ("beb0fe31a1c7ca8c6c04d574ea906e3f97b31fdca7571defb5b44dc"
-                     "a89b5af60"),
-  "SNSTopic": "arn:aws:sns:us-east-1:012345678901:mytopic",
-  "StatusCode": "InProgress",
-  "StatusMessage": "Operation in progress.",
-  "VaultARN": "arn:aws:glacier:us-east-1:012345678901:vaults/examplevault"
-}
-
-EXAMPLE_PART_LIST_RESULT_PAGE_1 = {
-    "ArchiveDescription": "archive description 1",
-    "CreationDate": "2012-03-20T17:03:43.221Z",
-    "Marker": "MfgsKHVjbQ6EldVl72bn3_n5h2TaGZQUO-Qb3B9j3TITf7WajQ",
-    "MultipartUploadId": "OW2fM5iVylEpFEMM9_HpKowRapC3vn5sSL39_396UW9zLFUWVrnRHaPjUJddQ5OxSHVXjYtrN47NBZ-khxOjyEXAMPLE",
-    "PartSizeInBytes": 4194304,
-    "Parts":
-    [ {
-      "RangeInBytes": "4194304-8388607",
-      "SHA256TreeHash": "01d34dabf7be316472c93b1ef80721f5d4"
-      }],
-    "VaultARN": "arn:aws:glacier:us-east-1:012345678901:vaults/demo1-vault"
-}
-
-# The documentation doesn't say whether the non-Parts fields are defined in
-# future pages, so assume they are not.
-EXAMPLE_PART_LIST_RESULT_PAGE_2 = {
-    "ArchiveDescription": None,
-    "CreationDate": None,
-    "Marker": None,
-    "MultipartUploadId": None,
-    "PartSizeInBytes": None,
-    "Parts":
-    [ {
-      "RangeInBytes": "0-4194303",
-      "SHA256TreeHash": "01d34dabf7be316472c93b1ef80721f5d4"
-      }],
-    "VaultARN": None
-}
-
-EXAMPLE_PART_LIST_COMPLETE = {
-    "ArchiveDescription": "archive description 1",
-    "CreationDate": "2012-03-20T17:03:43.221Z",
-    "Marker": None,
-    "MultipartUploadId": "OW2fM5iVylEpFEMM9_HpKowRapC3vn5sSL39_396UW9zLFUWVrnRHaPjUJddQ5OxSHVXjYtrN47NBZ-khxOjyEXAMPLE",
-    "PartSizeInBytes": 4194304,
-    "Parts":
-    [ {
-      "RangeInBytes": "4194304-8388607",
-      "SHA256TreeHash": "01d34dabf7be316472c93b1ef80721f5d4"
-    }, {
-      "RangeInBytes": "0-4194303",
-      "SHA256TreeHash": "01d34dabf7be316472c93b1ef80721f5d4"
-      }],
-    "VaultARN": "arn:aws:glacier:us-east-1:012345678901:vaults/demo1-vault"
-}
-
-
-class GlacierLayer2Base(unittest.TestCase):
-    def setUp(self):
-        self.mock_layer1 = Mock(spec=Layer1)
-
-
-class TestGlacierLayer2Connection(GlacierLayer2Base):
-    def setUp(self):
-        GlacierLayer2Base.setUp(self)
-        self.layer2 = Layer2(layer1=self.mock_layer1)
-
-    def test_create_vault(self):
-        self.mock_layer1.describe_vault.return_value = FIXTURE_VAULT
-        self.layer2.create_vault("My Vault")
-        self.mock_layer1.create_vault.assert_called_with("My Vault")
-
-    def test_get_vault(self):
-        self.mock_layer1.describe_vault.return_value = FIXTURE_VAULT
-        vault = self.layer2.get_vault("examplevault")
-        self.assertEqual(vault.layer1, self.mock_layer1)
-        self.assertEqual(vault.name, "examplevault")
-        self.assertEqual(vault.size, 78088912)
-        self.assertEqual(vault.number_of_archives, 192)
-
-    def list_vaults(self):
-        self.mock_layer1.list_vaults.return_value = [FIXTURE_VAULT]
-        vaults = self.layer2.list_vaults()
-        self.assertEqual(vaults[0].name, "examplevault")
-
-
-class TestVault(GlacierLayer2Base):
-    def setUp(self):
-        GlacierLayer2Base.setUp(self)
-        self.vault = Vault(self.mock_layer1, FIXTURE_VAULT)
-
-    # TODO: Tests for the other methods of uploading
-
-    def test_create_archive_writer(self):
-        self.mock_layer1.initiate_multipart_upload.return_value = {
-            "UploadId": "UPLOADID"}
-        writer = self.vault.create_archive_writer(description="stuff")
-        self.mock_layer1.initiate_multipart_upload.assert_called_with(
-            "examplevault", self.vault.DefaultPartSize, "stuff")
-        self.assertEqual(writer.vault, self.vault)
-        self.assertEqual(writer.upload_id, "UPLOADID")
-
-    def test_delete_vault(self):
-        self.vault.delete_archive("archive")
-        self.mock_layer1.delete_archive.assert_called_with("examplevault",
-                                                           "archive")
-
-    def test_get_job(self):
-        self.mock_layer1.describe_job.return_value = FIXTURE_ARCHIVE_JOB
-        job = self.vault.get_job(
-            "NkbByEejwEggmBz2fTHgJrg0XBoDfjP4q6iu87-TjhqG6eGoOY9Z8i1_AUyUsuhPA"
-            "dTqLHy8pTl5nfCFJmDl2yEZONi5L26Omw12vcs01MNGntHEQL8MBfGlqrEXAMPLEA"
-            "rchiveId")
-        self.assertEqual(job.action, "ArchiveRetrieval")
-
-    def test_list_jobs(self):
-        self.mock_layer1.list_jobs.return_value = {
-            "JobList": [FIXTURE_ARCHIVE_JOB]}
-        jobs = self.vault.list_jobs(False, "InProgress")
-        self.mock_layer1.list_jobs.assert_called_with("examplevault",
-                                                      False, "InProgress")
-        self.assertEqual(jobs[0].archive_id,
-                         "NkbByEejwEggmBz2fTHgJrg0XBoDfjP4q6iu87-TjhqG6eGoOY9Z"
-                         "8i1_AUyUsuhPAdTqLHy8pTl5nfCFJmDl2yEZONi5L26Omw12vcs0"
-                         "1MNGntHEQL8MBfGlqrEXAMPLEArchiveId")
-
-    def test_list_all_parts_one_page(self):
-        self.mock_layer1.list_parts.return_value = (
-            dict(EXAMPLE_PART_LIST_COMPLETE)) # take a copy
-        parts_result = self.vault.list_all_parts(sentinel.upload_id)
-        expected = [call('examplevault', sentinel.upload_id)]
-        self.assertEquals(expected, self.mock_layer1.list_parts.call_args_list)
-        self.assertEquals(EXAMPLE_PART_LIST_COMPLETE, parts_result)
-
-    def test_list_all_parts_two_pages(self):
-        self.mock_layer1.list_parts.side_effect = [
-            # take copies
-            dict(EXAMPLE_PART_LIST_RESULT_PAGE_1),
-            dict(EXAMPLE_PART_LIST_RESULT_PAGE_2)
-        ]
-        parts_result = self.vault.list_all_parts(sentinel.upload_id)
-        expected = [call('examplevault', sentinel.upload_id),
-                    call('examplevault', sentinel.upload_id,
-                         marker=EXAMPLE_PART_LIST_RESULT_PAGE_1['Marker'])]
-        self.assertEquals(expected, self.mock_layer1.list_parts.call_args_list)
-        self.assertEquals(EXAMPLE_PART_LIST_COMPLETE, parts_result)
-
-    @patch('boto.glacier.vault.resume_file_upload')
-    def test_resume_archive_from_file(self, mock_resume_file_upload):
-        part_size = 4
-        mock_list_parts = Mock()
-        mock_list_parts.return_value = {
-            'PartSizeInBytes': part_size,
-            'Parts': [{
-                'RangeInBytes': '0-3',
-                'SHA256TreeHash': '12',
-                }, {
-                'RangeInBytes': '4-6',
-                'SHA256TreeHash': '34',
-                },
-        ]}
-
-        self.vault.list_all_parts = mock_list_parts
-        self.vault.resume_archive_from_file(
-            sentinel.upload_id, file_obj=sentinel.file_obj)
-        mock_resume_file_upload.assert_called_once_with(
-            self.vault, sentinel.upload_id, part_size, sentinel.file_obj,
-            {0: '12'.decode('hex'), 1: '34'.decode('hex')})
-
-
-class TestJob(GlacierLayer2Base):
-    def setUp(self):
-        GlacierLayer2Base.setUp(self)
-        self.vault = Vault(self.mock_layer1, FIXTURE_VAULT)
-        self.job = Job(self.vault, FIXTURE_ARCHIVE_JOB)
-
-    def test_get_job_output(self):
-        self.mock_layer1.get_job_output.return_value = "TEST_OUTPUT"
-        self.job.get_output((0,100))
-        self.mock_layer1.get_job_output.assert_called_with(
-            "examplevault",
-            "HkF9p6o7yjhFx-K3CGl6fuSm6VzW9T7esGQfco8nUXVYwS0jlb5gq1JZ55yHgt5vP"
-            "54ZShjoQzQVVh7vEXAMPLEjobID", (0,100))
-
-class TestRangeStringParsing(unittest.TestCase):
-    def test_simple_range(self):
-        self.assertEquals(
-            Vault._range_string_to_part_index('0-3', 4), 0)
-
-    def test_range_one_too_big(self):
-        # Off-by-one bug in Amazon's Glacier implementation
-        # See: https://forums.aws.amazon.com/thread.jspa?threadID=106866&tstart=0
-        # Workaround is to assume that if a (start, end] range appears to be
-        # returned then that is what it is.
-        self.assertEquals(
-            Vault._range_string_to_part_index('0-4', 4), 0)
-
-    def test_range_too_big(self):
-        self.assertRaises(
-            AssertionError, Vault._range_string_to_part_index, '0-5', 4)
-
-    def test_range_start_mismatch(self):
-        self.assertRaises(
-            AssertionError, Vault._range_string_to_part_index, '1-3', 4)
-
-    def test_range_end_mismatch(self):
-        # End mismatch is OK, since the last part might be short
-        self.assertEquals(
-            Vault._range_string_to_part_index('0-2', 4), 0)

data/packages/gsutil/boto/tests/unit/glacier/test_utils.py

@@ -1,116 +0,0 @@
-# Copyright (c) 2012 Amazon.com, Inc. or its affiliates.  All Rights Reserved
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish, dis-
-# tribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the fol-
-# lowing conditions:
-#
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
-# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-#
-import time
-import logging
-from hashlib import sha256
-from tests.unit import unittest
-
-from boto.glacier.utils import minimum_part_size, chunk_hashes, tree_hash, \
-        bytes_to_hex
-
-
-class TestPartSizeCalculations(unittest.TestCase):
-    def test_small_values_still_use_default_part_size(self):
-        self.assertEqual(minimum_part_size(1), 4 * 1024 * 1024)
-
-    def test_under_the_maximum_value(self):
-        # If we're under the maximum, we can use 4MB part sizes.
-        self.assertEqual(minimum_part_size(8 * 1024 * 1024),
-                         4 * 1024 * 1024)
-
-    def test_gigabyte_size(self):
-        # If we're over the maximum default part size, we go up to the next
-        # power of two until we find a part size that keeps us under 10,000
-        # parts.
-        self.assertEqual(minimum_part_size(8 * 1024 * 1024 * 10000),
-                         8 * 1024 * 1024)
-
-    def test_terabyte_size(self):
-        # For a 4 TB file we need at least a 512 MB part size.
-        self.assertEqual(minimum_part_size(4 * 1024 * 1024 * 1024 * 1024),
-                         512 * 1024 * 1024)
-
-    def test_file_size_too_large(self):
-        with self.assertRaises(ValueError):
-            minimum_part_size((40000 * 1024 * 1024 * 1024) + 1)
-
-    def test_default_part_size_can_be_specified(self):
-        default_part_size = 2 * 1024 * 1024
-        self.assertEqual(minimum_part_size(8 * 1024 * 1024, default_part_size),
-                         default_part_size)
-
-
-class TestChunking(unittest.TestCase):
-    def test_chunk_hashes_exact(self):
-        chunks = chunk_hashes('a' * (2 * 1024 * 1024))
-        self.assertEqual(len(chunks), 2)
-        self.assertEqual(chunks[0], sha256('a' * 1024 * 1024).digest())
-
-    def test_chunks_with_leftovers(self):
-        bytestring = 'a' * (2 * 1024 * 1024 + 20)
-        chunks = chunk_hashes(bytestring)
-        self.assertEqual(len(chunks), 3)
-        self.assertEqual(chunks[0], sha256('a' * 1024 * 1024).digest())
-        self.assertEqual(chunks[1], sha256('a' * 1024 * 1024).digest())
-        self.assertEqual(chunks[2], sha256('a' * 20).digest())
-
-    def test_less_than_one_chunk(self):
-        chunks = chunk_hashes('aaaa')
-        self.assertEqual(len(chunks), 1)
-        self.assertEqual(chunks[0], sha256('aaaa').digest())
-
-
-class TestTreeHash(unittest.TestCase):
-    # For these tests, a set of reference tree hashes were computed.
-    # This will at least catch any regressions to the tree hash
-    # calculations.
-    def calculate_tree_hash(self, bytestring):
-        start = time.time()
-        calculated = bytes_to_hex(tree_hash(chunk_hashes(bytestring)))
-        end = time.time()
-        logging.debug("Tree hash calc time for length %s: %s",
-                      len(bytestring), end - start)
-        return calculated
-
-    def test_tree_hash_calculations(self):
-        one_meg_bytestring = 'a' * (1 * 1024 * 1024)
-        two_meg_bytestring = 'a' * (2 * 1024 * 1024)
-        four_meg_bytestring = 'a' * (4 * 1024 * 1024)
-        bigger_bytestring = four_meg_bytestring + 'a' * 20
-
-        self.assertEqual(
-            self.calculate_tree_hash(one_meg_bytestring),
-            '9bc1b2a288b26af7257a36277ae3816a7d4f16e89c1e7e77d0a5c48bad62b360')
-        self.assertEqual(
-            self.calculate_tree_hash(two_meg_bytestring),
-            '560c2c9333c719cb00cfdffee3ba293db17f58743cdd1f7e4055373ae6300afa')
-        self.assertEqual(
-            self.calculate_tree_hash(four_meg_bytestring),
-            '9491cb2ed1d4e7cd53215f4017c23ec4ad21d7050a1e6bb636c4f67e8cddb844')
-        self.assertEqual(
-            self.calculate_tree_hash(bigger_bytestring),
-            '12f3cbd6101b981cde074039f6f728071da8879d6f632de8afc7cdf00661b08f')
-
-    def test_empty_tree_hash(self):
-        self.assertEqual(
-            self.calculate_tree_hash(''),
-            'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855')