Man Linux: Main Page and Category List

NAME

       nosetests - nicer testing for python

SYNOPSIS

       nosetests [options] [names]

DESCRIPTION

       nose collects tests automatically from python source files, directories
       and packages found in its working  directory  (which  defaults  to  the
       current  working  directory).  Any  python  source  file,  directory or
       package that matches the  testMatch  regular  expression  (by  default:
       (?:^|[b_.-])[Tt]est)  will  be  collected  as  a  test  (or  source for
       collection of tests). In addition, all  other  packages  found  in  the
       working   directory  will  be  examined  for  python  source  files  or
       directories that match testMatch. Package discovery  descends  all  the
       way   down   the  tree,  so  package.tests  and  package.sub.tests  and
       package.sub.sub2.tests will all be collected.

       Within a test directory or package, any  python  source  file  matching
       testMatch  will  be  examined  for  test  cases.  Within a test module,
       functions  and  classes  whose  names  match  testMatch  and   TestCase
       subclasses  with  any  name will be loaded and executed as tests. Tests
       may use the assert keyword or raise AssertionErrors  to  indicate  test
       failure.  TestCase  subclasses  may  do  the  same  or  use the various
       TestCase methods available.

   Selecting Tests
       To specify which tests to run, pass test names on the command line:

       nosetests only_test_this.py
       Test names specified may be file or module names,  and  may  optionally
       indicate  the  test  case  to run by separating the module or file name
       from the test case name with a colon.  Filenames  may  be  relative  or
       absolute. Examples:

       nosetests test.module
       nosetests another.test:TestCase.test_method
       nosetests a.test:TestCase
       nosetests /path/to/test/file.py:test_function
       You may also change the working directory where nose looks for tests by
       using the -w switch:

       nosetests -w /path/to/tests
       Note, however, that support for multiple -w arguments is now deprecated
       and  will  be removed in a future release. As of nose 0.10, you can get
       the same behavior by specifying the target directories without  the  -w
       switch:

       nosetests /path/to/tests /another/path/to/tests
       Further customization of test selection and loading is possible through
       the use of plugins.

       Test result output is identical to that of  unittest,  except  for  the
       additional  features  (error classes, and plugin-supplied features such
       as output capture and assert introspection)  detailed  in  the  options
       below.

   Configuration
       In   addition  to  passing  command-line  options,  you  may  also  put
       configuration options in a  .noserc  or  nose.cfg  file  in  your  home
       directory.  These  are  standard  .ini-style  config  files.  Put  your
       nosetests configuration in a [nosetests] section. Options are the  same
       as  on  the  command line, with the -- prefix removed. For options that
       are simple switches, you must supply a value:

       [nosetests]
       verbosity=3
       with-doctest=1
       All configuration files that are found will be loaded and their options
       combined.

   Using Plugins
       There   are  numerous  nose  plugins  available  via  easy_install  and
       elsewhere. To use a plugin,  just  install  it.  The  plugin  will  add
       command  line  options  to  nosetests.  To  verify  that  the plugin is
       installed, run:

       nosetests --plugins
       You can add -v or -vv to that command to show  more  information  about
       each plugin.

       If  you  are  running  nose.main() or nose.run() from a script, you can
       specify a list of plugins to use by passing a list of plugins with  the
       plugins keyword argument.

   0.9 plugins
       nose  0.11  can  use  SOME  plugins that were written for nose 0.9. The
       default plugin manager  inserts  a  compatibility  wrapper  around  0.9
       plugins that adapts the changed plugin api calls. However, plugins that
       access nose internals are likely to fail, especially if they attempt to
       access  test  case or test suite classes. For example, plugins that try
       to determine if a test passed to startTest is an individual test  or  a
       suite  will  fail,  partly  because  suites  are  no  longer  passed to
       startTest and partly because it´s likely that the plugin is  trying  to
       find out if the test is an instance of a class that no longer exists.

   0.10 plugins
       All plugins written for nose 0.10 should work with nose 0.11.

   Options
       -V, --version
              Output nose version and exit

       -p, --plugins
              Output  list  of available plugins and exit. Combine with higher
              verbosity for greater detail

       -v=DEFAULT, --verbose=DEFAULT
              Be more verbose. [NOSE_VERBOSE]

       --verbosity=VERBOSITY
              Set verbosity; --verbosity=2 is the same as -v

       -q=DEFAULT, --quiet=DEFAULT
              Be less verbose

       -c=FILES, --config=FILES
              Load  configuration  from  config  file(s).  May  be   specified
              multiple  times;  in  that case, all config files will be loaded
              and combined

       -w=WHERE, --where=WHERE
              Look for tests in this  directory.  May  be  specified  multiple
              times.  The  first  directory passed will be used as the working
              directory, in place of the current working directory,  which  is
              the  default.  Others  will  be  added  to  the list of tests to
              execute. [NOSE_WHERE]

       -m=REGEX, --match=REGEX, --testmatch=REGEX
              Files, directories, function names, and class names  that  match
              this   regular   expression   are  considered  tests.   Default:
              (?:^|[b_./-])[Tt]est [NOSE_TESTMATCH]

       --tests=NAMES
              Run these tests (comma-separated list). This argument is  useful
              mainly  from configuration files; on the command line, just pass
              the tests to run as additional arguments with no switch.

       -l=DEFAULT, --debug=DEFAULT
              Activate debug logging for one or more systems. Available  debug
              loggers:   nose,  nose.importer,  nose.inspector,  nose.plugins,
              nose.result and nose.selector. Separate multiple  names  with  a
              comma.

       --debug-log=FILE
              Log debug messages to this file (default: sys.stderr)

       --logging-config=FILE, --log-config=FILE
              Load logging config from this file -- bypasses all other logging
              config settings.

       -e=REGEX, --exclude=REGEX
              Don´t run tests that match regular expression [NOSE_EXCLUDE]

       -i=REGEX, --include=REGEX
              This regular expression will be applied to  files,  directories,
              function  names,  and  class  names  for  a  chance  to  include
              additional tests that do  not  match  TESTMATCH.   Specify  this
              option   multiple   times   to   add  more  regular  expressions
              [NOSE_INCLUDE]

       -x, --stop
              Stop running tests after the first error or failure

       -P, --no-path-adjustment
              Don´t  make  any  changes  to  sys.path   when   loading   tests
              [NOSE_NOPATH]

       --exe  Look  for  tests  in  python modules that are executable. Normal
              behavior is to exclude executable modules, since they may not be
              import-safe [NOSE_INCLUDE_EXE]

       --noexe
              DO  NOT  look  for  tests in python modules that are executable.
              (The default on the windows platform is to do so.)

       --traverse-namespace
              Traverse through all path entries of a namespace package

       --first-package-wins=DEFAULT,                 --first-pkg-wins=DEFAULT,
       --1st-pkg-wins=DEFAULT
              nose´s importer will normally evict a package  from  sys.modules
              if it sees a package with the same name in a different location.
              Set this option to disable that behavior.

       -a=ATTR, --attr=ATTR
              Run  only  tests  that  have  attributes   specified   by   ATTR
              [NOSE_ATTR]

       -A=EXPR, --eval-attr=EXPR
              Run  only  tests for whose attributes the Python expression EXPR
              evaluates to True [NOSE_EVAL_ATTR]

       -s, --nocapture
              Don´t  capture  stdout  (any  stdout  output  will  be   printed
              immediately) [NOSE_NOCAPTURE]

       --nologcapture
              Disable  logging  capture  plugin.  Logging configurtion will be
              left intact. [NOSE_NOLOGCAPTURE]

       --logging-format=FORMAT
              Specify custom format to print statements. Uses the same  format
              as used by standard logging handlers. [NOSE_LOGFORMAT]

       --logging-datefmt=FORMAT
              Specify  custom  date/time  format to print statements. Uses the
              same   format   as   used   by   standard   logging    handlers.
              [NOSE_LOGDATEFMT]

       --logging-filter=FILTER
              Specify   which   statements   to  filter  in/out.  By  default,
              everything is captured. If the output is too verbose,  use  this
              option  to filter out needless output.  Example: filter=foo will
              capture statements issued ONLY to
               foo or  foo.what.ever.sub  but  not  foobar  or  other  logger.
              Specify   multiple   loggers   with  comma:  filter=foo,bar,baz.
              [NOSE_LOGFILTER]

       --logging-clear-handlers
              Clear all other logging handlers

       --with-coverage
              Enable plugin Coverage: Activate a  coverage  report  using  Ned
              Batchelder´s coverage module.
               [NOSE_WITH_COVERAGE]

       --cover-package=PACKAGE
              Restrict     coverage     output     to     selected    packages
              [NOSE_COVER_PACKAGE]

       --cover-erase
              Erase previously collected coverage statistics before run

       --cover-tests
              Include test modules in coverage report [NOSE_COVER_TESTS]

       --cover-inclusive
              Include all python files under  working  directory  in  coverage
              report.   Useful  for  discovering holes in test coverage if not
              all files are imported by the test suite. [NOSE_COVER_INCLUSIVE]

       --cover-html
              Produce HTML coverage information

       --cover-html-dir=DIR
              Produce HTML coverage information in dir

       --pdb  Drop into debugger on errors

       --pdb-failures
              Drop into debugger on failures

       --no-deprecated
              Disable special handling of DeprecatedTest exceptions.

       --with-doctest
              Enable  plugin  Doctest: Activate doctest plugin to find and run
              doctests in non-test modules.
               [NOSE_WITH_DOCTEST]

       --doctest-tests
              Also look for doctests  in  test  modules.  Note  that  classes,
              methods and functions should have either doctests or non-doctest
              tests, not both. [NOSE_DOCTEST_TESTS]

       --doctest-extension=EXT
              Also  look  for  doctests   in   files   with   this   extension
              [NOSE_DOCTEST_EXTENSION]

       --doctest-result-variable=VAR
              Change  the  variable  name  set  to  the  result  of  the  last
              interpreter command from the default ´_´. Can be used  to  avoid
              conflicts  with  the  _()  function  used  for text translation.
              [NOSE_DOCTEST_RESULT_VAR]

       --doctest-fixtures=SUFFIX
              Find fixtures for a  doctest  file  in  module  with  this  name
              appended to the base name of the doctest file

       --with-isolation
              Enable  plugin IsolationPlugin: Activate the isolation plugin to
              isolate changes to external modules to a single test  module  or
              package. The isolation plugin resets the contents of sys.modules
              after each test module or package runs to its state  before  the
              test.  PLEASE  NOTE that this plugin should not be used with the
              coverage plugin, or in any other case where module reloading may
              produce undesirable side-effects.
               [NOSE_WITH_ISOLATION]

       -d, --detailed-errors, --failure-detail
              Add  detail  to  error  output  by attempting to evaluate failed
              asserts [NOSE_DETAILED_ERRORS]

       --with-profile
              Enable plugin Profile: Use this plugin to run  tests  using  the
              hotshot profiler.
               [NOSE_WITH_PROFILE]

       --profile-sort=SORT
              Set sort order for profiler output

       --profile-stats-file=FILE
              Profiler stats file; default is a new temp file on each run

       --profile-restrict=RESTRICT
              Restrict profiler output. See help for pstats.Stats for details

       --no-skip
              Disable special handling of SkipTest exceptions.

       --with-id
              Enable  plugin  TestId:  Activate  to add a test id (like #1) to
              each test name output. Activate with --failed to  rerun  failing
              tests only.
               [NOSE_WITH_ID]

       --id-file=FILE
              Store  test  ids found in test runs in this file. Default is the
              file .noseids in the working directory.

       --failed
              Run the tests that failed in the last test run.

       --processes=NUM
              Spread test run among this many processes. Set a number equal to
              the  number  of  processors  or  cores  in your machine for best
              results. [NOSE_PROCESSES]

       --process-timeout=SECONDS
              Set timeout for return of results from each test runner process.
              [NOSE_PROCESS_TIMEOUT]

       --with-xunit
              Enable  plugin  Xunit:  This plugin provides test results in the
              standard XUnit XML format. [NOSE_WITH_XUNIT]

       --xunit-file=FILE
              Path to xml file to  store  the  xunit  report  in.  Default  is
              nosetests.xml in the working directory [NOSE_XUNIT_FILE]

       --all-modules
              Enable plugin AllModules: Collect tests from all python modules.
               [NOSE_ALL_MODULES]

       --collect-only
              Enable collect-only: Collect and output test names  only,  don´t
              run any tests.
               [COLLECT_ONLY]

AUTHOR

       jpellerin+nose@gmail.com

COPYRIGHT

       LGPL