Merge lp:~thisfred/desktopcouch/i_believe_you_have_my_couchdb into lp:desktopcouch

[Eric Casteleijn]

Makes the tests no longer use the user's desktopcouch couchdb.

[Eric Casteleijn (thisfred)]

No longer uses the user's desktopcouch couchdb, which was super ungood. Now creating everything in /tmp and running against that. And leaving it around, and running after the tests... which is only normal ungood. Any pointers on how to execute some code (to stop couch and remove the tempdir) after all the tests have run (or even at the end of each testcase) welcome. I believe Zope testcases have support for this, but my brain is fried for the week.

This has the branch lp:~rick-rickspencer3/desktopcouch/CouchWidget-tests-and-robustness merged in, and any conflicts removed.

[lp:~thisfred/desktopcouch/i_believe_you_have_my_couchdb]

47. By Eric Casteleijn on 2009-08-22

one forgotten checkin

=== modified file 'desktopcouch/__init__.py'
--- desktopcouch/__init__.py	2009-08-19 16:00:01 +0000
+++ desktopcouch/__init__.py	2009-08-21 21:57:37 +0000
@@ -16,7 +16,7 @@
 "Desktop Couch helper files"
 
 from __future__ import with_statement
-import os, re, errno, time, fcntl
+import os, re, time
 
 
 def find_pid(start_if_not_running=True):
@@ -88,7 +88,7 @@
     # which was shorter but less reliable)
 
     proc_dir = "/proc/%s" % (pid,)
-    
+
     # enumerate the process' file descriptors
     fd_dir = os.path.join(proc_dir, 'fd')
     try:
@@ -96,7 +96,7 @@
                     for fd in os.listdir(fd_dir)]
     except OSError:
         raise RuntimeError("Unable to find file descriptors in /proc")
-        
+
 
     # identify socket fds
     socket_matches = [re.match('socket:\\[([0-9]+)\\]', p) for p in fd_paths]
@@ -140,11 +140,11 @@
 os_name = platform.system()
 try:
     process_is_couchdb = {
-        "Linux":process_is_couchdb__linux
+        "Linux": process_is_couchdb__linux
         } [os_name]
 
     find_port = {
-        "Linux":find_port__linux
+        "Linux": find_port__linux
         } [os_name]
 except KeyError:
     raise NotImplementedError("os %r is not yet supported" % (os_name,))

=== modified file 'desktopcouch/contacts/contactspicker.py'
--- desktopcouch/contacts/contactspicker.py	2009-08-18 23:00:26 +0000
+++ desktopcouch/contacts/contactspicker.py	2009-08-20 22:14:02 +0000
@@ -28,18 +28,13 @@
 class ContactsPicker(gtk.VBox):
     __gtype_name__ = "ContactsPicker"
 
-    def __init__(self, server_ip = 'http://127.0.0.1:5984/'):
+    def __init__(self):
         """Create a new ContactsPicker widget
-        optional arguments:
-        server_ip - specify and ip and port for the server location.
-        Defaults to http://127.0.0.1:5984
         
         """
 
         gtk.VBox.__init__(self)
 
-        self.server_ip = server_ip
-
         # Create search entry and button
         hbox = gtk.HBox()
         self.pack_start(hbox, False, False, 3)
@@ -51,11 +46,17 @@
         hbox.pack_start(self.search_button, False, False, 3)
 
         # Create CouchWidget to contain list of contacts
-        self.contacts_list = CouchWidget(self.server_ip)
-        self.contacts_list.database = 'contacts'
+        self.contacts_list = CouchWidget('contacts')
         self.contacts_list.editable = False
         self.contacts_list.headings = [ "first_name", "last_name" ]
         self.contacts_list.record_type = CONTACT_RECORD_TYPE
+
+        #Pimp out the columns with some nicer titles
+        #TODO: this should be set up for translatability
+        columns = self.contacts_list.get_columns()
+        columns[0].set_title("First Name")
+        columns[1].set_title("Last Name")
+
         self.contacts_list.show()
         self.pack_start(self.contacts_list, True, True, 3)
 

=== modified file 'desktopcouch/local_files.py'
--- desktopcouch/local_files.py	2009-08-05 11:18:46 +0000
+++ desktopcouch/local_files.py	2009-08-21 22:45:24 +0000
@@ -16,6 +16,8 @@
 # along with desktopcouch.  If not, see <http://www.gnu.org/licenses/>.
 #
 # Author: Stuart Langridge <[e-mail]>
