Python create_origin_task_dict Examples

Example #1

def test_archive_loader_for_listed_origin(
    mocker,
    swh_scheduler_celery_app,
    hg_lister,
    hg_listed_origin,
):
    mock_loader = mocker.patch(
        "swh.loader.mercurial.loader.HgArchiveLoader.load")
    mock_loader.return_value = {"status": "uneventful"}

    hg_listed_origin.extra_loader_arguments = {
        "archive_path": "/some/tar.tgz",
    }

    task_dict = create_origin_task_dict(hg_listed_origin, hg_lister)

    res = swh_scheduler_celery_app.send_task(
        "swh.loader.mercurial.tasks.LoadArchiveMercurial",
        kwargs=task_dict["arguments"]["kwargs"],
    )
    assert res
    res.wait()
    assert res.successful()

    assert res.result == {"status": "uneventful"}
    mock_loader.assert_called_once_with()

Example #2

def test_git_loader_from_disk_for_listed_origin(
    mocker,
    swh_scheduler_celery_app,
    git_lister,
    git_listed_origin,
):
    mock_loader = mocker.patch(
        "swh.loader.git.from_disk.GitLoaderFromDisk.load")
    mock_loader.return_value = {"status": "uneventful"}

    git_listed_origin.extra_loader_arguments = {
        "directory": "/some/repo",
    }
    task_dict = create_origin_task_dict(git_listed_origin, git_lister)

    res = swh_scheduler_celery_app.send_task(
        "swh.loader.git.tasks.LoadDiskGitRepository",
        kwargs=task_dict["arguments"]["kwargs"],
    )
    assert res
    res.wait()
    assert res.successful()

    assert res.result == {"status": "uneventful"}
    mock_loader.assert_called_once_with()

Example #3

File: test_utils.py Project: SoftwareHeritage/swh-scheduler

def test_create_origin_task_dict():
    lister = model.Lister(**LISTERS[1], id=uuid.uuid4())
    origin = model.ListedOrigin(
        lister_id=lister.id,
        url="http://example.com/",
        visit_type="git",
    )

    task = utils.create_origin_task_dict(origin, lister)
    assert task == {
        "type": "load-git",
        "arguments": {
            "args": [],
            "kwargs": {
                "url": "http://example.com/",
                "lister_name": LISTERS[1]["name"],
                "lister_instance_name": LISTERS[1]["instance_name"],
            },
        },
    }

    loader_args = {"foo": "bar", "baz": {"foo": "bar"}}

    origin_w_args = model.ListedOrigin(
        lister_id=lister.id,
        url="http://example.com/svn/",
        visit_type="svn",
        extra_loader_arguments=loader_args,
    )

    task_w_args = utils.create_origin_task_dict(origin_w_args, lister)
    assert task_w_args == {
        "type": "load-svn",
        "arguments": {
            "args": [],
            "kwargs": {
                "url": "http://example.com/svn/",
                "lister_name": LISTERS[1]["name"],
                "lister_instance_name": LISTERS[1]["instance_name"],
                **loader_args,
            },
        },
    }

Example #4

def test_tasks_npm_loader_for_listed_origin(mocker, swh_scheduler_celery_app,
                                            npm_lister, npm_listed_origin):
    mock_load = mocker.patch("swh.loader.package.npm.loader.NpmLoader.load")
    mock_load.return_value = {"status": "eventful"}

    task_dict = create_origin_task_dict(npm_listed_origin, npm_lister)

    res = swh_scheduler_celery_app.send_task(
        "swh.loader.package.npm.tasks.LoadNpm",
        kwargs=task_dict["arguments"]["kwargs"],
    )
    assert res
    res.wait()
    assert res.successful()
    assert mock_load.called
    assert res.result == {"status": "eventful"}

Example #5

def test_tasks_nixguix_loader_for_listed_origin(
    mocker, swh_scheduler_celery_app, nixguix_lister, nixguix_listed_origin
):
    mock_loader = mocker.patch(
        "swh.loader.package.nixguix.loader.NixGuixLoader.from_configfile"
    )
    mock_loader.return_value = mock_loader
    mock_loader.load.return_value = {"status": "eventful"}

    task_dict = create_origin_task_dict(nixguix_listed_origin, nixguix_lister)

    res = swh_scheduler_celery_app.send_task(
        "swh.loader.package.nixguix.tasks.LoadNixguix",
        kwargs=task_dict["arguments"]["kwargs"],
    )
    assert res
    res.wait()
    assert res.successful()
    assert mock_loader.called
    assert res.result == {"status": "eventful"}

Example #6

def test_git_loader_for_listed_origin(
    mocker,
    swh_scheduler_celery_app,
    git_lister,
    git_listed_origin,
):
    mock_loader = mocker.patch("swh.loader.git.loader.GitLoader.load")
    mock_loader.return_value = {"status": "eventful"}

    task_dict = create_origin_task_dict(git_listed_origin, git_lister)

    res = swh_scheduler_celery_app.send_task(
        "swh.loader.git.tasks.UpdateGitRepository",
        kwargs=task_dict["arguments"]["kwargs"],
    )
    assert res
    res.wait()
    assert res.successful()

    assert res.result == {"status": "eventful"}
    mock_loader.assert_called_once_with()

Example #7

def test_svn_loader_from_dump_for_listed_origin(
    mocker,
    swh_scheduler_celery_app,
    svn_lister,
    svn_listed_origin,
):
    mock_loader = mocker.patch(
        "swh.loader.svn.loader.SvnLoaderFromDumpArchive.load")
    mock_loader.return_value = {"status": "eventful"}

    svn_listed_origin.extra_loader_arguments = {"archive_path": "some-path"}

    task_dict = create_origin_task_dict(svn_listed_origin, svn_lister)

    res = swh_scheduler_celery_app.send_task(
        "swh.loader.svn.tasks.MountAndLoadSvnRepository",
        args=task_dict["arguments"]["args"],
        kwargs=task_dict["arguments"]["kwargs"],
    )
    assert res
    res.wait()
    assert res.successful()

    assert res.result == {"status": "eventful"}

Example #8

def task_dict(svn_lister, svn_listed_origin):
    return create_origin_task_dict(svn_listed_origin, svn_lister)