예제 #1
0
파일: test_fx.py 프로젝트: tbarron/fx
def test_subst_rename_quiet(tmpdir, capsys):
    """
    Test subst_rename() with dryrun False and quiet True.
    """
    pytest.dbgfunc()
    with tbx.chdir(tmpdir.strpath):
        arglist = ['a.pl', 'b.pl', 'c.pl']
        for a in arglist:
            tmpdir.join(a).ensure()
        expected = "".join([
            'rename %s.pl %s.xyzzy\n' % (x, x)
            for x in [q.replace('.pl', '') for q in arglist]
        ])
        exp = [re.sub('.pl', '.xyzzy', x) for x in arglist]
        v = {
            '-n': False,
            '-q': True,
            '-e': True,
            'SUBSTITUTION': "s/.pl/.xyzzy"
        }
        fx.subst_rename(v, arglist)
        assert expected in " ".join(capsys.readouterr())
        q = glob.glob('*.pl')
        q.sort()
        assert [] == q
        q = glob.glob('*.xyzzy')
        q.sort()
        assert exp == q
예제 #2
0
def test_td_dhms(inp, exp):
    """
    test td.dhhmmss()
    """
    pytest.dbgfunc()
    obj = td(inp)
    assert obj.dhms() == exp
예제 #3
0
def test_chdir_rug(tmpdir):
    """
    Trying to chdir out af a non existent directory (i.e., one that was removed
    after we chdir'd into it)
    """
    pytest.dbgfunc()
    origin = os.getcwd()
    rug = tmpdir.join('foo/bar/nosuch')
    rug.ensure(dir=True)
    with tbx.chdir(rug.strpath):
        shutil.rmtree(rug.dirname)
        with pytest.raises(OSError) as err:
            with tbx.chdir('..'):
                assert os.getcwd() == origin
        assert any([
            'No such file or directory' in str(err.value), 'Invalid argument'
            in str(err.value)
        ])
        with pytest.raises(OSError) as err:
            assert os.getcwd() == rug.strpath
    assert os.getcwd() == origin
    assert any([
        'No such file or directory' in str(err.value), 'Invalid argument'
        in str(err.value)
    ])
예제 #4
0
def test_function_doc():
    """
    Verify that each of our functions have a __doc__ string
    """
    pytest.dbgfunc()

    importables = ['pyppi.__main__']
    importables.extend([tbx.basename(_).replace('.py', '')
                        for _ in glob.glob('tests/*.py')])

    missing_doc = []
    for mname in importables:
        mod = import_module(mname)
        for name, obj in inspect.getmembers(mod, inspect.isclass):
            if doc_missing(obj) and name not in missing_doc:
                missing_doc.append(name)

            for mthname, mthobj in inspect.getmembers(obj, inspect.isfunction):
                if name in ['pypath', 'local']:
                    continue
                if doc_missing(mthobj) and mthname not in missing_doc:
                    missing_doc.append("{}.{}".format(name, mthname))

        for name, obj in inspect.getmembers(mod, inspect.isfunction):
            if doc_missing(obj) and name not in missing_doc:
                missing_doc.append("{}.{}".format(mname, name))

    if missing_doc:
        pytest.fail("Items missing __doc__:\n   " + "\n   ".join(missing_doc))
예제 #5
0
def test_build_index_htmls(tmpdir, fx_cfgfile):
    """
    After calling build_index_htmls(), verify that the expected files exist and
    have (approximately) the right content
    """
    pytest.dbgfunc()
    cfg = fx_cfgfile
    root = pypath(cfg['root'])
    pkg_d = cfg['packages']
    pmain.build_dirs(cfg)
    pmain.build_index_htmls(cfg)                                      # payload

    rootidx = root.join("index.html")
    assert rootidx.exists()
    assert "<!DOCTYPE html>" in rootidx.read()
    base = root.basename
    for pkgname in pkg_d:
        assert "/{}/{}/".format(base, pkgname) in rootidx.read()

        pkgidx = root.join(pkgname, "index.html")
        assert "<!DOCTYPE html>" in pkgidx.read()
        for release in pkg_d[pkgname]:
            assert release['url'] in pkgidx.read()
            assert release['version'] in pkgidx.read()
            if 'minpy' in release:
                assert release['minpy'] in pkgidx.read()