+#         Eric Casteleijn <[e-mail]>
+
 """Specify location of files relevant to desktop CouchDB.
 
 Checks to see whether we're running out of the source tree or not.
@@ -30,48 +32,18 @@
     "Remove .. from paths"
     return os.path.realpath(os.path.join(rootdir, path))
 
-def u1_is_in_source_tree():
-    """If the parent dir of the module directory is "lib", and there is
-    a "tmp" dir and a "README" file, then the u1 code is in a source tree."""
-    try:
-        import ubuntuone
-    except ImportError:
-        return False
-    u1mod_dir, u1mod_file = os.path.split(ubuntuone.__file__)
-    if u1mod_dir.split(os.sep)[-2] != "lib":
-        return False
-
-    proj_root = os.path.join(u1mod_dir, os.pardir, os.pardir)
-    if not os.path.isdir(os.path.join(proj_root, "tmp")):
-        return False
-
-    if not os.path.isfile(os.path.join(proj_root, "README")):
-        return False
-
-    return True
-
-
-if u1_is_in_source_tree():
-    import ubuntuone
-    rootdir = os.path.join(os.path.split(ubuntuone.__file__)[0], "..", "..", "tmp")
-    FILE_INI = mkpath(rootdir, "desktop-couchdb.ini")
-    DIR_DB = mkpath(rootdir, "desktop-couch-files")
-    if not os.path.isdir(DIR_DB): 
-        os.makedirs(DIR_DB)
-else:
-    rootdir = os.path.join(xdg.BaseDirectory.xdg_cache_home, "desktop-couch")
-    if not os.path.isdir(rootdir):
-        os.makedirs(rootdir)
-    config_dir = xdg.BaseDirectory.save_config_path("desktop-couch")
-    FILE_INI = os.path.join(config_dir, "desktop-couchdb.ini")
-    DIR_DB = xdg.BaseDirectory.save_data_path("desktop-couch")
-    
+rootdir = os.path.join(xdg.BaseDirectory.xdg_cache_home, "desktop-couch")
+if not os.path.isdir(rootdir):
+    os.mkdir(rootdir)
+config_dir = xdg.BaseDirectory.save_config_path("desktop-couch")
+FILE_INI = os.path.join(config_dir, "desktop-couchdb.ini")
+DIR_DB = xdg.BaseDirectory.save_data_path("desktop-couch")
+
 FILE_PID = mkpath(rootdir, "desktop-couchdb.pid")
 FILE_LOG = mkpath(rootdir, "desktop-couchdb.log")
 FILE_STDOUT = mkpath(rootdir, "desktop-couchdb.stdout")
 FILE_STDERR = mkpath(rootdir, "desktop-couchdb.stderr")
 
-
 COUCH_EXE = os.environ.get('COUCHDB')
 if not COUCH_EXE:
     for x in os.environ['PATH'].split(':'):
@@ -92,7 +64,6 @@
 
     return chain
 
-
 # You will need to add -b or -k on the end of this
 COUCH_EXEC_COMMAND = [COUCH_EXE, couch_chain_flag(), FILE_INI, '-p', FILE_PID,
   '-o', FILE_STDOUT, '-e', FILE_STDERR]

=== modified file 'desktopcouch/pair/tests/test_network_io.py'
--- desktopcouch/pair/tests/test_network_io.py	2009-07-10 22:13:01 +0000
+++ desktopcouch/pair/tests/test_network_io.py	2009-08-21 21:57:37 +0000
@@ -17,21 +17,14 @@
 
 import pygtk
 pygtk.require('2.0')
-import gtk
 
 from twisted.internet import gtk2reactor
 gtk2reactor.install()
 from twisted.internet import reactor, task
 
-
-if __name__ == "__main__":
-    import sys, os
-    sys.path.append(os.pardir)
-    from couchdb_pairing.network_io import start_send_invitation, ListenForInvitations
-    from couchdb_pairing.dbus_io import get_local_hostname
-else:
-    from ..couchdb_pairing.network_io import start_send_invitation, ListenForInvitations
-    from ..couchdb_pairing.dbus_io import get_local_hostname
+from desktopcouch.pair.couchdb_pairing.network_io import (
+    start_send_invitation, ListenForInvitations)
+from desktopcouch.pair.couchdb_pairing.dbus_io import get_local_hostname
 
 import unittest
 
@@ -49,7 +42,7 @@
     def test_successful_lifespan(self):
 
         secret = "sekrit"
- 
+
         def listener_get_secret_from_user(sender, f, send_secret):
             """Get secret from user.  Try several first."""
             self.assertFalse(f("sek"))
@@ -106,7 +99,7 @@
     def disabled__test_inviter_quits(self):
 
         secret = "sekrit"
- 
+
         def listener_get_secret_from_user(sender, f, send_secret):
             """Get secret from user.  Try several first."""
             self.assertFalse(f("sek"))
@@ -152,7 +145,7 @@
     def disabled__test_listener_quits(self):
 
         secret = "sekrit"
- 
+
         def listener_get_secret_from_user(sender, f, send_secret):
             """Get secret from user.  Try several first."""
             self.assertFalse(f("sek"))
@@ -193,9 +186,3 @@
 
         self.assertEqual(self._listener_socket_state, "closed")
         self.assertEqual(self._inviter_socket_state, "closed")
-
-
-if __name__ == "__main__":
-    import logging
-    logging.basicConfig(level=logging.ERROR)
-    unittest.main()

=== modified file 'desktopcouch/records/couchwidget.py'
--- desktopcouch/records/couchwidget.py	2009-08-19 23:01:09 +0000
+++ desktopcouch/records/couchwidget.py	2009-08-21 23:46:57 +0000
@@ -26,24 +26,48 @@
 class CouchWidget(gtk.TreeView):
     __gtype_name__ = "CouchWidget"
 
-    def __init__(self, server_ip = 'http://127.0.0.1:5984/'):
+    def __init__(
+            self, database_name, record_type=None, headings=None, uri=None):
         """Create a new Couchwidget
+        arguments:
+        database_name - specify the name of the database in the desktop
+        couchdb to use. If the specified database does not exist, it
+        will be created.
+
         optional arguments:
-        server_ip - specify and ip and port for the server location.
-        Defaults to http://127.0.0.1:5984
-        
+        record_type - a string to specify the record_type to use in
+        retrieving and creating records. Note that if no records are
+        set the headings argument must also be used or a RuntimeError
+        will result.
+
+        headings - a list of strings specifying headings to use in
+        the columns of the CouchWidget.
+
+        Note that the CouchWidget uses headings for keys, and visa versa.
+        If a record does not contain a value for a specified value
+        the CouchWidget will simply display an empty string for the
+        value. If the widget is set to editable, the user will be able
+        to add values to the database.
+
         """
 
         gtk.TreeView.__init__(self)
 
-        #assume a local server
-        self.server_ip = server_ip
-
         #set up the default values
-        self.__db = None
+        if type(database_name) is not type(str()):
+            raise TypeError("database_name is required and must be a string")
+
+        #set up default values
         self.__record_type = None
-        self.__headings = None
+        self.__headings = headings
         self.__editable = False
+        self.uri = uri
+
+        #set the datatabase
+        self.database = database_name
+        if record_type is not None:
+            self.record_type = record_type
+
         self.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
 
     @property
@@ -57,7 +81,7 @@
         value. If the widget is set to editable, the user will be able
         to add values to the database.
 
-        Setting this property will cause the widget to reload.        
+        Setting this property will cause the widget to reload.
 
         """
 
@@ -84,20 +108,22 @@
 
         #refresh the treeview if possible
         if self.record_type != None:
