[snapshots] Unit tests

src/platform/backends/shared/base_snapshot.cpp

@@ -60,8 +60,8 @@ QJsonObject read_snapshot_json(const QString& filename)
 
     if (const auto json = QJsonDocument::fromJson(data, &parse_error).object(); parse_error.error)
         throw std::runtime_error{fmt::format("Could not parse snapshot JSON; error: {}; file: {}",
-                                             file.fileName(),
-                                             parse_error.errorString())};
+                                             parse_error.errorString(),
+                                             file.fileName())};
     else if (json.isEmpty())
         throw std::runtime_error{fmt::format("Empty snapshot JSON: {}", file.fileName())};
     else
@@ -124,7 +124,6 @@ mp::BaseSnapshot::BaseSnapshot(const std::string& name,    // NOLINT(modernize-p
       storage_dir{storage_dir},
       captured{captured}
 {
-    assert(index > 0 && "snapshot indices need to start at 1");
     using St = VirtualMachine::State;
     if (state != St::off && state != St::stopped)
         throw std::runtime_error{fmt::format("Unsupported VM state in snapshot: {}", static_cast<int>(state))};
@@ -161,6 +160,7 @@ mp::BaseSnapshot::BaseSnapshot(const std::string& name,
                    vm.instance_directory(),
                    /*captured=*/false}
 {
+    assert(index > 0 && "snapshot indices need to start at 1");
 }
 
 mp::BaseSnapshot::BaseSnapshot(const QString& filename, VirtualMachine& vm)
@@ -238,7 +238,7 @@ auto mp::BaseSnapshot::erase_helper()
     auto deleting_filepath = tmp_dir->filePath(snapshot_filename);
 
     QFile snapshot_file{snapshot_filepath};
-    if (!MP_FILEOPS.rename(snapshot_file, deleting_filepath))
+    if (!MP_FILEOPS.rename(snapshot_file, deleting_filepath) && snapshot_file.exists())
         throw std::runtime_error{
             fmt::format("Failed to move snapshot file to temporary destination: {}", deleting_filepath)};
 

src/platform/backends/shared/base_virtual_machine.cpp

@@ -548,12 +548,12 @@ std::shared_ptr<Snapshot> BaseVirtualMachine::make_specific_snapshot(const std::
                                                                      const VMSpecs& /*specs*/,
                                                                      std::shared_ptr<Snapshot> /*parent*/)
 {
-    throw NotImplementedOnThisBackendException{"Snapshots"};
+    throw NotImplementedOnThisBackendException{"snapshots"};
 }
 
 std::shared_ptr<Snapshot> BaseVirtualMachine::make_specific_snapshot(const QString& /*filename*/)
 {
-    throw NotImplementedOnThisBackendException{"Snapshots"};
+    throw NotImplementedOnThisBackendException{"snapshots"};
 }
 
 } // namespace multipass

tests/CMakeLists.txt

@@ -54,6 +54,7 @@ add_executable(multipass_tests
   temp_file.cpp
   test_alias_dict.cpp
   test_argparser.cpp
+  test_base_snapshot.cpp
   test_base_virtual_machine.cpp
   test_base_virtual_machine_factory.cpp
   test_basic_process.cpp
@@ -80,6 +81,7 @@ add_executable(multipass_tests
   test_image_vault.cpp
   test_instance_settings_handler.cpp
   test_ip_address.cpp
+  test_json_utils.cpp
   test_memory_size.cpp
   test_mock_standard_paths.cpp
   test_new_release_monitor.cpp
@@ -88,6 +90,7 @@ add_executable(multipass_tests
   test_petname.cpp
   test_platform_shared.cpp
   test_private_pass_provider.cpp
+  test_qemu_snapshot.cpp
   test_qemuimg_process_spec.cpp
   test_remote_settings_handler.cpp
   test_setting_specs.cpp

tests/common.h

@@ -62,6 +62,21 @@
 // work around warning: https://github.com/google/googletest/issues/2271#issuecomment-665742471
 #define MP_TYPED_TEST_SUITE(suite_name, types_param) TYPED_TEST_SUITE(suite_name, types_param, )
 
+// Macros to make a mock delegate calls on a base class by default.
+// For example, if `mock_widget` is an object of type `MockWidget` which mocks `Widget`, one can say:
+//     `MP_DELEGATE_MOCK_CALLS_ON_BASE(mock_widget, Widget, render);`
+// This will cause calls to `mock_widget.render()` to delegate on the base implementation in `MockWidget`.
+#define MP_DELEGATE_MOCK_CALLS_ON_BASE(mock, method, BaseT)                                                            \
+    MP_DELEGATE_MOCK_CALLS_ON_BASE_WITH_MATCHERS(mock, method, BaseT, )
+
+// This second form accepts matchers, which are useful to disambiguate overloaded methods. For example:
+//     `MP_DELEGATE_MOCK_CALLS_ON_BASE_WITH_MATCHERS(mock_widget, Widget, render, (A<Canvas>()))`
+// This will redirect the version of `MockWidget::render` that takes one argument of type `Canvas`.
+#define MP_DELEGATE_MOCK_CALLS_ON_BASE_WITH_MATCHERS(mock, method, BaseT, ...)                                         \
+    ON_CALL(mock, method __VA_ARGS__).WillByDefault([&mock](auto&&... args) {                                          \
+        return mock.BaseT::method(std::forward<decltype(args)>(args)...);                                              \
+    })
+
 // Teach GTest to print Qt stuff
 QT_BEGIN_NAMESPACE
 class QString;

tests/mock_snapshot.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef MULTIPASS_MOCK_SNAPSHOT_H
+#define MULTIPASS_MOCK_SNAPSHOT_H
+
+#include "common.h"
+
+#include <multipass/memory_size.h>
+#include <multipass/snapshot.h>
+#include <multipass/vm_mount.h>
+
+namespace mp = multipass;
+
+namespace multipass::test
+{
+struct MockSnapshot : public mp::Snapshot
+{
+    MOCK_METHOD(int, get_index, (), (const, noexcept, override));
+    MOCK_METHOD(std::string, get_name, (), (const, override));
+    MOCK_METHOD(std::string, get_comment, (), (const, override));
+    MOCK_METHOD(QDateTime, get_creation_timestamp, (), (const, noexcept, override));
+    MOCK_METHOD(int, get_num_cores, (), (const, noexcept, override));
+    MOCK_METHOD(mp::MemorySize, get_mem_size, (), (const, noexcept, override));
+    MOCK_METHOD(mp::MemorySize, get_disk_space, (), (const, noexcept, override));
+    MOCK_METHOD(mp::VirtualMachine::State, get_state, (), (const, noexcept, override));
+    MOCK_METHOD((const std::unordered_map<std::string, mp::VMMount>&), get_mounts, (), (const, noexcept, override));
+    MOCK_METHOD(const QJsonObject&, get_metadata, (), (const, noexcept, override));
+    MOCK_METHOD(std::shared_ptr<const Snapshot>, get_parent, (), (const, override));
+    MOCK_METHOD(std::shared_ptr<Snapshot>, get_parent, (), (override));
+    MOCK_METHOD(std::string, get_parents_name, (), (const, override));
+    MOCK_METHOD(int, get_parents_index, (), (const, override));
+    MOCK_METHOD(void, set_name, (const std::string&), (override));
+    MOCK_METHOD(void, set_comment, (const std::string&), (override));
+    MOCK_METHOD(void, set_parent, (std::shared_ptr<Snapshot>), (override));
+    MOCK_METHOD(void, capture, (), (override));
+    MOCK_METHOD(void, erase, (), (override));
+    MOCK_METHOD(void, apply, (), (override));
+};
+} // namespace multipass::test
+
+#endif // MULTIPASS_MOCK_SNAPSHOT_H

tests/mock_virtual_machine.h

@@ -25,6 +25,8 @@
 #include <multipass/mount_handler.h>
 #include <multipass/virtual_machine.h>
 
+#include <memory>
+
 using namespace testing;
 
 namespace multipass
@@ -41,7 +43,7 @@ struct MockVirtualMachineT : public T
 
     template <typename... Args>
     MockVirtualMachineT(std::unique_ptr<TempDir>&& tmp_dir, Args&&... args)
-        : T{std::forward<Args>(args)..., tmp_dir->path()}
+        : T{std::forward<Args>(args)..., tmp_dir->path()}, tmp_dir{std::move(tmp_dir)}
     {
         ON_CALL(*this, current_state()).WillByDefault(Return(multipass::VirtualMachine::State::off));
         ON_CALL(*this, ssh_port()).WillByDefault(Return(42));
@@ -76,7 +78,7 @@ struct MockVirtualMachineT : public T
                 make_native_mount_handler,
                 (const SSHKeyProvider*, const std::string&, const VMMount&),
                 (override));
-    MOCK_METHOD(VirtualMachine::SnapshotVista, view_snapshots, (), (const, override, noexcept));
+    MOCK_METHOD(VirtualMachine::SnapshotVista, view_snapshots, (), (const, override));
     MOCK_METHOD(int, get_num_snapshots, (), (const, override));
     MOCK_METHOD(std::shared_ptr<const Snapshot>, get_snapshot, (const std::string&), (const, override));
     MOCK_METHOD(std::shared_ptr<const Snapshot>, get_snapshot, (int index), (const, override));
@@ -92,6 +94,8 @@ struct MockVirtualMachineT : public T
     MOCK_METHOD(void, load_snapshots, (), (override));
     MOCK_METHOD(std::vector<std::string>, get_childrens_names, (const Snapshot*), (const, override));
     MOCK_METHOD(int, get_snapshot_count, (), (const, override));
+
+    std::unique_ptr<TempDir> tmp_dir;
 };
 
 using MockVirtualMachine = MockVirtualMachineT<>;

tests/qemu/test_qemu_backend.cpp

@@ -20,7 +20,10 @@
 #include "tests/common.h"
 #include "tests/mock_environment_helpers.h"
 #include "tests/mock_process_factory.h"
+#include "tests/mock_snapshot.h"
 #include "tests/mock_status_monitor.h"
+#include "tests/mock_virtual_machine.h"
+#include "tests/path.h"
 #include "tests/stub_process_factory.h"
 #include "tests/stub_ssh_key_provider.h"
 #include "tests/stub_status_monitor.h"
@@ -35,8 +38,10 @@
 #include <multipass/exceptions/start_exception.h>
 #include <multipass/memory_size.h>
 #include <multipass/platform.h>
+#include <multipass/snapshot.h>
 #include <multipass/virtual_machine.h>
 #include <multipass/virtual_machine_description.h>
+#include <multipass/vm_specs.h>
 
 #include <QJsonArray>
 #include <QJsonDocument>
@@ -675,6 +680,63 @@ TEST_F(QemuBackend, ssh_hostname_timeout_throws_and_sets_unknown_state)
     EXPECT_EQ(machine.state, mp::VirtualMachine::State::unknown);
 }
 
+struct PublicSnapshotMakingQemuVM : public mpt::MockVirtualMachineT<mp::QemuVirtualMachine>
+{
+    using mpt::MockVirtualMachineT<mp::QemuVirtualMachine>::MockVirtualMachineT;
+    using mp::QemuVirtualMachine::make_specific_snapshot;
+    using mp::QemuVirtualMachine::require_snapshots_support;
+};
+
+TEST_F(QemuBackend, supportsSnapshots)
+{
+    PublicSnapshotMakingQemuVM vm{"asdf"};
+    EXPECT_NO_THROW(vm.require_snapshots_support());
+}
+
+TEST_F(QemuBackend, createsQemuSnapshotsFromSpecs)
+{
+    PublicSnapshotMakingQemuVM machine{"mock-qemu-vm"};
+
+    auto snapshot_name = "elvis";
+    auto snapshot_comment = "has left the building";
+    const mp::VMSpecs specs{2,
+                            mp::MemorySize{"3.21G"},
+                            mp::MemorySize{"4.32M"},
+                            "00:00:00:00:00:00",
+                            {},
+                            "asdf",
+                            mp::VirtualMachine::State::stopped,
+                            {},
+                            false,
+                            {},
+                            {}};
+    auto snapshot = machine.make_specific_snapshot(snapshot_name, snapshot_comment, specs, nullptr);
+    EXPECT_EQ(snapshot->get_name(), snapshot_name);
+    EXPECT_EQ(snapshot->get_comment(), snapshot_comment);
+    EXPECT_EQ(snapshot->get_num_cores(), specs.num_cores);
+    EXPECT_EQ(snapshot->get_mem_size(), specs.mem_size);
+    EXPECT_EQ(snapshot->get_disk_space(), specs.disk_space);
+    EXPECT_EQ(snapshot->get_state(), specs.state);
+    EXPECT_EQ(snapshot->get_parent(), nullptr);
+}
+
+TEST_F(QemuBackend, createsQemuSnapshotsFromJsonFile)
+{
+    PublicSnapshotMakingQemuVM machine{"mock-qemu-vm"};
+
+    const auto parent = std::make_shared<mpt::MockSnapshot>();
+    EXPECT_CALL(machine, get_snapshot(2)).WillOnce(Return(parent));
+
+    auto snapshot = machine.make_specific_snapshot(mpt::test_data_path_for("test_snapshot.json"));
+    EXPECT_EQ(snapshot->get_name(), "snapshot3");
+    EXPECT_EQ(snapshot->get_comment(), "A comment");
+    EXPECT_EQ(snapshot->get_num_cores(), 1);
+    EXPECT_EQ(snapshot->get_mem_size(), mp::MemorySize{"1G"});
+    EXPECT_EQ(snapshot->get_disk_space(), mp::MemorySize{"5G"});
+    EXPECT_EQ(snapshot->get_state(), mp::VirtualMachine::State::off);
+    EXPECT_EQ(snapshot->get_parent(), parent);
+}
+
 TEST_F(QemuBackend, lists_no_networks)
 {
     EXPECT_CALL(*mock_qemu_platform_factory, make_qemu_platform(_)).WillOnce([this](auto...) {

tests/stub_virtual_machine.h

@@ -38,7 +38,7 @@ struct StubVirtualMachine final : public multipass::VirtualMachine
     {
     }
 
-    StubVirtualMachine(const std::string& name, std::unique_ptr<TempDir>&& tmp_dir)
+    StubVirtualMachine(const std::string& name, std::unique_ptr<TempDir> tmp_dir)
         : VirtualMachine{name, tmp_dir->path()}, tmp_dir{std::move(tmp_dir)}
     {
     }

tests/stub_virtual_machine_factory.h

@@ -34,8 +34,8 @@ struct StubVirtualMachineFactory : public multipass::BaseVirtualMachineFactory
     {
     }
 
-    StubVirtualMachineFactory(std::unique_ptr<TempDir>&& tmp_dir)
-        : mp::BaseVirtualMachineFactory{tmp_dir->path()}, tmp_dir{std::move(tmp_dir)}
+    StubVirtualMachineFactory(std::unique_ptr<TempDir> tmp_dir)
+        : multipass::BaseVirtualMachineFactory{tmp_dir->path()}, tmp_dir{std::move(tmp_dir)}
     {
     }