← Back to branch summary

~facundo/ubuntuone-client/fix-svfilenew-conflict

« back to all changes in this revision

Viewing changes to tests/platform/linux/eventlog/test_zg_listener.py

  • Committer: Facundo Batista
  • Date: 2011-04-04 12:31:43 UTC
  • mfrom: (922.1.9 ubuntuone-client)
  • Revision ID: facundo@taniquetil.com.ar-20110404123143-mobua5abcpinz0o2
Trunk merged in

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/platform/linux/eventlog/test_zg_listener.py
26
26
import unittest
27
27
import uuid
28
28
 
 
29
from os.path import basename
29
30
from twisted.internet import defer
30
31
from zeitgeist.datamodel import Interpretation, Manifestation
31
32
 
84
85
    def __init__(self):
85
86
        """Initialize this instance."""
86
87
        self.events = []
 
88
        self.deferreds = []
87
89
 
88
90
    def log(self, event):
89
91
        """Log the event."""
90
92
        self.events.append(event)
 
93
        if self.deferreds:
 
94
            self.callback_next_deferred(event)
 
95
 
 
96
    def callback_next_deferred(self, event):
 
97
        """Pop the next deferred and callback it."""
 
98
        d = self.deferreds.pop()
 
99
        if d:
 
100
            d.callback(event)
91
101
 
92
102
def listen_for(event_q, event, callback, count=1, collect=False):
93
103
    """Setup a EQ listener for the specified event."""
126
136
        self.patch(zglog, "ZeitgeistLogger", MockLogger)
127
137
        self.listener = ZeitgeistListener(self.fs, self.vm)
128
138
        self.event_q.subscribe(self.listener)
 
139
        self.patch(self.event_q, "ignored_base_exception", RuntimeError)
129
140
 
130
141
    def _listen_for(self, *args, **kwargs):
131
142
        return listen_for(self.main.event_q, *args, **kwargs)
134
145
class ZeitgeistSharesTestCase(ZeitgeistListenerTestCase):
135
146
    """Tests for all Share-related zeitgeist events."""
136
147
 
 
148
    @defer.inlineCallbacks
137
149
    def test_share_created_with_username_is_logged(self):
138
150
        """A ShareCreated event is logged."""
139
151
        fake_username = "fake user"
150
162
                                   share_id=share_id,
151
163
                                   marker=marker)
152
164
 
 
165
        d = defer.Deferred()
 
166
        self._listen_for('AQ_CREATE_SHARE_OK', d.callback, 1, collect=True)
153
167
        self.patch(self.main.action_q, "create_share", fake_create_share)
154
168
        self.vm.create_share(path, fake_username, 'shared_name', 'View')
155
169
 
 
170
        yield d
 
171
 
156
172
        self.assert_folder_shared_is_logged(path, fake_username)
157
 
    test_share_created_with_username_is_logged = """
158
 
        This test failed some times, Alecu told me to skip it, he will
159
 
        check later (opened bug #723832 for this) [Facundo]
160
 
        """
161
173
 
162
174
    def test_share_created_with_email_is_logged(self):
163
175
        """A ShareCreated event is logged."""
183
195
 
184
196
        self.assertEqual(len(self.listener.zg.events), 1)
185
197
        event = self.listener.zg.events[0]
 
198
        foldername = basename(path)
186
199
 
187
200
        self.assertEqual(event.interpretation,
188
201
                          EVENT_INTERPRETATION_U1_FOLDER_SHARED)
196
209
        self.assertEqual(folder.manifestation,
197
210
                          Manifestation.REMOTE_DATA_OBJECT)
198
211
        self.assertTrue(folder.origin.endswith(path))
 
212
        self.assertEqual(folder.text, foldername)
199
213
        self.assertEqual(folder.mimetype, DIRECTORY_MIMETYPE)
200
214
        self.assertEqual(folder.storage, STORAGE_NETWORK)
201
215
 
204
218
        self.assertEqual(other_user.interpretation, INTERPRETATION_U1_CONTACT)
205
219
        self.assertEqual(other_user.manifestation,
206
220
                          MANIFESTATION_U1_CONTACT_DATA_OBJECT)
 