예제 #6
0
def test_version():
    """
    Verify that tbx.version() returns a valid version string
    """
    pytest.dbgfunc()
    assert re.match(r"\d\.\d\.\d", tbx.version())
    assert tbx.version() == tbx.verinfo._v
예제 #7
0
def test_contents_good_str(ctest):
    """
    Calling contents on a file that exists as a string
    """
    pytest.dbgfunc()
    result = tbx.contents(ctest.data.strpath)
    assert result == ctest.exp
예제 #8
0
파일: test_tbx.py 프로젝트: tbarron/tbx
def test_contents_good_str(ctest):
    """
    Calling contents on a file that exists as a string
    """
    pytest.dbgfunc()
    result = tbx.contents(ctest.data.strpath)
    assert result == ctest.exp
예제 #9
0
def test_nodoc():
    """
    Report routines missing a doc string
    """
    pytest.dbgfunc()

    # get our bearings -- where is hpssic?
    hpssic_dir = U.dirname(sys.modules['hpssic'].__file__)

    excludes = ['setup.py', '__init__.py']

    # up a level from there, do we have a '.git' directory? That is, are we in
    # a git repository? If so, we want to talk the whole repo for .py files
    hpssic_par = U.dirname(hpssic_dir)
    if not os.path.isdir(U.pathjoin(hpssic_par, ".git")):
        # otherwise, we just work from hpssic down
        wroot = hpssic_dir
    else:
        wroot = hpssic_par

    # collect all the .py files in pylist
    pylist = []
    for r, dlist, flist in os.walk(wroot):
        if '.git' in dlist:
            dlist.remove('.git')
        pylist.extend([
            U.pathjoin(r, x) for x in flist
            if x.endswith('.py') and x not in excludes
        ])

    # make a list of the modules implied in pylist in mdict. Each module name
    # is a key. The associated value is False until the module is checked.
    mlist = ['hpssic']
    for path in pylist:
        # Throw away the hpssic parent string, '.py' at the end, and split on
        # '/' to get a list of the module components
        mp = path.replace(hpssic_par + '/', '').replace('.py', '').split('/')

        if 1 < len(mp):
            fromlist = ['hpssic']
        else:
            fromlist = []
        mname = '.'.join(mp)
        if mname.startswith('hpssic'):
            mlist.append(mname)
        if mname not in sys.modules and mname.startswith('hpssic'):
            try:
                __import__(mname, fromlist=fromlist)

            except ImportError:
                pytest.fail('Failure trying to import %s' % mname)

    result = ''
    for m in mlist:
        result += nodoc_check(sys.modules[m], pylist, 0, 't')

    # result = nodoc_check(hpssic, 0, 't')
    if result != '':
        result = "The following functions need doc strings:\n" + result
        pytest.fail(result)
예제 #10
0
def test_open_note_title_succ(tnt):  # noqa: F811
    """
    Test for bear.open_note()
    """
    pytest.dbgfunc()
    by_title = tnt["cub"].open_note(title=tnt["title"])
    assert by_title['title'] == tnt['title']
예제 #11
0
파일: test_tbx.py 프로젝트: tbarron/tbx
def test_contents_good_list(ctest):
    """
    Calling contents on a file that exists as a list
    """
    pytest.dbgfunc()
    result = tbx.contents(ctest.data.strpath, fmt='list')
    assert result == ctest.exp.split('\n')
