def test_evaluate_normal(self):
# NOTE: the actual expr.resource_name is irrelevant for this test
expr = ResourceExpression("obj.a == 2")
self.assertTrue(expr.evaluate([Resource({'a': 1}),
Resource({'a': 2})]))
self.assertTrue(expr.evaluate([Resource({'a': 2}),
Resource({'a': 1})]))
self.assertFalse(
expr.evaluate([Resource({'a': 1}),
Resource({'a': 3})]))
def test_compound_expression_or_passing(self):
resource_map = {
'a': [Resource({'foo': 1})],
'b': [Resource({'bar': 3})]
}
expr = ResourceExpression("a.foo == 1 or b.bar == 2")
self.assertTrue(
expr.evaluate(resource_map['a'],
resource_map['b'],
resource_map=resource_map))
def test_compound_expression_or_failing(self):
resource_map = {
'a': [Resource({'foo': 2})],
'b': [Resource({'bar': 3})]
}
expr = ResourceExpression("a.foo == 1 and b.bar == 2")
self.assertFalse(
expr.evaluate(resource_map['a'],
resource_map['b'],
resource_map=resource_map))
def test_evaluate_normal(self):
# NOTE: the actual expr.resource_name is irrelevant for this test
expr = ResourceExpression("obj.a == 2")
self.assertTrue(
expr.evaluate([
Resource({'a': 1}), Resource({'a': 2})]))
self.assertTrue(
expr.evaluate([
Resource({'a': 2}), Resource({'a': 1})]))
self.assertFalse(
expr.evaluate([
Resource({'a': 1}), Resource({'a': 3})]))
def test_compound_many_subexpressions_failing(self):
resource_map = {
'a': [Resource({'foo': 1}),
Resource({'foo': 2})],
'b': [Resource({'bar': 3}),
Resource({'bar': 4})]
}
expr = ResourceExpression(
"a.foo == 3 or b.bar == 3 and a.foo == 2 and b.bar == 1")
self.assertFalse(
expr.evaluate(resource_map['a'],
resource_map['b'],
resource_map=resource_map))
def test_namespace_support(self):
text = "package.name == 'fwts'"
expr = ResourceExpression(text, "2014.com.canonical")
self.assertEqual(expr.text, text)
self.assertEqual(expr.resource_id_list,
["2014.com.canonical::package"])
self.assertEqual(expr.implicit_namespace, "2014.com.canonical")
def test_imports_support(self):
text = "package.name == 'fwts'"
expr1 = ResourceExpression(text, "com.example")
self.assertEqual(expr1.text, text)
self.assertEqual(expr1.resource_id_list, ["com.example::package"])
self.assertEqual(expr1.implicit_namespace, "com.example")
expr2 = ResourceExpression(text, "com.example", imports=())
self.assertEqual(expr2.text, text)
self.assertEqual(expr2.resource_id_list, ["com.example::package"])
self.assertEqual(expr2.implicit_namespace, "com.example")
expr3 = ResourceExpression(text,
"com.example",
imports=[('com.canonical::package',
'package')])
self.assertEqual(expr3.text, text)
self.assertEqual(expr3.resource_id_list, ["com.canonical::package"])
self.assertEqual(expr3.implicit_namespace, "com.example")
def test_get_filter_program__bare(self):
# Programs are properly represented
prog = TemplateUnit({
'template-filter': 'resource.attr == "value"'
}).get_filter_program()
# The program wraps the right expressions
self.assertEqual(prog.expression_list,
[ResourceExpression('resource.attr == "value"')])
# The program references the right resources
self.assertEqual(prog.required_resources, set(['resource']))
def test_smoke(self):
expression = ResourceExpression('resource.attr == "value"')
exc = ExpressionFailedError(expression)
self.assertIs(exc.expression, expression)
self.assertEqual(
str(exc),
("expression 'resource.attr == \"value\"' evaluated to a non-true"
" result"))
self.assertEqual(
repr(exc), ("<ExpressionFailedError expression:<ResourceExpression"
" text:'resource.attr == \"value\"'>>"))
def test_smoke(self):
expression = ResourceExpression('resource.attr == "value"')
exc = ExpressionCannotEvaluateError(expression)
self.assertIs(exc.expression, expression)
self.assertEqual(
str(exc),
("expression 'resource.attr == \"value\"' needs unavailable"
" resource 'resource'"))
self.assertEqual(
repr(exc),
("<ExpressionCannotEvaluateError expression:<ResourceExpression"
" text:'resource.attr == \"value\"'>>"))
def test_get_inhibitor_list_PENDING_RESOURCE(self):
# verify that jobs that require a resource that hasn't been
# invoked yet produce the PENDING_RESOURCE inhibitor
j1 = JobDefinition({'id': 'j1', 'requires': 'j2.attr == "ok"'})
j2 = JobDefinition({'id': 'j2'})
session_state = mock.MagicMock(spec=SessionState)
session_state.job_state_map['j2'].job = j2
session_state.resource_map = {}
self.assertEqual(self.ctrl.get_inhibitor_list(session_state, j1), [
JobReadinessInhibitor(JobReadinessInhibitor.PENDING_RESOURCE, j2,
ResourceExpression('j2.attr == "ok"'))
])
def test_get_inhibitor_list_FAILED_RESOURCE(self):
# verify that jobs that require a resource that has been
# invoked and produced resources but the expression dones't
# evaluate to True produce the FAILED_RESOURCE inhibitor
j1 = JobDefinition({'id': 'j1', 'requires': 'j2.attr == "ok"'})
j2 = JobDefinition({'id': 'j2'})
session_state = mock.MagicMock(spec=SessionState)
session_state.job_state_map['j2'].job = j2
session_state.resource_map = {'j2': [Resource({'attr': 'not-ok'})]}
self.assertEqual(self.ctrl.get_inhibitor_list(session_state, j1), [
JobReadinessInhibitor(JobReadinessInhibitor.FAILED_RESOURCE, j2,
ResourceExpression('j2.attr == "ok"'))
])
def test_get_filter_program__inherited(self):
provider = mock.Mock(spec=IProvider1)
provider.namespace = 'inherited'
# Programs are properly represented
prog = TemplateUnit({
'template-resource': 'resource',
'template-filter': 'resource.attr == "value"'
}, provider=provider).get_filter_program()
# The program wraps the right expressions
self.assertEqual(
prog.expression_list,
[ResourceExpression('resource.attr == "value"')])
# The program references the right resources
self.assertEqual(prog.required_resources, set(['inherited::resource']))
def test_evaluate_checks_resource_type(self):
expr = ResourceExpression("obj.a == 2")
self.assertRaises(TypeError, expr.evaluate, [{'a': 2}])
def test_evaluate_exception(self):
# NOTE: the actual expr.resource_name is irrelevant for this test
expr = ResourceExpression("obj.a == 2")
self.assertFalse(expr.evaluate([Resource()]))
def test_evaluate_exception(self):
# NOTE: the actual expr.resource_name is irrelevant for this test
expr = ResourceExpression("obj.a == 2")
self.assertFalse(expr.evaluate([Resource()]))
def test_evaluate_no_namespaces(self):
self.assertFalse(ResourceExpression("whatever").evaluate([]))
def test_smoke_good(self):
text = "package.name == 'fwts'"
expr = ResourceExpression(text)
self.assertEqual(expr.text, text)
self.assertEqual(expr.resource_name, "package")
def test_smoke_good(self):
text = "package.name == 'fwts'"
expr = ResourceExpression(text)
self.assertEqual(expr.text, text)
self.assertEqual(expr.resource_id_list, ["package"])
self.assertEqual(expr.implicit_namespace, None)
def test_multiple_resources(self):
expr = ResourceExpression("a.foo == 1 and b.bar == 2")
self.assertEqual(expr.resource_id_list, ["a", "b"])
