def tahoe_venv(request, reactor): """ A virtualenv for our Tahoe install, letting us install a different one from the Tahoe we depend on. """ tahoe_env = request.config.getoption("tahoe_tox_env") print("creating venv") out_protocol = _DumpOutputProtocol(None) reactor.spawnProcess( out_protocol, sys.executable, ("python", "-m", "tox", "--notest", "-e", tahoe_env), env=environ, ) pytest_twisted.blockon(out_protocol.done) output = subprocess.check_output( [sys.executable, "-m", "tox", "-e", request.config.getoption("tahoe_tox_env"), "--showconfig"], env=environ, ) parser = ConfigParser(strict=False) parser.read_string(output.decode("utf-8")) venv_dir = parser.get("testenv:{}".format(tahoe_env), 'envdir') return VirtualEnv(FilePath(venv_dir))
def chutney(reactor, temp_dir): chutney_dir = join(temp_dir, 'chutney') mkdir(chutney_dir) # TODO: # check for 'tor' binary explicitly and emit a "skip" if we can't # find it # XXX yuck! should add a setup.py to chutney so we can at least # "pip install <path to tarball>" and/or depend on chutney in "pip # install -e .[dev]" (i.e. in the 'dev' extra) # # https://trac.torproject.org/projects/tor/ticket/20343 proto = _DumpOutputProtocol(None) reactor.spawnProcess( proto, 'git', ( 'git', 'clone', '--depth=1', 'https://git.torproject.org/chutney.git', chutney_dir, ), env=environ, ) pytest_twisted.blockon(proto.done) return chutney_dir
def admin_user(): """ Fixture that creates a random admin user and deletes the user afterwards. Useful if the test wishes to alter permissions to test failure cases. Default permissions is complete access to the "/" vhost. Returns: The username of the new administrator. The password is "guest". """ # Create a user with no permissions username = str(uuid.uuid4()) url = "{base}users/{user}".format(base=HTTP_API, user=username) body = {"username": username, "password": "******", "tags": "administrator"} deferred_resp = treq.put(url, json=body, auth=HTTP_AUTH, timeout=3) @pytest_twisted.inlineCallbacks def cp(resp): assert resp.code == 201 url = "{base}permissions/%2F/{user}".format(base=HTTP_API, user=username) body = {"configure": ".*", "write": ".*", "read": ".*"} resp = yield treq.put(url, json=body, auth=HTTP_AUTH, timeout=3) assert resp.code == 201 deferred_resp.addCallbacks(cp, cp) pytest_twisted.blockon(deferred_resp) yield username # Cleanup deferred_resp = treq.delete(url, auth=HTTP_AUTH, timeout=3) pytest_twisted.blockon(deferred_resp)
def setup_function(function): """Ensure each test starts with a fresh Service and configuration.""" config.conf = config.LazyConfig() config.conf["client_properties"]["app"] = function.__name__ if api._twisted_service: pytest_twisted.blockon(api._twisted_service.stopService()) api._twisted_service = None
def chutney(reactor, temp_dir): chutney_dir = join(temp_dir, 'chutney') mkdir(chutney_dir) # TODO: # check for 'tor' binary explicitly and emit a "skip" if we can't # find it # XXX yuck! should add a setup.py to chutney so we can at least # "pip install <path to tarball>" and/or depend on chutney in "pip # install -e .[dev]" (i.e. in the 'dev' extra) # # https://trac.torproject.org/projects/tor/ticket/20343 proto = _DumpOutputProtocol(None) reactor.spawnProcess( proto, '/usr/bin/git', ( '/usr/bin/git', 'clone', '--depth=1', 'https://git.torproject.org/chutney.git', chutney_dir, ) ) pytest_twisted.blockon(proto.done) return chutney_dir
def _cleanup_service_process(process, exited, action): """ Terminate the given process with a kill signal (SIGKILL on POSIX, TerminateProcess on Windows). :param process: The `IProcessTransport` representing the process. :param exited: A `Deferred` which fires when the process has exited. :return: After the process has exited. """ try: with action.context(): def report(m): log_message(message_type="integration:cleanup", message=m) print(m) if process.pid is not None: report("signaling {} with TERM".format(process.pid)) process.signalProcess('TERM') report("signaled, blocking on exit") pytest_twisted.blockon(exited) report("exited, goodbye") except ProcessExitedAlready: pass
def alice(reactor, temp_dir, introducer_furl, flog_gatherer, storage_nodes, request): process = pytest_twisted.blockon( _create_node( reactor, request, temp_dir, introducer_furl, flog_gatherer, "alice", web_port="tcp:9980:interface=localhost", storage=False, # We're going to kill this ourselves, so no need for finalizer to # do it: finalize=False, )) await_client_ready(process) # 1. Create a new RW directory cap: cli(process, "create-alias", "test") rwcap = loads(cli(process, "list-aliases", "--json"))["test"]["readwrite"] # 2. Enable SFTP on the node: host_ssh_key_path = join(process.node_dir, "private", "ssh_host_rsa_key") accounts_path = join(process.node_dir, "private", "accounts") with open(join(process.node_dir, "tahoe.cfg"), "a") as f: f.write("""\ [sftpd] enabled = true port = tcp:8022:interface=127.0.0.1 host_pubkey_file = {ssh_key_path}.pub host_privkey_file = {ssh_key_path} accounts.file = {accounts_path} """.format(ssh_key_path=host_ssh_key_path, accounts_path=accounts_path)) generate_ssh_key(host_ssh_key_path) # 3. Add a SFTP access file with username/password and SSH key auth. # The client SSH key path is typically going to be somewhere else (~/.ssh, # typically), but for convenience sake for testing we'll put it inside node. client_ssh_key_path = join(process.node_dir, "private", "ssh_client_rsa_key") generate_ssh_key(client_ssh_key_path) # Pub key format is "ssh-rsa <thekey> <username>". We want the key. ssh_public_key = open(client_ssh_key_path + ".pub").read().strip().split()[1] with open(accounts_path, "w") as f: f.write("""\ alice password {rwcap} alice2 ssh-rsa {ssh_public_key} {rwcap} """.format(rwcap=rwcap, ssh_public_key=ssh_public_key)) # 4. Restart the node with new SFTP config. process.kill() pytest_twisted.blockon(_run_node(reactor, process.node_dir, request, None)) await_client_ready(process) return process
def flog_gatherer(reactor, base_dir, tahoe_venv, flog_binary, request): if not request.config.getoption("gather_foolscap_logs"): return "" with start_task(action_type=u"integration:flog_gatherer"): out_protocol = _CollectOutputProtocol() gather_dir = join(base_dir, 'flog_gather') reactor.spawnProcess( out_protocol, flog_binary, ( u'flogtool', u'create-gatherer', u'--location', u'tcp:localhost:3117', u'--port', u'3117', gather_dir, ) ) pytest_twisted.blockon(out_protocol.done) magic_text = "Gatherer waiting at" executable = str(tahoe_venv.bin('twistd')) args = ( 'twistd', '--nodaemon', '--python', join(gather_dir, 'gatherer.tac'), ) action_fields = { "action_type": u"integration:flog-gatherer:service", } pytest_twisted.blockon( run_service(reactor, request, action_fields, magic_text, executable, args, cwd=gather_dir) ) def cleanup(): flog_file = 'integration.flog_dump' flog_protocol = _DumpOutputProtocol(open(flog_file, 'w')) flogs = [x for x in listdir(gather_dir) if x.endswith('.flog')] print("Dumping {} flogtool logfiles to '{}'".format(len(flogs), flog_file)) reactor.spawnProcess( flog_protocol, flog_binary, ( 'flogtool', 'dump', join(gather_dir, flogs[0]) ), ) print("Waiting for flogtool to complete") try: pytest_twisted.blockon(flog_protocol.done) except ProcessTerminated as e: print("flogtool exited unexpectedly: {}".format(str(e))) print("Flogtool completed") request.addfinalizer(cleanup) with open(join(gather_dir, 'log_gatherer.furl'), 'r') as f: furl = f.read().strip() return furl
def tor_introducer(reactor, temp_dir, flog_gatherer, request): config = ''' [node] nickname = introducer_tor web.port = 4561 log_gatherer.furl = {log_furl} '''.format(log_furl=flog_gatherer) intro_dir = join(temp_dir, 'introducer_tor') print("making introducer", intro_dir) if not exists(intro_dir): mkdir(intro_dir) done_proto = _ProcessExitedProtocol() _tahoe_runner_optional_coverage( done_proto, reactor, request, ( 'create-introducer', '--tor-control-port', 'tcp:localhost:8010', '--listen=tor', intro_dir, ), ) pytest_twisted.blockon(done_proto.done) # over-write the config file with our stuff with open(join(intro_dir, 'tahoe.cfg'), 'w') as f: f.write(config) # on windows, "tahoe start" means: run forever in the foreground, # but on linux it means daemonize. "tahoe run" is consistent # between platforms. protocol = _MagicTextProtocol('introducer running') transport = _tahoe_runner_optional_coverage( protocol, reactor, request, ( 'run', intro_dir, ), ) def cleanup(): try: transport.signalProcess('TERM') pytest_twisted.blockon(protocol.exited) except ProcessExitedAlready: pass request.addfinalizer(cleanup) pytest_twisted.blockon(protocol.magic_seen) return transport
def sleep(timeout): """ Sleep for the given amount of time, letting the pytest-twisted reactor run. This can only be called from the main pytest greenlet, not from the reactor greenlet. """ from twisted.internet import reactor as _reactor pytest_twisted.blockon(twisted_sleep(_reactor, timeout))
def test_allocate_channel_no_more_channels(self): """Assert a pika NoFreeChannels exception turns into a fedora_messaging exception.""" self.protocol.channel = mock.Mock( name="channel", side_effect=pika.exceptions.NoFreeChannels()) d = self.protocol._allocate_channel() d.addCallback(pytest.fail, "Expected a NoFreeChannels exception") d.addErrback(lambda f: f.trap(NoFreeChannels)) pytest_twisted.blockon(d)
def flog_gatherer(reactor, temp_dir, flog_binary, request): out_protocol = _CollectOutputProtocol() gather_dir = join(temp_dir, 'flog_gather') reactor.spawnProcess(out_protocol, flog_binary, ( 'flogtool', 'create-gatherer', '--location', 'tcp:localhost:3117', '--port', '3117', gather_dir, )) pytest_twisted.blockon(out_protocol.done) twistd_protocol = _MagicTextProtocol("Gatherer waiting at") twistd_process = reactor.spawnProcess( twistd_protocol, which('twistd')[0], ( 'twistd', '--nodaemon', '--python', join(gather_dir, 'gatherer.tac'), ), path=gather_dir, ) pytest_twisted.blockon(twistd_protocol.magic_seen) def cleanup(): _cleanup_tahoe_process(twistd_process, twistd_protocol.exited) flog_file = mktemp('.flog_dump') flog_protocol = _DumpOutputProtocol(open(flog_file, 'w')) flog_dir = join(temp_dir, 'flog_gather') flogs = [x for x in listdir(flog_dir) if x.endswith('.flog')] print("Dumping {} flogtool logfiles to '{}'".format( len(flogs), flog_file)) reactor.spawnProcess( flog_protocol, flog_binary, ('flogtool', 'dump', join(temp_dir, 'flog_gather', flogs[0])), ) print("Waiting for flogtool to complete") try: pytest_twisted.blockon(flog_protocol.done) except ProcessTerminated as e: print("flogtool exited unexpectedly: {}".format(str(e))) print("Flogtool completed") request.addfinalizer(cleanup) with open(join(gather_dir, 'log_gatherer.furl'), 'r') as f: furl = f.read().strip() return furl
def tor_introducer(reactor, temp_dir, flog_gatherer, request): config = ''' [node] nickname = introducer_tor web.port = 4561 log_gatherer.furl = {log_furl} '''.format(log_furl=flog_gatherer) intro_dir = join(temp_dir, 'introducer_tor') print("making introducer", intro_dir) if not exists(intro_dir): mkdir(intro_dir) done_proto = _ProcessExitedProtocol() reactor.spawnProcess( done_proto, sys.executable, ( sys.executable, '-m', 'allmydata.scripts.runner', 'create-introducer', '--tor-control-port', 'tcp:localhost:8010', '--listen=tor', intro_dir, ), ) pytest_twisted.blockon(done_proto.done) # over-write the config file with our stuff with open(join(intro_dir, 'tahoe.cfg'), 'w') as f: f.write(config) # on windows, "tahoe start" means: run forever in the foreground, # but on linux it means daemonize. "tahoe run" is consistent # between platforms. protocol = _MagicTextProtocol('introducer running') process = reactor.spawnProcess( protocol, sys.executable, ( sys.executable, '-m', 'allmydata.scripts.runner', 'run', intro_dir, ), ) def cleanup(): try: process.signalProcess('TERM') pytest_twisted.blockon(protocol.exited) except ProcessExitedAlready: pass request.addfinalizer(cleanup) pytest_twisted.blockon(protocol.magic_seen) return process
def flog_gatherer(reactor, temp_dir, flog_binary, request): out_protocol = _CollectOutputProtocol() gather_dir = join(temp_dir, 'flog_gather') reactor.spawnProcess( out_protocol, flog_binary, ( 'flogtool', 'create-gatherer', '--location', 'tcp:localhost:3117', '--port', '3117', gather_dir, ) ) pytest_twisted.blockon(out_protocol.done) twistd_protocol = _MagicTextProtocol("Gatherer waiting at") twistd_process = reactor.spawnProcess( twistd_protocol, which('twistd')[0], ( 'twistd', '--nodaemon', '--python', join(gather_dir, 'gatherer.tac'), ), path=gather_dir, ) pytest_twisted.blockon(twistd_protocol.magic_seen) def cleanup(): _cleanup_twistd_process(twistd_process, twistd_protocol.exited) flog_file = mktemp('.flog_dump') flog_protocol = _DumpOutputProtocol(open(flog_file, 'w')) flog_dir = join(temp_dir, 'flog_gather') flogs = [x for x in listdir(flog_dir) if x.endswith('.flog')] print("Dumping {} flogtool logfiles to '{}'".format(len(flogs), flog_file)) reactor.spawnProcess( flog_protocol, flog_binary, ( 'flogtool', 'dump', join(temp_dir, 'flog_gather', flogs[0]) ), ) print("Waiting for flogtool to complete") try: pytest_twisted.blockon(flog_protocol.done) except ProcessTerminated as e: print("flogtool exited unexpectedly: {}".format(str(e))) print("Flogtool completed") request.addfinalizer(cleanup) with open(join(gather_dir, 'log_gatherer.furl'), 'r') as f: furl = f.read().strip() return furl
def i2p_introducer(reactor, temp_dir, flog_gatherer, request): config = ''' [node] nickname = introducer_i2p web.port = 4561 log_gatherer.furl = {log_furl} '''.format(log_furl=flog_gatherer) intro_dir = join(temp_dir, 'introducer_i2p') print("making introducer", intro_dir) if not exists(intro_dir): mkdir(intro_dir) done_proto = util._ProcessExitedProtocol() util._tahoe_runner_optional_coverage( done_proto, reactor, request, ( 'create-introducer', '--listen=i2p', intro_dir, ), ) pytest_twisted.blockon(done_proto.done) # over-write the config file with our stuff with open(join(intro_dir, 'tahoe.cfg'), 'w') as f: f.write(config) # "tahoe run" is consistent across Linux/macOS/Windows, unlike the old # "start" command. protocol = util._MagicTextProtocol('introducer running') transport = util._tahoe_runner_optional_coverage( protocol, reactor, request, ( 'run', intro_dir, ), ) def cleanup(): try: transport.signalProcess('TERM') util.block_with_timeout(protocol.exited, reactor) except ProcessExitedAlready: pass request.addfinalizer(cleanup) pytest_twisted.blockon(protocol.magic_seen) return transport
def enabled_plugins(started_deluge_client): started_deluge_client.core.set_config({"pre_allocate_storage": True}) pytest_twisted.blockon(started_deluge_client.core.enable_plugin("Label")) pytest_twisted.blockon( started_deluge_client.core.enable_plugin("Waterwheel")) setup_translation() yield label_plugin = component.get("CorePlugin.Label") for label in label_plugin.get_labels(): label_plugin.remove(label)
def introducer(reactor, temp_dir, flog_gatherer, request): config = ''' [node] nickname = introducer0 web.port = 4560 log_gatherer.furl = {log_furl} '''.format(log_furl=flog_gatherer) intro_dir = join(temp_dir, 'introducer') print("making introducer", intro_dir) if not exists(intro_dir): mkdir(intro_dir) done_proto = _ProcessExitedProtocol() reactor.spawnProcess( done_proto, sys.executable, ( sys.executable, '-m', 'allmydata.scripts.runner', 'create-introducer', '--listen=tcp', '--hostname=localhost', intro_dir, ), ) pytest_twisted.blockon(done_proto.done) # over-write the config file with our stuff with open(join(intro_dir, 'tahoe.cfg'), 'w') as f: f.write(config) # on windows, "tahoe start" means: run forever in the foreground, # but on linux it means daemonize. "tahoe run" is consistent # between platforms. protocol = _MagicTextProtocol('introducer running') process = reactor.spawnProcess( protocol, sys.executable, ( sys.executable, '-m', 'allmydata.scripts.runner', 'run', intro_dir, ), ) request.addfinalizer( partial(_cleanup_twistd_process, process, protocol.exited)) pytest_twisted.blockon(protocol.magic_seen) return process
def device(factory_device): factory_device.bus.transmit = True factory_device.cyclic_send_signal( path=('ProcessToInverter', 'CommandModeControl', 'Enable'), period=0.1, ) try: yield factory_device finally: pytest_twisted.blockon(factory_device.set_access_level(level=0), ) factory_device.bus.transmit = False factory_device.cancel_all_cyclic_sends()
def cleanup(): print("Tearing down Chutney Tor network") proto = _CollectOutputProtocol() reactor.spawnProcess( proto, sys.executable, ( sys.executable, '-m', 'chutney.TorNet', 'stop', join(chutney_dir, 'networks', 'basic'), ), path=join(chutney_dir), env={"PYTHONPATH": join(chutney_dir, "lib")}, ) pytest_twisted.blockon(proto.done)
def cleanup(): print("Tearing down Chutney Tor network") proto = _CollectOutputProtocol() reactor.spawnProcess( proto, sys.executable, ( sys.executable, '-m', 'chutney.TorNet', 'stop', join(chutney_dir, 'networks', 'basic'), ), path=join(chutney_dir), env=env, ) pytest_twisted.blockon(proto.done)
def cleanup(): try: pytest_twisted.blockon( self.management.session.call( u"crossbarfabriccenter.remote.node.stop_worker", self.node_oid, name, )) except Exception: # this can fail if e.g. ALL the tests are stopping and # other pytest shutdown code runs before this does -- # probably only CancelledError needs to be caught # here. pass
def introducer(reactor, temp_dir, flog_gatherer, request): config = ''' [node] nickname = introducer0 web.port = 4560 log_gatherer.furl = {log_furl} '''.format(log_furl=flog_gatherer) intro_dir = join(temp_dir, 'introducer') print("making introducer", intro_dir) if not exists(intro_dir): mkdir(intro_dir) done_proto = _ProcessExitedProtocol() _tahoe_runner_optional_coverage( done_proto, reactor, request, ( 'create-introducer', '--listen=tcp', '--hostname=localhost', intro_dir, ), ) pytest_twisted.blockon(done_proto.done) # over-write the config file with our stuff with open(join(intro_dir, 'tahoe.cfg'), 'w') as f: f.write(config) # "tahoe run" is consistent across Linux/macOS/Windows, unlike the old # "start" command. protocol = _MagicTextProtocol('introducer running') transport = _tahoe_runner_optional_coverage( protocol, reactor, request, ( 'run', intro_dir, ), ) request.addfinalizer( partial(_cleanup_tahoe_process, transport, protocol.exited)) pytest_twisted.blockon(protocol.magic_seen) return TahoeProcess(transport, intro_dir)
def alice_invite(reactor, alice, temp_dir, request): node_dir = join(temp_dir, 'alice') with start_action(action_type=u"integration:alice:magic_folder:create"): # FIXME XXX by the time we see "client running" in the logs, the # storage servers aren't "really" ready to roll yet (uploads fairly # consistently fail if we don't hack in this pause...) import time time.sleep(5) proto = _CollectOutputProtocol() reactor.spawnProcess(proto, sys.executable, [ sys.executable, '-m', 'allmydata.scripts.runner', 'magic-folder', 'create', '--poll-interval', '2', '--basedir', node_dir, 'magik:', 'alice', join(temp_dir, 'magic-alice'), ]) pytest_twisted.blockon(proto.done) with start_action( action_type=u"integration:alice:magic_folder:invite") as a: proto = _CollectOutputProtocol() reactor.spawnProcess(proto, sys.executable, [ sys.executable, '-m', 'allmydata.scripts.runner', 'magic-folder', 'invite', '--basedir', node_dir, 'magik:', 'bob', ]) pytest_twisted.blockon(proto.done) invite = proto.output.getvalue() a.add_success_fields(invite=invite) with start_action(action_type=u"integration:alice:magic_folder:restart"): # before magic-folder works, we have to stop and restart (this is # crappy for the tests -- can we fix it in magic-folder?) try: alice.signalProcess('TERM') pytest_twisted.blockon(alice.exited) except ProcessExitedAlready: pass with start_action( action_type=u"integration:alice:magic_folder:magic-text"): magic_text = 'Completed initial Magic Folder scan successfully' pytest_twisted.blockon( _run_node(reactor, node_dir, request, magic_text)) return invite
def test_open_server(): server = RestServer(access_config=OpenAccessConfig()) d = server.start() def return_server(results, srv): return srv if results else None def failed(reason): return reason d.addCallback(return_server, server) d.addErrback(failed) yield pytest_twisted.blockon(d) d = server.stop() pytest_twisted.blockon(d)
def test_stopTrying(self): # The _client_ready deferred must errback when we stop trying to # reconnect. self.factory._client_ready.addCallbacks( self.fail, lambda f: f.trap(pika.exceptions.AMQPConnectionError)) self.factory.stopTrying() return pytest_twisted.blockon(self.factory._client_ready)
def test_passive_declares(self): """Assert queues and exchanges are created passively when configured so.""" factory = FedoraMessagingFactory( None, queues=[{ "queue": "my_queue" }], exchanges=[{ "exchange": "my_exchange" }], ) factory.buildProtocol(None) mock_channel = mock.Mock() factory.client._allocate_channel = mock.Mock(return_value=mock_channel) def _check(_): mock_channel.queue_declare.assert_called_once_with( queue="my_queue", passive=True) mock_channel.exchange_declare.assert_called_once_with( exchange="my_exchange", passive=True) with mock.patch.dict(config.conf, {"passive_declares": True}): d = factory._on_client_ready() d.addCallback(_check) return pytest_twisted.blockon(d)
def test_resumeProducing(self): # Check the resumeProducing method. self.protocol._running = False callback = mock.Mock() self.protocol._consumers = { "testqueue1": Consumer("consumer1", "testqueue1", callback, self.protocol._channel), "testqueue2": Consumer("consumer2", "testqueue2", callback, self.protocol._channel), "testqueue3": Consumer("consumer3", "testqueue3", callback, self.protocol._channel), } self.protocol._read = mock.Mock( side_effect=lambda _, __: defer.succeed(None)) d = self.protocol.resumeProducing() def _check(_): self.assertTrue(self.protocol._running) self.assertEqual(self.protocol._channel.basic_consume.call_count, 3) called_queues = [ kw["queue"] for arg, kw in self.protocol._channel.basic_consume.call_args_list ] self.assertEqual(sorted(called_queues), sorted(self.protocol._consumers.keys())) self.assertEqual(self.protocol._read.call_count, 3) d.addCallback(_check) return pytest_twisted.blockon(d)
def test_when_connected_unexpected_failure(self): """Assert when_connected errbacks when the connection fails.""" class DummyError(Exception): pass def _get_protocol(*a, **kw): protocol = mock.Mock(name="protocol mock") # Fail immediately protocol.ready = defer.fail(DummyError()) return protocol def _check(f): f.trap(DummyError) # Make sure a new Deferred has been generated for when_connected() new_d = self.factory.when_connected() assert new_d.called is False assert new_d != connected_d self.factory.protocol = _get_protocol connected_d = self.factory.when_connected() connected_d.addCallbacks( lambda r: ValueError("This should fail but I got: {!r}".format(r)), _check) with mock.patch( "fedora_messaging.twisted.factory._std_log") as mock_log: self.factory.buildProtocol(None) mock_log.error.assert_called() last_log_call_args = mock_log.error.call_args_list[-1][0] assert last_log_call_args[0] == ( "The connection failed with an unexpected exception; please report this bug: %s" ) assert last_log_call_args[1].startswith( "Traceback (most recent call last):") return pytest_twisted.blockon(connected_d)
def test_when_connected(self): """Assert whenConnected returns the current client once _client_ready fires""" self.factory.client = mock.Mock() self.factory._client_ready.callback(None) d = self.factory.whenConnected() d.addCallback( lambda client: self.assertEqual(self.factory.client, client)) return pytest_twisted.blockon(d)
def build(self, monkeypatch): # To create this fixture file: # cbs call getBuild 24284 \ # --json-output > txkoji/tests/fixtures/calls/getBuild.json monkeypatch.setattr('txkoji.connection.Proxy', FakeProxy) koji = Connection('mykoji') d = koji.getBuild(24284) return pytest_twisted.blockon(d)
def tasks(self, monkeypatch): # To create this fixture file: # cbs call listTasks --kwargs="{'opts': {'owner': 144, 'method': 'build', 'decode': True}}" --json-output > txkoji/tests/fixtures/calls/listTasks.json # NOQA: E501 monkeypatch.setattr('txkoji.connection.Proxy', FakeProxy) koji = Connection('mykoji') opts = {'owner': 144, 'method': 'build'} d = koji.listTasks(opts) return pytest_twisted.blockon(d)
def task(self, monkeypatch): # To create this fixture file: # cbs call getTaskInfo 291929 --kwargs="{'request': True}" \ # --json-output > txkoji/tests/fixtures/calls/getTaskInfo.json monkeypatch.setattr('txkoji.connection.Proxy', FakeProxy) koji = Connection('mykoji') d = koji.getTaskInfo(291929) return pytest_twisted.blockon(d)
def channels(self, monkeypatch): # To create this fixture file: # cbs call listChannels \ # --json-output > txkoji/tests/fixtures/calls/listChannels.json monkeypatch.setattr('txkoji.connection.Proxy', FakeProxy) koji = Connection('mykoji') d = koji.listChannels() return pytest_twisted.blockon(d)
def chutney(reactor, temp_dir): chutney_dir = join(temp_dir, 'chutney') mkdir(chutney_dir) # TODO: # check for 'tor' binary explicitly and emit a "skip" if we can't # find it # XXX yuck! should add a setup.py to chutney so we can at least # "pip install <path to tarball>" and/or depend on chutney in "pip # install -e .[dev]" (i.e. in the 'dev' extra) # # https://trac.torproject.org/projects/tor/ticket/20343 proto = _DumpOutputProtocol(None) reactor.spawnProcess( proto, 'git', ( 'git', 'clone', 'https://git.torproject.org/chutney.git', chutney_dir, ), env=environ, ) pytest_twisted.blockon(proto.done) # XXX: Here we reset Chutney to the last revision known to work # with Python 2, as a workaround for Chutney moving to Python 3. # When this is no longer necessary, we will have to drop this and # add '--depth=1' back to the above 'git clone' subprocess. proto = _DumpOutputProtocol(None) reactor.spawnProcess( proto, 'git', ( 'git', '-C', chutney_dir, 'reset', '--hard', '99bd06c7554b9113af8c0877b6eca4ceb95dcbaa' ), env=environ, ) pytest_twisted.blockon(proto.done) return chutney_dir
def magic_folder(reactor, alice_invite, alice, bob, temp_dir, request): print("pairing magic-folder") bob_dir = join(temp_dir, 'bob') proto = _CollectOutputProtocol() reactor.spawnProcess( proto, sys.executable, [ sys.executable, '-m', 'allmydata.scripts.runner', 'magic-folder', 'join', '--poll-interval', '2', '--basedir', bob_dir, alice_invite, join(temp_dir, 'magic-bob'), ] ) pytest_twisted.blockon(proto.done) # before magic-folder works, we have to stop and restart (this is # crappy for the tests -- can we fix it in magic-folder?) try: print("Sending TERM to Bob") bob.signalProcess('TERM') pytest_twisted.blockon(bob.exited) except ProcessExitedAlready: pass magic_text = 'Completed initial Magic Folder scan successfully' pytest_twisted.blockon(_run_node(reactor, bob_dir, request, magic_text)) return (join(temp_dir, 'magic-alice'), join(temp_dir, 'magic-bob'))
def cleanup(): _cleanup_twistd_process(twistd_process, twistd_protocol.exited) flog_file = mktemp('.flog_dump') flog_protocol = _DumpOutputProtocol(open(flog_file, 'w')) flog_dir = join(temp_dir, 'flog_gather') flogs = [x for x in listdir(flog_dir) if x.endswith('.flog')] print("Dumping {} flogtool logfiles to '{}'".format(len(flogs), flog_file)) reactor.spawnProcess( flog_protocol, flog_binary, ( 'flogtool', 'dump', join(temp_dir, 'flog_gather', flogs[0]) ), ) print("Waiting for flogtool to complete") try: pytest_twisted.blockon(flog_protocol.done) except ProcessTerminated as e: print("flogtool exited unexpectedly: {}".format(str(e))) print("Flogtool completed")
def alice_invite(reactor, alice, temp_dir, request): node_dir = join(temp_dir, 'alice') with start_action(action_type=u"integration:alice:magic_folder:create"): # FIXME XXX by the time we see "client running" in the logs, the # storage servers aren't "really" ready to roll yet (uploads fairly # consistently fail if we don't hack in this pause...) import time ; time.sleep(5) proto = _CollectOutputProtocol() reactor.spawnProcess( proto, sys.executable, [ sys.executable, '-m', 'allmydata.scripts.runner', 'magic-folder', 'create', '--poll-interval', '2', '--basedir', node_dir, 'magik:', 'alice', join(temp_dir, 'magic-alice'), ] ) pytest_twisted.blockon(proto.done) with start_action(action_type=u"integration:alice:magic_folder:invite") as a: proto = _CollectOutputProtocol() reactor.spawnProcess( proto, sys.executable, [ sys.executable, '-m', 'allmydata.scripts.runner', 'magic-folder', 'invite', '--basedir', node_dir, 'magik:', 'bob', ] ) pytest_twisted.blockon(proto.done) invite = proto.output.getvalue() a.add_success_fields(invite=invite) with start_action(action_type=u"integration:alice:magic_folder:restart"): # before magic-folder works, we have to stop and restart (this is # crappy for the tests -- can we fix it in magic-folder?) try: alice.signalProcess('TERM') pytest_twisted.blockon(alice.exited) except ProcessExitedAlready: pass with start_action(action_type=u"integration:alice:magic_folder:magic-text"): magic_text = 'Completed initial Magic Folder scan successfully' pytest_twisted.blockon(_run_node(reactor, node_dir, request, magic_text)) return invite
def bob(reactor, temp_dir, introducer_furl, flog_gatherer, storage_nodes, request): try: mkdir(join(temp_dir, 'magic-bob')) except OSError: pass process = pytest_twisted.blockon( _create_node( reactor, request, temp_dir, introducer_furl, flog_gatherer, "bob", web_port="tcp:9981:interface=localhost", storage=False, ) ) return process
def storage_nodes(reactor, temp_dir, introducer, introducer_furl, flog_gatherer, request): nodes = [] # start all 5 nodes in parallel for x in range(5): name = 'node{}'.format(x) # tub_port = 9900 + x nodes.append( pytest_twisted.blockon( _create_node( reactor, request, temp_dir, introducer_furl, flog_gatherer, name, web_port=None, storage=True, ) ) ) #nodes = pytest_twisted.blockon(DeferredList(nodes)) return nodes
def tor_network(reactor, temp_dir, chutney, request): # this is the actual "chutney" script at the root of a chutney checkout chutney_dir = chutney chut = join(chutney_dir, 'chutney') # now, as per Chutney's README, we have to create the network # ./chutney configure networks/basic # ./chutney start networks/basic proto = _DumpOutputProtocol(None) reactor.spawnProcess( proto, sys.executable, ( sys.executable, '-m', 'chutney.TorNet', 'configure', join(chutney_dir, 'networks', 'basic'), ), path=join(chutney_dir), env={"PYTHONPATH": join(chutney_dir, "lib")}, ) pytest_twisted.blockon(proto.done) proto = _DumpOutputProtocol(None) reactor.spawnProcess( proto, sys.executable, ( sys.executable, '-m', 'chutney.TorNet', 'start', join(chutney_dir, 'networks', 'basic'), ), path=join(chutney_dir), env={"PYTHONPATH": join(chutney_dir, "lib")}, ) pytest_twisted.blockon(proto.done) # print some useful stuff proto = _CollectOutputProtocol() reactor.spawnProcess( proto, sys.executable, ( sys.executable, '-m', 'chutney.TorNet', 'status', join(chutney_dir, 'networks', 'basic'), ), path=join(chutney_dir), env={"PYTHONPATH": join(chutney_dir, "lib")}, ) try: pytest_twisted.blockon(proto.done) except ProcessTerminated: print("Chutney.TorNet status failed (continuing):") print(proto.output.getvalue()) def cleanup(): print("Tearing down Chutney Tor network") proto = _CollectOutputProtocol() reactor.spawnProcess( proto, sys.executable, ( sys.executable, '-m', 'chutney.TorNet', 'stop', join(chutney_dir, 'networks', 'basic'), ), path=join(chutney_dir), env={"PYTHONPATH": join(chutney_dir, "lib")}, ) pytest_twisted.blockon(proto.done) request.addfinalizer(cleanup) return chut
def cleanup(): try: process.signalProcess('TERM') pytest_twisted.blockon(protocol.exited) except ProcessExitedAlready: pass
def test_that_threads_are_different(self): self.use_same_thread = False d = self.request_same_or_different_thread_thread() d.addCallback(lambda _: self.assert_that_threads_are_different) return pytest_twisted.blockon(d)