Ejemplo n.º 1
0
    def test_label_single_transaction(self):
        test_file = os.path.join(RESOURCES_DIR, "test_single_transaction.py")
        self.assertTrue(os.path.exists(test_file))
        store.writer = CachingWriter()
        nose2.discover(
            argv=[__file__, "tests.resources.test_single_transaction", '-v'],
            module="None",
            exit=False,
            plugins=["tests.unit.test_samples"])
        samples = store.writer.samples
        self.assertEqual(len(samples), 1)

        toplevel = samples[0]
        self.assertEqual(2, len(toplevel.subsamples))
        first, second = toplevel.subsamples

        self.assertEqual(first.test_suite, "test_requests")
        self.assertEqual(first.test_case, "blazedemo 123")
        self.assertEqual(1, len(first.subsamples))
        first_req = first.subsamples[0]
        self.assertEqual(first_req.test_suite, "blazedemo 123")
        self.assertEqual(first_req.test_case,
                         'https://api.demoblaze.com/entries')

        self.assertEqual(second.test_suite, "test_requests")
        self.assertEqual(second.test_case, "blazedemo 456")
        self.assertEqual(1, len(second.subsamples))
        second_req = second.subsamples[0]
        self.assertEqual(second_req.test_suite, "blazedemo 456")
        self.assertEqual(second_req.test_case,
                         'https://api.demoblaze.com/entries')
Ejemplo n.º 2
0
    def test_two_transactions(self):
        test_file = os.path.join(RESOURCES_DIR, "test_two_transactions.py")
        self.assertTrue(os.path.exists(test_file))
        store.writer = CachingWriter()
        nose2.discover(
            argv=[__file__, "tests.resources.test_two_transactions", '-v'],
            module="None",
            exit=False,
            plugins=["tests.unit.test_samples"])
        samples = store.writer.samples
        self.assertEqual(len(samples), 2)
        first, second = samples

        self.assertEqual(first.test_case, "test_simple")
        self.assertEqual(1, len(first.subsamples))
        self.assertEqual(first.subsamples[0].test_case, "1st")
        self.assertEqual(first.subsamples[0].subsamples[0].test_case,
                         'https://blazedemo.com/')
        self.assertEqual(first.subsamples[0].subsamples[0].assertions[0].name,
                         'assert_ok')

        self.assertEqual(second.test_case, "test_simple")
        self.assertEqual(1, len(second.subsamples))
        self.assertEqual(second.subsamples[0].test_case, "2nd")
        self.assertEqual(second.subsamples[0].subsamples[0].test_case,
                         'https://blazedemo.com/vacation.html')
Ejemplo n.º 3
0
def main():
    address = os.getenv('TEST_HOST')
    user = os.getenv('TEST_USERNAME')
    password = os.getenv('TEST_PASSWORD')
    xml = os.getenv('TEST_XML')

    ctx = Context(address, user, password, xml.lower() == 'yes')
    nose2.discover(extraHooks=[('startTest', ContextInjector(ctx))])
Ejemplo n.º 4
0
def main(cli):
    """Use nose2 to run unittests
    """
    try:
        import nose2
    except ImportError:
        cli.log.error(
            'Could not import nose2! Please install it with {fg_cyan}pip3 install nose2'
        )
        return False

    nose2.discover()
Ejemplo n.º 5
0
def runTestsForEnv(env, args):
    nose_base_args = _getNoseCommandLineArgs(args)
    nose_args = list(nose_base_args)

    if args.tests:
        nose_args += args.tests
    else:
        nose_args += _getDefaultTestByEnv(env)

    if env in TEST_ENVS and not _ON_WINDOWS:
        test_env = TEST_ENVS[env]
        test_env.update(
            {'HDLCC_SERVER_LOG_LEVEL' : args.log_level})

        patch = mock.patch.dict('os.environ', test_env)
    else:
        patch = mock.patch.dict(
            'os.environ',
            {'HDLCC_SERVER_LOG_LEVEL' : args.log_level})

    patch.start()
    tests = nose2.discover(exit=False, argv=nose_args)
    patch.stop()

    return tests.result.wasSuccessful()
