Пример #1
0
 def test_osbs(self):
     cct = builder_containerbuild.BuildContainerTask(id=1,
                                                     method='buildContainer',
                                                     params='params',
                                                     session='session',
                                                     options='options',
                                                     workdir='workdir')
     assert type(cct.osbs()) is osbs.api.OSBS
Пример #2
0
 def test_resultdir(self, resdir):
     cct = builder_containerbuild.BuildContainerTask(id=1,
                                                     method='buildContainer',
                                                     params='params',
                                                     session='session',
                                                     options='options',
                                                     workdir=resdir)
     assert cct.resultdir() == '%s/osbslogs' % resdir
Пример #3
0
    def test_build_nvr_exists(self, tmpdir, orchestrator, df_release,
                              param_release, expected):
        koji_task_id = 123
        last_event_id = 456
        koji_build_id = 999

        session = self._mock_session(last_event_id, koji_task_id)

        (session.should_receive('getBuild').with_args(
            'fedora-docker-25-%s' % expected).and_return({'id':
                                                          last_event_id}))

        dockerfile_content = dedent("""\
            FROM fedora

            LABEL com.redhat.component=fedora-docker
            LABEL version=25
            """)
        if df_release:
            dockerfile_content += 'LABEL release=%s' % df_release

        folders_info = self._mock_folders(
            str(tmpdir), dockerfile_content=dockerfile_content)
        src = self._mock_git_source()
        options = flexmock(allowed_scms='pkgs.example.com:/*:no')

        task = builder_containerbuild.BuildContainerTask(
            id=koji_task_id,
            method='buildContainer',
            params='params',
            session=session,
            options=options,
            workdir='workdir',
            demux=orchestrator)

        (flexmock(task).should_receive('fetchDockerfile').with_args(
            src['src'],
            'build-tag').and_return(folders_info['dockerfile_path']))
        (flexmock(task).should_receive('_write_incremental_logs'))
        if orchestrator:
            (flexmock(task).should_receive('_write_demultiplexed_logs'))
        else:
            (flexmock(task).should_receive('_write_combined_log'))

        additional_args = {}
        if param_release:
            additional_args['release'] = param_release
        task._osbs = self._mock_osbs(koji_build_id=koji_build_id,
                                     src=src,
                                     koji_task_id=koji_task_id,
                                     orchestrator=orchestrator,
                                     create_build_args=additional_args,
                                     build_not_started=True)

        with pytest.raises(koji.BuildError) as exc_info:
            task.handler(src['src'], 'target', opts=additional_args)
        assert 'already exists' in str(exc_info.value)
Пример #4
0
    def test_flatpak_build(self, tmpdir, module, should_raise):
        task_id = 123
        last_event_id = 456
        koji_build_id = 999

        session = self._mock_session(last_event_id, task_id,
                                     {'blocked': False})
        folders_info = self._mock_folders(str(tmpdir))
        src = self._mock_git_source()
        options = flexmock(allowed_scms='pkgs.example.com:/*:no')

        task = builder_containerbuild.BuildContainerTask(
            id=task_id,
            method='buildContainer',
            params='params',
            session=session,
            options=options,
            workdir='workdir')

        (flexmock(task).should_receive('fetchDockerfile').with_args(
            src['src'],
            'build-tag').and_return(folders_info['dockerfile_path']))
        (flexmock(task).should_receive('_write_incremental_logs'))

        additional_args = {'flatpak': True, 'module': module}

        task._osbs = self._mock_osbs(koji_build_id=koji_build_id,
                                     src=src,
                                     koji_task_id=task_id,
                                     orchestrator=True,
                                     flatpak=True,
                                     create_build_args=additional_args.copy(),
                                     build_not_started=should_raise
                                     is not None)
        build_response = flexmock()

        if should_raise is None:
            task_response = task.handler(src['src'],
                                         'target',
                                         opts={
                                             'flatpak': True,
                                             'module': module
                                         })
            assert task_response == {
                'repositories': ['unique-repo', 'primary-repo'],
                'koji_builds': [koji_build_id]
            }
        else:
            with pytest.raises(should_raise[0]) as exc_info:
                task_response = task.handler(src['src'],
                                             'target',
                                             opts={
                                                 'flatpak': True,
                                                 'module': module
                                             })
            assert should_raise[1] in str(exc_info)