예제 #12
0
def test_has_tag(tnt):  # noqa: F811
    """
    Test for bear.has_tag(). Use fixture tnt.
    """
    pytest.dbgfunc()
    assert tnt["cub"].has_tag(tnt["id"], "testing")
    assert not tnt["cub"].has_tag(tnt["id"], "newtag2")
예제 #13
0
def tzst_create_file_only(tmpdir):
    """
    create a note with just a file (filename required).

    Creating a note with just a file and no title or text fails on the note
    being empty. After creating the note as here, there's no evidence of the
    file in the note.

    Aha! I was overwriting the file content with the file name. Let's try it
    again...

    Well, when I pass both file and filename, with the file content base64
    encoded, what I get is 'File not in a valid base64 form'. It's not clear
    what the problem is. Guess I'll need to reach out to bear again.
    """
    pytest.dbgfunc()
    cub = Bear()
    testfile = tmpdir.join("bear-test-data")
    # data = "".join(["This is a file for testing bear\n",
    #                 "It contains a couple of lines\n",
    #                 "and is going to be inserted into a bear note\n"])
    data = "A"
    testfile.write(data)
    frob = base64.b64encode(data.encode())
    note = cub.create(title=beartest_title(),
                      file=frob,
                      filename=testfile.strpath)
    if not note:
        pytest.fail("create returned empty result")
    cub.trash(id=note['identifier'])
예제 #14
0
def test_instantiate():
    """
    Make sure pytest is working
    """
    pytest.dbgfunc()
    cub = Bear()
    assert 'open_note' in dir(cub)
예제 #15
0
파일: test_fx.py 프로젝트: tbarron/fx
def test_version():
    """
    Running 'fx version' should report the current fx version
    """
    pytest.dbgfunc()
    result = tbx.run("python fx version")
    assert result == "fx {}\n".format(fx.version.__version__)
예제 #16
0
파일: test_gh.py 프로젝트: tbarron/gh
def test_task_proj(tasks):
    """
    Given some tasks, report them and verify that they have whitespace between
    them
    """
    pytest.dbgfunc()
    tmpdir = tasks['tmpdir']
    kw = {
        'PROJECT': 'myproj',
        'count': False,
        'd': False,
        's': None,
        'projects': False,
        'tasks': True,
        'version': False
    }
    with tbx.envset(GH_ROOT=tmpdir.strpath):
        result = ghm.gh_tasks_t(**kw)
        assert "\n\n - " in result

    kw = {
        'PROJECT': 'nosuch',
        'count': False,
        'd': False,
        's': None,
        'projects': False,
        'tasks': True,
        'version': False
    }
    with tbx.envset(GH_ROOT=tmpdir.strpath):
        result = ghm.gh_tasks_t(**kw)
        assert result == ""
예제 #17
0
파일: test_fx.py 프로젝트: tbarron/fx
def test_xw_nopct_file(fx_batch):
    """
    Tests for xargs_wrap(cmd: str, rble: fileobj)

      - cmd may contain '%', or not
      - fileobj may be an open file, sys.stdin, a StringIO

    What xargs_wrap is supposed to do, is, given a *cmd* like 'foo % bar', it
    takes lexical items from *rble* and constructs strings of the form

        'foo item1 item2 item3 ... itemn bar'

    such that the strings are only minimally longer than 240 bytes. This is
    like xargs except that I've never figured out a way to get xargs to embed
    stuff in the middle of the command -- it only wants to put stuff at the
    end.

    If *cmd* does not contain a % character (or if all the % chars are
    escaped), xargs_wrap should put the items at the end of cmd.
    """
    pytest.dbgfunc()
    tmppath, data = fx_batch
    with open(tmppath, 'r') as fobj:
        result = fx.xargs_wrap("echo", fobj)
    assert result == data
예제 #18
0
파일: test_gh.py 프로젝트: tbarron/gh
def test_sorts(prjdirs, func, sname):
    """
    Test the sort routines
    """
    pytest.dbgfunc()
    result = func(prjdirs['input'])  # payload
    assert result == prjdirs[sname]
