Exemple #1
0
    def test_frozen_enough(self):
        """Test frozen enough."""

        # already has requests
        self.assertEqual(
            self.wf.api.prj_frozen_enough('openSUSE:Factory:Staging:B'), True)

        self.wf.create_staging('A')

        # Unfrozen
        self.assertEqual(
            self.wf.api.prj_frozen_enough('openSUSE:Factory:Staging:A'), False)

        self.wf.create_staging('C', freeze=True, rings=1)
        self.assertEqual(
            self.wf.api.prj_frozen_enough('openSUSE:Factory:Staging:C'), True)

        # pretend it's old
        attribute_value_save(self.wf.apiurl, 'openSUSE:Factory:Staging:C',
                             'FreezeTime', "2021-03-04T10:23:55.127903")
        self.assertEqual(
            self.wf.api.prj_frozen_enough('openSUSE:Factory:Staging:C'), False)

        # test old method (which still shows it's recent)
        attribute_value_delete(self.wf.apiurl, 'openSUSE:Factory:Staging:C',
                               'FreezeTime')
        self.assertEqual(
            self.wf.api.prj_frozen_enough('openSUSE:Factory:Staging:C'), True)
Exemple #2
0
    def test_get_memoize_reset(self):
        """Ensure memoize_session_reset() properly forces re-fetch of config."""
        self.assertEqual('remote-indeed', Config.get(obs.APIURL, obs.PROJECT)['remote-only'])

        attribute_value_save(obs.APIURL, obs.PROJECT, 'Config', 'remote-only = new value\n')
        memoize_session_reset()

        self.assertEqual('new value', Config.get(obs.APIURL, obs.PROJECT)['remote-only'])
Exemple #3
0
 def origin_config_write(self, origins, extra={}):
     config = {
         'origins': origins,
         'review-user': self.bot_user,
         'fallback-group': self.review_group,
     }
     config.update(extra)
     config = yaml.dump(config, default_flow_style=False)
     attribute_value_save(self.wf.apiurl, self.target_project, 'OriginConfig', config)
    def test_get_memoize_reset(self):
        """Ensure memoize_session_reset() properly forces re-fetch of config."""
        wf = self.setup_vcr()
        self.assertEqual('remote-indeed', Config.get(wf.apiurl, wf.project)['remote-only'])

        attribute_value_save(wf.apiurl, wf.project, 'Config', 'remote-only = new value\n')
        memoize_session_reset()

        self.assertEqual('new value', Config.get(wf.apiurl, wf.project)['remote-only'])
Exemple #5
0
    def test_get_memoize_reset(self):
        """Ensure memoize_session_reset() properly forces re-fetch of config."""
        self.assertEqual('remote-indeed',
                         Config.get(APIURL, PROJECT)['remote-only'])

        attribute_value_save(APIURL, PROJECT, 'Config',
                             'remote-only = new value\n')
        memoize_session_reset()

        self.assertEqual('new value',
                         Config.get(APIURL, PROJECT)['remote-only'])
Exemple #6
0
    def test_config(self):
        attribute_value_save(self.wf.apiurl, self.target_project, 'OriginConfig', 'origins: []')
        config = config_load(self.wf.apiurl, self.wf.project)
        self.assertEqual(config['unknown_origin_wait'], False)
        self.assertEqual(config['review-user'], NAME)

        memoize_session_reset()
        self.origin_config_write([{'fakeProject': {}}, {'*~': {}}])
        config = config_load(self.wf.apiurl, self.wf.project)
        self.assertEqual(config_origin_list(config), ['fakeProject', 'fakeProject~'])
        for _, values in config_origin_generator(config['origins']):
            self.assertEqual(values['automatic_updates'], True)