221
        self.assertEqual(other_user.text, fake_username)
207
222
 
208
223
 
209
224
    @defer.inlineCallbacks
212
227
        sample_share_id = "share id"
213
228
        sample_node_id = "node id"
214
229
        fake_username = "fake user"
215
 
        path = os.path.join(self.vm.root.path, 'shared_path')
 
230
        folder_name = "shared_path"
 
231
        path = os.path.join(self.vm.root.path, folder_name)
216
232
        self.main.fs.create(path, "")
217
233
        self.main.fs.set_node_id(path, sample_node_id)
218
234
        share = Shared(path=path, volume_id=sample_share_id,
245
261
        self.assertEqual(folder.manifestation,
246
262
                          Manifestation.REMOTE_DATA_OBJECT)
247
263
        self.assertTrue(folder.origin.endswith(path))
 
264
        self.assertEqual(folder.text, folder_name)
248
265
        self.assertEqual(folder.mimetype, DIRECTORY_MIMETYPE)
249
266
        self.assertEqual(folder.storage, STORAGE_NETWORK)
250
267
 
253
270
        self.assertEqual(other_user.interpretation, INTERPRETATION_U1_CONTACT)
254
271
        self.assertEqual(other_user.manifestation,
255
272
                          MANIFESTATION_U1_CONTACT_DATA_OBJECT)
 
273
        self.assertEqual(other_user.text, fake_username)
256
274
 
257
275
    @defer.inlineCallbacks
258
276
    def test_share_accepted_is_logged(self):
260
278
        # initialize the the root
261
279
        self.vm._got_root('root_uuid')
262
280
        fake_username = "fake user"
263
 
        path = os.path.join(self.vm.root.path, 'shared_path')
 
281
        folder_name = "shared_path"
 
282
        path = os.path.join(self.vm.root.path, folder_name)
264
283
        self.main.fs.create(path, "")
265
 
        share_path = os.path.join(self.shares_dir, 'fake_share')
 
284
        share_path = os.path.join(self.shares_dir, folder_name)
266
285
        share = Share(path=share_path, volume_id='volume_id', node_id="node_id",
267
286
                      other_username=fake_username)
268
287
        yield self.vm.add_share(share)
282
301
        self.assertEqual(folder.manifestation,
283
302
                          Manifestation.REMOTE_DATA_OBJECT)
284
303
        self.assertTrue(folder.origin.endswith(share_path))
 
304
        self.assertEqual(folder.text, folder_name)
285
305
        self.assertEqual(folder.mimetype, DIRECTORY_MIMETYPE)
286
306
        self.assertEqual(folder.storage, STORAGE_NETWORK)
287
307
 
290
310
        self.assertEqual(other_user.interpretation, INTERPRETATION_U1_CONTACT)
291
311
        self.assertEqual(other_user.manifestation,
292
312
                          MANIFESTATION_U1_CONTACT_DATA_OBJECT)
 
313
        self.assertEqual(other_user.text, fake_username)
293
314
 
294
315
 
295
316
    @defer.inlineCallbacks
296
317
    def test_share_unaccepted_is_logged(self):
297
318
        """Test that an unaccepted share event is logged."""
298
319
        fake_username = "fake user"
 
320
        folder_name = u"share"
299
321
        d = defer.Deferred()
300
322
 
301
 
        share_path = os.path.join(self.main.shares_dir, 'share')
 
323
        share_path = os.path.join(self.main.shares_dir, folder_name)
302
324
        holder = NotifyShareHolder.from_params(uuid.uuid4(),
303
325
                                                     uuid.uuid4(),
304
326
                                                     u'fake_share',
326
348
        self.assertEqual(folder.manifestation,
327
349
                          Manifestation.REMOTE_DATA_OBJECT)
328
350
        self.assertTrue(folder.origin.endswith(share_path))
 
351
        self.assertEqual(folder.text, folder_name)
329
352
        self.assertEqual(folder.mimetype, DIRECTORY_MIMETYPE)
330
353
        self.assertEqual(folder.storage, STORAGE_NETWORK)
331
354
 
334
357
        self.assertEqual(other_user.interpretation, INTERPRETATION_U1_CONTACT)
335
358
        self.assertEqual(other_user.manifestation,
336
359
                          MANIFESTATION_U1_CONTACT_DATA_OBJECT)
 
360
        self.assertEqual(other_user.text, fake_username)
337
361
 
338
362
 
339
363
class ZeitgeistUDFsTestCase(ZeitgeistListenerTestCase):
364
388
    @defer.inlineCallbacks
365
389
    def test_udf_create_is_logged(self):
366
390
        """Test for Folders.create."""
367
 
        path = os.path.join(self.home_dir, u'ñoño'.encode('utf-8'))
 
391
        folder_name = u'ñoño'.encode('utf-8')
 
392
        path = os.path.join(self.home_dir, folder_name)
368
393
        id = uuid.uuid4()
369
394
        node_id = uuid.uuid4()
370
395
 
383
408
        self.patch(self.main.action_q, "create_udf", create_udf)
384
409
 
385
410
        d = defer.Deferred()
386
 
        self._listen_for('VM_UDF_CREATED', d.callback, 1, collect=True)
 
411
        self.listener.zg.deferreds.append(d)
387
412
        self.vm.create_udf(path)
388
413
        yield d
389
414
 
402
427
        self.assertEqual(folder.manifestation,
403
428
                          Manifestation.REMOTE_DATA_OBJECT)
404
429
        self.assertTrue(folder.origin.endswith(path))
 
430
        self.assertEqual(folder.text, folder_name)
405
431
        self.assertEqual(folder.mimetype, DIRECTORY_MIMETYPE)
406
432
        self.assertEqual(folder.storage, STORAGE_NETWORK)
407
 
    test_udf_create_is_logged.skip = """
408
 
        This test failed some times, Alecu told me to skip it, he will
409
 
        check later (opened bug #723832 for this) [Facundo]
410
 
        """
411
433
 
412
434
    @defer.inlineCallbacks
413
435
    def test_udf_delete_is_logged(self):
414
436
        """Test for Folders.delete."""
415
437
        id = uuid.uuid4()
416
438
        node_id = uuid.uuid4()
417
 
        path = os.path.join(self.home_dir, u'ñoño'.encode('utf-8'))
 
439
        folder_name = u'ñoño'.encode('utf-8')
 
440
        path = os.path.join(self.home_dir, folder_name)
 
441
 
 
442
        d = defer.Deferred()
 
443
        self.listener.zg.deferreds.append(d)
418
444
 
419
445
        def create_udf(path, name, marker):
420
446
            """Fake create_udf."""
430
456
 
431
457
        self.patch(self.main.action_q, "create_udf", create_udf)
432
458
 
433
 
        d = defer.Deferred()
434
 
        self._listen_for('VM_UDF_CREATED', d.callback, 1, collect=True)
435
459
        self.vm.create_udf(path)
436
460
        yield d
437
461
 
441
465
 
442
466
        self.patch(self.main.action_q, "delete_volume", delete_volume)
443
467
 
 
468
        self.assertEqual(len(self.listener.zg.events), 1)
 
469
        event = self.listener.zg.events[0]
 
470
 
 
471
        d2 = defer.Deferred()
 
472
        self.listener.zg.deferreds.append(d2)
444
473
        self.vm.delete_volume(str(id))
445
 
 
446
 
        self.assertEqual(len(self.listener.zg.events), 1)
447
 
        event = self.listener.zg.events[0]
448
 
 
449
 
        d = defer.Deferred()
450
 
        self._listen_for('VM_VOLUME_DELETED', d.callback, 1, collect=True)
451
 
        yield d
 
474
        yield d2
452
475
 
453
476
        self.assertEqual(len(self.listener.zg.events), 2)
454
477
        event = self.listener.zg.events[1]
465
488
        self.assertEqual(folder.manifestation,
466
489
                          Manifestation.DELETED_RESOURCE)
467
490
        self.assertTrue(folder.origin.endswith(path))
 
491
        self.assertEqual(folder.text, folder_name)
468
492
        self.assertEqual(folder.mimetype, DIRECTORY_MIMETYPE)
469
493
        self.assertEqual(folder.storage, STORAGE_DELETED)
470
 
    test_udf_delete_is_logged.skip = """
471
 
        This test failed some times, Alecu told me to skip it, he will
472
 
        check later (opened bug #723832 for this) [Facundo]
473
 
        """
474
494
 
475
495
    @defer.inlineCallbacks
476
496
    def test_udf_subscribe_is_logged(self):
477
497
        """Test for Folders.subscribe."""
478
 
        suggested_path = u'~/ñoño'
 
498
        folder_name = u"ñoño"
 
499
        suggested_path = u'~/' + folder_name
479
500
        udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path,
480
501
                               subscribed=False)
481
502
        yield self.main.vm.add_udf(udf)
482
503
        d = defer.Deferred()
483
 
        self._listen_for('VM_UDF_SUBSCRIBED', d.callback, 1, collect=True)
 
504
        self.listener.zg.deferreds.append(d)
484
505
        self.vm.subscribe_udf(udf.volume_id)
485
506
        yield d
486
507
 
499
520
        self.assertEqual(folder.manifestation,
500
521
                          Manifestation.FILE_DATA_OBJECT)
501
522
        self.assertTrue(folder.origin.startswith(URI_PROTOCOL_U1))
 
523
        self.assertEqual(folder.text, folder_name)
502
524
        self.assertEqual(folder.mimetype, DIRECTORY_MIMETYPE)
503
525
        self.assertEqual(folder.storage, STORAGE_LOCAL)
504
 
    test_udf_subscribe_is_logged.skip = """
505
 
        This test failed some times, Alecu told me to skip it, he will
506
 
        check later (opened bug #723832 for this) [Facundo]
507
 
        """
508
526
 
509
527
    @defer.inlineCallbacks
510
528
    def test_udf_unsubscribe_is_logged(self):
512
530
        suggested_path = u'~/ñoño'
513
531
        udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path,
514
532
                               subscribed=True)
 
