def get_tahoe_version(self): tahoe = Tahoe(None, executable=self.executable) version = yield tahoe.command(["--version"]) if version: self.tahoe_version = version.split("\n")[0] if self.tahoe_version.startswith("tahoe-lafs: "): self.tahoe_version = self.tahoe_version.lstrip("tahoe-lafs: ")
def start_gateways(self): nodedirs = get_nodedirs(config_dir) if nodedirs: minimize_preference = get_preference('startup', 'minimize') if not minimize_preference or minimize_preference == 'false': self.gui.show_main_window() yield self.select_executable() tor_available = yield get_tor(reactor) logging.debug("Starting Tahoe-LAFS gateway(s)...") for nodedir in nodedirs: gateway = Tahoe(nodedir, executable=self.executable) tcp = gateway.config_get('connections', 'tcp') if tcp == 'tor' and not tor_available: msg.error( self.gui.main_window, "Error Connecting To Tor Daemon", 'The "{}" connection is configured to use Tor, ' 'however, no running tor daemon was found.\n\n' 'This connection will be disabled until you launch ' 'Tor again.'.format(gateway.name)) self.gateways.append(gateway) d = gateway.start() d.addCallback(gateway.ensure_folder_links) self.gui.populate(self.gateways) else: self.gui.show_welcome_dialog() yield self.select_executable()
def get_tahoe_version(self): tahoe = Tahoe(None, executable=self.executable) version = yield tahoe.command(['--version']) if version: self.tahoe_version = version.split('\n')[0] if self.tahoe_version.startswith('tahoe-lafs: '): self.tahoe_version = self.tahoe_version.lstrip('tahoe-lafs: ')
def test__create_magic_folder_write_yaml(monkeypatch, tmpdir_factory): client = Tahoe(str(tmpdir_factory.mktemp("nodedir"))) privatedir = os.path.join(client.nodedir, "private") os.makedirs(privatedir) monkeypatch.setattr("gridsync.tahoe.Tahoe.mkdir", lambda _: "URI:DIR2:aaa") monkeypatch.setattr( "gridsync.tahoe.Tahoe.get_json", lambda x, y: ["dirnode", { "ro_uri": "URI:DIR2-RO:bbb" }], ) monkeypatch.setattr("gridsync.tahoe.Tahoe.link", MagicMock()) folder_path = str(tmpdir_factory.mktemp("TestFolder")) yield client._create_magic_folder(folder_path, "testalias", 123) with open(os.path.join(privatedir, "magic_folders.yaml")) as f: yaml_data = yaml.safe_load(f) assert yaml_data == { "magic-folders": { os.path.basename(folder_path): { "directory": folder_path, "collective_dircap": "URI:DIR2-RO:bbb", "upload_dircap": "URI:DIR2:aaa", "poll_interval": 123, } } }
def test_add_storage_servers_no_add_missing_furl(tmpdir): nodedir = str(tmpdir.mkdir('TestGrid')) os.makedirs(os.path.join(nodedir, 'private')) client = Tahoe(nodedir) storage_servers = {'node-1': {'nickname': 'One'}} client.add_storage_servers(storage_servers) assert client.get_storage_servers() == {}
def test_add_storage_servers_no_add_missing_furl(tmpdir): nodedir = str(tmpdir.mkdir("TestGrid")) os.makedirs(os.path.join(nodedir, "private")) client = Tahoe(nodedir) storage_servers = {"node-1": {"nickname": "One"}} client.add_storage_servers(storage_servers) assert client.get_storage_servers() == {}
def test__create_magic_folder_write_yaml(monkeypatch, tmpdir_factory): client = Tahoe(str(tmpdir_factory.mktemp('nodedir'))) privatedir = os.path.join(client.nodedir, 'private') os.makedirs(privatedir) monkeypatch.setattr('gridsync.tahoe.Tahoe.mkdir', lambda _: 'URI:DIR2:aaa') monkeypatch.setattr( 'gridsync.tahoe.Tahoe.get_json', lambda x, y: ["dirnode", { "ro_uri": "URI:DIR2-RO:bbb" }]) monkeypatch.setattr('gridsync.tahoe.Tahoe.link', MagicMock()) folder_path = str(tmpdir_factory.mktemp('TestFolder')) yield client._create_magic_folder(folder_path, 'testalias', 123) with open(os.path.join(privatedir, 'magic_folders.yaml')) as f: yaml_data = yaml.safe_load(f) assert yaml_data == { 'magic-folders': { os.path.basename(folder_path): { 'directory': folder_path, 'collective_dircap': 'URI:DIR2-RO:bbb', 'upload_dircap': 'URI:DIR2:aaa', 'poll_interval': 123, } } }
def join_grid(self, settings): nickname = settings['nickname'] if self.use_tor: msg = "Connecting to {} via Tor...".format(nickname) else: msg = "Connecting to {}...".format(nickname) self.update_progress.emit(msg) icon_path = None if nickname == 'Least Authority S4': icon_path = resource('leastauthority.com.icon') self.got_icon.emit(icon_path) elif 'icon_base64' in settings: icon_path = os.path.join(config_dir, '.icon.tmp') self.decode_icon(settings['icon_base64'], icon_path) elif 'icon_url' in settings: # A temporary(?) measure to get around the performance issues # observed when transferring a base64-encoded icon through Least # Authority's wormhole server. Hopefully this will go away.. See: # https://github.com/LeastAuthority/leastauthority.com/issues/539 log.debug("Fetching service icon from %s...", settings['icon_url']) icon_path = os.path.join(config_dir, '.icon.tmp') try: # It's probably not worth cancelling or holding-up the setup # process if fetching/writing the icon fails (particularly # if doing so would require the user to get a new invite code) # so just log a warning for now if something goes wrong... yield self.fetch_icon(settings['icon_url'], icon_path) except Exception as e: # pylint: disable=broad-except log.warning("Error fetching service icon: %s", str(e)) executable = yield select_executable() nodedir = os.path.join(config_dir, nickname) self.gateway = Tahoe(nodedir, executable=executable) yield self.gateway.create_client(**settings) newscap = settings.get('newscap') if newscap: with open(os.path.join(nodedir, 'private', 'newscap'), 'w') as f: f.write(newscap) if icon_path: try: shutil.copy(icon_path, os.path.join(nodedir, 'icon')) except OSError as err: log.warning("Error copying icon file: %s", str(err)) if 'icon_url' in settings: try: with open(os.path.join(nodedir, 'icon.url'), 'w') as f: f.write(settings['icon_url']) except OSError as err: log.warning("Error writing icon url to file: %s", str(err)) self.update_progress.emit(msg) yield self.gateway.start() self.client_started.emit(self.gateway) self.update_progress.emit(msg) yield self.gateway.await_ready()
def test_upgrade_legacy_config(tmpdir_factory): client = Tahoe(str(tmpdir_factory.mktemp('tahoe-legacy'))) os.makedirs(os.path.join(client.nodedir, 'private')) subclient_nodedir = os.path.join(client.magic_folders_dir, 'LegacyFolder') privatedir = os.path.join(subclient_nodedir, 'private') os.makedirs(privatedir) with open(os.path.join(privatedir, 'collective_dircap'), 'w') as f: f.write('URI:COLLECTIVE_DIRCAP') with open(os.path.join(privatedir, 'magic_folder_dircap'), 'w') as f: f.write('URI:MAGIC_FOLDER_DIRCAP') db_path = os.path.join(privatedir, 'magicfolderdb.sqlite') with open(db_path, 'a'): os.utime(db_path, None) subclient = Tahoe(subclient_nodedir) subclient.config_set('magic_folder', 'local.directory', '/LegacyFolder') subclient.config_set('magic_folder', 'poll_interval', '10') yield client.upgrade_legacy_config() yaml_path = os.path.join(client.nodedir, 'private', 'magic_folders.yaml') with open(yaml_path) as f: data = yaml.safe_load(f) folder_data = data['magic-folders']['LegacyFolder'] assert folder_data['collective_dircap'] == 'URI:COLLECTIVE_DIRCAP' assert folder_data['upload_dircap'] == 'URI:MAGIC_FOLDER_DIRCAP' assert folder_data['directory'] == '/LegacyFolder' assert folder_data['poll_interval'] == '10' assert os.path.exists( os.path.join(client.nodedir, 'private', 'magicfolder_LegacyFolder.sqlite')) assert os.path.exists(client.magic_folders_dir + '.backup') assert not os.path.exists(client.magic_folders_dir)
def test_upgrade_legacy_config(tmpdir_factory): client = Tahoe(str(tmpdir_factory.mktemp("tahoe-legacy"))) os.makedirs(os.path.join(client.nodedir, "private")) subclient_nodedir = os.path.join(client.magic_folders_dir, "LegacyFolder") privatedir = os.path.join(subclient_nodedir, "private") os.makedirs(privatedir) with open(os.path.join(privatedir, "collective_dircap"), "w") as f: f.write("URI:COLLECTIVE_DIRCAP") with open(os.path.join(privatedir, "magic_folder_dircap"), "w") as f: f.write("URI:MAGIC_FOLDER_DIRCAP") db_path = os.path.join(privatedir, "magicfolderdb.sqlite") with open(db_path, "a"): os.utime(db_path, None) subclient = Tahoe(subclient_nodedir) subclient.config_set("magic_folder", "local.directory", "/LegacyFolder") subclient.config_set("magic_folder", "poll_interval", "10") yield client.upgrade_legacy_config() yaml_path = os.path.join(client.nodedir, "private", "magic_folders.yaml") with open(yaml_path) as f: data = yaml.safe_load(f) folder_data = data["magic-folders"]["LegacyFolder"] assert folder_data["collective_dircap"] == "URI:COLLECTIVE_DIRCAP" assert folder_data["upload_dircap"] == "URI:MAGIC_FOLDER_DIRCAP" assert folder_data["directory"] == "/LegacyFolder" assert folder_data["poll_interval"] == "10" assert os.path.exists( os.path.join(client.nodedir, "private", "magicfolder_LegacyFolder.sqlite")) assert os.path.exists(client.magic_folders_dir + ".backup") assert not os.path.exists(client.magic_folders_dir)
def test_tahoe_start_use_tor_false(monkeypatch, tmpdir_factory): client = Tahoe(str(tmpdir_factory.mktemp('tahoe-start'))) privatedir = os.path.join(client.nodedir, 'private') os.makedirs(privatedir) with open(os.path.join(client.nodedir, 'node.url'), 'w') as f: f.write('http://127.0.0.1:65536') with open(os.path.join(privatedir, 'api_auth_token'), 'w') as f: f.write('1234567890') client.config_set('client', 'shares.happy', '99999') monkeypatch.setattr('gridsync.tahoe.Tahoe.command', lambda x, y, z: 9999) yield client.start() assert not client.use_tor
def test_add_storage_servers(tmpdir): nodedir = str(tmpdir.mkdir('TestGrid')) os.makedirs(os.path.join(nodedir, 'private')) client = Tahoe(nodedir) storage_servers = { 'node-1': { 'anonymous-storage-FURL': 'pb://test', 'nickname': 'One' } } client.add_storage_servers(storage_servers) assert client.get_storage_servers() == storage_servers
def test_add_storage_servers(tmpdir): nodedir = str(tmpdir.mkdir("TestGrid")) os.makedirs(os.path.join(nodedir, "private")) client = Tahoe(nodedir) storage_servers = { "node-1": { "anonymous-storage-FURL": "pb://test", "nickname": "One" } } client.add_storage_servers(storage_servers) assert client.get_storage_servers() == storage_servers
def test_create_magic_folder_call_command_magic_folder_join_and_create_alias( admin_dircap, num_add_alias_calls, monkeypatch, tmpdir_factory): client = Tahoe(str(tmpdir_factory.mktemp('nodedir'))) monkeypatch.setattr('gridsync.tahoe.Tahoe.await_ready', MagicMock()) monkeypatch.setattr('gridsync.tahoe.Tahoe.load_magic_folders', MagicMock()) monkeypatch.setattr('gridsync.tahoe.Tahoe.link_magic_folder_to_rootcap', MagicMock()) monkeypatch.setattr('gridsync.tahoe.Tahoe.command', MagicMock()) m = MagicMock() monkeypatch.setattr('gridsync.tahoe.Tahoe.add_alias', m) folder_path = str(tmpdir_factory.mktemp('TestFolder')) yield client.create_magic_folder(folder_path, 'CAP1:CAP2', admin_dircap) assert m.call_count == num_add_alias_calls
def initialize_gateways(self): logging.debug("Initializing Tahoe-LAFS gateway(s)...") logging.debug(self.settings) for gateway in self.settings: try: t = Tahoe(gateway, self.settings[gateway]['tahoe.cfg']) except KeyError: t = Tahoe(gateway) self.gateways.append(t) for section, contents in self.settings[gateway].items(): if section == 'sync': for local_dir, dircap in contents.items(): self.add_sync_folder(local_dir, dircap, t)
def test__create_magic_folder_add_alias(monkeypatch, tmpdir_factory): client = Tahoe(str(tmpdir_factory.mktemp('nodedir'))) privatedir = os.path.join(client.nodedir, 'private') os.makedirs(privatedir) monkeypatch.setattr('gridsync.tahoe.Tahoe.mkdir', lambda _: 'URI:DIR2:aaa') monkeypatch.setattr( 'gridsync.tahoe.Tahoe.get_json', lambda x, y: ["dirnode", { "ro_uri": "URI:DIR2-RO:bbb" }]) monkeypatch.setattr('gridsync.tahoe.Tahoe.link', MagicMock()) folder_path = str(tmpdir_factory.mktemp('TestFolder')) yield client._create_magic_folder(folder_path, 'testalias', 123) assert client.get_alias('testalias') == 'URI:DIR2:aaa'
def tahoe(tmpdir_factory): client = Tahoe(str(tmpdir_factory.mktemp('tahoe')), executable='tahoe_exe') with open(os.path.join(client.nodedir, 'tahoe.cfg'), 'w') as f: f.write('[node]\nnickname = default') with open(os.path.join(client.nodedir, 'icon.url'), 'w') as f: f.write('test_url') private_dir = os.path.join(client.nodedir, 'private') os.mkdir(private_dir) with open(os.path.join(private_dir, 'aliases'), 'w') as f: f.write('test_alias: test_cap') with open(os.path.join(private_dir, 'magic_folders.yaml'), 'w') as f: f.write("magic-folders:\n test_folder: {directory: test_dir}") client.nodeurl = 'http://127.0.0.1:65536/' return client
def test__create_magic_folder_add_alias(monkeypatch, tmpdir_factory): client = Tahoe(str(tmpdir_factory.mktemp("nodedir"))) privatedir = os.path.join(client.nodedir, "private") os.makedirs(privatedir) monkeypatch.setattr("gridsync.tahoe.Tahoe.mkdir", lambda _: "URI:DIR2:aaa") monkeypatch.setattr( "gridsync.tahoe.Tahoe.get_json", lambda x, y: ["dirnode", { "ro_uri": "URI:DIR2-RO:bbb" }], ) monkeypatch.setattr("gridsync.tahoe.Tahoe.link", MagicMock()) folder_path = str(tmpdir_factory.mktemp("TestFolder")) yield client._create_magic_folder(folder_path, "testalias", 123) assert client.get_alias("testalias") == "URI:DIR2:aaa"
def __init__(self, local_dir, remote_dircap, tahoe=None, ignore_patterns=None): _ignore_patterns = [ '*.gridsync-versions*', '*.part*', '*(conflicted copy *-*-* *-*-*)*' ] if ignore_patterns: _ignore_patterns += ignore_patterns super(SyncFolder, self).__init__(ignore_patterns=_ignore_patterns) if not tahoe: from gridsync.tahoe import Tahoe tahoe = Tahoe() self.tahoe = tahoe self.local_dir = os.path.expanduser(local_dir) self.remote_dircap = remote_dircap self.versions_dir = os.path.join(self.local_dir, '.gridsync-versions') self.local_snapshot = 0 self.filesystem_modified = False self.do_backup = False self.do_sync = False self.sync_state = 0 self.sync_log = [] self.keep_versions = 1 self.local_checker = LoopingCall(self.check_for_changes) self.remote_checker = LoopingCall(reactor.callInThread, self.sync) logging.debug("{} initialized; " "{} <-> {}".format(self, self.local_dir, self.remote_dircap))
def test_tahoe_create_client_add_storage_servers(tmpdir, monkeypatch): nodedir = str(tmpdir.mkdir('TestGrid')) os.makedirs(os.path.join(nodedir, 'private')) monkeypatch.setattr('os.path.exists', lambda _: False) # suppress FileExistsError monkeypatch.setattr('gridsync.tahoe.Tahoe.command', lambda x, y: None) client = Tahoe(nodedir) storage_servers = { 'node-1': { 'anonymous-storage-FURL': 'pb://test', 'nickname': 'One' } } settings = {'nickname': 'TestGrid', 'storage': storage_servers} yield client.create_client(**settings) assert client.get_storage_servers() == storage_servers
def test_tahoe_create_client_add_storage_servers(tmpdir, monkeypatch): nodedir = str(tmpdir.mkdir("TestGrid")) os.makedirs(os.path.join(nodedir, "private")) monkeypatch.setattr("os.path.exists", lambda _: False) # suppress FileExistsError monkeypatch.setattr("gridsync.tahoe.Tahoe.command", lambda x, y: None) client = Tahoe(nodedir) storage_servers = { "node-1": { "anonymous-storage-FURL": "pb://test", "nickname": "One" } } settings = {"nickname": "TestGrid", "storage": storage_servers} yield client.create_client(**settings) assert client.get_storage_servers() == storage_servers
def validate_grid(settings, parent=None): nickname = settings.get("nickname") while not nickname: nickname, _ = prompt_for_grid_name(nickname, parent) nodedir = os.path.join(config_dir, nickname) if os.path.isdir(nodedir): conflicting_introducer = False introducer = settings.get("introducer") if introducer: config = Config(os.path.join(nodedir, "tahoe.cfg")) existing_introducer = config.get("client", "introducer.furl") if introducer != existing_introducer: conflicting_introducer = True conflicting_servers = False servers = settings.get("storage") if servers: existing_servers = Tahoe(nodedir).get_storage_servers() if servers != existing_servers: conflicting_servers = True if conflicting_introducer or conflicting_servers: while os.path.isdir(os.path.join(config_dir, nickname)): nickname, _ = prompt_for_grid_name(nickname, parent) settings["nickname"] = nickname return settings
def start(self): self.initialize_logger(self.args.debug) try: os.makedirs(config_dir) except OSError: pass # Acquire a filesystem lock to prevent multiple instances from running lock = FilesystemLock( os.path.join(config_dir, "{}.lock".format(APP_NAME))) lock.acquire() logging.debug("Core starting with args: %s", self.args) logging.debug("Loaded config.txt settings: %s", settings) self.show_message() self.gui = Gui(self) self.gui.show_systray() reactor.callLater(0, self.start_gateways) reactor.run() for nodedir in get_nodedirs(config_dir): Tahoe(nodedir, executable=self.executable).kill() lock.release()
def test_validate_folders_skip_folder(monkeypatch, tmpdir_factory): gateway = Tahoe( os.path.join(str(tmpdir_factory.mktemp("config_dir")), "SomeGrid") ) gateway.magic_folders = {"FolderName": {}} monkeypatch.setattr( "gridsync.setup.prompt_for_folder_name", lambda x, y, z: (None, 0) ) settings = { "nickname": "SomeGrid", "magic-folders": {"FolderName": {"code": "aaaaaaaa+bbbbbbbb"}}, } assert validate_folders(settings, [gateway]) == { "nickname": "SomeGrid", "magic-folders": {}, }
def __init__(self, parent, local_dir, remote_dircap, tahoe=None, # pylint: disable=too-many-arguments ignore_patterns=None): self.parent = parent _ignore_patterns = ['*.gridsync-versions*', '*.part*', '*(conflicted copy *-*-* *-*-*)*'] if ignore_patterns: _ignore_patterns += ignore_patterns super(SyncFolder, self).__init__(ignore_patterns=_ignore_patterns) if not tahoe: from gridsync.tahoe import Tahoe tahoe = Tahoe() self.tahoe = tahoe self.local_dir = os.path.expanduser(local_dir) self.remote_dircap = remote_dircap self.remote_dircap_alias = None self.versions_dir = os.path.join(self.local_dir, '.gridsync-versions') self.local_snapshot = 0 self.filesystem_modified = False self.do_backup = False self.do_sync = False self.sync_state = 0 self.sync_log = [] self.keep_versions = 1 self.local_checker = LoopingCall(self.check_for_changes) self.remote_checker = LoopingCall(reactor.callInThread, self.sync) self.observer = None logging.debug("%s initialized; %s <-> %s", self, self.local_dir, self.remote_dircap)
def start(self): reactor.listenTCP(52045, ServerFactory(self), interface='localhost') try: os.makedirs(self.config.config_dir) except OSError: pass if self.args.debug: logging.basicConfig( format='%(asctime)s %(funcName)s %(message)s', level=logging.DEBUG, stream=sys.stdout) else: logfile = os.path.join(self.config.config_dir, 'gridsync.log') logging.basicConfig( format='%(asctime)s %(funcName)s %(message)s', level=logging.INFO, filename=logfile) logging.info("Server started with args: {}".format((self.args))) logging.debug("$PATH is: {}".format(os.getenv('PATH'))) try: output = Tahoe().command(["--version-and-path"]) logging.info(output.split('\n')[0]) except Exception as e: logging.error('Error checking Tahoe-LAFS version: {}'.format(e)) # TODO: Notify user? try: self.settings = self.config.load() except IOError: self.settings = {} if not self.settings: reactor.callLater(0, self.first_run) else: self.initialize_gateways() reactor.callLater(0, self.start_gateways) if not self.args.no_gui: self.tray = SystemTrayIcon(self) self.tray.show() state_checker = LoopingCall(self.check_state) state_checker.start(1.0) connection_status_updater = LoopingCall( reactor.callInThread, self.update_connection_status) reactor.callLater(5, connection_status_updater.start, 60) reactor.callLater(1, self.start_sync_folders) reactor.addSystemEventTrigger("before", "shutdown", self.stop) reactor.suggestThreadPoolSize(20) # XXX Adjust? reactor.run()
def test_tahoe_set_streamedlogs_maxlen_from_config_txt(monkeypatch, given, expected): monkeypatch.setattr("gridsync.tahoe.global_settings", {"debug": { "log_maxlen": given }}) client = Tahoe() assert client.streamedlogs._buffer.maxlen == expected
def start(self): reactor.listenTCP(52045, ServerFactory(self), interface='localhost') try: os.makedirs(self.config.config_dir) except OSError: pass if self.args.debug: logging.basicConfig(format='%(asctime)s %(funcName)s %(message)s', level=logging.DEBUG, stream=sys.stdout) else: logfile = os.path.join(self.config.config_dir, 'gridsync.log') logging.basicConfig(format='%(asctime)s %(funcName)s %(message)s', level=logging.INFO, filename=logfile) logging.info("Server started with args: {}".format((self.args))) logging.debug("$PATH is: {}".format(os.getenv('PATH'))) try: output = Tahoe().command(["--version-and-path"]) logging.info(output.split('\n')[0]) except Exception as e: logging.error('Error checking Tahoe-LAFS version: {}'.format(e)) # TODO: Notify user? try: self.settings = self.config.load() except IOError: self.settings = {} if not self.settings: reactor.callLater(0, self.first_run) else: self.initialize_gateways() reactor.callLater(0, self.start_gateways) if not self.args.no_gui: self.tray = SystemTrayIcon(self) self.tray.show() state_checker = LoopingCall(self.check_state) state_checker.start(1.0) connection_status_updater = LoopingCall(reactor.callInThread, self.update_connection_status) reactor.callLater(5, connection_status_updater.start, 60) reactor.callLater(1, self.start_sync_folders) reactor.addSystemEventTrigger("before", "shutdown", self.stop) reactor.suggestThreadPoolSize(20) # XXX Adjust? reactor.run()
def test_create_magic_folder_call__create_magic_folder(exception_raised, num_calls, monkeypatch, tmpdir_factory): client = Tahoe(str(tmpdir_factory.mktemp('nodedir'))) monkeypatch.setattr('gridsync.tahoe.Tahoe.await_ready', MagicMock()) monkeypatch.setattr('gridsync.tahoe.Tahoe.load_magic_folders', MagicMock()) monkeypatch.setattr('gridsync.tahoe.Tahoe.link_magic_folder_to_rootcap', MagicMock()) monkeypatch.setattr('gridsync.tahoe.deferLater', MagicMock()) m = MagicMock(side_effect=exception_raised) monkeypatch.setattr('gridsync.tahoe.Tahoe._create_magic_folder', m) folder_path = str(tmpdir_factory.mktemp('TestFolder')) if exception_raised: with pytest.raises(exception_raised): yield client.create_magic_folder(folder_path) else: yield client.create_magic_folder(folder_path) assert m.call_count == num_calls
def test_join_folders_emit_joined_folders_signal(monkeypatch, qtbot, tmpdir): monkeypatch.setattr('gridsync.tahoe.Tahoe.link', lambda a, b, c, d: None) sr = SetupRunner([]) sr.gateway = Tahoe(str(tmpdir.mkdir('TestGrid'))) sr.gateway.rootcap = 'URI:rootcap' folders_data = {'TestFolder': {'code': 'URI:1+URI:2'}} with qtbot.wait_signal(sr.joined_folders) as blocker: yield sr.join_folders(folders_data) assert blocker.args == [['TestFolder']]
def test_validate_folders_skip_folder(monkeypatch, tmpdir_factory): gateway = Tahoe( os.path.join(str(tmpdir_factory.mktemp('config_dir')), 'SomeGrid')) gateway.magic_folders = {'FolderName': {}} monkeypatch.setattr('gridsync.setup.prompt_for_folder_name', lambda x, y, z: (None, 0)) settings = { 'nickname': 'SomeGrid', 'magic-folders': { 'FolderName': { 'code': 'aaaaaaaa+bbbbbbbb' } } } assert validate_folders(settings, [gateway]) == { 'nickname': 'SomeGrid', 'magic-folders': {} }