Skip to content

Commit

Permalink
Refactoring tests to make things more straightforward
Browse files Browse the repository at this point in the history 
I didn't managed to make parametrised tests with unittest but that should be the real solution.
Also, I don't know how to test the hook : it doesn't seem to work :/
  • Loading branch information
@SylvainDe
SylvainDe committed Oct 29, 2014
1 parent 7ebde19 commit 591d52b
Showing 1 changed file with 143 additions and 116 deletions.
259 changes: 143 additions & 116 deletions didyoumean_tests.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,143 +3,170 @@
from didyoumean_decorator import didyoumean
import unittest

# Following code is bad on purpose - please do not fix ;-)

class NameErrorSingleArgument(unittest.TestCase):
def nameerror_function(self, foo, bar):
return foob

@didyoumean
def nameerror_function_wrapped(self, foo, bar):
return self.nameerror_function(foo, bar)
def nameerror_1_arg(foo):
"""Should be 'return foo'."""
return foob

def test_original(self):
self.assertRaisesRegex(NameError, "^(global )?name '[^']*' is not defined$", lambda: self.nameerror_function(1, 2))

def test_wrapped(self):
self.assertRaisesRegex(NameError, "^(global )?name '[^']*' is not defined. Did you mean foo$", lambda: self.nameerror_function_wrapped(1, 2))
def nameerror_n_args(fool, foot, bar):
"""Should be 'fool' or 'foot'."""
return foob


class NameErrorMultipleArguments(unittest.TestCase):
def nameerror_function(self, fool, foot):
return food
def nameerror_builtin():
"""Should be 'max'."""
return maxi

@didyoumean
def nameerror_function_wrapped(self, foo, bar):
return self.nameerror_function(foo, bar)

def test_original(self):
self.assertRaisesRegex(NameError, "^(global )?name '[^']*' is not defined$", lambda: self.nameerror_function(1, 2))
def nameerror_no_sugg():
"""No suggestion."""
return ldkjhfnvdlkjhvgfdhgf

def test_wrapped(self):
self.assertRaisesRegex(NameError, "^(global )?name '[^']*' is not defined. Did you mean foot, fool$", lambda: self.nameerror_function_wrapped(1, 2))

def nameerror_import_sugg():
"""Should import functools first."""
return functools.wraps

class NameErrorBuiltin(unittest.TestCase):
def nameerror_function(self):
return maxi

@didyoumean
def nameerror_function_wrapped(self):
return self.nameerror_function()
def attributeerror_method():
"""Should be 'append'."""
lst = [1, 2, 3]
lst.appendh(4)

def test_original(self):
self.assertRaisesRegex(NameError, "^(global )?name '[^']*' is not defined$", lambda: self.nameerror_function())

def test_wrapped(self):
self.assertRaisesRegex(NameError, "^(global )?name '[^']*' is not defined. Did you mean max$", lambda: self.nameerror_function_wrapped())
def attributeerror_builtin():
"""Should be 'max(lst)'."""
lst = [1, 2, 3]
lst.max()


class NameErrorNoSuggestion(unittest.TestCase):
def nameerror_function(self):
return ldkjhfnvdlkjhvgfdhgf
def attributeerror_no_sugg():
"""No suggestion."""
lst = [1, 2, 3]
lst.ldkjhfnvdlkjhvgfdhgf

@didyoumean
def nameerror_function_wrapped(self):
return self.nameerror_function()

def test_original(self):
self.assertRaisesRegex(NameError, "^(global )?name '[^']*' is not defined$", lambda: self.nameerror_function())
class FoobarClass():
"""Dummy class for testing purposes."""

def test_wrapped(self):
self.assertRaisesRegex(NameError, "^(global )?name '[^']*' is not defined$", lambda: self.nameerror_function_wrapped())
def __init__(self):
"""Constructor."""
self.foo = 4
self.bar = 2


class NameErrorImportSuggestion(unittest.TestCase):
def nameerror_function(self):
return math.pi

@didyoumean
def nameerror_function_wrapped(self):
return self.nameerror_function()

def test_original(self):
self.assertRaisesRegex(NameError, "^(global )?name '[^']*' is not defined$", lambda: self.nameerror_function())

def test_wrapped(self):
self.assertRaisesRegex(NameError, "^(global )?name '[^']*' is not defined. Did you mean import math.*$", lambda: self.nameerror_function_wrapped())


class NameErrorSelfSuggestion(unittest.TestCase):
def nameerror_function(self):
return assertEqual

@didyoumean
def nameerror_function_wrapped(self):
return self.nameerror_function()

def test_original(self):
self.assertRaisesRegex(NameError, "^(global )?name '[^']*' is not defined$", lambda: self.nameerror_function())

def test_wrapped(self):
self.assertRaisesRegex(NameError, "^(global )?name '[^']*' is not defined. Did you mean self.assertEqual$", lambda: self.nameerror_function_wrapped())