-            self.__populate_treeview()(self.record_type)
+            self.__populate_treeview()
 
     @property
     def database(self):
         """database - gets an instance to the CouchDB.
         Set to a string to change the database.
 
-        """        
+        """
         return self.__db
 
     @database.setter
     def database(self, db_name):
-        self.__db = CouchDatabase(db_name, uri=self.server_ip, create=True)
-
+        if self.uri:
+            self.__db = CouchDatabase(db_name, create=True, uri=self.uri)
+        else:
+            self.__db = CouchDatabase(db_name, create=True)
         if self.record_type != None:
             self.__populate_treeview()(self.record_type)
 
@@ -119,30 +145,52 @@
 
     def __populate_treeview(self):
         #if the database is not set up, just return
-        if self.__db == None or self.__headings == None:
+        if self.__db == None:
             return
 
-        #refresh the model structure
-        self.__reset_model()
+        #the cases with headings are complex and hacky
+        #there are the following cases:
+        #1. headings have not been set and cannot be inferred
+        #2. headings have been previously set
+        #3. headings should be inferred from results
+
 
         #retrieve the docs for the record_type, if any
-        results = self.__db.get_records(record_type=self.__record_type,create_view=True)
+        results = self.__db.get_records(
+            record_type=self.__record_type,create_view=True)
+
+        #test for headings case 1 and raise an exception
+        if len(results) < 1 and self.headings == None:
+            raise RuntimeError("""Cannot infer columns for CouchWidget.
+        Ensure that records exist, or define columns using
+        CouchWidget.headings property.
+        """)
+
+        #test for case 2, and set up the model
+        if self.headings is not None:
+            self.__reset_model()
 
         #if headings are already assigned, set up headings and columns
+        #for headings case 2 with or without results
         if self.headings != None:
             self.__make_headings()
 
         first_row = True
         for r in results:
-            #if headings are not set up, infer them from 
-            #the first stored record
+            #handle headings case 3
+            #if headings are not set up, infer them from
             if self.headings == None and first_row:
                 self.headings = []
                 for k in r.value.keys():
                     if not k.startswith("_") and k != "record_type":
                         self.headings.append(k)
                 #now set up the columns and headers
-                self.__make_headings()              
+                self.__make_headings()
+
+                #in headings case 3 the model has not been set yet
+                #so do that now
+                self.__reset_model()
+
             first_row = False
 
             #lists have to match the list_store columns in length
@@ -152,19 +200,19 @@
             row = ["" for i in xrange(col_count)]
 
             #replace the values in the row with the values in the
-            #retrieved rows. If the the key is not in the doc, 
+            #retrieved rows. If the the key is not in the doc,
             #just continue with an empty string
             for i, h in enumerate(self.headings):
                 try:
                     row[i] = r.value[h]
                 except:
                     pass
-    
+
             #set the last value as the document_id, and append
             row[-1] = r.key
             self.list_store.append(row)
 
-        #apply the model tot he Treeview                 
+        #apply the model tot he Treeview
         self.set_model(self.list_store)
 
     def append_row(self, new_row, auto_save = True):
@@ -176,45 +224,48 @@
         to specify all values to include in the new row, as
         append_row will copy all the values starting at position 0
         and will fill in the remaining values with empty strings.
-        
+
         auto_save - if True will immediately commit the row
         to the database. Otherwise, the row won't be saved until
         a cell is edited. Typically should be False if adding an
-        empty row. An empty list will not be autosaved, even if 
+        empty row. An empty list will not be autosaved, even if
         auto_save is set to True.
 
         Defaults to True.
 
         """
 
+        #TODO: add gaurd conditions
+        #throw if no database is set
+
         #lists have to match the list_store columns in length
         #note that the last value is reserved for the doc_id
         col_count = len(self.headings) + 1
         row = ["" for i in xrange(col_count)]
-        
+
         #create a document for autosaving
-        doc = {"record_type":self.record_type}    
-        
+        doc = {"record_type":self.record_type}
+
         #copy the values into the row
         #add to the document in case it needs to be auto saved
         for i, v in enumerate(new_row):
             row[i] = new_row[i]
             doc[self.headings[i]] = new_row[i]
-        
+
         rec = Record(doc)
 
         #auto save non-empty rows
         if auto_save and len(new_row) > 0:
             doc_id = self.__db.put_record(rec)
             row[len(self.headings)] = doc_id #store the id
-            
+
         #add it to the list store
         self.list_store.append(row)
 
     @property
     def selected_rows(self):
-        """ selected_rows - returns a list of dictionaries  
-        for each row selected. Note that the values are not 
+        """ selected_rows - returns a list of dictionaries
+        for each row selected. Note that the values are not
         necessarily the complete dictionary for the records, but rather
         are determined by the headings used for the CouchWidget.
 
@@ -236,7 +287,7 @@
             #get the value for each heading and add it to the row
             for i, h in enumerate(self.headings):
                 row[h] = model.get_value(iter,i)
-    
+
             #add the row to the list
             rows.append(row)
         return rows
@@ -244,7 +295,7 @@
     @property
     def selected_record_ids(self):
         """ selected_record_ids - a list of document ids that are
-        selected in the CouchWidget. Throws an IndexError if 
+        selected in the CouchWidget. Throws an IndexError if
         a specified id is not found in the list when setting
         this property.
 
@@ -269,7 +320,7 @@
     @selected_record_ids.setter
     def selected_record_ids(self, indexes):
         rows = [] #a list of rows to select
-        for id in indexes: 
+        for id in indexes:
             id_found = False #track if the id was found
 
             for i,r in enumerate(self.list_store):
@@ -286,7 +337,7 @@
         selection.unselect_all()
         for r in rows:
             selection.select_path(r)
- 
+
     @property
     def selected_records(self):
         """ selected_records - returns a list of Record objects
@@ -296,7 +347,7 @@
 
         """
         recs = [] #a list of records to return
-        for id in self.selected_record_ids: 
+        for id in self.selected_record_ids:
             #retrieve a record for each id
             recs.append(Record(record_id = id, record_type = self.record_type))
         return recs
@@ -314,12 +365,12 @@
 
         #make a new ListStore
         col_count = len(self.headings) + 1
-        self.list_store = gtk.ListStore(*[gobject.TYPE_STRING for i in xrange(col_count)])
-
+        self.list_store = gtk.ListStore(
+            *[gobject.TYPE_STRING for i in xrange(col_count)])
 
     def __make_headings(self):
         """ __make_headings - internal funciton do not call direclty
-        Sets up the headings and columnss for the TreeView.
+        Sets up the headings and columns for the TreeView.
 
         """
 
@@ -334,12 +385,12 @@
             #create a column and add to the TreeView
             col = gtk.TreeViewColumn(h, rend, text=i)
             self.append_column(col)
-        
+
     def __edited(self, cellrenderertext, path, new_text, col):
         """ __edited - internal signal handler.
         Updates the database if a cell in the Treeview
         has been edited.
