TEST_FIXTURE(page_blob_test_base, page_blob_sequence_number)
{
m_blob.properties().set_content_language(U("tr,en"));
m_blob.create(512, 0, azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
CHECK_EQUAL(512, m_blob.properties().size());
CHECK_EQUAL(0, m_blob.properties().page_blob_sequence_number());
m_blob.properties().set_content_language(U("en"));
m_blob.set_sequence_number(azure::storage::sequence_number::update(5), azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
CHECK_EQUAL(5, m_blob.properties().page_blob_sequence_number());
m_blob.set_sequence_number(azure::storage::sequence_number::maximum(7), azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
CHECK_EQUAL(7, m_blob.properties().page_blob_sequence_number());
m_blob.set_sequence_number(azure::storage::sequence_number::maximum(3), azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
CHECK_EQUAL(7, m_blob.properties().page_blob_sequence_number());
m_blob.set_sequence_number(azure::storage::sequence_number::increment(), azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
CHECK_EQUAL(8, m_blob.properties().page_blob_sequence_number());
CHECK_UTF8_EQUAL(U("en"), m_blob.properties().content_language());
m_blob.download_attributes(azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
CHECK_UTF8_EQUAL(U("tr,en"), m_blob.properties().content_language());
CHECK_EQUAL(8, m_blob.properties().page_blob_sequence_number());
m_blob.clear_pages(0, 512, azure::storage::access_condition::generate_if_sequence_number_equal_condition(8), azure::storage::blob_request_options(), m_context);
m_blob.clear_pages(0, 512, azure::storage::access_condition::generate_if_sequence_number_less_than_or_equal_condition(8), azure::storage::blob_request_options(), m_context);
m_blob.clear_pages(0, 512, azure::storage::access_condition::generate_if_sequence_number_less_than_or_equal_condition(9), azure::storage::blob_request_options(), m_context);
m_blob.clear_pages(0, 512, azure::storage::access_condition::generate_if_sequence_number_less_than_condition(9), azure::storage::blob_request_options(), m_context);
CHECK_THROW(m_blob.clear_pages(0, 512, azure::storage::access_condition::generate_if_sequence_number_equal_condition(7), azure::storage::blob_request_options(), m_context), azure::storage::storage_exception);
CHECK_THROW(m_blob.clear_pages(0, 512, azure::storage::access_condition::generate_if_sequence_number_less_than_or_equal_condition(7), azure::storage::blob_request_options(), m_context), azure::storage::storage_exception);
CHECK_THROW(m_blob.clear_pages(0, 512, azure::storage::access_condition::generate_if_sequence_number_less_than_or_equal_condition(7), azure::storage::blob_request_options(), m_context), azure::storage::storage_exception);
CHECK_THROW(m_blob.clear_pages(0, 512, azure::storage::access_condition::generate_if_sequence_number_less_than_condition(7), azure::storage::blob_request_options(), m_context), azure::storage::storage_exception);
}
void blob_service_test_base::check_blob_copy_state_equal(const azure::storage::copy_state& expected, const azure::storage::copy_state& actual)
{
CHECK(expected.status() == actual.status());
CHECK_EQUAL(expected.bytes_copied(), actual.bytes_copied());
CHECK_EQUAL(expected.total_bytes(), actual.total_bytes());
CHECK(expected.completion_time() == actual.completion_time());
CHECK_UTF8_EQUAL(expected.copy_id(), actual.copy_id());
CHECK_UTF8_EQUAL(expected.status_description(), actual.status_description());
CHECK_UTF8_EQUAL(expected.source().to_string(), actual.source().to_string());
}
void blob_service_test_base::check_blob_equal(const azure::storage::cloud_blob& expected, const azure::storage::cloud_blob& actual)
{
CHECK(expected.type() == actual.type());
CHECK_UTF8_EQUAL(expected.uri().primary_uri().to_string(), actual.uri().primary_uri().to_string());
CHECK_UTF8_EQUAL(expected.uri().secondary_uri().to_string(), actual.uri().secondary_uri().to_string());
CHECK_EQUAL(expected.is_snapshot(), actual.is_snapshot());
CHECK(expected.snapshot_time() == actual.snapshot_time());
CHECK_UTF8_EQUAL(expected.snapshot_qualified_uri().primary_uri().to_string(), actual.snapshot_qualified_uri().primary_uri().to_string());
CHECK_UTF8_EQUAL(expected.snapshot_qualified_uri().secondary_uri().to_string(), actual.snapshot_qualified_uri().secondary_uri().to_string());
check_blob_copy_state_equal(expected.copy_state(), actual.copy_state());
check_blob_properties_equal(expected.properties(), actual.properties());
}
TEST_FIXTURE(append_blob_test_base, append_blob_create_with_metadata)
{
m_blob.metadata()[U("key1")] = U("value1");
m_blob.metadata()[U("key2")] = U("value2");
m_blob.create_or_replace(azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
auto same_blob = m_container.get_append_blob_reference(m_blob.name());
CHECK(same_blob.metadata().empty());
same_blob.download_attributes(azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
CHECK_EQUAL(2U, same_blob.metadata().size());
CHECK_UTF8_EQUAL(U("value1"), same_blob.metadata()[U("key1")]);
CHECK_UTF8_EQUAL(U("value2"), same_blob.metadata()[U("key2")]);
}
TEST_FIXTURE(file_directory_test_base, directory_get_parent_directory_ref)
{
m_directory.create_if_not_exists(azure::storage::file_access_condition(), azure::storage::file_request_options(), m_context);
auto directory_name = _XPLATSTR("directory");
auto directory = m_directory.get_subdirectory_reference(directory_name);
auto parent_directory = directory.get_parent_directory_reference();
CHECK_UTF8_EQUAL(directory_name, directory.name());
CHECK(directory.get_parent_share_reference().is_valid());
check_equal(m_share, directory.get_parent_share_reference());
check_equal(m_directory, parent_directory);
CHECK(!directory.uri().primary_uri().is_empty());
CHECK(directory.metadata().empty());
CHECK(directory.properties().etag().empty());
CHECK(!directory.properties().last_modified().is_initialized());
CHECK(!parent_directory.uri().primary_uri().is_empty());
CHECK(parent_directory.metadata().empty());
CHECK(parent_directory.properties().etag().empty());
CHECK(!parent_directory.properties().last_modified().is_initialized());
// Check if get_root_directory_refence works for root directory's sub-directory.
auto root_direcotry = m_share.get_root_directory_reference();
directory_name = _XPLATSTR("directory");
directory = root_direcotry.get_subdirectory_reference(directory_name);
parent_directory = directory.get_parent_directory_reference();
CHECK_UTF8_EQUAL(directory_name, directory.name());
CHECK(directory.get_parent_share_reference().is_valid());
check_equal(m_share, directory.get_parent_share_reference());
check_equal(root_direcotry, parent_directory);
CHECK(!directory.uri().primary_uri().is_empty());
CHECK(directory.metadata().empty());
CHECK(directory.properties().etag().empty());
CHECK(!directory.properties().last_modified().is_initialized());
CHECK(!parent_directory.uri().primary_uri().is_empty());
CHECK(parent_directory.metadata().empty());
CHECK(parent_directory.properties().etag().empty());
CHECK(!parent_directory.properties().last_modified().is_initialized());
// Check if get_root_directory_refence works for root directory.
root_direcotry = m_share.get_root_directory_reference();
directory = root_direcotry.get_parent_directory_reference();
check_equal(root_direcotry, parent_directory);
}
TEST_FIXTURE(page_blob_test_base, page_blob_resize)
{
m_blob.properties().set_content_language(U("tr,en"));
m_blob.create(1024, 0, azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
CHECK_EQUAL(1024, m_blob.properties().size());
m_blob.properties().set_content_language(U("en"));
m_blob.resize(2048, azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
CHECK_EQUAL(2048, m_blob.properties().size());
CHECK_UTF8_EQUAL(U("en"), m_blob.properties().content_language());
m_blob.download_attributes(azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
CHECK_UTF8_EQUAL(U("tr,en"), m_blob.properties().content_language());
}
TEST_FIXTURE(append_blob_test_base, append_blob_snapshot_metadata)
{
m_blob.metadata()[U("key1")] = U("value1");
m_blob.metadata()[U("key2")] = U("value2");
m_blob.create_or_replace(azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
auto snapshot1 = m_blob.create_snapshot(azure::storage::cloud_metadata(), azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
CHECK_EQUAL(2U, snapshot1.metadata().size());
CHECK_UTF8_EQUAL(U("value1"), snapshot1.metadata()[U("key1")]);
CHECK_UTF8_EQUAL(U("value2"), snapshot1.metadata()[U("key2")]);
azure::storage::cloud_append_blob snapshot1_clone(snapshot1.uri(), snapshot1.snapshot_time(), snapshot1.service_client().credentials());
CHECK(snapshot1_clone.metadata().empty());
snapshot1_clone.download_attributes(azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
CHECK_EQUAL(2U, snapshot1_clone.metadata().size());
CHECK_UTF8_EQUAL(U("value1"), snapshot1_clone.metadata()[U("key1")]);
CHECK_UTF8_EQUAL(U("value2"), snapshot1_clone.metadata()[U("key2")]);
azure::storage::cloud_metadata snapshot_metadata;
snapshot_metadata[U("key3")] = U("value1");
snapshot_metadata[U("key4")] = U("value2");
auto snapshot2 = m_blob.create_snapshot(snapshot_metadata, azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
CHECK_EQUAL(2U, snapshot1.metadata().size());
CHECK_UTF8_EQUAL(U("value1"), snapshot2.metadata()[U("key3")]);
CHECK_UTF8_EQUAL(U("value2"), snapshot2.metadata()[U("key4")]);
azure::storage::cloud_append_blob snapshot2_clone(snapshot2.uri(), snapshot2.snapshot_time(), snapshot2.service_client().credentials());
CHECK(snapshot2_clone.metadata().empty());
snapshot2_clone.download_attributes(azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
CHECK_EQUAL(2U, snapshot2_clone.metadata().size());
CHECK_UTF8_EQUAL(U("value1"), snapshot2_clone.metadata()[U("key3")]);
CHECK_UTF8_EQUAL(U("value2"), snapshot2_clone.metadata()[U("key4")]);
}
TEST_FIXTURE(file_directory_test_base, directory_get_file_ref)
{
m_directory.create_if_not_exists(azure::storage::file_access_condition(), azure::storage::file_request_options(), m_context);
auto file_name = _XPLATSTR("file");
auto file = m_directory.get_file_reference(file_name);
CHECK_UTF8_EQUAL(file_name, file.name());
CHECK(file.get_parent_share_reference().is_valid());
check_equal(m_share, file.get_parent_share_reference());
check_equal(m_directory, file.get_parent_directory_reference());
CHECK(!file.uri().primary_uri().is_empty());
CHECK(file.metadata().empty());
CHECK(file.properties().etag().empty());
CHECK(file.properties().cache_control().empty());
CHECK(file.properties().content_disposition().empty());
CHECK(file.properties().content_encoding().empty());
CHECK(file.properties().content_language().empty());
CHECK(file.properties().content_md5().empty());
CHECK(file.properties().content_type().empty());
CHECK(file.properties().type().empty());
CHECK_EQUAL(file.properties().length(), 0);
CHECK(!file.properties().last_modified().is_initialized());
// In root directory
file = m_share.get_root_directory_reference().get_file_reference(file_name);
CHECK_UTF8_EQUAL(file_name, file.name());
CHECK(file.get_parent_share_reference().is_valid());
check_equal(m_share, file.get_parent_share_reference());
check_equal(m_share.get_root_directory_reference(), file.get_parent_directory_reference());
CHECK(!file.uri().primary_uri().is_empty());
CHECK(file.metadata().empty());
CHECK(file.properties().etag().empty());
CHECK(file.properties().cache_control().empty());
CHECK(file.properties().content_disposition().empty());
CHECK(file.properties().content_encoding().empty());
CHECK(file.properties().content_language().empty());
CHECK(file.properties().content_md5().empty());
CHECK(file.properties().content_type().empty());
CHECK(file.properties().type().empty());
CHECK_EQUAL(file.properties().length(), 0);
CHECK(!file.properties().last_modified().is_initialized());
}
void blob_service_test_base_with_objects_to_delete::check_container_list(const std::vector<azure::storage::cloud_blob_container>& list, const utility::string_t& prefix, bool check_found)
{
auto container_list_sorted = std::is_sorted(list.cbegin(), list.cend(), [](const azure::storage::cloud_blob_container& a, const azure::storage::cloud_blob_container& b)
{
return a.name() < b.name();
});
CHECK(container_list_sorted);
std::vector<azure::storage::cloud_blob_container> containers(m_containers_to_delete);
for (auto list_iter = list.begin(); list_iter != list.end(); ++list_iter)
{
bool found = false;
for (auto iter = containers.begin(); iter != containers.end(); ++iter)
{
if (iter->name() == list_iter->name())
{
auto index_str = list_iter->metadata().find(U("index"));
CHECK(index_str != list_iter->metadata().end());
CHECK_UTF8_EQUAL(iter->name(), prefix + index_str->second);
containers.erase(iter);
found = true;
break;
}
}
if (check_found)
{
CHECK(found);
}
}
CHECK(containers.empty());
}
void check_service_properties(const azure::storage::service_properties& a, const azure::storage::service_properties& b)
{
CHECK_UTF8_EQUAL(a.logging().version(), b.logging().version());
CHECK_EQUAL(a.logging().delete_enabled(), b.logging().delete_enabled());
CHECK_EQUAL(a.logging().read_enabled(), b.logging().read_enabled());
CHECK_EQUAL(a.logging().write_enabled(), b.logging().write_enabled());
CHECK_EQUAL(a.logging().retention_policy_enabled(), b.logging().retention_policy_enabled());
CHECK_EQUAL(a.logging().retention_days(), b.logging().retention_days());
CHECK_UTF8_EQUAL(a.hour_metrics().version(), b.hour_metrics().version());
CHECK_EQUAL(a.hour_metrics().enabled(), b.hour_metrics().enabled());
if (a.hour_metrics().enabled())
{
CHECK_EQUAL(a.hour_metrics().include_apis(), b.hour_metrics().include_apis());
}
CHECK_EQUAL(a.hour_metrics().retention_policy_enabled(), b.hour_metrics().retention_policy_enabled());
CHECK_EQUAL(a.hour_metrics().retention_days(), b.hour_metrics().retention_days());
CHECK_UTF8_EQUAL(a.minute_metrics().version(), b.minute_metrics().version());
CHECK_EQUAL(a.minute_metrics().enabled(), b.minute_metrics().enabled());
if (a.minute_metrics().enabled())
{
CHECK_EQUAL(a.minute_metrics().include_apis(), b.minute_metrics().include_apis());
}
CHECK_EQUAL(a.minute_metrics().retention_policy_enabled(), b.minute_metrics().retention_policy_enabled());
CHECK_EQUAL(a.minute_metrics().retention_days(), b.minute_metrics().retention_days());
auto a_iter = a.cors().cbegin();
auto b_iter = b.cors().cbegin();
for (; a_iter != a.cors().cend() && b_iter != b.cors().cend(); ++a_iter, ++b_iter)
{
CHECK(std::equal(a_iter->allowed_headers().cbegin(), a_iter->allowed_headers().cend(), b_iter->allowed_headers().cbegin()));
CHECK(std::equal(a_iter->allowed_methods().cbegin(), a_iter->allowed_methods().cend(), b_iter->allowed_methods().cbegin()));
CHECK(std::equal(a_iter->allowed_origins().cbegin(), a_iter->allowed_origins().cend(), b_iter->allowed_origins().cbegin()));
CHECK(std::equal(a_iter->exposed_headers().cbegin(), a_iter->exposed_headers().cend(), b_iter->exposed_headers().cbegin()));
CHECK_EQUAL(a_iter->max_age().count(), b_iter->max_age().count());
}
CHECK(a_iter == a.cors().cend());
CHECK(b_iter == b.cors().cend());
// TODO: Is the following check valid?
//CHECK_UTF8_EQUAL(a.default_service_version(), b.default_service_version());
}
TEST_FIXTURE(file_directory_test_base, directory_metadata)
{
auto value1 = this->get_random_string();
auto value2 = this->get_random_string();
auto value3 = this->get_random_string();
auto value4 = this->get_random_string();
// create 2 pairs
m_directory.metadata()[_XPLATSTR("key1")] = value1;
m_directory.metadata()[_XPLATSTR("key2")] = value2;
m_directory.create_if_not_exists(azure::storage::file_access_condition(), azure::storage::file_request_options(), m_context);
CHECK_UTF8_EQUAL(m_directory.metadata()[_XPLATSTR("key1")], value1);
CHECK_UTF8_EQUAL(m_directory.metadata()[_XPLATSTR("key2")], value2);
auto same_directory = m_directory.get_parent_share_reference().get_directory_reference(m_directory.name());
CHECK(same_directory.metadata().empty());
same_directory.download_attributes();
CHECK_EQUAL(2U, same_directory.metadata().size());
CHECK_UTF8_EQUAL(value1, same_directory.metadata()[_XPLATSTR("key1")]);
CHECK_UTF8_EQUAL(value2, same_directory.metadata()[_XPLATSTR("key2")]);
// add 1 pair
m_directory.metadata()[_XPLATSTR("key3")] = value3;
m_directory.upload_metadata(azure::storage::file_access_condition(), azure::storage::file_request_options(), m_context);
same_directory.metadata().clear();
CHECK(same_directory.metadata().empty());
same_directory.download_attributes();
CHECK_EQUAL(3U, same_directory.metadata().size());
CHECK_UTF8_EQUAL(value1, same_directory.metadata()[_XPLATSTR("key1")]);
CHECK_UTF8_EQUAL(value2, same_directory.metadata()[_XPLATSTR("key2")]);
CHECK_UTF8_EQUAL(value3, same_directory.metadata()[_XPLATSTR("key3")]);
// overwrite with 1 pair
m_directory.metadata().clear();
m_directory.metadata()[_XPLATSTR("key4")] = value4;
m_directory.upload_metadata(azure::storage::file_access_condition(), azure::storage::file_request_options(), m_context);
same_directory.metadata().clear();
CHECK(same_directory.metadata().empty());
same_directory.download_attributes();
CHECK_EQUAL(1U, same_directory.metadata().size());
CHECK_UTF8_EQUAL(value4, same_directory.metadata()[_XPLATSTR("key4")]);
// clear metadata
m_directory.metadata().clear();
m_directory.upload_metadata(azure::storage::file_access_condition(), azure::storage::file_request_options(), m_context);
same_directory.metadata().clear();
CHECK(same_directory.metadata().empty());
same_directory.download_attributes();
CHECK_EQUAL(0U, same_directory.metadata().size());
}
void blob_service_test_base::check_blob_properties_equal(const azure::storage::cloud_blob_properties& expected, const azure::storage::cloud_blob_properties& actual)
{
CHECK_UTF8_EQUAL(expected.etag(), actual.etag());
CHECK(expected.last_modified() == actual.last_modified());
CHECK_UTF8_EQUAL(expected.cache_control(), actual.cache_control());
CHECK_UTF8_EQUAL(expected.content_disposition(), actual.content_disposition());
CHECK_UTF8_EQUAL(expected.content_encoding(), actual.content_encoding());
CHECK_UTF8_EQUAL(expected.content_language(), actual.content_language());
CHECK_UTF8_EQUAL(expected.content_md5(), actual.content_md5());
CHECK_UTF8_EQUAL(expected.content_type(), actual.content_type());
}
TEST_FIXTURE(container_test_base, container_get_reference)
{
auto block_blob = m_container.get_block_blob_reference(_XPLATSTR("blob1"));
CHECK_UTF8_EQUAL(m_container.uri().primary_uri().to_string(), block_blob.container().uri().primary_uri().to_string());
CHECK_UTF8_EQUAL(m_container.uri().secondary_uri().to_string(), block_blob.container().uri().secondary_uri().to_string());
auto page_blob = m_container.get_page_blob_reference(_XPLATSTR("blob2"));
CHECK_UTF8_EQUAL(m_container.uri().primary_uri().to_string(), page_blob.container().uri().primary_uri().to_string());
CHECK_UTF8_EQUAL(m_container.uri().secondary_uri().to_string(), page_blob.container().uri().secondary_uri().to_string());
auto append_blob = m_container.get_append_blob_reference(_XPLATSTR("blob3"));
CHECK_UTF8_EQUAL(m_container.uri().primary_uri().to_string(), append_blob.container().uri().primary_uri().to_string());
CHECK_UTF8_EQUAL(m_container.uri().secondary_uri().to_string(), append_blob.container().uri().secondary_uri().to_string());
auto directory = m_container.get_directory_reference(_XPLATSTR("dir"));
CHECK_UTF8_EQUAL(m_container.uri().primary_uri().to_string(), directory.container().uri().primary_uri().to_string());
CHECK_UTF8_EQUAL(m_container.uri().secondary_uri().to_string(), directory.container().uri().secondary_uri().to_string());
}
TEST_FIXTURE(page_blob_test_base, page_blob_file_upload)
{
azure::storage::blob_request_options options;
options.set_store_blob_content_md5(true);
utility::string_t md5_header;
m_context.set_sending_request([&md5_header] (web::http::http_request& request, azure::storage::operation_context)
{
if (!request.headers().match(U("x-ms-blob-content-md5"), md5_header))
{
md5_header.clear();
}
});
temp_file invalid_file(1000);
CHECK_THROW(m_blob.upload_from_file(invalid_file.path(), 0, azure::storage::access_condition(), options, m_context), azure::storage::storage_exception);
temp_file file(1024);
m_blob.upload_from_file(file.path(), 0, azure::storage::access_condition(), options, m_context);
CHECK_UTF8_EQUAL(file.content_md5(), md5_header);
m_context.set_sending_request(std::function<void(web::http::http_request &, azure::storage::operation_context)>());
temp_file file2(0);
m_blob.download_to_file(file2.path(), azure::storage::access_condition(), options, m_context);
concurrency::streams::container_buffer<std::vector<uint8_t>> original_file_buffer;
auto original_file = concurrency::streams::file_stream<uint8_t>::open_istream(file.path()).get();
original_file.read_to_end(original_file_buffer).wait();
original_file.close().wait();
concurrency::streams::container_buffer<std::vector<uint8_t>> downloaded_file_buffer;
auto downloaded_file = concurrency::streams::file_stream<uint8_t>::open_istream(file2.path()).get();
downloaded_file.read_to_end(downloaded_file_buffer).wait();
downloaded_file.close().wait();
CHECK_EQUAL(original_file_buffer.collection().size(), downloaded_file_buffer.collection().size());
CHECK_ARRAY_EQUAL(original_file_buffer.collection(), downloaded_file_buffer.collection(), (int)downloaded_file_buffer.collection().size());
m_blob.properties().set_content_md5(dummy_md5);
m_blob.upload_properties();
options.set_retry_policy(azure::storage::no_retry_policy());
CHECK_THROW(m_blob.download_to_file(file2.path(), azure::storage::access_condition(), options, m_context), azure::storage::storage_exception);
}
TEST_FIXTURE(block_blob_test_base, storage_extended_error_verify_xml_with_details)
{
const size_t buffer_size = 8 * 1024;
std::vector<uint8_t> buffer;
buffer.resize(buffer_size);
auto md5 = fill_buffer_and_get_md5(buffer);
auto stream = concurrency::streams::bytestream::open_istream(buffer);
m_blob.upload_block(get_block_id(0), stream, md5);
try
{
stream.seek(1024, std::ios_base::beg);
m_blob.upload_block(get_block_id(1), stream, md5);
CHECK(false);
}
catch (azure::storage::storage_exception& ex)
{
CHECK_UTF8_EQUAL(U("Md5Mismatch"), ex.result().extended_error().code());
CHECK(!ex.result().extended_error().message().empty());
CHECK(ex.result().extended_error().details().size() > 0);
}
}
TEST_FIXTURE(container_test_base, container_metadata)
{
// Create with 2 pairs
m_container.metadata()[_XPLATSTR("key1")] = _XPLATSTR("value1");
m_container.metadata()[_XPLATSTR("key2")] = _XPLATSTR("value2");
m_container.create(azure::storage::blob_container_public_access_type::off, azure::storage::blob_request_options(), m_context);
check_container_no_stale_property(m_container);
auto same_container = m_client.get_container_reference(m_container.name());
CHECK(same_container.metadata().empty());
same_container.download_attributes(azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
CHECK_EQUAL(2U, same_container.metadata().size());
CHECK_UTF8_EQUAL(_XPLATSTR("value1"), same_container.metadata()[_XPLATSTR("key1")]);
CHECK_UTF8_EQUAL(_XPLATSTR("value2"), same_container.metadata()[_XPLATSTR("key2")]);
// Add 1 pair
same_container.metadata()[_XPLATSTR("key3")] = _XPLATSTR("value3");
same_container.upload_metadata(azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
m_container.download_attributes(azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
CHECK_EQUAL(3U, same_container.metadata().size());
CHECK_UTF8_EQUAL(_XPLATSTR("value1"), m_container.metadata()[_XPLATSTR("key1")]);
CHECK_UTF8_EQUAL(_XPLATSTR("value2"), m_container.metadata()[_XPLATSTR("key2")]);
CHECK_UTF8_EQUAL(_XPLATSTR("value3"), m_container.metadata()[_XPLATSTR("key3")]);
// Overwrite with 1 pair
m_container.metadata().clear();
m_container.metadata()[_XPLATSTR("key4")] = _XPLATSTR("value4");
m_container.upload_metadata(azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
same_container.download_attributes(azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
CHECK_EQUAL(1U, same_container.metadata().size());
CHECK_UTF8_EQUAL(_XPLATSTR("value4"), same_container.metadata()[_XPLATSTR("key4")]);
// Clear all pairs
same_container.metadata().clear();
same_container.upload_metadata(azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
m_container.download_attributes(azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
CHECK(m_container.metadata().empty());
}
TEST_FIXTURE(container_test_base, container_list_blobs)
{
m_container.create(azure::storage::blob_container_public_access_type::off, azure::storage::blob_request_options(), m_context);
check_container_no_stale_property(m_container);
std::map<utility::string_t, azure::storage::cloud_blob> blobs;
for (int i = 0; i < 4; i++)
{
auto index = utility::conversions::print_string(i);
auto blob = m_container.get_block_blob_reference(_XPLATSTR("blockblob") + index);
blob.metadata()[_XPLATSTR("index")] = index;
std::vector<uint8_t> buffer;
buffer.resize(i * 16 * 1024);
auto stream = concurrency::streams::container_stream<std::vector<uint8_t>>::open_istream(buffer);
blob.upload_from_stream(stream, azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
blobs[blob.name()] = blob;
}
for (int i = 0; i < 3; i++)
{
auto index = utility::conversions::print_string(i);
auto blob = m_container.get_page_blob_reference(_XPLATSTR("pageblob") + index);
blob.metadata()[_XPLATSTR("index")] = index;
blob.create(i * 512, 0, azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
check_container_no_stale_property(m_container);
blobs[blob.name()] = blob;
}
for (int i = 0; i < 3; i++)
{
auto index = utility::conversions::print_string(i);
auto blob = m_container.get_append_blob_reference(_XPLATSTR("appendblob") + index);
blob.metadata()[_XPLATSTR("index")] = index;
blob.create_or_replace(azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
check_container_no_stale_property(m_container);
std::vector<uint8_t> buffer;
buffer.resize((i + 1) * 8 * 1024);
fill_buffer_and_get_md5(buffer);
auto stream = concurrency::streams::container_stream<std::vector<uint8_t>>::open_istream(buffer);
blob.append_block(stream, utility::string_t(), azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
blobs[blob.name()] = blob;
}
auto listing1 = list_all_blobs(utility::string_t(), azure::storage::blob_listing_details::all, 0, azure::storage::blob_request_options());
for (auto iter = listing1.begin(); iter != listing1.end(); ++iter)
{
auto blob = blobs.find(iter->name());
CHECK(blob != blobs.end());
CHECK_UTF8_EQUAL(blob->second.uri().primary_uri().to_string(), iter->uri().primary_uri().to_string());
CHECK_UTF8_EQUAL(blob->second.uri().secondary_uri().to_string(), iter->uri().secondary_uri().to_string());
auto index_str = blob->second.metadata().find(_XPLATSTR("index"));
CHECK(index_str != blob->second.metadata().end());
auto index = utility::conversions::scan_string<int>(index_str->second);
switch (iter->type())
{
case azure::storage::blob_type::block_blob:
CHECK_EQUAL(index * 16 * 1024, iter->properties().size());
break;
case azure::storage::blob_type::page_blob:
CHECK_EQUAL(index * 512, iter->properties().size());
break;
case azure::storage::blob_type::append_blob:
CHECK_EQUAL((index + 1) * 8 * 1024, iter->properties().size());
break;
default:
CHECK(false);
break;
}
blobs.erase(blob);
}
CHECK_EQUAL(0U, blobs.size());
auto listing2 = list_all_blobs(_XPLATSTR("block"), azure::storage::blob_listing_details::none, 10, azure::storage::blob_request_options());
CHECK_EQUAL(4U, listing2.size());
for (auto iter = listing2.begin(); iter != listing2.end(); ++iter)
{
CHECK(iter->metadata().empty());
}
}
TEST_FIXTURE(append_blob_test_base, append_blob_append)
{
const size_t file_buffer_size = 24 * 1024 * 1024 + 6;
std::vector<uint8_t> file_buffer;
file_buffer.resize(file_buffer_size);
azure::storage::blob_request_options options;
options.set_use_transactional_md5(false);
utility::string_t md5_header;
m_context.set_sending_request([&md5_header](web::http::http_request& request, azure::storage::operation_context)
{
if (!request.headers().match(web::http::header_names::content_md5, md5_header))
{
md5_header.clear();
}
});
m_blob.create_or_replace(azure::storage::access_condition(), options, m_context);
int block_count = 0;
// append stream (4M, 4M)
const size_t buffer_offsets1[2] = { 0, 4 * 1024 * 1024};
for (uint16_t i = 0; i < 2; ++i)
{
std::vector<uint8_t> buffer;
buffer.resize(4 * 1024 * 1024);
fill_buffer_and_get_md5(buffer);
std::copy(buffer.begin(), buffer.end(), file_buffer.begin() + buffer_offsets1[i]);
auto stream = concurrency::streams::bytestream::open_istream(buffer);
azure::storage::access_condition condition = azure::storage::access_condition::generate_if_append_position_equal_condition(buffer_offsets1[i]);
m_blob.append_from_stream(stream, condition, options, m_context);
CHECK_UTF8_EQUAL(utility::string_t(), md5_header);
block_count++;
CHECK_EQUAL(block_count, m_blob.properties().append_blob_committed_block_count());
}
// append stream with length (2M, 2M, 2M)
const size_t buffer_offsets2[3] = { 8 * 1024 * 1024, 10 * 1024 * 1024, 12 * 1024 * 1024 };
for (uint16_t i = 0; i < 3; ++i)
{
std::vector<uint8_t> buffer;
buffer.resize(4 * 1024 * 1024);
fill_buffer_and_get_md5(buffer);
std::copy(buffer.begin(), buffer.begin() + 2 * 1024 * 1024, file_buffer.begin() + buffer_offsets2[i]);
auto stream = concurrency::streams::bytestream::open_istream(buffer);
m_blob.append_from_stream(stream, 2 * 1024 * 1024, azure::storage::access_condition(), options, m_context);
CHECK_UTF8_EQUAL(utility::string_t(), md5_header);
block_count++;
CHECK_EQUAL(block_count, m_blob.properties().append_blob_committed_block_count());
}
// append file (5M, 5M)
const size_t buffer_offsets3[2] = { 14 * 1024 * 1024, 19 * 1024 * 1024 };
for (uint16_t i = 0; i < 2; ++i)
{
std::vector<uint8_t> buffer;
buffer.resize(5 * 1024 * 1024);
fill_buffer_and_get_md5(buffer);
std::copy(buffer.begin(), buffer.end(), file_buffer.begin() + buffer_offsets3[i]);
// create a temporary test file
utility::string_t tmp_file_path = get_random_container_name(8);
auto stream = concurrency::streams::file_stream<uint8_t>::open_ostream(tmp_file_path).get();
stream.streambuf().putn_nocopy(buffer.data(), buffer.size()).wait();
stream.close().wait();
// append from file
m_blob.append_from_file(tmp_file_path, azure::storage::access_condition(), options, m_context);
// remote the temporary test file
std::remove(utility::conversions::to_utf8string(tmp_file_path).c_str());
block_count += 2;
CHECK_EQUAL(block_count, m_blob.properties().append_blob_committed_block_count());
}
// append text (1, 5)
const size_t buffer_offsets4[2] = { 24 * 1024 * 1024, 24 * 1024 * 1024 + 1};
{
utility::string_t text1 = U("1");
std::string text1_copy = utility::conversions::to_utf8string(text1);
std::copy(text1_copy.begin(), text1_copy.end(), file_buffer.begin() + buffer_offsets4[0]);
m_blob.append_text(text1);
block_count++;
CHECK_EQUAL(block_count, m_blob.properties().append_blob_committed_block_count());
utility::string_t text2 = U("test2");
std::string text2_copy = utility::conversions::to_utf8string(text2);
std::copy(text2_copy.begin(), text2_copy.end(), file_buffer.begin() + buffer_offsets4[1]);
m_blob.append_text(text2);
block_count++;
CHECK_EQUAL(block_count, m_blob.properties().append_blob_committed_block_count());
}
// download the blob
concurrency::streams::container_buffer<std::vector<uint8_t>> downloaded_blob;
m_blob.download_to_stream(downloaded_blob.create_ostream(), azure::storage::access_condition(), options, m_context);
CHECK_ARRAY_EQUAL(file_buffer, downloaded_blob.collection(), (int)file_buffer.size());
m_blob.delete_blob();
m_context.set_sending_request(std::function<void(web::http::http_request &, azure::storage::operation_context)>());
}
TEST_FIXTURE(append_blob_test_base, append_block)
{
const size_t buffer_size = 16 * 1024;
std::vector<uint8_t> buffer;
buffer.resize(buffer_size);
azure::storage::blob_request_options options;
utility::string_t md5_header;
m_context.set_sending_request([&md5_header](web::http::http_request& request, azure::storage::operation_context)
{
if (!request.headers().match(web::http::header_names::content_md5, md5_header))
{
md5_header.clear();
}
});
m_blob.create_or_replace(azure::storage::access_condition(), options, m_context);
options.set_use_transactional_md5(false);
for (uint16_t i = 0; i < 3; ++i)
{
fill_buffer_and_get_md5(buffer);
auto stream = concurrency::streams::bytestream::open_istream(buffer);
int64_t offset = m_blob.append_block(stream, utility::string_t(), azure::storage::access_condition(), options, m_context);
CHECK_UTF8_EQUAL(utility::string_t(), md5_header);
CHECK_EQUAL(i * buffer_size, offset);
CHECK_EQUAL(i + 1, m_blob.properties().append_blob_committed_block_count());
}
options.set_use_transactional_md5(false);
for (uint16_t i = 3; i < 6; ++i)
{
auto md5 = fill_buffer_and_get_md5(buffer);
auto stream = concurrency::streams::bytestream::open_istream(buffer);
int64_t offset = m_blob.append_block(stream, md5, azure::storage::access_condition(), options, m_context);
CHECK_UTF8_EQUAL(md5, md5_header);
CHECK_EQUAL(i * buffer_size, offset);
CHECK_EQUAL(i + 1, m_blob.properties().append_blob_committed_block_count());
}
options.set_use_transactional_md5(true);
for (uint16_t i = 6; i < 9; ++i)
{
auto md5 = fill_buffer_and_get_md5(buffer);
auto stream = concurrency::streams::bytestream::open_istream(buffer);
int64_t offset = m_blob.append_block(stream, utility::string_t(), azure::storage::access_condition(), options, m_context);
CHECK_UTF8_EQUAL(md5, md5_header);
CHECK_EQUAL(i * buffer_size, offset);
CHECK_EQUAL(i + 1, m_blob.properties().append_blob_committed_block_count());
}
// block stream with length = 0
options.set_use_transactional_md5(true);
fill_buffer_and_get_md5(buffer);
auto stream1 = concurrency::streams::bytestream::open_istream(buffer);
stream1.seek(buffer.size());
CHECK_THROW(m_blob.append_block(stream1, utility::string_t(), azure::storage::access_condition(), options, m_context), azure::storage::storage_exception);
options.set_use_transactional_md5(true);
fill_buffer_and_get_md5(buffer);
auto stream = concurrency::streams::bytestream::open_istream(buffer);
CHECK_THROW(m_blob.append_block(stream, dummy_md5, azure::storage::access_condition(), options, m_context), azure::storage::storage_exception);
CHECK_UTF8_EQUAL(dummy_md5, md5_header);
m_context.set_sending_request(std::function<void(web::http::http_request &, azure::storage::operation_context)>());
}
TEST_FIXTURE(append_blob_test_base, append_blob_constructor)
{
m_blob.create_or_replace(azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
CHECK(!m_blob.properties().etag().empty());
azure::storage::cloud_append_blob blob1(m_blob.uri());
CHECK_UTF8_EQUAL(m_blob.name(), blob1.name());
CHECK_UTF8_EQUAL(m_blob.uri().primary_uri().to_string(), blob1.uri().primary_uri().to_string());
CHECK_UTF8_EQUAL(m_blob.uri().secondary_uri().to_string(), blob1.uri().secondary_uri().to_string());
CHECK(blob1.properties().etag().empty());
azure::storage::cloud_blob blob2(m_blob);
CHECK_UTF8_EQUAL(m_blob.name(), blob2.name());
CHECK_UTF8_EQUAL(m_blob.uri().primary_uri().to_string(), blob2.uri().primary_uri().to_string());
CHECK_UTF8_EQUAL(m_blob.uri().secondary_uri().to_string(), blob2.uri().secondary_uri().to_string());
CHECK_UTF8_EQUAL(m_blob.properties().etag(), blob2.properties().etag());
azure::storage::cloud_append_blob blob3(blob2);
CHECK_UTF8_EQUAL(m_blob.name(), blob3.name());
CHECK_UTF8_EQUAL(m_blob.uri().primary_uri().to_string(), blob3.uri().primary_uri().to_string());
CHECK_UTF8_EQUAL(m_blob.uri().secondary_uri().to_string(), blob3.uri().secondary_uri().to_string());
CHECK_UTF8_EQUAL(m_blob.properties().etag(), blob2.properties().etag());
}
TEST_FIXTURE(page_blob_test_base, page_upload)
{
std::vector<uint8_t> buffer;
buffer.resize(512);
azure::storage::blob_request_options options;
std::vector<azure::storage::page_range> pages;
utility::string_t md5_header;
m_context.set_sending_request([&md5_header] (web::http::http_request& request, azure::storage::operation_context)
{
if (!request.headers().match(web::http::header_names::content_md5, md5_header))
{
md5_header.clear();
}
});
m_blob.create(12 * 1024 * 1024, 0, azure::storage::access_condition(), options, m_context);
options.set_use_transactional_md5(false);
for (int i = 0; i < 3; ++i)
{
fill_buffer_and_get_md5(buffer);
auto stream = concurrency::streams::bytestream::open_istream(buffer);
azure::storage::page_range range(i * 1024, i * 1024 + buffer.size() - 1);
pages.push_back(range);
m_blob.upload_pages(stream, range.start_offset(), utility::string_t(), azure::storage::access_condition(), options, m_context);
CHECK_UTF8_EQUAL(utility::string_t(), md5_header);
}
check_page_ranges_equal(pages);
options.set_use_transactional_md5(false);
for (int i = 3; i < 6; ++i)
{
auto md5 = fill_buffer_and_get_md5(buffer);
auto stream = concurrency::streams::bytestream::open_istream(buffer);
azure::storage::page_range range(i * 1536, i * 1536 + buffer.size() - 1);
pages.push_back(range);
m_blob.upload_pages(stream, range.start_offset(), md5, azure::storage::access_condition(), options, m_context);
CHECK_UTF8_EQUAL(md5, md5_header);
}
check_page_ranges_equal(pages);
options.set_use_transactional_md5(true);
for (int i = 6; i < 9; ++i)
{
auto md5 = fill_buffer_and_get_md5(buffer);
auto stream = concurrency::streams::bytestream::open_istream(buffer);
azure::storage::page_range range(i * 2048, i * 2048 + buffer.size() - 1);
pages.push_back(range);
m_blob.upload_pages(stream, range.start_offset(), utility::string_t(), azure::storage::access_condition(), options, m_context);
CHECK_UTF8_EQUAL(md5, md5_header);
}
options.set_use_transactional_md5(false);
{
// upload a page range of max_block_size
std::vector<uint8_t> big_buffer;
big_buffer.resize(azure::storage::protocol::max_block_size);
auto md5 = fill_buffer_and_get_md5(big_buffer);
auto stream = concurrency::streams::bytestream::open_istream(big_buffer);
azure::storage::page_range range(4 * 1024 * 1024, 4 * 1024 * 1024 + azure::storage::protocol::max_block_size - 1);
pages.push_back(range);
m_blob.upload_pages(stream, range.start_offset(), md5, azure::storage::access_condition(), options, m_context);
CHECK_UTF8_EQUAL(md5, md5_header);
}
check_page_ranges_equal(pages);
options.set_use_transactional_md5(true);
fill_buffer_and_get_md5(buffer);
auto stream = concurrency::streams::bytestream::open_istream(buffer);
CHECK_THROW(m_blob.upload_pages(stream, 0, dummy_md5, azure::storage::access_condition(), options, m_context), azure::storage::storage_exception);
CHECK_UTF8_EQUAL(dummy_md5, md5_header);
// trying upload page ranges bigger than max_block_size
{
buffer.resize(azure::storage::protocol::max_block_size + 1);
fill_buffer_and_get_md5(buffer);
azure::storage::page_range range(8 * 1024 * 1024, 8 * 1024 * 1024 + azure::storage::protocol::max_block_size -1);
auto stream = concurrency::streams::bytestream::open_istream(buffer);
CHECK_THROW(m_blob.upload_pages(stream, range.start_offset(), utility::string_t(), azure::storage::access_condition(), options, m_context), std::invalid_argument);
}
check_page_ranges_equal(pages);
m_context.set_sending_request(std::function<void(web::http::http_request &, azure::storage::operation_context)>());
}
