nose2.util

nose2.util.call_with_args_if_expected(func, *args)

Take :func: and call it with supplied :args:, in case that signature expects any. Otherwise call the function without any arguments.

nose2.util.ensure_importable(dirname)

Ensure a directory is on sys.path.

nose2.util.exc_info_to_string(err, test)

Format exception info for output

nose2.util.format_traceback(test, err)

Converts a sys.exc_info() -style tuple of values into a string.

nose2.util.has_module_fixtures(test)

Does this test live in a module with module fixtures?

nose2.util.ispackage(path)

Is this path a package directory?

nose2.util.ln(label, char='-', width=70)

Draw a divider, with label in the middle.

>>> ln('hello there')
'---------------------------- hello there -----------------------------'

width and divider char may be specified. Defaults are 70 and '-', respectively.

nose2.util.module_from_name(name)

Import module from name

nose2.util.name_from_args(name, index, args)

Create test name from test args

nose2.util.name_from_path(path)

Translate path into module name

Returns a two-element tuple:

1. a dotted module name that can be used in an import statement (e.g., pkg1.test.test_things)

2. a full path to filesystem directory, which must be on sys.path for the import to succeed.

nose2.util.num_expected_args(func)

Return the number of arguments that :func: expects

nose2.util.object_from_name(name, module=None)

Given a dotted name, return the corresponding object.

Getting the object can fail for two reason:

• the object is a module that cannot be imported.

• the object is a class or a function that does not exists.

Since we cannot distinguish between these two cases, we assume we are in the first one. We expect the stacktrace is explicit enough for the user to understand the error.

nose2.util.parse_log_level(lvl)

Return numeric log level given a string

nose2.util.safe_decode(string)

Safely decode a byte string into unicode

nose2.util.test_from_name(name, module)

Import test from name

nose2.util.transplant_class(cls, module)

Make cls appear to reside in module.

Parameters:

• cls – A class

• module – A module name

Returns:

A subclass of cls that appears to have been defined in module.

The returned class’s __name__ will be equal to cls.__name__, and its __module__ equal to module.

nose2.util.try_import_module_from_name(splitted_name)

Try to find the longest importable from the splitted_name, and return the corresponding module, as well as the potential ImportError exception that occurs when trying to import a longer name.

For instance, if splitted_name is [‘a’, ‘b’, ‘c’] but only a.b is importable, this function:

1. tries to import a.b.c and fails

2. tries to import a.b and succeeds

3. return a.b and the exception that occurred at step 1.

nose2.util.valid_module_name(path)

Is path a valid module name?