/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_remote.py

(spiv) Give clearer errors when remote operation fails with MemoryError or
 other unexpected exception (Martin [gz])

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_remote.py
2775
2775
             ('pack collection autopack',)],
2776
2776
            client._calls)
2777
2777
 
 
2778
    def test_oom_error_reporting(self):
 
2779
        """An out-of-memory condition on the server is reported clearly"""
 
2780
        transport_path = 'quack'
 
2781
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2782
        client.add_expected_call(
 
2783
            'PackRepository.autopack', ('quack/',),
 
2784
            'error', ('MemoryError',))
 
2785
        err = self.assertRaises(errors.BzrError, repo.autopack)
 
2786
        self.assertContainsRe(str(err), "^remote server out of mem")
 
2787
 
2778
2788
 
2779
2789
class TestErrorTranslationBase(tests.TestCaseWithMemoryTransport):
2780
2790
    """Base class for unit tests for bzrlib.remote._translate_error."""
2853
2863
            detail='extra detail')
2854
2864
        self.assertEqual(expected_error, translated_error)
2855
2865
 
 
2866
    def test_norepository(self):
 
2867
        bzrdir = self.make_bzrdir('')
 
2868
        translated_error = self.translateTuple(('norepository',),
 
2869
            bzrdir=bzrdir)
 
2870
        expected_error = errors.NoRepositoryPresent(bzrdir)
 
2871
        self.assertEqual(expected_error, translated_error)
 
2872
 
2856
2873
    def test_LockContention(self):
2857
2874
        translated_error = self.translateTuple(('LockContention',))
2858
2875
        expected_error = errors.LockContention('(remote lock)')
2886
2903
        expected_error = errors.DivergedBranches(branch, other_branch)
2887
2904
        self.assertEqual(expected_error, translated_error)
2888
2905
 
 
2906
    def test_NotStacked(self):
 
2907
        branch = self.make_branch('')
 
2908
        translated_error = self.translateTuple(('NotStacked',), branch=branch)
 
2909
        expected_error = errors.NotStacked(branch)
 
2910
        self.assertEqual(expected_error, translated_error)
 
2911
 
2889
2912
    def test_ReadError_no_args(self):
2890
2913
        path = 'a path'
2891
2914
        translated_error = self.translateTuple(('ReadError',), path=path)
2907
2930
 
2908
2931
    def test_PermissionDenied_no_args(self):
2909
2932
        path = 'a path'
2910
 
        translated_error = self.translateTuple(('PermissionDenied',), path=path)
 
2933
        translated_error = self.translateTuple(('PermissionDenied',),
 
2934
            path=path)
2911
2935
        expected_error = errors.PermissionDenied(path)
2912
2936
        self.assertEqual(expected_error, translated_error)
2913
2937
 
2936
2960
        expected_error = errors.PermissionDenied(path, extra)
2937
2961
        self.assertEqual(expected_error, translated_error)
2938
2962
 
 
2963
    # GZ 2011-03-02: TODO test for PermissionDenied with non-ascii 'extra'
 
2964
 
 
2965
    def test_NoSuchFile_context_path(self):
 
2966
        local_path = "local path"
 
2967
        translated_error = self.translateTuple(('ReadError', "remote path"),
 
2968
            path=local_path)
 
2969
        expected_error = errors.ReadError(local_path)
 
2970
        self.assertEqual(expected_error, translated_error)
 
2971
 
 
2972
    def test_NoSuchFile_without_context(self):
 
2973
        remote_path = "remote path"
 
2974
        translated_error = self.translateTuple(('ReadError', remote_path))
 
2975
        expected_error = errors.ReadError(remote_path)
 
2976
        self.assertEqual(expected_error, translated_error)
 
2977
 
 
2978
    def test_ReadOnlyError(self):
 
2979
        translated_error = self.translateTuple(('ReadOnlyError',))
 
2980
        expected_error = errors.TransportNotPossible("readonly transport")
 
2981
        self.assertEqual(expected_error, translated_error)
 
2982
 
 
2983
    def test_MemoryError(self):
 
2984
        translated_error = self.translateTuple(('MemoryError',))
 
2985
        self.assertStartsWith(str(translated_error),
 
2986
            "remote server out of memory")
 
2987
 
 
2988
    def test_generic_IndexError_no_classname(self):
 
2989
        err = errors.ErrorFromSmartServer(('error', "list index out of range"))
 
2990
        translated_error = self.translateErrorFromSmartServer(err)
 
2991
        expected_error = errors.UnknownErrorFromSmartServer(err)
 
2992
        self.assertEqual(expected_error, translated_error)
 
2993
 
 
2994
    # GZ 2011-03-02: TODO test generic non-ascii error string
 
2995
 
 
2996
    def test_generic_KeyError(self):
 
2997
        err = errors.ErrorFromSmartServer(('error', 'KeyError', "1"))
 
2998
        translated_error = self.translateErrorFromSmartServer(err)
 
2999
        expected_error = errors.UnknownErrorFromSmartServer(err)
 
3000
        self.assertEqual(expected_error, translated_error)
 
3001
 
2939
3002
 
2940
3003
class TestErrorTranslationRobustness(TestErrorTranslationBase):
2941
3004
    """Unit tests for bzrlib.remote._translate_error's robustness.