Got tests working again

fs/remote.py

@@ -253,21 +253,7 @@ class RemoteFileBuffer(FileWrapper):
         if "w" in self.mode or "a" in self.mode or "+" in self.mode:
             pos = self.wrapped_file.tell()
             self.wrapped_file.seek(0)
-            
-#            chunk_size = 64*1024
-#            f = None
-#            try:
-#                f = self.fs.wrapped_fs.open(self.path, 'wb')                
-#                chunk = self.wrapped_file.read(chunk_size)
-#                while chunk:
-#                    f.write(chunk)
-#                    chunk = self.wrapped_file.read(chunk_size)
-#            finally:
-#                if f is not None:
-#                    f.close()
-            
             self.fs.setcontents(self.path, self.wrapped_file)
-            
             self.wrapped_file.seek(pos)
     
     def close(self):
@@ -345,6 +331,7 @@ class ConnectionManagerFS(LazyFS):
                 if not self._poll_thread:
                     target = self._poll_connection
                     self._poll_thread = threading.Thread(target=target)
+                    self._poll_thread.daemon = True
                     self._poll_thread.start()
                 self._connection_cond.wait(timeout)
         finally:

fs/rpcfs.py

@@ -24,8 +24,8 @@ def re_raise_faults(func):
         try:
             return func(*args,**kwds)
         except xmlrpclib.Fault, f:
-            import traceback
-            traceback.print_exc()           
+            #import traceback
+            #traceback.print_exc()           
             # Make sure it's in a form we can handle
             bits = f.faultString.split(" ")
             if bits[0] not in ["<type","<class"]:

fs/sftpfs.py

@@ -103,50 +103,20 @@ class SFTPFS(FS):
             except ValueError:
                 pass
                     
-        
-        hostkeytype = None
-        hostkey = None
-                
-        if hostname is not None:
-            try:
-                host_keys = paramiko.util.load_host_keys(os.path.expanduser('~/.ssh/known_hosts'))
-            except IOError:
-                try:
-                    # try ~/ssh/ too, because windows can't have a folder named ~/.ssh/
-                    host_keys = paramiko.util.load_host_keys(os.path.expanduser('~/ssh/known_hosts'))
-                except IOError:
-                    
-                    host_keys = {}
-                        
-            if host_keys.has_key(hostname):
-                hostkeytype = host_keys[hostname].keys()[0]
-                hostkey = host_keys[hostname][hostkeytype]
-                credentials['hostkey'] = hostkey                
-        
-        if not credentials.get('username'):
-            credentials['username'] = getuser()                    
-        
         super(SFTPFS, self).__init__()        
+        self.root_path = abspath(normpath(root_path))
         
         if isinstance(connection,paramiko.Channel):
             self._transport = None
             self._client = paramiko.SFTPClient(connection)
         else:
-            if not isinstance(connection, paramiko.Transport):
+            if not isinstance(connection,paramiko.Transport):
                 connection = paramiko.Transport(connection)
                 self._owns_transport = True
-            try:           
             if not connection.is_authenticated():
                 connection.connect(**credentials)
-                if not connection.is_authenticated():
-                    self._agent_auth(connection, credentials.get('username'))
-                if not connection.is_authenticated():
-                    connection.close()
-                    raise RemoteConnectionError('No auth')
-            except paramiko.AuthenticationException:
-                raise RemoteConnectionError('Auth rejected')
             self._transport = connection
-        self.root_path = abspath(normpath(root_path))
+        
 
     @classmethod
     def _agent_auth(cls, transport, username):

fs/tests/__init__.py

@@ -761,7 +761,9 @@ class ThreadingTestCases:
                 func()
             except Exception:
                 errors.append(sys.exc_info())
-        return threading.Thread(target=runThread)
+        thread = threading.Thread(target=runThread)
+        thread.daemon = True
+        return thread
 
     def _runThreads(self,*funcs):
         check_interval = sys.getcheckinterval()

fs/tests/test_expose.py

@@ -197,3 +197,5 @@ if dokan.is_available:
                     self.mount_proc.terminate()
             self.temp_fs.close()
 
+if __name__ == '__main__':
+    unittest.main()
\ No newline at end of file

fs/tests/test_remote.py

@@ -229,7 +229,7 @@ class TestCacheFS(unittest.TestCase,FSTestCases,ThreadingTestCases):
         sys.setcheckinterval(self._check_interval)
 
 
-class TestConnectionManagerFS(unittest.TestCase,FSTestCases,ThreadingTestCases):
+class TestConnectionManagerFS(unittest.TestCase,FSTestCases):#,ThreadingTestCases):
     """Test simple operation of ConnectionManagerFS"""
 
     def setUp(self):
@@ -255,6 +255,7 @@ class DisconnectingFS(WrapFS):
         if random.choice([True,False]):
             raise RemoteConnectionError("")
         self._bounce_thread = threading.Thread(target=self._bounce)
+        self._bounce_thread.daemon = True
         self._bounce_thread.start()
 
     def __getstate__(self):
@@ -265,6 +266,7 @@ class DisconnectingFS(WrapFS):
     def __setstate__(self,state):
         super(DisconnectingFS,self).__setstate__(state)
         self._bounce_thread = threading.Thread(target=self._bounce)
+        self._bounce_thread.daemon = True
         self._bounce_thread.start()
 
     def _bounce(self):

fs/utils.py

@@ -168,7 +168,7 @@ def copystructure(src_fs, dst_fs):
     
     """
     
-    for path in src_fs.walkdirs(wildcard="depth"):
+    for path in src_fs.walkdirs():
         dst_fs.makedir(path, allow_recreate=True)
 
 
@@ -291,7 +291,7 @@ def find_duplicates(fs,
         return
 
     def identical(p1, p2):
-        """ Returns True if the contests of two files are identical. """
+        """ Returns True if the contents of two files are identical. """
         f1, f2 = None, None
         try:
             f1 = fs.open(p1, 'rb')