def test_setup_teardown_ssh(self):

       hosts = [HostInfo('localhost:%s' % self.dest)]

       setup_events = []

       teardown_events = []

       tmpdir = self.source

       config = py.test.config._reparse([tmpdir])

       hm = HostManager(config, hosts)

->     nodes = hm.setup_hosts(setup_events.append)

       hm.teardown_hosts(teardown_events.append, 

                      [node.channel for node in nodes], nodes)

       count_rsyn_calls = [i for i in setup_events 

               if isinstance(i, repevent.HostRSyncing)]

       assert len(count_rsyn_calls) == len([i for i in hosts])

       count_ready_calls = [i for i in setup_events 

               if isinstance(i, repevent.HostRSyncRootReady)]

       assert len(count_ready_calls) == len([i for i in hosts])

       # same for teardown events

       teardown_wait_starts = [i for i in teardown_events 

                                   if isinstance(i, repevent.CallStart)]

       teardown_wait_ends = [i for i in teardown_events 

                                   if isinstance(i, repevent.CallFinish)]

       assert len(teardown_wait_starts) == len(hosts)

       assert len(teardown_wait_ends) == len(hosts)

   def setup_hosts(self, reporter):

->     self.init_rsync(reporter)

       nodes = []

       for host in self.hosts:

           if hasattr(host.gw, 'remote_exec'): # otherwise dummy for tests :/

               ch = setup_slave(host, self.config)

               nodes.append(MasterNode(ch, reporter))

       return nodes

   def init_rsync(self, reporter):

       ignores = self.config.getvalue_pathlist("dist_rsync_ignore")

->     self.prepare_gateways(reporter)

       # send each rsync root

       for root in self.roots:

           rsync = HostRSync(root, ignores=ignores, 

                             verbose=self.config.option.verbose)

           if self._addrel: 

               destrelpath = ""

           else:

               destrelpath = root.basename

           for host in self.hosts:

               rsync.add_target_host(host, destrelpath, reporter)

           rsync.send(raises=False)

   def prepare_gateways(self, reporter):

       python = self.config.getvalue("dist_remotepython")

       for host in self.hosts:

->         host.initgateway(python=python)

           reporter(repevent.HostGatewayReady(host, self.roots))

           host.gw.host = host