def test_parameter_to_expression(pattern: str, expected: Any) -> None:
"""Test the interpolate convert_to_expression feature."""
expression = expr.interpolate(pattern, {}, convert_to_expression=True)
assert isinstance(expression, str)
assert (expr.interpolate(
expression,
{},
jslib=expr.jshead([], interpolate_input),
fullJS=True,
debug=True,
) == expected)
def test_parameter_to_expression_interpolate_escapebehavior(
pattern: str, expected: str, behavior: int) -> None:
"""Test escaping behavior in an convert_to_expression context."""
expression = expr.interpolate(pattern, {},
escaping_behavior=behavior,
convert_to_expression=True)
assert isinstance(expression, str)
assert (expr.interpolate(
expression,
{},
jslib=expr.jshead([], interpolate_input),
fullJS=True,
debug=True,
) == expected)
def test_expression_interpolate_failures(pattern: str) -> None:
result = None
try:
result = expr.interpolate(pattern, interpolate_input)
except JavascriptException:
return
assert False, 'Should have produced a JavascriptException, got "{}".'.format(result)
def run(environment_path=None):
if expression is None:
raise Exception("Python library cwltool must be available to evaluate expressions.")
if environment_path is None:
environment_path = os.environ.get("GALAXY_EXPRESSION_INPUTS")
with open(environment_path) as f:
raw_inputs = json.load(f)
outputs = raw_inputs["outputs"]
inputs = raw_inputs.copy()
del inputs["outputs"]
result = evaluate(None, inputs)
if '__error_message' in result:
raise Exception(result['__error_message'])
for output in outputs:
path = output["path"]
from_expression = output["from_expression"]
# if it is just a simple value, short-cut all the interpolation
# interpolate seems to fail with None values so this worksaround
# that for now.
if from_expression in result:
output_value = result[from_expression]
else:
from_expression = f"$({from_expression})"
output_value = expression.interpolate(from_expression, result)
with open(path, "w") as f:
json.dump(output_value, f)
def test_expression_interpolate_escapebehavior(
pattern: str, expected: str, behavior: int
) -> None:
"""Test escaping behavior in an interpolation context."""
assert (
expr.interpolate(pattern, interpolate_input, escaping_behavior=behavior)
== expected
)
def run(environment_path=None):
if expression is None:
raise Exception("Python library cwltool must be available to evaluate expressions.")
if environment_path is None:
environment_path = os.environ.get("GALAXY_EXPRESSION_INPUTS")
with open(environment_path, "r") as f:
raw_inputs = json.load(f)
outputs = raw_inputs["outputs"]
inputs = raw_inputs.copy()
del inputs["outputs"]
result = evaluate(None, inputs)
for output in outputs:
path = output["path"]
from_expression = "$(" + output["from_expression"] + ")"
output_value = expression.interpolate(from_expression, result)
with open(path, "w") as f:
json.dump(output_value, f)
def test_expression_interpolate(pattern, expected):
assert expr.interpolate(pattern, interpolate_input) == expected
def test_params(self):
self.assertTrue(expr.param_re.match("(foo)"))
self.assertTrue(expr.param_re.match("(foo.bar)"))
self.assertTrue(expr.param_re.match("(foo['bar'])"))
self.assertTrue(expr.param_re.match("(foo[\"bar\"])"))
self.assertTrue(expr.param_re.match("(foo.bar.baz)"))
self.assertTrue(expr.param_re.match("(foo['bar'].baz)"))
self.assertTrue(expr.param_re.match("(foo['bar']['baz'])"))
self.assertTrue(expr.param_re.match("(foo['b\\'ar']['baz'])"))
self.assertTrue(expr.param_re.match("(foo['b ar']['baz'])"))
self.assertTrue(expr.param_re.match("(foo_bar)"))
self.assertFalse(expr.param_re.match("(foo.[\"bar\"])"))
self.assertFalse(expr.param_re.match("(.foo[\"bar\"])"))
self.assertFalse(expr.param_re.match("(foo [\"bar\"])"))
self.assertFalse(expr.param_re.match("( foo[\"bar\"])"))
self.assertFalse(expr.param_re.match("(foo[bar].baz)"))
self.assertFalse(expr.param_re.match("(foo['bar\"].baz)"))
self.assertFalse(expr.param_re.match("(foo['bar].baz)"))
self.assertFalse(expr.param_re.match("{foo}"))
self.assertFalse(expr.param_re.match("(foo.bar"))
self.assertFalse(expr.param_re.match("foo.bar)"))
self.assertFalse(expr.param_re.match("foo.b ar)"))
self.assertFalse(expr.param_re.match("foo.b\'ar)"))
self.assertFalse(expr.param_re.match("(foo+bar"))
self.assertFalse(expr.param_re.match("(foo bar"))
inputs = {
"foo": {
"bar": {
"baz": "zab1"
},
"b ar": {
"baz": 2
},
"b'ar": {
"baz": True
},
'b"ar': {
"baz": None
}
}
}
self.assertEqual(expr.interpolate("$(foo)", inputs), inputs["foo"])
for pattern in ("$(foo.bar)", "$(foo['bar'])", "$(foo[\"bar\"])"):
self.assertEqual(expr.interpolate(pattern, inputs),
inputs["foo"]["bar"])
for pattern in ("$(foo.bar.baz)", "$(foo['bar'].baz)",
"$(foo['bar'][\"baz\"])", "$(foo.bar['baz'])"):
self.assertEqual(expr.interpolate(pattern, inputs), "zab1")
self.assertEqual(expr.interpolate("$(foo['b ar'].baz)", inputs), 2)
self.assertEqual(expr.interpolate("$(foo['b\\'ar'].baz)", inputs),
True)
self.assertEqual(expr.interpolate("$(foo[\"b'ar\"].baz)", inputs),
True)
self.assertEqual(expr.interpolate("$(foo['b\\\"ar'].baz)", inputs),
None)
for pattern in ("-$(foo.bar)", "-$(foo['bar'])", "-$(foo[\"bar\"])"):
self.assertEqual(expr.interpolate(pattern, inputs),
"""-{"baz": "zab1"}""")
for pattern in ("-$(foo.bar.baz)", "-$(foo['bar'].baz)",
"-$(foo['bar'][\"baz\"])", "-$(foo.bar['baz'])"):
self.assertEqual(expr.interpolate(pattern, inputs), "-zab1")
self.assertEqual(expr.interpolate("-$(foo['b ar'].baz)", inputs), "-2")
self.assertEqual(expr.interpolate("-$(foo['b\\'ar'].baz)", inputs),
"-true")
self.assertEqual(expr.interpolate("-$(foo[\"b\\'ar\"].baz)", inputs),
"-true")
self.assertEqual(expr.interpolate("-$(foo['b\\\"ar'].baz)", inputs),
"-null")
for pattern in ("$(foo.bar) $(foo.bar)", "$(foo['bar']) $(foo['bar'])",
"$(foo[\"bar\"]) $(foo[\"bar\"])"):
self.assertEqual(expr.interpolate(pattern, inputs),
"""{"baz": "zab1"} {"baz": "zab1"}""")
for pattern in ("$(foo.bar.baz) $(foo.bar.baz)",
"$(foo['bar'].baz) $(foo['bar'].baz)",
"$(foo['bar'][\"baz\"]) $(foo['bar'][\"baz\"])",
"$(foo.bar['baz']) $(foo.bar['baz'])"):
self.assertEqual(expr.interpolate(pattern, inputs), "zab1 zab1")
self.assertEqual(
expr.interpolate("$(foo['b ar'].baz) $(foo['b ar'].baz)", inputs),
"2 2")
self.assertEqual(
expr.interpolate("$(foo['b\\'ar'].baz) $(foo['b\\'ar'].baz)",
inputs), "true true")
self.assertEqual(
expr.interpolate("$(foo[\"b\\'ar\"].baz) $(foo[\"b\\'ar\"].baz)",
inputs), "true true")
self.assertEqual(
expr.interpolate("$(foo['b\\\"ar'].baz) $(foo['b\\\"ar'].baz)",
inputs), "null null")
def test_expression_interpolate(pattern: str, expected: Any) -> None:
assert expr.interpolate(pattern, interpolate_input) == expected
def test_params(self):
self.assertTrue(expr.param_re.match("(foo)"))
self.assertTrue(expr.param_re.match("(foo.bar)"))
self.assertTrue(expr.param_re.match("(foo['bar'])"))
self.assertTrue(expr.param_re.match('(foo["bar"])'))
self.assertTrue(expr.param_re.match("(foo.bar.baz)"))
self.assertTrue(expr.param_re.match("(foo['bar'].baz)"))
self.assertTrue(expr.param_re.match("(foo['bar']['baz'])"))
self.assertTrue(expr.param_re.match("(foo['b\\'ar']['baz'])"))
self.assertTrue(expr.param_re.match("(foo['b ar']['baz'])"))
self.assertTrue(expr.param_re.match("(foo_bar)"))
self.assertFalse(expr.param_re.match('(foo.["bar"])'))
self.assertFalse(expr.param_re.match('(.foo["bar"])'))
self.assertFalse(expr.param_re.match('(foo ["bar"])'))
self.assertFalse(expr.param_re.match('( foo["bar"])'))
self.assertFalse(expr.param_re.match("(foo[bar].baz)"))
self.assertFalse(expr.param_re.match("(foo['bar\"].baz)"))
self.assertFalse(expr.param_re.match("(foo['bar].baz)"))
self.assertFalse(expr.param_re.match("{foo}"))
self.assertFalse(expr.param_re.match("(foo.bar"))
self.assertFalse(expr.param_re.match("foo.bar)"))
self.assertFalse(expr.param_re.match("foo.b ar)"))
self.assertFalse(expr.param_re.match("foo.b'ar)"))
self.assertFalse(expr.param_re.match("(foo+bar"))
self.assertFalse(expr.param_re.match("(foo bar"))
inputs = {"foo": {"bar": {"baz": "zab1"}, "b ar": {"baz": 2}, "b'ar": {"baz": True}, 'b"ar': {"baz": None}}}
self.assertEqual(expr.interpolate("$(foo)", inputs), inputs["foo"])
for pattern in ("$(foo.bar)", "$(foo['bar'])", '$(foo["bar"])'):
self.assertEqual(expr.interpolate(pattern, inputs), inputs["foo"]["bar"])
for pattern in ("$(foo.bar.baz)", "$(foo['bar'].baz)", "$(foo['bar'][\"baz\"])", "$(foo.bar['baz'])"):
self.assertEqual(expr.interpolate(pattern, inputs), "zab1")
self.assertEqual(expr.interpolate("$(foo['b ar'].baz)", inputs), 2)
self.assertEqual(expr.interpolate("$(foo['b\\'ar'].baz)", inputs), True)
self.assertEqual(expr.interpolate('$(foo["b\'ar"].baz)', inputs), True)
self.assertEqual(expr.interpolate("$(foo['b\\\"ar'].baz)", inputs), None)
for pattern in ("-$(foo.bar)", "-$(foo['bar'])", '-$(foo["bar"])'):
self.assertEqual(expr.interpolate(pattern, inputs), """-{"baz": "zab1"}""")
for pattern in ("-$(foo.bar.baz)", "-$(foo['bar'].baz)", "-$(foo['bar'][\"baz\"])", "-$(foo.bar['baz'])"):
self.assertEqual(expr.interpolate(pattern, inputs), "-zab1")
self.assertEqual(expr.interpolate("-$(foo['b ar'].baz)", inputs), "-2")
self.assertEqual(expr.interpolate("-$(foo['b\\'ar'].baz)", inputs), "-true")
self.assertEqual(expr.interpolate('-$(foo["b\\\'ar"].baz)', inputs), "-true")
self.assertEqual(expr.interpolate("-$(foo['b\\\"ar'].baz)", inputs), "-null")
for pattern in ("$(foo.bar) $(foo.bar)", "$(foo['bar']) $(foo['bar'])", '$(foo["bar"]) $(foo["bar"])'):
self.assertEqual(expr.interpolate(pattern, inputs), """{"baz": "zab1"} {"baz": "zab1"}""")
for pattern in (
"$(foo.bar.baz) $(foo.bar.baz)",
"$(foo['bar'].baz) $(foo['bar'].baz)",
"$(foo['bar'][\"baz\"]) $(foo['bar'][\"baz\"])",
"$(foo.bar['baz']) $(foo.bar['baz'])",
):
self.assertEqual(expr.interpolate(pattern, inputs), "zab1 zab1")
self.assertEqual(expr.interpolate("$(foo['b ar'].baz) $(foo['b ar'].baz)", inputs), "2 2")
self.assertEqual(expr.interpolate("$(foo['b\\'ar'].baz) $(foo['b\\'ar'].baz)", inputs), "true true")
self.assertEqual(expr.interpolate('$(foo["b\\\'ar"].baz) $(foo["b\\\'ar"].baz)', inputs), "true true")
self.assertEqual(expr.interpolate("$(foo['b\\\"ar'].baz) $(foo['b\\\"ar'].baz)", inputs), "null null")
def test_expression_interpolate(pattern, expected):
assert expr.interpolate(pattern, interpolate_input) == expected
def test_expression_interpolate_failures(pattern: str) -> None:
result = None
with pytest.raises(JavascriptException):
result = expr.interpolate(pattern, interpolate_input)
