TEST_FIXTURE(blob_service_test_base_with_objects_to_delete, list_containers)
{
auto prefix = get_random_container_name();
create_containers(prefix, 1);
auto listing = list_all_containers(utility::string_t(), azure::storage::container_listing_details::all, 5001, azure::storage::blob_request_options());
check_container_list(listing, prefix, false);
}
TEST_FIXTURE(blob_service_test_base_with_objects_to_delete, list_blobs_from_client_root)
{
auto root_container = m_client.get_root_container_reference();
root_container.create_if_not_exists();
auto prefix = get_random_container_name();
create_blobs(root_container, prefix, 1);
auto listing = list_all_blobs_from_client(prefix, azure::storage::blob_listing_details::none, 1, azure::storage::blob_request_options());
check_blob_list(listing);
}
TEST_FIXTURE(blob_service_test_base, get_container_reference)
{
utility::string_t container_name = get_random_container_name();
azure::storage::cloud_blob_container container = m_client.get_container_reference(container_name);
CHECK(!container.service_client().base_uri().primary_uri().is_empty());
CHECK(container.service_client().credentials().is_shared_key());
CHECK(container.name() == container_name);
CHECK(!container.uri().primary_uri().is_empty());
CHECK(container.metadata().empty());
CHECK(container.properties().etag().empty());
CHECK(!container.properties().last_modified().is_initialized());
CHECK(container.properties().lease_status() == azure::storage::lease_status::unspecified);
CHECK(container.properties().lease_state() == azure::storage::lease_state::unspecified);
CHECK(container.properties().lease_duration() == azure::storage::lease_duration::unspecified);
CHECK(container.is_valid());
}
TEST_FIXTURE(blob_service_test_base_with_objects_to_delete, list_containers_with_continuation_token)
{
auto prefix = get_random_container_name();
create_containers(prefix, 10);
std::vector<azure::storage::cloud_blob_container> listing;
azure::storage::continuation_token token;
azure::storage::blob_request_options options;
do{
auto results = m_client.list_containers_segmented(prefix, azure::storage::container_listing_details::all, 3, token, options, m_context);
CHECK(results.results().size() <= 3);
std::copy(results.results().begin(), results.results().end(), std::back_inserter(listing));
token = results.continuation_token();
} while (!token.empty());
check_container_list(listing, prefix, true);
}
TEST_FIXTURE(blob_test_base, list_blobs_from_client)
{
std::vector<azure::storage::cloud_blob> blobs;
auto prefix = get_random_container_name();
std::vector<azure::storage::cloud_blob> blobs2;
auto prefix2 = get_random_container_name();
for (int i = 0; i < 3; i++)
{
auto index = utility::conversions::print_string(i);
auto blob = m_container.get_block_blob_reference(prefix + index);
blob.upload_text(U("test"), azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
blobs.push_back(blob);
}
for (int i = 0; i < 2; i++)
{
auto index = utility::conversions::print_string(i);
auto blob = m_container.get_block_blob_reference(prefix2 + index);
blob.upload_text(U("test2"), azure::storage::access_condition(), azure::storage::blob_request_options(), m_context);
blobs2.push_back(blob);
}
std::vector<azure::storage::cloud_blob> all_blobs(blobs);
all_blobs.insert(all_blobs.end(), blobs2.begin(), blobs2.end());
auto listing = list_all_blobs_from_client(m_container.name(), azure::storage::blob_listing_details::none, 0, azure::storage::blob_request_options());
CHECK(listing.empty());
listing = list_all_blobs_from_client(m_container.name() + U("/"), azure::storage::blob_listing_details::none, 0, azure::storage::blob_request_options());
CHECK_EQUAL(5U, listing.size());
for (auto listing_iter = listing.begin(); listing_iter != listing.end(); ++listing_iter)
{
for (auto iter = all_blobs.begin(); iter != all_blobs.end(); ++iter)
{
if (iter->name() == listing_iter->name())
{
all_blobs.erase(iter);
break;
}
}
}
CHECK(all_blobs.empty());
std::vector<azure::storage::cloud_blob> blobs_copy(blobs);
listing = list_all_blobs_from_client(m_container.name() + U("/") + prefix, azure::storage::blob_listing_details::none, 0, azure::storage::blob_request_options());
CHECK_EQUAL(3U, listing.size());
for (auto listing_iter = listing.begin(); listing_iter != listing.end(); ++listing_iter)
{
for (auto iter = blobs_copy.begin(); iter != blobs_copy.end(); ++iter)
{
if (iter->name() == listing_iter->name())
{
blobs_copy.erase(iter);
break;
}
}
}
CHECK(blobs_copy.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)>());
}