예제 #19
0
def test_contents_good_list(ctest):
    """
    Calling contents on a file that exists as a list
    """
    pytest.dbgfunc()
    result = tbx.contents(ctest.data.strpath, fmt='list')
    assert result == ctest.exp.split('\n')
예제 #20
0
def test_delta(left, right, exp):
    """
    Tests for _delta
    """
    pytest.dbgfunc()
    q = dt()
    assert q._delta(left, right) == exp
예제 #21
0
def test_nodoc():
    """
    Report routines missing a doc string
    """
    pytest.dbgfunc()

    # get our bearings -- where is hpssic?
    hpssic_dir = U.dirname(sys.modules['hpssic'].__file__)

    excludes = ['setup.py', '__init__.py']

    # up a level from there, do we have a '.git' directory? That is, are we in
    # a git repository? If so, we want to talk the whole repo for .py files
    hpssic_par = U.dirname(hpssic_dir)
    if not os.path.isdir(U.pathjoin(hpssic_par, ".git")):
        # otherwise, we just work from hpssic down
        wroot = hpssic_dir
    else:
        wroot = hpssic_par

    # collect all the .py files in pylist
    pylist = []
    for r, dlist, flist in os.walk(wroot):
        if '.git' in dlist:
            dlist.remove('.git')
        pylist.extend([U.pathjoin(r, x)
                       for x in flist
                       if x.endswith('.py') and x not in excludes])

    # make a list of the modules implied in pylist in mdict. Each module name
    # is a key. The associated value is False until the module is checked.
    mlist = ['hpssic']
    for path in pylist:
        # Throw away the hpssic parent string, '.py' at the end, and split on
        # '/' to get a list of the module components
        mp = path.replace(hpssic_par + '/', '').replace('.py', '').split('/')

        if 1 < len(mp):
            fromlist = ['hpssic']
        else:
            fromlist = []
        mname = '.'.join(mp)
        if mname.startswith('hpssic'):
            mlist.append(mname)
        if mname not in sys.modules and mname.startswith('hpssic'):
            try:
                __import__(mname, fromlist=fromlist)

            except ImportError:
                pytest.fail('Failure trying to import %s' % mname)

    result = ''
    for m in mlist:
        result += nodoc_check(sys.modules[m], pylist, 0, 't')

    # result = nodoc_check(hpssic, 0, 't')
    if result != '':
        result = "The following functions need doc strings:\n" + result
        pytest.fail(result)
예제 #22
0
def test_contents_invalid_fmt(ctest):
    """
    Calling contents with an invalid format
    """
    pytest.dbgfunc()
    with pytest.raises(tbx.Error) as err:
        _ = tbx.contents(ctest.data.strpath, fmt='foobar', sep=r'\s')
    assert "Invalid format" in str(err.value)
예제 #23
0
def test_contents_good_altsep(ctest):
    """
    Calling contents on a file that exists as a list
    """
    pytest.dbgfunc()
    result = tbx.contents(ctest.data.strpath, fmt='list', sep=r'\s')
    assert len(result) == len(re.split(r'\s', ctest.exp))
    assert result == re.split(r'\s', ctest.exp)
예제 #24
0
파일: test_tbx.py 프로젝트: tbarron/tbx
def test_contents_good_altsep(ctest):
    """
    Calling contents on a file that exists as a list
    """
    pytest.dbgfunc()
    result = tbx.contents(ctest.data.strpath, fmt='list', sep=r'\s')
    assert len(result) == len(re.split(r'\s', ctest.exp))
    assert result == re.split(r'\s', ctest.exp)
예제 #25
0
def test_grep(rgx, idx, grep_prep):
    """
    Check the results of calling U.grep()
    """
    pytest.dbgfunc()
    f = test_grep
    for n, s in enumerate(f.searches):
        assert U.grep(s, f.testdata, regex=rgx, index=idx) == f.exp[n]
