← Back to branch summary

~ubuntu-branches/ubuntu/lucid/desktopcouch/lucid

« back to all changes in this revision

Viewing changes to desktopcouch/records/tests/test_record.py

  • Committer: Elliot Murphy
  • Date: 2010-03-01 17:18:07 UTC
  • mfrom: (1.5.3 upstream)
  • mto: This revision was merged to the branch mainline in revision 14.
  • Revision ID: elliot@elliotmurphy.com-20100301171807-fb8hzyzfbgcuig2j
* New upstream bugfix release.
  - Include a new program bin/desktopcouch-get-port .
  - Use DBus to get port, and thereby start the service daemon, on normal
    Python access to the database. (LP: #519444)
  - Update docs to be explicit about put_record(r) mutating r .
  - Add new method put_records_batch(iterable_of_records) .
  - Fix up apport collection.
  - Fix a problem with couchdb mutating its INI file to store a hashed
    password, which is useless for HTTP Basic auth in the bookmark file.
  - Fix obscure bugs in couchdb startup regarding port availability.
  - Update execute_view() ti take a dict of additional parameters for
    execution.
  - Add has_key() method to desktopcouch.record.RecordDict so that it
    behaves more like a dictionary.

Show diffs side-by-side

added added

removed removed

Lines of Context:
desktopcouch/records/tests/test_record.py
34
34
 
35
35
    def setUp(self):
36
36
        """Test setup."""
 
37
        super(TestRecords, self).setUp()
37
38
        self.dict = {
38
39
            "a": "A",
39
40
            "b": "B",
62
63
        db = CouchDatabase('testing', create=True, ctx=ctx)
63
64
        record_id = db.put_record(self.record)
64
65
 
65
 
        retreived_record = db.get_record(record_id)
 
66
        db.get_record(record_id)
66
67
        self.assertNotEquals(self.record.record_revision, None)
67
68
 
68
69
        first = self.record.record_revision
69
70
 
70
71
        record_id = db.put_record(self.record)
71
 
        retreived_record = db.get_record(record_id)
 
72
        db.get_record(record_id)
72
73
        second = self.record.record_revision
73
74
 
74
75
        self.assertTrue(first < second)
81
82
        self.assertRaises(KeyError, f, self.record)
82
83
 
83
84
        del self.record["a"]
84
 
        
 
85
 
85
86
    def test_iter(self):
86
 
        self.assertEquals(sorted(list(iter(self.record))), 
 
87
        self.assertEquals(sorted(list(iter(self.record))),
87
88
            ['a', 'b', 'record_type', 'subfield', 'subfield_uuid'])
88
 
  
 
89
 
89
90
    def test_setitem_internal(self):
90
91
        def f(r):
91
92
            r["_id"] = "new!"
92
93
        self.assertRaises(IllegalKeyException, f, self.record)
93
 
        
 
94
 
94
95
    def test_no_record_type(self):
95
96
        self.assertRaises(NoRecordTypeSpecified, Record, {})
96
97
 
111
112
            ['a', 'b', 'record_type', 'subfield', 'subfield_uuid'],
112
113
            sorted(self.record.keys()))
113
114
        self.assertIn("a", self.record)
 
115
        self.assertTrue(self.record.has_key("a"))
 
116
        self.assertFalse(self.record.has_key("f"))
114
117
        self.assertNotIn("_id", self.record)  # is internal.  play dumb.
115
118
 
116
119
    def test_application_annotations(self):
174
177
        self.record["subfield_uuid"].append(value)
175
178
        self.assertEqual(3, len(self.record["subfield_uuid"]))
176
179
        self.assertEqual("value32", self.record["subfield_uuid"][-1]["field32"])
 
180
        
 
181
    def test_mergeable_list_remove(self):
 
182
        """Test remove a normal value"""
 
183
        value = "string"
 
184
        self.record["subfield_uuid"].append(value)
 
185
        self.record["subfield_uuid"].remove(value)
 
186
        self.assertFalse(value in self.record["subfield_uuid"])
 
187
        
 
188
    def test_mergeable_list_remove_record_dict(self):
 
189
        """Test remove a RecordDict value"""
 
190
        value = RecordDict({
 
191
            "field31": "value31",
 
192
            "field32": "value32"})
 
193
        self.record["subfield_uuid"].append(value)
 
194
        self.record["subfield_uuid"].remove(value)
 
195
        self.assertFalse(value in self.record["subfield_uuid"])
177
196
 
 
197
    def test_mergeable_list_remove_list(self):
 
198
        """Test list removal"""
 
199
        value = [1, 2, 3, 4, 5]
 
200
        self.record["subfield_uuid"].append(value)
 
201
        self.record["subfield_uuid"].remove(value)
 
202
        self.assertFalse(value in self.record["subfield_uuid"])
 
203
        
 
204
    def test_mergeable_list_remove_tuple(self):
 
205
        """Test tuple removal"""
 
206
        value = (1, 2, 3, 4, 5)
 
207
        self.record["subfield_uuid"].append(value)
 
208
        self.record["subfield_uuid"].remove(value)
 
209
        self.assertFalse(value in self.record["subfield_uuid"])
 
210
        
 
211
    def test_mergeable_list_remove_missing(self):
 
212
        """Test missing data rmeoval"""
 
213
        self.assertRaises(ValueError, self.record["subfield_uuid"].remove, 
 
214
            "missing_data")
 
215
    def test_mergeable_list_remove_last(self):
 
216
        """Test that exception is raised when removing last item."""
 
217
        self.record["subfield_uuid"] = [1]
 
218
        self.assertRaises(ValueError, self.record["subfield_uuid"].remove, 1)
 
219
        
 
220
    def test_mergeable_list_pop_correct_index(self):
 
221
        """Test the pop method when working with a correct index."""
 
222
        value = [1, 2, 3, 4, 5]
 
223
        self.record["subfield_uuid"] = value
 
224
        # test with negative index
 
225
        poped_value = self.record["subfield_uuid"].pop(-2)
 
226
        self.assertEqual(value[-2], poped_value)
 
227
        # test with positive index
 
228
        poped_value = self.record["subfield_uuid"].pop(1)
 
229
        self.assertEqual(value[1], poped_value)
 
230
        
 
231
    def test_mergeable_list_pop_wrong_index(self):
 
232
        """Test pop when index is out or range."""
 
233
        value = [1, 2, 3, 4, 5]
 
234
        self.record["subfield_uuid"] = value
 
235
        self.assertRaises(IndexError, self.record["subfield_uuid"].pop, 
 
236
            len(value)*2)
 
237
    
 
238
    def test_mergeable_list_pop_last(self):
 
239
        """Test that exception is raised when poping last item"""
 
240
        self.record["subfield_uuid"] = [1]
 
241
        self.assertRaises(ValueError, self.record["subfield_uuid"].pop, 0)
 
242
        
178
243
    def test_tuple(self):
179
244
        """Test assigning tuples to a key results in mergeable lists."""
180
245
        rec = Record({'record_type': 'http://fnord.org/smorgasbord'})
230
295
        globs = { "db": CouchDatabase('testing', create=True, ctx=ctx) }
231
296
        results = doctest.testfile('../doc/records.txt', globs=globs)
232
297
        self.assertEqual(0, results.failed)
233
 
    
 
298
 
234
299
    def test_record_id(self):
235
300
        data = {"_id":"recordid"}
236
301
        record = Record(data, record_type="url")
240
305
        record = Record(data, record_type="url", record_id=record_id)
241
306
        self.assertEqual(record_id, record.record_id)
242
307
        data = {"_id":"differentid"}
243
 
        self.assertRaises(ValueError, 
 
308
        self.assertRaises(ValueError,
244
309
            Record, data, record_id=record_id, record_type="url")
245
310
 
 
311
 
246
312
class TestRecordFactory(TestCase):
247
313
    """Test Record/Mergeable List factories."""
248
314
 
249
315
    def setUp(self):
250
316
        """Test setup."""
 
317
        super(TestRecordFactory, self).setUp()
251
318
        self.dict = {
252
319
            "a": "A",
253
320
            "b": "B",