-        
+
         """
 
         #get an iterator that points to the edited row
@@ -356,10 +407,10 @@
         if id == "": #the row has not been stored
             #create a document
             doc = {"record_type":self.record_type}
-           
+
             for i, h in enumerate(self.headings):
                 #copy the all the values into the doc
-                doc[h] = self.list_store.get_value(iter,i)      
+                doc[h] = self.list_store.get_value(iter,i)
 
             rec = Record(doc)
             #save the document and store the id
@@ -383,7 +434,7 @@
     disp += "\n\nRecords:\n"
     for r in cw.selected_records:
         disp += str(r) + "\n"
-    
+
     tv.get_buffer().set_text(disp)
 
 def __select_ids(widget, widgets):
@@ -391,7 +442,7 @@
     try:
         cw.selected_record_ids = entry.get_text().split(",")
     except Exception, inst:
-        lbl.set_text(str(inst))        
+        lbl.set_text(str(inst))
 
 if __name__ == "__main__":
     """creates a test CouchWidget if called directly"""
@@ -408,19 +459,12 @@
     win.add(vbox)
 
     #create a test widget with test database values
-    cw = CouchWidget()
-    cw.database = "couch_widget_test"
+    cw = CouchWidget("couch_widget_test", record_type="test_record_type",
+                     headings=["Key1", "Key2", "Key3", "Key4"])
 
     #allow editing
     cw.editable = True
 
-    #create headers/keys
-    cw.headings = ["Key1","Key2","Key3","Key4"]
-
-    #set the record_type for the TreeView
-    #it will not populate without this value being set
-    cw.record_type = "test_record_type"
-
     #create a row with all four columns set
     cw.append_row(["val1","val2","val3","val4"])
 
@@ -442,12 +486,10 @@
     tv.show()
     cw.connect("cursor-changed",__show_selected, (tv,cw))
 
-
     #create ui for testing selection
     id_vbox = gtk.VBox(False, 5)
     id_vbox.show()
 
-
     fb_lbl = gtk.Label("paste ids into the edit box to select them")
     fb_lbl.show()
 

=== modified file 'desktopcouch/records/server.py'
--- desktopcouch/records/server.py	2009-08-10 21:32:52 +0000
+++ desktopcouch/records/server.py	2009-08-21 22:45:24 +0000
@@ -21,7 +21,6 @@
 
 """The Desktop Couch Records API."""
 
-import urllib
 from couchdb import Server
 from couchdb.client import ResourceNotFound, ResourceConflict
 from couchdb.design import ViewDefinition
@@ -155,7 +154,7 @@
 
             # sync_many does nothing if we pass an empty list.  It even gets
             # its design-document from the ViewDefinition items, and if there
-            # are no items, then it has no idea of a design document to 
+            # are no items, then it has no idea of a design document to
             # update.  This is a serious flaw.  Thus, the "else" to follow.
             ViewDefinition.sync_many(self.db, views, remove_missing=True)
         else:
@@ -219,16 +218,16 @@
         special value, None, is analogous to  O_EXCL|O_CREAT .
 
         Set record_type to a string to retrieve records of only that
-        specified type. Otherwise, usse the view to return *all* records. 
-        If there is no view to use or we insist on creating a new view 
+        specified type. Otherwise, usse the view to return *all* records.
+        If there is no view to use or we insist on creating a new view
         and cannot, raise KeyError .
 
-        You can use index notation on the result to get rows with a 
+        You can use index notation on the result to get rows with a
         particular record type.
         =>> results = get_records()
         =>> for foo_document in results["foo"]:
         ...    print foo_document
-        
+
         Use slice notation to apply start-key and end-key options to the view.
         =>> results = get_records()
         =>> people = results[['Person']:['Person','ZZZZ']]
@@ -250,7 +249,7 @@
 
         if not exists:
             self.add_view(view_name, view_map_js, None, design_doc)
-        
+
         viewdata = self.execute_view(view_name, design_doc)
         if record_type is None:
             return viewdata

=== modified file 'desktopcouch/records/tests/__init__.py'
--- desktopcouch/records/tests/__init__.py	2009-07-08 17:48:11 +0000
+++ desktopcouch/records/tests/__init__.py	2009-08-21 22:47:25 +0000
@@ -14,3 +14,27 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with desktopcouch.  If not, see <http://www.gnu.org/licenses/>.
 """Tests for Documents API"""
+
+import os, tempfile
+from desktopcouch.local_files import COUCH_EXE, couch_chain_flag
+from desktopcouch.start_local_couchdb import create_ini_file, run_couchdb
+
+directory = tempfile.mkdtemp()
+ini_path = os.path.join(directory, "test_couchdb.ini")
+log_path = os.path.join(directory, "test_couchdb.log")
+pid_path = os.path.join(directory, "test_couchdb.pid")
+stdout_path = os.path.join(directory, "test_couchdb.stdout")
+stderr_path = os.path.join(directory, "test_couchdb.stderr")
+
+db_dir = os.path.join(directory, "test_couchdb")
+os.mkdir(db_dir)
+
+port = "21224"
+create_ini_file(
+    ini_path=ini_path, db_dir=db_dir, log_path=log_path, port=port)
+exec_command = [
+    COUCH_EXE, couch_chain_flag(), ini_path, '-p', pid_path, '-o', stdout_path,
+    '-e', stderr_path]
+exec_command[2] = ini_path
+run_couchdb(exec_command=exec_command)
+URI = "htpp://localhost:%s" % port

=== modified file 'desktopcouch/records/tests/test_couchwidget.py'
--- desktopcouch/records/tests/test_couchwidget.py	2009-08-19 23:01:09 +0000
+++ desktopcouch/records/tests/test_couchwidget.py	2009-08-21 23:46:57 +0000
@@ -19,76 +19,182 @@
 """Tests for the couchwidget object"""
 
 from testtools import TestCase
+from desktopcouch.records.record import Record
 from desktopcouch.records.server import CouchDatabase
 from desktopcouch.records.couchwidget import CouchWidget
+from desktopcouch.records.tests import URI
+
 
 class TestCouchWidget(TestCase):
     """Test the CouchWidget functionality"""
+
     def setUp(self):
-        self.dbname = "couch_widget_test"
+        self.dbname = self._testMethodName
+        self.db = CouchDatabase(self.dbname, create=True, uri=URI)
         self.record_type = "test_record_type"
 
-    def test_headings_first(self):
-        #create a test widget with test database values
-        cw = CouchWidget()
-        cw.database = self.dbname
-
-        #allow editing
-        cw.editable = True
-
-        #create headers/keys
-        cw.headings = ["Key1","Key2","Key3","Key4"]
-
-        #set the record_type for the TreeView
-        #it will not populate without this value being set
-        cw.record_type = self.record_type
-
-        #create a row with all four columns set
-        cw.append_row(["val1","val2","val3","val4"])
-
-        #create a row with only the second column set
-        cw.append_row(["","val2"])
-
-        #create an empty row (which will not be saved until the user edits it)
-        cw.append_row([])
-
-        self.assertEqual(cw.record_type, self.record_type)
-        self.__delete_db()
-
-    def test_record_type_first(self):
-        #create a test widget with test database values
-        cw = CouchWidget()
-        cw.database = self.dbname
-
-        #allow editing
-        cw.editable = True
-
-        #set the record_type for the TreeView
-        #it will not populate without this value being set
-        cw.record_type = self.record_type
-
-        #create headers/keys
-        cw.headings = ["Key1","Key2","Key3","Key4"]
-
-        #create a row with all four columns set
-        cw.append_row(["val1","val2","val3","val4"])
-
-        #create a row with only the second column set
-        cw.append_row(["","val2"])
-
-        #create an empty row (which will not be saved until the user edits it)
-        cw.append_row([])
-
-        self.assertEqual(cw.record_type, self.record_type)
-        self.__delete_db()        
-
     def tearDown(self):
         """tear down each test"""
-        self.__delete_db()
         #delete the database
-
-    def __delete_db(self):
-        db = CouchDatabase(self.dbname, create=True)
-        del db._server[self.dbname]
-
-      
+        del self.db._server[self.dbname]
+
+    def test_constructor_guarded(self):
+        """Ensure that couchwidget cannot be constructed without a
+        database name.
+        """
+        try:
+            cw = CouchWidget(None, uri=URI)
+        except TypeError, inst:
+            self.assertEqual(
+                inst.args[0],"database_name is required and must be a string")
+
+    def test_new_rows_with_headings(self):
+        """Test a simple creating a couchwidget """
+
+        #create a test widget with test database values
+        cw = CouchWidget(self.dbname, uri=URI)
+
+        #allow editing
+        cw.editable = True
+
+        #create headers/keys
+        cw.headings = ["Key1", "Key2", "Key3", "Key4"]
+
+        #set the record_type for the TreeView
+        #it will not populate without this value being set
+        cw.record_type = self.record_type
+
+        #create a row with all four columns set
+        cw.append_row(["val1", "val2", "val3", "val4"])
+
+        #create a row with only the second column set
+        cw.append_row(["", "val2"])
+
+        #create an empty row (which will not be saved until the user edits it)
+        cw.append_row([])
+
+        #if this all worked, there should be three rows in the model
+        model = cw.get_model()
+        self.assertEqual(len(model), 3)
+
+    def test_no_headings_or_stored_records(self):
+        """test when there is no defined headings and no stored records
+        to infer headings from. Should raise a proper exception.
+        """
+
+        try:
+            #create a test widget with test database values
+            cw = CouchWidget(self.dbname, uri=URI)
+
+            #set the record_type for the TreeView
+            #it will not populate without this value being set
+            cw.record_type = self.record_type
+
+            #create a row with all four columns set
+            cw.append_row(["val1", "val2", "val3", "val4"])
+
+            #create a row with only the second column set
+            cw.append_row(["", "val2"])
+
+            #create an empty row (which will not be saved until the
+            #user edits it)
+            cw.append_row([])
+
+            #if this all worked, there should be three rows in the model
+            model = cw.get_model()
+
+        #should be catching the following exception
+        except RuntimeError, inst:
+            self.assertEquals(
+                inst.args[0].find("Cannot infer columns for CouchWidget"),0)
+
+    def test_all_from_database(self):
+        #create some records
+        db = CouchDatabase(self.dbname, create=True, uri=URI)
+        db.put_record(Record({
+            "key1_1": "val1_1", "key1_2": "val1_2", "key1_3": "val1_3",
+            "record_type": self.record_type}))
+        db.put_record(Record({
+            "key2_1": "val2_1", "key2_2": "val2_2", "key2_3": "val2_3",
+            "record_type": self.record_type}))
+
+        #build the couchwidget
+        cw = CouchWidget(self.dbname, uri=URI)
+        cw.record_type = self.record_type
+        #make sure there are three columns and two rows
+        self.assertEqual(cw.get_model().get_n_columns(),4)
+        self.assertEqual(len(cw.get_model()),2)
+
+    def test_single_col_from_database(self):
+        #create some records
+        self.db.put_record(Record({
+            "key1_1": "val1_1", "key1_2": "val1_2", "key1_3": "val1_3",
+            "record_type": self.record_type}))
+        self.db.put_record(Record({
+            "key1_1": "val2_1", "key1_2": "val2_2", "key1_3": "val2_3",
+            "record_type": self.record_type}))
+        #build the couchwidget
+        cw = CouchWidget(self.dbname, uri=URI)
+        cw.headings = ["key1_1"]
+        cw.record_type = self.record_type
+        #make sure there are three columns and two rows
+        self.assertEqual(cw.get_model().get_n_columns(),2)
+        self.assertEqual(len(cw.get_model()),2)
+
+    def test_optional_record_type_arg(self):
+        """Test a simple creating a couchwidget """
+        #create some records
+        self.db.put_record(Record({
+            "key1_1": "val1_1", "key1_2": "val1_2", "key1_3": "val1_3",
+            "record_type": self.record_type}))
+        self.db.put_record(Record({
+            "key2_1": "val2_1", "key2_2": "val2_2", "key2_3": "val2_3",
+            "record_type": self.record_type}))
+
+        #create a test widget with test database values
+        cw = CouchWidget(self.dbname, record_type=self.record_type, uri=URI)
+
+        #make sure there are three columns and two rows
+        self.assertEqual(cw.get_model().get_n_columns(),4)
+        self.assertEqual(len(cw.get_model()),2)
+
+    def test_optional_args_no_stored_records(self):
+        """Test a simple creating a couchwidget """
+
+        #create a test widget with test database values
+        cw = CouchWidget(
+            self.dbname, record_type=self.record_type,
+            headings=["Key1", "Key2", "Key3", "Key4"], uri=URI)
+
+        #create a row with all four columns set
+        cw.append_row(["val1", "val2", "val3", "val4"])
+
+        #create a row with only the second column set
+        cw.append_row(["", "val2"])
+
+        #create an empty row (which will not be saved until the user edits it)
+        cw.append_row([])
+
+        #if this all worked, there should be three rows in the model
+        model = cw.get_model()
+        self.assertEqual(len(model), 3)
+
+    def test_programatically_add_row(self):
+        """test appending different sized rows programatically"""
+        #create some records
+        self.db.put_record(Record({
+            "key1_1": "val1_1", "key1_2": "val1_2", "key1_3": "val1_3",
+            "record_type": self.record_type}))
+        self.db.put_record(Record({
+            "key2_1": "val2_1", "key2_2": "val2_2", "key2_3": "val2_3",
+            "record_type": self.record_type}))
+
+        #create a test widget with test database values
+        cw = CouchWidget(self.dbname, record_type=self.record_type, uri=URI)
+
+        #allow editing
+        cw.append_row(["boo", "ray"])
+
+        #make sure there are three columns and two rows
+        self.assertEqual(cw.get_model().get_n_columns(),4)
+        self.assertEqual(len(cw.get_model()),3)

=== modified file 'desktopcouch/records/tests/test_server.py'
--- desktopcouch/records/tests/test_server.py	2009-08-12 14:26:40 +0000
+++ desktopcouch/records/tests/test_server.py	2009-08-21 22:45:24 +0000
@@ -17,12 +17,10 @@
 # Authors: Eric Casteleijn <[e-mail]>
 
 """testing database/contact.py module"""
-
 import testtools
-import random
-from desktopcouch.stop_local_couchdb import stop_couchdb
 from desktopcouch.records.server import CouchDatabase
 from desktopcouch.records.record import Record
+from desktopcouch.records.tests import URI
 
 FAKE_RECORD_TYPE = "http://example.org/test"
 
@@ -33,33 +31,38 @@
     }
 }""" % FAKE_RECORD_TYPE
 
