예제 #1
0
class PhonebookTestCase(unittest.TestCase):
    def setUp(self):
        self.env = TestFileEnvironment('./scratch')
        self.prefix = os.getcwd()
        
        # load phonebook fixture. Need to use separate name to prevent
        # overwriting actual file.
        with open('phonebook_fixture.txt') as f:
            with open('phonebook_fixture.pb', 'wb') as phonebook_fixture:
                for line in f:
                    phonebook_fixture.write(line)

    def tearDown(self):
        os.remove('phonebook_fixture.pb')

    # helper methods for ensuring things were/weren't added to files.
    def assert_not_added(self, entry_fields):
        result = self.env.run('cat %s/phonebook_fixture.pb' % self.prefix)
        for value in entry_fields:
            nose.tools.assert_not_in(value, result.stdout)

    def assert_added(self, entry_fields):
        result = self.env.run('cat %s/phonebook_fixture.pb' % self.prefix)
        for value in entry_fields:
            nose.tools.assert_in(value, result.stdout)
예제 #2
0
파일: test.py 프로젝트: brodul/githook
class CLITest(unittest.TestCase):

    def setUp(self):
        import githook

        self.githook = githook
        self.githook.app.config['TESTING'] = True

        self.tempdir = tempfile.mkdtemp()
        self.env = TestFileEnvironment(
            os.path.join(self.tempdir,'test-output'),
            ignore_hidden=False)

    @unittest.skipIf(*is_travis)
    def test_no_config(self):
        result = self.env.run('bin/python %s' % os.path.join(here, "..", "__init__.py"),
            expect_error=True,
            cwd=os.path.join(here, '../', '../')
        )
        self.assertEqual(result.returncode, 1)
        self.assertEqual(result.stderr, u'CRITICAL:root:Configuration file not found. Please specify one.\n')

    # TODO This loops. :D Need another way of testing daemons.
    @unittest.skipIf(True, 'It loops')
    def test_ok_config(self):
        self.env.run('bin/python -m githook -c githook/tests/config/okconfig.ini',
            cwd=os.path.join(here, '../', '../')
        )
예제 #3
0
파일: test.py 프로젝트: Drey/csv2ofx
def main():
    """ Main method
    Returns 0 on success, 1 on failure
    """
    start = timer()
    script = 'bin/csv2ofx --help'
    env = TestFileEnvironment('.scripttest')
    tmpfile = NamedTemporaryFile(dir=parent_dir, delete=False)
    tmpname = tmpfile.name

    tests = [
        (2, 'default.csv', 'default.qif', 'oq'),
        (3, 'default.csv', 'default_w_splits.qif', 'oqS Category'),
        (4, 'xero.csv', 'xero.qif', 'oqc Description -m xero'),
        (5, 'mint.csv', 'mint.qif', 'oqS Category -m mint'),
        (
            6, 'mint.csv', 'mint_alt.qif',
            'oqs20150613 -e20150614 -S Category -m mint'
        ),
        (7, 'default.csv', 'default.ofx', 'oe 20150908'),
        (8, 'default.csv', 'default_w_splits.ofx', 'oS Category'),
        (9, 'mint.csv', 'mint.ofx', 'oS Category -m mint'),
    ]

    try:
        env.run(script, cwd=parent_dir)
        print('\nScripttest #1: %s ... ok' % script)

        for test_num, example_filename, check_filename, opts in tests:
            example = p.join(example_dir, example_filename)
            check = p.join(check_dir, check_filename)
            checkfile = open(check)

            script = 'bin/csv2ofx -%s %s %s' % (opts, example, tmpname)
            env.run(script, cwd=parent_dir)
            args = [checkfile.readlines(), open(tmpname).readlines()]
            kwargs = {'fromfile': 'expected', 'tofile': 'got'}
            diffs = list(unified_diff(*args, **kwargs))

            if diffs:
                loc = ' '.join(script.split(' ')[:-1])
                msg = "ERROR from test #%i! Output:\n\t%s\n" % (test_num, loc)
                msg += "doesn't match hash of\n\t%s\n" % check
                sys.stderr.write(msg)
                sys.exit(''.join(diffs))
            else:
                short_script = 'csv2ofx -%s %s %s' % (
                    opts, example_filename, check_filename)

                print('Scripttest #%i: %s ... ok' % (test_num, short_script))
    except Exception as e:
        sys.exit(e)
    else:
        time = timer() - start
        print('%s' % '-' * 70)
        print('Ran %i scripttests in %0.3fs\n\nOK' % (test_num, time))
        sys.exit(0)
    finally:
        checkfile.close
        os.unlink(tmpname)
예제 #4
0
    def get_env(self, check_help_version=True):
        #import tempfile
        #env = TestFileEnvironment(tempfile.mkdtemp(suffix='', prefix='test_' + script))
        env = TestFileEnvironment()

        # Use Agg backend for plots.
        #env.writefile("matplotlibrc", "backend: Agg")
        #with open(os.path.join(env.base_path, "matplotlibrc"), "wt") as fh:
        #    fh.write("backend: Agg\n")

        if check_help_version:
            # Start with --help. If this does not work...
            r = env.run(self.script, "--help", expect_stderr=self.expect_stderr)
            assert r.returncode == 0

            # Script must provide a version option
            r = env.run(self.script, "--version", expect_stderr=self.expect_stderr)
            assert r.returncode == 0
            print("stderr", r.stderr)
            print("stdout", r.stdout)
            verstr = r.stdout.strip()
            # deprecation warnings break --version
            #if not verstr: verstr = r.stdout.strip()  # py3k
            #assert str(verstr) == str(abilab.__version__)

        return env
예제 #5
0
def test_stop_service_minimal_docker_container():
    env = ScriptTestEnvironment()
    env.run('ansible-container', 'run', '--detached', cwd=project_dir('minimal_sleep'), expect_stderr=True)
    result = env.run('ansible-container', 'stop', 'minimal1',
                     cwd=project_dir('minimal_sleep'), expect_stderr=True)
    assert "Stopping ansible_minimal1_1 ... done" in result.stderr
    assert "Stopping ansible_minimal2_1 ... done" not in result.stderr