533
        folder_name = basename(udf.path)
515
534
        yield self.main.vm.add_udf(udf)
516
535
        d = defer.Deferred()
517
536
        self._listen_for('VM_UDF_UNSUBSCRIBED', d.callback, 1, collect=True)
533
552
        self.assertEqual(folder.manifestation,
534
553
                          Manifestation.DELETED_RESOURCE)
535
554
        self.assertTrue(folder.origin.startswith(URI_PROTOCOL_U1))
 
555
        self.assertEqual(folder.text, folder_name)
536
556
        self.assertEqual(folder.mimetype, DIRECTORY_MIMETYPE)
537
557
        self.assertEqual(folder.storage, STORAGE_DELETED)
538
558
 
621
641
        self.assertEqual(remote_file.manifestation,
622
642
                          Manifestation.REMOTE_DATA_OBJECT)
623
643
        self.assertTrue(remote_file.origin.endswith(filename))
 
644
        self.assertEqual(remote_file.text, filename)
624
645
        self.assertEqual(remote_file.mimetype, "audio/mpeg")
625
646
        self.assertEqual(remote_file.storage, STORAGE_NETWORK)
626
647
 
656
677
                          Manifestation.SCHEDULED_ACTIVITY)
657
678
        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
658
679
 
659
 
        remote_file = event.subjects[0]
