def set_default_type(k, v):
if Dict.is_dict(v):
return (k, Close(v))
elif Dict.is_list(v):
return (k, Dict.is_type(v)([None if isinstance(i, type) else i for i in v]))
else:
return (k, None if isinstance(v, type) else v)
def test_is_dict(self):
et = {'test': 123}
dicts = [i(et) for i in Dict.__supported_classes__]
for i in dicts:
self.assertEqual(Dict.is_dict(i), True)
for i in TestType.all_items:
self.assertEqual(Dict.is_dict(i), False)
def _request(self) -> Dict:
if self._config['kv_version'] == 2:
return Dict(
self._auth.v2.read_secret_version(
path=self._config['path'])['data']['data'])
elif self._config['kv_version'] == 1:
return Dict(
self._auth.v1.read_secret(path=self._config['path'])['data'])
else:
return Dict()
def test_list_value(self):
with unittest.mock.patch.dict(os.environ, {'FOO': '1,2,3,4,5'}):
self.assertEqual(
Dict(foo=[int], __env__=True).bind(Environment), {
'foo': [1, 2, 3, 4, 5],
'__env__': True
})
def test_variable(self):
with unittest.mock.patch.dict(os.environ, {'FOO': 'bar'}):
self.assertEqual(
Dict(foo=str, __env__=True).bind(Environment), {
'foo': 'bar',
'__env__': True
})
def test_with_prefix(self):
with unittest.mock.patch.dict(os.environ, {'FOO_BAR': 'baz'}):
self.assertEqual(
Dict(foo=dict(bar=str), __env__=True).bind(Environment), {
'foo': {
'bar': 'baz'
},
'__env__': True
})
def test_finalize(self):
data = test_data
self.assertEqual(Close(Dict(data)), test_data)
def read(self, obj: Dict, prefix: str) -> Dict:
return Dict([self.env(prefix, k, v) for k, v in obj.items()])
import unittest
from abconfig import GetAttrs
from abconfig.common import Dict
from abconfig.utils import Close
test_data = dict(test1=1, test2=1, test3=Dict(a=1, b=1))
class TestClass(Dict):
test1 = 1
test2 = 1
test3 = Dict(a=1, b=1)
class TestGetAttrs(unittest.TestCase):
def test_read_attrs(self):
self.assertEqual(GetAttrs(TestClass()), test_data)
class TestClose(unittest.TestCase):
def test_finalize(self):
data = test_data
self.assertEqual(Close(Dict(data)), test_data)
def __init__(self, obj: Dict):
super().__init__(Dict(obj).fmap(self.set_default_type))
def test_wrong_file_format(self, m):
self.assertEqual(
Dict(test=1, __file__=data['__file__']).bind(Json),
dict(test=1, __file__=data['__file__']))
m.assert_called_with(data['__file__'], 'r')
def test_detect_format_toml(self, m):
self.assertEqual(
Dict(test=1, __file__=data['__file__']).bind(File),
dict(test=1, __file__=data['__file__']))
m.assert_called_with(data['__file__'], 'r')
def test_disabled(self):
self.assertEqual(Dict(test=1, ).bind(Json), dict(test=1))
def test_with_prefix(self, m):
self.assertEqual(
Dict(test=1, __file__=data['__file__'],
__prefix__='test').bind(File),
dict(test=1, __file__=data['__file__'], __prefix__='test'))
m.assert_called_with(data['__file__'], 'r')
def test_toml(self, m):
self.assertEqual(Dict(source).bind(Toml), data)
m.assert_called_with(data['__file__'], 'r')
class TestClass(Dict):
test1 = 1
test2 = 1
test3 = Dict(a=1, b=1)
def test_bind(self):
self.assertEqual(
Dict(data=1).bind(lambda x: dict(new_data=x['data'])),
Dict(new_data=1))
def test_fmap(self):
self.assertEqual(
Dict(data=1).fmap(lambda k, v: (k, v + 1)), Dict(data=2))
def test_associativity(self):
self.assertEqual(
Dict(Dict(data=1) + dict(data=2)) + dict(data=3),
Dict(data=1) + (Dict(dict(data=2)) + dict(data=3)))
def test_mempty(self):
self.assertEqual(
Dict(Dict.__mempty__) + dict(data=2),
Dict(data=2) + Dict.__mempty__, dict(data=2))
class VaultData(OSEnviron):
_config_scheme = Dict(auth_type='token',
data_type='json',
addr=str,
token=str,
path=str,
kv_version=2,
header_value=str,
role=str)
def __init__(self, obj: Dict):
self._required = obj.get('__vault_required__', True)
self._config = (self._config_scheme + obj.get('__vault__')).bind(Close)
try:
self._cache = self._request()
except VaultError as error:
if self._required is True:
raise VaultError(error)
self._cache = {}
if self._config['data_type'] == 'kv':
super().__init__(obj + self.read(obj, obj.get('__prefix__')))
elif self._config['data_type'] == 'json':
super().__init__(obj + self._cache)
else:
raise ValueError(f'only supported "kv" or "json"')
def env(self, prefix: str, k: str, v: any) -> tuple:
key = k if k != '__vault__' else 'vault'
if self.is_dict(v):
return (key, self.read(v, self.concat(prefix, key)))
else:
return (key,
self._cache.get(self.concat(prefix, key).upper(), None))
def _request(self) -> Dict:
if self._config['kv_version'] == 2:
return Dict(
self._auth.v2.read_secret_version(
path=self._config['path'])['data']['data'])
elif self._config['kv_version'] == 1:
return Dict(
self._auth.v1.read_secret(path=self._config['path'])['data'])
else:
return Dict()
@property
@ignore_warnings
def _auth(self):
client = VaultClient(url=self._config['addr'])
auth = self._config['auth_type']
token = self._config['token']
if token and auth == 'token':
client.token = token
elif auth == 'aws_iam':
session = boto3.Session()
creds = session.get_credentials()
kwargs = [self._config['header_value'], self._config['role']]
client.auth_aws_iam(
creds.access_key, creds.secret_key, creds.token,
**{k: v
for k, v in self._config.items() if v and k in kwargs})
if client.is_authenticated() is False:
raise VaultUnauthorized(f'auth_type: {auth}')
return client.secrets.kv
@staticmethod
def enabled(obj: Dict):
return Dict.is_dict(obj.get('__vault__'))
def test_disabled(self):
self.assertEqual(
Dict(foo=1, __env__=False).bind(Environment), {
'foo': 1,
'__env__': False
})
def enabled(obj: Dict):
return Dict.is_dict(obj.get('__vault__'))
def test_json(self, m):
self.assertEqual(Dict(source).bind(Json), data)
m.assert_called_with(data['__file__'], 'r')
