Python pytest.fail函数代码示例

def test_freeze_bazaar_clone(script, tmpdir):
    """
    Test freezing a Bazaar clone.

    """
    try:
        checkout_path = _create_test_package(script, vcs='bazaar')
    except OSError as e:
        pytest.fail('Invoking `bzr` failed: %s' % e)

    result = script.run(
        'bzr', 'checkout', checkout_path, 'bzr-package'
    )
    result = script.run(
        'python', 'setup.py', 'develop',
        cwd=script.scratch_path / 'bzr-package',
        expect_stderr=True,
    )
    result = script.pip('freeze', expect_stderr=True)
    expected = textwrap.dedent("""\
        ...-e bzr+file://[email protected]#egg=version_pkg
        ...""")
    _check_output(result.stdout, expected)

    result = script.pip(
        'freeze', '-f',
        '%s/#egg=django-wikiapp' % checkout_path,
        expect_stderr=True,
    )
    expected = textwrap.dedent("""\
        -f %(repo)s/#egg=django-wikiapp
        ...-e bzr+file://[email protected]#egg=version_pkg
        ...""" % {'repo': checkout_path})
    _check_output(result.stdout, expected)

    def fnmatch_lines(self, lines2):
        """Search the text for matching lines.

        The argument is a list of lines which have to match and can
        use glob wildcards.  If they do not match an pytest.fail() is
        called.  The matches and non-matches are also printed on
        stdout.

        """
        def show(arg1, arg2):
            py.builtin.print_(arg1, arg2, file=sys.stderr)
        lines2 = self._getlines(lines2)
        lines1 = self.lines[:]
        nextline = None
        extralines = []
        __tracebackhide__ = True
        for line in lines2:
            nomatchprinted = False
            while lines1:
                nextline = lines1.pop(0)
                if line == nextline:
                    show("exact match:", repr(line))
                    break
                elif fnmatch(nextline, line):
                    show("fnmatch:", repr(line))
                    show("   with:", repr(nextline))
                    break
                else:
                    if not nomatchprinted:
                        show("nomatch:", repr(line))
                        nomatchprinted = True
                    show("    and:", repr(nextline))
                extralines.append(nextline)
            else:
                pytest.fail("remains unmatched: %r, see stderr" % (line,))

    def test_implement_tokenize_words(self):
        """
        Ensure functionality is implemented.

        | *Test Suite ID* : L
        |
        | *Test Case Number* : 04
        |
        | *Description* : Ensure that the word level clean functionality
        |                 is implemented in the class.
        |                 Tests :func:`LeipzigPreprocessor._tokenize_words`
        |
        | *Preconditions* : LeipzigPreprocessor class instance exists.
        |
        | *Test Parameters* : sentence passed to function.
        |
        | *Test Data* : sentence=''
        |
        | *Expected Result* : NotImplementedError exception is not raised.
        |
        | *Actual Result* : NotImplementedError exception is not raised.
        |
        | **Status : Pass**
        |

        """
        testing_object = self.__class__.testing_obj
        try:
            testing_object._tokenize_words(sentence='')
        except NotImplementedError:
            pytest.fail('Not Implemented _tokenize_words function')

    def destroy_marathon_app(self, app_name, timeout=300):
        """Remove a marathon app

        Abort the test if the removal was unsuccesful.

        Args:
            app_name: name of the applicatoin to remove
            timeout: seconds to wait for destruction before failing test
        """
        @retrying.retry(wait_fixed=1000, stop_max_delay=timeout*1000,
                        retry_on_result=lambda ret: not ret,
                        retry_on_exception=lambda x: False)
        def _destroy_complete(deployment_id):
            r = self.get('/marathon/v2/deployments', headers=self._marathon_req_headers())
            assert r.ok

            for deployment in r.json():
                if deployment_id == deployment.get('id'):
                    logging.info('Waiting for application to be destroyed')
                    return False
            logging.info('Application destroyed')
            return True

        r = self.delete('/marathon/v2/apps' + app_name, headers=self._marathon_req_headers())
        assert r.ok

        try:
            _destroy_complete(r.json()['deploymentId'])
        except retrying.RetryError:
            pytest.fail("Application destroy failed - operation was not "
                        "completed in {} seconds.".format(timeout))