660
 
        self.assertTrue(remote_file.uri.startswith(URI_PROTOCOL_U1))
661
 
        self.assertEqual(remote_file.interpretation, Interpretation.FOLDER)
662
 
        self.assertEqual(remote_file.manifestation,
 
680
        remote_folder = event.subjects[0]
 
681
        self.assertTrue(remote_folder.uri.startswith(URI_PROTOCOL_U1))
 
682
        self.assertEqual(remote_folder.interpretation, Interpretation.FOLDER)
 
683
        self.assertEqual(remote_folder.manifestation,
663
684
                          Manifestation.REMOTE_DATA_OBJECT)
664
 
        self.assertTrue(remote_file.origin.endswith(dirname))
665
 
        self.assertEqual(remote_file.mimetype, DIRECTORY_MIMETYPE)
666
 
        self.assertEqual(remote_file.storage, STORAGE_NETWORK)
 
685
        self.assertTrue(remote_folder.origin.endswith(dirname))
 
686
        self.assertEqual(remote_folder.text, dirname)
 
687
        self.assertEqual(remote_folder.mimetype, DIRECTORY_MIMETYPE)
 
688
        self.assertEqual(remote_folder.storage, STORAGE_NETWORK)
667
689
 
668
690
    def test_syncdaemon_modifies_on_server_is_logged(self):
669
691
        """Files modified by SyncDaemon on the server are logged."""
703
725
        self.assertEqual(remote_file.manifestation,
704
726
                          Manifestation.REMOTE_DATA_OBJECT)
705
727
        self.assertTrue(remote_file.origin.endswith(filename))
 
728
        self.assertEqual(remote_file.text, filename)
706
729
        self.assertEqual(remote_file.mimetype, "audio/mpeg")
707
730
        self.assertEqual(remote_file.storage, STORAGE_NETWORK)
708
731
 
709
732
    @defer.inlineCallbacks
710
733
    def test_syncdaemon_deletes_file_on_server_is_logged(self):
711
734
        """Files deleted by SD on the server are logged."""
 
735
        file_name = "filename.mp3"
712
736
        d = defer.Deferred()
713
737
        listen_for(self.main.event_q, 'AQ_UNLINK_OK', d.callback)
714
738
 
728
752
                          Manifestation.SCHEDULED_ACTIVITY)
