Integration Tests

### Navigation

- index
- modules |
- next |
- previous |
- « SaltStack.org |
- Documentation home

# Integration Tests

The Salt integration tests come with a number of classes and methods which allow for components to be easily tested. These classes are generally inherited from and provide specific methods for hooking into the running integration test environment created by the integration tests.

It is noteworthy that since integration tests validate against a running environment that they are generally the preferred means to write tests.

The integration system is all located under tests/integration in the Salt source tree.

## Integration Classes

The integration classes are located in tests/integration/__init__.py and can be extended therein. There are three classes available to extend:

### ModuleCase

Used to define executions run via the master to minions and to call single modules and states.

The available methods are as follows:

run_function:
  Run a single salt function and condition the return down to match the behavior of the raw function call. This will run the command and only return the results from a single minion to verify.
state_result:
  Return the result data from a single state return
run_state:
  Run the state.single command and return the state return structure

### SyndicCase

Used to execute remote commands via a syndic, only used to verify the capabilities of the Syndic.

The available methods are as follows:

run_function:
  Run a single salt function and condition the return down to match the behavior of the raw function call. This will run the command and only return the results from a single minion to verify.

### ShellCase

Shell out to the scripts which ship with Salt.

The available methods are as follows:

run_script:
  Execute a salt script with the given argument string
run_salt:
  Execute the salt command, pass in the argument string as it would be passed on the command line.
run_run:
  Execute the salt-run command, pass in the argument string as it would be passed on the command line.
run_run_plus:
  Execute Salt run and the salt run function and return the data from each in a dict
run_key:
  Execute the salt-key command, pass in the argument string as it would be passed on the command line.
run_cp:
  Execute salt-cp, pass in the argument string as it would be passed on the command line.
run_call:
  Execute salt-call, pass in the argument string as it would be passed on the command line.

## Examples

### Module Example via ModuleCase Class

Import the integration module, this module is already added to the python path by the test execution. Inherit from the `integration.ModuleCase` class. The tests that execute against salt modules should be placed in the tests/integration/modules directory so that they will be detected by the test system.

Now the workhorse method `run_function` can be used to test a module:

    import os
    import integration

    class TestModuleTest(integration.ModuleCase):
        '''
        Validate the test module
        '''
        def test_ping(self):
            '''
            test.ping
            '''
            self.assertTrue(self.run_function('test.ping'))

        def test_echo(self):
            '''
            test.echo
            '''
            self.assertEqual(self.run_function('test.echo', ['text']), 'text')

ModuleCase can also be used to test states, when testing states place the test module in the tests/integration/states directory. The `state_result` and the `run_state` methods are the workhorse here:

    import os
    import shutil
    import integration

    HFILE = os.path.join(integration.TMP, 'hosts')

    class HostTest(integration.ModuleCase):
        '''
        Validate the host state
        '''

        def setUp(self):
            shutil.copyfile(os.path.join(integration.FILES, 'hosts'), HFILE)
            super(HostTest, self).setUp()

        def tearDown(self):
            if os.path.exists(HFILE):
                os.remove(HFILE)
            super(HostTest, self).tearDown()

        def test_present(self):
            '''
            host.present
            '''
            name = 'spam.bacon'
            ip = '10.10.10.10'
            ret = self.run_state('host.present', name=name, ip=ip)
            result = self.state_result(ret)
            self.assertTrue(result)
            with open(HFILE) as fp_:
                output = fp_.read()
                self.assertIn('{0}\t\t{1}'.format(ip, name), output)

The above example also demonstrates using the integration files and the integration state tree. The variable integration.FILES will point to the directory used to store files that can be used or added to to help enable tests that require files. The location integration.TMP can also be used to store temporary files that the test system will clean up when the execution finishes.

The integration state tree can be found at tests/integration/files/file/base. This is where the referenced host.present sls file resides.

### Shell Example via ShellCase

Validating the shell commands can be done via shell tests. Here are some examples:

    import sys
    import shutil
    import tempfile

    import integration

    class KeyTest(integration.ShellCase):
        '''
        Test salt-key script
        '''

        _call_binary_ = 'salt-key'

        def test_list(self):
            '''
            test salt-key -L
            '''
            data = self.run_key('-L')
            expect = [
                    'Unaccepted Keys:',
                    'Accepted Keys:',
                    'minion',
                    'sub_minion',
                    'Rejected:', '']
            self.assertEqual(data, expect)

This example verifies that the `salt-key` command executes and returns as expected by making use of the `run_key` method.

All shell tests should be placed in the tests/integraion/shell directory.

## Comments

comments powered by Disqus

### Navigation

- index
- modules |
- next |
- previous |
- « SaltStack.org |
- Documentation home