| 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') |