Exemple #7
0
    def remote_config_set(self, config, replace_all=False):
        if not replace_all:
            config_existing = Config.get(self.apiurl, self.project)
            config_existing.update(config)
            config = config_existing

        config_lines = []
        for key, value in config.items():
            config_lines.append(f'{key} = {value}')

        attribute_value_save(APIURL, self.project, 'Config',
                             '\n'.join(config_lines))
    def test_get_memoize_reset(self):
        """Ensure memoize_session_reset() properly forces re-fetch of config."""
        wf = self.setup_vcr()
        self.assertEqual('remote-indeed',
                         Config.get(wf.apiurl, wf.project)['remote-only'])

        attribute_value_save(wf.apiurl, wf.project, 'Config',
                             'remote-only = new value\n')
        memoize_session_reset()

        self.assertEqual('new value',
                         Config.get(wf.apiurl, wf.project)['remote-only'])
Exemple #9
0
    def test_remote(self):
        # Initial config present in fixtures/oscrc and obs.py attribute default.
        # Local config fixture contains overridden-by-local and should win over
        # the remote config value.
        self.assertEqual('local', conf.config[obs.PROJECT]['overridden-by-local'])
        self.assertEqual('remote-indeed', conf.config[obs.PROJECT]['remote-only'])

        # Change remote value.
        attribute_value_save(obs.APIURL, obs.PROJECT, 'Config', 'remote-only = new value\n')
        self.load_config()

        self.assertEqual('local', conf.config[obs.PROJECT]['overridden-by-local'])
        self.assertEqual('new value', conf.config[obs.PROJECT]['remote-only'])
Exemple #10
0
    def freeze_prjlinks(self):
        sources = {}
        flink = ET.Element('frozenlinks')

        for lprj in self.projectlinks:
            fl = ET.SubElement(flink, 'frozenlink', {'project': lprj})
            sources = self.receive_sources(lprj, sources, fl)

        url = self.api.makeurl(
            ['source', self.prj, '_project', '_frozenlinks'], {'meta': '1'})
        self.api.retried_PUT(url, ET.tostring(flink))
        attribute_value_save(self.api.apiurl, self.prj, 'FreezeTime',
                             datetime.now(timezone.utc).isoformat())
Exemple #11
0
 def __config_origin_manager(self):
     """Creates the very minimal configuration needed by origin-manager to work"""
     self.wf.create_attribute_type('OSRT', 'OriginConfig', 1)
     self.wf.remote_config_set({'originmanager-request-age-min': 0})
     config = {
         'origins': [{
             '<devel>': {}
         }],
         'review-user': '******',
         'fallback-group': 'origin-reviewers'
     }
     config = yaml.dump(config, default_flow_style=False)
     attribute_value_save(self.wf.apiurl, PROJECT, 'OriginConfig', config)
Exemple #12
0
    def test_remote(self):
        # Initial config present in fixtures/oscrc and obs.py attribute default.
        # Local config fixture contains overridden-by-local and should win over
        # the remote config value.
        self.assertEqual('local', conf.config[PROJECT]['overridden-by-local'])
        self.assertEqual('remote-indeed', conf.config[PROJECT]['remote-only'])

        # Change remote value.
        attribute_value_save(APIURL, PROJECT, 'Config',
                             'remote-only = new value\n')
        self.load_config()

        self.assertEqual('local', conf.config[PROJECT]['overridden-by-local'])
        self.assertEqual('new value', conf.config[PROJECT]['remote-only'])
    def test_remote(self):
        wf = self.setup_vcr()
        # Initial config present in fixtures/oscrc and obs.py attribute default.
        # Local config fixture contains overridden-by-local and should win over
        # the remote config value.
        self.assertEqual('local', conf.config[wf.project]['overridden-by-local'])
        self.assertEqual('remote-indeed', conf.config[wf.project]['remote-only'])

        # Change remote value.
        attribute_value_save(wf.apiurl, wf.project, 'Config', 'remote-only = new value\n')
        wf.load_config()

        self.assertEqual('local', conf.config[wf.project]['overridden-by-local'])
        self.assertEqual('new value', conf.config[wf.project]['remote-only'])
    def test_remote(self):
        wf = self.setup_vcr()
        # Initial config present in fixtures/oscrc and obs.py attribute default.
        # Local config fixture contains overridden-by-local and should win over
        # the remote config value.
        self.assertEqual('local',
                         conf.config[wf.project]['overridden-by-local'])
        self.assertEqual('remote-indeed',
                         conf.config[wf.project]['remote-only'])

        # Change remote value.
        attribute_value_save(wf.apiurl, wf.project, 'Config',
                             'remote-only = new value\n')
        wf.load_config()

        self.assertEqual('local',
                         conf.config[wf.project]['overridden-by-local'])
        self.assertEqual('new value', conf.config[wf.project]['remote-only'])