class NameErrorSelfClassMethodSuggestion(unittest.TestCase):
@classmethod
def function_class_nameerror(cls):
pass

def nameerror_function(self):
return function_class_nameerror
def this_is_cls_mthd(cls):
"""Just a class method."""
return 5

@didyoumean
def nameerror_function_wrapped(self):
return self.nameerror_function()
def nameerror_self(self):
"""Should be self.foo."""
return foo

def test_original(self):
self.assertRaisesRegex(NameError, "^(global )?name '[^']*' is not defined$", lambda: self.nameerror_function())
def nameerror_self2(self):
"""Should be self.this_is_cls_mthd."""
return this_is_cls_mthd

def test_wrapped(self):
self.assertRaisesRegex(NameError, "^(global )?name '[^']*' is not defined. Did you mean self.function_class_nameerror$", lambda: self.nameerror_function_wrapped())


class AttributeErrorBuiltin(unittest.TestCase):
def attributeerror_function(self):
lst = [1, 2, 3]
lst.max()

@didyoumean
def attributeerror_function_wrapped(self):
return self.attributeerror_function()

def test_original(self):
self.assertRaisesRegex(AttributeError, "^'[^']*' object has no attribute '[^']*'$", lambda: self.attributeerror_function())

def test_wrapped(self):
self.assertRaisesRegex(AttributeError, "^'[^']*' object has no attribute '[^']*'. Did you mean max\(list\)$", lambda: self.attributeerror_function_wrapped())


class AttributeErrorMethod(unittest.TestCase):
def attributeerror_function(self):
lst = [1, 2, 3]
lst.appendh(4)

@didyoumean
def attributeerror_function_wrapped(self):
return self.attributeerror_function()

def test_original(self):
self.assertRaisesRegex(AttributeError, "^'[^']*' object has no attribute '[^']*'$", lambda: self.attributeerror_function())

def test_wrapped(self):
self.assertRaisesRegex(AttributeError, "^'[^']*' object has no attribute '[^']*'. Did you mean append*$", lambda: self.attributeerror_function_wrapped())
@classmethod
def nameerror_cls(cls):
"""Should be cls.this_is_cls_mthd."""
return this_is_cls_mthd


def function_caller(name):
"""Dirty function to call test function without bothering about arguments
or instances."""
if name == 'nameerror_1_arg':
return nameerror_1_arg(1)
if name == 'nameerror_n_args':
return nameerror_n_args(1, 2, 3)
if name == 'nameerror_builtin':
return nameerror_builtin()
if name == 'nameerror_no_sugg':
return nameerror_no_sugg()
if name == 'nameerror_import_sugg':
return nameerror_import_sugg()
if name == 'nameerror_self':
return FoobarClass().nameerror_self()
if name == 'nameerror_self2':
return FoobarClass().nameerror_self2()
if name == 'nameerror_cls':
return FoobarClass().nameerror_cls()
if name == 'attributeerror_builtin':
return attributeerror_builtin()
if name == 'attributeerror_method':
return attributeerror_method()
if name == 'attributeerror_no_sugg':
return attributeerror_no_sugg()


@didyoumean
def function_caller_deco(name):
"""Wrapper around function_caller with a didyoumean decorator."""
return function_caller(name)


class AbstractTests(unittest.TestCase):
"""Generic class for unit tests."""

def run_input(self, name, sugg):
"""Helper function to run tests."""
name = self.error_prefix + '_' + name
self.assertRaisesRegex(
self.error_type,
self.error_msg + "$",
lambda: function_caller(name))
self.assertRaisesRegex(
self.error_type,
self.error_msg + sugg + "$",
lambda: function_caller_deco(name))


class NameErrorTests(AbstractTests):
"""Class for tests related to NameError."""
error_type = NameError
error_msg = "^(global )?name '[^']*' is not defined"
error_prefix = 'nameerror'

def test_1_arg(self):
self.run_input('1_arg', ". Did you mean foo")

def test_n_args(self):
self.run_input('n_args', ". Did you mean foot, fool")

def test_builtin(self):
self.run_input('builtin', ". Did you mean max")

def test_no_sugg(self):
self.run_input('no_sugg', "")

def test_import_sugg(self):
self.run_input('import_sugg', ". Did you mean import functools")

def test_self(self):
self.run_input('self', ". Did you mean self.foo")

def test_self2(self):
self.run_input('self2', ". Did you mean self.this_is_cls_mthd")

def test_cls(self):
self.run_input('cls', ". Did you mean cls.this_is_cls_mthd")


class AttributeErrorTest(AbstractTests):
"""Class for tests related to AttributeError."""
error_type = AttributeError
error_msg = "^'[^']*' object has no attribute '[^']*'"
error_prefix = 'attributeerror'

def test_method(self):
self.run_input('method', ". Did you mean append")

def test_builtin(self):
self.run_input('builtin', ". Did you mean max\\(list\\)")

def test_no_sugg(self):
self.run_input('no_sugg', "")

0 comments on commit 591d52b

Please sign in to comment.