Ejemplo n.º 6
0
def runTestsForEnv(args):
    nose_base_args = _getNoseCommandLineArgs(args)
    nose_args = list(nose_base_args)

    if args.tests:
        nose_args += args.tests

    test_env = os.environ.copy()

    test_env.update({"SERVER_LOG_LEVEL": args.log_level})

    home = p.join(os.environ["TOX_ENV_DIR"], "tmp", "home")
    os.makedirs(home)

    if not _ON_WINDOWS:
        test_env.update({"HOME": home})
    else:
        test_env.update({"LOCALAPPDATA": home})

    _logger.info("nose2 args: %s", nose_args)

    with mock.patch.dict("os.environ", test_env):
        successful = nose2.discover(exit=False,
                                    argv=nose_args).result.wasSuccessful()

    return successful
Ejemplo n.º 7
0
    def _run(self):
        argv = ['']
        argv += self.test_args.split()
        collector = Nose2ResultsCollector()

        with open(os.devnull, 'w') as devnull:
            with redirect_stdout(devnull):
                with redirect_stderr(devnull):
                    nose2.discover(argv=argv,
                                   extraHooks=[('testOutcome', collector)],
                                   exit=False)
        failures = [x for x in collector.events if x.outcome != 'passed']

        return (not failures, [(str(r.test),
                                traceback.format_exception(*r.exc_info))
                               for r in failures])
Ejemplo n.º 8
0
 def communicate(self):
     with self:
         try:
             self.result = discover(
                 argv=('nose2',) + self.args, exit=False,
                 **self.kwargs)
         except SystemExit as e:
             pass
         return self.stdout.getvalue(), self.stderr.getvalue()
Ejemplo n.º 9
0
 def communicate(self):
     with self:
         try:
             self.result = discover(argv=('nose2', ) + self.args,
                                    exit=False,
                                    **self.kwargs)
         except SystemExit as e:
             self._exit_code = e.code
         return self.stdout.getvalue(), self.stderr.getvalue()
Ejemplo n.º 10
0
 def communicate(self):
     with self:
         try:
             self.result = discover(argv=('nose2', ) + self.args,
                                    exit=False,
                                    **self.kwargs)
         except SystemExit as e:
             return "", "EXIT CODE %s" % str(e)
         return self.stdout.getvalue(), self.stderr.getvalue()
Ejemplo n.º 11
0
def iterAllTestPathsFromRootDir(startDirOrModuleName, topDir=None):
    argv = [
        "nose2",
        "--plugin",
        "iutest.plugins.nose2plugins.testlister",
        "--list-tests",
        "--plugin",
        "nose2.plugins.loader.eggdiscovery",
        "--exclude-plugin",
        "nose2.plugins.result",
    ]
    extraHooks = duplicationremoval.TestsDuplicationRemovalHooks.getHooks()
    if pathutils.isPath(startDirOrModuleName):
        argv.extend(["-s", startDirOrModuleName, "-t", topDir])
    else:
        argv.append(startDirOrModuleName)

    TestCollector.gotError = False
    nose2.discover(argv=argv, exit=False, extraHooks=extraHooks)
    for tid in TestCollector.iterTestIds():
        yield tid
Ejemplo n.º 12
0
def main(test_names=None):
    import pkgutil

    if not test_names:
        test_names = []
        #for name in ['test_new']:
        #    test_names.append(name)
        for _, name, _ in pkgutil.iter_modules([os.path.dirname(__file__)]):
            test_names.append(name)

    suite = unittest.TestSuite()
    for name in test_names:
        str2 = re.search('^(test_[a-z_]+)', name)
        if str2:
            try:
                suite.addTest(unittest.TestLoader().loadTestsFromName(name))
            except unittest.SkipTest as exc:
                print('###{0}###: {1}'.format(__name__, repr(exc)))
    #unittest.TextTestRunner(verbosity = 2).run(suite)
    nose2.discover(argv=sys.argv[:1] + test_names)
    return 0
Ejemplo n.º 13
0
def _noseRunner(args):
    "Runs nose2 with coverage"
    _logger.info("nose2 args: %s", repr(args))
    cov = coverage.Coverage(config_file='.coveragerc')
    cov.start()

    try:
        result = nose2.discover(exit=False, argv=args)
    finally:
        cov.stop()
        cov.save()

    return result
Ejemplo n.º 14
0
def test(coverage=False):
    """Run unit tests."""
    import nose2

    script_path = os.path.realpath(__file__)
    server_path = os.path.dirname(script_path) #+ '/tests'

    # Remember that the first argument is always current file
    arguments = [script_path, '-s', server_path]
    plugins = ['nose2.plugins.layers']

    if coverage:
        arguments.append('--with-coverage')

    return nose2.discover(argv=arguments, plugins=plugins)
