add backups integration tests

Author: yungwine

modules/backups.py

@@ -2,17 +2,18 @@
 import shutil
 import subprocess
 import time
+import typing
 
 from modules.module import MtcModule
-from mypylib.mypylib import color_print, ip2int, run_as_root, parse, MyPyClass
+from mypylib.mypylib import color_print, ip2int, run_as_root, parse
 from mytoncore.utils import get_package_resource_path
 from mytonctrl.utils import get_current_user, pop_user_from_args
 from mytoninstaller.config import get_own_ip
 
 
 class BackupModule(MtcModule):
 
-    def create_keyring(self, dir_name):
+    def create_keyring(self, dir_name: str):
         keyring_dir = dir_name + '/keyring'
         self.ton.validatorConsole.Run(f'exportallprivatekeys {keyring_dir}')
 
@@ -34,10 +35,10 @@ def run_create_backup(args, user: str = None):
         with get_package_resource_path('mytonctrl', 'scripts/create_backup.sh') as backup_script_path:
             return subprocess.run(["bash", backup_script_path, "-u", user] + args, timeout=5)
 
-    def create_backup(self, args):
+    def create_backup(self, args: list) -> typing.Union[int, None]:
         if len(args) > 3:
             color_print("{red}Bad args. Usage:{endc} create_backup [filename] [-u <user>]")
-            return
+            return None
         tmp_dir = self.create_tmp_ton_dir()
         command_args = ["-m", self.ton.local.buffer.my_work_dir, "-t", tmp_dir]
         user = pop_user_from_args(args)
@@ -51,7 +52,6 @@ def create_backup(self, args):
             color_print("create_backup - {red}Error{endc}")
         shutil.rmtree(tmp_dir)
         return process.returncode
-    # end define
 
     @staticmethod
     def run_restore_backup(args, user: str = None):
@@ -94,7 +94,6 @@ def restore_backup(self, args):
             self.local.exit()
         else:
             color_print("restore_backup - {red}Error{endc}")
-    # end define
 
     def add_console_commands(self, console):
         console.AddItem("create_backup", self.create_backup, self.local.translate("create_backup_cmd"))

tests/conftest.py

@@ -23,12 +23,12 @@ def get_my_work_dir(self):
     def get_my_temp_dir(self):
         return ensure_dir(self._temp_dir)
 
-    def write_db(self, data):
-        self.buffer.old_db = Dict(self.db)
-
-    def load_db(self, db_path=False):
-        self.set_default_config()
-        return True
+    # def write_db(self, data):
+    #     self.buffer.old_db = Dict(self.db)
+    #
+    # def load_db(self, db_path=False):
+    #     self.set_default_config()
+    #     return True
 
     def write_log(self):
         pass

tests/integration/test_backup_commands.py