예제 #26
0
def test_grep(rgx, idx, grep_prep):
    """
    Check the results of calling U.grep()
    """
    pytest.dbgfunc()
    f = test_grep
    for n, s in enumerate(f.searches):
        assert U.grep(s, f.testdata, regex=rgx, index=idx) == f.exp[n]
예제 #27
0
파일: test_tbx.py 프로젝트: tbarron/gitr
def test_contents_list(tmpdir, contents_setup):
    """
    Test getting the contents of a file
    """
    pytest.dbgfunc()
    pt = pytest.this
    c = tbx.contents(pt['tfn'].strpath, type=list)
    assert c == [x + '\n' for x in pt['td']]
예제 #28
0
파일: test_tbx.py 프로젝트: tbarron/gitr
def test_run_stdout():
    """
    Run a process and capture stdout
    """
    pytest.dbgfunc()
    r = tbx.run('python -c "import this"')
    assert "Zen of Python" in r
    assert "Namespaces" in r
예제 #29
0
파일: test_tbx.py 프로젝트: tbarron/tbx
def test_run_cmd_istrio(rdata):
    """
    tbx.run(cmd, input=StringIO)
    """
    pytest.dbgfunc()
    result = tbx.run('python', input=StringIO.StringIO('import this\n'))
    for item in rdata.exp:
        assert item in result
예제 #30
0
파일: test_tbx.py 프로젝트: tbarron/gitr
def test_run_fail():
    """
    Run a binary that doesn't exist
    """
    pytest.dbgfunc()
    r = tbx.run("nosuchbinary")
    assert "ERR:" in r
    assert "No such file or directory" in r
예제 #31
0
파일: test_gh.py 프로젝트: tbarron/gh
def test_no_sort(prjdirs):
    """
    What we get if we don't sort a list of projects
    """
    pytest.dbgfunc()
    tup_l = ghm.projects(prjdirs['root'].strpath, False)  # payload
    result = [_[0] for _ in tup_l]
    assert set(result) == set([_.strpath for _ in prjdirs['input']])
예제 #32
0
파일: test_gh.py 프로젝트: tbarron/gh
def test_dodo_filename_x(dodo_existing):
    """
    Run dodo_filename for a file that exists
    """
    pytest.dbgfunc()
    (prjdir, dofile) = dodo_existing
    rval = ghm.dodo_filename(prjdir.strpath)  # payload
    assert rval == dofile.strpath
예제 #33
0
파일: test_gh.py 프로젝트: tbarron/gh
def test_get_tasks_empty(tasks_empty):
    """
    Make get_tasks() return an empty list because no tasks are present
    """
    pytest.dbgfunc()
    path = tasks_empty['prj'].strpath
    task_l = ghm.get_tasks(path)
    assert task_l == []
예제 #34
0
파일: test_gh.py 프로젝트: tbarron/gh
def test_task_markers(tasks, capsys):
    """
    Use all potential task markers to identify tasks
    """
    pytest.dbgfunc()
    path = tasks['prj'].strpath
    task_l = ghm.get_tasks(path)
    assert len(task_l) == 4
예제 #35
0
파일: test_tbx.py 프로젝트: tbarron/gitr
def test_run_stderr():
    """
    Run a process and capture stdout
    """
    pytest.dbgfunc()
    r = tbx.run("ls --nosuch")
    assert "ERR:" in r
    assert re.findall("(illegal|unrecognized) option", r)
예제 #36
0
파일: test_tbx.py 프로젝트: tbarron/tbx
def test_contents_badfmt(ctest):
    """
    Calling contents on a file that exists as a list
    """
    pytest.dbgfunc()
    with pytest.raises(tbx.Error) as err:
        _ = tbx.contents(ctest.data.strpath, fmt='str', sep=r'\s')
    assert 'Non-default separator is only valid for list format' in str(err)