Пример #5
0
    def test_oversized_tags(self, tmpdir, orchestrator, tag, release,
                            is_oversized):
        koji_task_id = 123
        last_event_id = 456
        koji_build_id = 999

        session = self._mock_session(last_event_id, koji_task_id)
        folders_info = self._mock_folders(str(tmpdir),
                                          additional_tags_content=tag)
        src = self._mock_git_source()
        options = flexmock(allowed_scms='pkgs.example.com:/*:no')

        task = builder_containerbuild.BuildContainerTask(
            id=koji_task_id,
            method='buildContainer',
            params='params',
            session=session,
            options=options,
            workdir='workdir',
            demux=orchestrator)

        (flexmock(task).should_receive('fetchDockerfile').with_args(
            src['src'],
            'build-tag').and_return(folders_info['dockerfile_path']))
        (flexmock(task).should_receive('_write_incremental_logs'))
        if orchestrator:
            (flexmock(task).should_receive('_write_demultiplexed_logs'))
        else:
            (flexmock(task).should_receive('_write_combined_log'))

        additional_args = {}
        if release:
            additional_args['release'] = release
        task._osbs = self._mock_osbs(koji_build_id=koji_build_id,
                                     src=src,
                                     koji_task_id=koji_task_id,
                                     orchestrator=orchestrator,
                                     create_build_args=additional_args,
                                     build_not_started=is_oversized)

        if is_oversized:
            with pytest.raises(koji.BuildError) as exc_info:
                task.handler(src['src'], 'target', opts=additional_args)

            assert 'cannot create image with a tag longer than 128' in str(
                exc_info.value)
        else:
            task_response = task.handler(src['src'],
                                         'target',
                                         opts=additional_args)

            assert task_response == {
                'repositories': ['unique-repo', 'primary-repo'],
                'koji_builds': [koji_build_id]
            }
Пример #6
0
 def test_get_repositories(self, repos):
     response = flexmock(get_repositories=lambda: repos)
     cct = builder_containerbuild.BuildContainerTask(id=1,
                                                     method='buildContainer',
                                                     params='params',
                                                     session='session',
                                                     options='options',
                                                     workdir='workdir')
     repositories = []
     for repo in repos.values():
         repositories.extend(repo)
     assert set(cct._get_repositories(response)) ^ set(repositories) == set([])
Пример #7
0
    def test_osbs_build(self, tmpdir, pkg_info, failure, orchestrator):
        koji_task_id = 123
        last_event_id = 456
        koji_build_id = 999

        session = self._mock_session(last_event_id, koji_task_id, pkg_info)
        folders_info = self._mock_folders(str(tmpdir))
        src = self._mock_git_source()
        options = flexmock(allowed_scms='pkgs.example.com:/*:no')

        task = builder_containerbuild.BuildContainerTask(
            id=koji_task_id,
            method='buildContainer',
            params='params',
            session=session,
            options=options,
            workdir='workdir',
            demux=orchestrator)

        (flexmock(task).should_receive('fetchDockerfile').with_args(
            src['src'],
            'build-tag').and_return(folders_info['dockerfile_path']))
        (flexmock(task).should_receive('_write_incremental_logs'))
        if orchestrator:
            (flexmock(task).should_receive('_write_demultiplexed_logs'))
        else:
            (flexmock(task).should_receive('_write_combined_log'))

        task._osbs = self._mock_osbs(
            koji_build_id=koji_build_id,
            src=src,
            koji_task_id=koji_task_id,
            orchestrator=orchestrator,
            build_not_started=bool(failure),
        )

        if failure:
            with pytest.raises(koji.BuildError) as exc:
                task.handler(src['src'], 'target', opts={})

            assert failure in str(exc)

        else:
            task_response = task.handler(src['src'], 'target', opts={})

            assert task_response == {
                'repositories': ['unique-repo', 'primary-repo'],
                'koji_builds': [koji_build_id]
            }