Ejemplo n.º 15
0
def run_tests(python3=False, plugins=None):
    """Discover unittests and run them using nose2"""
    hook_args(sys.argv)

    # plugins
    if plugins is None:
        plugins = []
    if python3:
        plugins.append('py3filter')

    # fix_encoding
    sys.path.insert(0, CLIENT_THIRD_PARTY_DIR)
    from depot_tools import fix_encoding
    fix_encoding.fix_encoding()

    # add nose2 plugin dir to path
    sys.path.insert(0, PLUGINS_DIR)
    result = discover(plugins=plugins, exit=False).result
    if not result.wasSuccessful():
        return 1
    return 0
Ejemplo n.º 16
0
"""Main entry point"""

import sys
if sys.argv[0].endswith("__main__.py"):
    sys.argv[0] = "nose2"

__unittest = True


if __name__ == '__main__':
    from nose2 import discover
    discover()
Ejemplo n.º 17
0
            npts=10,
            radians=True)

        # Check they are equal
        for index, dpoint in enumerate(points_d):
            self.assertAlmostEqual(dpoint[0], math.degrees(points_r[index][0]))
            self.assertAlmostEqual(dpoint[1], math.degrees(points_r[index][1]))


class UnicodeTest(unittest.TestCase):
    def setUp(self):
        self.datadir_save = pyproj.datadir.pyproj_datadir

    def tearDown(self):
        # restore the original datapath, othwise this could cause other
        # tests to have errors
        pyproj.set_datapath(self.datadir_save)
        
    def test_utf8_set_datapath(self):
        # Issue #83 reported that Unicode characters in the installation
        # path this would cause a UnicodeEncodeError
        # the path is fictious and not meant to be a real path
        pyproj.set_datapath(u'göteborg')
        

if __name__ == '__main__':
    if HAS_NOSE2 is True:
        nose2.discover()
    else:
        unittest.main()
Ejemplo n.º 18
0
import nose2
import sys
from yoga.yoga import test_env_setup
from yoga.args import yoga_nose_argparser, nose_args

if __name__ == '__main__':
    args = test_env_setup(yoga_nose_argparser)
    res = nose2.discover(argv=nose_args(args)).runTests()
    sys.exit(res)
Ejemplo n.º 19
0
import nose2
nose2.discover()
Ejemplo n.º 20
0
    def test_transactions(self):
        test_file = os.path.join(RESOURCES_DIR, "test_transactions.py")
        self.assertTrue(os.path.exists(test_file))
        store.writer = CachingWriter()
        nose2.discover(
            argv=[__file__, "tests.resources.test_transactions", '-v'],
            module="None",
            exit=False,
            plugins=["tests.unit.test_samples"])
        samples = store.writer.samples
        self.assertEqual(len(samples), 8)

        single = samples[0]
        self.assertEqual(single.test_suite, 'TestTransactions')
        self.assertEqual(single.test_case, 'test_1_single_transaction')
        tran = single.subsamples[0]
        self.assertEqual('test_1_single_transaction', tran.test_suite)
        self.assertEqual('single-transaction', tran.test_case)
        self.assertEqual(tran.status, "PASSED")

        two_trans = samples[1]
        self.assertEqual(two_trans.test_case, 'test_2_two_transactions')
        self.assertEqual(len(two_trans.subsamples), 2)
        first, second = two_trans.subsamples
        self.assertEqual(first.status, "PASSED")
        self.assertEqual(first.test_suite, 'test_2_two_transactions')
        self.assertEqual(first.test_case, 'transaction-1')
        self.assertEqual(second.status, "PASSED")
        self.assertEqual(second.test_suite, 'test_2_two_transactions')
        self.assertEqual(second.test_case, 'transaction-2')

        nested = samples[2]
        middle = nested.subsamples[0]
        self.assertEqual('test_3_nested_transactions.outer',
                         middle.test_suite + '.' + middle.test_case)
        self.assertEqual(middle.status, "PASSED")
        inner = middle.subsamples[0]
        self.assertEqual('outer.inner',
                         inner.test_suite + '.' + inner.test_case)
        self.assertEqual(inner.status, "PASSED")

        no_tran = samples[3]
        self.assertEqual(no_tran.status, "PASSED")
        self.assertEqual(no_tran.test_suite, "TestTransactions")
        self.assertEqual(no_tran.test_case, "test_4_no_transactions")

        with_assert = samples[4]
        self.assertEqual(with_assert.status, "PASSED")
        self.assertEqual(len(with_assert.subsamples), 1)
        request = with_assert.subsamples[0]
        self.assertEqual(request.test_suite, "test_5_apiritif_assertions")
        self.assertEqual(request.test_case, "http://blazedemo.com/")
        self.assertEqual(len(request.assertions), 1)
        assertion = request.assertions[0]
        self.assertEqual(assertion.name, "assert_ok")
        self.assertEqual(assertion.failed, False)

        assert_failed = samples[5]
        self.assertEqual(assert_failed.status, "FAILED")
        request = assert_failed.subsamples[0]
        self.assertEqual(request.test_suite,
                         "test_6_apiritif_assertions_failed")
        self.assertEqual(request.test_case, "http://blazedemo.com/")
        self.assertEqual(len(request.assertions), 1)
        assertion = request.assertions[0]
        self.assertEqual(assertion.name, "assert_failed")
        self.assertEqual(assertion.failed, True)
        self.assertEqual(
            assertion.error_message,
            "Request to https://blazedemo.com/ didn't fail (200)")

        assert_failed_req = samples[6]
        self.assertEqual(assert_failed_req.status, "FAILED")
        request = assert_failed_req.subsamples[0]
        self.assertEqual(request.test_suite, "test_7_failed_request")
        self.assertEqual(request.test_case, "http://notexists")
        self.assertEqual(len(request.assertions), 0)

        # checks if series of assertions is recorded into trace correctly
        assert_seq_problem = samples[7]
        self.assertEqual(assert_seq_problem.status, "FAILED")
        request = assert_seq_problem.subsamples[0]
        self.assertEqual(request.test_suite, "test_8_assertion_trace_problem")
        self.assertEqual(len(request.assertions), 3)
        self.assertFalse(request.assertions[0].failed)
        self.assertFalse(request.assertions[1].failed)
        self.assertTrue(request.assertions[2].failed)
