def test_copy(self):
# copy support is disabled by default in _sre.c
import re
p = re.compile("b")
raises(TypeError, p.__copy__) # p.__copy__() should raise
raises(TypeError, p.__deepcopy__) # p.__deepcopy__() should raise
def test_surface():
# TypeError: The Surface type cannot be instantiated
test.raises(TypeError, "s = cairo.Surface()")
if cairo.HAS_IMAGE_SURFACE:
f, w, h = cairo.FORMAT_ARGB32, 100, 100
s = cairo.ImageSurface(f, w, h)
assert s.get_format() == f
assert s.get_width() == w
assert s.get_height() == h
if cairo.HAS_PDF_SURFACE:
f, w, h = tfi.TemporaryFile(mode="w+b"), 100, 100
s = cairo.PDFSurface(f, w, h)
if cairo.HAS_PS_SURFACE:
f, w, h = tfi.TemporaryFile(mode="w+b"), 100, 100
s = cairo.PSSurface(f, w, h)
if cairo.HAS_RECORDING_SURFACE:
s = cairo.RecordingSurface(cairo.CONTENT_COLOR, None)
s = cairo.RecordingSurface(cairo.CONTENT_COLOR, (1, 1, 10, 10))
if cairo.HAS_SVG_SURFACE:
f, w, h = tfi.TemporaryFile(mode="w+b"), 100, 100
s = cairo.SVGSurface(f, w, h)
def test_combo(self):
x_obj = qterm.Variable('x', pq('obj'))
x_var = qterm.Variable('x', pq('?a'))
phi_var = qterm.Constant('phi', pq('?b->bool'))
phi_obj = qterm.Constant('phi', pq('obj->bool'))
combo_var = term_builder.build_combination(phi_var, x_var)
combo_obj = term_builder.build_combination(phi_obj, x_obj)
combo_var2 = term_builder.build_combination(phi_var, x_obj)
x, combo = unify_types([x_obj, combo_var])
assert x == x_obj
assert combo == combo_obj
phi_a, phi_b = unify_types([phi_var, phi_obj])
assert phi_a == phi_var
assert phi_b == phi_obj
combo_a, combo_b = unify_types([combo_var, combo_obj])
assert combo_a == combo_obj
assert combo_b == combo_obj
combo_a, combo_b = unify_types([combo_var2, combo_obj])
assert combo_a == combo_obj
assert combo_b == combo_obj
f = qterm.Variable('f', pq('?x->?y'))
raises(UnificationError, term_builder.build_combination, f, f)
raises(UnificationError, term_builder.build_combination, x_var, x_var)
def test_group(self):
import re
m = re.search("a((?P<first>\d)|(?P<second>\s))", "aa1b")
assert "a1" == m.group()
assert ("1", "1", None) == m.group(1, 2, 3)
assert ("1", None) == m.group("first", "second")
raises(IndexError, m.group, 1, 4)
def test_choice_loader():
env = Environment(loader=choice_loader)
tmpl = env.get_template('justdict.html')
assert tmpl.render().strip() == 'FOO'
tmpl = env.get_template('test.html')
assert tmpl.render().strip() == 'BAR'
raises(TemplateNotFound, env.get_template, 'missing.html')
def test_help(self):
"""tests getting help (returning the help_string so further tests can be done)"""
stdout = sys.stdout
helpfile = self.open_testfile("help.txt", "w")
sys.stdout = helpfile
try:
test.raises(SystemExit, self.run_command, help=True)
finally:
sys.stdout = stdout
helpfile.close()
help_string = self.read_testfile("help.txt")
print help_string
convertsummary = self.convertmodule.__doc__.split("\n")[0]
# the convertsummary might be wrapped. this will probably unwrap it
assert convertsummary in help_string.replace("\n", " ")
usageline = help_string[:help_string.find("\n")]
# Different versions of optparse might contain either upper or
# lowercase versions of 'Usage:' and 'Options:', so we need to take
# that into account
assert (usageline.startswith("Usage: ") or usageline.startswith("usage: ")) \
and "[--version] [-h|--help]" in usageline
options = help_string[help_string.find("ptions:\n"):]
options = options[options.find("\n")+1:]
options = self.help_check(options, "--progress=PROGRESS")
options = self.help_check(options, "--version")
options = self.help_check(options, "-h, --help")
options = self.help_check(options, "--manpage")
options = self.help_check(options, "--errorlevel=ERRORLEVEL")
if psyco:
options = self.help_check(options, "--psyco=MODE")
options = self.help_check(options, "-i INPUT, --input=INPUT")
options = self.help_check(options, "-x EXCLUDE, --exclude=EXCLUDE")
options = self.help_check(options, "-o OUTPUT, --output=OUTPUT")
return options
def test_lost_displayhook(self):
import sys
olddisplayhook = sys.displayhook
del sys.displayhook
code = compile("42", "<string>", "single")
raises(RuntimeError, eval, code)
sys.displayhook = olddisplayhook
def test_ava_filter_2():
conf = {
"default": {
"lifetime": {"minutes":15},
"attribute_restrictions": None # means all I have
},
"urn:mace:umu.se:saml:roland:sp": {
"lifetime": {"minutes": 5},
"attribute_restrictions":{
"givenName": None,
"surName": None,
"mail": [".*@.*\.umu\.se"],
}
}}
policy = Policy(conf)
ava = {"givenName":"Derek",
"surName": "Jeter",
"mail":"*****@*****.**"}
# I'm filtering away something the SP deems necessary
#policy.filter(ava, 'urn:mace:umu.se:saml:roland:sp', [mail], [gn, sn])
raises(MissingValue, policy.filter, ava, 'urn:mace:umu.se:saml:roland:sp',
[mail], [gn, sn])
ava = {"givenName":"Derek",
"surName": "Jeter"}
# it wasn't there to begin with
raises(MissingValue, policy.filter, ava, 'urn:mace:umu.se:saml:roland:sp',
[gn,sn,mail])
def test_filter_values_req_opt_2():
r = [
to_dict(
Attribute(
friendly_name="surName",
name="urn:oid:2.5.4.4",
name_format="urn:oasis:names:tc:SAML:2.0:attrname-format:uri"),
ONTS),
to_dict(
Attribute(
friendly_name="givenName",
name="urn:oid:2.5.4.42",
name_format="urn:oasis:names:tc:SAML:2.0:attrname-format:uri"),
ONTS),
to_dict(
Attribute(
friendly_name="mail",
name="urn:oid:0.9.2342.19200300.100.1.3",
name_format="urn:oasis:names:tc:SAML:2.0:attrname-format:uri"),
ONTS)]
o = [
to_dict(
Attribute(
friendly_name="title",
name="urn:oid:2.5.4.12",
name_format="urn:oasis:names:tc:SAML:2.0:attrname-format:uri"),
ONTS)]
ava = {"surname": ["Hedberg"], "givenName": ["Roland"],
"eduPersonAffiliation": ["staff"], "uid": ["rohe0002"]}
raises(MissingValue, "filter_on_attributes(ava, r, o)")
def test_exception_sign_verify_with_cert_from_instance(self):
assertion = factory(saml.Assertion,
version="2.0",
id="11100",
issue_instant="2009-10-30T13:20:28Z",
#signature= sigver.pre_signature_part("11100",
# self.sec.my_cert),
attribute_statement=do_attribute_statement({
("", "", "surName"): ("Foo", ""),
("", "", "givenName"): ("Bar", ""),
})
)
response = factory(samlp.Response,
assertion=assertion,
id="22222",
signature=sigver.pre_signature_part("22222",
self.sec
.my_cert))
to_sign = [(class_name(response), response.id)]
s_response = sigver.signed_instance_factory(response, self.sec, to_sign)
response2 = response_from_string(s_response)
# Change something that should make everything fail
response2.id = "23456"
raises(sigver.SignatureError, self.sec._check_signature,
s_response, response2, class_name(response2))
def test_unpackiterable(self):
space = self.space
w = space.wrap
l = [space.newlist([]) for l in range(4)]
w_l = space.newlist(l)
l1 = space.unpackiterable(w_l)
l2 = space.unpackiterable(w_l, 4)
for i in range(4):
assert space.is_w(l1[i], l[i])
assert space.is_w(l2[i], l[i])
err = raises(OperationError, space.unpackiterable, w_l, 3)
assert err.value.match(space, space.w_ValueError)
err = raises(OperationError, space.unpackiterable, w_l, 5)
assert err.value.match(space, space.w_ValueError)
w_a = space.appexec((), """():
class A(object):
def __iter__(self):
return self
def next(self):
raise StopIteration
def __len__(self):
1/0
return A()
""")
try:
space.unpackiterable(w_a)
except OperationError, o:
if not o.match(space, space.w_ZeroDivisionError):
raise Exception("DID NOT RAISE")
def test_ueimporterror():
ue = uecommunication()
raises(UeImportError, ue.valid_response, "<Response><Import>Import not ok</Import></Response>")
assert (
ue.valid_response("<Response><Import>Import ok</Import></Response>")
== "<Response><Import>Import ok</Import></Response>"
)
def test_creation_fail2():
"""
Try to create two Managers with the same position.
This should fail without leaving any partial records in
the database.
"""
setupClass([DIManager, DIEmployee, DIPerson])
kwargs = {'firstName': 'John', 'lastName': 'Doe',
'position': 'Project Manager'}
DIManager(**kwargs)
persons = DIEmployee.select(DIPerson.q.firstName == 'John')
assert persons.count() == 1
kwargs = {'firstName': 'John', 'lastName': 'Doe II',
'position': 'Project Manager'}
raises(Exception, DIManager, **kwargs)
persons = DIPerson.select(DIPerson.q.firstName == 'John')
assert persons.count() == 1
if not supports('transactions'):
skip("Transactions aren't supported")
transaction = DIPerson._connection.transaction()
kwargs = {'firstName': 'John', 'lastName': 'Doe III',
'position': 'Project Manager'}
raises(Exception, DIManager, connection=transaction, **kwargs)
transaction.rollback()
transaction.begin()
persons = DIPerson.select(DIPerson.q.firstName == 'John',
connection=transaction)
assert persons.count() == 1
def test_cjk(self):
import sys
import unicodedata
cases = ((0x3400, 0x4DB5),
(0x4E00, 0x9FA5))
if unicodedata.unidata_version >= "4.1":
cases = ((0x3400, 0x4DB5),
(0x4E00, 0x9FBB),
(0x20000, 0x2A6D6))
for first, last in cases:
# Test at and inside the boundary
for i in (first, first + 1, last - 1, last):
charname = 'CJK UNIFIED IDEOGRAPH-%X'%i
char = ('\\U%08X' % i).decode('unicode-escape')
assert unicodedata.name(char) == charname
assert unicodedata.lookup(charname) == char
# Test outside the boundary
for i in first - 1, last + 1:
charname = 'CJK UNIFIED IDEOGRAPH-%X'%i
char = ('\\U%08X' % i).decode('unicode-escape')
try:
unicodedata.name(char)
except ValueError, e:
assert e.message == 'no such name'
raises(KeyError, unicodedata.lookup, charname)
def test_copy(self):
import re
# copy support is disabled by default in _sre.c
m = re.match("bla", "bla")
raises(TypeError, m.__copy__)
raises(TypeError, m.__deepcopy__)
def test_no_2nd_arg_and_1st_isnt_enough_for_mkv(self, p):
s = """
name = s
key_format = 16s
type = HashIndex
hash_lim = 1
make_key_value:
0
"""
with raises(IndexCreatorValueException):
p.parse(s, 'TestIndex')
s2 = """
name = s
key_format = 16s
type = HashIndex
hash_lim = 1
make_key_value:
"aaa"
"""
with raises(IndexCreatorValueException):
p.parse(s2, 'TestIndex')
s3 = """
name = s
key_format = 16s
type = HashIndex
hash_lim = 1
make_key_value:
md5(a)
"""
with raises(IndexCreatorValueException):
p.parse(s3, 'TestIndex')
def test_ava_filter_2():
conf = {
"default": {
"lifetime": {"minutes": 15},
"attribute_restrictions": None # means all I have
},
"urn:mace:umu.se:saml:roland:sp": {
"lifetime": {"minutes": 5},
"attribute_restrictions": {
"givenName": None,
"surName": None,
"mail": [".*@.*\.umu\.se"],
}
}}
policy = Policy(conf)
ava = {"givenName": "Derek",
"surName": "Jeter",
"mail": "*****@*****.**"}
# mail removed because it doesn't match the regular expression
# So this should fail.
raises(MissingValue, policy.filter, ava, 'urn:mace:umu.se:saml:roland:sp',
None, [mail], [gn, sn])
ava = {"givenName": "Derek",
"surName": "Jeter"}
# it wasn't there to begin with
raises(Exception, policy.filter, ava, 'urn:mace:umu.se:saml:roland:sp',
None, [gn, sn, mail])
def test_too_much_colons(self, p):
s = """
name = s
key_format = 32s
type = HashIndex
hash_lim = 1
make_key_value:
1<=2:1:1,None
make_key:
1"""
with raises(IndexCreatorFunctionException):
p.parse(s, 'TestIndex')
s2 = """
name = s
key_format = 32s
type = HashIndex
hash_lim = 1
make_key_value:
1<=2:1,None
make_key:
a>1::"""
with raises(IndexCreatorFunctionException):
p.parse(s2, 'TestIndex')
s3 = """
name = s
key_format = : 32s
type = HashIndex
hash_lim = 1
make_key_value:
1<=2:1,None
make_key:
a>1:1"""
with raises(IndexCreatorValueException):
p.parse(s3, 'TestIndex')
def test_setcheckinterval(self):
import sys
raises(TypeError, sys.setcheckinterval)
orig = sys.getcheckinterval()
for n in 0, 100, 120, orig: # orig last to restore starting state
sys.setcheckinterval(n)
assert sys.getcheckinterval() == n
def test_logout_2(self):
""" one IdP/AA with BINDING_SOAP, can't actually send something"""
conf = config.SPConfig()
conf.load_file("server2_conf")
client = Saml2Client(conf)
# information about the user from an IdP
session_info = {
"name_id": "123456",
"issuer": "urn:mace:example.com:saml:roland:idp",
"not_on_or_after": in_a_while(minutes=15),
"ava": {
"givenName": "Anders",
"surName": "Andersson",
"mail": "*****@*****.**"
}
}
client.users.add_information_about_person(session_info)
entity_ids = self.client.users.issuers_of_info("123456")
assert entity_ids == ["urn:mace:example.com:saml:roland:idp"]
destinations = client.config.single_logout_services(entity_ids[0],
BINDING_SOAP)
print destinations
assert destinations == ['http://localhost:8088/slo']
# Will raise an error since there is noone at the other end.
raises(LogoutError, 'client.global_logout("123456", "Tired", in_a_while(minutes=5))')
def test_fill_in_start_end(self):
# case where neither start nor end is defined; they are returned
# as is (as None values)
s = e = None
assert (None, None) == self.arl_indexer._fill_in_start_end(s, e)
# case where end is defined but start isn't (invalid); exception raised
e = datetime.datetime.utcnow()
with raises(ValueError) as e_info:
self.arl_indexer._fill_in_start_end(s, e)
assert arlindexer.ArlIndexer.END_WITHOUT_START_ERR_MSG == e_info.value.args[0]
# case where start is after end (invalid); exception raised
s = e + datetime.timedelta(1)
with raises(ValueError) as e_info:
self.arl_indexer._fill_in_start_end(s, e)
assert arlindexer.ArlIndexer.START_AFTER_END_ERR_MSG == e_info.value.args[0]
# case where start is before end (valid); they are returned as is
s = e - datetime.timedelta(1)
assert s, e == self.arl_indexer._fill_in_start_end(s, e)
# case where start is defined but not end; end gets set to now
with timecop.freeze(time.mktime(e.timetuple())):
assert s, e == self.arl_indexer._fill_in_start_end(s, None)
def test():
for puzzle in puzzles.itervalues():
puzzle = load(puzzle)
puzzle.solve()
assert puzzle.is_solved()
for puzzle in bad_puzzles.itervalues():
raises(InconsistentPuzzleError, load(puzzle).solve)
def test_prefix_loader():
env = Environment(loader=prefix_loader)
tmpl = env.get_template('a/test.html')
assert tmpl.render().strip() == 'BAR'
tmpl = env.get_template('b/justdict.html')
assert tmpl.render().strip() == 'FOO'
raises(TemplateNotFound, env.get_template, 'missing')
def test_cjk(self):
import sys
if sys.maxunicode < 0x10ffff:
skip("requires a 'wide' python build.")
import unicodedata
cases = ((0x3400, 0x4DB5),
(0x4E00, 0x9FA5))
if unicodedata.unidata_version >= "4.1":
cases = ((0x3400, 0x4DB5),
(0x4E00, 0x9FBB),
(0x20000, 0x2A6D6))
for first, last in cases:
# Test at and inside the boundary
for i in (first, first + 1, last - 1, last):
charname = 'CJK UNIFIED IDEOGRAPH-%X'%i
assert unicodedata.name(unichr(i)) == charname
assert unicodedata.lookup(charname) == unichr(i)
# Test outside the boundary
for i in first - 1, last + 1:
charname = 'CJK UNIFIED IDEOGRAPH-%X'%i
try:
unicodedata.name(unichr(i))
except ValueError:
pass
raises(KeyError, unicodedata.lookup, charname)
def test_filesystem_loader():
env = Environment(loader=filesystem_loader)
tmpl = env.get_template('test.html')
assert tmpl.render().strip() == 'BAR'
tmpl = env.get_template('foo/test.html')
assert tmpl.render().strip() == 'FOO'
raises(TemplateNotFound, env.get_template, 'missing.html')
def test_finditer(self):
import re
it = re.finditer("b(.)", "brabbel")
assert "br" == it.next().group(0)
assert "bb" == it.next().group(0)
raises(StopIteration, it.next)
def test_coordinate_attribute_assignment_01( ):
'''Coordinates are immutable.
Attributes cannot be set (rebound).'''
t = Coordinate(1, 2)
assert raises(AttributeError, 't.xy = 2')
assert raises(AttributeError, 't.foo = 3')
assert raises(TypeError, 't[0] = 2')
def test_unpackiterable(self):
space = self.space
w = space.wrap
l = [w(1), w(2), w(3), w(4)]
w_l = space.newlist(l)
assert space.unpackiterable(w_l) == l
assert space.unpackiterable(w_l, 4) == l
err = raises(OperationError, space.unpackiterable, w_l, 3)
assert err.value.match(space, space.w_ValueError)
err = raises(OperationError, space.unpackiterable, w_l, 5)
assert err.value.match(space, space.w_ValueError)
w_a = space.appexec((), """():
class A(object):
def __iter__(self):
return self
def next(self):
raise StopIteration
def __len__(self):
1/0
return A()
""")
try:
space.unpackiterable(w_a)
except OperationError, o:
if not o.match(space, space.w_ZeroDivisionError):
raise Exception("DID NOT RAISE")
def test_begin_twice():
transaction = Transaction(Collection([]))
transaction.begin()
raises(TransactionAlreadyActiveError, transaction.begin)
# no exception raised if transaction is already finished
transaction.rollback()
transaction.begin()
def test_basic(self):
self.o.ind = -2
self.n.ind = 2
import operator
assert operator.index(self.o) == -2
assert operator.index(self.n) == 2
raises(TypeError, operator.index, self.o_no_index)
raises(TypeError, operator.index, self.n_no_index)
def test_parse_problem_name_fail():
test = ['(domain test)']
iter = parse_lisp_iterator(test)
with raises(ValueError):
parse_problem_name(iter)
def test_parseRequirements2():
test = ['(:predicates :name :parameters :foo )']
iter = parse_lisp_iterator(test)
with raises(ValueError):
parse_requirements_stmt(iter)
def test_parseParameters2():
test = ['(:predicates ( ?x - block ?y - foo ?z - block ))']
iter = parse_lisp_iterator(test)
with raises(ValueError):
parse_parameters(iter)
def test_no_location(self):
with raises(ValueError) as e:
self.estimator.estimate({'activity':[{}]})
def test_empty_lookup_info(self):
self.estimator.lookup.look_up = lambda p: {}
with raises(RuntimeError) as e:
self.estimator.estimate(self.active_area_location)
def test_global_id_invalid():
field = GlobalIDFormField()
with raises(ValidationError):
field.clean('badvalue')
def test_global_id_bad_int():
field = GlobalIDFormField()
with raises(ValidationError):
field.clean('TXlUeXBlOmFiYw==')
def test_coordinate__init__06():
'''Coordinate cannot be initialized with a triple.'''
assert raises(TypeError, 't = Coordinate((1, 2, 3))')
def test_coordinate__init__07():
'''Coordinate cannot be initialized with a Path.'''
assert raises(TypeError, 't = Coordinate(Path([1,2]))')
def test_should_unknown_django_field_raise_exception():
with raises(Exception) as excinfo:
convert_django_field(None)
assert "Don't know how to convert the Django field" in str(excinfo.value)
def test_dependency():
dep = Dependency('test_module')
with raises(ImportError):
dep.method_call
def test_field_no_contributed_raises_error():
f = Field(GraphQLString)
with raises(Exception):
schema.T(f)
def test_should_unknown_sqlalchemy_field_raise_exception():
with raises(Exception) as excinfo:
convert_sqlalchemy_column(None)
assert "Don't know how to convert the SQLAlchemy field" in str(
excinfo.value)
def test_schema_no_query():
schema = Schema(name='My own schema')
with raises(Exception) as excinfo:
schema.schema
assert 'define a base query type' in str(excinfo)
def test_coordinate__div__03():
'''A Coordinate cannot be divided by a Coordinate.'''
a = Coordinate(1, 2)
b = Coordinate(2, 4)
assert raises(TypeError, 't = a / b')
def test_coordinate__getitem__01():
t = Coordinate(1, 2)
assert t[0] == 1
assert t[1] == 2
assert raises(IndexError, 't[3]')
def test_global_id_none():
field = GlobalIDFormField()
with raises(ValidationError):
field.clean(None)
def test_coordinate__init__03():
'''Coordinate cannot be initialized with a Coordinate.'''
##In this case, the constructor returns the existing coordinate.'''
a = Coordinate(1, 2)
assert raises(TypeError, 't = Coordinate(a)')
def test_lookup_info_percentages_greater_than_100(self):
self.estimator.lookup.look_up = lambda p: FUELBED_INFO_60_40_10
with raises(RuntimeError) as e:
self.estimator.estimate(self.active_area_location)
def test_coordinate__floordiv__04():
'''Floor Division raises an OperandError on wrong type.'''
a = Coordinate(1, 2)
assert raises(TypeError, 'a // (1, 2, 3)')
def test_no_geojson_or_lat_or_lng(self):
with raises(ValueError) as e:
self.estimator.estimate({"activity":[{"location":{}}]})
def test_coordinate__floordiv__03():
'''Denominator 0 raises ZeroDivisionError.'''
a = Coordinate(1, 2)
assert raises(ZeroDivisionError, 't = a // 0')
def test_no_activity(self):
with raises(ValueError) as e:
self.estimator.estimate({})
def test_coordinate__floordiv__02():
'''Floor division does not work with two Coordinates.'''
a = Coordinate(1, 2)
b = Coordinate(2, -4)
assert raises(TypeError, 't = a // b')
def test_coordinate__init__02():
'''Coordinate cannot be initialized with a duple.'''
assert raises(TypeError, 'Coordinate((1, 2))')
def test_coordinate__div__05():
'''Division raises an Error on wrong type.'''
a = Coordinate(1, 2)
assert raises(TypeError, 'a / (1, 2, 3)')
def test_parse_goal_stmt_fail():
test = ['(:init ssdfsdf)']
iter = parse_lisp_iterator(test)
with raises(ValueError):
parse_goal_stmt(iter)
def test_coordinate__div__04():
'''A Coordinate cannot be divided by a duple.'''
a = Coordinate(1, 2)
b = (2, 4)
assert raises(TypeError, 'a / b')
def test_get_unregistered_type():
with raises(Exception) as excinfo:
schema.get_type('NON_EXISTENT_MODEL')
assert 'not found' in str(excinfo.value)
def test_deprecated_plugins_throws_exception():
with raises(Exception) as excinfo:
Schema(plugins=[])
assert 'Plugins are deprecated, please use middlewares' in str(excinfo.value)
