Merge lp:~mandel/desktopcouch/mock_db_for_records into lp:desktopcouch

[Manuel de la Peña]

Moved trash db to be an instance variable for bug #697661
Fixed how deleted records ids are generated for bug #697636
Added unit tests in which the db access is mocked for bug #674587

Moved trash db to be an instance variable for bug #697661
Fixed how deleted records ids are generated for bug #697636
Added unit tests in which the db access is mocked for bug #674587

[Vincenzo Di Somma (vds)]

review: Approve

[Eric Casteleijn (thisfred)]

I like it!

review: Approve

=== modified file 'desktopcouch/application/server.py'
--- desktopcouch/application/server.py	2010-11-26 20:30:30 +0000
+++ desktopcouch/application/server.py	2011-01-05 17:11:33 +0000
@@ -64,7 +64,7 @@
 
     def __init__(self, database, uri=None, record_factory=None,
                  create=False, server_class=DesktopServer, oauth_tokens=None,
-                 ctx=None):
+                 ctx=None, views_factory=None):
         if ctx is None:
             ctx = DEFAULT_CONTEXT
         self.ctx = ctx
@@ -72,7 +72,7 @@
         super(DesktopDatabase, self).__init__(
             database, uri, record_factory=record_factory,
             create=create, server_class=server_class,
-            oauth_tokens=oauth_tokens, ctx=ctx)
+            oauth_tokens=oauth_tokens, ctx=ctx, views_factory=views_factory)
 
     # pylint: disable=W0221
     # Arguments number differs from overridden method
 
=== modified file 'desktopcouch/records/database.py'
--- desktopcouch/records/database.py	2011-01-05 13:48:31 +0000
+++ desktopcouch/records/database.py	2011-01-05 17:11:33 +0000
@@ -26,7 +26,6 @@
 # pylint: disable=W0402
 import string
 # pylint: enable=W0402
-import uuid
 import warnings
 
 from time import time
@@ -106,7 +105,12 @@
     """A desktopcouch.records specific CouchDb database."""
 
     def __init__(self, database, uri, record_factory=None, create=False,
-                 server_class=Server, **server_class_extras):
+                 views_factory=None, server_class=Server,
+                 **server_class_extras):
+        if views_factory is None:
+            self._views_factory = ViewDefinition
+        else:
+            self._views_factory = views_factory
         self.server_uri = uri
         self._database_name = database
         self.record_factory = record_factory or Record
@@ -115,6 +119,7 @@
         self._server_class_extras = server_class_extras
         self._server = None
         self.db = None
+        self._dctrash = None
         self._reconnect()
         self._changes_since = self.db.info()["update_seq"]
         self._changes_last_used = 0  # Immediate run works.
@@ -182,40 +187,45 @@
 
     def put_record(self, record):
         """Put a record in back end storage."""
-        if not record.record_id:
+        record_id = record.record_id
+        record_data = record._data  # pylint: disable=W0212
+        if not record_id:
             # Do not rely on couchdb to create an ID for us.
             # pylint: disable=E1101
-            record.record_id = base_n(uuid4().int, 62)
+            record_id = base_n(uuid4().int, 62)
+            record.record_id = record_id
             # pylint: enable=E1101
-        self.db[record.record_id] = record._data  # pylint: disable=W0212
+        self.db[record_id] = record_data
 
         # pylint: disable=W0212
         for attachment_name in getattr(record, "_detached", []):
-            self.db.delete_attachment(record._data, attachment_name)
+            self.db.delete_attachment(record_data, attachment_name)
 
         for attachment_name in record.list_attachments():
             data, content_type = record.attachment_data(attachment_name)