예제 #6
0
def test_setting_ansible_container_envar():
    env = ScriptTestEnvironment()
    result = env.run('ansible-container', '--debug', 'build',
                     cwd=project_dir('environment'), expect_stderr=True)
    assert "web MYVAR=foo ANSIBLE_CONTAINER=1" in result.stdout
    assert "db MYVAR=foo ANSIBLE_CONTAINER=1" in result.stdout
    assert "mw ANSIBLE_CONTAINER=1" in result.stdout
예제 #7
0
class TestBasicCommands(TestCase):
    """Test basic command-line invoke of the program"""
    def setUp(self):
        self.env = TestFileEnvironment('./test-output')

    def test_default(self):
        res = self.env.run('../run.py', '-s', '1')
        assert 'Timeout' in res.stdout
        self.assertEqual(res.returncode, 0)

    def test_collect(self):
        res = self.env.run('../run.py', '-s', '1', '-c')
        assert 'Collecting' in res.stdout
        self.assertEqual(res.returncode, 0)

    def test_log(self):
        res = self.env.run('../run.py', '-s', '1', '--log', 'log.txt')
        assert 'Timeout' in res.stdout
        assert 'log.txt' in res.files_created
        self.assertEqual(res.returncode, 0)

    def test_segment(self):
        res = self.env.run('../run.py', '-s', '1', '--segment', '0.2')
        assert 'Timeout' in res.stdout
        self.assertEqual(res.returncode, 0)

    def tearDown(self):
        pass
예제 #8
0
def test_no_command_shows_help():
    env = ScriptTestEnvironment()
    result = env.run('ansible-container', expect_error=True)
    assert result.returncode == 2
    assert len(result.stdout) == 0
    assert "usage: ansible-container" in result.stderr
    assert "ansible-container: error:" in result.stderr
예제 #9
0
class TestProgramsHelp(unittest.TestCase):

    def spawn_tests(self):
        programs = os.listdir(programs_WD)
        not_checked = []
        for prog in programs:
            if prog in ['__init__.py', 'program_envs.py']:
                continue
            if not prog.endswith('.py') or '#' in prog:
                not_checked.append(prog)
                continue
            if prog.lower() != prog:
                continue
            #res = env.run(prog, '-h')
            return prog

    def setUp(self):
        if os.path.exists('./new-test-output'):
            shutil.rmtree('./new-test-output')
        self.env = TestFileEnvironment('./new-test-output')
        #if not os.path.exists('./new-test-output'):
        #    os.mkdir('./new-test-output')

    def tearDown(self):
        if os.path.exists('./new-test-output'):
            shutil.rmtree('./new-test-output')

    def test_cmd_line(self):
        print 'programs_WD', programs_WD
        programs = os.listdir(programs_WD)
        not_checked = []
        for prog in programs:
            print "Testing help message for:", prog
            if prog in ['__init__.py', 'program_envs.py']:
                continue
            if 'gui' in prog:
                continue
            if not prog.endswith('.py') or '#' in prog:
                not_checked.append(prog)
                continue
            if prog.lower() != prog:
                continue
            if sys.platform in ['win32', 'win62']:
                prog = prog[:-3]
            res = self.env.run(prog, '-h')
            #except AssertionError as ex:
            #    not_checked.append(prog)
            #    print 'ex', type(ex)
            #    print res
        print 'not_checked', not_checked

    def test_guis(self):
        tests = ['pmag_gui.py', 'magic_gui.py', 'demag_gui.py',
                 'thellier_gui.py']
        for prog in tests:
            if sys.platform in ['win32', 'win62']:
                prog = prog[:-3]
            print 'testing:', prog
            res = self.env.run(prog, '-h')
예제 #10
0
파일: test.py 프로젝트: bestwpw/pygogo
def main(script, tests, verbose=False, stop=True):
    """ Main method

    Returns 0 on success, 1 on failure
    """
    failures = 0
    logger = gogo.Gogo(__name__, verbose=verbose).logger
    short_script = p.basename(script)
    env = TestFileEnvironment('.scripttest')

    start = timer()

    for pos, test in enumerate(tests):
        num = pos + 1
        opts, arguments, expected = test
        joined_opts = ' '.join(opts) if opts else ''
        joined_args = '"%s"' % '" "'.join(arguments) if arguments else ''
        command = "%s %s %s" % (script, joined_opts, joined_args)
        short_command = "%s %s %s" % (short_script, joined_opts, joined_args)
        result = env.run(command, cwd=p.abspath(p.dirname(p.dirname(__file__))))
        output = result.stdout

        if isinstance(expected, bool):
            text = StringIO(output).read()
            outlines = [str(bool(text))]
            checklines = StringIO(str(expected)).readlines()
        elif p.isfile(expected):
            outlines = StringIO(output).readlines()

            with open(expected, encoding='utf-8') as f:
                checklines = f.readlines()
        else:
            outlines = StringIO(output).readlines()
            checklines = StringIO(expected).readlines()

        args = [checklines, outlines]
        kwargs = {'fromfile': 'expected', 'tofile': 'got'}
        diffs = ''.join(unified_diff(*args, **kwargs))
        passed = not diffs

        if not passed:
            failures += 1
            msg = "ERROR! Output from test #%i:\n  %s\n" % (num, short_command)
            msg += "doesn't match:\n  %s\n" % expected
            msg += diffs if diffs else ''
        else:
            logger.debug(output)
            msg = 'Scripttest #%i: %s ... ok' % (num, short_command)

        logger.info(msg)

        if stop and failures:
            break

    time = timer() - start
    logger.info('%s' % '-' * 70)
    end = 'FAILED (failures=%i)' % failures if failures else 'OK'
    logger.info('Ran %i scripttests in %0.3fs\n\n%s' % (num, time, end))
    sys.exit(failures)
예제 #11
0
 def test_script(self):
     with HTTMock(mock_TwitterK):
         env = TestFileEnvironment('myria_upload')
         res = env.run('''myria_upload --relation TwitterK --program test
                       --overwrite --hostname localhost
                       --port 12345 --dry''', stdin='foo,bar\n1,b\n3,c',
                       expect_stderr=True)
         eq_(res.stdout, '''1,b\n3,c\n''')
