def test_unicode_input_errors(unicode_filename, verbose=False):
with open(unicode_filename, 'rb') as fp:
data = fp.read().decode('utf-8')
for input in [
data.encode('latin1', 'ignore'),
data.encode('utf-16-be'),
data.encode('utf-16-le'),
codecs.BOM_UTF8 + data.encode('utf-16-be'),
codecs.BOM_UTF16_BE + data.encode('utf-16-le'),
codecs.BOM_UTF16_LE + data.encode('utf-8') + b'!',
]:
try:
yaml.load(input)
except yaml.YAMLError as exc:
if verbose:
print(exc)
else:
raise AssertionError('expected an exception')
try:
yaml.load(BytesIO(input))
except yaml.YAMLError as exc:
if verbose:
print(exc)
else:
raise AssertionError('expected an exception')
def test_loader_error_single(error_filename, verbose=False):
try:
with open(error_filename, 'rb') as fp0:
yaml.load(fp0.read())
except yaml.YAMLError as exc:
if verbose:
print('%s:' % exc.__class__.__name__, exc)
else:
raise AssertionError('expected an exception')
def test_load_cyaml():
print("???????????????????????", platform.python_implementation())
import ruyaml
if sys.version_info >= (3, 8):
return
assert ruyaml.__with_libyaml__
from ruyaml.cyaml import CLoader
ruyaml.load('abc: 1', Loader=CLoader)
def rt(s):
import ruyaml
res = ruyaml.dump(
ruyaml.load(s, Loader=ruyaml.RoundTripLoader),
Dumper=ruyaml.RoundTripDumper,
)
return res.strip() + '\n'
def test_yaml_obj():
import ruyaml # NOQA
ruyaml.add_representer(Obj1, YAMLObj1.to_yaml)
ruyaml.add_multi_constructor(YAMLObj1.yaml_tag, YAMLObj1.from_yaml)
x = ruyaml.load('!obj:x.2\na: 1', Loader=ruyaml.Loader)
print(x)
assert ruyaml.dump(x) == """!obj:x.2 "{'a': 1}"\n"""
def test_dice_implicit_resolver():
import ruyaml # NOQA
pattern = re.compile(r'^\d+d\d+$')
ruyaml.add_implicit_resolver(u'!dice', pattern)
assert (ruyaml.dump(dict(treasure=Dice(10, 20)),
default_flow_style=False) == 'treasure: 10d20\n')
assert ruyaml.load('damage: 5d10',
Loader=ruyaml.Loader) == dict(damage=Dice(5, 10))
def test_emitter_events(events_filename, verbose=False):
with open(events_filename, 'rb') as fp0:
events = list(yaml.load(fp0, Loader=EventsLoader))
output = yaml.emit(events)
if verbose:
print('OUTPUT:')
print(output)
new_events = list(yaml.parse(output))
_compare_events(events, new_events)
def test_roundtrip_flow_mapping(self):
import ruyaml
s = dedent("""\
- {a: 1, b: hallo}
- {j: fka, k: 42}
""")
data = ruyaml.load(s, Loader=ruyaml.RoundTripLoader)
output = ruyaml.dump(data, Dumper=ruyaml.RoundTripDumper)
assert s == output
def test_emitter_error(error_filename, verbose=False):
with open(error_filename, 'rb') as fp0:
events = list(yaml.load(fp0, Loader=test_emitter.EventsLoader))
try:
yaml.emit(events)
except yaml.YAMLError as exc:
if verbose:
print('%s:' % exc.__class__.__name__, exc)
else:
raise AssertionError('expected an exception')
def round_trip_load(inp, preserve_quotes=None, version=None):
import ruyaml # NOQA
dinp = dedent(inp)
return ruyaml.load(
dinp,
Loader=ruyaml.RoundTripLoader,
preserve_quotes=preserve_quotes,
version=version,
)
def test_unicode_input(unicode_filename, verbose=False):
with open(unicode_filename, 'rb') as fp:
data = fp.read().decode('utf-8')
value = ' '.join(data.split())
output = yaml.load(data)
assert output == value, (output, value)
output = yaml.load(StringIO(data))
assert output == value, (output, value)
for input in [
data.encode('utf-8'),
codecs.BOM_UTF8 + data.encode('utf-8'),
codecs.BOM_UTF16_BE + data.encode('utf-16-be'),
codecs.BOM_UTF16_LE + data.encode('utf-16-le'),
]:
if verbose:
print('INPUT:', repr(input[:10]), '...')
output = yaml.load(input)
assert output == value, (output, value)
output = yaml.load(BytesIO(input))
assert output == value, (output, value)
def load(s, typ=float):
import ruyaml
x = '{"low": %s }' % (s)
print('input: [%s]' % (s), repr(x))
# just to check it is loadable json
res = json.loads(x)
assert isinstance(res['low'], typ)
ret_val = ruyaml.load(x, ruyaml.RoundTripLoader)
print(ret_val)
return ret_val['low']
def Xtest_numpy():
import ruyaml
if numpy is None:
return
data = numpy.arange(10)
print('data', type(data), data)
yaml_str = ruyaml.dump(data)
datb = ruyaml.load(yaml_str)
print('datb', type(datb), datb)
print('\nYAML', yaml_str)
assert data == datb
def test_added_inline_list(self):
import ruyaml
s1 = dedent("""
a:
- b
- c
- d
""")
s = 'a: [b, c, d]\n'
data = ruyaml.load(s1, Loader=ruyaml.RoundTripLoader)
val = data['a']
val.fa.set_flow_style()
# print(type(val), '_yaml_format' in dir(val))
output = ruyaml.dump(data, Dumper=ruyaml.RoundTripDumper)
assert s == output
def test_recursive(recursive_filename, verbose=False):
context = globals().copy()
with open(recursive_filename, 'rb') as fp0:
exec(fp0.read(), context)
value1 = context['value']
output1 = None
value2 = None
output2 = None
try:
output1 = yaml.dump(value1)
value2 = yaml.load(output1)
output2 = yaml.dump(value2)
assert output1 == output2, (output1, output2)
finally:
if verbose:
print('VALUE1:', value1)
print('VALUE2:', value2)
print('OUTPUT1:')
print(output1)
print('OUTPUT2:')
print(output2)
def test_representer_types(code_filename, verbose=False):
yaml = YAML(typ='safe', pure=True)
test_constructor._make_objects()
for allow_unicode in [False, True]:
for encoding in ['utf-8', 'utf-16-be', 'utf-16-le']:
with open(code_filename, 'rb') as fp0:
native1 = test_constructor._load_code(fp0.read())
native2 = None
try:
output = yaml.dump(
native1,
Dumper=test_constructor.MyDumper,
allow_unicode=allow_unicode,
encoding=encoding,
)
native2 = yaml.load(output, Loader=test_constructor.MyLoader)
try:
if native1 == native2:
continue
except TypeError:
pass
value1 = test_constructor._serialize_value(native1)
value2 = test_constructor._serialize_value(native2)
if verbose:
print('SERIALIZED NATIVE1:')
print(value1)
print('SERIALIZED NATIVE2:')
print(value2)
assert value1 == value2, (native1, native2)
finally:
if verbose:
print('NATIVE1:')
pprint.pprint(native1)
print('NATIVE2:')
pprint.pprint(native2)
print('OUTPUT:')
print(output)
mock_yaml.load.side_effect = [course_yml]
# this is not okay I assume, I just added args
helm_args = ['provided args']
helm_instance = mock_helm(helm_args)
helm_instance.client_version = '0.0.0'
instance = reckoner.course.Course(None)
self.assertTrue(
instance.plot(['a-chart-that-is-not-defined', 'fake-chart']))
test_course = "./tests/test_course.yml"
git_repo_path = "./test"
with open(test_course, 'r') as yaml_stream:
course_yaml_dict = ruyaml.load(yaml_stream, Loader=ruyaml.Loader)
test_release_names = list(course_yaml_dict['charts'].keys())
test_repositories = ['stable', 'incubator'],
test_minimum_versions = ['helm', 'reckoner']
test_repository_dict = {
'name': 'test_repo',
'url': 'https://kubernetes-charts.storage.googleapis.com'
}
test_reckoner_version = "1.0.0"
test_namespace = 'test'
test_release_name = 'spotify-docker-gc-again'
test_chart_name = 'spotify-docker-gc'
test_git_repository_chart = 'centrifugo'
test_git_repository = {
def test_dice_constructor_with_loader():
import ruyaml # NOQA
ruyaml.add_constructor(u'!dice', dice_constructor, Loader=ruyaml.Loader)
data = ruyaml.load('initial hit points: !dice 8d4', Loader=ruyaml.Loader)
assert str(data) == "{'initial hit points': Dice(8,4)}"
def from_yaml_file(f):
"""
Read a yaml file and convert to Python objects (including rpcq messages).
"""
return from_json(to_json(yaml.load(f, Loader=yaml.Loader)))
def canonical_load(stream):
return ruyaml.load(stream, Loader=CanonicalLoader)