Exemple #15
0
    def test_frozen_mtime(self):
        """Test frozen mtime."""

        self.wf.create_staging('A')

        # unfrozen
        self.assertTrue(
            self.wf.api.days_since_last_freeze('openSUSE:Factory:Staging:A') >
            1000)

        # Testing frozen mtime
        self.wf.create_staging('B', freeze=True, rings=1)
        self.assertLess(
            self.wf.api.days_since_last_freeze('openSUSE:Factory:Staging:B'),
            1)

        attribute_value_save(self.wf.apiurl, 'openSUSE:Factory:Staging:B',
                             'FreezeTime', "2021-03-04T10:23:55.127903")
        self.assertGreater(
            self.wf.api.days_since_last_freeze('openSUSE:Factory:Staging:B'),
            8)
    def remote_config_set(self, config, replace_all=False):
        """Sets the values of the 'Config' attribute for the target project.

        That attribute stores a set of values that are useful to influence the behavior of several
        tools and bots in the context of the given project. For convenience, such a collection of
        values is usually accessed using a :class:`osclib.Config` object. See :func:`load_config`.

        :param config: values to write into the attribute
        :type config: dict[str, str]
        :param replace_all: whether the previous content of 'Config' should be cleared up
        :type replace_all: bool
        """

        if not replace_all:
            config_existing = Config.get(self.apiurl, self.project)
            config_existing.update(config)
            config = config_existing

        config_lines = []
        for key, value in config.items():
            config_lines.append(f'{key} = {value}')

        attribute_value_save(APIURL, self.project, 'Config', '\n'.join(config_lines))
 def update_version_attribute(self, project, version):
     version_attr = attribute_value_load(self.api.apiurl, project, 'ProductVersion')
     if version_attr != version:
         attribute_value_save(self.api.apiurl, project, 'ProductVersion', version)
 def setup_remote_config(self):
     self.create_target()
     self.create_attribute_type('OSRT', 'Config', 1)
     attribute_value_save(APIURL, self.project, 'Config', 'overridden-by-local = remote-nope\n'
                                                     'remote-only = remote-indeed\n')
Exemple #19
0
    def test_automatic_update_modes(self):
        self.remote_config_set_age_minimum()

        upstream1_project = self.randomString('upstream1')
        package1 = self.randomString('package1')

        target_package1 = self.wf.create_package(self.target_project, package1)
        upstream1_package1 = self.wf.create_package(upstream1_project, package1)

        upstream1_package1.create_commit()
        copy_package(self.wf.apiurl, upstream1_project, package1,
                     self.wf.apiurl, self.target_project, package1)

        attribute_value_save(self.wf.apiurl, upstream1_project, 'ApprovedRequestSource', '', 'OBS')
        self.wf.create_attribute_type('OSRT', 'OriginUpdateSkip', 0)

        def config_write(delay=0, supersede=True, frequency=0):
            self.origin_config_write([
                {upstream1_project: {
                    'automatic_updates_delay': delay,
                    'automatic_updates_supersede': supersede,
                    'automatic_updates_frequency': frequency,
                }},
            ])

        # Default config with fresh commit.
        config_write()
        upstream1_package1.create_commit()

        # Check the full order of precidence available to mode attributes.
        for project in (upstream1_project, self.target_project):
            for package in (package1, None):
                # Ensure no update is triggered due to OSRT:OriginUpdateSkip.
                attribute_value_save(self.wf.apiurl, project, 'OriginUpdateSkip', '', package=package)
                self.assertNoUpdate(package1)
                attribute_value_delete(self.wf.apiurl, project, 'OriginUpdateSkip', package=package)

        # Configure a delay, make commit, and ensure no update until delayed.
        delay = 17  # Allow enough time for API speed fluctuation.
        config_write(delay=delay)
        upstream1_package1.create_commit()
        start = datetime.now()

        self.assertNoUpdate(package1)
        self.waitDelta(start, delay)
        request_id_package1_1 = self.assertUpdate(package1)

        # Configure no supersede and ensure no update generated for new commit.
        config_write(supersede=False)
        upstream1_package1.create_commit()
        self.assertNoUpdate(package1)

        # Accept request and ensure update since no request to supersede.
        self.assertReviewBot(request_id_package1_1, self.bot_user, 'new', 'accepted')
        request_state_change(self.wf.apiurl, request_id_package1_1, 'accepted')

        request_id_package1_2 = self.assertUpdate(package1)

        # Track time since last request created for testing frequency.
        start = datetime.now()

        # Configure frequency (removes supersede=False).
        config_write(frequency=delay)

        upstream1_package1.create_commit()
        self.assertNoUpdate(package1)

        # Fresh commit should not impact frequency which only looks at requests.
        self.waitDelta(start, delay)
        upstream1_package1.create_commit()

        request_id_package1_3 = self.assertUpdate(package1)
