From c0111d83aefa1a1036263ac0291f0fa773a94efd Mon Sep 17 00:00:00 2001 From: "Scott E. Graves" Date: Wed, 13 Nov 2024 12:44:11 -0600 Subject: [PATCH] refactor --- .../repertory_test/src/file_manager_test.cpp | 856 +++++++++--------- 1 file changed, 432 insertions(+), 424 deletions(-) diff --git a/repertory/repertory_test/src/file_manager_test.cpp b/repertory/repertory_test/src/file_manager_test.cpp index dc03a3cf..a9298ade 100644 --- a/repertory/repertory_test/src/file_manager_test.cpp +++ b/repertory/repertory_test/src/file_manager_test.cpp @@ -1,5 +1,5 @@ /* - Copyright <2018-2024> + Copyright <2018-2024> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal @@ -43,8 +43,9 @@ namespace repertory { auto file_manager::open(std::shared_ptr of, const open_file_data &ofd, std::uint64_t &handle, - std::shared_ptr &f) -> api_error { - return open(of->get_api_path(), of->is_directory(), ofd, handle, f, of); + std::shared_ptr &open_file) -> api_error { + return open(of->get_api_path(), of->is_directory(), ofd, handle, open_file, + of); } class file_manager_test : public ::testing::Test { @@ -75,30 +76,30 @@ std::atomic file_manager_test::inst{0U}; TEST_F(file_manager_test, can_start_and_stop) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - event_consumer es("service_started", [](const event &e) { - const auto &ee = dynamic_cast(e); - EXPECT_STREQ("file_manager", ee.get_service().get().c_str()); + event_consumer consumer("service_started", [](const event &evt) { + const auto &evt2 = dynamic_cast(evt); + EXPECT_STREQ("file_manager", evt2.get_service().get().c_str()); }); - event_consumer es2("service_shutdown_begin", [](const event &e) { - const auto &ee = dynamic_cast(e); - EXPECT_STREQ("file_manager", ee.get_service().get().c_str()); + event_consumer consumer2("service_shutdown_begin", [](const event &evt) { + const auto &evt2 = dynamic_cast(evt); + EXPECT_STREQ("file_manager", evt2.get_service().get().c_str()); }); - event_consumer es3("service_shutdown_end", [](const event &e) { - const auto &ee = dynamic_cast(e); - EXPECT_STREQ("file_manager", ee.get_service().get().c_str()); + event_consumer consumer3("service_shutdown_end", [](const event &evt) { + const auto &evt2 = dynamic_cast(evt); + EXPECT_STREQ("file_manager", evt2.get_service().get().c_str()); }); - event_capture ec({ + event_capture capture({ "service_started", "service_shutdown_begin", "service_shutdown_end", }); - file_manager fm(*cfg, mp); - fm.start(); - fm.stop(); + file_manager mgr(*cfg, mp); + mgr.start(); + mgr.stop(); - ec.wait_for_empty(); + capture.wait_for_empty(); } TEST_F(file_manager_test, can_create_and_close_file) { @@ -108,8 +109,8 @@ TEST_F(file_manager_test, can_create_and_close_file) { polling::instance().start(cfg.get()); - file_manager fm(*cfg, mp); - fm.start(); + file_manager mgr(*cfg, mp); + mgr.start(); event_capture capture({ "item_timeout", @@ -119,17 +120,17 @@ TEST_F(file_manager_test, can_create_and_close_file) { "filesystem_item_closed", }); - const auto source_path = utils::path::combine(cfg->get_cache_directory(), - {utils::create_uuid_string()}); + auto source_path = utils::path::combine(cfg->get_cache_directory(), + {utils::create_uuid_string()}); std::uint64_t handle{}; { - std::shared_ptr f; + std::shared_ptr open_file; - const auto now = utils::time::get_time_now(); - auto meta = create_meta_attributes(now, FILE_ATTRIBUTE_ARCHIVE, now + 1u, - now + 2u, false, 1, "key", 2, now + 3u, - 3u, 4u, 0u, source_path, 10, now + 4u); + auto now = utils::time::get_time_now(); + auto meta = create_meta_attributes(now, FILE_ATTRIBUTE_ARCHIVE, now + 1U, + now + 2U, false, 1, "key", 2, now + 3U, + 3U, 4U, 0U, source_path, 10U, now + 4U); EXPECT_CALL(mp, create_file("/test_create.txt", meta)) .WillOnce(Return(api_error::success)); @@ -146,65 +147,66 @@ TEST_F(file_manager_test, can_create_and_close_file) { return api_error::success; }); - event_consumer ec("filesystem_item_opened", [&](const event &e) { - const auto &ee = dynamic_cast(e); + event_consumer consumer("filesystem_item_opened", [&](const event &evt) { + const auto &evt2 = dynamic_cast(evt); EXPECT_STREQ("/test_create.txt", - ee.get_api_path().get().c_str()); + evt2.get_api_path().get().c_str()); EXPECT_STREQ(source_path.c_str(), - ee.get_source().get().c_str()); - EXPECT_STREQ("0", ee.get_directory().get().c_str()); + evt2.get_source().get().c_str()); + EXPECT_STREQ("0", evt2.get_directory().get().c_str()); }); - event_consumer ec2("filesystem_item_handle_opened", [&](const event &e) { - const auto &ee = dynamic_cast(e); + event_consumer ec2("filesystem_item_handle_opened", [&](const event &evt) { + const auto &evt2 = + dynamic_cast(evt); EXPECT_STREQ("/test_create.txt", - ee.get_api_path().get().c_str()); + evt2.get_api_path().get().c_str()); EXPECT_STREQ(source_path.c_str(), - ee.get_source().get().c_str()); - EXPECT_STREQ("0", ee.get_directory().get().c_str()); - EXPECT_STREQ("1", ee.get_handle().get().c_str()); + evt2.get_source().get().c_str()); + EXPECT_STREQ("0", evt2.get_directory().get().c_str()); + EXPECT_STREQ("1", evt2.get_handle().get().c_str()); }); #if defined(_WIN32) EXPECT_EQ(api_error::success, - fm.create("/test_create.txt", meta, {}, handle, f)); + mgr.create("/test_create.txt", meta, {}, handle, open_file)); #else EXPECT_EQ(api_error::success, - fm.create("/test_create.txt", meta, O_RDWR, handle, f)); + mgr.create("/test_create.txt", meta, O_RDWR, handle, open_file)); #endif - EXPECT_EQ(std::size_t(1u), fm.get_open_file_count()); - EXPECT_EQ(std::size_t(1u), fm.get_open_handle_count()); - EXPECT_EQ(std::uint64_t(1u), handle); + EXPECT_EQ(std::size_t(1U), mgr.get_open_file_count()); + EXPECT_EQ(std::size_t(1U), mgr.get_open_handle_count()); + EXPECT_EQ(std::uint64_t(1U), handle); } - event_consumer ec3("filesystem_item_closed", [&](const event &e) { - const auto &ee = dynamic_cast(e); + event_consumer ec3("filesystem_item_closed", [&](const event &evt) { + const auto &evt2 = dynamic_cast(evt); EXPECT_STREQ("/test_create.txt", - ee.get_api_path().get().c_str()); + evt2.get_api_path().get().c_str()); EXPECT_STREQ(source_path.c_str(), - ee.get_source().get().c_str()); - EXPECT_STREQ("0", ee.get_directory().get().c_str()); + evt2.get_source().get().c_str()); + EXPECT_STREQ("0", evt2.get_directory().get().c_str()); }); - event_consumer ec4("filesystem_item_handle_closed", [&](const event &e) { - const auto &ee = dynamic_cast(e); + event_consumer ec4("filesystem_item_handle_closed", [&](const event &evt) { + const auto &evt2 = dynamic_cast(evt); EXPECT_STREQ("/test_create.txt", - ee.get_api_path().get().c_str()); + evt2.get_api_path().get().c_str()); EXPECT_STREQ(source_path.c_str(), - ee.get_source().get().c_str()); - EXPECT_STREQ("0", ee.get_directory().get().c_str()); - EXPECT_STREQ("1", ee.get_handle().get().c_str()); + evt2.get_source().get().c_str()); + EXPECT_STREQ("0", evt2.get_directory().get().c_str()); + EXPECT_STREQ("1", evt2.get_handle().get().c_str()); }); - fm.close(handle); + mgr.close(handle); - EXPECT_EQ(std::size_t(1u), fm.get_open_file_count()); - EXPECT_EQ(std::size_t(0u), fm.get_open_handle_count()); + EXPECT_EQ(std::size_t(1U), mgr.get_open_file_count()); + EXPECT_EQ(std::size_t(0U), mgr.get_open_handle_count()); capture.wait_for_empty(); - EXPECT_EQ(std::size_t(0u), fm.get_open_file_count()); + EXPECT_EQ(std::size_t(0U), mgr.get_open_file_count()); - fm.stop(); + mgr.stop(); polling::instance().stop(); } @@ -215,8 +217,8 @@ TEST_F(file_manager_test, can_open_and_close_file) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); polling::instance().start(cfg.get()); - file_manager fm(*cfg, mp); - fm.start(); + file_manager mgr(*cfg, mp); + mgr.start(); event_capture capture({ "item_timeout", @@ -225,18 +227,18 @@ TEST_F(file_manager_test, can_open_and_close_file) { "filesystem_item_handle_closed", "filesystem_item_closed", }); - const auto source_path = utils::path::combine(cfg->get_cache_directory(), - {utils::create_uuid_string()}); + auto source_path = utils::path::combine(cfg->get_cache_directory(), + {utils::create_uuid_string()}); std::uint64_t handle{}; { - const auto now = utils::time::get_time_now(); - auto meta = create_meta_attributes(now, FILE_ATTRIBUTE_ARCHIVE, now + 1u, - now + 2u, false, 1, "key", 2, now + 3u, - 3u, 4u, 0u, source_path, 10, now + 4u); + auto now = utils::time::get_time_now(); + auto meta = create_meta_attributes(now, FILE_ATTRIBUTE_ARCHIVE, now + 1U, + now + 2U, false, 1U, "key", 2U, now + 3U, + 3U, 4U, 0U, source_path, 10U, now + 4U); - EXPECT_CALL(mp, create_file).Times(0u); + EXPECT_CALL(mp, create_file).Times(0U); EXPECT_CALL(mp, get_filesystem_item) .WillOnce([&meta](const std::string &api_path, bool directory, @@ -251,66 +253,67 @@ TEST_F(file_manager_test, can_open_and_close_file) { return api_error::success; }); - event_consumer ec("filesystem_item_opened", [&](const event &e) { - const auto &ee = dynamic_cast(e); + event_consumer consumer("filesystem_item_opened", [&](const event &evt) { + const auto &evt2 = dynamic_cast(evt); EXPECT_STREQ("/test_open.txt", - ee.get_api_path().get().c_str()); + evt2.get_api_path().get().c_str()); EXPECT_STREQ(source_path.c_str(), - ee.get_source().get().c_str()); - EXPECT_STREQ("0", ee.get_directory().get().c_str()); + evt2.get_source().get().c_str()); + EXPECT_STREQ("0", evt2.get_directory().get().c_str()); }); - event_consumer ec2("filesystem_item_handle_opened", [&](const event &e) { - const auto &ee = dynamic_cast(e); + event_consumer ec2("filesystem_item_handle_opened", [&](const event &evt) { + const auto &evt2 = + dynamic_cast(evt); EXPECT_STREQ("/test_open.txt", - ee.get_api_path().get().c_str()); + evt2.get_api_path().get().c_str()); EXPECT_STREQ(source_path.c_str(), - ee.get_source().get().c_str()); - EXPECT_STREQ("0", ee.get_directory().get().c_str()); - EXPECT_STREQ("1", ee.get_handle().get().c_str()); + evt2.get_source().get().c_str()); + EXPECT_STREQ("0", evt2.get_directory().get().c_str()); + EXPECT_STREQ("1", evt2.get_handle().get().c_str()); }); - std::shared_ptr f; + std::shared_ptr open_file; #if defined(_WIN32) EXPECT_EQ(api_error::success, - fm.open("/test_open.txt", false, {}, handle, f)); + mgr.open("/test_open.txt", false, {}, handle, open_file)); #else EXPECT_EQ(api_error::success, - fm.open("/test_open.txt", false, O_RDWR, handle, f)); + mgr.open("/test_open.txt", false, O_RDWR, handle, open_file)); #endif - EXPECT_EQ(std::size_t(1u), fm.get_open_file_count()); - EXPECT_EQ(std::size_t(1u), fm.get_open_handle_count()); - EXPECT_EQ(std::uint64_t(1u), handle); + EXPECT_EQ(std::size_t(1U), mgr.get_open_file_count()); + EXPECT_EQ(std::size_t(1U), mgr.get_open_handle_count()); + EXPECT_EQ(std::uint64_t(1U), handle); } - event_consumer ec3("filesystem_item_closed", [&](const event &e) { - const auto &ee = dynamic_cast(e); + event_consumer ec3("filesystem_item_closed", [&](const event &evt) { + const auto &evt2 = dynamic_cast(evt); EXPECT_STREQ("/test_open.txt", - ee.get_api_path().get().c_str()); + evt2.get_api_path().get().c_str()); EXPECT_STREQ(source_path.c_str(), - ee.get_source().get().c_str()); - EXPECT_STREQ("0", ee.get_directory().get().c_str()); + evt2.get_source().get().c_str()); + EXPECT_STREQ("0", evt2.get_directory().get().c_str()); }); - event_consumer ec4("filesystem_item_handle_closed", [&](const event &e) { - const auto &ee = dynamic_cast(e); + event_consumer ec4("filesystem_item_handle_closed", [&](const event &evt) { + const auto &evt2 = dynamic_cast(evt); EXPECT_STREQ("/test_open.txt", - ee.get_api_path().get().c_str()); + evt2.get_api_path().get().c_str()); EXPECT_STREQ(source_path.c_str(), - ee.get_source().get().c_str()); - EXPECT_STREQ("0", ee.get_directory().get().c_str()); - EXPECT_STREQ("1", ee.get_handle().get().c_str()); + evt2.get_source().get().c_str()); + EXPECT_STREQ("0", evt2.get_directory().get().c_str()); + EXPECT_STREQ("1", evt2.get_handle().get().c_str()); }); - fm.close(handle); + mgr.close(handle); - EXPECT_EQ(std::size_t(1u), fm.get_open_file_count()); - EXPECT_EQ(std::size_t(0u), fm.get_open_handle_count()); + EXPECT_EQ(std::size_t(1U), mgr.get_open_file_count()); + EXPECT_EQ(std::size_t(0U), mgr.get_open_handle_count()); capture.wait_for_empty(); - EXPECT_EQ(std::size_t(0u), fm.get_open_file_count()); + EXPECT_EQ(std::size_t(0U), mgr.get_open_file_count()); - fm.stop(); + mgr.stop(); polling::instance().stop(); } @@ -319,14 +322,14 @@ TEST_F(file_manager_test, can_open_and_close_multiple_handles_for_same_file) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); polling::instance().start(cfg.get()); - file_manager fm(*cfg, mp); - fm.start(); + file_manager mgr(*cfg, mp); + mgr.start(); { - const auto source_path = utils::path::combine( - cfg->get_cache_directory(), {utils::create_uuid_string()}); + auto source_path = utils::path::combine(cfg->get_cache_directory(), + {utils::create_uuid_string()}); - const auto now = utils::time::get_time_now(); + auto now = utils::time::get_time_now(); auto meta = create_meta_attributes(now, FILE_ATTRIBUTE_ARCHIVE, now + 1u, now + 2u, false, 1, "key", 2, now + 3u, 3u, 4u, 0u, source_path, 10, now + 4u); @@ -346,32 +349,32 @@ TEST_F(file_manager_test, can_open_and_close_multiple_handles_for_same_file) { return api_error::success; }); - std::array handles; - for (std::uint8_t i = 0u; i < handles.size(); i++) { - std::shared_ptr f; + std::array handles{}; + for (std::size_t idx = 0U; idx < handles.size(); ++idx) { + std::shared_ptr open_file; #if defined(_WIN32) - EXPECT_EQ(api_error::success, - fm.open("/test_open.txt", false, {}, handles[i], f)); + EXPECT_EQ(api_error::success, mgr.open("/test_open.txt", false, {}, + handles.at(idx), open_file)); #else - EXPECT_EQ(api_error::success, - fm.open("/test_open.txt", false, O_RDWR, handles[i], f)); + EXPECT_EQ(api_error::success, mgr.open("/test_open.txt", false, O_RDWR, + handles.at(idx), open_file)); #endif - EXPECT_EQ(std::size_t(1u), fm.get_open_file_count()); - EXPECT_EQ(std::size_t(i + 1u), fm.get_open_handle_count()); - EXPECT_EQ(std::uint64_t(i + 1u), handles[i]); + EXPECT_EQ(std::size_t(1U), mgr.get_open_file_count()); + EXPECT_EQ(std::size_t(idx + 1U), mgr.get_open_handle_count()); + EXPECT_EQ(std::uint64_t(idx + 1U), handles.at(idx)); } - for (std::uint8_t i = 0u; i < handles.size(); i++) { - EXPECT_EQ(std::size_t(1u), fm.get_open_file_count()); - EXPECT_EQ(std::size_t(handles.size() - i), fm.get_open_handle_count()); - fm.close(handles[i]); + for (std::size_t idx = 0U; idx < handles.size(); ++idx) { + EXPECT_EQ(std::size_t(1U), mgr.get_open_file_count()); + EXPECT_EQ(std::size_t(handles.size() - idx), mgr.get_open_handle_count()); + mgr.close(handles.at(idx)); } - fm.stop(); + mgr.stop(); } - EXPECT_EQ(std::size_t(0u), fm.get_open_file_count()); - EXPECT_EQ(std::size_t(0u), fm.get_open_handle_count()); + EXPECT_EQ(std::size_t(0U), mgr.get_open_file_count()); + EXPECT_EQ(std::size_t(0U), mgr.get_open_handle_count()); polling::instance().stop(); } @@ -380,32 +383,33 @@ TEST_F(file_manager_test, download_is_stored_after_write_if_partially_downloaded) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - file_manager fm(*cfg, mp); - fm.start(); + file_manager mgr(*cfg, mp); + mgr.start(); - const auto source_path = utils::path::combine(cfg->get_cache_directory(), - {utils::create_uuid_string()}); + auto source_path = utils::path::combine(cfg->get_cache_directory(), + {utils::create_uuid_string()}); - event_consumer es("download_resume_added", [&source_path](const event &e) { - const auto &ee = dynamic_cast(e); - EXPECT_STREQ("/test_write_partial_download.txt", - ee.get_api_path().get().c_str()); - EXPECT_STREQ(source_path.c_str(), - ee.get_dest_path().get().c_str()); - }); + event_consumer consumer( + "download_resume_added", [&source_path](const event &evt) { + const auto &evt2 = dynamic_cast(evt); + EXPECT_STREQ("/test_write_partial_download.txt", + evt2.get_api_path().get().c_str()); + EXPECT_STREQ(source_path.c_str(), + evt2.get_dest_path().get().c_str()); + }); - event_capture ec({"download_resume_added"}, { - "file_upload_completed", - "file_upload_queued", - }); + event_capture capture({"download_resume_added"}, { + "file_upload_completed", + "file_upload_queued", + }); - const auto now = utils::time::get_time_now(); + auto now = utils::time::get_time_now(); auto meta = create_meta_attributes( now, FILE_ATTRIBUTE_ARCHIVE, now + 1u, now + 2u, false, 1, "key", 2, now + 3u, 3u, 4u, utils::encryption::encrypting_reader::get_data_chunk_size() * 4u, source_path, 10, now + 4u); - auto &nf = + auto &file = test::create_random_file(utils::string::to_uint64(meta[META_SIZE])); EXPECT_CALL(mp, get_filesystem_item) @@ -422,20 +426,20 @@ TEST_F(file_manager_test, }); std::uint64_t handle{}; - std::shared_ptr f; + std::shared_ptr open_file; #if defined(_WIN32) - EXPECT_EQ(api_error::success, - fm.open("/test_write_partial_download.txt", false, {}, handle, f)); + EXPECT_EQ(api_error::success, mgr.open("/test_write_partial_download.txt", + false, {}, handle, open_file)); #else - EXPECT_EQ(api_error::success, fm.open("/test_write_partial_download.txt", - false, O_RDWR, handle, f)); + EXPECT_EQ(api_error::success, mgr.open("/test_write_partial_download.txt", + false, O_RDWR, handle, open_file)); #endif EXPECT_CALL(mp, read_file_bytes) - .WillRepeatedly([&nf](const std::string & /* api_path */, - std::size_t size, std::uint64_t offset, - data_buffer &data, - stop_type &stop_requested) -> api_error { + .WillRepeatedly([&file](const std::string & /* api_path */, + std::size_t size, std::uint64_t offset, + data_buffer &data, + stop_type &stop_requested) -> api_error { if (stop_requested) { return api_error::download_stopped; } @@ -443,8 +447,8 @@ TEST_F(file_manager_test, if (offset == 0u) { std::size_t bytes_read{}; data.resize(size); - auto ret = nf.read(data, offset, &bytes_read) ? api_error::success - : api_error::os_error; + auto ret = file.read(data, offset, &bytes_read) ? api_error::success + : api_error::os_error; EXPECT_EQ(bytes_read, data.size()); return ret; } @@ -467,27 +471,27 @@ TEST_F(file_manager_test, std::size_t bytes_written{}; data_buffer data = {0, 1, 2}; - EXPECT_EQ(api_error::success, f->write(0u, data, bytes_written)); + EXPECT_EQ(api_error::success, open_file->write(0u, data, bytes_written)); EXPECT_EQ(std::size_t(3u), bytes_written); - f.reset(); + open_file.reset(); - fm.close(handle); + mgr.close(handle); - EXPECT_EQ(std::size_t(1u), fm.get_open_file_count()); - EXPECT_EQ(std::size_t(0u), fm.get_open_handle_count()); + EXPECT_EQ(std::size_t(1u), mgr.get_open_file_count()); + EXPECT_EQ(std::size_t(0u), mgr.get_open_handle_count()); - fm.stop(); - ec.wait_for_empty(); + mgr.stop(); + capture.wait_for_empty(); event_capture ec2({"download_restored", "download_resume_added"}, { "file_upload_completed", "file_upload_queued", }); - EXPECT_EQ(std::size_t(0u), fm.get_open_file_count()); - EXPECT_EQ(std::size_t(0u), fm.get_open_handle_count()); + EXPECT_EQ(std::size_t(0u), mgr.get_open_file_count()); + EXPECT_EQ(std::size_t(0u), mgr.get_open_handle_count()); - auto stored_downloads = fm.get_stored_downloads(); + auto stored_downloads = mgr.get_stored_downloads(); EXPECT_EQ(std::size_t(1u), stored_downloads.size()); std::cout << stored_downloads[0u].dump(2) << std::endl; @@ -504,25 +508,25 @@ TEST_F(file_manager_test, EXPECT_STREQ(source_path.c_str(), stored_downloads[0u]["source"].get().c_str()); - fm.start(); + mgr.start(); - event_consumer es2("download_restored", [&source_path](const event &e) { - const auto &ee = dynamic_cast(e); + event_consumer es2("download_restored", [&source_path](const event &evt) { + const auto &evt2 = dynamic_cast(evt); EXPECT_STREQ("/test_write_partial_download.txt", - ee.get_api_path().get().c_str()); + evt2.get_api_path().get().c_str()); EXPECT_STREQ(source_path.c_str(), - ee.get_dest_path().get().c_str()); + evt2.get_dest_path().get().c_str()); }); - EXPECT_EQ(std::size_t(1u), fm.get_open_file_count()); - EXPECT_EQ(std::size_t(0u), fm.get_open_handle_count()); - fm.stop(); + EXPECT_EQ(std::size_t(1u), mgr.get_open_file_count()); + EXPECT_EQ(std::size_t(0u), mgr.get_open_handle_count()); + mgr.stop(); ec2.wait_for_empty(); - EXPECT_EQ(std::size_t(0u), fm.get_open_file_count()); - EXPECT_EQ(std::size_t(0u), fm.get_open_handle_count()); + EXPECT_EQ(std::size_t(0u), mgr.get_open_file_count()); + EXPECT_EQ(std::size_t(0u), mgr.get_open_handle_count()); - nf.close(); + file.close(); } TEST_F(file_manager_test, upload_occurs_after_write_if_fully_downloaded) { @@ -531,35 +535,36 @@ TEST_F(file_manager_test, upload_occurs_after_write_if_fully_downloaded) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); polling::instance().start(cfg.get()); - file_manager fm(*cfg, mp); - fm.start(); + file_manager mgr(*cfg, mp); + mgr.start(); - const auto source_path = utils::path::combine(cfg->get_cache_directory(), - {utils::create_uuid_string()}); + auto source_path = utils::path::combine(cfg->get_cache_directory(), + {utils::create_uuid_string()}); - event_consumer es("file_upload_queued", [&source_path](const event &e) { - const auto &ee = dynamic_cast(e); + event_consumer consumer( + "file_upload_queued", [&source_path](const event &evt) { + const auto &evt2 = dynamic_cast(evt); + EXPECT_STREQ("/test_write_full_download.txt", + evt2.get_api_path().get().c_str()); + EXPECT_STREQ(source_path.c_str(), + evt2.get_source().get().c_str()); + }); + event_consumer es2("file_upload_completed", [&source_path](const event &evt) { + const auto &evt2 = dynamic_cast(evt); EXPECT_STREQ("/test_write_full_download.txt", - ee.get_api_path().get().c_str()); + evt2.get_api_path().get().c_str()); EXPECT_STREQ(source_path.c_str(), - ee.get_source().get().c_str()); + evt2.get_source().get().c_str()); }); - event_consumer es2("file_upload_completed", [&source_path](const event &e) { - const auto &ee = dynamic_cast(e); - EXPECT_STREQ("/test_write_full_download.txt", - ee.get_api_path().get().c_str()); - EXPECT_STREQ(source_path.c_str(), - ee.get_source().get().c_str()); - }); - event_capture ec({"download_end"}); + event_capture capture({"download_end"}); - const auto now = utils::time::get_time_now(); + auto now = utils::time::get_time_now(); auto meta = create_meta_attributes( now, FILE_ATTRIBUTE_ARCHIVE, now + 1u, now + 2u, false, 1, "key", 2, now + 3u, 3u, 4u, utils::encryption::encrypting_reader::get_data_chunk_size() * 4u, source_path, 10, now + 4u); - auto &nf = + auto &file = test::create_random_file(utils::string::to_uint64(meta[META_SIZE])); EXPECT_CALL(mp, get_filesystem_item) @@ -576,24 +581,24 @@ TEST_F(file_manager_test, upload_occurs_after_write_if_fully_downloaded) { }); std::uint64_t handle{}; - std::shared_ptr f; + std::shared_ptr open_file; #if defined(_WIN32) - EXPECT_EQ(api_error::success, - fm.open("/test_write_full_download.txt", false, {}, handle, f)); + EXPECT_EQ(api_error::success, mgr.open("/test_write_full_download.txt", false, + {}, handle, open_file)); #else - EXPECT_EQ(api_error::success, - fm.open("/test_write_full_download.txt", false, O_RDWR, handle, f)); + EXPECT_EQ(api_error::success, mgr.open("/test_write_full_download.txt", false, + O_RDWR, handle, open_file)); #endif EXPECT_CALL(mp, read_file_bytes) - .WillRepeatedly([&nf](const std::string & /* api_path */, - std::size_t size, std::uint64_t offset, - data_buffer &data, - stop_type & /* stop_requested */) -> api_error { + .WillRepeatedly([&file](const std::string & /* api_path */, + std::size_t size, std::uint64_t offset, + data_buffer &data, + stop_type & /* stop_requested */) -> api_error { std::size_t bytes_read{}; data.resize(size); - auto ret = nf.read(data, offset, &bytes_read) ? api_error::success - : api_error::os_error; + auto ret = file.read(data, offset, &bytes_read) ? api_error::success + : api_error::os_error; EXPECT_EQ(bytes_read, data.size()); return ret; }); @@ -607,11 +612,11 @@ TEST_F(file_manager_test, upload_occurs_after_write_if_fully_downloaded) { }); std::size_t bytes_written{}; data_buffer data = {0, 1, 2}; - EXPECT_EQ(api_error::success, f->write(0u, data, bytes_written)); + EXPECT_EQ(api_error::success, open_file->write(0u, data, bytes_written)); EXPECT_EQ(std::size_t(3u), bytes_written); - f.reset(); + open_file.reset(); - ec.wait_for_empty(); + capture.wait_for_empty(); EXPECT_CALL(mp, upload_file("/test_write_full_download.txt", source_path, _)) .WillOnce(Return(api_error::success)); @@ -621,16 +626,16 @@ TEST_F(file_manager_test, upload_occurs_after_write_if_fully_downloaded) { "file_upload_queued", "file_upload_completed", }); - fm.close(handle); + mgr.close(handle); ec2.wait_for_empty(); - EXPECT_EQ(std::size_t(0U), fm.get_open_file_count()); - EXPECT_EQ(std::size_t(0U), fm.get_open_handle_count()); + EXPECT_EQ(std::size_t(0U), mgr.get_open_file_count()); + EXPECT_EQ(std::size_t(0U), mgr.get_open_handle_count()); - fm.stop(); + mgr.stop(); - nf.close(); + file.close(); polling::instance().stop(); } @@ -638,8 +643,8 @@ TEST_F(file_manager_test, upload_occurs_after_write_if_fully_downloaded) { TEST_F(file_manager_test, can_evict_file) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - file_manager fm(*cfg, mp); - fm.start(); + file_manager mgr(*cfg, mp); + mgr.start(); event_capture capture({ "filesystem_item_opened", @@ -649,17 +654,17 @@ TEST_F(file_manager_test, can_evict_file) { "file_upload_completed", }); - const auto source_path = utils::path::combine(cfg->get_cache_directory(), - {utils::create_uuid_string()}); + auto source_path = utils::path::combine(cfg->get_cache_directory(), + {utils::create_uuid_string()}); - const auto now = utils::time::get_time_now(); + auto now = utils::time::get_time_now(); auto meta = create_meta_attributes(now, FILE_ATTRIBUTE_ARCHIVE, now + 1u, now + 2u, false, 1, "key", 2, now + 3u, 3u, 4u, 0u, source_path, 10, now + 4u); std::uint64_t handle{}; { - std::shared_ptr f; + std::shared_ptr open_file; EXPECT_CALL(mp, create_file("/test_evict.txt", meta)) .WillOnce(Return(api_error::success)); @@ -678,10 +683,10 @@ TEST_F(file_manager_test, can_evict_file) { #if defined(_WIN32) EXPECT_EQ(api_error::success, - fm.create("/test_evict.txt", meta, {}, handle, f)); + mgr.create("/test_evict.txt", meta, {}, handle, open_file)); #else EXPECT_EQ(api_error::success, - fm.create("/test_evict.txt", meta, O_RDWR, handle, f)); + mgr.create("/test_evict.txt", meta, O_RDWR, handle, open_file)); #endif EXPECT_CALL(mp, set_item_meta("/test_evict.txt", _)) .Times(2) @@ -690,18 +695,18 @@ TEST_F(file_manager_test, can_evict_file) { data_buffer data{{0, 1, 1}}; std::size_t bytes_written{}; - EXPECT_EQ(api_error::success, f->write(0U, data, bytes_written)); + EXPECT_EQ(api_error::success, open_file->write(0U, data, bytes_written)); auto opt_size = utils::file::file{source_path}.size(); EXPECT_TRUE(opt_size.has_value()); EXPECT_EQ(static_cast(data.size()), opt_size.value()); } - fm.close(handle); + mgr.close(handle); capture.wait_for_empty(); EXPECT_TRUE(utils::retry_action( - [&fm]() -> bool { return not fm.is_processing("/test_evict.txt"); })); + [&mgr]() -> bool { return not mgr.is_processing("/test_evict.txt"); })); EXPECT_CALL(mp, get_item_meta(_, META_SOURCE, _)) .WillOnce([&source_path](const std::string &api_path, @@ -720,15 +725,15 @@ TEST_F(file_manager_test, can_evict_file) { value = "0"; return api_error::success; }); - EXPECT_TRUE(fm.evict_file("/test_evict.txt")); + EXPECT_TRUE(mgr.evict_file("/test_evict.txt")); EXPECT_FALSE(utils::file::file(source_path).exists()); - fm.stop(); + mgr.stop(); } TEST_F(file_manager_test, evict_file_fails_if_file_is_pinned) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - file_manager fm(*cfg, mp); + file_manager mgr(*cfg, mp); EXPECT_CALL(mp, get_item_meta(_, META_PINNED, _)) .WillOnce([](const std::string &api_path, const std::string &key, @@ -739,18 +744,18 @@ TEST_F(file_manager_test, evict_file_fails_if_file_is_pinned) { return api_error::success; }); - EXPECT_FALSE(fm.evict_file("/test_open.txt")); + EXPECT_FALSE(mgr.evict_file("/test_open.txt")); } TEST_F(file_manager_test, evict_file_fails_if_provider_is_read_only) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(true)); - file_manager fm(*cfg, mp); - EXPECT_FALSE(fm.evict_file("/test.txt")); + file_manager mgr(*cfg, mp); + EXPECT_FALSE(mgr.evict_file("/test.txt")); } TEST_F(file_manager_test, evict_file_fails_if_file_is_open) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - file_manager fm(*cfg, mp); + file_manager mgr(*cfg, mp); EXPECT_CALL(mp, get_filesystem_item) .WillOnce([](const std::string &api_path, bool directory, @@ -774,24 +779,24 @@ TEST_F(file_manager_test, evict_file_fails_if_file_is_open) { }); std::uint64_t handle{}; - std::shared_ptr f{}; + std::shared_ptr open_file{}; #if defined(_WIN32) EXPECT_EQ(api_error::success, - fm.open("/test_open.txt", false, {}, handle, f)); + mgr.open("/test_open.txt", false, {}, handle, open_file)); #else EXPECT_EQ(api_error::success, - fm.open("/test_open.txt", false, O_RDWR, handle, f)); + mgr.open("/test_open.txt", false, O_RDWR, handle, open_file)); #endif - EXPECT_FALSE(fm.evict_file("/test_open.txt")); + EXPECT_FALSE(mgr.evict_file("/test_open.txt")); - fm.close(handle); + mgr.close(handle); } TEST_F(file_manager_test, evict_file_fails_if_unable_to_get_source_path_from_item_meta) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - file_manager fm(*cfg, mp); + file_manager mgr(*cfg, mp); EXPECT_CALL(mp, get_item_meta(_, META_SOURCE, _)) .WillOnce([](const std::string &api_path, const std::string &key, @@ -810,12 +815,12 @@ TEST_F(file_manager_test, return api_error::success; }); - EXPECT_FALSE(fm.evict_file("/test_open.txt")); + EXPECT_FALSE(mgr.evict_file("/test_open.txt")); } TEST_F(file_manager_test, evict_file_fails_if_source_path_is_empty) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - file_manager fm(*cfg, mp); + file_manager mgr(*cfg, mp); EXPECT_CALL(mp, get_item_meta(_, META_SOURCE, _)) .WillOnce([](const std::string &api_path, const std::string &key, @@ -834,14 +839,14 @@ TEST_F(file_manager_test, evict_file_fails_if_source_path_is_empty) { return api_error::success; }); - EXPECT_FALSE(fm.evict_file("/test_open.txt")); + EXPECT_FALSE(mgr.evict_file("/test_open.txt")); } TEST_F(file_manager_test, evict_file_fails_if_file_is_uploading) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - file_manager fm(*cfg, mp); - fm.start(); + file_manager mgr(*cfg, mp); + mgr.start(); event_capture capture({ "filesystem_item_opened", @@ -851,17 +856,17 @@ TEST_F(file_manager_test, evict_file_fails_if_file_is_uploading) { "file_upload_completed", }); - const auto source_path = utils::path::combine(cfg->get_cache_directory(), - {utils::create_uuid_string()}); + auto source_path = utils::path::combine(cfg->get_cache_directory(), + {utils::create_uuid_string()}); - const auto now = utils::time::get_time_now(); + auto now = utils::time::get_time_now(); auto meta = create_meta_attributes(now, FILE_ATTRIBUTE_ARCHIVE, now + 1u, now + 2u, false, 1, "", 2, now + 3u, 3u, 4u, 0u, source_path, 10, now + 4u); std::uint64_t handle{}; { - std::shared_ptr f; + std::shared_ptr open_file; EXPECT_CALL(mp, create_file("/test_evict.txt", meta)) .WillOnce(Return(api_error::success)); @@ -880,10 +885,10 @@ TEST_F(file_manager_test, evict_file_fails_if_file_is_uploading) { #if defined(_WIN32) EXPECT_EQ(api_error::success, - fm.create("/test_evict.txt", meta, {}, handle, f)); + mgr.create("/test_evict.txt", meta, {}, handle, open_file)); #else EXPECT_EQ(api_error::success, - fm.create("/test_evict.txt", meta, O_RDWR, handle, f)); + mgr.create("/test_evict.txt", meta, O_RDWR, handle, open_file)); #endif EXPECT_CALL(mp, set_item_meta("/test_evict.txt", _)) .Times(2) @@ -900,45 +905,47 @@ TEST_F(file_manager_test, evict_file_fails_if_file_is_uploading) { data_buffer data{{0, 1, 1}}; std::size_t bytes_written{}; - EXPECT_EQ(api_error::success, f->write(0U, data, bytes_written)); + EXPECT_EQ(api_error::success, open_file->write(0U, data, bytes_written)); auto opt_size = utils::file::file{source_path}.size(); EXPECT_TRUE(opt_size.has_value()); EXPECT_EQ(static_cast(data.size()), opt_size.value()); - fm.close(handle); + mgr.close(handle); EXPECT_TRUE(utils::retry_action( - [&fm]() -> bool { return fm.is_processing("/test_evict.txt"); })); - EXPECT_FALSE(fm.evict_file("/test_evict.txt")); + [&mgr]() -> bool { return mgr.is_processing("/test_evict.txt"); })); + EXPECT_FALSE(mgr.evict_file("/test_evict.txt")); } capture.wait_for_empty(); EXPECT_TRUE(utils::file::file(source_path).exists()); - fm.stop(); + mgr.stop(); } TEST_F(file_manager_test, evict_file_fails_if_file_is_in_upload_queue) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - file_manager fm(*cfg, mp); + file_manager mgr(*cfg, mp); - mock_open_file of{}; - EXPECT_CALL(of, is_directory).WillRepeatedly(Return(false)); - EXPECT_CALL(of, get_api_path).WillRepeatedly(Return("/test_evict.txt")); - EXPECT_CALL(of, get_source_path).WillRepeatedly(Return("/test_evict.src")); - fm.queue_upload(of); + mock_open_file open_file{}; + EXPECT_CALL(open_file, is_directory).WillRepeatedly(Return(false)); + EXPECT_CALL(open_file, get_api_path) + .WillRepeatedly(Return("/test_evict.txt")); + EXPECT_CALL(open_file, get_source_path) + .WillRepeatedly(Return("/test_evict.src")); + mgr.queue_upload(open_file); - EXPECT_TRUE(fm.is_processing("/test_evict.txt")); - EXPECT_FALSE(fm.evict_file("/test_evict.txt")); + EXPECT_TRUE(mgr.is_processing("/test_evict.txt")); + EXPECT_FALSE(mgr.evict_file("/test_evict.txt")); } TEST_F(file_manager_test, evict_file_fails_if_file_is_modified) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - file_manager fm(*cfg, mp); + file_manager mgr(*cfg, mp); EXPECT_CALL(mp, get_filesystem_item) .WillOnce([](const std::string &api_path, bool directory, filesystem_item &fsi) -> api_error { @@ -952,29 +959,29 @@ TEST_F(file_manager_test, evict_file_fails_if_file_is_modified) { return api_error::success; }); - auto of = std::make_shared(); - EXPECT_CALL(*of, is_directory).WillOnce(Return(false)); - EXPECT_CALL(*of, add).WillOnce(Return()); - EXPECT_CALL(*of, get_api_path).WillRepeatedly(Return("/test_evict.txt")); - EXPECT_CALL(*of, get_source_path).WillRepeatedly(Return("/test_evict.src")); - EXPECT_CALL(*of, is_modified).Times(2).WillRepeatedly(Return(true)); + auto file = std::make_shared(); + EXPECT_CALL(*file, is_directory).WillOnce(Return(false)); + EXPECT_CALL(*file, add).WillOnce(Return()); + EXPECT_CALL(*file, get_api_path).WillRepeatedly(Return("/test_evict.txt")); + EXPECT_CALL(*file, get_source_path).WillRepeatedly(Return("/test_evict.src")); + EXPECT_CALL(*file, is_modified).Times(2).WillRepeatedly(Return(true)); std::uint64_t handle{}; - std::shared_ptr f; + std::shared_ptr open_file; #if defined(_WIN32) - EXPECT_EQ(api_error::success, fm.open(of, {}, handle, f)); + EXPECT_EQ(api_error::success, mgr.open(of, {}, handle, open_file)); #else - EXPECT_EQ(api_error::success, fm.open(of, O_RDWR, handle, f)); + EXPECT_EQ(api_error::success, mgr.open(file, O_RDWR, handle, open_file)); #endif - EXPECT_TRUE(fm.is_processing("/test_evict.txt")); - EXPECT_FALSE(fm.evict_file("/test_evict.txt")); + EXPECT_TRUE(mgr.is_processing("/test_evict.txt")); + EXPECT_FALSE(mgr.evict_file("/test_evict.txt")); } TEST_F(file_manager_test, evict_file_fails_if_file_is_not_complete) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - file_manager fm(*cfg, mp); + file_manager mgr(*cfg, mp); EXPECT_CALL(mp, get_filesystem_item) .WillOnce([](const std::string &api_path, bool directory, filesystem_item &fsi) -> api_error { @@ -987,32 +994,32 @@ TEST_F(file_manager_test, evict_file_fails_if_file_is_not_complete) { return api_error::success; }); - auto of = std::make_shared(); - EXPECT_CALL(*of, is_directory).WillOnce(Return(false)); - EXPECT_CALL(*of, add).WillOnce(Return()); - EXPECT_CALL(*of, get_api_path).WillRepeatedly(Return("/test_evict.txt")); - EXPECT_CALL(*of, get_source_path).WillRepeatedly(Return("/test_evict.src")); - EXPECT_CALL(*of, is_modified).Times(2).WillRepeatedly(Return(false)); - EXPECT_CALL(*of, is_complete).Times(2).WillRepeatedly(Return(false)); + auto file = std::make_shared(); + EXPECT_CALL(*file, is_directory).WillOnce(Return(false)); + EXPECT_CALL(*file, add).WillOnce(Return()); + EXPECT_CALL(*file, get_api_path).WillRepeatedly(Return("/test_evict.txt")); + EXPECT_CALL(*file, get_source_path).WillRepeatedly(Return("/test_evict.src")); + EXPECT_CALL(*file, is_modified).Times(2).WillRepeatedly(Return(false)); + EXPECT_CALL(*file, is_complete).Times(2).WillRepeatedly(Return(false)); EXPECT_CALL(mp, set_item_meta("/test_evict.txt", META_SOURCE, _)) .WillOnce(Return(api_error::success)); std::uint64_t handle{}; - std::shared_ptr f; + std::shared_ptr open_file; #if defined(_WIN32) - EXPECT_EQ(api_error::success, fm.open(of, {}, handle, f)); + EXPECT_EQ(api_error::success, mgr.open(of, {}, handle, open_file)); #else - EXPECT_EQ(api_error::success, fm.open(of, O_RDWR, handle, f)); + EXPECT_EQ(api_error::success, mgr.open(file, O_RDWR, handle, open_file)); #endif - EXPECT_TRUE(fm.is_processing("/test_evict.txt")); - EXPECT_FALSE(fm.evict_file("/test_evict.txt")); + EXPECT_TRUE(mgr.is_processing("/test_evict.txt")); + EXPECT_FALSE(mgr.evict_file("/test_evict.txt")); } TEST_F(file_manager_test, can_get_directory_items) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - file_manager fm(*cfg, mp); + file_manager mgr(*cfg, mp); EXPECT_CALL(mp, get_directory_items) .WillOnce([](const std::string &api_path, directory_item_list &list) -> api_error { @@ -1029,74 +1036,74 @@ TEST_F(file_manager_test, can_get_directory_items) { }); return api_error::success; }); - auto list = fm.get_directory_items("/"); + auto list = mgr.get_directory_items("/"); EXPECT_EQ(std::size_t(2U), list.size()); } TEST_F(file_manager_test, file_is_not_opened_if_provider_create_file_fails) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - const auto now = utils::time::get_time_now(); + auto now = utils::time::get_time_now(); auto meta = create_meta_attributes(now, FILE_ATTRIBUTE_ARCHIVE, now + 1u, now + 2u, false, 1, "", 2, now + 3u, 3u, 4u, 0u, "/test_create.src", 10, now + 4u); - file_manager fm(*cfg, mp); + file_manager mgr(*cfg, mp); EXPECT_CALL(mp, create_file("/test_create.txt", meta)) .WillOnce(Return(api_error::error)); std::uint64_t handle{}; - std::shared_ptr f; + std::shared_ptr open_file; #if defined(_WIN32) EXPECT_EQ(api_error::error, - fm.create("/test_create.txt", meta, {}, handle, f)); + mgr.create("/test_create.txt", meta, {}, handle, open_file)); #else EXPECT_EQ(api_error::error, - fm.create("/test_create.txt", meta, O_RDWR, handle, f)); + mgr.create("/test_create.txt", meta, O_RDWR, handle, open_file)); #endif - EXPECT_FALSE(f); - EXPECT_EQ(std::size_t(0U), fm.get_open_file_count()); + EXPECT_FALSE(open_file); + EXPECT_EQ(std::size_t(0U), mgr.get_open_file_count()); } TEST_F(file_manager_test, create_fails_if_provider_create_is_unsuccessful) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - file_manager fm(*cfg, mp); + file_manager mgr(*cfg, mp); EXPECT_CALL(mp, create_file("/test_create.txt", _)) .WillOnce(Return(api_error::error)); std::uint64_t handle{}; - std::shared_ptr f{}; + std::shared_ptr open_file{}; api_meta_map meta{}; #if defined(_WIN32) EXPECT_EQ(api_error::error, - fm.create("/test_create.txt", meta, {}, handle, f)); + mgr.create("/test_create.txt", meta, {}, handle, open_file)); #else EXPECT_EQ(api_error::error, - fm.create("/test_create.txt", meta, O_RDWR, handle, f)); + mgr.create("/test_create.txt", meta, O_RDWR, handle, open_file)); #endif - EXPECT_EQ(std::size_t(0U), fm.get_open_file_count()); + EXPECT_EQ(std::size_t(0U), mgr.get_open_file_count()); } TEST_F(file_manager_test, get_open_file_fails_if_file_is_not_open) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - file_manager fm(*cfg, mp); + file_manager mgr(*cfg, mp); - std::shared_ptr f{}; - EXPECT_FALSE(fm.get_open_file(0U, true, f)); - EXPECT_FALSE(f); + std::shared_ptr open_file{}; + EXPECT_FALSE(mgr.get_open_file(0U, true, open_file)); + EXPECT_FALSE(open_file); - EXPECT_FALSE(fm.get_open_file(0U, false, f)); - EXPECT_FALSE(f); + EXPECT_FALSE(mgr.get_open_file(0U, false, open_file)); + EXPECT_FALSE(open_file); } TEST_F(file_manager_test, get_open_file_promotes_non_writeable_file_if_writeable_is_specified) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - file_manager fm(*cfg, mp); + file_manager mgr(*cfg, mp); auto non_writeable = std::make_shared(); EXPECT_CALL(*non_writeable, is_directory).WillOnce(Return(false)); @@ -1134,9 +1141,9 @@ TEST_F(file_manager_test, }); std::uint64_t handle{}; - std::shared_ptr f{}; + std::shared_ptr open_file{}; #if defined(_WIN32) - EXPECT_EQ(api_error::success, fm.open(non_writeable, {}, handle, f)); + EXPECT_EQ(api_error::success, mgr.open(non_writeable, {}, handle, open_file)); EXPECT_CALL(*non_writeable, get_open_data()) .WillOnce([&handle]() -> std::map & { static std::map map; @@ -1144,7 +1151,8 @@ TEST_F(file_manager_test, return map; }); #else // !defined(_WIN32) - EXPECT_EQ(api_error::success, fm.open(non_writeable, O_RDWR, handle, f)); + EXPECT_EQ(api_error::success, + mgr.open(non_writeable, O_RDWR, handle, open_file)); EXPECT_CALL(*non_writeable, get_open_data()) .WillOnce([&handle]() -> std::map & { static std::map map; @@ -1159,41 +1167,41 @@ TEST_F(file_manager_test, EXPECT_CALL(*non_writeable, has_handle(1)).WillOnce([]() -> bool { return true; }); - EXPECT_TRUE(fm.get_open_file(handle, true, f)); - EXPECT_NE(non_writeable.get(), f.get()); - EXPECT_EQ(std::size_t(1U), fm.get_open_file_count()); + EXPECT_TRUE(mgr.get_open_file(handle, true, open_file)); + EXPECT_NE(non_writeable.get(), open_file.get()); + EXPECT_EQ(std::size_t(1U), mgr.get_open_file_count()); - std::shared_ptr f2{}; - EXPECT_TRUE(fm.get_open_file(handle, false, f2)); - EXPECT_EQ(f.get(), f2.get()); - EXPECT_EQ(std::size_t(1U), fm.get_open_file_count()); + std::shared_ptr file2{}; + EXPECT_TRUE(mgr.get_open_file(handle, false, file2)); + EXPECT_EQ(open_file.get(), file2.get()); + EXPECT_EQ(std::size_t(1U), mgr.get_open_file_count()); } TEST_F(file_manager_test, open_file_fails_if_file_is_not_found) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - file_manager fm(*cfg, mp); + file_manager mgr(*cfg, mp); - std::shared_ptr f{}; - EXPECT_FALSE(fm.get_open_file(1U, true, f)); - EXPECT_EQ(std::size_t(0U), fm.get_open_file_count()); - EXPECT_FALSE(f); + std::shared_ptr open_file{}; + EXPECT_FALSE(mgr.get_open_file(1U, true, open_file)); + EXPECT_EQ(std::size_t(0U), mgr.get_open_file_count()); + EXPECT_FALSE(open_file); - EXPECT_FALSE(fm.get_open_file(1U, false, f)); - EXPECT_FALSE(f); - EXPECT_EQ(std::size_t(0U), fm.get_open_file_count()); + EXPECT_FALSE(mgr.get_open_file(1U, false, open_file)); + EXPECT_FALSE(open_file); + EXPECT_EQ(std::size_t(0U), mgr.get_open_file_count()); } TEST_F(file_manager_test, open_file_fails_if_provider_get_filesystem_item_fails) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - file_manager fm(*cfg, mp); + file_manager mgr(*cfg, mp); - auto of = std::make_shared(); - EXPECT_CALL(*of, is_directory).WillRepeatedly(Return(false)); - EXPECT_CALL(*of, get_api_path).WillRepeatedly(Return("/test_open.txt")); - EXPECT_CALL(*of, get_source_path).WillRepeatedly(Return("/test_open.src")); + auto file = std::make_shared(); + EXPECT_CALL(*file, is_directory).WillRepeatedly(Return(false)); + EXPECT_CALL(*file, get_api_path).WillRepeatedly(Return("/test_open.txt")); + EXPECT_CALL(*file, get_source_path).WillRepeatedly(Return("/test_open.src")); EXPECT_CALL(mp, get_filesystem_item) .WillOnce([](const std::string &api_path, bool directory, @@ -1204,30 +1212,30 @@ TEST_F(file_manager_test, }); std::uint64_t handle{}; - std::shared_ptr f{}; + std::shared_ptr open_file{}; #if defined(_WIN32) - EXPECT_EQ(api_error::error, fm.open(of, {}, handle, f)); + EXPECT_EQ(api_error::error, mgr.open(of, {}, handle, open_file)); #else - EXPECT_EQ(api_error::error, fm.open(of, O_RDWR, handle, f)); + EXPECT_EQ(api_error::error, mgr.open(file, O_RDWR, handle, open_file)); #endif - EXPECT_FALSE(fm.get_open_file(1U, true, f)); - EXPECT_EQ(std::size_t(0U), fm.get_open_file_count()); - EXPECT_FALSE(f); + EXPECT_FALSE(mgr.get_open_file(1U, true, open_file)); + EXPECT_EQ(std::size_t(0U), mgr.get_open_file_count()); + EXPECT_FALSE(open_file); - EXPECT_FALSE(fm.get_open_file(1U, false, f)); - EXPECT_FALSE(f); - EXPECT_EQ(std::size_t(0U), fm.get_open_file_count()); + EXPECT_FALSE(mgr.get_open_file(1U, false, open_file)); + EXPECT_FALSE(open_file); + EXPECT_EQ(std::size_t(0U), mgr.get_open_file_count()); } TEST_F(file_manager_test, open_file_fails_if_provider_set_item_meta_fails) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - file_manager fm(*cfg, mp); + file_manager mgr(*cfg, mp); - auto of = std::make_shared(); - EXPECT_CALL(*of, is_directory).WillRepeatedly(Return(false)); - EXPECT_CALL(*of, get_api_path).WillRepeatedly(Return("/test_open.txt")); - EXPECT_CALL(*of, get_source_path).WillRepeatedly(Return("/test_open.src")); + auto file = std::make_shared(); + EXPECT_CALL(*file, is_directory).WillRepeatedly(Return(false)); + EXPECT_CALL(*file, get_api_path).WillRepeatedly(Return("/test_open.txt")); + EXPECT_CALL(*file, get_source_path).WillRepeatedly(Return("/test_open.src")); EXPECT_CALL(mp, get_filesystem_item) .WillOnce([](const std::string &api_path, bool directory, @@ -1245,32 +1253,32 @@ TEST_F(file_manager_test, open_file_fails_if_provider_set_item_meta_fails) { .WillOnce(Return(api_error::error)); std::uint64_t handle{}; - std::shared_ptr f{}; + std::shared_ptr open_file{}; #if defined(_WIN32) - EXPECT_EQ(api_error::error, fm.open(of, {}, handle, f)); + EXPECT_EQ(api_error::error, mgr.open(of, {}, handle, open_file)); #else - EXPECT_EQ(api_error::error, fm.open(of, O_RDWR, handle, f)); + EXPECT_EQ(api_error::error, mgr.open(file, O_RDWR, handle, open_file)); #endif - EXPECT_FALSE(fm.get_open_file(1U, true, f)); - EXPECT_EQ(std::size_t(0U), fm.get_open_file_count()); - EXPECT_FALSE(f); + EXPECT_FALSE(mgr.get_open_file(1U, true, open_file)); + EXPECT_EQ(std::size_t(0U), mgr.get_open_file_count()); + EXPECT_FALSE(open_file); - EXPECT_FALSE(fm.get_open_file(1U, false, f)); - EXPECT_FALSE(f); - EXPECT_EQ(std::size_t(0U), fm.get_open_file_count()); + EXPECT_FALSE(mgr.get_open_file(1U, false, open_file)); + EXPECT_FALSE(open_file); + EXPECT_EQ(std::size_t(0U), mgr.get_open_file_count()); } TEST_F(file_manager_test, open_file_creates_source_path_if_empty) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - file_manager fm(*cfg, mp); + file_manager mgr(*cfg, mp); - auto of = std::make_shared(); - EXPECT_CALL(*of, add).WillOnce(Return()); - EXPECT_CALL(*of, is_directory).WillRepeatedly(Return(false)); - EXPECT_CALL(*of, is_write_supported).WillRepeatedly(Return(true)); - EXPECT_CALL(*of, get_api_path).WillRepeatedly(Return("/test_open.txt")); - EXPECT_CALL(*of, get_source_path).WillRepeatedly(Return("")); + auto file = std::make_shared(); + EXPECT_CALL(*file, add).WillOnce(Return()); + EXPECT_CALL(*file, is_directory).WillRepeatedly(Return(false)); + EXPECT_CALL(*file, is_write_supported).WillRepeatedly(Return(true)); + EXPECT_CALL(*file, get_api_path).WillRepeatedly(Return("/test_open.txt")); + EXPECT_CALL(*file, get_source_path).WillRepeatedly(Return("")); EXPECT_CALL(mp, get_filesystem_item) .WillOnce([](const std::string &api_path, bool directory, @@ -1294,36 +1302,36 @@ TEST_F(file_manager_test, open_file_creates_source_path_if_empty) { }); std::uint64_t handle{}; - std::shared_ptr f{}; + std::shared_ptr open_file{}; #if defined(_WIN32) - EXPECT_EQ(api_error::success, fm.open(of, {}, handle, f)); + EXPECT_EQ(api_error::success, mgr.open(of, {}, handle, open_file)); #else - EXPECT_EQ(api_error::success, fm.open(of, O_RDWR, handle, f)); + EXPECT_EQ(api_error::success, mgr.open(file, O_RDWR, handle, open_file)); #endif - EXPECT_CALL(*of, has_handle(1)).Times(2).WillRepeatedly([]() -> bool { + EXPECT_CALL(*file, has_handle(1)).Times(2).WillRepeatedly([]() -> bool { return true; }); - EXPECT_TRUE(fm.get_open_file(1U, true, f)); - EXPECT_EQ(std::size_t(1U), fm.get_open_file_count()); - EXPECT_TRUE(f); + EXPECT_TRUE(mgr.get_open_file(1U, true, open_file)); + EXPECT_EQ(std::size_t(1U), mgr.get_open_file_count()); + EXPECT_TRUE(open_file); - EXPECT_TRUE(fm.get_open_file(1U, false, f)); - EXPECT_TRUE(f); - EXPECT_EQ(std::size_t(1U), fm.get_open_file_count()); + EXPECT_TRUE(mgr.get_open_file(1U, false, open_file)); + EXPECT_TRUE(open_file); + EXPECT_EQ(std::size_t(1U), mgr.get_open_file_count()); } TEST_F(file_manager_test, open_file_first_file_handle_is_not_zero) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - file_manager fm(*cfg, mp); + file_manager mgr(*cfg, mp); - auto of = std::make_shared(); - EXPECT_CALL(*of, add).WillOnce(Return()); - EXPECT_CALL(*of, is_directory).WillRepeatedly(Return(false)); - EXPECT_CALL(*of, is_write_supported).WillRepeatedly(Return(true)); - EXPECT_CALL(*of, get_api_path).WillRepeatedly(Return("/test_open.txt")); - EXPECT_CALL(*of, get_source_path).WillRepeatedly(Return("/test_open.src")); + auto file = std::make_shared(); + EXPECT_CALL(*file, add).WillOnce(Return()); + EXPECT_CALL(*file, is_directory).WillRepeatedly(Return(false)); + EXPECT_CALL(*file, is_write_supported).WillRepeatedly(Return(true)); + EXPECT_CALL(*file, get_api_path).WillRepeatedly(Return("/test_open.txt")); + EXPECT_CALL(*file, get_source_path).WillRepeatedly(Return("/test_open.src")); EXPECT_CALL(mp, get_filesystem_item) .WillOnce([](const std::string &api_path, bool directory, @@ -1339,22 +1347,22 @@ TEST_F(file_manager_test, open_file_first_file_handle_is_not_zero) { }); std::uint64_t handle{}; - std::shared_ptr f{}; + std::shared_ptr open_file{}; #if defined(_WIN32) - EXPECT_EQ(api_error::success, fm.open(of, {}, handle, f)); + EXPECT_EQ(api_error::success, mgr.open(of, {}, handle, open_file)); #else - EXPECT_EQ(api_error::success, fm.open(of, O_RDWR, handle, f)); + EXPECT_EQ(api_error::success, mgr.open(file, O_RDWR, handle, open_file)); #endif - EXPECT_CALL(*of, has_handle(1)).WillOnce([]() -> bool { return true; }); + EXPECT_CALL(*file, has_handle(1)).WillOnce([]() -> bool { return true; }); - EXPECT_TRUE(fm.get_open_file(1U, true, f)); + EXPECT_TRUE(mgr.get_open_file(1U, true, open_file)); EXPECT_GT(handle, std::uint64_t(0U)); } TEST_F(file_manager_test, can_remove_file) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - file_manager fm(*cfg, mp); + file_manager mgr(*cfg, mp); { auto file = utils::file::file::open_or_create_file("./test_remove.txt"); @@ -1377,33 +1385,33 @@ TEST_F(file_manager_test, can_remove_file) { EXPECT_CALL(mp, remove_file("/test_remove.txt")) .WillOnce(Return(api_error::success)); - EXPECT_EQ(api_error::success, fm.remove_file("/test_remove.txt")); + EXPECT_EQ(api_error::success, mgr.remove_file("/test_remove.txt")); EXPECT_FALSE(utils::file::file("./test_remove.txt").exists()); } TEST_F(file_manager_test, can_queue_and_remove_upload) { - event_capture ec({ + event_capture capture({ "file_upload_queued", "download_resume_removed", }); EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - file_manager fm(*cfg, mp); + file_manager mgr(*cfg, mp); - mock_open_file of{}; - EXPECT_CALL(of, get_api_path).WillOnce(Return("/test_queue.txt")); - EXPECT_CALL(of, get_source_path).WillOnce(Return("/test_queue.src")); + mock_open_file file{}; + EXPECT_CALL(file, get_api_path).WillOnce(Return("/test_queue.txt")); + EXPECT_CALL(file, get_source_path).WillOnce(Return("/test_queue.src")); - EXPECT_FALSE(fm.is_processing("/test_queue.txt")); - fm.queue_upload(of); - EXPECT_TRUE(fm.is_processing("/test_queue.txt")); + EXPECT_FALSE(mgr.is_processing("/test_queue.txt")); + mgr.queue_upload(file); + EXPECT_TRUE(mgr.is_processing("/test_queue.txt")); - fm.remove_upload("/test_queue.txt"); - EXPECT_FALSE(fm.is_processing("/test_queue.txt")); + mgr.remove_upload("/test_queue.txt"); + EXPECT_FALSE(mgr.is_processing("/test_queue.txt")); - ec.wait_for_empty(); + capture.wait_for_empty(); } TEST_F(file_manager_test, file_is_closed_after_download_timeout) { @@ -1414,19 +1422,19 @@ TEST_F(file_manager_test, file_is_closed_after_download_timeout) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - file_manager fm(*cfg, mp); - fm.start(); + file_manager mgr(*cfg, mp); + mgr.start(); - const auto source_path = utils::path::combine(cfg->get_cache_directory(), - {utils::create_uuid_string()}); + auto source_path = utils::path::combine(cfg->get_cache_directory(), + {utils::create_uuid_string()}); - event_consumer es("item_timeout", [](const event &e) { - const auto &ee = dynamic_cast(e); + event_consumer consumer("item_timeout", [](const event &evt) { + const auto &evt2 = dynamic_cast(evt); EXPECT_STREQ("/test_download_timeout.txt", - ee.get_api_path().get().c_str()); + evt2.get_api_path().get().c_str()); }); - const auto now = utils::time::get_time_now(); + auto now = utils::time::get_time_now(); auto meta = create_meta_attributes( now, FILE_ATTRIBUTE_ARCHIVE, now + 1u, now + 2u, false, 1, "key", 2, now + 3u, 3u, 4u, @@ -1446,16 +1454,16 @@ TEST_F(file_manager_test, file_is_closed_after_download_timeout) { return api_error::success; }); - event_capture ec({"item_timeout"}); + event_capture capture({"item_timeout"}); std::uint64_t handle{}; - std::shared_ptr f; + std::shared_ptr open_file; #if defined(_WIN32) - EXPECT_EQ(api_error::success, - fm.open("/test_download_timeout.txt", false, {}, handle, f)); + EXPECT_EQ(api_error::success, mgr.open("/test_download_timeout.txt", false, + {}, handle, open_file)); #else - EXPECT_EQ(api_error::success, - fm.open("/test_download_timeout.txt", false, O_RDWR, handle, f)); + EXPECT_EQ(api_error::success, mgr.open("/test_download_timeout.txt", false, + O_RDWR, handle, open_file)); #endif EXPECT_CALL(mp, read_file_bytes) @@ -1467,7 +1475,7 @@ TEST_F(file_manager_test, file_is_closed_after_download_timeout) { return api_error::download_stopped; } - if (offset == 0u) { + if (offset == 0U) { return api_error::success; } @@ -1479,18 +1487,18 @@ TEST_F(file_manager_test, file_is_closed_after_download_timeout) { }); data_buffer data{}; - EXPECT_EQ(api_error::success, f->read(1U, 0U, data)); + EXPECT_EQ(api_error::success, open_file->read(1U, 0U, data)); - fm.close(handle); + mgr.close(handle); EXPECT_CALL(mp, set_item_meta("/test_download_timeout.txt", META_SOURCE, _)) .WillOnce(Return(api_error::success)); - EXPECT_EQ(std::size_t(1U), fm.get_open_file_count()); - ec.wait_for_empty(); + EXPECT_EQ(std::size_t(1U), mgr.get_open_file_count()); + capture.wait_for_empty(); - EXPECT_EQ(std::size_t(0U), fm.get_open_file_count()); - fm.stop(); + EXPECT_EQ(std::size_t(0U), mgr.get_open_file_count()); + mgr.stop(); polling::instance().stop(); } @@ -1498,7 +1506,7 @@ TEST_F(file_manager_test, file_is_closed_after_download_timeout) { TEST_F(file_manager_test, remove_file_fails_if_file_does_not_exist) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - file_manager fm(*cfg, mp); + file_manager mgr(*cfg, mp); EXPECT_CALL(mp, get_filesystem_item) .WillOnce([](const std::string &api_path, const bool &directory, @@ -1508,13 +1516,13 @@ TEST_F(file_manager_test, remove_file_fails_if_file_does_not_exist) { return api_error::item_not_found; }); - EXPECT_EQ(api_error::item_not_found, fm.remove_file("/test_remove.txt")); + EXPECT_EQ(api_error::item_not_found, mgr.remove_file("/test_remove.txt")); } TEST_F(file_manager_test, remove_file_fails_if_provider_remove_file_fails) { EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); - file_manager fm(*cfg, mp); + file_manager mgr(*cfg, mp); EXPECT_CALL(mp, get_filesystem_item) .WillOnce([](const std::string &api_path, const bool &directory, @@ -1530,7 +1538,7 @@ TEST_F(file_manager_test, remove_file_fails_if_provider_remove_file_fails) { EXPECT_CALL(mp, remove_file("/test_remove.txt")) .WillOnce(Return(api_error::item_not_found)); - EXPECT_EQ(api_error::item_not_found, fm.remove_file("/test_remove.txt")); + EXPECT_EQ(api_error::item_not_found, mgr.remove_file("/test_remove.txt")); } TEST_F(file_manager_test, @@ -1541,8 +1549,8 @@ TEST_F(file_manager_test, polling::instance().start(cfg.get()); - file_manager fm(*cfg, mp); - fm.start(); + file_manager mgr(*cfg, mp); + mgr.start(); event_capture capture({ "item_timeout", @@ -1555,9 +1563,9 @@ TEST_F(file_manager_test, std::uint64_t handle{}; EXPECT_CALL(mp, upload_file).Times(AnyNumber()); - const auto source_path = utils::path::combine(cfg->get_cache_directory(), - {utils::create_uuid_string()}); - const auto now = utils::time::get_time_now(); + auto source_path = utils::path::combine(cfg->get_cache_directory(), + {utils::create_uuid_string()}); + auto now = utils::time::get_time_now(); auto meta = create_meta_attributes(now, FILE_ATTRIBUTE_ARCHIVE, now + 1U, now + 2U, false, 1U, "key", 2, now + 3U, 3U, 4U, 0U, source_path, 10U, now + 4U); @@ -1591,10 +1599,10 @@ TEST_F(file_manager_test, #if defined(_WIN32) EXPECT_EQ(api_error::success, - fm.create("/test_create.txt", meta, {}, handle, open_file)); + mgr.create("/test_create.txt", meta, {}, handle, open_file)); #else // !defined(_WIN32) EXPECT_EQ(api_error::success, - fm.create("/test_create.txt", meta, O_RDWR, handle, open_file)); + mgr.create("/test_create.txt", meta, O_RDWR, handle, open_file)); #endif // defined(_WIN32) EXPECT_EQ( @@ -1605,11 +1613,11 @@ TEST_F(file_manager_test, EXPECT_TRUE(open_file->get_read_state().all()); } - fm.close(handle); + mgr.close(handle); capture.wait_for_empty(); - fm.stop(); + mgr.stop(); polling::instance().stop(); }