def test_one_is(self): with Assertable(self.rock_bands) as in_rock_bands: #in_rock_bands.one("formation").is_(1968) in_rock_bands.one([("band", "Pink Floyd"), "periods"]).is_({1963: "Formation", 1968: "Fame", 1978: "Waters leadership", 1986: "Gilmour leadership", 1995: "End", 2005: "Reunion"}) in_rock_bands.one([("band", "Cream"), "members"]).has("Clapton") self.assertRaises(AssertionError, in_rock_bands.one([("band", "Cream"), "members"]).is_, "Clapton") self.assertRaises(AssertionError, in_rock_bands.one([("band", "Pink Floyd"), "periods"]).is_, {1963: "Formation"}) self.assertRaises(AssertionError, in_rock_bands.one([("band", "Pink Floyd"), "periods"]).has, {1968: "Fame", 2000: "!"}) self.assertRaises(AssertionError, in_rock_bands.one("albums year").is_, 1972) self.assertRaises(AssertionError, in_rock_bands.one("albums year").is_, 1973)
def test_trivial(self): with Assertable([]) as empty_lst: empty_lst().evals_false() empty_lst().is_not_none() empty_lst.every_existent('a').is_('b') empty_lst.one().is_([]) empty_lst().is_([]) with Assertable({}) as empty_dict: empty_dict().evals_false() empty_dict().is_not_none() empty_lst.every_existent('a').is_('b') empty_dict.one().is_({}) empty_dict().is_({}) with Assertable('') as empty_str: empty_str().evals_false() empty_str().is_not_none() empty_str.every_existent('a').is_('b') empty_str.one().is_('') empty_str().is_('') with Assertable(None) as none: none().evals_false() none().is_none() none.one().is_(None) none().is_(None) with Assertable(set([1, 1])) as simple_set: simple_set().has_length(1) simple_set.one().is_(1) with Assertable((1, 2, 3)) as simple_tuple: simple_tuple().evals_true() simple_tuple().has_length(3) simple_tuple().has(2, 3) simple_tuple().is_((1, 3, 2)) simple_tuple().is_ordered((1, 2, 3))
def test_only_prefix_as_str(self): with Assertable(self.rock_bands, "albums title") as in_album_titles: in_album_titles.some().is_("The Wall") in_album_titles.one().matches("Made in Ja") in_album_titles.no().has("Python")
def test_strictly_every(self): with Assertable(self.rock_bands) as in_rock_bands: in_rock_bands.every("albums title").is_not_none() self.assertRaises(AssertionError, in_rock_bands.every, "albums songs")
def test_has_not(self): with Assertable(self.rock_bands) as in_rock_bands: in_rock_bands.every_existent("albums year").has_not(1984) in_rock_bands.every("genre").has_not("Rap") in_rock_bands.every_existent("periods").has_not({1984: "101"}) in_rock_bands.every_existent("nonsense").has_not("more nonsense")
def test_keys_are(self): with Assertable(self.programming_languages) as programming_languages: programming_languages().keys_are(["functional", "procedural", "object oriented"]) self.assertRaises(AssertionError, programming_languages().keys_are, ["functional", "procedural"])
def test_is_not(self): with Assertable(self.rock_bands) as in_rock_bands: in_rock_bands.one(["albums", ("title", "The Wall"), "year"]).is_not(1981) in_rock_bands.one(["albums", ("title", "The Wall"), "title"]).is_not("Other")
def test_is_nones(self): with Assertable(self.rock_bands) as in_rock_bands: in_rock_bands.every("albums title").is_not_none() in_rock_bands.no("albums title").is_none() in_rock_bands.some(["albums", "uk chart"]).is_not_none() in_rock_bands.some(["albums", "uk chart"]).is_none()
def test_has_keys(self): with Assertable(self.programming_languages) as programming_languages: programming_languages().has_keys("functional", "procedural") self.assertRaises(AssertionError, programming_languages().has_keys, "literate")
def test_no_has(self): with Assertable(self.rock_bands) as in_rock_bands: in_rock_bands.no("albums songs").has("Stairway to heaven") in_rock_bands.no("albums songs").has(["Stairway to heaven", "Smoke on the water"]) self.assertRaises(AssertionError, in_rock_bands.no("albums songs").has, "Stairway to heaven", "Smoke on the water")
def test_every_has(self): with Assertable(self.numbers) as in_numbers: in_numbers.every("sequences *").has(5) in_numbers.every("sequences *").has(2, 5) in_numbers.every("sequences *").has([2, 5]) self.assertRaises(AssertionError, in_numbers.every("sequences *").has, 0)
def test_deeply_nested_has(self): with Assertable({"n": {"e": {"s": {"t": {"e": "D"}}}}}) as in_deeply_nested: in_deeply_nested.one("n e s t e").has("D")
def test_basic_lists(self): with Assertable([1, 2, 3]) as in_list: in_list.one().is_(1) in_list.one().has(2, 3) with Assertable([1, 1, 1]) as in_list: in_list.every().is_(1) in_list.every().is_not(2) in_list.no().is_(2) with Assertable([[1, 2, 3], [4, 5, 6]]) as in_list: in_list.some().has(1, 4) in_list.some().has([1, 2]) in_list.no().has([1, 4]) in_list.some().has([1, 2], [4, 5]) in_list.no().is_([[5, 4, 6], [3, 2, 1]]) in_list.no().is_([[4, 5, 6], [1, 2, 3]]) in_list.one().is_([1, 2, 3]) in_list.one().is_([6, 4, 5]) in_list().is_([[4, 5, 6], [1, 2, 3]]) self.assertRaises(AssertionError, in_list().is_, [[5, 4, 6], [3, 2, 1]]) with Assertable({"x": [1, 2, 3]}) as in_list: in_list.one("x").is_(2, 3) in_list.one("x").has(1, 2) in_list.no("x").has([1, 2]) with Assertable({"x": [1, 2, 3]}) as in_list: in_list.one("x").is_(3) with Assertable([{"x": [1, 2, 3]}]) as in_list: in_list.one("x").is_([1, 2, 3]) in_list.one("x").has([1, 2, 3]) in_list.one("x").has([3, 2]) in_list.one("x").has(1, 2) with Assertable({"x": [1, 2, 3], "y": [4, 5, 6]}) as in_list: in_list.some("*").is_([3, 2, 1]) in_list.some("*").is_([5, 4, 6]) in_list.some("*").has([1, 2, 3]) in_list.some("*").has([1, 2]) in_list.some("*").has([1, 2], [5, 4]) in_list.no("*").has([1, 2, 3, 4]) in_list.one("*").has(1, 2) in_list.one("*").has(6) with Assertable({"x": ["flat", "nested"]}) as in_str_list: in_str_list.one("x").has("fl", "ed") in_str_list.one("x").has("f", "d") # catch! in_str_list.one("x").has(["f", "l"]) in_str_list.one("x").has(["fl", "at"], ["nest"]) in_str_list.no("x").has(["f", "d"]) with Assertable([{"x": [1, 2, 3]}]) as in_list: in_list.one("x").is_([1, 2, 3]) in_list.one("*").is_([[1, 2, 3]]) in_list.one("x").has([1, 2, 3]) in_list.one("x").has([3, 2]) in_list.one("x").has(1, 2) with Assertable([[1, 2, 3], [4, 5, 6]]) as in_list: in_list.one().is_([1, 2, 3])
def test_prefix_as_lst(self): with Assertable(self.programming_languages, ["functional", "Lisp"]) as in_lisp: in_lisp.one("year").is_(58) in_lisp.one(["designer", "name"]).is_("John McCarthy")
def test_every_is_a(self): with Assertable(self.rock_bands) as in_rock_bands: in_rock_bands.every("members").is_a(list) in_rock_bands.every_existent("albums year").is_a(int) in_rock_bands.every("genre").is_a(str)
def test_booleans(self): with Assertable({'a': False, 'b': [], 'c': True, 'd': 1}) as in_tricky_booleans: in_tricky_booleans.one('a').is_false() in_tricky_booleans.no('b').is_false() in_tricky_booleans.one('c').is_true() in_tricky_booleans.no('d').is_true()
class TestDemo(TestCase): def setUp(self): self.programming_languages = \ [{'languages': {'academical': {'functional': [{'name': 'Lisp', 'designer': {'name': 'John McCarthy', 'quote': """ We understand human mental processes only slightly better than a fish understands swimming. """}, 'features': ['macros', 'recursion', 'garbage collection'], 'type system': 'dynamic', 'year': 1958}, {'name': 'Haskell', 'designer': {'name': 'Simon Peyton Jones', 'quote': """ You'd like to be able to write a contract for a function like: 'You give me arguments that are bigger than zero and I'll give you a result that is smaller than zero'. """}, 'features': ['lazy evaluation', 'monads'], 'type system': 'static', 'year': 1990}]}, 'practical': {'functional': [{'name': 'Clojure', 'designer': {'name': 'Rich Hickey', 'quote': """ Programming is not about typing... it's about thinking. """}, 'features': ['software transactional memory', 'multimethods', 'protocols'], 'type system': 'dynamic', 'year': 2007}], 'object oriented': [{'name': 'Python', 'designer': {'name': 'Guido van Rossum', 'quote': """ filter(P, S) is almost always written clearer as [x for x in S if P(x)] """}, 'features': ['duck typing', 'GIL', 'multiple inheritance'], 'type system': 'dynamic', 'year': 1991}, {'name': 'Java', 'designer': {'name': 'James Gosling', 'quote': """ I think everybody has a different answer for what Web services are. """}, 'features': ['JIT compiler', 'generics'], 'type system': 'static', 'year': 1995}], 'procedural': [{'name': 'Fortran', 'designer': {'name': 'John Backus', 'quote': """ Much of my work has come from being lazy. """}, 'features': ['oldest high-level programming language', 'high-performance computing'], 'type system': 'static', 'year': 1957}, {'name': 'C', 'designer': {'name': 'Dennis Ritchie', 'quote': """ UNIX is basically a simple operating system, but you have to be a genius to understand the simplicity. """}, 'features': ['weakly typing', 'low level'], 'type system': 'static', 'year': 1972}]}}}] def test_programming(self): with Assertable(self.programming_languages) as in_programming: # Something equals something in_programming.one(["languages", "academical", "functional", ("name", "Lisp"), "year"]).is_(1958) in_programming.some("languages academical functional year").is_(1990) self.assertRaises(AssertionError, in_programming.every(["languages", "*", "functional", "type system"]).is_, "static") # Throws: # AssertionError: # Selection on the object under test with path ['languages', '*', 'functional', 'type system'] ---> # # ['dynamic', 'static', 'dynamic'] # # Compared with assertion input ---> # # 'static' # # Not verified (expected = 3, got = 1) in_programming.at_least(2, ["languages", "*", "functional", "type system"]).is_("dynamic") # Something contains something object_oriented_features = ["languages", "*", "object oriented", "features"] in_programming.some(object_oriented_features).has("duck typing") in_programming.some(object_oriented_features).has("duck typing", "generics") in_programming.some(object_oriented_features).has(["duck typing", "GIL"]) self.assertRaises(AssertionError, in_programming.some(object_oriented_features).has, ["duck typing", "generics"]) #Throws: # AssertionError: # Selection on the object under test with path ['languages', '*', 'object oriented', 'features'] ---> # # [['duck typing', 'GIL', 'multiple inheritance'], ['JIT compiler', 'generics']] # # Compared with assertion input ---> # # ['duck typing', 'generics'] # # Not verified (expected = 1, got = 0) in_programming.every(["languages", "*", "*", "type system"]).has("ic") in_programming.one(["languages", "practical", "procedural", ("name", "Fortran")]).has( {"year": 1957, "type system": "static"}) in_programming.one(["languages", "practical", "procedural", ("name", "Fortran")]).has_some_of( {"year": 2042, "type system": "static"}) # More on something equals something in_programming.some(object_oriented_features).is_(["JIT compiler", "generics"]) in_programming.some(object_oriented_features).is_(["generics", "JIT compiler"]) in_programming.some(object_oriented_features).is_ordered(["JIT compiler", "generics"]) self.assertRaises(AssertionError, in_programming.some(object_oriented_features).is_ordered, ["generics", "JIT compiler"]) # Something compares somehow with some property of something else in_programming.exactly(2, "languages * * year").has(1960, cmp=operator.lt) in_programming("languages * * year").has(1957, cmp=operator.eq, property=min) in_programming.every("languages * * features").has(2, cmp=operator.ge, property=len) in_programming.some("languages practical functional").is_not_none() in_programming.every("languages **").is_not_none() def test_convenient_methods(self): with Assertable(self.programming_languages, "languages * *") as in_languages: in_languages.every("features").has_no_nones() in_languages.every("features").has_not("can fly") in_languages.every("features").has_not("can fly", "can drive") in_languages.every("year").has_not(datetime.now().year, cmp=operator.gt) in_languages.every("year").is_a(int) in_languages.no("designer name").is_("Jim Morrison") in_languages.at_most(1, "designer name").is_("Denis Ritchie") in_languages.at_most(1, "designer name").is_("Denis Ritchie", "James Gosling") in_languages.some("designer quote").matches("(?i)uNiX") in_languages.some("designer quote").matches("(?i)uNiX", "work.*lazy") in_languages.some(["designer"], "quote").matches("(?i)uNiX", "work.*lazy") def test_others(self): with Assertable([[1, 2, 3]]) as in_numbers: self.assertRaises(AssertionError, in_numbers.one().is_, [[1, 2, 3]]) in_numbers.one().is_([1, 2, 3]) in_numbers().is_([[1, 2, 3]]) with Assertable([2, 3, 5, 7, 11, 13, 17, 19]) as in_primes: in_primes().has(True, cmp=operator.eq, property=lambda x: x == sorted(x)) all_modulos = lambda x: [(n, x % n) for n in xrange(1, x + 1)] all_divisibles = lambda x: ([x for (x, m) in all_modulos(x) if m == 0], x) is_prime = lambda (div_set, x), _: len(div_set) == 2 and 1 in div_set and x in div_set in_primes.every().has("ignore this attribute", cmp=is_prime, property=all_divisibles) with Assertable([1, 2, 3, 3]) as in_some_duplicates: in_some_duplicates.at_least(3).has_no_duplicates() self.assertRaises(AssertionError, in_some_duplicates.every().has_no_duplicates) self.assertRaises(AssertionError, in_some_duplicates().has, [1, 2, 3, 3], cmp=operator.eq, property=lambda x: list(set(x))) with Assertable({"programmers": [{"name": "Alice", "says": "I love functional programming!", "profession": "poet"}, {"name": "Bob", "says": "I love monkey patching!", "profession": "plumber"}, {"name": "Podio", "says": "I love agile!"}]}) as in_programmers: in_programmers.every_existent("programmers says").has("love") in_programmers.every("programmers says").has("love") self.assertRaises(AssertionError, in_programmers.every, "programmers profession") # Throws: # AssertionError: Attribute profession not found in path ['programmers', 'profession'] in_programmers.every_existent("programmers profession").is_not_none() in_programmers.one(["programmers", ("name", "Bob"), "profession"]).is_("plumber") # This doesn't work: #in_programmers.one(["programmers", ("profession", "plumber"), "says"]).has("monkey") def test_users(self): with Assertable({'users': [ {'name': 'Alice', 'mails': ['*****@*****.**'], 'country': 'UK', 'knows_python': False, 'birth_date': datetime(1987, 01, 06), 'favourite': {'color': 'Blue', 'number': 1}}, {'name': 'Bob', 'mails': ['*****@*****.**', '*****@*****.**'], 'knows_python': True, 'birth_date': datetime(1982, 04, 22), 'favourite': {'color': 'Black', 'number': 42}}, {'name': 'Mette', 'mails': [], 'country': 'DK', 'knows_python': True, 'birth_date': datetime(1980, 11, 11), 'favourite': {'color': 'Green', 'number': 7}}]}) as users: users('users').has_length(3) # there are 3 users users.one(['users', 'name']).is_('Alice') # exactly one user is named Alice users.one('users name').is_('Alice', 'Bob') # exactly one user is named Alice and another one is Bob users.one('users').has({'name': 'Alice', 'country': 'UK', 'favourite': {'color': 'Blue'}}) # exactly one user has these properties... users.one('users').has_some_of({'name': 'Alice', 'country': 'IE'}) # exactly one user is either named Alice or comes from Ireland users.one(['users', ('name', 'Alice'), 'knows_python']).is_false() # exactly one user named Alice does not know Python users.one('users mails').has('*****@*****.**') # exactly one user has this mail... users.one('users mails').has('*****@*****.**', '*****@*****.**') # different users has these 2 mails... users.one('users mails').has(['*****@*****.**', '*****@*****.**']) # the same user has these 2 mails users.one('users mails').has(['*****@*****.**', '*****@*****.**'], '*****@*****.**') # voila! users.one(['users', ('name', 'Bob'), 'mails']).is_(['*****@*****.**', '*****@*****.**']) # Bob has exactly these 2 mails users.one(['users', ('name', 'Bob'), 'mails']).is_ordered(['*****@*****.**', '*****@*****.**']) # Bob has exactly these 2 mails in that order users.every('users favourite number').is_a(int) # every user's favourite number is an int users.every(['users', 'favourite'], 'number').is_a(int) # the same - arguments values are concatenated users.every('users favourite *').evals_true() # every user's favourite thing is logically true (not None, 0, empty...) users.every('**').is_not_none() # every value of any property of any user is not none with Assertable({'users': [ {'name': 'Alice', 'mails': ['*****@*****.**'], 'country': 'UK', 'knows_python': False, 'birth_date': datetime(1987, 01, 06), 'favourite': {'color': 'Blue', 'number': 1}}, {'name': 'Bob', 'mails': ['*****@*****.**', '*****@*****.**'], 'knows_python': True, 'birth_date': datetime(1982, 04, 22), 'favourite': {'color': 'Black', 'number': 42}}, {'name': 'Mette', 'mails': [], 'country': 'DK', 'knows_python': True, 'birth_date': datetime(1980, 11, 11), 'favourite': {'color': 'Green', 'number': 7}}]}, 'users') as users: users().has_length(3) # there are 3 users users().has(3, cmp=operator.eq, property=len) # there are 3 users, the long way users().has_length(1, cmp=operator.gt) # there are more than 1 user users().has(1, cmp=operator.gt, property=len) # there are more than 1 user, the long way users.some('knows_python').is_true() # some users know Python users.no('favourite color').is_('Yellow') # no users have yellow as favourite color users.every([('name', 'Bob'), 'mails']).matches("[^@]+@[^@]+\.[^@]+") # every Bob's mail matches the regex users.every('mails').has_no_duplicates() # there are no duplicate mails users.every_existent('country').evals_true() # in every user that has a country, that country is logically true users.every('birth_date').has(20, cmp=operator.gt, # all users are more than 20 years old property=lambda birth_date: (datetime.now() - birth_date).days / 365) users.some('country').is_not('DK') # not all countries are DK # users.every('name').is_('Alice') # AssertionError: # Selection on the object under test with path ['users', 'name'] ---> # # ['Alice', 'Bob', 'Mette'] # # Compared with assertion input ---> # # 'Alice' # # Not verified (expected = 3, got = 1) with Assertable({'name': 'Alice', 'country': 'UK', 'knows_python': False}) as alice: alice().has_keys('name', 'country') # these are keys present in the dict alice().keys_are(['name', 'country', 'knows_python']) # these are *all* the keys in the dict