+
 class TestCouchDatabase(testtools.TestCase):
     """tests specific for CouchDatabase"""
 
+
     def setUp(self):
         """setup each test"""
         # Connect to CouchDB server
         self.dbname = self._testMethodName
-        self.database = CouchDatabase(self.dbname, create=True)
-
+        self.database = CouchDatabase(
+            self.dbname, create=True, uri=URI)
         #create some records to pull out and test
-        self.database.put_record(Record({"key1_1":"val1_1","key1_2":"val1_2","key1_3":"val1_3","record_type":"test.com"}))
-        self.database.put_record(Record({"key2_1":"val2_1","key2_2":"val2_2","key2_3":"val2_3","record_type":"test.com"}))
-        self.database.put_record(Record({"key13_1":"va31_1","key3_2":"val3_2","key3_3":"val3_3","record_type":"test.com"}))
+        self.database.put_record(Record({
+            "key1_1": "val1_1", "key1_2": "val1_2", "key1_3": "val1_3",
+            "record_type": "test.com"}))
+        self.database.put_record(Record({
+            "key2_1": "val2_1", "key2_2": "val2_2", "key2_3": "val2_3",
+            "record_type": "test.com"}))
+        self.database.put_record(Record({
+            "key13_1": "va31_1", "key3_2": "val3_2", "key3_3": "val3_3",
+            "record_type": "test.com"}))
 
     def tearDown(self):
         """tear down each test"""
         del self.database._server[self.dbname]
