Running unittest with modules that must import other modules

Here is how I have gone about trying to solve this.

I exported the PYTHONPATH to the repo folder repoName (I am using linux)

cd repoName
export PYTHONPATH=`pwd`

then in test_example.py

import unittest

class test_third(unittest.TestCase):

  def test_doThree(self):
    from app.third import third # changed here
    num3 = third()
    num3.doThree()
    self.assertTrue(True)

if __name__ == '__main__':
    unittest.main()

Then in third.py

print('inside third.py')
import app.second as second # changed here

class third:

  def __init__(self):  
    pass

  #@public
  def doThree(self):
    print("jonesy is: ", second.inputVars.get('jonesy'))

Also it is worth noting that I did not create any __init__.py files

The code in the question relies on first.py being imported so it calls a function in second.py to set a global that is used by third.py. As the Zen Of Python says:

Explicit is better than implicit

The current structure will be difficult to maintain, test, and debug as your project grows. I have redone the example in the question removing globals and code being executed on import.

first.py

import sys

from app import second
from app.third import Third


def run_commands(input_args):
    trd = Third()
    if input_args.another == "on":
        trd.do_three(input_args)


def main():
    input_args = second.process_input_args(sys.argv)
    run_commands(input_args)


if __name__ == "__main__":
    main()

second.py

from dataclasses import dataclass


@dataclass
class InputArgs:
    something: str
    another: str
    jonesy: str


def process_input_args(input_args):
    something = "platform"
    another = "on"
    jonesy = "go"
    return InputArgs(something, another, jonesy)

third.py

import sys

print("inside third.py")


class Third:
    def __init__(self):
        pass

    # @public
    def do_three(self, input_args):
        print("jonesy is: ", input_args.jonesy)

test_example.py

import io
import unittest
from unittest import mock

from app.second import InputArgs
from app.third import Third


class ThirdTests(unittest.TestCase):
    def test_doThree(self):
        input_args = InputArgs(something="platform",
                               another="on",
                               jonesy="go")

        num3 = Third()
        with unittest.mock.patch('sys.stdout', new=io.StringIO()) as fake_out:
            num3.do_three(input_args)
            self.assertEqual("jonesy is:  gon", fake_out.getvalue())


if __name__ == "__main__":
    unittest.main()

For Python development I would always recommend having a Python Virtual Environment (venv) so that each repo’s development is isolated.

In the repoName directory do (for Linux):

python3.10 -m venv venv

Or like the following for windows:

c:>c:Python310python -m venv venv

You will then need to activate the venv.

Linux: . venv/bin/activate

Windows: .venvscriptsactivate.ps1

I would suggest packaging the app as your module then all your imports will be of the style:

from app.third import third
trd = third()

or

from app import third
trd = third.third()

To package app create a setup.py file in the repoName directory. The file will look something like this:

from setuptools import setup

setup(
    name='My App',
    version='1.0.0',
    url='https://github.com/mypackage.git',
    author='Author Name',
    author_email='[email protected]',
    description='Description of my package',
    packages=['app'],
    install_requires=[],
    entry_points={
        'console_scripts': ['my-app=app.first:main'],
    },
)

I would also rename the unitTests directory to something like tests so that the unittest module can find it automatically as it looks for files and directories starting with test.

So a structure something like this:

repoName/
├── app
│   ├── __init__.py
│   ├── first.py
│   ├── second.py
│   └── third.py
├── setup.py
├── tests
│   ├── __init__.py
│   └── test_example.py
└── venv

You can now do pip install to install from a local src tree in development mode. The great thing about this is that you don’t have to mess with the python path or sys.path.

(venv) repoName $ pip install -e .
Obtaining file:///home/user/projects/repoName
  Preparing metadata (setup.py) ... done
Installing collected packages: My-App
  Running setup.py develop for My-App
Successfully installed My-App-1.0.0

With the install done the app can be launched:

(venv) repoName $ python app/first.py
inside app __init__.py
inside third.py
jonesy is:  go

In the setup file we told python that my-app was an entry point so we can use this to launch the same thing:

(venv) repoName $ my-app 
inside app __init__.py
inside third.py
jonesy is:  go

For the unittests we can use the following command and it will discover all the tests because we have used test to start directory and file names.

(venv) repoName $ python -m unittest 
inside app __init__.py
inside unit-tests __init__.py
inside third.py
jonesy is:  go
.
----------------------------------------------------------------------
Ran 1 test in 0.000s

OK

Now we have this setup it is easy to package up app for distribution. Either directly to users or via a Package Index like https://pypi.org/

Install the build module:

(venv) repoName $ pip install --upgrade build

To build the Python wheel:

(venv) repoName $ python build

There should now be a dist folder with a wheel in it which you can send to users. They can install this with pip:

pip install My_App-1.0.0-py3-none-any.whl