← Back to branch summary

~duplicity-team/duplicity/0.8-series

« back to all changes in this revision

Viewing changes to testing/unit/test_backend_instance.py

  • Committer: Kenneth Loafman
  • Date: 2018-07-27 02:18:12 UTC
  • Revision ID: kenneth@loafman.com-20180727021812-3yzv15gux0bnncds
* Checkpoint: Fixing unadorned strings for testing/unit/*.

Show diffs side-by-side

added added

removed removed

Lines of Context:
testing/unit/test_backend_instance.py
33
33
 
34
34
    def setUp(self):
35
35
        UnitTestCase.setUp(self)
36
 
        assert not os.system("rm -rf testfiles")
37
 
        os.makedirs('testfiles')
 
36
        assert not os.system(u"rm -rf testfiles")
 
37
        os.makedirs(u'testfiles')
38
38
        self.backend = None
39
 
        self.local = path.Path('testfiles/local')
40
 
        self.local.writefileobj(StringIO.StringIO("hello"))
 
39
        self.local = path.Path(u'testfiles/local')
 
40
        self.local.writefileobj(StringIO.StringIO(u"hello"))
41
41
 
42
42
    def tearDown(self):
43
43
        if self.backend is None:
44
44
            return
45
 
        if hasattr(self.backend, '_close'):
 
45
        if hasattr(self.backend, u'_close'):
46
46
            self.backend._close()
47
47
 
48
48
    def test_get(self):
49
49
        if self.backend is None:
50
50
            return
51
 
        self.backend._put(self.local, 'a')
52
 
        getfile = path.Path('testfiles/getfile')
53
 
        self.backend._get('a', getfile)
 
51
        self.backend._put(self.local, u'a')
 
52
        getfile = path.Path(u'testfiles/getfile')
 
53
        self.backend._get(u'a', getfile)
54
54
        self.assertTrue(self.local.compare_data(getfile))
55
55
 
56
56
    def test_list(self):
57
57
        if self.backend is None:
58
58
            return
59
 
        self.backend._put(self.local, 'a')
60
 
        self.backend._put(self.local, 'b')
 
59
        self.backend._put(self.local, u'a')
 
60
        self.backend._put(self.local, u'b')
61
61
        # It's OK for backends to create files as a side effect of put (e.g.
62
62
        # the par2 backend does), so only check that at least a and b exist.
63
 
        self.assertTrue('a' in self.backend._list())
64
 
        self.assertTrue('b' in self.backend._list())
 
63
        self.assertTrue(u'a' in self.backend._list())
 
64
        self.assertTrue(u'b' in self.backend._list())
65
65
 
66
66
    def test_delete(self):
67
67
        if self.backend is None:
68
68
            return
69
 
        if not hasattr(self.backend, '_delete'):
70
 
            self.assertTrue(hasattr(self.backend, '_delete_list'))
 
69
        if not hasattr(self.backend, u'_delete'):
 
70
            self.assertTrue(hasattr(self.backend, u'_delete_list'))
71
71
            return
72
 
        self.backend._put(self.local, 'a')
73
 
        self.backend._put(self.local, 'b')
74
 
        self.backend._delete('a')
75
 
        self.assertFalse('a' in self.backend._list())
76
 
        self.assertTrue('b' in self.backend._list())
 
72
        self.backend._put(self.local, u'a')
 
73
        self.backend._put(self.local, u'b')
 
74
        self.backend._delete(u'a')
 
75
        self.assertFalse(u'a' in self.backend._list())
 
76
        self.assertTrue(u'b' in self.backend._list())
77
77
 
78
78
    def test_delete_clean(self):
79
79
        if self.backend is None:
80
80
            return
81
 
        if not hasattr(self.backend, '_delete'):
82
 
            self.assertTrue(hasattr(self.backend, '_delete_list'))
 
81
        if not hasattr(self.backend, u'_delete'):
 
82
            self.assertTrue(hasattr(self.backend, u'_delete_list'))
83
83
            return
84
 
        self.backend._put(self.local, 'a')
85
 
        self.backend._delete('a')
 
84
        self.backend._put(self.local, u'a')
 
85
        self.backend._delete(u'a')
86
86
        self.assertEqual(self.backend._list(), [])
87
87
 
88
88
    def test_delete_missing(self):
89
89
        if self.backend is None:
90
90
            return
91
 
        if not hasattr(self.backend, '_delete'):
92
 
            self.assertTrue(hasattr(self.backend, '_delete_list'))
 
91
        if not hasattr(self.backend, u'_delete'):
 
92
            self.assertTrue(hasattr(self.backend, u'_delete_list'))
93
93
            return
94
94
        # Backends can either silently ignore this, or throw an error
95
95
        # that gives log.ErrorCode.backend_not_found.
96
96
        try:
97
 
            self.backend._delete('a')
 
97
            self.backend._delete(u'a')
98
98
        except BackendException as e:
99
99
            pass  # Something went wrong, but it was an 'expected' something
100
100
        except Exception as e:
101
 
            code = duplicity.backend._get_code_from_exception(self.backend, 'delete', e)
 
101
            code = duplicity.backend._get_code_from_exception(self.backend, u'delete', e)
102
102
            self.assertEqual(code, log.ErrorCode.backend_not_found)
103
103
 
104
104
    def test_delete_list(self):
105
105
        if self.backend is None:
106
106
            return
107
 
        if not hasattr(self.backend, '_delete_list'):
108
 
            self.assertTrue(hasattr(self.backend, '_delete'))
 
107
        if not hasattr(self.backend, u'_delete_list'):
 
108
            self.assertTrue(hasattr(self.backend, u'_delete'))
109
109
            return
110
 
        self.backend._put(self.local, 'a')
111
 
        self.backend._put(self.local, 'b')
112
 
        self.backend._put(self.local, 'c')
113
 
        self.backend._delete_list(['a', 'd', 'c'])
 
110
        self.backend._put(self.local, u'a')
 
111
        self.backend._put(self.local, u'b')
 
112
        self.backend._put(self.local, u'c')
 
113
        self.backend._delete_list([u'a', u'd', u'c'])
114
114
        files = self.backend._list()
115
 
        self.assertFalse('a' in files, files)
116
 
        self.assertTrue('b' in files, files)
117
 
        self.assertFalse('c' in files, files)
 
115
        self.assertFalse(u'a' in files, files)
 
116
        self.assertTrue(u'b' in files, files)
 
117
        self.assertFalse(u'c' in files, files)
118
118
 
119
119
    def test_move(self):
120
120
        if self.backend is None:
121
121
            return
122
 
        if not hasattr(self.backend, '_move'):
 
122
        if not hasattr(self.backend, u'_move'):
123
123
            return
124
124
 
125
 
        copy = path.Path('testfiles/copy')
 
125
        copy = path.Path(u'testfiles/copy')
126
126
        self.local.copy(copy)
127
127
 
128
 
        self.backend._move(self.local, 'a')
129
 
        self.assertTrue('a' in self.backend._list())
 
128
        self.backend._move(self.local, u'a')
 
129
        self.assertTrue(u'a' in self.backend._list())
130
130
        self.assertFalse(self.local.exists())
131
131
 
132
 
        getfile = path.Path('testfiles/getfile')
133
 
        self.backend._get('a', getfile)
 
132
        getfile = path.Path(u'testfiles/getfile')
 
133
        self.backend._get(u'a', getfile)
134
134
        self.assertTrue(copy.compare_data(getfile))
135
135
 
136
136
    def test_query_exists(self):
137
137
        if self.backend is None:
138
138
            return
139
 
        if not hasattr(self.backend, '_query'):
 
139
        if not hasattr(self.backend, u'_query'):
140
140
            return
141
 
        self.backend._put(self.local, 'a')
142
 
        info = self.backend._query('a')
143
 
        self.assertEqual(info['size'], self.local.getsize())
 
141
        self.backend._put(self.local, u'a')
 
142
        info = self.backend._query(u'a')
 
143
        self.assertEqual(info[u'size'], self.local.getsize())
144
144
 
145
145
    def test_query_missing(self):
146
146
        if self.backend is None:
147
147
            return
148
 
        if not hasattr(self.backend, '_query'):
 
148
        if not hasattr(self.backend, u'_query'):
149
149
            return
150
150
        # Backends can either return -1 themselves, or throw an error
151
151
        # that gives log.ErrorCode.backend_not_found.
152
152
        try:
153
 
            info = self.backend._query('a')
 
153
            info = self.backend._query(u'a')
154
154
        except BackendException as e:
155
155
            pass  # Something went wrong, but it was an 'expected' something
156
156
        except Exception as e:
157
 
            code = duplicity.backend._get_code_from_exception(self.backend, 'query', e)
 
157
            code = duplicity.backend._get_code_from_exception(self.backend, u'query', e)
158
158
            self.assertEqual(code, log.ErrorCode.backend_not_found)
159
159
        else:
160
 
            self.assertEqual(info['size'], -1)
 
160
            self.assertEqual(info[u'size'], -1)
161
161
 
162
162
    def test_query_list(self):
163
163
        if self.backend is None:
164
164
            return
165
 
        if not hasattr(self.backend, '_query_list'):
 
165
        if not hasattr(self.backend, u'_query_list'):
166
166
            return
167
 
        self.backend._put(self.local, 'a')
168
 
        self.backend._put(self.local, 'c')
169
 
        info = self.backend._query_list(['a', 'b'])
170
 
        self.assertEqual(info['a']['size'], self.local.getsize())
171
 
        self.assertEqual(info['b']['size'], -1)
172
 
        self.assertFalse('c' in info)
 
167
        self.backend._put(self.local, u'a')
 
168
        self.backend._put(self.local, u'c')
 
169
        info = self.backend._query_list([u'a', u'b'])
 
170
        self.assertEqual(info[u'a'][u'size'], self.local.getsize())
 
171
        self.assertEqual(info[u'b'][u'size'], -1)
 
172
        self.assertFalse(u'c' in info)
173
173
 
174
174
 
175
175
class LocalBackendTest(BackendInstanceBase):
176
176
    def setUp(self):
177
177
        super(LocalBackendTest, self).setUp()
178
 
        url = 'file://testfiles/output'
 
178
        url = u'file://testfiles/output'
179
179
        self.backend = duplicity.backend.get_backend_object(url)
180
 
        self.assertEqual(self.backend.__class__.__name__, 'LocalBackend')
 
180
        self.assertEqual(self.backend.__class__.__name__, u'LocalBackend')
181
181
 
182
182
 
183
183
class Par2BackendTest(BackendInstanceBase):
184
184
    def setUp(self):
185
185
        super(Par2BackendTest, self).setUp()
186
 
        url = 'par2+file://testfiles/output'
 
186
        url = u'par2+file://testfiles/output'
187
187
        self.backend = duplicity.backend.get_backend_object(url)
188
 
        self.assertEqual(self.backend.__class__.__name__, 'Par2Backend')
 
188
        self.assertEqual(self.backend.__class__.__name__, u'Par2Backend')
189
189
 
190
190
    # TODO: Add par2-specific tests here, to confirm that we can recover from
191
191
    # a missing file
203
203
class TahoeBackendTest(BackendInstanceBase):
204
204
    def setUp(self):
205
205
        super(TahoeBackendTest, self).setUp()
206
 
        os.makedirs('testfiles/output')
207
 
        url = 'tahoe://testfiles/output'
 
206
        os.makedirs(u'testfiles/output')
 
207
        url = u'tahoe://testfiles/output'
208
208
        self.backend = duplicity.backend.get_backend_object(url)
209
 
        self.assertEqual(self.backend.__class__.__name__, 'TAHOEBackend')
 
209
        self.assertEqual(self.backend.__class__.__name__, u'TAHOEBackend')
210
210
 
211
211
 
212
212
class HSIBackendTest(BackendInstanceBase):
213
213
    def setUp(self):
214
214
        super(HSIBackendTest, self).setUp()
215
 
        os.makedirs('testfiles/output')
 
215
        os.makedirs(u'testfiles/output')
216
216
        # hostname is ignored...  Seemingly on purpose
217
 
        url = 'hsi://hostname%s/testfiles/output' % os.getcwd()
 
217
        url = u'hsi://hostname%s/testfiles/output' % os.getcwd()
218
218
        self.backend = duplicity.backend.get_backend_object(url)
219
 
        self.assertEqual(self.backend.__class__.__name__, 'HSIBackend')
 
219
        self.assertEqual(self.backend.__class__.__name__, u'HSIBackend')
220
220
 
221
221
 
222
222
class FTPBackendTest(BackendInstanceBase):
223
223
    def setUp(self):
224
224
        super(FTPBackendTest, self).setUp()
225
 
        os.makedirs('testfiles/output')
226
 
        url = 'ftp://user:pass@hostname/testfiles/output'
 
225
        os.makedirs(u'testfiles/output')
 
226
        url = u'ftp://user:pass@hostname/testfiles/output'
227
227
        self.backend = duplicity.backend.get_backend_object(url)
228
 
        self.assertEqual(self.backend.__class__.__name__, 'LFTPBackend')
 
228
        self.assertEqual(self.backend.__class__.__name__, u'LFTPBackend')
229
229
 
230
230
 
231
231
class FTPSBackendTest(BackendInstanceBase):
232
232
    def setUp(self):
233
233
        super(FTPSBackendTest, self).setUp()
234
 
        os.makedirs('testfiles/output')
235
 
        url = 'ftps://user:pass@hostname/testfiles/output'
 
234
        os.makedirs(u'testfiles/output')
 
235
        url = u'ftps://user:pass@hostname/testfiles/output'
236
236
        self.backend = duplicity.backend.get_backend_object(url)
237
 
        self.assertEqual(self.backend.__class__.__name__, 'LFTPBackend')
238
 
 
239
 
 
240
 
if __name__ == "__main__":
 
237
        self.assertEqual(self.backend.__class__.__name__, u'LFTPBackend')
 
238
 
 
239
 
 
240
if __name__ == u"__main__":
241
241
    unittest.main()