Beispiel #1
0
def test_conda_init_install_and_detect(tmpdir):
    # Note: We use a subdirectory of tmpdir because `install_packages` decides
    # to install miniconda based on whether the directory exists.
    test_dir = os.path.join(str(tmpdir), "miniconda")
    dist = CondaDistribution(
        name="conda",
        path=test_dir,
        conda_version="4.3.31",
        python_version="2.7.14.final.0",
        platform=get_conda_platform_from_python(sys.platform) + "-64",
        environments=[
            CondaEnvironment(
                name="root",
                path=test_dir,
                packages=[
                    CondaPackage(
                        name="conda",
                        installer=None,
                        version="4.3.31",
                        build=None,
                        channel_name=None,
                        md5=None,
                        size=None,
                        url=None,
                        files=None),
                    CondaPackage(
                        name="pip",
                        installer=None,
                        version="9.0.1",
                        build=None,
                        channel_name=None,
                        md5=None,
                        size=None,
                        url=None,
                        files=None),
                    CondaPackage(
                        name="pytest",
                        installer="pip",
                        version="3.4.0",
                        build=None,
                        channel_name=None,
                        md5=None,
                        size=None,
                        url=None,
                        files=None)],
                channels=[
                    CondaChannel(
                        name="conda-forge",
                        url="https://conda.anaconda.org/conda-forge/linux-64"),
                    CondaChannel(
                        name="defaults",
                        url="https://repo.continuum.io/pkgs/main/linux-64")]),
            CondaEnvironment(
                name="mytest",
                path=os.path.join(test_dir, "envs/mytest"),
                packages=[
                    CondaPackage(
                        name="pip",
                        installer=None,
                        version="9.0.1",
                        build=None,
                        channel_name=None,
                        md5=None,
                        size=None,
                        url=None,
                        files=None),
                    CondaPackage(
                        name="xz",
                        installer=None,
                        version="5.2.3",
                        build="0",
                        channel_name="conda-forge",
                        md5="f4e0d30b3caf631be7973cba1cf6f601",
                        size="874292",
                        url="https://conda.anaconda.org/conda-forge/linux-64/xz-5.2.3-0.tar.bz2",
                        files=["bin/xz", ]),
                    CondaPackage(
                        name="rpaths",
                        installer="pip",
                        version="0.13",
                        build=None,
                        channel_name=None,
                        md5=None,
                        size=None,
                        url=None,
                        files=["lib/python2.7/site-packages/rpaths.py"])],
                channels=[
                    CondaChannel(
                        name="conda-forge",
                        url="https://conda.anaconda.org/conda-forge/linux-64")])])
    # First install the environment in the temporary directory.
    dist.initiate(None)
    dist.install_packages()
    # Add an empty environment to test detection of them
    if not os.path.exists(os.path.join(test_dir, "envs/empty")):
        call("cd " + test_dir + "; " +
             "./bin/conda create -y -n empty; ",
             shell=True)

    # Test that editable packages are detected
    pymod_dir = os.path.join(test_dir, "minimal_pymodule")
    if not os.path.exists(pymod_dir):
        create_pymodule(pymod_dir)
        call([os.path.join(test_dir, "envs/mytest/bin/pip"),
              "install", "-e", pymod_dir])

    # Now pick some files we know are in the conda install and detect them
    files = [os.path.join(test_dir, "bin/pip"),
             os.path.join(test_dir, "envs/mytest/bin/xz"),
             os.path.join(test_dir, "envs/empty/conda-meta/history"),
             ]
    tracer = CondaTracer()
    dists = list(tracer.identify_distributions(files))

    assert len(dists) == 1, "Exactly one Conda distribution expected."

    (distributions, unknown_files) = dists[0]

    # RepromanProvenance.write(sys.stdout, distributions)

    assert distributions.platform.startswith(
        get_conda_platform_from_python(sys.platform)), \
        "A conda platform is expected."

    assert len(distributions.environments) == 3, \
        "Three conda environments are expected."

    out = {'environments': [{'name': 'root',
                             'packages': [{'name': 'pip'}]},
                            {'name': 'mytest',
                             'packages': [{'name': 'xz'},
                                          {'name': 'pip'},
                                          {'name': 'rpaths',
                                           'installer': 'pip',
                                           'editable': False},
                                          {'name': 'nmtest',
                                           'files': [],
                                           'installer': 'pip',
                                           'editable': True}]
                             }
                            ]
           }
    assert_is_subset_recur(out, attr.asdict(distributions), [dict, list])

    # conda packages are not repeated as "pip" packages.
    for envs in distributions.environments:
        for pkg in envs.packages:
            if pkg.name == "pip":
                assert pkg.installer is None

    # Smoke test to make sure install_packages doesn't choke on the format that
    # is actually returned by the tracer.
    distributions.initiate(None)
    distributions.install_packages()