729
753
        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
730
754
 
731
 
        remote_folder = event.subjects[0]
732
 
        self.assertTrue(remote_folder.uri.startswith(URI_PROTOCOL_U1))
733
 
        self.assertEqual(remote_folder.interpretation, Interpretation.AUDIO)
734
 
        self.assertEqual(remote_folder.manifestation,
 
755
        remote_file = event.subjects[0]
 
756
        self.assertTrue(remote_file.uri.startswith(URI_PROTOCOL_U1))
 
757
        self.assertEqual(remote_file.interpretation, Interpretation.AUDIO)
 
758
        self.assertEqual(remote_file.manifestation,
735
759
                          Manifestation.DELETED_RESOURCE)
736
 
        self.assertTrue(remote_folder.origin.endswith("filename.mp3"))
737
 
        self.assertEqual(remote_folder.mimetype, "audio/mpeg")
738
 
        self.assertEqual(remote_folder.storage, STORAGE_DELETED)
 
760
        self.assertTrue(remote_file.origin.endswith(file_name))
 
761
        self.assertEqual(remote_file.text, file_name)
 
762
        self.assertEqual(remote_file.mimetype, "audio/mpeg")
 
763
        self.assertEqual(remote_file.storage, STORAGE_DELETED)
739
764
 
740
765
    @defer.inlineCallbacks
741
766
    def test_syncdaemon_deletes_dir_on_server_is_logged(self):
742
 
        """Files deleted by SD on the server are logged."""
 
767
        """Directories deleted by SD on the server are logged."""
 
768
        folder_name = "folder name"
743
769
        d = defer.Deferred()
744
770
        listen_for(self.main.event_q, 'AQ_UNLINK_OK', d.callback)
745
771
 
764
790
        self.assertEqual(remote_folder.interpretation, Interpretation.FOLDER)
765
791
        self.assertEqual(remote_folder.manifestation,
766
792
                          Manifestation.DELETED_RESOURCE)
767
 
        self.assertTrue(remote_folder.origin.endswith("folder name"))
 
793
        self.assertTrue(remote_folder.origin.endswith(folder_name))
 
794
        self.assertEqual(remote_folder.text, folder_name)
768
795
        self.assertEqual(remote_folder.mimetype, DIRECTORY_MIMETYPE)
769
796
        self.assertEqual(remote_folder.storage, STORAGE_DELETED)
770
797
 
824
851
    @defer.inlineCallbacks
825
852
    def test_syncdaemon_creates_file_locally_is_logged(self):
826
853
        """Files created locally by SyncDaemon are logged."""
 
854
        file_name = self.filemp3delta.name.encode('utf8')
827
855
        d = defer.Deferred()
828
856
        d2 = defer.Deferred()
829
857
        listen_for(self.main.event_q, 'SV_FILE_NEW', d.callback)
836
864
 
837
865
        # check that the file is created
838
866
        node = self.main.fs.get_by_node_id(ROOT, self.filemp3delta.node_id)
839
 
        self.assertEqual(node.path, self.filemp3delta.name.encode('utf8'))
 
867
        self.assertEqual(node.path, file_name)
840
868
        self.assertEqual(node.is_dir, False)
841
869
        self.assertEqual(node.generation, self.filemp3delta.generation)
842
870
 
860
888
        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
861
889
 
862
890
        local_file = event.subjects[0]
863
 
        self.assertTrue(local_file.uri.endswith(
864
 
                        self.filemp3delta.name.encode('utf8')))
 
891
        self.assertTrue(local_file.uri.endswith(file_name))
865
892
        self.assertEqual(local_file.interpretation, Interpretation.AUDIO)
866
893
        self.assertEqual(local_file.manifestation,
867
894
                          Manifestation.FILE_DATA_OBJECT)
868
895
        self.assertTrue(local_file.origin.startswith(URI_PROTOCOL_U1))
 
896
        self.assertEqual(local_file.text, file_name)
869
897
        self.assertEqual(local_file.mimetype, "audio/mpeg")
870
898
        self.assertEqual(local_file.storage, STORAGE_LOCAL)
871
899
 
872
900
    @defer.inlineCallbacks
873
901
    def test_syncdaemon_creates_dir_locally_is_logged(self):
874
902
        """Dirs created locally by SyncDaemon are logged."""
 
903
        folder_name = self.dirdelta.name.encode('utf8')
875
904
        d = defer.Deferred()
876
905
        listen_for(self.main.event_q, 'SV_DIR_NEW', d.callback)
877
906
 
882
911
 
883
912
        # check that the dir is created
884
913
        node = self.main.fs.get_by_node_id(ROOT, self.dirdelta.node_id)
885
 
        self.assertEqual(node.path, self.dirdelta.name.encode('utf8'))
 
914
        self.assertEqual(node.path, folder_name)
886
915
        self.assertEqual(node.is_dir, True)
887
916
        self.assertEqual(node.generation, self.dirdelta.generation)
888
917
 
897
926
                          Manifestation.WORLD_ACTIVITY)