-        if random.choice([1,2,3,4]) == 3:  # don't harass it unnecessarily
-            print u"\u2620",  # death
-            stop_couchdb()
 
     def test_get_records_by_record_type_save_view(self):
         """Test getting mutliple records by type"""
-        records = self.database.get_records(record_type="test.com",create_view=True)
+        records = self.database.get_records(
+            record_type="test.com",create_view=True)
         self.assertEqual(3,len(records))
 
-
     def test_get_record(self):
         """Test getting a record."""
         record = Record({'record_number': 0}, record_type="http://example.com/")
@@ -122,14 +125,18 @@
                 }"""
 
         # add two and delete two.
-        self.assertRaises(KeyError, self.database.delete_view, view1_name, design_doc)
-        self.assertRaises(KeyError, self.database.delete_view, view2_name, design_doc)
+        self.assertRaises(
+            KeyError, self.database.delete_view, view1_name, design_doc)
+        self.assertRaises(
+            KeyError, self.database.delete_view, view2_name, design_doc)
         self.database.add_view(view1_name, map_js, reduce_js, design_doc)
         self.database.add_view(view2_name, map_js, reduce_js, design_doc)
         self.database.delete_view(view1_name, design_doc)
-        self.assertRaises(KeyError, self.database.delete_view, view1_name, design_doc)
+        self.assertRaises(
+            KeyError, self.database.delete_view, view1_name, design_doc)
         self.database.delete_view(view2_name, design_doc)
-        self.assertRaises(KeyError, self.database.delete_view, view2_name, design_doc)
+        self.assertRaises(
+            KeyError, self.database.delete_view, view2_name, design_doc)
 
     def test_func_get_records(self):
         record_ids_we_care_about = set()

=== modified file 'desktopcouch/start_local_couchdb.py'
--- desktopcouch/start_local_couchdb.py	2009-08-19 16:00:01 +0000
+++ desktopcouch/start_local_couchdb.py	2009-08-21 22:45:24 +0000
@@ -16,6 +16,8 @@
 # along with desktopcouch.  If not, see <http://www.gnu.org/licenses/>.
 #
 # Author: Stuart Langridge <[e-mail]>
+#         Eric Casteleijn <[e-mail]>
+
 """
 Start local CouchDB server.
 Steps:
@@ -54,40 +56,31 @@
         fd.write("\n")
     fd.close()
 
-def create_ini_file():
+def create_ini_file(
+        ini_path=local_files.FILE_INI, db_dir=local_files.DIR_DB,
+        log_path=local_files.FILE_LOG, port="0"):
     """Write CouchDB ini file if not already present"""
-    # FIXME add update trigger folder
-    #update_trigger_dir = [
-    #    'lib', 'canonical', 'ubuntuone', 'cloud_server', 'update_triggers']
-    #
-    #timestamp_trigger = os.path.join(
-    #    *update_trigger_dir + ['timestamp_trigger.py'])
-    #update_trigger =  os.path.join(
-    #    *update_trigger_dir + ['update_trigger.py'])
-
-    if os.path.exists(local_files.FILE_INI):
+    if os.path.exists(ini_path):
         return
