As your project grows, you will find that unittests test your code much better.
The Django project itself converts all doctrines into unittests (this will be done in version 1.3). The reason we do this is that before this conversion, the execution order in the test suite sometimes led to serious error reproduction. Sometimes a bit of code would accidentally depend on previously run doctrine code. In addition, switching to unittests speeds up the overall testing time, as we can more intelligently find out how and when we clear the database.
Another advantage of unittests is that they are MORE easier to maintain. Since the entire test script is self-contained, you either write another test case or modify a small target test function.
Doctests tend to work by evolution - you get a copy of your widget, add green fur, make sure the fur is green, add 4 legs, make sure you have 4 legs and green fur, add the thumb, make sure you have thumb, 4 legs and green fur, etc. This means that if you want to add a test immediately after the green fur stage, you need to change the expected results for each subsequent test.
You don't want to do all this rewriting, so you add your new test at the end. Then you add another one, and then after a while your tests are so hopelessly mixed up that you cannot figure out if any feature is even tested! With unittests, since each test embodies a specific, specific, and limited idea, it is much easier to re-order the tests logically and add a new test that is independent of all previous ones. In addition, if you change the way add_green_fur() works, you do not need to change dozens of test case results.
Another advantage is that unittests (when well written) tells you exactly where your code failed. Failed: MyWidget.tests.test_green_fur() much easier to debug than the "widget test failed on line 384", which is often tens to hundreds of lines from the actual point of failure.
In general, unittests are the best way to test.
Edit:
In response to your colleague's idea, I respectfully believe that he did not work on a major project with many doctrines. Doctests in models are just as bad as in views. They have exactly the same problems (although, if anything, the teachings are worse in models because flush is very expensive and absolutely necessary for careful study). Do not underestimate the cost of the time taken to complete the tests.
Also, do not mix your test types unless you have a VERY good reason for this. If you do this, you will very quickly find that you will double the tests or think that the function is tested in any test suite that you are not looking at.
Doctests are often touted as "providing documentation" on how your code should work. This is good, but it is not a substitute for reading readable code with good legible inline comments. If you want additional documentation, write it separately!
You cannot write good tests, which also serve as good documentation.