Debian Codegraph @

test/unit/test_represent_file_metadata.py

raw
1 ######################################################################
2 #
3 # File: test/unit/test_represent_file_metadata.py
4 #
5 # Copyright 2021 Backblaze Inc. All Rights Reserved.
6 #
7 # License https://www.backblaze.com/using_b2_code.html
8 #
9 ######################################################################
10
11 from io import StringIO
12
13 import pytest
14 from b2sdk.v2 import (
15 SSE_B2_AES,
16 B2Api,
17 B2HttpApiConfig,
18 EncryptionAlgorithm,
19 EncryptionKey,
20 EncryptionMode,
21 EncryptionSetting,
22 FileRetentionSetting,
23 LegalHold,
24 RawSimulator,
25 RetentionMode,
26 StubAccountInfo,
27 )
28
29 from b2._internal.console_tool import ConsoleTool, DownloadCommand
30
31 from .test_base import TestBase
32
33
34 class TestReprentFileMetadata(TestBase):
35 def setUp(self):
36 self.master_b2_api = B2Api(
37 StubAccountInfo(), None, api_config=B2HttpApiConfig(_raw_api_class=RawSimulator)
38 )
39 self.raw_api = self.master_b2_api.session.raw_api
40 (self.master_account_id, self.master_key) = self.raw_api.create_account()
41 self.master_b2_api.authorize_account('production', self.master_account_id, self.master_key)
42 self.lock_enabled_bucket = self.master_b2_api.create_bucket(
43 'lock-enabled-bucket', 'allPrivate', is_file_lock_enabled=True
44 )
45 self.lock_disabled_bucket = self.master_b2_api.create_bucket(
46 'lock-disabled-bucket', 'allPrivate', is_file_lock_enabled=False
47 )
48 new_key = self.master_b2_api.create_key(
49 [
50 'listKeys',
51 'listBuckets',
52 'listFiles',
53 'readFiles',
54 ], 'restricted'
55 )
56 self.restricted_key_id, self.restricted_key = new_key.id_, new_key.application_key
57
58 self.restricted_b2_api = B2Api(StubAccountInfo(), None)
59 self.restricted_b2_api.session.raw_api = self.raw_api
60 self.restricted_b2_api.authorize_account(
61 'production', self.restricted_key_id, self.restricted_key
62 )
63
64 def _get_b2api(**kwargs) -> B2Api:
65 kwargs.pop('profile', None)
66 return self.master_b2_api
67
68 self.mp = pytest.MonkeyPatch()
69 self.mp.setattr('b2._internal.console_tool._get_b2api_for_profile', _get_b2api)
70 self.mp.setattr('b2._internal.console_tool._get_inmemory_b2api', _get_b2api)
71
72 self.stdout = StringIO()
73 self.stderr = StringIO()
74 self.console_tool = ConsoleTool(self.stdout, self.stderr)
75
76 def tearDown(self):
77 self.mp.undo()
78 super().tearDown()
79
80 def assertRetentionRepr(self, file_id: str, api: B2Api, expected_repr: str):
81 file_version = api.get_file_info(file_id)
82 assert DownloadCommand._represent_retention(file_version.file_retention) == expected_repr
83
84 def assertLegalHoldRepr(self, file_id: str, api: B2Api, expected_repr: str):
85 file_version = api.get_file_info(file_id)
86 assert DownloadCommand._represent_legal_hold(file_version.legal_hold) == expected_repr
87
88 def assertEncryptionRepr(self, file_id: str, expected_repr: str):
89 file_version = self.master_b2_api.get_file_info(file_id)
90 assert DownloadCommand._represent_encryption(
91 file_version.server_side_encryption
92 ) == expected_repr
93
94 def test_file_retention(self):
95 file = self.lock_disabled_bucket.upload_bytes(b'insignificant', 'file')
96 self.assertRetentionRepr(file.id_, self.master_b2_api, 'none')
97 self.assertRetentionRepr(file.id_, self.restricted_b2_api, '<unauthorized to read>')
98
99 file = self.lock_enabled_bucket.upload_bytes(b'insignificant', 'file')
100 self.assertRetentionRepr(file.id_, self.master_b2_api, 'none')
101 self.assertRetentionRepr(file.id_, self.restricted_b2_api, '<unauthorized to read>')
102
103 self.master_b2_api.update_file_retention(
104 file.id_, file.file_name, FileRetentionSetting(RetentionMode.GOVERNANCE, 1500)
105 )
106 self.assertRetentionRepr(
107 file.id_, self.master_b2_api,
108 'mode=governance, retainUntil=1970-01-01 00:00:01.500000+00:00'
109 )
110 self.assertRetentionRepr(file.id_, self.restricted_b2_api, '<unauthorized to read>')
111
112 self.master_b2_api.update_file_retention(
113 file.id_, file.file_name, FileRetentionSetting(RetentionMode.COMPLIANCE, 2000)
114 )
115
116 self.assertRetentionRepr(
117 file.id_, self.master_b2_api, 'mode=compliance, retainUntil=1970-01-01 00:00:02+00:00'
118 )
119 self.assertRetentionRepr(file.id_, self.restricted_b2_api, '<unauthorized to read>')
120
121 def test_legal_hold(self):
122 file = self.lock_disabled_bucket.upload_bytes(b'insignificant', 'file')
123 self.assertLegalHoldRepr(file.id_, self.master_b2_api, '<unset>')
124 self.assertLegalHoldRepr(file.id_, self.restricted_b2_api, '<unauthorized to read>')
125
126 file = self.lock_enabled_bucket.upload_bytes(b'insignificant', 'file')
127 self.assertLegalHoldRepr(file.id_, self.master_b2_api, '<unset>')
128 self.assertLegalHoldRepr(file.id_, self.restricted_b2_api, '<unauthorized to read>')
129
130 self.master_b2_api.update_file_legal_hold(file.id_, file.file_name, LegalHold.ON)
131 self.assertLegalHoldRepr(file.id_, self.master_b2_api, 'on')
132 self.assertLegalHoldRepr(file.id_, self.restricted_b2_api, '<unauthorized to read>')
133
134 self.master_b2_api.update_file_legal_hold(file.id_, file.file_name, LegalHold.OFF)
135 self.assertLegalHoldRepr(file.id_, self.master_b2_api, 'off')
136 self.assertLegalHoldRepr(file.id_, self.restricted_b2_api, '<unauthorized to read>')
137
138 def test_encryption(self):
139 file = self.lock_enabled_bucket.upload_bytes(b'insignificant', 'file')
140 self.assertEncryptionRepr(file.id_, 'none')
141
142 file = self.lock_enabled_bucket.upload_bytes(
143 b'insignificant', 'file', encryption=SSE_B2_AES
144 )
145 self.assertEncryptionRepr(file.id_, 'mode=SSE-B2, algorithm=AES256')
146
147 file = self.lock_enabled_bucket.upload_bytes(
148 b'insignificant',
149 'file',
150 encryption=EncryptionSetting(
151 EncryptionMode.SSE_C,
152 algorithm=EncryptionAlgorithm.AES256,
153 key=EncryptionKey(b'', key_id=None),
154 )
155 )
156 self.assertEncryptionRepr(file.id_, 'mode=SSE-C, algorithm=AES256')
157
158 file = self.lock_enabled_bucket.upload_bytes(
159 b'insignificant',
160 'file',
161 encryption=EncryptionSetting(
162 EncryptionMode.SSE_C,
163 algorithm=EncryptionAlgorithm.AES256,
164 key=EncryptionKey(b'', key_id='some_id'),
165 )
166 )
167 self.assertEncryptionRepr(file.id_, 'mode=SSE-C, algorithm=AES256, key_id=some_id')