def verify_source(source_files, gz_path):
    """Ensure the std python dist files and source_files are in the .tar.gz."""

    f_name = glob.glob(os.path.join(gz_path, "*.tar.gz"))[0]
    with tarfile.open(f_name, "r:gz") as tar_file:
        tar_files = tar_file.getnames()

    pkg_full_name = os.path.basename(
        os.path.dirname(gz_path)
    ).split(".tar.gz")[0]
    egg_name = "{}.egg-info".format(pkg_full_name.rsplit("-")[0])  # fragile..
    source_files.extend([
        "PKG-INFO",
        egg_name,
        os.path.join(egg_name, "dependency_links.txt"),
        os.path.join(egg_name, "PKG-INFO"),
        os.path.join(egg_name, "SOURCES.txt"),
        os.path.join(egg_name, "top_level.txt"),
        "setup.cfg",
        "setup.py",
    ])
    assert len(tar_files) == len(source_files) + 1  # +1 for the base dir
    base_dir_skipped = False
    for tar_file in tar_files:
        assert tar_file.startswith(pkg_full_name)
        if os.path.sep in tar_file:
            tar_file = tar_file[tar_file.index(os.path.sep) + 1:]
            assert tar_file in source_files
        elif not base_dir_skipped:
            base_dir_skipped = True
        else:
            pytest.fail("{} not expected in source dist!".format(tar_file))

    def _test_executables(self, name, args, runtime, run_from_path):
        """
        Run created executable to make sure it works.

        Multipackage-tests generate more than one exe-file and all of
        them have to be run.

        :param args: CLI options to pass to the created executable.
        :param runtime: Time in miliseconds how long to keep the executable running.

        :return: Exit code of the executable.
        """
        __tracebackhide__ = True
        # TODO implement runtime - kill the app (Ctrl+C) when time times out
        exes = self._find_executables(name)
        # Empty list means that PyInstaller probably failed to create any executable.
        assert exes != [], 'No executable file was found.'
        for exe in exes:
            # Try to find .toc log file. .toc log file has the same basename as exe file.
            toc_log = os.path.join(_LOGS_DIR, os.path.basename(exe) + '.toc')
            if os.path.exists(toc_log):
                if not self._examine_executable(exe, toc_log):
                    pytest.fail('Matching .toc of %s failed.' % exe)
            retcode = self._run_executable(exe, args, run_from_path, runtime)
            if retcode != 0:
                pytest.fail('Running exe %s failed with return-code %s.' %
                            (exe, retcode))

def test_insert(empty_warehouse):
    """
    Inserts a fact with MAX_ITERATIONS ^ 2 rows.
    """
    enable_logging()

    Warehouse.use(empty_warehouse)

    Store.build()
    stores = _get_instances('store')
    Store.insert(*stores)

    Product.build()
    products = _get_instances('product')
    Product.insert(*products)

    Sales.build()
    sales = _get_instances('sales')

    start_time = datetime.datetime.now()
    print 'Starting bulk insert of fact at ', start_time

    try:
        Sales.insert(*sales)
    except OperationalError:
        pytest.fail('The connection broke.')

    end_time = datetime.datetime.now()
    print 'Ending bulk insert of fact at ', end_time

    delta = end_time - start_time
    print 'Time taken = ', delta

def test_blocking_read(conn, monkeypatch):
    path = '/foo/wurfl'
    chunks = [120] * 10
    delay = 10

    while True:
        monkeypatch.setattr(MockRequestHandler, 'do_GET',
                            get_chunked_GET_handler(path, chunks, delay))
        conn.send_request('GET', path)

        resp = conn.read_response()
        assert resp.status == 200

        interrupted = 0
        parts = []
        while True:
            crt = conn.co_read(100)
            try:
                while True:
                    io_req = next(crt)
                    interrupted += 1
                    assert io_req.poll(5)
            except StopIteration as exc:
                buf = exc.value
                if not buf:
                    break
                parts.append(buf)
        assert not conn.response_pending()

        assert _join(parts) == b''.join(DUMMY_DATA[:x] for x in chunks)
        if interrupted >= 8:
            break
        elif delay > 5000:
            pytest.fail('no blocking read even with %f sec sleep' % delay)
        delay *= 2

def test_action_tag(request, assign_policy_for_testing, vm, vm_off, vm_crud_refresh):
    """ Tests action tag

    Metadata:
        test_flag: actions, provision
    """
    if any(tag.category.display_name == "Service Level" and tag.display_name == "Gold"
           for tag in vm.crud.get_tags()):
        vm.crud.remove_tag(("Service Level", "Gold"))

    tag_assign_action = actions.Action(
        fauxfactory.gen_alphanumeric(),
        action_type="Tag",
        action_values={"tag": ("My Company Tags", "Service Level", "Gold")}
    )
    assign_policy_for_testing.assign_actions_to_event("VM Power On", [tag_assign_action])

    @request.addfinalizer
    def finalize():
        assign_policy_for_testing.assign_events()
        tag_assign_action.delete()

    vm.start_vm()
    vm_crud_refresh()
    try:
        wait_for(
            lambda: any(tag.category.display_name == "Service Level" and tag.display_name == "Gold"
                        for tag in vm.crud.get_tags()),
            num_sec=600,
            message="tag presence check"
        )
    except TimedOutError:
        pytest.fail("Tags were not assigned!")

    def tst_lock_rm(self):

        # Extract tar
        tempdir = os.path.join(self.mnt_dir, 'lock_dir')
        filename = os.path.join(tempdir, 'myfile')
        os.mkdir(tempdir)
        with open(filename, 'w') as fh:
            fh.write('Hello, world')

        # copy
        try:
            s3ql.lock.main([tempdir])
        except:
            sys.excepthook(*sys.exc_info())
            pytest.fail("s3qllock raised exception")

        # Try to delete
        assert_raises(PermissionError, os.unlink, filename)

        # Try to write
        with pytest.raises(PermissionError):
            open(filename, 'w+').write('Hello')

        # delete properly
        try:
            s3ql.remove.main([tempdir])
        except:
            sys.excepthook(*sys.exc_info())
            pytest.fail("s3qlrm raised exception")

        assert 'lock_dir' not in llfuse.listdir(self.mnt_dir)

    def _test_run(self, protocol):
        fh = open('/tmp/hb.txt', 'w')
        list_for_find = ['wrtest.com', 'some', 'nf', 'aaa.wrtest.com']
        for obj in list_for_find:
            fh.write("{0}\n".format(obj))
        fh.close()

        queue = HostsBruteJob()
        generator = FileGenerator('/tmp/hb.txt')
        queue.set_generator(generator)

        result = []
        thrd = HostsBruteThread(
            queue=queue,
            protocol=protocol,
            host='wrtest.com',
            template='@',
            mask_symbol='@',
            false_phrase='403 Forbidden',
            retest_codes='',
            delay=0,
            ignore_words_re='',
            counter=CounterMock(),
            result=result
        )
        thrd.setDaemon(True)
        thrd.start()

        start_time = int(time.time())
        while not thrd.done:
            if int(time.time()) - start_time > self.threads_max_work_time:
                pytest.fail("Thread work {0} secs".format(int(time.time()) - start_time))
            time.sleep(1)

        assert result == ['wrtest.com', 'aaa.wrtest.com']