예제 #37
0
def test_zlint():
    """
    Run flake8 on the payload and test code
    """
    pytest.dbgfunc()
    result = subp.Popen(shlex.split("flake8 tbx test"),
                        stdout=subp.PIPE).communicate()[0]
    assert result.decode() == ''
예제 #38
0
파일: test_tbx.py 프로젝트: tbarron/tbx
def test_run_cmd_istr(rdata):
    """
    tbx.run(cmd, input=str)
    """
    pytest.dbgfunc()
    result = tbx.run('python', input='import this\n')
    for item in rdata.exp:
        assert item in result
예제 #39
0
파일: test_tbx.py 프로젝트: tbarron/gitr
def test_contents_str(tmpdir):
    """
    Test getting the contents of a file
    """
    pytest.dbgfunc()
    pt = pytest.this
    c = tbx.contents(pt['tfn'].strpath)
    assert c == ''.join([x + '\n' for x in pt['td']])
예제 #40
0
파일: test_tbx.py 프로젝트: tbarron/gitr
def test_contents_default(tmpdir):
    """
    Test getting the contents of a file
    """
    pytest.dbgfunc()
    pt = pytest.this
    c = tbx.contents(pt['tfn'].strpath + "_nonesuch", default="take this instead")
    assert "take this instead" in c
예제 #41
0
파일: test_tbx.py 프로젝트: tbarron/gitr
def test_chdir(tmpdir):
    """
    Test the chdir contextmanager
    """
    pytest.dbgfunc()
    here = os.getcwd()
    with tbx.chdir(tmpdir.strpath):
        assert os.getcwd() == tmpdir.strpath
    assert os.getcwd() == here
예제 #42
0
파일: test_tbx.py 프로젝트: tbarron/tbx
def test_run_cmd(rdata):
    """
    With just a command (*cmd*), tbx.run() should run the command and return
    its stdout + stderr
    """
    pytest.dbgfunc()
    result = tbx.run("python -c 'import this'")
    for item in rdata.exp:
        assert item in result
예제 #43
0
파일: test_tbx.py 프로젝트: tbarron/tbx
def test_run_noargs():
    """
    Without arguments, tbx.run() should throw a TypeError exception
    """
    pytest.dbgfunc()
    with pytest.raises(TypeError) as err:
        tbx.run()
    assert 'run() takes' in str(err)
    assert 'argument' in str(err)
예제 #44
0
파일: test_tbx.py 프로젝트: tbarron/tbx
def test_dispatch_help_nosuch():
    """
    Dispatch help on a function that does not exist
    """
    pytest.dbgfunc()
    exp = 'Module test.test_tbx has no attribute foo_nosuch'
    with pytest.raises(SystemExit) as err:
        tbx.dispatch(__name__, 'foo', ['help', 'nosuch'])
    assert exp in str(err)
예제 #45
0
파일: test_tbx.py 프로젝트: tbarron/tbx
def test_dispatch_help_nopfx():
    """
    Dispatch help with no prefix
    """
    pytest.dbgfunc()
    exp = '*prefix* is required'
    with pytest.raises(SystemExit) as err:
        tbx.dispatch(__name__, args=['help', 'nosuch'])
    assert exp in str(err)
예제 #46
0
파일: test_tbx.py 프로젝트: tbarron/tbx
def test_dispatch_help_nomodule():
    """
    Dispatch help on a non-existent module
    """
    pytest.dbgfunc()
    exp = 'Module xtest.test_tbx is not in sys.modules'
    with pytest.raises(SystemExit) as err:
        tbx.dispatch('x' + __name__, 'foo', ['help', 'nosuch'])
    assert exp in str(err)