-
-    local = {
+    ini = {
         'couchdb': {
-            'database_dir': local_files.DIR_DB,
-            'view_index_dir': local_files.DIR_DB,
+            'database_dir': db_dir,
+            'view_index_dir': db_dir,
         },
         'httpd': {
             'bind_address': '127.0.0.1',
-            'port': "0",
+            'port': port,
         },
         'log': {
-            'file': local_files.FILE_LOG,
+            'file': log_path,
             'level': 'info',
         },
     }
-
-    dump_ini(local, local_files.FILE_INI)
-
-def run_couchdb():
+    dump_ini(ini, ini_path)
+
+def run_couchdb(exec_command=local_files.COUCH_EXEC_COMMAND):
     """Actually start the CouchDB process"""
-    local_exec = local_files.COUCH_EXEC_COMMAND + ['-b']
+    local_exec = exec_command + ['-b']
     try:
         # subprocess is buggy.  Chad patched, but that takes time to propagate.
         proc = subprocess.Popen(local_exec)
@@ -109,39 +102,42 @@
 
 def update_design_documents():
     """Check system design documents and update any that need updating
-    
-    A database should be created if 
+
+    A database should be created if
       $XDG_DATA_DIRs/desktop-couch/databases/dbname/database.cfg exists
     Design docs are defined by the existence of
-      $XDG_DATA_DIRs/desktop-couch/databases/dbname/_design/designdocname/views/viewname/map.js 
+      $XDG_DATA_DIRs/desktop-couch/databases/dbname/_design/designdocname/views/viewname/map.js
       reduce.js may also exist in the same folder.
     """
     for base in xdg.BaseDirectory.xdg_data_dirs:
-        db_spec = os.path.join(base, "desktop-couch", "databases", "*", "database.cfg")
+        db_spec = os.path.join(
+            base, "desktop-couch", "databases", "*", "database.cfg")
         for database_path in glob.glob(db_spec):
             database_root = os.path.split(database_path)[0]
             database_name = os.path.split(database_root)[1]
             # Just the presence of database.cfg is enough to create the database
             db = CouchDatabase(database_name, create=True)
             # look for design documents
-            dd_spec = os.path.join(database_root, "_design", "*", "views", "*", "map.js")
+            dd_spec = os.path.join(
+                database_root, "_design", "*", "views", "*", "map.js")
             for dd_path in glob.glob(dd_spec):
                 view_root = os.path.split(dd_path)[0]
                 view_name = os.path.split(view_root)[1]
                 dd_root = os.path.split(os.path.split(view_root)[0])[0]
                 dd_name = os.path.split(dd_root)[1]
-                
+
                 def load_js_file(filename_no_extension):
-                    fn = os.path.join(view_root, "%s.js" % (filename_no_extension))
+                    fn = os.path.join(
+                        view_root, "%s.js" % (filename_no_extension))
                     if not os.path.isfile(fn): return None
                     fp = open(fn)
                     data = fp.read()
                     fp.close()
                     return data
-                
+
                 mapjs = load_js_file("map")
                 reducejs = load_js_file("reduce")
-                
+
                 # XXX check whether this already exists or not, rather
                 # than inefficiently just overwriting it regardless
                 db.add_view(view_name, mapjs, reducejs, dd_name)
@@ -150,13 +146,16 @@
     """Write out an HTML document that the user can bookmark to find their DB"""
     bookmark_file = os.path.join(local_files.DIR_DB, "couchdb.html")
 
-    if os.path.exists(os.path.join(os.path.split(__file__)[0], "../data/couchdb.tmpl")):
-        bookmark_template = os.path.join(os.path.split(__file__)[0], "../data/couchdb.tmpl")
+    if os.path.exists(
+            os.path.join(os.path.split(__file__)[0], "../data/couchdb.tmpl")):
+        bookmark_template = os.path.join(
+            os.path.split(__file__)[0], "../data/couchdb.tmpl")
     else:
         for base in xdg.BaseDirectory.xdg_data_dirs:
             template_path = os.path.join(base, "desktopcouch", "couchdb.tmpl")
             if os.path.exists(template_path):
-                bookmark_template = os.path.join(os.path.split(__file__)[0], template_path)
+                bookmark_template = os.path.join(
+                    os.path.split(__file__)[0], template_path)
 
     fp = open(bookmark_template)
     html = fp.read()
@@ -175,7 +174,8 @@
             continue
 
     if port is None:
-        print "We couldn't find desktop-CouchDB's network port.  Bookmark file not written."
+        print ("We couldn't find desktop-CouchDB's network port.  Bookmark "
+               "file not written.")
         try:
             os.remove(bookmark_file)
         except OSError:

=== modified file 'desktopcouch/tests/test_local_files.py'
--- desktopcouch/tests/test_local_files.py	2009-08-04 12:31:15 +0000
+++ desktopcouch/tests/test_local_files.py	2009-08-21 21:57:37 +0000
@@ -1,28 +1,15 @@
 """testing desktopcouch/local_files.py module"""
 
 import testtools
-import os
 
 class TestLocalFiles(testtools.TestCase):
     """Testing that local files returns the right things"""
     def test_all_files_returned(self):
         "Does local_files list all the files that it needs to?"
         import desktopcouch.local_files
-        for required in ["FILE_LOG", "FILE_INI", "FILE_PID", "FILE_STDOUT",
-          "FILE_STDERR", "DIR_DB", "COUCH_EXE", "COUCH_EXEC_COMMAND"]:
+        for required in [
+                "FILE_LOG", "FILE_INI", "FILE_PID", "FILE_STDOUT",
+                "FILE_STDERR", "DIR_DB", "COUCH_EXE", "COUCH_EXEC_COMMAND"]:
             self.assertTrue(required in dir(desktopcouch.local_files))
 
-    def DISABLED_test_file_locations(self):
-        """This stopped working when we split desktopcouch into its own
-        top-level package."""
 
-        "Are the files in local_files actually correct?"
-        # Only test one file; if one's right the others should be too
-        import desktopcouch.local_files
-        thisfolder = os.path.split(__file__)[0]
-        tmpfolder = os.path.join(thisfolder, "..", "..", "..", "..", "tmp")
-        pidfile = os.path.join(tmpfolder, "desktop-couchdb.pid")
-        flatpidfile = os.path.realpath(pidfile)
-        self.assertEqual(flatpidfile, desktopcouch.local_files.FILE_PID)
-    
-    

=== modified file 'desktopcouch/tests/test_start_local_couchdb.py'
--- desktopcouch/tests/test_start_local_couchdb.py	2009-08-20 18:20:18 +0000
+++ desktopcouch/tests/test_start_local_couchdb.py	2009-08-21 21:57:37 +0000
@@ -3,7 +3,8 @@
 import testtools
 import os, tempfile, sys
 import desktopcouch
-sys.path.append(os.path.join(os.path.split(desktopcouch.__file__)[0], "..", "contrib"))
+sys.path.append(
+    os.path.join(os.path.split(desktopcouch.__file__)[0], "..", "contrib"))
 from mocker import Mocker
 
 class TestUpdateDesignDocuments(testtools.TestCase):
@@ -16,37 +17,37 @@
         self.tmpdir = tempfile.mkdtemp(dir=branch_root)
         self.basedir = os.path.join(self.tmpdir, "desktop-couch")
         os.mkdir(self.basedir)
-        DIRS = [ 
-        "databases", 
-          "databases/nocfg", 
-          "databases/cfg", 
-          "databases/cfg_and_empty_design", 
-            "databases/cfg_and_empty_design/_design", 
+        DIRS = [
+        "databases",
+          "databases/nocfg",
+          "databases/cfg",
+          "databases/cfg_and_empty_design",
+            "databases/cfg_and_empty_design/_design",
           "databases/cfg_and_design_no_views",
-            "databases/cfg_and_design_no_views/_design", 
-            "databases/cfg_and_design_no_views/_design/doc1", 
-            "databases/cfg_and_design_no_views/_design/doc1/views", 
+            "databases/cfg_and_design_no_views/_design",
+            "databases/cfg_and_design_no_views/_design/doc1",
+            "databases/cfg_and_design_no_views/_design/doc1/views",
           "databases/cfg_and_design_one_view_no_map",
-            "databases/cfg_and_design_one_view_no_map/_design", 
-            "databases/cfg_and_design_one_view_no_map/_design/doc1", 
-            "databases/cfg_and_design_one_view_no_map/_design/doc1/views", 
-            "databases/cfg_and_design_one_view_no_map/_design/doc1/views/view1", 
+            "databases/cfg_and_design_one_view_no_map/_design",
+            "databases/cfg_and_design_one_view_no_map/_design/doc1",
+            "databases/cfg_and_design_one_view_no_map/_design/doc1/views",
+            "databases/cfg_and_design_one_view_no_map/_design/doc1/views/view1",
           "databases/cfg_and_design_one_view_map_no_reduce",
-            "databases/cfg_and_design_one_view_map_no_reduce/_design", 
-            "databases/cfg_and_design_one_view_map_no_reduce/_design/doc1", 
-            "databases/cfg_and_design_one_view_map_no_reduce/_design/doc1/views", 
-            "databases/cfg_and_design_one_view_map_no_reduce/_design/doc1/views/view1", 
+            "databases/cfg_and_design_one_view_map_no_reduce/_design",
+            "databases/cfg_and_design_one_view_map_no_reduce/_design/doc1",
+            "databases/cfg_and_design_one_view_map_no_reduce/_design/doc1/views",
+            "databases/cfg_and_design_one_view_map_no_reduce/_design/doc1/views/view1",
           "databases/cfg_and_design_one_view_map_reduce",
-            "databases/cfg_and_design_one_view_map_reduce/_design", 
-            "databases/cfg_and_design_one_view_map_reduce/_design/doc1", 
-            "databases/cfg_and_design_one_view_map_reduce/_design/doc1/views", 
-            "databases/cfg_and_design_one_view_map_reduce/_design/doc1/views/view1", 
+            "databases/cfg_and_design_one_view_map_reduce/_design",
+            "databases/cfg_and_design_one_view_map_reduce/_design/doc1",
+            "databases/cfg_and_design_one_view_map_reduce/_design/doc1/views",
+            "databases/cfg_and_design_one_view_map_reduce/_design/doc1/views/view1",
           "databases/cfg_and_design_two_views_map_reduce",
-            "databases/cfg_and_design_two_views_map_reduce/_design", 
-            "databases/cfg_and_design_two_views_map_reduce/_design/doc1", 
-            "databases/cfg_and_design_two_views_map_reduce/_design/doc1/views", 
-            "databases/cfg_and_design_two_views_map_reduce/_design/doc1/views/view1", 
-            "databases/cfg_and_design_two_views_map_reduce/_design/doc1/views/view2", 
+            "databases/cfg_and_design_two_views_map_reduce/_design",
+            "databases/cfg_and_design_two_views_map_reduce/_design/doc1",
+            "databases/cfg_and_design_two_views_map_reduce/_design/doc1/views",
+            "databases/cfg_and_design_two_views_map_reduce/_design/doc1/views/view1",
+            "databases/cfg_and_design_two_views_map_reduce/_design/doc1/views/view2",
           ]
         FILES = {
             "databases/cfg/database.cfg": "",
@@ -78,7 +79,7 @@
             fp = open(os.path.join(self.basedir, f), "w")
             fp.write(data)
             fp.close()
-    
+
     def tearDown(self):
         # delete temp folder
         for root, dirs, files in os.walk(self.tmpdir, topdown=False):
@@ -86,10 +87,10 @@
                 os.remove(os.path.join(root, name))
             for name in dirs:
                 os.rmdir(os.path.join(root, name))
-        os.rmdir(self.tmpdir)    
+        os.rmdir(self.tmpdir)
 
     def test_create_databases_and_design_docs(self):
-        """Are databases and design documents correctly 
+        """Are databases and design documents correctly
            created from the filesystem?"""
         # poke local_files so that it returns our temp folder
         os.environ['XDG_DATA_HOME'] = self.tmpdir
@@ -101,11 +102,11 @@
         import xdg.BaseDirectory
         reload(xdg.BaseDirectory)
 
-        
+
         # Mock CouchDatabase
         mocker = Mocker()
         couchdb = mocker.replace("desktopcouch.records.server.CouchDatabase")
-        
+
         # databases that should be created
         couchdb("cfg", create=True)
         couchdb("cfg_and_empty_design", create=True)
@@ -114,28 +115,28 @@
         couchdb("cfg_and_design_one_view_map_no_reduce", create=True)
         dbmock1 = mocker.mock()
         mocker.result(dbmock1)
-        dbmock1.add_view("view1", "cfg_and_design_one_view_map_no_reduce:map", 
+        dbmock1.add_view("view1", "cfg_and_design_one_view_map_no_reduce:map",
           None, "doc1")
         couchdb("cfg_and_design_one_view_map_reduce", create=True)
         dbmock2 = mocker.mock()
         mocker.result(dbmock2)
-        dbmock2.add_view("view1", "cfg_and_design_one_view_map_reduce:map", 
+        dbmock2.add_view("view1", "cfg_and_design_one_view_map_reduce:map",
           "cfg_and_design_one_view_map_reduce:reduce", "doc1")
         couchdb("cfg_and_design_two_views_map_reduce", create=True)
         dbmock3 = mocker.mock()
         mocker.result(dbmock3)
-        dbmock3.add_view("view1", "cfg_and_design_two_views_map_reduce:map1", 
+        dbmock3.add_view("view1", "cfg_and_design_two_views_map_reduce:map1",
           "cfg_and_design_two_views_map_reduce:reduce1", "doc1")
-        dbmock3.add_view("view2", "cfg_and_design_two_views_map_reduce:map2", 
+        dbmock3.add_view("view2", "cfg_and_design_two_views_map_reduce:map2",
           "cfg_and_design_two_views_map_reduce:reduce2", "doc1")
-        
+
         # actually call update_design_documents to confirm that it creates
         # all the right things
         mocker.replay()
         from desktopcouch.start_local_couchdb import update_design_documents
         update_design_documents()
-        
+
         mocker.restore()
         mocker.verify()
-        
+