def test_unit_size(self):
        MEBIBYTE = 1024 * 1024
        GIBIBYTE = MEBIBYTE * 1024

        file_size_map = {
            1:
                1024 * 1024,
            4 * MEBIBYTE:
                1024 * 1024,
            8 * MEBIBYTE:
                1024 * 1024,
            129740800:
                4096 * 1024,
            16 * GIBIBYTE:
                65536 * 1024,
            65 * GIBIBYTE:
                65536 * 1024
        }

        for file_size, expected in file_size_map.items():
            actual = compute_resumable_upload_unit_size(file_size)
            self.assertEqual(
                actual,
                expected,
                "unit_size for {} - {}, expected {}".format(
                    file_size, actual, expected)
            )
    def test_unit_size_hashing(self):
        """Test that hasher returns units hashes as well"""
        MEBIBYTE = 2 ** 20
        # 4 MiB and 1 byte for leftover testing
        DATA_SIZE = 4 * MEBIBYTE + 1

        data = b'\0' * DATA_SIZE
        fd = io.BytesIO(data)

        unit_size = compute_resumable_upload_unit_size(DATA_SIZE)
        self.assertEqual(unit_size, MEBIBYTE)

        result = compute_hash_info(fd, unit_size)

        self.assertEqual(
            result.file,
            '95e441ca65cd41fa01b2a71799e79fd6'
            '0db59ed34f13af32a91e85f90378676c'
        )

        self.assertNotEqual(result.units, [])

        print(math.ceil(1.0 * DATA_SIZE/unit_size))
        self.assertEqual(
            len(result.units),
            math.ceil(1.0 * DATA_SIZE / unit_size)
        )

        MIB_ZERO_HASH = ('30e14955ebf1352266dc2ff8067e6810'
                         '4607e750abb9d3b36582b8af909fcb58')

        ZERO_BYTE_HASH = ('6e340b9cffb37a989ca544e6bb780a2c'
                          '78901d3fb33738768511a30617afa01d')

        for i in range(4):
            self.assertEqual(result.units[i], MIB_ZERO_HASH)

        self.assertEqual(result.units[4], ZERO_BYTE_HASH)