-            self.db.put_attachment(record._data,
+            self.db.put_attachment(record_data,
                                    data,
                                    attachment_name,
                                    content_type)
         # pylint: enable=W0212
 
-        return record.record_id
+        return record_id
 
     def put_records_batch(self, batch):
         """Put a batch of records in back end storage."""
         # used to access fast the record
         records_hash = {}
         for record in batch:
-            if not record.record_id:
+            record_id = record.record_id
+            if not record_id:
                 # Do not rely on couchdb to create an ID for us.
                 # pylint: disable=E1101
-                record.record_id = base_n(uuid4().int, 62)
+                record_id = base_n(uuid4().int, 62)
+                record.record_id = record_id
                 # pylint: enable=E1101
-            records_hash[record.record_id] = record
+            records_hash[record_id] = record
         # although with a single record we need to test for the
-        # revisison, with a batch we do not, but we have to make sure
+        # revision, with a batch we do not, but we have to make sure
         # that we did not get an error
         # pylint: disable=W0212
         batch_put_result = self.db.update([record._data for record in batch])
@@ -223,15 +233,16 @@
             success, docid, rev_or_exc = current_tuple
             if success:
                 record = records_hash[docid]
+                record_data = record._data
                 # set the new rev
-                record._data["_rev"] = rev_or_exc
+                record_data["_rev"] = rev_or_exc
                 for attachment_name in getattr(record, "_detached", []):
-                    self.db.delete_attachment(record._data, attachment_name)
+                    self.db.delete_attachment(record_data, attachment_name)
                 for attachment_name in record.list_attachments():
                     data, content_type = record.attachment_data(
                         attachment_name)
                     self.db.put_attachment(
-                        {"_id": record.record_id, "_rev": record["_rev"]},
+                        {"_id": docid, "_rev": rev_or_exc},
                         data, attachment_name, content_type)
         # pylint: enable=W0212
         # all success record have the blobs added we return result of
@@ -323,12 +334,15 @@
         """Delete record with given id"""
         record = self.get_record(record_id)
         new_record = copy.deepcopy(record)
-        dctrash = self.__class__(
-            database=DCTRASH,
-            uri=self.server_uri,
-            create=True,
-            **self._server_class_extras)
-        new_record.record_id = str(uuid.uuid4())
+        if not self._dctrash:
+            self._dctrash = self.__class__(
+                database=DCTRASH,
+                uri=self.server_uri,
+                create=True,
+                **self._server_class_extras)
+        # pylint: disable=E1101
+        new_record.record_id = base_n(uuid4().int, 62)
+        # pylint: enable=E1101
         del new_record._data['_rev']
         try:
             del new_record._data['_attachments']
@@ -339,7 +353,7 @@
             {'original_database_name': self._database_name,
              'original_id': record_id}}
         del self.db[record_id]
-        return dctrash.put_record(new_record)
+        return self._dctrash.put_record(new_record)
     # pylint: enable=W0212
 
     def delete_view(self, view_name, design_doc=DEFAULT_DESIGN_DOCUMENT):