예제 #12
0
파일: test_konch.py 프로젝트: sloria/konch
def env():
    env_ = FileEnvironment(ignore_hidden=False)
    auth_file = Path(env_.base_path) / "konch_auth"
    env_.environ["KONCH_AUTH_FILE"] = str(auth_file)
    env_.environ["KONCH_EDITOR"] = "echo"
    yield env_
    try:
        auth_file.unlink()
    except FileNotFoundError:
        pass
예제 #13
0
class TestIntegration(unittest.TestCase):
    def setUp(self):
        self.env = TestFileEnvironment(test_path, template_path=template_path)

    def test_init(self):
        result = self.env.run("gpc", "init", expect_stderr=True)
        created_filenames = result.files_created.keys()
        self.assertTrue("log" in created_filenames)
        self.assertTrue("log/data" in created_filenames)
        self.assertTrue("log/schema.sql" in created_filenames)
        self.assertTrue("storage" in created_filenames)

    def test_make_target(self):
        self.env.run("gpc", "init", expect_stderr=True)
        self.env.writefile("gpc.yaml", frompath="simple.yaml")
        result = self.env.run("gpc", "make", "c", expect_stderr=True)
        created_filenames = list(result.files_created.keys())
        self.assertTrue("c" in created_filenames)
        created_filenames.remove("c")
        self.assertTrue(any([s.startswith("storage/") for s in created_filenames]))
        self.assertTrue(any([s.startswith("log/data/") for s in created_filenames]))

    def test_make_target_cached(self):
        call(["cp", "-r", template_path + "/.gpc", test_path])
        call(["cp", "-r", template_path + "/log", test_path])
        call(["cp", "-r", template_path + "/storage", test_path])
        self.env.writefile("gpc.yaml", frompath="simple.yaml")
        result = self.env.run("gpc", "make", "c", expect_stderr=True)
        created_filenames = result.files_created.keys()
        self.assertTrue("c" in created_filenames)
        self.assertTrue(len(created_filenames) == 1)
예제 #14
0
def test_build_with_variables():
    env = ScriptTestEnvironment()
    result = env.run('ansible-container', 'build', '--save-build-container', '--with-variables', 'foo=bar',
                     'bar=baz', cwd=project_dir('minimal'), expect_stderr=True)
    assert "Aborting on container exit" in result.stdout
    assert "Exported minimal-minimal with image ID " in result.stderr

    result = env.run('docker', 'inspect', '--format="{{ .Config.Env }}"', 'ansible_ansible-container_1',
                     expect_stderr=True)
    assert "foo=bar" in result.stdout
    assert "bar=baz" in result.stdout
예제 #15
0
def test_build_with_volumes():
    env = ScriptTestEnvironment()
    volume_string = "{0}:{1}:{2}".format(os.getcwd(), '/projectdir', 'ro')
    result = env.run('ansible-container', 'build', '--save-build-container', '--with-volumes', volume_string,
                     cwd=project_dir('minimal'), expect_stderr=True)
    assert "Aborting on container exit" in result.stdout
    assert "Exported minimal-minimal with image ID " in result.stderr
    result = env.run('docker', 'inspect',
                     '--format="{{range .Mounts}}{{ .Source }}:{{ .Destination }}:{{ .Mode}} {{ end }}"',
                     'ansible_ansible-container_1', expect_stderr=True)
    volumes = result.stdout.split(' ')
    assert volume_string in volumes
예제 #16
0
def test_shipit_kube():
   env = ScriptTestEnvironment()
   # Should run shipit kube to success
   result = env.run('ansible-container', '--debug',  'shipit', 'kube', '--pull-from', 'https://index.docker.io/v1/ansible',
                    cwd=project_dir('postgres'), expect_error=True)
   assert result.returncode == 0
   assert "Role postgres created" in result.stderr
   # Should create a role
   result = env.run('ls ansible/roles', cwd=project_dir('postgres'))
   assert "postgres-kubernetes" in result.stdout
   # Should create a playbook
   result = env.run('ls ansible', cwd=project_dir('postgres'))
   assert "shipit-kubernetes.yml" in result.stdout
예제 #17
0
    def get_env(self):
        #import tempfile
        #env = TestFileEnvironment(tempfile.mkdtemp(suffix='', prefix='test_' + script))
        env = TestFileEnvironment()

        # Use Agg backend for plots.
        #env.writefile("matplotlibrc", "backend : Agg")

        # Start with --help. If this does not work...
        env.run(self.script, "--help")

        # Script must provide a version option
        #r = env.run(self.script, "--version", expect_stderr=True)
        #assert r.stderr.strip() == "%s version %s" % (os.path.basename(self.script), abilab.__version__)
        return env
예제 #18
0
def test_bad_symlink(tmpdir):
    """
    symlinks only work in UNIX
    """
    if sys.platform == 'win32':
        return
    env = TestFileEnvironment(str(tmpdir), start_clear=False)
    res = env.run(sys.executable, '-c', '''\
import os
os.symlink(os.path.join('does', 'not', 'exist.txt'), "does-not-exist.txt")
''')
    assert 'does-not-exist.txt' in res.files_created, res.files_created
    assert res.files_created['does-not-exist.txt'].invalid
    # Just make sure there's no error:
    str(res)
예제 #19
0
class BaseTemplateTest(unittest.TestCase):

    def setUp(self):
        self.tempdir = tempfile.mkdtemp()
        self.addCleanup(shutil.rmtree,
                self.tempdir)

        # docs httpcripttest//pythonpaste.org/scripttest/
        self.env = TestFileEnvironment(
            os.path.join(self.tempdir,
                    'test-output'),
            ignore_hidden=False,
        )

    def create_template(self):
        """Run mr.bob to create your template."""
        options = {
            'dir': os.path.join(os.path.dirname(__file__)),
            'template': self.template,
            'project': self.project,
        }
        return self.env.run(
            '%(dir)s/bin/mrbob -O %(project)s --config '
            '%(dir)s/test_answers.ini %(dir)s/bobtemplates/%(template)s'
            % options)