Exemple #20
0
    def test_new_package_submission(self):
        self.remote_config_set_age_minimum()

        upstream1_project = self.randomString('upstream1')
        upstream2_project = self.randomString('upstream2')
        upstream3_project = self.randomString('upstream3')
        package1 = self.randomString('package1')
        package2 = self.randomString('package2')
        package3 = self.randomString('package3')

        target_package1 = self.wf.create_package(self.target_project, package1)
        upstream1_package1 = self.wf.create_package(upstream1_project, package1)
        upstream2_package1 = self.wf.create_package(upstream2_project, package1)

        upstream1_package1.create_commit()
        copy_package(self.wf.apiurl, upstream1_project, package1,
                     self.wf.apiurl, upstream2_project, package1)

        upstream3_package2 = self.wf.create_package(upstream3_project, package2)
        upstream3_package2.create_commit()

        upstream1_package3 = self.wf.create_package(upstream1_project, package3)
        upstream1_package3.create_commit()

        attribute_value_save(self.wf.apiurl, upstream1_project, 'ApprovedRequestSource', '', 'OBS')
        attribute_value_save(self.wf.apiurl, upstream2_project, 'ApprovedRequestSource', '', 'OBS')
        attribute_value_save(self.wf.apiurl, upstream3_project, 'ApprovedRequestSource', '', 'OBS')

        self.origin_config_write([
            {upstream1_project: { 'automatic_updates_initial': True }},
            {upstream2_project: { 'automatic_updates_initial': True }},
            {upstream3_project: {}},
        ])

        self.osc_user(self.bot_user)
        memoize_session_reset()
        request_future = origin_update(self.wf.apiurl, self.wf.project, package1)
        self.assertNotEqual(request_future, False)
        if request_future:
            request_id_package1 = request_future.print_and_create()

        # Ensure a second request is not triggered.
        memoize_session_reset()
        request_future = origin_update(self.wf.apiurl, self.wf.project, package1)
        self.assertEqual(request_future, False)

        # No new package submission from upstream3 since not automatic_updates_initial.
        memoize_session_reset()
        request_future = origin_update(self.wf.apiurl, self.wf.project, package2)
        self.assertEqual(request_future, False)
        self.osc_user_pop()

        upstream2_package2 = self.wf.create_package(upstream2_project, package2)
        upstream2_package2.create_commit()

        self.osc_user(self.bot_user)
        memoize_session_reset()
        request_future = origin_update(self.wf.apiurl, self.wf.project, package2)
        self.assertNotEqual(request_future, False)
        if request_future:
            request_id_package2 = request_future.print_and_create()
        self.osc_user_pop()

        request_state_change(self.wf.apiurl, request_id_package2, 'declined')
        upstream2_package2.create_commit()

        self.osc_user(self.bot_user)
        # No new package submission from upstream2 for new revision since
        # declined initial package submission.
        memoize_session_reset()
        request_future = origin_update(self.wf.apiurl, self.wf.project, package2)
        self.assertEqual(request_future, False)
        self.osc_user_pop()

        # Ensure blacklist prevents initial package submission.
        self.wf.create_attribute_type('OSRT', 'OriginUpdateInitialBlacklist', 1)
        attribute_value_save(self.wf.apiurl, self.target_project, 'OriginUpdateInitialBlacklist', package3)
        self.assertNoUpdate(package3)

        attribute_value_delete(self.wf.apiurl, self.target_project, 'OriginUpdateInitialBlacklist')
        self.assertUpdate(package3)