Beispiel #2
0
def test_spec_round_trip():
    # FIXME: This should also test GitDistribution's, but RepromanProvenance
    # can't currently load those (gh-222).

    spec = EnvironmentSpec(
        distributions=[
            DebianDistribution(
                name="debian",
                apt_sources=[
                    APTSource(
                        name="apt_Debian_stable_main_0",
                        component="main",
                        archive="stable",
                        architecture="amd64",
                        codename="stretch",
                        origin="Debian",
                        label="Debian",
                        site="ftp.us.debian.org",
                        archive_uri="http://ftp.us.debian.org/debian",
                        date="2018-03-10 10:21:19+00:00")],
                packages=[
                    DEBPackage(name="debpackage"),
                    DEBPackage(
                        name="libc-bin",
                        upstream_name=None,
                        version="2.24-11+deb9u3",
                        architecture="amd64",
                        source_name="glibc",
                        source_version=None,
                        size="779468",
                        md5="3b9aaa83b5253895b8e13509659662e4",
                        sha1=None,
                        sha256="aaa",
                        versions={"2.24-11+deb9u1": ["apt_Debian_stable_foo"],
                                  "2.24-11+deb9u3": ["apt_Debian_stable_bar",
                                                     "apt__now__0"]},
                        install_date="2018-03-12 10:55:13+00:00",
                        files=["/usr/bin/zdump"])],
                version="9.4"),
            CondaDistribution(
                name="conda",
                path="/path/to/miniconda3",
                conda_version="4.4.10",
                python_version="3.6.3.final.0",
                platform="linux-64",
                environments=[
                    CondaEnvironment(
                        name="root",
                        path="/path/to/miniconda3",
                        packages=[
                            CondaPackage(name="condapkg"),
                            CondaPackage(
                                version="36.5.0",
                                build="py36he42e2e1_0",
                                name="setuptools",
                                md5="cb1383539629db998105faf7e91e2bc7",
                                url="https://somewhere")],
                        channels=[
                            CondaChannel(
                                name="defaults",
                                url="https://somewhere")]),
                    CondaEnvironment(
                        name="other",
                        path="/path/to/miniconda3",
                        packages=[
                            CondaPackage(name="condapkg2")])]),
            GitDistribution(
                name="git",
                packages=[GitRepo(path="/path/to/repo")]),
            SVNDistribution(
                name="svn",
                packages=[SVNRepo(path="/path/to/repo")]),
            VenvDistribution(
                name="venv0",
                path="/usr/bin/virtualenv",
                venv_version="15.1.0",
                environments=[
                    VenvEnvironment(
                        path="venv-reproman",
                        python_version="3.5.3",
                        packages=[
                            VenvPackage(
                                version="3.12",
                                name="PyYAML",
                                location="/path/to/venv/site-packages",
                                local=True)])]),
            VenvDistribution(name="venv1")])

    output = io.StringIO()
    RepromanProvenance.write(output, spec)
    loaded = RepromanProvenance(output.getvalue()).get_environment()
    assert spec == loaded