예제 #20
0
class TestCommands(TestCase):

    @classmethod
    def setUpClass(cls):
        create_run_script()

    def setUp(self):
        self.env = TestFileEnvironment('./test-output')

    def test_send_no_args(self):
        cmd = 'python ../run.py send'
        self.env.run(*shlex.split(cmd), expect_error=True)

    def test_send_alias_stdin(self):
        cmd = 'python ../run.py send -a "%s"' % (TEST_ALIAS)
        self.env.run(*shlex.split(cmd), stdin=b'Hi')
예제 #21
0
class BaseTemplateTest(unittest.TestCase):

    # credit bobtemplates.plone

    def setUp(self):
        self.maxDiff = None
        self.tempdir = tempfile.mkdtemp()
        self.addCleanup(shutil.rmtree, self.tempdir)

        # docs http://pythonpaste.org/scripttest/
        self.env = TestFileEnvironment(
            os.path.join(self.tempdir, 'test-output'),
            ignore_hidden=False,
        )

    def create_template(self):
        """Run mr.bob to create your template."""
        options = {
            'dir': os.path.join(os.path.dirname(__file__)),
            'template': self.template,
            'addon': self.addon,
            'answers_file': self.answers_file,
            'target_dir': self.target_dir,
        }
        return self.env.run(
            'mrbob -O %(target_dir)s --config '
            '%(dir)s/%(answers_file)s bobtemplates.odoo:%(template)s'
            % options)
예제 #22
0
class TestSpec(object):
    td_dir = "{0}/test_data/".format(tests_dir)
    bin_dir = os.path.split(tests_dir)[0] + "/"
    exe = "python {0}mybin.py".format(bin_dir)

    def setup_method(self, method):
        self.env = TestFileEnvironment("{0}/test_output/".format(tests_dir))

    @pytest.mark.parametrize(
        ("package", "options", "expected"),
        [
            ("Jinja2", "", "python-Jinja2.spec"),
            ("Jinja2", "-b3", "python-Jinja2_base.spec"),
            ("Jinja2", "-t epel7", "python-Jinja2_epel7.spec"),
            ("Jinja2", "-t epel6", "python-Jinja2_epel6.spec"),
            ("buildkit", "-b2", "python-buildkit.spec"),
            ("StructArray", "-b2", "python-StructArray.spec"),
            ("Sphinx", "-r python-sphinx", "python-sphinx.spec"),
        ],
    )
    @pytest.mark.spectest
    def test_spec(self, package, options, expected):
        with open(self.td_dir + expected) as fi:
            self.spec_content = fi.read()
        res = self.env.run("{0} {1} {2}".format(self.exe, package, options))
        # changelog have to be cut from spec files
        assert set(res.stdout.split("\n")[1:-4]) == set(self.spec_content.split("\n")[1:-4])
예제 #23
0
class TestSpec(object):
    td_dir = '{0}/test_data/'.format(tests_dir)
    bin_dir = os.path.split(tests_dir)[0] + '/'
    exe = 'python {0}mybin.py'.format(bin_dir)

    def setup_method(self, method):
        self.env = TestFileEnvironment('{0}/test_output/'.format(tests_dir))

    @pytest.mark.parametrize(('package', 'options', 'expected'), [
        ('Jinja2', '-v2.8', 'python-Jinja2.spec'),
        ('Jinja2', '-v2.8 -b3', 'python-Jinja2_base.spec'),
        ('Jinja2', '-v2.8 -t epel7', 'python-Jinja2_epel7.spec'),
        ('Jinja2', '-v2.8 -t epel6', 'python-Jinja2_epel6.spec'),
        ('buildkit', '-v0.2.2 -b2', 'python-buildkit.spec'),
        ('StructArray', '-v0.1 -b2', 'python-StructArray.spec'),
        ('Sphinx', '-v1.5 -r python-sphinx', 'python-sphinx.spec'),
    ])
    @pytest.mark.webtest
    def test_spec(self, package, options, expected):
        with open(self.td_dir + expected) as fi:
            self.spec_content = fi.read()
        res = self.env.run('{0} {1} {2}'.format(self.exe, package, options),
                           expect_stderr=True)
        # changelog have to be cut from spec files
        assert set(res.stdout.split('\n')[1:-4]) == set(self.spec_content.split('\n')[1:-4])
예제 #24
0
class BaseTemplateTest(unittest.TestCase):
    """Base class for all spirit.bob test cases."""

    def setUp(self):
        self.tempdir = tempfile.mkdtemp()
        self.addCleanup(shutil.rmtree, self.tempdir)

        # docs http://pythonpaste.org/scripttest/
        self.env = TestFileEnvironment(
            os.path.join(self.tempdir, 'test-output'),
            ignore_hidden=False,
        )

    def create_template(self):
        """Run mr.bob to create your template."""
        options = {
            'dir': os.path.join(os.path.dirname(__file__)),
            'template': self.template,
            'answers_file': self.answers_file,
        }
        return self.env.run(
            '{dir}/bin/mrbob --config '
            '{dir}/{answers_file} {dir}/src/spirit/bob/{template}'.format(
                **options
            )
        )
예제 #25
0
    def setUp(self):
        self.tempdir = tempfile.mkdtemp()
        self.addCleanup(shutil.rmtree, self.tempdir)

        # docs http://pythonpaste.org/scripttest/
        self.env = TestFileEnvironment(os.path.join(self.tempdir,
                                                    'test-output'),
                                       ignore_hidden=False)
예제 #26
0
 def setUp(self):
     self.env = TestFileEnvironment(
             base_path=TEST_DIR,
             template_path=TEMPLATE_DIR,
             cwd=os.getcwd(),
             ignore_hidden=False)
     self.env.writefile(INPUT_FILE_NAME,
             frompath='test_freq_2_then_1_then_8_then_4.fda')
예제 #27
0
 def setUp(self):
     super(Shell, self).setUp()
     migrate_path = os.path.dirname(sys.executable)
     # PATH to migrations development script folder
     log.debug('PATH for ScriptTest: %s', migrate_path)
     self.env = TestFileEnvironment(
         base_path=os.path.join(self.temp_usable_dir, 'env'),
     )