Пример #8
0
    def test_private_branch(self, tmpdir):
        git_uri = 'git://pkgs.example.com/rpms/fedora-docker'
        git_ref = 'private-test1'
        source = git_uri + '#' + git_ref

        koji_task_id = 123
        last_event_id = 456

        options = flexmock(allowed_scms='pkgs.example.com:/*:no')
        folders_info = self._mock_folders(str(tmpdir))

        pkg_info = {'blocked': False}
        session = flexmock()
        (session.should_receive('getLastEvent').and_return(
            {'id': last_event_id}))
        (session.should_receive('getBuildTarget').with_args(
            'target', event=last_event_id).and_return({
                'build_tag':
                'build-tag',
                'name':
                'target-name',
                'dest_tag_name':
                'dest-tag'
            }))
        (session.should_receive('getBuildConfig').with_args(
            'build-tag', event=last_event_id).and_return({'arches': 'x86_64'}))
        (session.should_receive('getTaskInfo').with_args(
            koji_task_id, request=True).and_return({'owner': 'owner'}))
        (session.should_receive('getUser').with_args('owner').and_return(
            {'name': 'owner-name'}))
        (session.should_receive('getPackageConfig').with_args(
            'dest-tag', 'fedora-docker').and_return(pkg_info))

        task = builder_containerbuild.BuildContainerTask(
            id=koji_task_id,
            method='buildContainer',
            params='params',
            session=session,
            options=options,
            workdir=str(tmpdir),
            demux=True)
        (flexmock(task).should_receive('getUploadDir').and_return(str(tmpdir)))
        (flexmock(task).should_receive('run_callbacks').times(2))

        (flexmock(koji.daemon.SCM).should_receive('checkout').and_return(
            folders_info['dockerfile_path']))
        (flexmock(os.path).should_receive('exists').and_return(True))
        task.fetchDockerfile(source, 'build_tag')
Пример #9
0
    def test_compose_ids_and_signing_intent(self, tmpdir, additional_args,
                                            raises):
        koji_task_id = 123
        last_event_id = 456
        koji_build_id = 999

        session = self._mock_session(last_event_id, koji_task_id)
        folders_info = self._mock_folders(str(tmpdir))
        src = self._mock_git_source()
        options = flexmock(allowed_scms='pkgs.example.com:/*:no')

        task = builder_containerbuild.BuildContainerTask(
            id=koji_task_id,
            method='buildContainer',
            params='params',
            session=session,
            options=options,
            workdir='workdir',
            demux=True)

        (flexmock(task).should_receive('fetchDockerfile').with_args(
            src['src'],
            'build-tag').and_return(folders_info['dockerfile_path']))
        (flexmock(task).should_receive('_write_incremental_logs'))
        (flexmock(task).should_receive('_write_demultiplexed_logs'))

        task._osbs = self._mock_osbs(koji_build_id=koji_build_id,
                                     src=src,
                                     koji_task_id=koji_task_id,
                                     orchestrator=True,
                                     build_not_started=raises,
                                     create_build_args=additional_args.copy())

        if raises:
            with pytest.raises(koji.BuildError):
                task.handler(src['src'], 'target', opts=additional_args)
        else:
            task_response = task.handler(src['src'],
                                         'target',
                                         opts=additional_args)

            assert task_response == {
                'repositories': ['unique-repo', 'primary-repo'],
                'koji_builds': [koji_build_id]
            }