← Back to branch summary

~nataliabidart/ubuntuone-client/credentials-shutdown

« back to all changes in this revision

Viewing changes to tests/credentials/test_credentials.py

  • Committer: natalia.bidart at canonical
  • Date: 2011-01-11 19:13:52 UTC
  • Revision ID: natalia.bidart@canonical.com-20110111191352-zeucudsfuzlj6czc
https://launchpad.net/bugs/701606
The service should shutdown when unused (LP: #701606).

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/credentials/test_credentials.py
25
25
from ubuntuone.devtools.handlers import MementoHandler
26
26
 
27
27
from ubuntuone.credentials import (dbus, logger, logging, ubuntu_sso,
28
 
    CredentialsManagement,
 
28
    CredentialsManagement, TIMEOUT_INTERVAL,
29
29
    DBUS_BUS_NAME, DBUS_CREDENTIALS_PATH, DBUS_CREDENTIALS_IFACE,
30
30
    APP_NAME, HELP_TEXT_KEY, DESCRIPTION, TC_URL_KEY, TC_URL,
31
31
    PING_URL_KEY, PING_URL, WINDOW_ID_KEY,
578
578
 
579
579
    app_name = APP_NAME * 2
580
580
    error_dict = {'error_type': 'Test'}
 
581
 
 
582
 
 
583
class RefCountingTestCase(CredentialsManagementTestCase):
 
584
    """Tests for the CredentialsManagement ref counting."""
 
585
 
 
586
    def setUp(self):
 
587
        super(RefCountingTestCase, self).setUp()
 
588
        self._called = False
 
589
        self.client = CredentialsManagement(timeout_func=lambda *a: None,
 
590
                                            shutdown_func=lambda *a: None)
 
591
 
 
592
    def _set_called(self, *args, **kwargs):
 
593
        """Keep track of method calls."""
 
594
        self._called = (args, kwargs)
 
595
 
 
596
    def test_ref_counting(self):
 
597
        """Ref counting is in place."""
 
598
        self.assertEqual(self.client.ref_count, 0)
 
599
 
 
600
    def test_find_credentials(self):
 
601
        """Keep proper track of on going requests."""
 
602
        self.client.find_credentials()
 
603
 
 
604
        self.assertEqual(self.client.ref_count, 1)
 
605
 
 
606
    def test_clear_credentials(self):
 
607
        """Keep proper track of on going requests."""
 
608
        self.client.clear_credentials()
 
609
 
 
610
        self.assertEqual(self.client.ref_count, 1)
 
611
 
 
612
    def test_store_credentials(self):
 
613
        """Keep proper track of on going requests."""
 
614
        self.client.store_credentials(FAKED_CREDENTIALS)
 
615
 
 
616
        self.assertEqual(self.client.ref_count, 1)
 
617
 
 
618
    def test_register(self):
 
619
        """Keep proper track of on going requests."""
 
620
        self.client.register()
 
621
 
 
622
        self.assertEqual(self.client.ref_count, 1)
 
623
 
 
624
    def test_login(self):
 
625
        """Keep proper track of on going requests."""
 
626
        self.client.login()
 
627
 
 
628
        self.assertEqual(self.client.ref_count, 1)
 
629
 
 
630
    def test_several_requests(self):
 
631
        """Requests can be nested."""
 
632
        self.client.login()
 
633
        self.client.clear_credentials()
 
634
        self.client.find_credentials()
 
635
        self.client.register()
 
636
        self.client.store_credentials(FAKED_CREDENTIALS)
 
637
 
 
638
        self.assertEqual(self.client.ref_count, 5)
 
639
 
 
640
    def test_credentials_found(self):
 
641
        """Ref counter is decreased when a signal is sent."""
 
642
        self.client.ref_count = 3
 
643
        self.client.CredentialsFound(FAKED_CREDENTIALS)
 
644
 
 
645
        self.assertEqual(self.client.ref_count, 2)
 
646
 
 
647
    def test_credentials_not_found(self):
 
648
        """Ref counter is decreased when a signal is sent."""
 
649
        self.client.ref_count = 3
 
650
        self.client.CredentialsNotFound()
 
651
 
 
652
        self.assertEqual(self.client.ref_count, 2)
 
653
 
 
654
    def test_credentials_cleared(self):
 
655
        """Ref counter is decreased when a signal is sent."""
 
656
        self.client.ref_count = 3
 
657
        self.client.CredentialsCleared()
 
658
 
 
659
        self.assertEqual(self.client.ref_count, 2)
 
660
 
 
661
    def test_credentials_stored(self):
 
662
        """Ref counter is decreased when a signal is sent."""
 
663
        self.client.ref_count = 3
 
664
        self.client.CredentialsStored()
 
665
 
 
666
        self.assertEqual(self.client.ref_count, 2)
 
667
 
 
668
    def test_credentials_error(self):
 
669
        """Ref counter is decreased when a signal is sent."""
 
670
        self.client.ref_count = 3
 
671
        self.client.CredentialsError({'error_type': 'test'})
 
672
 
 
673
        self.assertEqual(self.client.ref_count, 2)
 
674
 
 
675
    def test_authorization_denied(self):
 
676
        """Ref counter is decreased when a signal is sent."""
 
677
        self.client.ref_count = 3
 
678
        self.client.AuthorizationDenied()
 
679
 
 
680
        self.assertEqual(self.client.ref_count, 2)
 
681
 
 
682
    def test_credentials_found_when_ref_count_is_not_positive(self):
 
683
        """Ref counter is decreased when a signal is sent."""
 
684
        self.client._ref_count = -3
 
685
        self.client.CredentialsFound(FAKED_CREDENTIALS)
 
686
 
 
687
        self.assertEqual(self.client.ref_count, 0)
 
688
        msg = 'Attempting to decrease ref_count to a negative value (-4).'
 
689
        self.assertTrue(self.memento.check_warning(msg))
 
690
 
 
691
    def test_credentials_not_found_when_ref_count_is_not_positive(self):
 
692
        """Ref counter is decreased when a signal is sent."""
 
693
        self.client._ref_count = -3
 
694
        self.client.CredentialsNotFound()
 
695
 
 
696
        self.assertEqual(self.client.ref_count, 0)
 
697
        msg = 'Attempting to decrease ref_count to a negative value (-4).'
 
698
        self.assertTrue(self.memento.check_warning(msg))
 
699
 
 
700
    def test_credentials_cleared_when_ref_count_is_not_positive(self):
 
701
        """Ref counter is decreased when a signal is sent."""
 
702
        self.client._ref_count = -3
 
703
        self.client.CredentialsCleared()
 
704
 
 
705
        self.assertEqual(self.client.ref_count, 0)
 
706
        msg = 'Attempting to decrease ref_count to a negative value (-4).'
 
707
        self.assertTrue(self.memento.check_warning(msg))
 
708
 
 
709
    def test_credentials_stored_when_ref_count_is_not_positive(self):
 
710
        """Ref counter is decreased when a signal is sent."""
 
711
        self.client._ref_count = -3
 
712
        self.client.CredentialsStored()
 
713
 
 
714
        self.assertEqual(self.client.ref_count, 0)
 
715
        msg = 'Attempting to decrease ref_count to a negative value (-4).'
 
716
        self.assertTrue(self.memento.check_warning(msg))
 
717
 
 
718
    def test_credentials_error_when_ref_count_is_not_positive(self):
 
719
        """Ref counter is decreased when a signal is sent."""
 
720
        self.client._ref_count = -3
 
721
        self.client.CredentialsError({'error_type': 'test'})
 
722
 
 
723
        self.assertEqual(self.client.ref_count, 0)
 
724
        msg = 'Attempting to decrease ref_count to a negative value (-4).'
 
725
        self.assertTrue(self.memento.check_warning(msg))
 
726
 
 
727
    def test_autorization_denied_when_ref_count_is_not_positive(self):
 
728
        """Ref counter is decreased when a signal is sent."""
 
729
        self.client._ref_count = -3
 
730
        self.client.AuthorizationDenied()
 
731
 
 
732
        self.assertEqual(self.client.ref_count, 0)
 
733
        msg = 'Attempting to decrease ref_count to a negative value (-4).'
 
734
        self.assertTrue(self.memento.check_warning(msg))
 
735
 
 
736
    def test_on_zero_ref_count_shutdown(self):
 
737
        """When ref count reaches 0, queue shutdown op."""
 
738
        self.client.timeout_func = self._set_called
 
739
        self.client.find_credentials()
 
740
        self.client.CredentialsFound(FAKED_CREDENTIALS)
 
741
 
 
742
        self.assertEqual(self._called,
 
743
                         ((TIMEOUT_INTERVAL, self.client.shutdown_func), {}))
 
744
 
 
745
    def test_on_non_zero_ref_count_do_not_shutdown(self):
 
746
        """If ref count is not 0, do not queue shutdown op."""
 
747
        self.client.timeout_func = self._set_called
 
748
        self.client.find_credentials()
 
749
 
 
750
        self.assertEqual(self._called, False)