예제 #28
0
파일: test.py 프로젝트: reubano/ckanny
def main(verbose=False):
    env = TestFileEnvironment('.scripttest')
    test_num = 1

    # Test main usage
    result = env.run('%s --help' % script)

    if verbose:
        print(result.stdout)

    usage = 'usage: ckanny [<namespace>.]<command> [<args>]'
    assert result.stdout.split('\n')[0] == usage
    print('\nScripttest: #%i ... ok' % test_num)
    test_num += 1

    # Test command usage
    commands = [
        'ds.delete', 'ds.update', 'ds.upload',
        'fs.fetch', 'fs.migrate', 'fs.upload',
        'pk.create', 'pk.update']

    for command in commands:
        result = env.run('%s %s --help' % (script, command))

        if verbose:
            print(result.stdout)

        usage = 'usage: %s %s\n' % (script, command)
        assert ' '.join(result.stdout.split(' ')[:3]) == usage
        print('Scripttest: %s ... ok' % command)
        test_num += 1

    # Test version
    result = env.run('%s ver' % script)

    if verbose:
        print(result.stdout)

    assert result.stdout.split('\n')[0] == 'v%s' % version
    print('Scripttest: #%i ... ok' % test_num)

    # End of testing
    print('-----------------------------')
    print('Ran %i tests\n\nOK' % test_num)
    exit(0)
예제 #29
0
def reset_env():
    global env
    env = TestFileEnvironment(base_path, ignore_hidden=False)
    env.run('virtualenv', '--no-site-packages', env.base_path)
    # To avoid the 0.9c8 svn 1.5 incompatibility:
    env.run('%s/bin/easy_install' % env.base_path, 'http://peak.telecommunity.com/snapshots/setuptools-0.7a1dev-r66388.tar.gz')
    env.run('mkdir', 'src')
예제 #30
0
class TestManagement(TestCase):
    @staticmethod
    def _remvoe_db_file():
        if os.path.exists(DB_PATH):
            os.remove(DB_PATH)

    def setUp(self):
        # removes the database file
        self._remvoe_db_file()

        # sets up ScriptTest testing environement
        self.env = TestFileEnvironment(
            base_path = TESTS_OUTPUT_PATH,
            start_clear = True,
        )
        os.chdir(TESTS_OUTPUT_PATH)

    def tearDown(self):
        # restores current directory
        os.chdir(BASE_PATH)

        # removes files created during the tests
        self.env.clear()

        # remove the test output folder
        shutil.rmtree(TESTS_OUTPUT_PATH)

        # removes the database file
        self._remvoe_db_file()

    def test_test_cmd(self):
        r = self.env.run('%s test' % os.path.join(EXAMPLE_PATH, 'manage.py'))
        self.assertEquals(r.stdout, "Hello world!\n")

    def test_create_admin(self):
        r = self.env.run('%s create_admin' % os.path.join(EXAMPLE_PATH, 'manage.py'))
        self.assertEquals(r.stdout, "Admin user %(user)s (password: %(pwd)s) created successfully.\n" % {
            'user': ADMIN_USER,
            'pwd': ADMIN_PWD,
        })

        r = self.env.run('%s create_admin' % os.path.join(EXAMPLE_PATH, 'manage.py'))
        self.assertEquals(r.stdout, "Admin user %(user)s already exists!\n" % {
            'user': ADMIN_USER,
        })
예제 #31
0
def test_help_option_shows_help_for_shipit_engine_command():
    env = ScriptTestEnvironment()
    result = env.run('ansible-container', 'shipit', 'kube', '--help')
    assert "usage: ansible-container shipit kube" in result.stdout
예제 #32
0
파일: test.py 프로젝트: tvabramov/ant
# TODO: optimize file pathing in TestFileEnvironment for different platforms.
from scripttest import TestFileEnvironment
import filecmp
import os

env = TestFileEnvironment('./scratch')


def synthetic():
    env.clear()

    print('Testing input 12 3 21')
    encode_result_0 = env.run('..\\ant', '12', '3', '21', expect_error=False)
    assert encode_result_0.returncode == 0
    assert encode_result_0.stdout.startswith('72469')
    print('OK')

    print('Testing input 67 12 19')
    encode_result_0 = env.run('..\\ant', '67', '12', '19', expect_error=False)
    assert encode_result_0.returncode == 0
    assert encode_result_0.stdout.startswith('25920')
    print('OK')

    print('Testing input 137 67 25')
    encode_result_0 = env.run('..\\ant', '137', '67', '25', expect_error=False)
    assert encode_result_0.returncode == 0
    assert encode_result_0.stdout.startswith('259359')
    print('OK')

    print('Testing input 15 653 25')
    encode_result_0 = env.run('..\\ant', '15', '653', '25', expect_error=False)
#!/usr/bin/env python
from __future__ import print_function
from __future__ import unicode_literals

from scripttest import TestFileEnvironment
import subprocess

env = TestFileEnvironment('./_test')
debug = False

# DEFINE ANSIBLE VERSION
ANSIBLE_2_4 = "/home/kbyers/VENV/py27_venv/bin/ansible-playbook"
#ANSIBLE_2_4 = "/home/kbyers/VENV/ans_2_4/bin/ansible-playbook"
ACTIVE_VERSION = ANSIBLE_2_4