898
927
        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
899
928
 
900
 
        local_file = event.subjects[0]
901
 
        self.assertTrue(local_file.uri.endswith(
902
 
                        self.dirdelta.name.encode('utf8')))
903
 
        self.assertEqual(local_file.interpretation, Interpretation.FOLDER)
904
 
        self.assertEqual(local_file.manifestation,
 
929
        local_folder = event.subjects[0]
 
930
        self.assertTrue(local_folder.uri.endswith(folder_name))
 
931
        self.assertEqual(local_folder.interpretation, Interpretation.FOLDER)
 
932
        self.assertEqual(local_folder.manifestation,
905
933
                          Manifestation.FILE_DATA_OBJECT)
906
 
        self.assertTrue(local_file.origin.startswith(URI_PROTOCOL_U1))
907
 
        self.assertEqual(local_file.mimetype, DIRECTORY_MIMETYPE)
908
 
        self.assertEqual(local_file.storage, STORAGE_LOCAL)
 
934
        self.assertTrue(local_folder.origin.startswith(URI_PROTOCOL_U1))
 
935
        self.assertEqual(local_folder.text, folder_name)
 
936
        self.assertEqual(local_folder.mimetype, DIRECTORY_MIMETYPE)
 
937
        self.assertEqual(local_folder.storage, STORAGE_LOCAL)
909
938
 
910
939
    @defer.inlineCallbacks
911
940
    def test_syncdaemon_modifies_locally_is_logged(self):
912
941
        """Files modified locally by SyncDaemon are logged."""
 
942
        file_name = self.filemp3delta.name.encode('utf8')
913
943
        d = defer.Deferred()
914
944
        d2 = defer.Deferred()
915
945
        listen_for(self.main.event_q, 'SV_FILE_NEW', d.callback)
922
952
 
923
953
        # check that the file is modified
924
954
        node = self.main.fs.get_by_node_id(ROOT, self.filemp3delta.node_id)
925
 
        self.assertEqual(node.path, self.filemp3delta.name.encode('utf8'))
 
955
        self.assertEqual(node.path, file_name)
926
956
        self.assertEqual(node.is_dir, False)
927
957
        self.assertEqual(node.generation, self.filemp3delta.generation)
928
958
 
950
980
        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
951
981
 
952
982
        local_file = event.subjects[0]
953
 
        self.assertTrue(local_file.uri.endswith(
954
 
                        self.filemp3delta.name.encode('utf8')))
 
983
        self.assertTrue(local_file.uri.endswith(file_name))
955
984
        self.assertEqual(local_file.interpretation, Interpretation.AUDIO)
956
985
        self.assertEqual(local_file.manifestation,
957
986
                          Manifestation.FILE_DATA_OBJECT)
958
987
        self.assertTrue(local_file.origin.startswith(URI_PROTOCOL_U1))
 
988
        self.assertEqual(local_file.text, file_name)
959
989
        self.assertEqual(local_file.mimetype, "audio/mpeg")
960
990
        self.assertEqual(local_file.storage, STORAGE_LOCAL)
961
991
 
962
992
    @defer.inlineCallbacks
963
993
    def test_syncdaemon_deletes_file_locally_is_logged(self):
964
994
        """Files deleted locally by SyncDaemon are logged."""
 
995
        file_name = self.filemp3delta.name.encode("utf-8")
965
996
        d = defer.Deferred()
966
997
        listen_for(self.main.event_q, 'SV_FILE_DELETED', d.callback)
967
998
 
982
1013
        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
983
1014
 
984
1015
        local_file = event.subjects[0]
985
 
        self.assertTrue(local_file.uri.endswith(
986
 
                        self.filemp3delta.name.encode('utf8')))
 
1016
        self.assertTrue(local_file.uri.endswith(file_name))
987
1017
        self.assertEqual(local_file.interpretation, Interpretation.AUDIO)
988
1018
        self.assertEqual(local_file.manifestation,
989
1019
                          Manifestation.DELETED_RESOURCE)
990
1020
        self.assertTrue(local_file.origin.startswith(URI_PROTOCOL_U1))
 
1021
        self.assertEqual(local_file.text, file_name)
991
1022
        self.assertEqual(local_file.mimetype, "audio/mpeg")
992
1023
        self.assertEqual(local_file.storage, STORAGE_DELETED)
993
1024
 
994
1025
    @defer.inlineCallbacks
995
1026
    def test_syncdaemon_deletes_dir_locally_is_logged(self):
996
1027
        """Dirs deleted locally by SyncDaemon are logged."""
 
1028
        folder_name = "folder name"
997
1029
        d = defer.Deferred()
998
1030
        listen_for(self.main.event_q, 'SV_FILE_DELETED', d.callback)
999
1031
 
1014
1046
        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
1015
1047
 
1016
1048
        local_folder = event.subjects[0]
1017
 
        self.assertTrue(local_folder.uri.endswith("folder name"))
 
1049
        self.assertTrue(local_folder.uri.endswith(folder_name))
1018
1050
        self.assertEqual(local_folder.interpretation, Interpretation.FOLDER)
1019
1051
        self.assertEqual(local_folder.manifestation,
1020
1052
                          Manifestation.DELETED_RESOURCE)
1021
1053
        self.assertTrue(local_folder.origin.startswith(URI_PROTOCOL_U1))
 
1054
        self.assertEqual(local_folder.text, folder_name)
1022
1055
        self.assertEqual(local_folder.mimetype, DIRECTORY_MIMETYPE)
1023
1056
        self.assertEqual(local_folder.storage, STORAGE_DELETED)
1024
1057
 
1025
1058
    @defer.inlineCallbacks
1026
1059
    def test_file_sync_conflict_is_logged(self):
1027
1060
        """Files renamed because of conflict are logged."""
 
1061
        file_name = "sample.mp3"
1028
1062
        d = defer.Deferred()
1029
1063
        listen_for(self.main.event_q, 'FSM_FILE_CONFLICT', d.callback)
1030
1064
 
1031
 
        testfile = os.path.join(self.main.vm.root.path, 'sample.mp3')
 
1065
        testfile = os.path.join(self.main.vm.root.path, file_name)
1032
1066
        mdid = self.main.fs.create(testfile, "")
1033
1067
        self.main.fs.set_node_id(testfile, "uuid")
1034
1068
        with open(testfile, "w") as fh:
1054
1088
        self.assertEqual(local_file.manifestation,
1055
1089
                          Manifestation.FILE_DATA_OBJECT)
1056
1090
        self.assertTrue(local_file.origin.endswith(testfile))
 
1091
        self.assertEqual(local_file.text,
 
1092
                         file_name + self.main.fs.CONFLICT_SUFFIX)
1057
1093
        self.assertEqual(local_file.mimetype, "audio/mpeg")
1058
1094
        self.assertEqual(local_file.storage, STORAGE_LOCAL)
1059
1095
 
1060
1096
    @defer.inlineCallbacks
1061
1097
    def test_dir_sync_conflict_is_logged(self):
1062
1098
        """Dirs renamed because of conflict are logged."""
 
1099
        folder_name = "sampledir"
1063
1100
        d = defer.Deferred()
1064
1101
        listen_for(self.main.event_q, 'FSM_DIR_CONFLICT', d.callback)
1065
1102
 
1066
 
        testdir = os.path.join(self.main.vm.root.path, 'sampledir')
 
1103
        testdir = os.path.join(self.main.vm.root.path, folder_name)
1067
1104
        mdid = self.main.fs.create(testdir, "", is_dir=True)
1068
1105
        self.main.fs.set_node_id(testdir, "uuid")
1069
1106
        os.mkdir(testdir)
1081
1118
                          Manifestation.WORLD_ACTIVITY)
