[Django]-Django test coverage vs code coverage

since you use django-nose you have two options on how to run coverage. The first was already pointed out by DaveB:

coverage run ./manage.py test myapp

The above actually runs coverage which then monitors all code executed by the test command.

But then, there is also a nose coverage plugin included by default in the django-nose package (http://nose.readthedocs.org/en/latest/plugins/cover.html). You can use it like this:

./manage.py test myapp --with-coverage

(There are also some additional options like which modules should be covered, whether to include an html report or not etc . These are all documented in the above link – you can also type ./manage.py test --help for some quick info).

Running the nose coverage plugin will result in coverage running after the django bootstrapping code is executed and therefore the corresponding code will not be reported as covered.

Most of the code you see reported as covered when running coverage the original way, are import statements, class definitions, class members etc. As python evaluates them during import time, coverage will naturally mark them as covered. However, running the nose plugin will not report bootstrapping code as covered since the test runner starts after the django environment is loaded. Of course, a side effect of this is you can never achieve 100% coverage (…or close :)) as your global scope statements will never get covered.

After switching back and forth and playing around with coverage options, I now have ended up using coverage like this:

coverage run --source=myapp,anotherapp --omit=*/migrations/* ./manage.py test

so that

a. coverage will report import statements, class member definitions etc as covered (which is actually the truth – this code was successfully imported and interpreted)

b. it will only cover my code and not django code, or any other third-party app I use; The coverage percentage will reflect how well my project is covered.

Hope this helps!

The “Ok, start counting reached code here.” can be done through the API of the coverage module. You can check this out through the shell. Stole directly from http://nedbatchelder.com/code/coverage/api.html:

import coverage

cov = coverage.coverage()
cov.start()

# .. call your code ..

cov.stop()
cov.save()

cov.html_report()

You can make your own test-runner to do this exactly to match your needs (some would consider coverage made from any unit-test to be OK, and others would only accept the coverage of a unit caused by the unit-test for that unit.)

I had the same issue. I saved some time by creating a .coveragerc file that specified options similar to those outlined in the bounty-awarded answer.

Now running ‘coverage run manage.py test’ and then ‘coverage report -m’ will show me the coverage report and the lines that aren’t covered.

(See here for details on the .coveragerc file: http://nedbatchelder.com/code/coverage/config.html)

I’m a bit confused by what you are trying to achieve here.

Testing in Django is covered very well here: https://docs.djangoproject.com/en/dev/topics/testing/overview/

You write tests in your app as test.py – I don’t see the need for nose, as the standard django way is pretty simple.

Then run them as coverage run ./manage.py test main – where ‘main’ is your app

Specify the source files for your code as documented here: http://nedbatchelder.com/code/coverage/cmd.html so that only your code is counted

e.g. coverage run –source=main ./manage.py test main

You’ll still get a certain percentage marked as covered with the simple test provided as an example. This is because parts of your code are executed in order to start up the server e.g definitions in modules etc.