# DEFINE TEST CASES
PROGRAMS = [
    ('/home/kbyers/ansible_course/class3/exercises/exercise1.yml', {
        'tests': {
            'return_code':
            0,
            'return_strings': [
                'nxos1                      : ok=2    changed=1    unreachable=0    failed=0',
                'nxos2                      : ok=2    changed=1    unreachable=0    failed=0',
                "changed: [nxos1] => (item={u'name': u'blue', u'vlan_id': 301})",
                "changed: [nxos2] => (item={u'name': u'blue', u'vlan_id': 301})",
                "changed: [nxos1] => (item={u'name': u'red', u'vlan_id': 302})",
                "changed: [nxos2] => (item={u'name': u'red', u'vlan_id': 302})",
                "changed: [nxos1] => (item={u'name': u'green', u'vlan_id': 303})",
                "changed: [nxos2] => (item={u'name': u'green', u'vlan_id': 303})",
                "changed: [nxos1] => (item={u'name': u'yellow', u'vlan_id': 304})",
예제 #34
0
from scripttest import TestFileEnvironment
from filecmp import cmp

testdir = "tests/testenv_graphprot_classification_ls/"

env = TestFileEnvironment(testdir)


def test_classification_ls():
    "Run parameter linesearch."
    call = """../../GraphProt.pl -mode classification -action ls --onlyseq \
              -fasta ../testclip.train.positives.fa \
              -negfasta ../testclip.train.negatives.fa -prefix CL_ls --keep-tmp"""
    env.run(call)
    assert cmp("tests/CL_ls.params", testdir + "CL_ls.params")


def test_classification_train_from_lsparam():
    "Train a model using parameter file."
    call = """../../GraphProt.pl -mode classification -action train --onlyseq\
              -fasta ../testclip.train.positives.fa \
              -negfasta ../testclip.train.negatives.fa
              -params ../CL_ls.params \
              -prefix CL_train_from_ls --keep-tmp"""
    env.run(call)
    assert cmp("tests/CL_train_from_ls.model",
               testdir + "CL_train_from_ls.model")
예제 #35
0
    def __init__(self, environ=None, sitecustomize=None):
        import virtualenv

        self.root_path = fast_test_env_root
        self.backup_path = fast_test_env_backup

        self.scratch_path = self.root_path / self.scratch

        # We will set up a virtual environment at root_path.
        self.venv_path = self.root_path / self.venv

        if not environ:
            environ = os.environ.copy()
            environ = clear_environ(environ)
            environ['PIP_DOWNLOAD_CACHE'] = str(download_cache)

        environ['PIP_NO_INPUT'] = '1'
        environ['PIP_LOG_FILE'] = str(self.root_path / 'pip-log.txt')

        TestFileEnvironment.__init__(self,
                                     self.root_path,
                                     ignore_hidden=False,
                                     environ=environ,
                                     split_cmd=False,
                                     start_clear=False,
                                     cwd=self.scratch_path,
                                     capture_temp=True,
                                     assert_no_temp=True)

        virtualenv_paths = virtualenv.path_locations(self.venv_path)

        for id, path in zip(('venv', 'lib', 'include', 'bin'),
                            virtualenv_paths):
            #fix for virtualenv issue #306
            if hasattr(sys, "pypy_version_info") and id == 'lib':
                path = os.path.join(self.venv_path, 'lib-python', pyversion)
            setattr(self, id + '_path', Path(path))
            setattr(self, id, relpath(self.root_path, path))

        assert self.venv == TestPipEnvironment.venv  # sanity check

        if hasattr(sys, "pypy_version_info"):
            self.site_packages = self.venv / 'site-packages'
        else:
            self.site_packages = self.lib / 'site-packages'
        self.user_base_path = self.venv_path / 'user'
        self.user_site_path = self.venv_path / 'user' / 'lib' / self.lib.name / 'site-packages'

        self.user_site = relpath(self.root_path, self.user_site_path)

        self.environ["PYTHONUSERBASE"] = self.user_base_path

        # put the test-scratch virtualenv's bin dir first on the PATH
        self.environ['PATH'] = Path.pathsep.join(
            (self.bin_path, self.environ['PATH']))

        self.use_distribute = os.environ.get('PIP_TEST_USE_DISTRIBUTE', False)

        if self.root_path.exists:
            rmtree(self.root_path)
        if self.backup_path.exists:
            shutil.copytree(self.backup_path, self.root_path, True)
        else:
            demand_dirs(self.venv_path)
            demand_dirs(self.scratch_path)

            # Create a virtualenv and remember where it's putting things.
            create_virtualenv(self.venv_path, distribute=self.use_distribute)

            demand_dirs(self.user_site_path)

            # create easy-install.pth in user_site, so we always have it updated instead of created
            open(self.user_site_path / 'easy-install.pth', 'w').close()

            # test that test-scratch virtualenv creation produced sensible venv python
            result = self.run('python', '-c',
                              'import sys; print(sys.executable)')
            pythonbin = result.stdout.strip()

            if Path(pythonbin).noext != self.bin_path / 'python':
                raise RuntimeError(
                    "Oops! 'python' in our test environment runs %r"
                    " rather than expected %r" %
                    (pythonbin, self.bin_path / 'python'))

            # make sure we have current setuptools to avoid svn incompatibilities
            if not self.use_distribute:
                install_setuptools(self)

            # Uninstall whatever version of pip came with the virtualenv.
            # Earlier versions of pip were incapable of
            # self-uninstallation on Windows, so we use the one we're testing.
            self.run(
                'python', '-c',
                '"import sys; sys.path.insert(0, %r); import pip; sys.exit(pip.main());"'
                % os.path.dirname(here), 'uninstall', '-vvv', '-y', 'pip')

            # Install this version instead
            self.run('python',
                     'setup.py',
                     'install',
                     cwd=src_folder,
                     expect_stderr=True)
            shutil.copytree(self.root_path, self.backup_path, True)

        #create sitecustomize.py and add patches
        self._create_empty_sitecustomize()
        self._use_cached_pypi_server()
        if sitecustomize:
            self._add_to_sitecustomize(sitecustomize)

        assert self.root_path.exists

        # Ensure that $TMPDIR exists (because we use start_clear=False, it's not created for us)
        if self.temp_path and not os.path.exists(self.temp_path):
            os.makedirs(self.temp_path)
예제 #36
0
def before_scenario(context, scenario):
    context.env = TestFileEnvironment('./tmp')
예제 #37
0
 def setUp(self):
     self.env = TestFileEnvironment('./test-output')
예제 #38
0
def test_socialize():
    env = TestFileEnvironment('./test-output')
    result = env.run('socl', 'me', expect_error=True)
    assert result.stderr == "You aren't authenticated yet. Please use the login or register command to do so.\n"
예제 #39
0
    def test_abidoc(self):
        """Testing abiconf.py script"""
        env = TestFileEnvironment()

        # Start with --help. If this does not work...
        print(self.script)
        env.run(self.script, "--help")

        # Script must provide a version option
        #r = env.run(self.script, "--version", expect_stderr=True)
        #assert r.stderr.strip() == "%s version %s" % (os.path.basename(self.script), abilab.__version__)

        # Test hostname
        env.run(self.script, "hostname", self.verbose)
        env.run(self.script, "hostname", "zenobe", self.verbose)

        # Test list
        env.run(self.script, "list", self.verbose)

        # Test keys
        env.run(self.script, "keys", "intel", self.verbose)
        env.run(self.script, "keys", "intel", "mkl", self.verbose)

        # Test doc
        env.run(self.script, "doc", self.verbose)

        # Test opts
        env.run(self.script, "opts", self.verbose)

        # Test load
        #env.run(self.script, "load", "acfile", self.verbose)

        # Test workon
        env.run(self.script, "workon", self.verbose)
        env.run(self.script, "workon", "zenobe-intel-impi-mkl.ac",
                self.verbose)
예제 #40
0
def test_run_in_uninitialized_directory_fails():
    env = ScriptTestEnvironment()
    result = env.run('ansible-container', 'run', expect_error=True)
    assert result.returncode == 1
    assert result.stdout == ''
    assert "No Ansible Container project data found" in result.stderr
예제 #41
0
def test_help_option_shows_help_for_push_command():
    env = ScriptTestEnvironment()
    result = env.run('ansible-container', 'push', '--help')
    assert "usage: ansible-container push" in result.stdout
예제 #42
0
def test_invalid_command_fails():
    env = ScriptTestEnvironment()
    result = env.run('ansible-container', 'invalid', expect_error=True)
    assert result.returncode == 2
    assert len(result.stdout) == 0
    assert "ansible-container: error: argument subcommand: invalid choice: 'invalid'" in result.stderr
예제 #43
0
def test_help_option_shows_help():
    env = ScriptTestEnvironment()
    result = env.run('ansible-container', '--help')
    assert "usage: ansible-container" in result.stdout
예제 #44
0
def test_no_command_shows_help():
    env = ScriptTestEnvironment()
    result = env.run('ansible-container', expect_error=True)
    assert result.returncode == 2
    assert len(result.stdout) == 0
    assert "ansible-container: error: too few arguments" in result.stderr
예제 #45
0
def env():
    return TestFileEnvironment(ignore_hidden=False)
예제 #46
0
 def setup_method(self, method):
     self.temp_dir = tempfile.mkdtemp()
     self.env = TestFileEnvironment(self.temp_dir, start_clear=False)
예제 #47
0
def test_run_minimal_docker_container():
    env = ScriptTestEnvironment()
    result = env.run('ansible-container', 'run', cwd=project_dir('minimal'))
    assert "ansible_minimal_1 exited with code 0" in result.stdout
예제 #48
0
class TestCLI():
    """ Contains setups, teardowns, and tests for CLI
    """
    @classmethod
    def setup_class(cls):
        """ Create a config file to read from """
        with open(CONFIGFILE, 'w') as config:
            config.write(CONFIG_YAML)

    @classmethod
    def teardown_class(cls):
        """ Remove config file """
        os.remove(CONFIGFILE)

    def setup(self):
        """ Create a file to print to and set up env"""
        self.env = None
        self.default_args = None

        self.env = TestFileEnvironment(
            base_path=TEST_DIR,
            cwd=os.getcwd(),
        )

        self.default_args = (
            'python-escpos',
            '-c',
            CONFIGFILE,
        )

        fhandle = open(DEVFILE, 'a')
        try:
            os.utime(DEVFILE, None)
        finally:
            fhandle.close()

    def teardown(self):
        """ Destroy printer file and env """
        os.remove(DEVFILE)
        self.env.clear()

    def test_cli_help(self):
        """ Test getting help from cli """
        result = self.env.run('python-escpos', '-h')
        assert not result.stderr
        assert 'usage' in result.stdout

    def test_cli_version(self):
        """ Test the version string """
        result = self.env.run('python-escpos', 'version')
        assert not result.stderr
        assert_equals(escpos.__version__, result.stdout.strip())

    @nottest  # disable this test as it is not that easy anymore to predict the outcome of this call
    def test_cli_text(self):
        """ Make sure text returns what we sent it """
        test_text = 'this is some text'
        result = self.env.run(*(self.default_args + (
            'text',
            '--txt',
            test_text,
        )))
        assert not result.stderr
        assert DEVFILE_NAME in result.files_updated.keys()
        assert_equals(result.files_updated[DEVFILE_NAME].bytes,
                      test_text + '\n')

    def test_cli_text_inavlid_args(self):
        """ Test a failure to send valid arguments """
        result = self.env.run(*(self.default_args +
                                ('text', '--invalid-param', 'some data')),
                              expect_error=True,
                              expect_stderr=True)
        assert_equals(result.returncode, 2)
        assert 'error:' in result.stderr
        assert not result.files_updated
예제 #49
0
def test_shipit_in_uninitialized_directory_fails():
    env = ScriptTestEnvironment()
    result = env.run('ansible-container', 'shipit', expect_error=True)
    assert result.returncode == 1
    assert result.stdout == ''
    assert "No such file or directory" in result.stderr
예제 #50
0
class PyCliTest(object):
    'Base class for all test cases.'

    def __init__(self, description, tmp_wd='tests-out', clear_base_dir=True):
        self.description = description
        self.command = ''
        self.negative_case = False
        self.ignore_err = False
        self.tmp_wd = tmp_wd
        self._create_temp_working_dir()
        self.env = TestFileEnvironment(base_path=self.working_dir,
                                       start_clear=clear_base_dir)

    def before_all(self):
        raise NotImplementedError("before_all not implemented.")

    def _create_temp_working_dir(self):
        self.working_dir = os.path.join(
            os.path.dirname(os.path.realpath(__file__)), self.tmp_wd)

    def with_cli(self, command):
        self.command = command
        return self

    def setup(self):
        # Do some initializations required to run the tests
        logit("Setting up the test [%s]" % (self.description))
        return self

    def run(self, stdin_values=None):
        # Execute the test.
        logit("Running command: [%s]" % (self.command))

        stdin_param = None
        expect_error_value = False
        expect_stderr_value = False

        start_time = time.time()
        if Config.dummy_run:
            self.status = self.env.run("echo [%s]" % (self.command))
        else:

            if stdin_values != None:
                stdin_param = bytearray(stdin_values, 'utf-8')
            if (self.negative_case):
                expect_error_value = True
                expect_stderr_value = True
            elif (self.ignore_err):
                expect_error_value = False
                expect_stderr_value = True

            self.status = self.env.run(self.command,
                                       expect_error=expect_error_value,
                                       stdin=stdin_param,
                                       expect_stderr=expect_stderr_value)

        end_time = time.time()
        self.print_time(round(end_time - start_time, 3))
        logit("returncode: [%d]" % (self.status.returncode))
        logit("stdout: [%s]" % (self.status.stdout))
        logit("stderr: [%s]" % (self.status.stderr))
        return self

    def print_time(self, time):
        time_str = "Execution time - "
        if (Config.time_readable_format):
            if (time < 1):
                time_str += str(round(time * 1000)) + " ms"
            elif (time > 60):
                m, s = divmod(time, 60)
                time_str += str(round(m)) + " min " + str(round(
                    s, 3)) + " seconds"
            else:
                time_str += str(round(time, 3)) + " seconds"
        else:
            time_str += str(round(time * 1000)) + " ms"

        print(time_str)

    def teardown(self):
        # Do some cleanup
        logit("Running teardown [%s]" % (self.description) + "    ")
        shutil.rmtree(self.working_dir, ignore_errors=True)
        return self

    def execute_test(self,
                     negative_case=False,
                     ignore_err=False,
                     stdin_values=None):
        print("\nTest case [%s] - " % (self.description), end="")
        self.negative_case = negative_case
        self.ignore_err = ignore_err
        self.setup()
        if stdin_values != None:
            self.run(stdin_values)
        else:
            self.run()
        self.teardown()
        return self

    def command_is_successful(self):
        if not Config.dummy_run:
            assert self.status.returncode == 0, 'Test Failed'
        print("Command was successful.")
        return self

    def command_should_fail(self):
        if not Config.dummy_run:
            assert self.status.returncode != 0, 'Test Failed'
        print("Command has failed as expected.")
        return self

    def command_response_should_have(self, msg):
        if not Config.dummy_run:
            assert msg in self.status.stdout
        print("Response has [%s]." % (msg))
        return self

    def command_response_should_be_empty(self):
        if not Config.dummy_run:
            assert self.status.stdout == ""
        print("Response is empty")
        return self

    def command_response_should_not_have(self, msg):
        if not Config.dummy_run:
            assert msg not in self.status.stdout
        print("Response does not have [%s]." % (msg))
        return self

    def command_error_should_have(self, msg):
        if not Config.dummy_run:
            assert msg in self.status.stderr
        print("Error message has [%s]." % (msg))
        return self

    def command_error_should_not_have(self, msg):
        if not Config.dummy_run:
            assert msg in self.status.stderr
        print("Error message does not have [%s]." % (msg))
        return self

    def command_created_file(self, file_name):
        logit("Checking for file [%s] in files created [%s]" %
              (file_name, ', '.join(self.status.files_created)))
        if not Config.dummy_run:
            assert file_name in self.status.files_created, file_name + ' NOT created'
        print("File [%s] was created." % (file_name))
        return self

    def command_deleted_file(self, file_name):
        logit("Checking for file [%s] in files deleted [%s]" %
              (file_name, ', '.join(self.status.files_deleted)))
        if not Config.dummy_run:
            assert file_name in self.status.files_deleted, file_name + ' NOT deleted'
        print("File [%s] was deleted." % (file_name))
        return self

    def command_updated_file(self, file_name):
        logit("Checking for file [%s] in files updated [%s]" %
              (file_name, ', '.join(self.status.files_updated)))
        if not Config.dummy_run:
            assert file_name in self.status.files_updated, file_name + ' NOT updated'
        print("File [%s] was updated." % (file_name))
        return self

    # Match the output with the given pattern.
    def command_should_match_pattern(self, pattern):
        regex = re.compile(pattern)
        if not Config.dummy_run:
            assert bool(regex.match(self.status.stdout)), (
                "Expected output %s.\nActual output %s" %
                (pattern, self.status.stdout))
        print("Command was successful.")
        return self

    # Match the std error with the given pattern.
    def command_error_should_match_pattern(self, pattern):
        regex = re.compile(pattern)
        if not Config.dummy_run:
            assert bool(regex.match(self.status.stderr)), (
                "Expected output %s.\nActual output %s" %
                (pattern, self.status.stdout))
        print("Command was successful.")
        return self

    # Get exit status for command
    def get_exitstatus(self):
        return self.status.returncode
예제 #51
0
def test_init_empty_directory():
    env = ScriptTestEnvironment()
    result = env.run('ansible-container', 'init', expect_stderr=True)
    assert result.stdout == ''
    assert "Ansible Container initialized" in result.stderr
예제 #52
0
#!/usr/bin/env python
# encoding: utf-8

from os.path import dirname, abspath, join as pjoin
from functools import partial
from scripttest import TestFileEnvironment

here = dirname(abspath(__file__))
env = TestFileEnvironment(pjoin(here, './test-output'))

feed1 = '%s/feeds/jenkins.rss' % here
cmd = 'rsstail'

run = partial(env.run, expect_stderr=True)


def test_run_no_args_no_opts():
    r = run(cmd)
    assert r.returncode == 0
    assert 'General Options:' in r.stdout


def test_run_initial():
    r = run(cmd + ' -e 1 --initial 3 %s' % feed1)
    assert len(r.stdout.splitlines()) == 3


def test_run_order():
    r = run(cmd + ' -e 1 --reverse --title %s' % feed1)

    exp = [
예제 #53
0
def env():
    yield TestFileEnvironment(cwd=".", )
예제 #54
0
def before_scenario(context, _):
    context.env = TestFileEnvironment(
        base_path=os.path.join(root_dir, 'tmp/features'))