1082
1119
        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
1083
1120
 
1084
 
        local_file = event.subjects[0]
 
1121
        local_folder = event.subjects[0]
1085
1122
        new_name = testdir + self.main.fs.CONFLICT_SUFFIX
1086
 
        self.assertTrue(local_file.uri.endswith(new_name))
1087
 
        self.assertEqual(local_file.interpretation, Interpretation.FOLDER)
1088
 
        self.assertEqual(local_file.manifestation,
 
1123
        self.assertTrue(local_folder.uri.endswith(new_name))
 
1124
        self.assertEqual(local_folder.interpretation, Interpretation.FOLDER)
 
1125
        self.assertEqual(local_folder.manifestation,
1089
1126
                          Manifestation.FILE_DATA_OBJECT)
1090
 
        self.assertTrue(local_file.origin.endswith(testdir))
1091
 
        self.assertEqual(local_file.mimetype, DIRECTORY_MIMETYPE)
1092
 
        self.assertEqual(local_file.storage, STORAGE_LOCAL)
 
1127
        self.assertTrue(local_folder.origin.endswith(testdir))
 
1128
        self.assertEqual(local_folder.text,
 
1129
                         folder_name + self.main.fs.CONFLICT_SUFFIX)
 
1130
        self.assertEqual(local_folder.mimetype, DIRECTORY_MIMETYPE)
 
1131
        self.assertEqual(local_folder.storage, STORAGE_LOCAL)
1093
1132
 
1094
1133
class ZeitgeistPublicFilesTestCase(ZeitgeistListenerTestCase):
1095
1134
    """Public files events are logged into Zeitgeist."""
1131
1170
        self.assertEqual(public_file.manifestation,
1132
1171
                          Manifestation.REMOTE_DATA_OBJECT)
1133
1172
        self.assertTrue(public_file.origin.endswith(node_id))
 
1173
        self.assertEqual(public_file.text, public_url)
1134
1174
        self.assertEqual(public_file.mimetype, "audio/mpeg")
1135
1175
        self.assertEqual(public_file.storage, STORAGE_NETWORK)
1136
1176
 
1171
1211
        self.assertEqual(public_file.manifestation,
1172
1212
                          Manifestation.DELETED_RESOURCE)
1173
1213
        self.assertTrue(public_file.origin.endswith(node_id))
 
1214
        self.assertEqual(public_file.text, public_url)
1174
1215
        self.assertEqual(public_file.mimetype, "audio/mpeg")
1175
1216
        self.assertEqual(public_file.storage, STORAGE_DELETED)
1176
1217