def test_conflict_error():
class FooDirective(Action):
def __init__(self, name):
self.name = name
def identifier(self):
return self.name
def perform(self, obj):
raise DirectiveError("A real problem")
class MyApp(App):
foo = directive(FooDirective)
@MyApp.foo('hello')
def f():
pass
@MyApp.foo('hello')
def g():
pass
with pytest.raises(ConflictError) as e:
commit(MyApp)
value = text_type(e.value)
assert value.startswith("Conflict between:")
assert ', line ' in value
assert "@MyApp.foo('hello')" in value
assert '/test_error.py' in value
def test_type_error_too_many_arguments():
class MyDirective(Action):
config = {'my': list}
def __init__(self, message):
self.message = message
def identifier(self, my):
return self.message
def perform(self, obj, my):
my.append((self.message, obj))
class MyApp(App):
foo = directive(MyDirective)
# too many arguments
@MyApp.foo('a', 'b')
def f():
pass
with pytest.raises(DirectiveReportError) as e:
commit(MyApp)
value = text_type(e.value)
assert "@MyApp.foo('a', 'b')" in value
def test_directive_error_in_action():
class FooDirective(Action):
def __init__(self, name):
self.name = name
def identifier(self):
return self.name
def perform(self, obj):
raise DirectiveError("A real problem")
class MyApp(App):
foo = directive(FooDirective)
@MyApp.foo('hello')
def f():
pass
with pytest.raises(DirectiveReportError) as e:
commit(MyApp)
value = text_type(e.value)
assert value.startswith("A real problem")
assert value.endswith(" @MyApp.foo('hello')")
assert '/test_error.py' in value
def test_conflict_error():
class FooDirective(Action):
def __init__(self, name):
self.name = name
def identifier(self):
return self.name
def perform(self, obj):
raise DirectiveError("A real problem")
class MyApp(App):
foo = directive(FooDirective)
@MyApp.foo('hello')
def f():
pass
@MyApp.foo('hello')
def g():
pass
with pytest.raises(ConflictError) as e:
commit(MyApp)
value = text_type(e.value)
assert value.startswith("Conflict between:")
assert ', line ' in value
assert "@MyApp.foo('hello')" in value
assert '/test_error.py' in value
def test_with_statement_error():
class FooDirective(Action):
def __init__(self, model, name):
self.model = model
self.name = name
def identifier(self):
return (self.model, self.name)
def perform(self, obj):
raise DirectiveError("A real problem")
class MyApp(App):
foo = directive(FooDirective)
class Dummy(object):
pass
with MyApp.foo(model=Dummy) as foo:
@foo(name='a')
def f():
pass
@foo(name='b')
def g():
pass
with pytest.raises(DirectiveReportError) as e:
commit(MyApp)
value = text_type(e.value)
assert value.startswith("A real problem")
assert value.endswith(" @foo(name='a')")
assert '/test_error.py' in value
def test_type_error_too_many_arguments():
class MyDirective(Action):
config = {
'my': list
}
def __init__(self, message):
self.message = message
def identifier(self, my):
return self.message
def perform(self, obj, my):
my.append((self.message, obj))
class MyApp(App):
foo = directive(MyDirective)
# too many arguments
@MyApp.foo('a', 'b')
def f():
pass
with pytest.raises(DirectiveReportError) as e:
commit(MyApp)
value = text_type(e.value)
assert "@MyApp.foo('a', 'b')" in value
def test_directive_error_in_action():
class FooDirective(Action):
def __init__(self, name):
self.name = name
def identifier(self):
return self.name
def perform(self, obj):
raise DirectiveError("A real problem")
class MyApp(App):
foo = directive(FooDirective)
@MyApp.foo('hello')
def f():
pass
with pytest.raises(DirectiveReportError) as e:
commit(MyApp)
value = text_type(e.value)
assert value.startswith("A real problem")
assert value.endswith(" @MyApp.foo('hello')")
assert '/test_error.py' in value
def test_type_error_not_enough_arguments():
class MyApp(App):
pass
@MyApp.directive('foo')
class MyDirective(Action):
config = {
'my': list
}
def __init__(self, message):
self.message = message
def identifier(self, my):
return self.message
def perform(self, obj, my):
my.append((self.message, obj))
# not enough arguments
@MyApp.foo()
def f():
pass
with pytest.raises(DirectiveReportError) as e:
commit(MyApp)
value = text_type(e.value)
assert "@MyApp.foo()" in value
def test_composite_codeinfo_propagation():
class MyApp(App):
pass
@MyApp.directive('sub')
class SubDirective(Action):
config = {
'my': list
}
def __init__(self, message):
self.message = message
def identifier(self, my):
return self.message
def perform(self, obj, my):
my.append((self.message, obj))
@MyApp.directive('composite')
class CompositeDirective(Composite):
def __init__(self, messages):
self.messages = messages
def actions(self, obj):
return [(SubDirective(message), obj) for message in self.messages]
@MyApp.composite(['a'])
def f():
pass
@MyApp.composite(['a'])
def g():
pass
with pytest.raises(ConflictError) as e:
commit(MyApp)
value = text_type(e.value)
assert "@MyApp.composite(['a'])" in value
assert '/test_error.py' in value
def test_directive_error_in_composite():
class FooDirective(Composite):
def __init__(self, name):
self.name = name
def actions(self, obj):
raise DirectiveError("Something went wrong")
class MyApp(App):
foo = directive(FooDirective)
@MyApp.foo('hello')
def f():
pass
with pytest.raises(DirectiveReportError) as e:
commit(MyApp)
value = text_type(e.value)
assert value.startswith("Something went wrong")
assert value.endswith(" @MyApp.foo('hello')")
assert '/test_error.py' in value
def test_composite_codeinfo_propagation():
class SubDirective(Action):
config = {'my': list}
def __init__(self, message):
self.message = message
def identifier(self, my):
return self.message
def perform(self, obj, my):
my.append((self.message, obj))
class CompositeDirective(Composite):
def __init__(self, messages):
self.messages = messages
def actions(self, obj):
return [(SubDirective(message), obj) for message in self.messages]
class MyApp(App):
_sub = directive(SubDirective)
composite = directive(CompositeDirective)
@MyApp.composite(['a'])
def f():
pass
@MyApp.composite(['a'])
def g():
pass
with pytest.raises(ConflictError) as e:
commit(MyApp)
value = text_type(e.value)
assert "@MyApp.composite(['a'])" in value
assert '/test_error.py' in value
def test_directive_error_in_composite():
class FooDirective(Composite):
def __init__(self, name):
self.name = name
def actions(self, obj):
raise DirectiveError("Something went wrong")
class MyApp(App):
foo = directive(FooDirective)
@MyApp.foo('hello')
def f():
pass
with pytest.raises(DirectiveReportError) as e:
commit(MyApp)
value = text_type(e.value)
assert value.startswith("Something went wrong")
assert value.endswith(" @MyApp.foo('hello')")
assert '/test_error.py' in value
def test_with_statement_error():
class FooDirective(Action):
def __init__(self, model, name):
self.model = model
self.name = name
def identifier(self):
return (self.model, self.name)
def perform(self, obj):
raise DirectiveError("A real problem")
class MyApp(App):
foo = directive(FooDirective)
class Dummy(object):
pass
with MyApp.foo(model=Dummy) as foo:
@foo(name='a')
def f():
pass
@foo(name='b')
def g():
pass
with pytest.raises(DirectiveReportError) as e:
commit(MyApp)
value = text_type(e.value)
assert value.startswith("A real problem")
assert value.endswith(" @foo(name='a')")
assert '/test_error.py' in value