Ejemplo n.º 21
0
def runNose2():
    import nose2
    nose2.discover(exit=False)
Ejemplo n.º 22
0
#!/usr/bin/env python
"""
HACK to support the Django + nose without django-nose.
Built based on documentation from:
* https://docs.djangoproject.com/en/1.8/topics/testing/advanced/#using-the-django-test-runner-to-test-reusable-applications
* http://nose.readthedocs.org/en/latest/usage.html#basic-usage
"""
import os
import sys

import nose2
import django
from django.conf import settings


if __name__ == '__main__':
    settings.configure()
    django.setup()
    settings.BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
    settings.DJANGO_LIVESYNC = {'PORT': 9001, 'HOST': '127.0.0.1'}
    result = nose2.discover()
    if not result:
        sys.exit(1)
Ejemplo n.º 23
0
# import unittest
# from selenium import webdriver
#  
# class AweberTest(unittest.TestCase):
#  
#     #@classmethod
#     def setUpClass(cls):
#         cls.driver = webdriver.Firefox()
#  
#     def test_title(self):
#         self.driver.get('https://www.aweber.com')
#         self.assertEqual(
#             self.driver.title,
#             'AWeber Email Marketing Services & Software Solutions for Small Business')
#  
#    # @classmethod
#     def tearDownClass(cls):
#==============================================================================
        #cls.driver.quit()
if __name__ == '__main__':
    import nose2
    
    class Hello(object):
        def startTestRun(self,event):
            print('hello!')
    nose2.discover(extraHooks=[('startTestRun', Hello())])

        


Ejemplo n.º 24
0
def run_all():
    import nose2
    nose2.discover(module='pygraphml')
Ejemplo n.º 25
0
#!/usr/bin/env python
# -*- coding: utf-8 -*-

try:
    import nose2
except ImportError:
    message = """nose2 package not installed, install test requirements with:

    pip install -r requirements-test.txt
    """
    raise ImportError(message)

if __name__ == "__main__":
    result = nose2.discover()
    if result is False:
        import sys
        sys.exit(1)
Ejemplo n.º 26
0
import nose2
from nose2.tools import params

from game import Frame, Game


class FrameTests(unittest.TestCase):
    def setUp(self):
        # We probably need a frame object every time
        self.frame = Frame()


class GameTests(unittest.TestCase):
    def setUp(self):
        # We probably need a game object every time
        self.game = Game()


if __name__ == '__main__':
    # Construct command line
    CURRENT_DIRECTORY = os.path.dirname(os.path.abspath(__file__))
    PARENT_DIRECTORY = os.path.split(CURRENT_DIRECTORY)[0]
    argv = [
        sys.argv[0],
        '-s',
        PARENT_DIRECTORY
    ]

    # Run the tests with exit=False so we can print coverage after
    nose2.discover(argv=argv)