def test_mrsid_online_4():

    if gdaltest.jp2mrsid_drv is None:
        pytest.skip()

    if not gdaltest.download_file('http://www.openjpeg.org/samples/Bretagne2.j2k', 'Bretagne2.j2k'):
        pytest.skip()
    if not gdaltest.download_file('http://www.openjpeg.org/samples/Bretagne2.bmp', 'Bretagne2.bmp'):
        pytest.skip()

    # Checksum = 53186 on my PC
    tst = gdaltest.GDALTest('JP2MrSID', 'tmp/cache/Bretagne2.j2k', 1, None, filename_absolute=1)

    tst.testOpen()

    ds = gdal.Open('tmp/cache/Bretagne2.j2k')
    ds_ref = gdal.Open('tmp/cache/Bretagne2.bmp')
    maxdiff = gdaltest.compare_ds(ds, ds_ref, width=256, height=256)

    ds = None
    ds_ref = None

    # Difference between the image before and after compression
    if maxdiff > 1:
        print(ds.GetRasterBand(1).Checksum())
        print(ds_ref.GetRasterBand(1).Checksum())
        pytest.fail('Image too different from reference')

def test_mrsid_2():

    if gdaltest.mrsid_drv is None:
        pytest.skip()

    ds = gdal.Open('data/mercator.sid')

    try:
        data = ds.ReadRaster(0, 0, 515, 515, buf_xsize=10, buf_ysize=10)
    except:
        pytest.fail('Small overview read failed: ' + gdal.GetLastErrorMsg())

    ds = None

    is_bytes = False
    if (isinstance(data, bytes) and not isinstance(data, str)):
        is_bytes = True

    # check that we got roughly the right values by checking mean.
    if is_bytes is True:
        total = sum(data)
    else:
        total = sum([ord(c) for c in data])

    mean = float(total) / len(data)

    assert mean >= 95 and mean <= 105, 'image mean out of range.'

def test_vm_discovery(request, setup_provider, provider, vm_crud):
    """ Tests whether cfme will discover a vm change (add/delete) without being manually refreshed.

    Prerequisities:
        * Desired provider set up

    Steps:
        * Create a virtual machine on the provider.
        * Wait for the VM to appear
        * Delete the VM from the provider (not using CFME)
        * Wait for the VM to become Archived.

    Metadata:
        test_flag: discovery
    """

    @request.addfinalizer
    def _cleanup():
        vm_crud.delete_from_provider()
        if_scvmm_refresh_provider(provider)

    vm_crud.create_on_provider(allow_skip="default")
    if_scvmm_refresh_provider(provider)

    try:
        vm_crud.wait_to_appear(timeout=600, load_details=False)
    except TimedOutError:
        pytest.fail("VM was not found in CFME")
    vm_crud.delete_from_provider()
    if_scvmm_refresh_provider(provider)
    wait_for_vm_state_changes(vm_crud)

def test_abort_co_read(conn, monkeypatch):
    # We need to delay the write to ensure that we encounter a blocking read
    path = '/foo/wurfl'
    chunks = [300, 317, 283]
    delay = 10
    while True:
        monkeypatch.setattr(MockRequestHandler, 'do_GET',
                            get_chunked_GET_handler(path, chunks, delay))
        conn.send_request('GET', path)
        resp = conn.read_response()
        assert resp.status == 200
        cofun = conn.co_read(450)
        try:
            next(cofun)
        except StopIteration:
            # Not good, need to wait longer
            pass
        else:
            break
        finally:
            conn.disconnect()

        if delay > 5000:
            pytest.fail('no blocking read even with %f sec sleep' % delay)
        delay *= 2

    assert_raises(dugong.ConnectionClosed, next, cofun)