Exemple #21
0
    def test_split_product(self):
        self.remote_config_set_age_minimum()

        upstream1_project = self.randomString('upstream1')
        upstream2_project = self.randomString('upstream2')
        devel_project = self.randomString('devel')
        package = self.randomString('package')

        target_package = self.wf.create_package(self.target_project, package)
        upstream1_package = self.wf.create_package(upstream1_project, package)
        upstream2_package = self.wf.create_package(upstream2_project, package)
        devel_package = self.wf.create_package(devel_project, package)

        upstream1_package.create_commit()
        upstream2_package.create_commit()
        devel_package.create_commit()

        attribute_value_save(self.wf.apiurl, upstream1_project, 'ApprovedRequestSource', '', 'OBS')
        attribute_value_save(self.wf.apiurl, upstream2_project, 'ApprovedRequestSource', '', 'OBS')
        attribute_value_save(self.wf.apiurl, devel_project, 'ApprovedRequestSource', '', 'OBS')

        self.origin_config_write([
            {'<devel>': {}},
            {upstream1_project: {}},
            {upstream2_project: { 'pending_submission_consider': True }},
            {'*~': {}},
        ], {'unknown_origin_wait': True})

        # Simulate branch project from upstream1.
        copy_package(self.wf.apiurl, upstream1_project, package,
                     self.wf.apiurl, self.target_project, package)

        memoize_session_reset()
        origin_info = origin_find(self.wf.apiurl, self.target_project, package)
        self.assertEqual(str(origin_info), upstream1_project)

        # Create request against upstream2 which considers pending submissions.
        request_upstream2 = self.wf.submit_package(devel_package, upstream2_project)
        request_target = self.wf.submit_package(devel_package, self.target_project)

        self.assertReviewBot(request_target.reqid, self.bot_user, 'new', 'new')
        comment = [
            '<!-- OriginManager state=seen result=None -->',
            f'Waiting on acceptance of request#{request_upstream2.reqid}.',
        ]
        self.assertComment(request_target.reqid, comment)

        request_upstream2.change_state('accepted')

        self.assertReviewBot(request_target.reqid, self.bot_user, 'new', 'accepted')
        self.assertAnnotation(request_target.reqid, {
            'origin': upstream2_project,
            'origin_old': upstream1_project,
        })

        # Accept fallback review for changing to lower priority origin.
        self.accept_fallback_review(request_target.reqid)
        request_target.change_state('accepted')

        memoize_session_reset()
        origin_info = origin_find(self.wf.apiurl, self.target_project, package)
        self.assertEqual(str(origin_info), upstream2_project)

        # Simulate upstream1 incorporating upstream2 version of package.
        copy_package(self.wf.apiurl, upstream2_project, package,
                     self.wf.apiurl, upstream1_project, package)

        memoize_session_reset()
        origin_info = origin_find(self.wf.apiurl, self.target_project, package)
        self.assertEqual(str(origin_info), upstream1_project)
