def test_have_property_with_value():
(u"this(instance).should.have.property(property_name).being or "
".with_value should allow chain up")
class Person(object):
name = "John Doe"
def __repr__(self):
return r"Person()"
jay = Person()
assert this(jay).should.have.property("name").being.equal("John Doe")
assert this(jay).should.have.property("name").not_being.equal("Foo")
def opposite():
assert this(jay).should.have.property("name").not_being.equal(
"John Doe")
def opposite_not():
assert this(jay).should.have.property("name").being.equal(
"Foo")
expect(opposite).when.called.to.throw(AssertionError)
expect(opposite).when.called.to.throw(compat_repr(
"'John Doe' should differ to 'John Doe', but is the same thing"))
expect(opposite_not).when.called.to.throw(AssertionError)
expect(opposite_not).when.called.to.throw(compat_repr(
"X is 'John Doe' whereas Y is 'Foo'"))
def test_have_property_with_value():
(u"this(instance).should.have.property(property_name).being or "
".with_value should allow chain up")
class Person(object):
name = "John Doe"
def __repr__(self):
return r"Person()"
jay = Person()
assert this(jay).should.have.property("name").being.equal("John Doe")
assert this(jay).should.have.property("name").not_being.equal("Foo")
def opposite():
assert this(jay).should.have.property("name").not_being.equal(
"John Doe")
def opposite_not():
assert this(jay).should.have.property("name").being.equal(
"Foo")
expect(opposite).when.called.to.throw(AssertionError)
expect(opposite).when.called.to.throw(compat_repr(
"'John Doe' should differ to 'John Doe', but is the same thing"))
expect(opposite_not).when.called.to.throw(AssertionError)
expect(opposite_not).when.called.to.throw(compat_repr(
"X is 'John Doe' whereas Y is 'Foo'"))
def test_equal_with_repr_of_complex_types_and_repr():
(u"test usage of repr() inside expect(complex1).to.equal(complex2)")
class Y(object):
def __init__(self, x):
self.x = x
def __repr__(self):
if PY3:
# PY3K should return the regular (unicode) string
return self.x
else:
return self.x.encode('utf-8')
def __eq__(self, other):
return self.x == other.x
y1 = {
'a': 2,
'b': Y(u'Gabriel Falcão'),
'c': 'Foo',
}
expect(y1).to.equal({
'a': 2,
'b': Y(u'Gabriel Falcão'),
'c': 'Foo',
})
expect(y1).to_not.equal({
'a': 2,
'b': Y(u'Gabriel Falçao'),
'c': 'Foo',
})
def opposite():
expect(y1).to.equal({
'a': 2,
'b': Y(u'Gabriel Falçao'),
'c': 'Foo',
})
def opposite_not():
expect(y1).to_not.equal({
'a': 2,
'b': Y(u'Gabriel Falcão'),
'c': 'Foo',
})
expect(opposite).when.called.to.throw(AssertionError)
expect(opposite).when.called.to.throw(compat_repr("X['b'] != Y['b']"))
expect(opposite_not).when.called.to.throw(AssertionError)
expect(opposite_not).when.called.to.throw(
compat_repr(
u"{'a': 2, 'b': Gabriel Falcão, 'c': 'Foo'} should differ to {'a': 2, 'b': Gabriel Falcão, 'c': 'Foo'}, but is the same thing"
))
def test_equal_with_repr_of_complex_types_and_repr():
(u"test usage of repr() inside expect(complex1).to.equal(complex2)")
class Y(object):
def __init__(self, x):
self.x = x
def __repr__(self):
if PY3:
# PY3K should return the regular (unicode) string
return self.x
else:
return self.x.encode('utf-8')
def __eq__(self, other):
return self.x == other.x
y1 = {
'a': 2,
'b': Y(u'Gabriel Falcão'),
'c': 'Foo',
}
expect(y1).to.equal({
'a': 2,
'b': Y(u'Gabriel Falcão'),
'c': 'Foo',
})
expect(y1).to_not.equal({
'a': 2,
'b': Y(u'Gabriel Falçao'),
'c': 'Foo',
})
def opposite():
expect(y1).to.equal({
'a': 2,
'b': Y(u'Gabriel Falçao'),
'c': 'Foo',
})
def opposite_not():
expect(y1).to_not.equal({
'a': 2,
'b': Y(u'Gabriel Falcão'),
'c': 'Foo',
})
expect(opposite).when.called.to.throw(AssertionError)
expect(opposite).when.called.to.throw(compat_repr("X['b'] != Y['b']"))
expect(opposite_not).when.called.to.throw(AssertionError)
expect(opposite_not).when.called.to.throw(compat_repr(
u"{'a': 2, 'b': Gabriel Falcão, 'c': 'Foo'} should differ to {'a': 2, 'b': Gabriel Falcão, 'c': 'Foo'}, but is the same thing"))
def test_unicode():
"dicts with unicode should work properly"
class Y(object):
def __init__(self, x):
self.x = x
def __repr__(self):
if PY3:
# PY3K should return the regular (unicode) string
return self.x
else:
return self.x.encode('utf-8')
def __eq__(self, other):
return self.x == other.x
y1 = {
'a': 2,
'b': Y(u'Gabriel Falcão'),
'c': u'Foo',
}
name = u'Gabriel Falcão' if PY3 else u'Gabriel Falc\xe3o'
expect(safe_repr(y1)).should.equal(
compat_repr("{'a': 2, 'b': %s, 'c': 'Foo'}" % name))
def test_have_property():
(u"this(instance).should.have.property(property_name)")
class Person(object):
name = "John Doe"
def __repr__(self):
return r"Person()"
jay = Person()
assert this(jay).should.have.property("name")
assert this(jay).should_not.have.property("age")
def opposite():
assert this(jay).should_not.have.property("name")
def opposite_not():
assert this(jay).should.have.property("age")
expect(opposite).when.called.to.throw(AssertionError)
expect(opposite).when.called.to.throw(compat_repr(
"Person() should not have the property `name`, but it is 'John Doe'"))
expect(opposite_not).when.called.to.throw(AssertionError)
expect(opposite_not).when.called.to.throw(
"Person() should have the property `age` but does not")
def test_deep_equals_dict_level3_fails_different_key():
"that() deep_equals(dict) failing on level 3 when has an extra key"
something = {
u'my::all_users': [
{
u'name': u'John',
u'age': 33,
u'foo': u'bar'
},
],
}
def assertions():
assert that(something).deep_equals({
u'my::all_users': [
{
u'name': u'John',
u'age': 33,
u'bar': u'foo'
},
],
})
assert that(assertions).raises(
AssertionError, compat_repr(
"given\n" \
"X = {'my::all_users': [{'age': 33, 'foo': 'bar', 'name': 'John'}]}\n" \
" and\n" \
"Y = {'my::all_users': [{'age': 33, 'bar': 'foo', 'name': 'John'}]}\n" \
"X['my::all_users'][0] has the key 'foo' whereas Y['my::all_users'][0] does not",
))
def test_deep_equals_dict_level3_fail_values():
"that() deep_equals(dict) failing on level 3"
something = {
'my::all_users': [
{
'name': 'John',
'age': 33
},
],
}
def assertions():
assert that(something).deep_equals({
'my::all_users': [
{
'name': 'John',
'age': 30
},
],
})
assert that(assertions).raises(
AssertionError, compat_repr(
"given\n" \
"X = {'my::all_users': [{'age': 33, 'name': 'John'}]}\n" \
" and\n" \
"Y = {'my::all_users': [{'age': 30, 'name': 'John'}]}\n" \
"X['my::all_users'][0]['age'] is 33 whereas Y['my::all_users'][0]['age'] is 30",
))
def test_deep_equals_dict_level3_fails_missing_key():
"that() deep_equals(dict) failing on level 3 when missing a key"
something = {
'my::all_users': [
{
'name': 'John',
'age': 33
},
],
}
def assertions():
assert that(something).deep_equals({
'my::all_users': [
{
'name': 'John',
'age': 30,
'foo': 'bar'
},
],
})
assert that(assertions).raises(
AssertionError, compat_repr(
"given\n" \
"X = {'my::all_users': [{'age': 33, 'name': 'John'}]}\n" \
" and\n" \
"Y = {'my::all_users': [{'age': 30, 'foo': 'bar', 'name': 'John'}]}\n" \
"X['my::all_users'][0] does not have the key 'foo' whereas Y['my::all_users'][0] has it",
))
def test_deep_equals_dict_level2_fail():
"that() deep_equals(dict) failing on level 2"
something = {
'one': 'yeah',
'another': {
'two': '##',
},
}
def assertions():
assert that(something).deep_equals({
'one': 'yeah',
'another': {
'two': '$$',
},
})
assert that(assertions).raises(
AssertionError, compat_repr(
"given\n" \
"X = {'another': {'two': '##'}, 'one': 'yeah'}\n" \
" and\n" \
"Y = {'another': {'two': '$$'}, 'one': 'yeah'}\n" \
"X['another']['two'] is '##' whereas Y['another']['two'] is '$$'",
))
def test_deep_equals_dict_level2_fail():
"that() deep_equals(dict) failing on level 2"
something = {
'one': 'yeah',
'another': {
'two': '##',
},
}
def assertions():
assert that(something).deep_equals({
'one': 'yeah',
'another': {
'two': '$$',
},
})
assert that(assertions).raises(
AssertionError, compat_repr(
"given\n" \
"X = {'another': {'two': '##'}, 'one': 'yeah'}\n" \
" and\n" \
"Y = {'another': {'two': '$$'}, 'one': 'yeah'}\n" \
"X['another']['two'] is '##' whereas Y['another']['two'] is '$$'",
))
def test_nested_dict():
"dicts nested inside values should also get sorted"
X = {u'my::all_users': [{u'age': 33, u'name': u'John', u'foo': u'bar'}]}
expect(safe_repr(X)).should.equal(
compat_repr(
'''{'my::all_users': [{'age': 33, 'foo': 'bar', 'name': 'John'}]}'''
))
def test_have_property():
(u"this(instance).should.have.property(property_name)")
class Person(object):
name = "John Doe"
def __repr__(self):
return r"Person()"
jay = Person()
assert this(jay).should.have.property("name")
assert this(jay).should_not.have.property("age")
def opposite():
assert this(jay).should_not.have.property("name")
def opposite_not():
assert this(jay).should.have.property("age")
expect(opposite).when.called.to.throw(AssertionError)
expect(opposite).when.called.to.throw(compat_repr(
"Person() should not have the property `name`, but it is 'John Doe'"))
expect(opposite_not).when.called.to.throw(AssertionError)
expect(opposite_not).when.called.to.throw(
"Person() should have the property `age` but does not")
def test_unicode():
"dicts with unicode should work properly"
class Y(object):
def __init__(self, x):
self.x = x
def __repr__(self):
if PY3:
# PY3K should return the regular (unicode) string
return self.x
else:
return self.x.encode('utf-8')
def __eq__(self, other):
return self.x == other.x
y1 = {
'a': 2,
'b': Y(u'Gabriel Falcão'),
'c': u'Foo',
}
name = u'Gabriel Falcão' if PY3 else u'Gabriel Falc\xe3o'
expect(safe_repr(y1)).should.equal(compat_repr(
"{'a': 2, 'b': %s, 'c': 'Foo'}" % name
))
def test_look_like():
(u"this(' aa \n ').should.look_like('aa')")
assert this(' \n aa \n ').should.look_like('AA')
assert this(' \n bb \n ').should_not.look_like('aa')
def opposite():
assert this('\n aa \n').should.look_like('bb')
def opposite_not():
assert this('\n aa \n').should_not.look_like('aa')
expect(opposite).when.called.to.throw(AssertionError)
expect(opposite).when.called.to.throw(compat_repr(r"'\n aa \n' does not look like 'bb'"))
expect(opposite_not).when.called.to.throw(AssertionError)
expect(opposite_not).when.called.to.throw(compat_repr(r"'\n aa \n' should not look like 'aa' but does"))
def test_look_like():
(u"this(' aa \n ').should.look_like('aa')")
assert this(' \n aa \n ').should.look_like('AA')
assert this(' \n bb \n ').should_not.look_like('aa')
def opposite():
assert this('\n aa \n').should.look_like('bb')
def opposite_not():
assert this('\n aa \n').should_not.look_like('aa')
expect(opposite).when.called.to.throw(AssertionError)
expect(opposite).when.called.to.throw(compat_repr(r"'\n aa \n' does not look like 'bb'"))
expect(opposite_not).when.called.to.throw(AssertionError)
expect(opposite_not).when.called.to.throw(compat_repr(r"'\n aa \n' should not look like 'aa' but does"))
def test_that_equals_fails():
"that() equals(string) when it's supposed to fail"
something = "else"
def fail():
assert that("something").equals(something)
assert that(fail).raises(
AssertionError,
compat_repr("given\n" "X = 'something'\n" " and\n" "Y = 'else'\n" "X is 'something' whereas Y is 'else'"),
)
def test_have_key():
(u"this(dictionary).should.have.key(key_name)")
jay = {'name': "John Doe"}
assert this(jay).should.have.key("name")
assert this(jay).should_not.have.key("age")
def opposite():
assert this(jay).should_not.have.key("name")
def opposite_not():
assert this(jay).should.have.key("age")
expect(opposite).when.called.to.throw(AssertionError)
expect(opposite).when.called.to.throw(compat_repr(
"{'name': 'John Doe'} should not have the key `name`, "
"but it is 'John Doe'"))
expect(opposite_not).when.called.to.throw(AssertionError)
expect(opposite_not).when.called.to.throw(compat_repr(
"{'name': 'John Doe'} should have the key `age` but does not"))
def test_have_key():
(u"this(dictionary).should.have.key(key_name)")
jay = {'name': "John Doe"}
assert this(jay).should.have.key("name")
assert this(jay).should_not.have.key("age")
def opposite():
assert this(jay).should_not.have.key("name")
def opposite_not():
assert this(jay).should.have.key("age")
expect(opposite).when.called.to.throw(AssertionError)
expect(opposite).when.called.to.throw(compat_repr(
"{'name': 'John Doe'} should not have the key `name`, "
"but it is 'John Doe'"))
expect(opposite_not).when.called.to.throw(AssertionError)
expect(opposite_not).when.called.to.throw(compat_repr(
"{'name': 'John Doe'} should have the key `age` but does not"))
def test_have_key_with_value():
(u"this(dictionary).should.have.key(key_name).being or "
".with_value should allow chain up")
jay = dict(name="John Doe")
assert this(jay).should.have.key("name").being.equal("John Doe")
assert this(jay).should.have.key("name").not_being.equal("Foo")
def opposite():
assert this(jay).should.have.key("name").not_being.equal("John Doe")
def opposite_not():
assert this(jay).should.have.key("name").being.equal("Foo")
expect(opposite).when.called.to.throw(AssertionError)
expect(opposite).when.called.to.throw(
compat_repr(
"'John Doe' should differ to 'John Doe', but is the same thing"))
expect(opposite_not).when.called.to.throw(AssertionError)
expect(opposite_not).when.called.to.throw(
compat_repr("X is 'John Doe' whereas Y is 'Foo'"))
def test_deep_equals_failing_complex_vs_basic():
"that(X) deep_equals(Y) fails with complex vc basic type"
def assertions():
assert that({'two': 'yeah'}).deep_equals('two yeah')
assert that(assertions).raises(
AssertionError, compat_repr(
"given\n" \
"X = {'two': 'yeah'}\n" \
" and\n" \
"Y = 'two yeah'\n"
"X is a dict and Y is a %s instead" % text_type_name,
))
def test_deep_equals_failing_complex_vs_basic():
"that(X) deep_equals(Y) fails with complex vc basic type"
def assertions():
assert that({'two': 'yeah'}).deep_equals('two yeah')
assert that(assertions).raises(
AssertionError, compat_repr(
"given\n" \
"X = {'two': 'yeah'}\n" \
" and\n" \
"Y = 'two yeah'\n"
"X is a dict and Y is a %s instead" % text_type_name,
))
def test_have_key_with_value():
(u"this(dictionary).should.have.key(key_name).being or "
".with_value should allow chain up")
jay = dict(name="John Doe")
assert this(jay).should.have.key("name").being.equal("John Doe")
assert this(jay).should.have.key("name").not_being.equal("Foo")
def opposite():
assert this(jay).should.have.key("name").not_being.equal(
"John Doe")
def opposite_not():
assert this(jay).should.have.key("name").being.equal(
"Foo")
expect(opposite).when.called.to.throw(AssertionError)
expect(opposite).when.called.to.throw(compat_repr(
"'John Doe' should differ to 'John Doe', but is the same thing"))
expect(opposite_not).when.called.to.throw(AssertionError)
expect(opposite_not).when.called.to.throw(compat_repr(
"X is 'John Doe' whereas Y is 'Foo'"))
def test_that_equals_fails():
"that() equals(string) when it's supposed to fail"
something = u"else"
def fail():
assert that(u'something').equals(something)
assert that(fail).raises(
AssertionError, compat_repr(
"given\n" \
"X = 'something'\n" \
" and\n" \
"Y = 'else'\n" \
"X is 'something' whereas Y is 'else'",
))
def test_deep_equals_tuple_level1_fail_by_value():
"that(tuple) deep_equals(tuple) failing on level 1"
something = ('one', 'yeahs')
def assertions():
assert that(something).deep_equals(('one', 'yeah'))
assert that(assertions).raises(
AssertionError, compat_repr(
"given\n" \
"X = ('one', 'yeahs')\n" \
" and\n" \
"Y = ('one', 'yeah')\n" \
"X[1] is 'yeahs' whereas Y[1] is 'yeah'",
))
def test_deep_equals_tuple_level1_fail_by_length_y_gt_x():
"that(tuple) deep_equals(tuple) failing by length (len(Y) > len(X))"
something = ('one', 'yeah')
def assertions():
assert that(something).deep_equals(('one', 'yeah', 'damn'))
assert that(assertions).raises(
AssertionError, compat_repr(
"given\n" \
"X = ('one', 'yeah')\n" \
" and\n" \
"Y = ('one', 'yeah', 'damn')\n" \
"Y has 3 items whereas X has only 2",
))
def test_deep_equals_list_level2_fail_by_length_x_gt_y():
"that(list) deep_equals(list) failing by length (len(X) > len(Y))"
something = {'iterable': ['one', 'yeah', 'awesome!']}
def assertions():
assert that(something).deep_equals({'iterable': ['one', 'yeah']})
assert that(assertions).raises(
AssertionError, compat_repr(
"given\n" \
"X = {'iterable': ['one', 'yeah', 'awesome!']}\n" \
" and\n" \
"Y = {'iterable': ['one', 'yeah']}\n" \
"X has 3 items whereas Y has only 2",
))
def test_deep_equals_list_level1_fail_by_value():
"that(list) deep_equals(list) failing on level 1"
something = ['one', 'yeahs']
def assertions():
assert that(something).deep_equals(['one', 'yeah'])
assert that(assertions).raises(
AssertionError, compat_repr(
"given\n" \
"X = ['one', 'yeahs']\n" \
" and\n" \
"Y = ['one', 'yeah']\n" \
"X[1] is 'yeahs' whereas Y[1] is 'yeah'",
))
def test_deep_equals_list_level2_fail_by_length_y_gt_x():
"that(list) deep_equals(list) failing by length (len(Y) > len(X))"
something = [u'one', u'yeah']
def assertions():
assert that(something).deep_equals(['one', 'yeah', 'damn'])
assert that(assertions).raises(
AssertionError, compat_repr(
"given\n" \
"X = ['one', 'yeah']\n" \
" and\n" \
"Y = ['one', 'yeah', 'damn']\n" \
"Y has 3 items whereas X has only 2",
))
def test_deep_equals_list_level1_fail_by_value():
"that(list) deep_equals(list) failing on level 1"
something = ['one', 'yeahs']
def assertions():
assert that(something).deep_equals(['one', 'yeah'])
assert that(assertions).raises(
AssertionError, compat_repr(
"given\n" \
"X = ['one', 'yeahs']\n" \
" and\n" \
"Y = ['one', 'yeah']\n" \
"X[1] is 'yeahs' whereas Y[1] is 'yeah'",
))
def test_deep_equals_failing_basic_vs_complex():
"that(X) deep_equals(Y) fails with basic vc complex type"
def assertions():
assert that('two yeah').deep_equals({
'two': 'yeah',
})
assert that(assertions).raises(
AssertionError, compat_repr(
"given\n" \
"X = 'two yeah'\n"
" and\n" \
"Y = {'two': 'yeah'}\n" \
"X is a %s and Y is a dict instead" % text_type_name,
))
def test_deep_equals_list_level2_fail_by_length_y_gt_x():
"that(list) deep_equals(list) failing by length (len(Y) > len(X))"
something = [u'one', u'yeah']
def assertions():
assert that(something).deep_equals(['one', 'yeah', 'damn'])
assert that(assertions).raises(
AssertionError, compat_repr(
"given\n" \
"X = ['one', 'yeah']\n" \
" and\n" \
"Y = ['one', 'yeah', 'damn']\n" \
"Y has 3 items whereas X has only 2",
))
def test_deep_equals_failing_basic_vs_complex():
"that(X) deep_equals(Y) fails with basic vc complex type"
def assertions():
assert that("two yeah").deep_equals({"two": "yeah"})
assert that(assertions).raises(
AssertionError,
compat_repr(
"given\n"
"X = 'two yeah'\n"
" and\n"
"Y = {'two': 'yeah'}\n"
"X is a %s and Y is a dict instead" % text_type_name
),
)
def test_deep_equals_tuple_level1_fail_by_value():
"that(tuple) deep_equals(tuple) failing on level 1"
something = ('one', 'yeahs')
def assertions():
assert that(something).deep_equals(('one', 'yeah'))
assert that(assertions).raises(
AssertionError, compat_repr(
"given\n" \
"X = ('one', 'yeahs')\n" \
" and\n" \
"Y = ('one', 'yeah')\n" \
"X[1] is 'yeahs' whereas Y[1] is 'yeah'",
))
def test_deep_equals_tuple_level1_fail_by_length_y_gt_x():
"that(tuple) deep_equals(tuple) failing by length (len(Y) > len(X))"
something = ('one', 'yeah')
def assertions():
assert that(something).deep_equals(('one', 'yeah', 'damn'))
assert that(assertions).raises(
AssertionError, compat_repr(
"given\n" \
"X = ('one', 'yeah')\n" \
" and\n" \
"Y = ('one', 'yeah', 'damn')\n" \
"Y has 3 items whereas X has only 2",
))
def test_deep_equals_list_level2_fail_by_length_x_gt_y():
"that(list) deep_equals(list) failing by length (len(X) > len(Y))"
something = {'iterable': ['one', 'yeah', 'awesome!']}
def assertions():
assert that(something).deep_equals({'iterable': ['one', 'yeah']})
assert that(assertions).raises(
AssertionError, compat_repr(
"given\n" \
"X = {'iterable': ['one', 'yeah', 'awesome!']}\n" \
" and\n" \
"Y = {'iterable': ['one', 'yeah']}\n" \
"X has 3 items whereas Y has only 2",
))
def test_deep_equals_dict_level1_fails_missing_key_on_y():
"that(X) deep_equals(Y) fails when Y is missing a key that X has"
something = {"one": "yeah"}
def assertions():
assert that(something).deep_equals({"two": "yeah"})
assert that(assertions).raises(
AssertionError,
compat_repr(
"given\n"
"X = {'one': 'yeah'}\n"
" and\n"
"Y = {'two': 'yeah'}\n"
"X has the key 'one' whereas Y does not"
),
)
def test_deep_equals_dict_level1_fail():
"that() deep_equals(dict) failing on level 1"
something = {"one": "yeah"}
def assertions():
assert that(something).deep_equals({"one": "oops"})
assert that(assertions).raises(
AssertionError,
compat_repr(
"given\n"
"X = {'one': 'yeah'}\n"
" and\n"
"Y = {'one': 'oops'}\n"
"X['one'] is 'yeah' whereas Y['one'] is 'oops'"
),
)
def test_deep_equals_dict_level3_fails_different_key():
"that() deep_equals(dict) failing on level 3 when has an extra key"
something = {"my::all_users": [{"name": "John", "age": 33, "foo": "bar"}]}
def assertions():
assert that(something).deep_equals({"my::all_users": [{"name": "John", "age": 33, "bar": "foo"}]})
assert that(assertions).raises(
AssertionError,
compat_repr(
"given\n"
"X = {'my::all_users': [{'age': 33, 'foo': 'bar', 'name': 'John'}]}\n"
" and\n"
"Y = {'my::all_users': [{'age': 33, 'bar': 'foo', 'name': 'John'}]}\n"
"X['my::all_users'][0] has the key 'foo' whereas Y['my::all_users'][0] does not"
),
)
def test_deep_equals_dict_level2_fail():
"that() deep_equals(dict) failing on level 2"
something = {"one": "yeah", "another": {"two": "##"}}
def assertions():
assert that(something).deep_equals({"one": "yeah", "another": {"two": "$$"}})
assert that(assertions).raises(
AssertionError,
compat_repr(
"given\n"
"X = {'another': {'two': '##'}, 'one': 'yeah'}\n"
" and\n"
"Y = {'another': {'two': '$$'}, 'one': 'yeah'}\n"
"X['another']['two'] is '##' whereas Y['another']['two'] is '$$'"
),
)
def test_deep_equals_dict_level3_fail_values():
"that() deep_equals(dict) failing on level 3"
something = {"my::all_users": [{"name": "John", "age": 33}]}
def assertions():
assert that(something).deep_equals({"my::all_users": [{"name": "John", "age": 30}]})
assert that(assertions).raises(
AssertionError,
compat_repr(
"given\n"
"X = {'my::all_users': [{'age': 33, 'name': 'John'}]}\n"
" and\n"
"Y = {'my::all_users': [{'age': 30, 'name': 'John'}]}\n"
"X['my::all_users'][0]['age'] is 33 whereas Y['my::all_users'][0]['age'] is 30"
),
)
def test_deep_equals_tuple_level1_fail_by_length_x_gt_y():
"that(tuple) deep_equals(tuple) failing by length (len(X) > len(Y))"
something = ("one", "yeah", "awesome!")
def assertions():
assert that(something).deep_equals(("one", "yeah"))
assert that(assertions).raises(
AssertionError,
compat_repr(
"given\n"
"X = ('one', 'yeah', 'awesome!')\n"
" and\n"
"Y = ('one', 'yeah')\n"
"X has 3 items whereas Y has only 2"
),
)
def test_deep_equals_list_level1_fail_by_length_x_gt_y():
"that(list) deep_equals(list) failing by length (len(X) > len(Y))"
something = ["one", "yeah", "awesome!"]
def assertions():
assert that(something).deep_equals(["one", "yeah"])
assert that(assertions).raises(
AssertionError,
compat_repr(
"given\n"
"X = ['one', 'yeah', 'awesome!']\n"
" and\n"
"Y = ['one', 'yeah']\n"
"X has 3 items whereas Y has only 2"
),
)
def test_iterable_should_have_length_of():
(u"this(iterable).should.have.length_of(N)")
assert this({'foo': 'bar', 'a': 'b'}).should.have.length_of(2)
assert this([1, 2, 3]).should_not.have.length_of(4)
def opposite():
assert this(('foo', 'bar', 'a', 'b')).should.have.length_of(1)
def opposite_not():
assert this([1, 2, 3]).should_not.have.length_of(3)
expect(opposite).when.called.to.throw(AssertionError)
expect(opposite).when.called.to.throw(compat_repr(
"the length of ('foo', 'bar', 'a', 'b') should be 1, but is 4"))
expect(opposite_not).when.called.to.throw(AssertionError)
expect(opposite_not).when.called.to.throw(
"the length of [1, 2, 3] should not be 3")
def test_iterable_should_have_length_of():
(u"this(iterable).should.have.length_of(N)")
assert this({'foo': 'bar', 'a': 'b'}).should.have.length_of(2)
assert this([1, 2, 3]).should_not.have.length_of(4)
def opposite():
assert this(('foo', 'bar', 'a', 'b')).should.have.length_of(1)
def opposite_not():
assert this([1, 2, 3]).should_not.have.length_of(3)
expect(opposite).when.called.to.throw(AssertionError)
expect(opposite).when.called.to.throw(compat_repr(
"the length of ('foo', 'bar', 'a', 'b') should be 1, but is 4"))
expect(opposite_not).when.called.to.throw(AssertionError)
expect(opposite_not).when.called.to.throw(
"the length of [1, 2, 3] should not be 3")
def test_should_be_callable():
(u"this(function).should.be.callable")
assert this(lambda: None).should.be.callable
assert this("aa").should_not.be.callable
def opposite():
assert this("foo").should.be.callable
def opposite_not():
assert this(opposite).should_not.be.callable
expect(opposite).when.called.to.throw(AssertionError)
expect(opposite).when.called.to.throw(compat_repr(
"expected 'foo' to be callable"))
expect(opposite_not).when.called.to.throw(AssertionError)
expect(opposite_not).when.called.to.throw(
"expected `{0}` to not be callable but it is".format(repr(opposite)))
def test_should_be_callable():
(u"this(function).should.be.callable")
assert this(lambda: None).should.be.callable
assert this("aa").should_not.be.callable
def opposite():
assert this("foo").should.be.callable
def opposite_not():
assert this(opposite).should_not.be.callable
expect(opposite).when.called.to.throw(AssertionError)
expect(opposite).when.called.to.throw(compat_repr(
"expected 'foo' to be callable"))
expect(opposite_not).when.called.to.throw(AssertionError)
expect(opposite_not).when.called.to.throw(
"expected `{0}` to not be callable but it is".format(repr(opposite)))
def test_deep_equals_fallsback_to_generic_comparator_failing_type():
"that() deep_equals(dict) with generic comparator failing"
from datetime import datetime
now = datetime(2012, 3, 5)
something = {"date": now}
def assertions():
assert that(something).deep_equals({"date": None})
assert that(assertions).raises(
AssertionError,
compat_repr(
"given\n"
"X = {'date': datetime.datetime(2012, 3, 5, 0, 0)}\n"
" and\n"
"Y = {'date': None}\n"
"X['date'] is a datetime and Y['date'] is a NoneType instead"
),
)
def test_deep_equals_dict_level1_fails_missing_key_on_y():
"that(X) deep_equals(Y) fails when Y is missing a key that X has"
something = {
'one': 'yeah',
}
def assertions():
assert that(something).deep_equals({
'two': 'yeah',
})
assert that(assertions).raises(
AssertionError, compat_repr(
"given\n" \
"X = {'one': 'yeah'}\n" \
" and\n" \
"Y = {'two': 'yeah'}\n" \
"X has the key 'one' whereas Y does not",
))
def test_deep_equals_dict_level1_fail():
"that() deep_equals(dict) failing on level 1"
something = {
'one': 'yeah',
}
def assertions():
assert that(something).deep_equals({
'one': 'oops',
})
assert that(assertions).raises(
AssertionError, compat_repr(
"given\n" \
"X = {'one': 'yeah'}\n" \
" and\n" \
"Y = {'one': 'oops'}\n" \
"X['one'] is 'yeah' whereas Y['one'] is 'oops'",
))
def test_deep_equals_fallsback_to_generic_comparator_failing_type():
"that() deep_equals(dict) with generic comparator failing"
from datetime import datetime
now = datetime(2012, 3, 5)
something = {
'date': now,
}
def assertions():
assert that(something).deep_equals({
'date': None,
})
assert that(assertions).raises(
AssertionError, compat_repr(
"given\n" \
"X = {'date': datetime.datetime(2012, 3, 5, 0, 0)}\n" \
" and\n" \
"Y = {'date': None}\n" \
"X['date'] is a datetime and Y['date'] is a NoneType instead",
))
def test_deep_equals_fallsback_to_generic_comparator_failing():
"that() deep_equals(dict) with generic comparator failing"
from datetime import datetime
now = datetime(2012, 3, 5)
tomorrow = datetime(2012, 3, 6)
something = {"date": now}
def assertions():
assert that(something).deep_equals({"date": tomorrow})
assert that(assertions).raises(
AssertionError,
compat_repr(
"given\n"
"X = {'date': datetime.datetime(2012, 3, 5, 0, 0)}\n"
" and\n"
"Y = {'date': datetime.datetime(2012, 3, 6, 0, 0)}\n"
"X['date'] != Y['date']"
),
)
def test_deep_equals_fallsback_to_generic_comparator_failing():
"that() deep_equals(dict) with generic comparator failing"
from datetime import datetime
now = datetime(2012, 3, 5)
tomorrow = datetime(2012, 3, 6)
something = {
'date': now,
}
def assertions():
assert that(something).deep_equals({
'date': tomorrow,
})
assert that(assertions).raises(
AssertionError, compat_repr(
"given\n" \
"X = {'date': datetime.datetime(2012, 3, 5, 0, 0)}\n" \
" and\n" \
"Y = {'date': datetime.datetime(2012, 3, 6, 0, 0)}\n" \
"X['date'] != Y['date']",
))
def test_deep_equals_dict_level3_fails_missing_key():
"that() deep_equals(dict) failing on level 3 when missing a key"
something = {
'my::all_users': [
{'name': 'John', 'age': 33},
],
}
def assertions():
assert that(something).deep_equals({
'my::all_users': [
{'name': 'John', 'age': 30, 'foo': 'bar'},
],
})
assert that(assertions).raises(
AssertionError, compat_repr(
"given\n" \
"X = {'my::all_users': [{'age': 33, 'name': 'John'}]}\n" \
" and\n" \
"Y = {'my::all_users': [{'age': 30, 'foo': 'bar', 'name': 'John'}]}\n" \
"X['my::all_users'][0] does not have the key 'foo' whereas Y['my::all_users'][0] has it",
))
def test_deep_equals_dict_level3_fails_different_key():
"that() deep_equals(dict) failing on level 3 when has an extra key"
something = {
u'my::all_users': [
{u'name': u'John', u'age': 33, u'foo': u'bar'},
],
}
def assertions():
assert that(something).deep_equals({
u'my::all_users': [
{u'name': u'John', u'age': 33, u'bar': u'foo'},
],
})
assert that(assertions).raises(
AssertionError, compat_repr(
"given\n" \
"X = {'my::all_users': [{'age': 33, 'foo': 'bar', 'name': 'John'}]}\n" \
" and\n" \
"Y = {'my::all_users': [{'age': 33, 'bar': 'foo', 'name': 'John'}]}\n" \
"X['my::all_users'][0] has the key 'foo' whereas Y['my::all_users'][0] does not",
))
def test_basic_list():
"safe_repr should display a simple list"
X = [u'one', u'yeah']
expect(safe_repr(X)).should.equal(compat_repr("['one', 'yeah']"))
def test_nested_dict():
"dicts nested inside values should also get sorted"
X = {u'my::all_users': [{u'age': 33, u'name': u'John', u'foo': u'bar'}]}
expect(safe_repr(X)).should.equal(compat_repr(
'''{'my::all_users': [{'age': 33, 'foo': 'bar', 'name': 'John'}]}'''
))
def test_basic_dict():
"safe_repr should return a sorted repr"
X = {u'b': u'd', u'a': u'c'}
expect(safe_repr(X)).should.equal(compat_repr("{'a': 'c', 'b': 'd'}"))