@@ -0,0 +1,157 @@
+import json
+import os
+
+from pytest_mock import MockerFixture
+
+from modules.backups import BackupModule
+from modules import backups as backups_module
+from mypylib.mypylib import MyPyClass
+from mytoncore.mytoncore import MyTonCore
+from pathlib import Path
+
+from mytonctrl.utils import get_current_user
+
+
+def test_create_backup(cli, ton, monkeypatch, tmp_path, mocker: MockerFixture):
+    tmp_dir = tmp_path / "test"
+
+    def create_tmp_ton_dir(_):
+        os.makedirs(tmp_dir)
+        return str(tmp_dir)
+
+    monkeypatch.setattr(BackupModule, "create_tmp_ton_dir", create_tmp_ton_dir)
+
+    fun_args, fun_user = [], None
+    return_code = 0
+
+    def run_create_backup(_, args: list, user: str):
+        nonlocal fun_args, fun_user, return_code
+        fun_args = args
+        fun_user = user
+        mock = mocker.Mock()
+        mock.returncode = return_code
+        return mock
+
+    monkeypatch.setattr(BackupModule, "run_create_backup", run_create_backup)
+
+    output = cli.execute("create_backup", no_color=True)
+    assert "create_backup - OK" in output
+    assert fun_user is None
+    assert fun_args == ["-m", ton.local.buffer.my_work_dir, "-t", str(tmp_dir)]
+
+    output = cli.execute("create_backup /to_dir/", no_color=True)
+    assert "create_backup - OK" in output
+    assert fun_user is None
+    assert fun_args == ["-m", ton.local.buffer.my_work_dir, "-t", str(tmp_dir), "-d", "/to_dir/"]
+    assert not Path(tmp_dir).exists()
+
+    output = cli.execute("create_backup /to_dir/ -u yungwine", no_color=True)
+    assert "create_backup - OK" in output
+    assert fun_user == 'yungwine'
+    assert fun_args == ["-m", ton.local.buffer.my_work_dir, "-t", str(tmp_dir), "-d", "/to_dir/"]
+    assert not Path(tmp_dir).exists()
+
+    return_code = 1
+    output = cli.execute("create_backup /to_dir/ -u yungwine", no_color=True)
+    assert "create_backup - Error" in output
+
+
+
+def test_restore_backup(cli, ton, monkeypatch, tmp_path, mocker: MockerFixture):
+    exit_mock = mocker.Mock()
+    monkeypatch.setattr(MyPyClass, "exit", exit_mock)
+
+    create_backup_mock = mocker.Mock()
+    monkeypatch.setattr(BackupModule, "create_backup", create_backup_mock)
+    monkeypatch.setattr("modules.backups.get_own_ip", lambda: "127.0.0.1")
+
+    return_code = 0
+    run_args = []
+    def fake_run_as_root(args: list):
+        nonlocal return_code, run_args
+        run_args = args
+        return return_code
+
+    monkeypatch.setattr(backups_module, "run_as_root", fake_run_as_root)
+
+    run_restore_backup = BackupModule.run_restore_backup
+
+    def fake_run_restore_backup(*args, **kwargs):
+        # really do update db after restore
+        with open(ton.local.buffer.db_path, 'w') as f:
+            f.write(json.dumps(ton.local.db | {"abc": 123}))
+        return run_restore_backup(*args, **kwargs)
+
+    monkeypatch.setattr(BackupModule, "run_restore_backup", staticmethod(fake_run_restore_backup))
+
+    current_user = get_current_user()
+    backup_path = Path(__file__).resolve().parents[2] / 'mytonctrl'/ 'scripts' / 'restore_backup.sh'
+
+    def assert_happy_run_args(outp: str, user: str):
+        assert 'restore_backup - OK' in outp
+        exit_mock.assert_called_once()  # exited after restore_backup
+        assert run_args == ['bash', backup_path, '-u', user, '-m', ton.local.buffer.my_work_dir, '-n',
+                            'backup.tar.gz', '-i', '2130706433']
+        assert ton.local.db.get('abc') == 123  # db updated after restore_backup
+
+    monkeypatch.setattr(MyTonCore, "using_validator", lambda self: False)
+
+    # bad args
+    output = cli.execute("restore_backup", no_color=True)
+    assert "Bad args" in output
+
+    # prompt: abort
+    monkeypatch.setattr("builtins.input", lambda *_: "n")
+    output = cli.execute("restore_backup backup.tar.gz", no_color=True)
+    assert "aborted." in output
+    create_backup_mock.assert_not_called()
+    exit_mock.assert_not_called()
+
+    # happy path
+    monkeypatch.setattr("builtins.input", lambda *_: "y")
+    output = cli.execute("restore_backup backup.tar.gz", no_color=True)
+    assert_happy_run_args(output, current_user)
+    create_backup_mock.assert_called_once()
+
+    # happy path custom user
+    exit_mock.reset_mock()
+    create_backup_mock.reset_mock()
+    output = cli.execute("restore_backup backup.tar.gz -u customuser", no_color=True)
+    create_backup_mock.assert_called_once()
+    assert_happy_run_args(output, 'customuser')
+    create_backup_mock.assert_called_once()
+
+    # skip prompt
+    exit_mock.reset_mock()
+    create_backup_mock.reset_mock()
+    output = cli.execute("restore_backup backup.tar.gz -y", no_color=True)
+    assert_happy_run_args(output, current_user)
+    create_backup_mock.assert_called_once()
+
+    # skip create_backup
+    exit_mock.reset_mock()
+    create_backup_mock.reset_mock()
+    output = cli.execute("restore_backup backup.tar.gz --skip-create-backup -y -u abc", no_color=True)
+    assert_happy_run_args(output, 'abc')
+    create_backup_mock.assert_not_called()
+
+    # check btc teleport installment
+    exit_mock.reset_mock()
+    create_backup_mock.reset_mock()
+    monkeypatch.setattr(MyTonCore, "using_validator", lambda self: True)
+
+    from modules import btc_teleport
+    btc_teleport_mock = mocker.Mock()
+    monkeypatch.setattr(btc_teleport, "BtcTeleportModule", btc_teleport_mock)
+
+    output = cli.execute("restore_backup backup.tar.gz --skip-create-backup -u abc -y", no_color=True)
+
+    assert_happy_run_args(output, 'abc')
+    create_backup_mock.assert_not_called()
+    btc_teleport_mock.assert_called_once()
+    btc_teleport_mock.return_value.init.assert_called_once_with(reinstall=True)
+
+    # Failed to restore backup
+    return_code = 1
+    output = cli.execute("restore_backup backup.tar.gz --skip-create-backup -y", no_color=True)
+    assert "restore_backup - Error" in output