@@ -362,7 +376,7 @@
         if len(view_container) > 0:
             # Construct a new list of objects representing all views to have.
             views = [
-                    ViewDefinition(design_doc, k, v.get("map"),
+                    self._views_factory(design_doc, k, v.get("map"),
                                    v.get("reduce"))
                     for k, v in view_container.iteritems()]
             # Push back a new batch of view.  Pray to Eris that this doesn't
@@ -372,7 +386,7 @@
             # its design-document from the ViewDefinition items, and if there
             # 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)
+            self._views_factory.sync_many(self.db, views, remove_missing=True)
         else:
             # There are no views left in this design document.
 
@@ -401,7 +415,7 @@
         if design_doc is None:
             design_doc = view_name
 
-        view = ViewDefinition(design_doc, view_name, map_js, reduce_js)
+        view = self._views_factory(design_doc, view_name, map_js, reduce_js)
         view.sync(self.db)
         assert self.view_exists(view_name, design_doc)
 
 
=== added file 'desktopcouch/records/tests/test_mocked_server.py'
--- desktopcouch/records/tests/test_mocked_server.py	1970-01-01 00:00:00 +0000
+++ desktopcouch/records/tests/test_mocked_server.py	2011-01-05 17:11:33 +0000
@@ -0,0 +1,519 @@
+# Copyright 2009-2010 Canonical Ltd.
+#
+# This file is part of desktopcouch.
+#
+#  desktopcouch is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# as published by the Free Software Foundation.
+#
+# desktopcouch is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with desktopcouch.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Authors: Manuel de la Pena<[e-mail]>
+"""Test the database code mocking the db access."""
+
+from couchdb.http import  ResourceNotFound
+from mocker import MockerTestCase, ANY, KWARGS
+
+from desktopcouch.application.server import DesktopDatabase
+from desktopcouch.records.database import NoSuchDatabase
+
+
+# disable pylint warnings that are common due to the nature of the tests
+# pylint: disable=W0104, W0201, W0212
+def set_database_expectations(testcase):
+    """Set the expectations for the db creation."""
+    testcase.server_class(testcase.uri, ctx=testcase.ctx,
+        oauth_tokens=testcase.oauth_tokens)
+    testcase.mocker.result(testcase.server_class)
+    testcase.dbname in testcase.server_class
+    testcase.mocker.result(True)
+    testcase.server_class[testcase.dbname]
+    testcase.mocker.result(testcase.server_class)
+    testcase.server_class.info()
+    testcase.mocker.result({'update_seq': []})
+
+
+def set_create_view_expectations(testcase):
+    """Set the expectations for when a view is created."""
+    # set expectations for the creation of the view
+    testcase.views_factory(ANY, ANY, ANY, ANY)
+    testcase.mocker.result(testcase.views_factory)
+    testcase.views_factory.sync(testcase.server_class)
+    # assert that is was added, shall we be mocking this?
+    testcase.server_class[ANY]['views']
+    testcase.mocker.result(testcase.server_class)
+    ANY in testcase.server_class
+    testcase.mocker.result(True)
+
+
+def create_database(testcase):
+    """Create a database to be used in the testcase."""
+    testcase.database = DesktopDatabase(testcase.dbname, uri=testcase.uri,
+        record_factory=testcase.record_factory, create=True,
+        server_class=testcase.server_class,
+        oauth_tokens=testcase.oauth_tokens, ctx=testcase.ctx,
+        views_factory=testcase.views_factory)
+
+
+class TestMockedCouchDatabaseDeprecated(MockerTestCase):
+    """Test the deprecated API."""
+
+    def setUp(self):
+        """Setup each test."""
+        super(TestMockedCouchDatabaseDeprecated, self).setUp()
+        # set mocked objects
+        self.record_factory = self.mocker.mock()
+        self.server_class = self.mocker.mock()
+        self.oauth_tokens = self.mocker.mock()
+        self.ctx = self.mocker.mock()
+        self.views_factory = self.mocker.mock()
+        # set not mocked required data
+        self.uri = 'uri'
+        self.dbname = self._testMethodName
+        self.database = None
+
+    def set_database_expectations(self):
+        """Set the expectations for the creation of the db."""
+        self.server_class(self.uri, ctx=self.ctx,
+            oauth_tokens=self.oauth_tokens)
+        self.mocker.result(self.server_class)
+        self.dbname in self.server_class
+        self.mocker.result(True)
+        self.server_class[self.dbname]
+        self.mocker.result(self.server_class)
+        self.server_class.info()
+        self.mocker.result({'update_seq': []})
+
+    def test_get_records_by_record_type_saved_view(self):
+        """Test getting multiple records by type."""
+        record_type = 'test.com'
+        set_database_expectations(self)
+        # set expectations for the view_exists operation
+        self.server_class[ANY]['views']
+        self.mocker.result(self.server_class)
+        ANY in self.server_class
+        self.mocker.result(True)
+        # set expectations for the execution
+        self.server_class.view(ANY, KWARGS)
+        self.mocker.result({record_type: record_type})
+        self.mocker.replay()
+        create_database(self)
+        records = self.database.get_records(record_type=record_type,
+            create_view=True)
+        self.assertEqual(record_type, records)
+
+    def test_get_records_by_record_type_new_view(self):
+        """Test getting multiple record and create the view."""
+        record_type = 'test.com'
+        set_database_expectations(self)
+        # set expectations for the view_exists operation
+        self.server_class[ANY]['views']
+        self.mocker.result(self.server_class)
+        ANY in self.server_class
+        self.mocker.result(False)
+        set_create_view_expectations(self)
+        # set expectations for the execution
+        self.server_class.view(ANY, KWARGS)
+        self.mocker.result({record_type: record_type})
+        self.mocker.replay()
+        create_database(self)
+        records = self.database.get_records(record_type=record_type,
+            create_view=True)
+        self.assertEqual(record_type, records)
+
+    def test_get_records_by_record_type_new_view_not_create(self):
+        """Test getting the records when the view does not exist."""
+        record_type = 'test.com'
+        set_database_expectations(self)
+        # assert that is was added, shall we be mocking this?
+        self.server_class[ANY]['views']
+        self.mocker.result(self.server_class)
+        ANY in self.server_class
+        self.mocker.result(True)
+        # set expectations for the execution
+        self.server_class.view(ANY, KWARGS)
+        self.mocker.result({record_type: record_type})
+        self.mocker.replay()
+        create_database(self)
+        self.assertRaises(KeyError, self.database.get_records,
+            (record_type, False))
+
+    def test_get_records_by_record_type_saved_view_false_create(self):
+        """Test calling the view and do not create it."""
+        record_type = 'test.com'
+        set_database_expectations(self)
+        # set expectations for the view_exists operation
+        self.server_class[ANY]['views']
+        self.mocker.result(self.server_class)
+        ANY in self.server_class
+        self.mocker.result(True)
+        # set expectations for the execution
+        self.server_class.view(ANY, KWARGS)
+        self.mocker.result({record_type: record_type})
+        self.mocker.replay()
+        create_database(self)
+        records = self.database.get_records(record_type=record_type,
+            create_view=False)
+        self.assertEqual(record_type, records)
+
+
+class TestMockedDesktopDatabase(MockerTestCase):
+    """Test case for DesktopDatabase."""
+
+    def setUp(self):
+        """setup each test"""
+        super(TestMockedDesktopDatabase, self).setUp()
+        # set mocked objects
+        self.record_factory = self.mocker.mock()
+        self.server_class = self.mocker.mock()
+        self.oauth_tokens = self.mocker.mock()
+        self.ctx = self.mocker.mock()
+        self.views_factory = self.mocker.mock()
+        # set not mocked required data
+        self.uri = 'uri'
+        self.dbname = self._testMethodName
+        self.database = None
+
+    def _set_get_all_records_expectations(self, record_type, view_result,
+        records):
+        """Set the common expectations for the get_all_records call."""
+        # replace the transform to records funtion which is used to
+        # return records instead of view results
+        transform_to_records = self.mocker.replace(
+            'desktopcouch.records.database.transform_to_records')
+        self.server_class.view(ANY, KWARGS)
+        self.mocker.result(view_result)
+        transform_to_records(record_type)
+        self.mocker.result(records)
+
+    def test_database_not_exists(self):
+        """Test that the database does not exist."""
+        # set expectations so that the server class returns that
+        # the db does ot exist.
+        self.server_class(self.uri, ctx=self.ctx,
+            oauth_tokens=self.oauth_tokens)
+        self.mocker.result(self.server_class)
+        self.dbname in self.server_class
+        self.mocker.result(False)
+        self.mocker.replay()
+        self.assertRaises(NoSuchDatabase, DesktopDatabase, self.dbname,
+            uri=self.uri, record_factory=self.record_factory, create=False,
+            server_class=self.server_class, oauth_tokens=self.oauth_tokens,
+            ctx=self.ctx, views_factory=self.views_factory)
+
+    def test_get_records_by_record_type_present_view(self):
+        """Test getting mutliple records by type with a present view."""
+        record_type = 'test.com'
+        view_result = {record_type: record_type}
+        records = ['first', 'second']
+        set_database_expectations(self)
+        self._set_get_all_records_expectations(record_type, view_result,
+            records)
+        self.mocker.replay()
+        create_database(self)
+        self.assertEqual(records,
+            self.database.get_all_records(record_type=record_type))
+
+    def test_get_records_by_record_type_missing_view(self):
+        """Test getting mutliple records by type with a present view."""
+        record_type = 'test.com'
+        view_result = {record_type: record_type}
+        records = ['first', 'second']
+        set_database_expectations(self)
+        self.server_class.view(ANY, KWARGS)
+        # raise exception so that the view has to be created.
+        self.mocker.throw(ResourceNotFound)
+        set_create_view_expectations(self)
+        # set the expectations to be used after the creation of the view
+        self._set_get_all_records_expectations(record_type, view_result,
+            records)
+        self.mocker.replay()
+        create_database(self)
+        self.assertEqual(records,
+            self.database.get_all_records(record_type=record_type))
+
+    def test_get_present_record_no_attachments(self):
+        """Test getting a record."""
+        record_id = 'test_record'
+        data = {record_id: record_id}
+        record_mock = self.mocker.mock()
+        set_database_expectations(self)
+        self.server_class[record_id]
+        self.mocker.result(data)
+        self.record_factory(data=data)
+        self.mocker.result(record_mock)
+        self.mocker.replay()
+        create_database(self)
+        self.assertEqual(record_mock, self.database.get_record(record_id))
+
+    def test_get_deleted_record(self):
+        """Test getting a deleted record."""
+        record_id = 'random_id'
+        set_database_expectations(self)
+        self.server_class[record_id]
+        self.mocker.throw(ResourceNotFound)
+        self.mocker.replay()
+        create_database(self)
+        self.assertEqual(None, self.database.get_record(record_id))
+
+    def test_put_record_no_attachments_or_id(self):
+        """Test putting a record with no attachments."""
+        record_id = 'random_id'
+        record_mock = self.mocker.mock()
+        # replace the base_n funtion which is used to
+        # return the string representation of the uuid
+        base_n = self.mocker.replace(
+            'desktopcouch.records.database.base_n')
+        set_database_expectations(self)
+        record_mock.record_id
+        self.mocker.result(None)
+        base_n(ANY, ANY)
+        self.mocker.result(record_id)
+        record_mock.record_id = record_id
+        record_mock._detached
+        self.mocker.result([])
+        record_mock.list_attachments()
+        self.mocker.result([])
+        record_mock._data
+        self.mocker.result({})
+        self.server_class[record_id] = {}
+        self.mocker.replay()
+        create_database(self)
+        self.assertEqual(record_id, self.database.put_record(record_mock))
+
+    def test_put_record_no_attachments(self):
+        """Test putting a record with no attachments."""
+        record_id = 'random_id'
+        record_mock = self.mocker.mock()
+        set_database_expectations(self)
+        record_mock.record_id
+        self.mocker.result(record_id)
+        record_mock._detached
+        self.mocker.result([])
+        record_mock.list_attachments()
+        self.mocker.result([])
+        record_mock._data
+        self.mocker.result({})
+        self.server_class[record_id] = {}
+        self.mocker.replay()
+        create_database(self)
+        self.assertEqual(record_id, self.database.put_record(record_mock))
+
+    def test_put_record_with_attachments(self):
+        """Test putting a record with attachments."""
+        record_id = 'random_id'
+        record_mock = self.mocker.mock()
+        set_database_expectations(self)
+        record_mock.record_id
+        self.mocker.result(record_id)
+        record_mock._data
+        self.mocker.result({})
+        record_mock._detached
+        self.mocker.result(['to_delete'])
+        self.server_class.delete_attachment({}, 'to_delete')
+        record_mock.list_attachments()
+        self.mocker.result(['to_add'])
+        record_mock.attachment_data('to_add')
+        self.mocker.result(('data', 'type'))
+        self.server_class.put_attachment({}, 'data', 'to_add', 'type')
+        self.server_class[record_id] = {}
+        self.mocker.replay()
+        create_database(self)
+        self.assertEqual(record_id, self.database.put_record(record_mock))
+
+    def test_put_records_batch(self):
+        """Test putting a batch of records."""
+        records = {'1': (self.mocker.mock(), {'name': '1'}),
+                   '2': (self.mocker.mock(), {'name': '2'})}
+        put_result = []
+        for record_id in records:
+            put_result.append((True, record_id, record_id))
+        set_database_expectations(self)
+        for record_id in records:
+            records[record_id][0].record_id
+            self.mocker.result(record_id)
+            # TODO: we currently call _data twice, we should get
+            # this number down
+            records[record_id][0]._data
+            self.mocker.result(records[record_id][1])
+            records[record_id][0]._data
+            self.mocker.result(records[record_id][1])
+            records[record_id][0]._detached
+            self.mocker.result(['to_delete'])
+            self.server_class.delete_attachment(
+                records[record_id][1], 'to_delete')
+            records[record_id][0].list_attachments()
+            self.mocker.result(['to_add'])
+            records[record_id][0].attachment_data('to_add')
+            self.mocker.result(('data', 'type'))
+            self.server_class.put_attachment({'_id': record_id,
+                '_rev': record_id}, 'data', 'to_add', 'type')
+        self.server_class.update([records[record_id][1]
+            for record_id in records])
+        self.mocker.result(put_result)
+        self.mocker.replay()
+        create_database(self)
+        self.assertEqual(put_result, self.database.put_records_batch(
+            [records[record_id][0] for record_id in records]))
+
+    def test_delete_record_no_attachments(self):
+        """Test deleting a record with no attachments."""
+        # replace the base_n funtion which is used to
+        # return the string representation of the uuid
+        base_n = self.mocker.replace(
+            'desktopcouch.records.database.base_n')
+        # replace deepcopy because it is used to create a duplicate of
+        # the record
+        deepcopy = self.mocker.replace('copy.deepcopy')
+        record_id = 'test_record'
+        data = {record_id: record_id}
+        record_mock = self.mocker.mock()
+        trash_mock = self.mocker.mock()
+        set_database_expectations(self)
+        self.server_class[record_id]
+        self.mocker.result(data)
+        self.record_factory(data=data)
+        self.mocker.result(record_mock)
+        deepcopy(record_mock)
+        self.mocker.result(record_mock)
+        base_n(ANY, ANY)
+        self.mocker.result(record_id)
+        record_mock.record_id = record_id
+        del record_mock._data['_rev']
+        del record_mock._data['_attachments']
+        record_mock.application_annotations['desktopcouch'] = ANY
+        del self.server_class[record_id]
+        trash_mock.put_record(record_mock)
+        self.mocker.replay()
+        create_database(self)
+        self.database._dctrash = trash_mock
+        self.database.delete_record(record_id)
+
+    def test_record_exists(self):
+        """Test checking whether a record exists."""
+        record_id = 'test_record'
+        set_database_expectations(self)
+        record_id in self.server_class
+        self.mocker.result(True)
+        record_id in self.server_class
+        self.mocker.result(False)
+        self.mocker.replay()
+        create_database(self)
+        self.assertTrue(self.database.record_exists(record_id))
+        self.assertFalse(self.database.record_exists(record_id))
+
+    def test_update_fields(self):
+        """Test the update_fields method."""
+        dictionary = {'record_number': 0, 'field1': 1, 'field2': 2}
+        record_id = 'test_record'
+        set_database_expectations(self)
+        self.server_class[record_id]
+        self.mocker.result(dictionary)
+        self.server_class[record_id] = {'record_number': 0, 'field1': 11,
+             'field2': 2}
+        self.mocker.replay()
+        create_database(self)
+        # no assertions are required because mocker will make sure that
+        # the new saved dict matches the expected one.
+        self.database.update_fields(record_id, {'field1': 11})
+
+    def test_delete_not_present_view(self):
+        """Test deleting a view that is not in the db."""
+        view_name = 'my_view'
+        design_doc = 'my_design'
+        doc_id = "_design/%s" % design_doc
+        set_database_expectations(self)
+        self.server_class[doc_id]['views']
+        self.mocker.throw(ResourceNotFound)
+        self.mocker.replay()
+        create_database(self)
+        self.assertRaises(KeyError, self.database.delete_view, view_name,
+            design_doc)
+
+    def test_delete_present_view_not_last(self):
+        """Test deleting a view that is not the last in the doc."""
+        view_name = 'my_view'
+        design_doc = 'my_design'
+        doc_id = "_design/%s" % design_doc
+        container_mock = self.mocker.mock()
+        key_mock = self.mocker.mock()
+        value_mock = self.mocker.mock()
+        iteritems = [(key_mock, value_mock)]
+        set_database_expectations(self)
+        self.server_class[doc_id]['views']
+        self.mocker.result(container_mock)
+        container_mock.pop(view_name)
+        self.mocker.result(view_name)
+        len(container_mock)
+        self.mocker.result(3)
+        container_mock.iteritems()
+        self.mocker.result(iteritems)
+        value_mock.get('map')
+        self.mocker.result('map')
+        value_mock.get('reduce')
+        self.mocker.result('reduce')
+        self.views_factory(design_doc, key_mock, 'map', 'reduce')
+        self.mocker.result(container_mock)
+        self.views_factory.sync_many(ANY, ANY, remove_missing=True)
+        # set expectations for the view_exists operation
+        self.server_class[ANY]['views']
+        self.mocker.result(self.server_class)
+        ANY in self.server_class
+        self.mocker.result(False)
+        self.mocker.replay()
+        create_database(self)
+        self.assertEqual(view_name, self.database.delete_view(
+            view_name, design_doc))
+
+    def test_delete_present_view_is_last(self):
+        """Test deleting a view that is the last of the doc."""
+        view_name = 'my_view'
+        design_doc = 'my_design'
+        doc_id = "_design/%s" % design_doc
+        container_mock = self.mocker.mock()
+        set_database_expectations(self)
+        self.server_class[doc_id]['views']
+        self.mocker.result(container_mock)
+        container_mock.pop(view_name)
+        self.mocker.result(view_name)
+        len(container_mock)
+        self.mocker.result(0)
+        del self.server_class[doc_id]
+        # set expectations for the view_exists operation
+        self.server_class[ANY]['views']
+        self.mocker.result(self.server_class)
+        ANY in self.server_class
+        self.mocker.result(False)
+        self.mocker.replay()
+        create_database(self)
+        self.assertEqual(view_name, self.database.delete_view(
+            view_name, design_doc))
+
+    def test_list_views_no_design_doc(self):
+        """Test the list views when they do not exist.."""
+        design_doc = 'my_design'
+        doc_id = "_design/%s" % design_doc
+        set_database_expectations(self)
+        self.server_class[doc_id]['views']
+        self.mocker.throw(KeyError)
+        self.mocker.replay()
+        create_database(self)
+        self.assertEqual([], self.database.list_views(design_doc))
+
+    def test_list_views(self):
+        """Test the list views."""
+        design_doc = 'my_design'
+        doc_id = "_design/%s" % design_doc
+        views = ['one', 'two', 'three']
+        set_database_expectations(self)
+        self.server_class[doc_id]['views']
+        self.mocker.result(views)
+        self.mocker.replay()
+        create_database(self)
+        self.assertEqual(views, self.database.list_views(design_doc))
 
=== modified file 'desktopcouch/records/tests/test_server.py'
--- desktopcouch/records/tests/test_server.py	2011-01-03 15:02:36 +0000
+++ desktopcouch/records/tests/test_server.py	2011-01-05 17:11:33 +0000
@@ -106,7 +106,7 @@
                 break
 
     def test_get_records_by_record_type_save_view(self):
-        """Test getting mutliple records by type"""
+        """Test getting multiple records by type"""
         records = self.database.get_records(
             record_type="test.com", create_view=True)
         self.maybe_die()  # should be able to survive couchdb death