googlecloud 0.0.4 → 0.0.6

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

@@ -0,0 +1,60 @@
+# 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

@@ -0,0 +1,98 @@
+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

@@ -0,0 +1,266 @@
+# -*- 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

@@ -0,0 +1,116 @@
+# 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')