Exemple #22
0
    def devel_workflow(self, only_devel):
        self.remote_config_set_age_minimum()

        devel_project = self.randomString('devel')
        package = self.randomString('package')
        request = self.wf.create_submit_request(devel_project, package)
        attribute_value_save(self.wf.apiurl, devel_project, 'ApprovedRequestSource', '', 'OBS')

        if not only_devel:
            self.assertReviewBot(request.reqid, self.bot_user, 'new', 'new')

            comment = [
                '<!-- OriginManager state=seen result=None -->',
                'Source not found in allowed origins:',
                f'- {self.product_project}',
                f'Decision may be overridden via `@{self.bot_user} override`.',
            ]
            self.assertComment(request.reqid, comment)

            CommentAPI(self.wf.api.apiurl).add_comment(
                request_id=request.reqid, comment=f'@{self.bot_user} change_devel')

            comment = 'change_devel command by {}'.format('Admin')
        else:
            comment = 'only devel origin allowed'

        self.assertReviewBot(request.reqid, self.bot_user, 'new', 'accepted')
        self.assertAnnotation(request.reqid, {
            'comment': comment,
            'origin': devel_project,
        })

        request.change_state('accepted')

        memoize_session_reset()
        self.osc_user(self.bot_user)
        request_future = origin_update(self.wf.apiurl, self.wf.project, package)
        self.assertNotEqual(request_future, False)
        if request_future:
            request_id_change_devel = request_future.print_and_create()

        # Ensure a second request is not triggered.
        request_future = origin_update(self.wf.apiurl, self.wf.project, package)
        self.assertEqual(request_future, False)
        self.osc_user_pop()

        memoize_session_reset()
        origin_info = origin_find(self.wf.apiurl, self.wf.project, package)
        self.assertEqual(origin_info, None)

        self.assertReviewBot(request_id_change_devel, self.bot_user, 'new', 'accepted')
        self.assertAnnotation(request_id_change_devel, {
            'origin': devel_project,
        })

        # Origin should change before request is accepted since it is properly
        # annotated and without fallback review.
        memoize_session_reset()
        origin_info = origin_find(self.wf.apiurl, self.wf.project, package)
        self.assertEqual(str(origin_info), devel_project)

        self.wf.projects[devel_project].packages[0].create_commit()

        self.osc_user(self.bot_user)
        request_future = origin_update(self.wf.apiurl, self.wf.project, package)
        self.assertNotEqual(request_future, False)
        if request_future:
            request_id_update = request_future.print_and_create()

        request_future = origin_update(self.wf.apiurl, self.wf.project, package)
        self.assertEqual(request_future, False)
        self.osc_user_pop()

        self.assertReviewBot(request_id_update, self.bot_user, 'new', 'accepted')
        self.assertAnnotation(request_id_update, {
            'origin': devel_project,
        })

        memoize_session_reset()
        devel_project_actual, _ = devel_project_get(self.wf.apiurl, self.wf.project, package)
        self.assertEqual(devel_project_actual, None)

        request = get_request(self.wf.apiurl, request_id_change_devel)
        request_state_change(self.wf.apiurl, request_id_change_devel, 'accepted')

        memoize_session_reset()
        devel_project_actual, devel_package_actual = devel_project_get(
            self.wf.apiurl, self.wf.project, package)
        self.assertEqual(devel_project_actual, devel_project)
        self.assertEqual(devel_package_actual, package)

        request = get_request(self.wf.apiurl, request_id_update)
        request_state_change(self.wf.apiurl, request_id_update, 'accepted')

        devel_project_new = self.randomString('develnew')
        self.wf.create_package(devel_project_new, package)
        attribute_value_save(self.wf.apiurl, devel_project_new, 'ApprovedRequestSource', '', 'OBS')

        copy_package(self.wf.apiurl, devel_project, package,
                     self.wf.apiurl, devel_project_new, package)

        request_future = request_create_change_devel(
            self.wf.apiurl, devel_project_new, package, self.wf.project)
        self.assertNotEqual(request_future, False)
        if request_future:
            request_id_change_devel_new = request_future.print_and_create()

        self.assertReviewBot(request_id_change_devel_new, self.bot_user, 'new', 'accepted')
        self.assertAnnotation(request_id_change_devel_new, {
            'origin': devel_project_new,
            'origin_old': devel_project,
        })

        self.accept_fallback_review(request_id_change_devel_new)
        request_state_change(self.wf.apiurl, request_id_change_devel_new, 'accepted')

        memoize_session_reset()
        origin_info = origin_find(self.wf.apiurl, self.wf.project, package)
        self.assertEqual(str(origin_info), devel_project_new)
Exemple #23
0
 def update_version_attribute(self, project, version):
     version_attr = attribute_value_load(self.api.apiurl, project, 'ProductVersion')
     if version_attr != version:
         attribute_value_save(self.api.apiurl, project, 'ProductVersion', version)