예제 #47
0
파일: test_tbx.py 프로젝트: tbarron/tbx
def test_dispatch_help_nodoc():
    """
    Dispatch help on a function that has no doc string
    """
    pytest.dbgfunc()
    exp = 'Function xtst_undocumented is missing a __doc__ string'
    with pytest.raises(SystemExit) as err:
        tbx.dispatch_help(__name__, 'xtst', ['undocumented'])
    assert exp in str(err)
예제 #48
0
파일: test_tbx.py 프로젝트: tbarron/tbx
def test_dispatch_help_good(capsys):
    """
    Dispatch help on a function that exists and has a doc string
    """
    pytest.dbgfunc()
    exp = 'foobar - print a comma delimited argument list'
    tbx.dispatch_help(__name__, 'dtst', ['foobar'])
    out, _ = capsys.readouterr()
    assert exp in out
예제 #49
0
파일: test_tbx.py 프로젝트: tbarron/gitr
def contents_setup(tmpdir):
    """
    set up data for test
    """
    pytest.dbgfunc()
    pytest.this = {}
    td = pytest.this['td'] = ["one", "two", "three", "four", "five"]
    tfn = pytest.this['tfn'] = tmpdir.join("testthis")
    tfn.write(''.join([x+"\n" for x in td]))
예제 #50
0
파일: test_tbx.py 프로젝트: tbarron/tbx
def test_run_cmd_icmd(rdata):
    """
    tbx.run(cmd, input='cmd |')
    """
    pytest.dbgfunc()
    icmd = "echo 'import this' |"
    result = tbx.run('python', input=icmd)
    for item in rdata.exp:
        assert item in result
예제 #51
0
파일: test_tbx.py 프로젝트: tbarron/tbx
def test_run_cmd_ostr():
    """
    tbx.run(cmd, output='foobar')
        should raise error -- '>' or '|' required
    """
    pytest.dbgfunc()
    with pytest.raises(tbx.Error) as err:
        tbx.run('python -c "import this"', output='foobar')
    assert '| or > required for string output' in str(err)
예제 #52
0
파일: test_tbx.py 프로젝트: tbarron/tbx
def test_contents_badperm(ctest):
    """
    Calling contents on a file that is not readable with throw an exception
    """
    pytest.dbgfunc()
    ctest.data.chmod(0000)
    with pytest.raises(tbx.Error) as err:
        _ = tbx.contents(ctest.data.strpath, fmt=str, sep=r'\s')
    assert "Can't read file {0}".format(ctest.data.strpath) in str(err)
예제 #53
0
파일: test_gitr.py 프로젝트: tbarron/gitr
def test_gitr_unimpl(subc, capsys):
    """
    gitr <subc> -> 'coming soon'
    """
    pytest.dbgfunc()
    func = getattr(gitr, 'gitr_' + subc)
    func({subc: True})
    o, e = capsys.readouterr()
    assert 'Coming soon' in o
예제 #54
0
파일: test_tbx.py 프로젝트: tbarron/gitr
def test_contents_fail(tmpdir):
    """
    Test getting the contents of a file
    """
    pytest.dbgfunc()
    pt = pytest.this
    with pytest.raises(IOError) as e:
        c = tbx.contents(pt['tfn'].strpath + "_nonesuch")
    assert "No such file or directory" in str(e)
예제 #55
0
파일: test_gitr.py 프로젝트: tbarron/gitr
def test_docopt(argd, capsys):
    """
    Test calls to docopt.docopt() that should be successful
    """
    pytest.dbgfunc()
    exp = docopt_exp(**argd)
    argl = docopt_cmdl(argd)
    r = docopt.docopt(gitr.__doc__, argl)
    assert r == exp
예제 #56
0
파일: test_tbx.py 프로젝트: tbarron/tbx
def test_contents_nosuch_default(ctest):
    """
    Attempting to get the contents of a non-existent file with a default value
    should return the default
    """
    pytest.dbgfunc()
    filename = ctest.data.strpath + 'xxx'
    result = tbx.contents(filename,
                          default='foobar')
    assert result == 'foobar'