f605862a4d
The regex to detect Depends-On relations between Gerrit changes was recently
updated for the new URL schema. However because the change.uris attribute was
not also updated, getChangesDependingOn was not working, and the functionality
that this enables ("reverse" dependency processing, where a dependee change
triggers a test for an already-approved dependent) was not covered by the test.
Update the attribute and add test coverage.
Change-Id: I400445093beda390aa9ce19af31e50820f7c56df
767 lines
29 KiB
Python
767 lines
29 KiB
Python
# Copyright 2012 Hewlett-Packard Development Company, L.P.
|
|
# Copyright 2018 Red Hat, Inc.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
from tests.base import (
|
|
ZuulTestCase,
|
|
simple_layout,
|
|
)
|
|
|
|
URL_FORMATS = [
|
|
'{baseurl}/{change_no}',
|
|
'{baseurl}/#/c/{change_no}',
|
|
'{baseurl}/c/{project}/+/{change_no}/',
|
|
]
|
|
|
|
|
|
class TestGerritCRD(ZuulTestCase):
|
|
tenant_config_file = 'config/single-tenant/main.yaml'
|
|
|
|
def _test_crd_gate(self, url_fmt):
|
|
"Test cross-repo dependencies"
|
|
A = self.fake_gerrit.addFakeChange('org/project1', 'master', 'A')
|
|
B = self.fake_gerrit.addFakeChange('org/project2', 'master', 'B')
|
|
A.addApproval('Code-Review', 2)
|
|
B.addApproval('Code-Review', 2)
|
|
|
|
AM2 = self.fake_gerrit.addFakeChange('org/project1', 'master', 'AM2')
|
|
AM1 = self.fake_gerrit.addFakeChange('org/project1', 'master', 'AM1')
|
|
AM2.setMerged()
|
|
AM1.setMerged()
|
|
|
|
BM2 = self.fake_gerrit.addFakeChange('org/project2', 'master', 'BM2')
|
|
BM1 = self.fake_gerrit.addFakeChange('org/project2', 'master', 'BM1')
|
|
BM2.setMerged()
|
|
BM1.setMerged()
|
|
|
|
# A -> AM1 -> AM2
|
|
# B -> BM1 -> BM2
|
|
# A Depends-On: B
|
|
# M2 is here to make sure it is never queried. If it is, it
|
|
# means zuul is walking down the entire history of merged
|
|
# changes.
|
|
|
|
B.setDependsOn(BM1, 1)
|
|
BM1.setDependsOn(BM2, 1)
|
|
|
|
A.setDependsOn(AM1, 1)
|
|
AM1.setDependsOn(AM2, 1)
|
|
|
|
url = url_fmt.format(baseurl=B.gerrit.baseurl.rstrip('/'),
|
|
project=B.project,
|
|
change_no=B.number)
|
|
A.data['commitMessage'] = '%s\n\nDepends-On: %s\n' % (
|
|
A.subject, url)
|
|
|
|
self.fake_gerrit.addEvent(A.addApproval('Approved', 1))
|
|
self.waitUntilSettled()
|
|
|
|
self.assertEqual(A.data['status'], 'NEW')
|
|
self.assertEqual(B.data['status'], 'NEW')
|
|
|
|
for connection in self.connections.connections.values():
|
|
connection.maintainCache([])
|
|
|
|
self.executor_server.hold_jobs_in_build = True
|
|
B.addApproval('Approved', 1)
|
|
self.fake_gerrit.addEvent(A.addApproval('Approved', 1))
|
|
self.waitUntilSettled()
|
|
|
|
self.executor_server.release('.*-merge')
|
|
self.waitUntilSettled()
|
|
self.executor_server.release('.*-merge')
|
|
self.waitUntilSettled()
|
|
self.executor_server.hold_jobs_in_build = False
|
|
self.executor_server.release()
|
|
self.waitUntilSettled()
|
|
|
|
self.assertEqual(AM2.queried, 0)
|
|
self.assertEqual(BM2.queried, 0)
|
|
self.assertEqual(A.data['status'], 'MERGED')
|
|
self.assertEqual(B.data['status'], 'MERGED')
|
|
self.assertEqual(A.reported, 2)
|
|
self.assertEqual(B.reported, 2)
|
|
|
|
changes = self.getJobFromHistory(
|
|
'project-merge', 'org/project1').changes
|
|
self.assertEqual(changes, '2,1 1,1')
|
|
|
|
# Different versions of Gerrit have used 3 different URL schemata for
|
|
# changes - repeat the simple test on each of the 3 to ensure they can be
|
|
# parsed, the other tests just use the default URL schema provided in
|
|
# FakeGerritChange.data['url'] .
|
|
def test_crd_gate_url_schema0(self):
|
|
self._test_crd_gate(URL_FORMATS[0])
|
|
|
|
def test_crd_gate_url_schema1(self):
|
|
self._test_crd_gate(URL_FORMATS[1])
|
|
|
|
def test_crd_gate_url_schema2(self):
|
|
self._test_crd_gate(URL_FORMATS[2])
|
|
|
|
def test_crd_gate_triangle(self):
|
|
A = self.fake_gerrit.addFakeChange('org/project1', 'master', 'A')
|
|
B = self.fake_gerrit.addFakeChange('org/project2', 'master', 'B')
|
|
C = self.fake_gerrit.addFakeChange('org/project2', 'master', 'C')
|
|
A.addApproval('Code-Review', 2)
|
|
B.addApproval('Code-Review', 2)
|
|
C.addApproval('Code-Review', 2)
|
|
A.addApproval('Approved', 1)
|
|
B.addApproval('Approved', 1)
|
|
|
|
# C-->B
|
|
# \ /
|
|
# v
|
|
# A
|
|
|
|
# C Depends-On: A
|
|
C.data['commitMessage'] = '%s\n\nDepends-On: %s\n' % (
|
|
C.subject, A.data['url'])
|
|
# B Depends-On: A
|
|
B.data['commitMessage'] = '%s\n\nDepends-On: %s\n' % (
|
|
B.subject, A.data['url'])
|
|
# C git-depends on B
|
|
C.setDependsOn(B, 1)
|
|
self.fake_gerrit.addEvent(C.addApproval('Approved', 1))
|
|
self.waitUntilSettled()
|
|
|
|
self.assertEqual(A.reported, 2)
|
|
self.assertEqual(B.reported, 2)
|
|
self.assertEqual(C.reported, 2)
|
|
self.assertEqual(A.data['status'], 'MERGED')
|
|
self.assertEqual(B.data['status'], 'MERGED')
|
|
self.assertEqual(C.data['status'], 'MERGED')
|
|
self.assertEqual(self.history[-1].changes, '1,1 2,1 3,1')
|
|
|
|
def test_crd_branch(self):
|
|
"Test cross-repo dependencies in multiple branches"
|
|
|
|
self.create_branch('org/project2', 'mp')
|
|
A = self.fake_gerrit.addFakeChange('org/project1', 'master', 'A')
|
|
B = self.fake_gerrit.addFakeChange('org/project2', 'master', 'B')
|
|
C1 = self.fake_gerrit.addFakeChange('org/project2', 'mp', 'C1')
|
|
|
|
A.addApproval('Code-Review', 2)
|
|
B.addApproval('Code-Review', 2)
|
|
C1.addApproval('Code-Review', 2)
|
|
|
|
# A Depends-On: B+C1
|
|
A.data['commitMessage'] = '%s\n\nDepends-On: %s\nDepends-On: %s\n' % (
|
|
A.subject, B.data['url'], C1.data['url'])
|
|
|
|
self.executor_server.hold_jobs_in_build = True
|
|
B.addApproval('Approved', 1)
|
|
C1.addApproval('Approved', 1)
|
|
self.fake_gerrit.addEvent(A.addApproval('Approved', 1))
|
|
self.waitUntilSettled()
|
|
|
|
self.executor_server.release('.*-merge')
|
|
self.waitUntilSettled()
|
|
self.executor_server.release('.*-merge')
|
|
self.waitUntilSettled()
|
|
self.executor_server.release('.*-merge')
|
|
self.waitUntilSettled()
|
|
self.executor_server.hold_jobs_in_build = False
|
|
self.executor_server.release()
|
|
self.waitUntilSettled()
|
|
|
|
self.assertEqual(A.data['status'], 'MERGED')
|
|
self.assertEqual(B.data['status'], 'MERGED')
|
|
self.assertEqual(C1.data['status'], 'MERGED')
|
|
self.assertEqual(A.reported, 2)
|
|
self.assertEqual(B.reported, 2)
|
|
self.assertEqual(C1.reported, 2)
|
|
|
|
changes = self.getJobFromHistory(
|
|
'project-merge', 'org/project1').changes
|
|
self.assertEqual(changes, '2,1 3,1 1,1')
|
|
|
|
def test_crd_multiline(self):
|
|
"Test multiple depends-on lines in commit"
|
|
A = self.fake_gerrit.addFakeChange('org/project1', 'master', 'A')
|
|
B = self.fake_gerrit.addFakeChange('org/project2', 'master', 'B')
|
|
C = self.fake_gerrit.addFakeChange('org/project2', 'master', 'C')
|
|
A.addApproval('Code-Review', 2)
|
|
B.addApproval('Code-Review', 2)
|
|
C.addApproval('Code-Review', 2)
|
|
|
|
# A Depends-On: B+C
|
|
A.data['commitMessage'] = '%s\n\nDepends-On: %s\nDepends-On: %s\n' % (
|
|
A.subject, B.data['url'], C.data['url'])
|
|
|
|
self.executor_server.hold_jobs_in_build = True
|
|
B.addApproval('Approved', 1)
|
|
C.addApproval('Approved', 1)
|
|
self.fake_gerrit.addEvent(A.addApproval('Approved', 1))
|
|
self.waitUntilSettled()
|
|
|
|
self.executor_server.release('.*-merge')
|
|
self.waitUntilSettled()
|
|
self.executor_server.release('.*-merge')
|
|
self.waitUntilSettled()
|
|
self.executor_server.release('.*-merge')
|
|
self.waitUntilSettled()
|
|
self.executor_server.hold_jobs_in_build = False
|
|
self.executor_server.release()
|
|
self.waitUntilSettled()
|
|
|
|
self.assertEqual(A.data['status'], 'MERGED')
|
|
self.assertEqual(B.data['status'], 'MERGED')
|
|
self.assertEqual(C.data['status'], 'MERGED')
|
|
self.assertEqual(A.reported, 2)
|
|
self.assertEqual(B.reported, 2)
|
|
self.assertEqual(C.reported, 2)
|
|
|
|
changes = self.getJobFromHistory(
|
|
'project-merge', 'org/project1').changes
|
|
self.assertEqual(changes, '2,1 3,1 1,1')
|
|
|
|
def test_crd_unshared_gate(self):
|
|
"Test cross-repo dependencies in unshared gate queues"
|
|
A = self.fake_gerrit.addFakeChange('org/project1', 'master', 'A')
|
|
B = self.fake_gerrit.addFakeChange('org/project', 'master', 'B')
|
|
A.addApproval('Code-Review', 2)
|
|
B.addApproval('Code-Review', 2)
|
|
|
|
# A Depends-On: B
|
|
A.data['commitMessage'] = '%s\n\nDepends-On: %s\n' % (
|
|
A.subject, B.data['url'])
|
|
|
|
# A and B do not share a queue, make sure that A is unable to
|
|
# enqueue B (and therefore, A is unable to be enqueued).
|
|
B.addApproval('Approved', 1)
|
|
self.fake_gerrit.addEvent(A.addApproval('Approved', 1))
|
|
self.waitUntilSettled()
|
|
|
|
self.assertEqual(A.data['status'], 'NEW')
|
|
self.assertEqual(B.data['status'], 'NEW')
|
|
self.assertEqual(A.reported, 0)
|
|
self.assertEqual(B.reported, 0)
|
|
self.assertEqual(len(self.history), 0)
|
|
|
|
# Enqueue and merge B alone.
|
|
self.fake_gerrit.addEvent(B.addApproval('Approved', 1))
|
|
self.waitUntilSettled()
|
|
|
|
self.assertEqual(B.data['status'], 'MERGED')
|
|
self.assertEqual(B.reported, 2)
|
|
|
|
# Now that B is merged, A should be able to be enqueued and
|
|
# merged.
|
|
self.fake_gerrit.addEvent(A.addApproval('Approved', 1))
|
|
self.waitUntilSettled()
|
|
|
|
self.assertEqual(A.data['status'], 'MERGED')
|
|
self.assertEqual(A.reported, 2)
|
|
|
|
def _test_crd_gate_reverse(self, url_fmt):
|
|
"Test reverse cross-repo dependencies"
|
|
A = self.fake_gerrit.addFakeChange('org/project1', 'master', 'A')
|
|
B = self.fake_gerrit.addFakeChange('org/project2', 'master', 'B')
|
|
A.addApproval('Code-Review', 2)
|
|
B.addApproval('Code-Review', 2)
|
|
|
|
# A Depends-On: B
|
|
|
|
url = url_fmt.format(baseurl=B.gerrit.baseurl.rstrip('/'),
|
|
project=B.project,
|
|
change_no=B.number)
|
|
A.data['commitMessage'] = '%s\n\nDepends-On: %s\n' % (
|
|
A.subject, url)
|
|
|
|
self.fake_gerrit.addEvent(A.addApproval('Approved', 1))
|
|
self.waitUntilSettled()
|
|
|
|
self.assertEqual(A.data['status'], 'NEW')
|
|
self.assertEqual(B.data['status'], 'NEW')
|
|
|
|
self.executor_server.hold_jobs_in_build = True
|
|
A.addApproval('Approved', 1)
|
|
self.fake_gerrit.addEvent(B.addApproval('Approved', 1))
|
|
self.waitUntilSettled()
|
|
|
|
self.executor_server.release('.*-merge')
|
|
self.waitUntilSettled()
|
|
self.executor_server.release('.*-merge')
|
|
self.waitUntilSettled()
|
|
self.executor_server.hold_jobs_in_build = False
|
|
self.executor_server.release()
|
|
self.waitUntilSettled()
|
|
|
|
self.assertEqual(A.data['status'], 'MERGED')
|
|
self.assertEqual(B.data['status'], 'MERGED')
|
|
self.assertEqual(A.reported, 2)
|
|
self.assertEqual(B.reported, 2)
|
|
|
|
changes = self.getJobFromHistory(
|
|
'project-merge', 'org/project1').changes
|
|
self.assertEqual(changes, '2,1 1,1')
|
|
|
|
def test_crd_gate_reverse_schema0(self):
|
|
self._test_crd_gate_reverse(URL_FORMATS[0])
|
|
|
|
def test_crd_gate_reverse_schema1(self):
|
|
self._test_crd_gate_reverse(URL_FORMATS[1])
|
|
|
|
def test_crd_gate_reverse_schema2(self):
|
|
self._test_crd_gate_reverse(URL_FORMATS[2])
|
|
|
|
def test_crd_cycle(self):
|
|
"Test cross-repo dependency cycles"
|
|
A = self.fake_gerrit.addFakeChange('org/project1', 'master', 'A')
|
|
B = self.fake_gerrit.addFakeChange('org/project2', 'master', 'B')
|
|
A.addApproval('Code-Review', 2)
|
|
B.addApproval('Code-Review', 2)
|
|
B.addApproval('Approved', 1)
|
|
|
|
# A -> B -> A (via commit-depends)
|
|
|
|
A.data['commitMessage'] = '%s\n\nDepends-On: %s\n' % (
|
|
A.subject, B.data['url'])
|
|
B.data['commitMessage'] = '%s\n\nDepends-On: %s\n' % (
|
|
B.subject, A.data['url'])
|
|
|
|
self.fake_gerrit.addEvent(A.addApproval('Approved', 1))
|
|
self.waitUntilSettled()
|
|
|
|
self.assertEqual(A.reported, 0)
|
|
self.assertEqual(B.reported, 0)
|
|
self.assertEqual(A.data['status'], 'NEW')
|
|
self.assertEqual(B.data['status'], 'NEW')
|
|
|
|
def test_crd_gate_unknown(self):
|
|
"Test unknown projects in dependent pipeline"
|
|
self.init_repo("org/unknown", tag='init')
|
|
A = self.fake_gerrit.addFakeChange('org/project', 'master', 'A')
|
|
B = self.fake_gerrit.addFakeChange('org/unknown', 'master', 'B')
|
|
A.addApproval('Code-Review', 2)
|
|
B.addApproval('Code-Review', 2)
|
|
|
|
# A Depends-On: B
|
|
A.data['commitMessage'] = '%s\n\nDepends-On: %s\n' % (
|
|
A.subject, B.data['url'])
|
|
|
|
B.addApproval('Approved', 1)
|
|
self.fake_gerrit.addEvent(A.addApproval('Approved', 1))
|
|
self.waitUntilSettled()
|
|
|
|
# Unknown projects cannot share a queue with any other
|
|
# since they don't have common jobs with any other (they have no jobs).
|
|
# Changes which depend on unknown project changes
|
|
# should not be processed in dependent pipeline
|
|
self.assertEqual(A.data['status'], 'NEW')
|
|
self.assertEqual(B.data['status'], 'NEW')
|
|
self.assertEqual(A.reported, 0)
|
|
self.assertEqual(B.reported, 0)
|
|
self.assertEqual(len(self.history), 0)
|
|
|
|
# Simulate change B being gated outside this layout Set the
|
|
# change merged before submitting the event so that when the
|
|
# event triggers a gerrit query to update the change, we get
|
|
# the information that it was merged.
|
|
B.setMerged()
|
|
self.fake_gerrit.addEvent(B.addApproval('Approved', 1))
|
|
self.waitUntilSettled()
|
|
self.assertEqual(len(self.history), 0)
|
|
|
|
# Now that B is merged, A should be able to be enqueued and
|
|
# merged.
|
|
self.fake_gerrit.addEvent(A.addApproval('Approved', 1))
|
|
self.waitUntilSettled()
|
|
|
|
self.assertEqual(A.data['status'], 'MERGED')
|
|
self.assertEqual(A.reported, 2)
|
|
self.assertEqual(B.data['status'], 'MERGED')
|
|
self.assertEqual(B.reported, 0)
|
|
|
|
def test_crd_check(self):
|
|
"Test cross-repo dependencies in independent pipelines"
|
|
|
|
self.executor_server.hold_jobs_in_build = True
|
|
self.gearman_server.hold_jobs_in_queue = True
|
|
A = self.fake_gerrit.addFakeChange('org/project1', 'master', 'A')
|
|
B = self.fake_gerrit.addFakeChange('org/project2', 'master', 'B')
|
|
|
|
# A Depends-On: B
|
|
A.data['commitMessage'] = '%s\n\nDepends-On: %s\n' % (
|
|
A.subject, B.data['url'])
|
|
|
|
self.fake_gerrit.addEvent(A.getPatchsetCreatedEvent(1))
|
|
self.waitUntilSettled()
|
|
|
|
self.gearman_server.hold_jobs_in_queue = False
|
|
self.gearman_server.release()
|
|
self.waitUntilSettled()
|
|
|
|
self.executor_server.release('.*-merge')
|
|
self.waitUntilSettled()
|
|
|
|
self.assertTrue(self.builds[0].hasChanges(A, B))
|
|
|
|
self.executor_server.hold_jobs_in_build = False
|
|
self.executor_server.release()
|
|
self.waitUntilSettled()
|
|
|
|
self.assertEqual(A.data['status'], 'NEW')
|
|
self.assertEqual(B.data['status'], 'NEW')
|
|
self.assertEqual(A.reported, 1)
|
|
self.assertEqual(B.reported, 0)
|
|
|
|
self.assertEqual(self.history[0].changes, '2,1 1,1')
|
|
tenant = self.sched.abide.tenants.get('tenant-one')
|
|
self.assertEqual(len(tenant.layout.pipelines['check'].queues), 0)
|
|
|
|
def test_crd_check_git_depends(self):
|
|
"Test single-repo dependencies in independent pipelines"
|
|
self.gearman_server.hold_jobs_in_build = True
|
|
A = self.fake_gerrit.addFakeChange('org/project1', 'master', 'A')
|
|
B = self.fake_gerrit.addFakeChange('org/project1', 'master', 'B')
|
|
|
|
# Add two git-dependent changes and make sure they both report
|
|
# success.
|
|
B.setDependsOn(A, 1)
|
|
self.fake_gerrit.addEvent(A.getPatchsetCreatedEvent(1))
|
|
self.waitUntilSettled()
|
|
self.fake_gerrit.addEvent(B.getPatchsetCreatedEvent(1))
|
|
self.waitUntilSettled()
|
|
|
|
self.orderedRelease()
|
|
self.gearman_server.hold_jobs_in_build = False
|
|
self.waitUntilSettled()
|
|
|
|
self.assertEqual(A.data['status'], 'NEW')
|
|
self.assertEqual(B.data['status'], 'NEW')
|
|
self.assertEqual(A.reported, 1)
|
|
self.assertEqual(B.reported, 1)
|
|
|
|
self.assertEqual(self.history[0].changes, '1,1')
|
|
self.assertEqual(self.history[-1].changes, '1,1 2,1')
|
|
tenant = self.sched.abide.tenants.get('tenant-one')
|
|
self.assertEqual(len(tenant.layout.pipelines['check'].queues), 0)
|
|
|
|
self.assertIn('Build succeeded', A.messages[0])
|
|
self.assertIn('Build succeeded', B.messages[0])
|
|
|
|
def test_crd_check_duplicate(self):
|
|
"Test duplicate check in independent pipelines"
|
|
self.executor_server.hold_jobs_in_build = True
|
|
A = self.fake_gerrit.addFakeChange('org/project1', 'master', 'A')
|
|
B = self.fake_gerrit.addFakeChange('org/project1', 'master', 'B')
|
|
tenant = self.sched.abide.tenants.get('tenant-one')
|
|
check_pipeline = tenant.layout.pipelines['check']
|
|
|
|
# Add two git-dependent changes...
|
|
B.setDependsOn(A, 1)
|
|
self.fake_gerrit.addEvent(B.getPatchsetCreatedEvent(1))
|
|
self.waitUntilSettled()
|
|
self.assertEqual(len(check_pipeline.getAllItems()), 2)
|
|
|
|
# ...make sure the live one is not duplicated...
|
|
self.fake_gerrit.addEvent(B.getPatchsetCreatedEvent(1))
|
|
self.waitUntilSettled()
|
|
self.assertEqual(len(check_pipeline.getAllItems()), 2)
|
|
|
|
# ...but the non-live one is able to be.
|
|
self.fake_gerrit.addEvent(A.getPatchsetCreatedEvent(1))
|
|
self.waitUntilSettled()
|
|
self.assertEqual(len(check_pipeline.getAllItems()), 3)
|
|
|
|
# Release jobs in order to avoid races with change A jobs
|
|
# finishing before change B jobs.
|
|
self.orderedRelease()
|
|
self.executor_server.hold_jobs_in_build = False
|
|
self.executor_server.release()
|
|
self.waitUntilSettled()
|
|
|
|
self.assertEqual(A.data['status'], 'NEW')
|
|
self.assertEqual(B.data['status'], 'NEW')
|
|
self.assertEqual(A.reported, 1)
|
|
self.assertEqual(B.reported, 1)
|
|
|
|
self.assertEqual(self.history[0].changes, '1,1 2,1')
|
|
self.assertEqual(self.history[1].changes, '1,1')
|
|
self.assertEqual(len(tenant.layout.pipelines['check'].queues), 0)
|
|
|
|
self.assertIn('Build succeeded', A.messages[0])
|
|
self.assertIn('Build succeeded', B.messages[0])
|
|
|
|
def _test_crd_check_reconfiguration(self, project1, project2):
|
|
"Test cross-repo dependencies re-enqueued in independent pipelines"
|
|
|
|
self.gearman_server.hold_jobs_in_queue = True
|
|
A = self.fake_gerrit.addFakeChange(project1, 'master', 'A')
|
|
B = self.fake_gerrit.addFakeChange(project2, 'master', 'B')
|
|
|
|
# A Depends-On: B
|
|
A.data['commitMessage'] = '%s\n\nDepends-On: %s\n' % (
|
|
A.subject, B.data['url'])
|
|
|
|
self.fake_gerrit.addEvent(A.getPatchsetCreatedEvent(1))
|
|
self.waitUntilSettled()
|
|
|
|
self.sched.reconfigure(self.config)
|
|
|
|
# Make sure the items still share a change queue, and the
|
|
# first one is not live.
|
|
tenant = self.sched.abide.tenants.get('tenant-one')
|
|
self.assertEqual(len(tenant.layout.pipelines['check'].queues), 1)
|
|
queue = tenant.layout.pipelines['check'].queues[0]
|
|
first_item = queue.queue[0]
|
|
for item in queue.queue:
|
|
self.assertEqual(item.queue, first_item.queue)
|
|
self.assertFalse(first_item.live)
|
|
self.assertTrue(queue.queue[1].live)
|
|
|
|
self.gearman_server.hold_jobs_in_queue = False
|
|
self.gearman_server.release()
|
|
self.waitUntilSettled()
|
|
|
|
self.assertEqual(A.data['status'], 'NEW')
|
|
self.assertEqual(B.data['status'], 'NEW')
|
|
self.assertEqual(A.reported, 1)
|
|
self.assertEqual(B.reported, 0)
|
|
|
|
self.assertEqual(self.history[0].changes, '2,1 1,1')
|
|
self.assertEqual(len(tenant.layout.pipelines['check'].queues), 0)
|
|
|
|
def test_crd_check_reconfiguration(self):
|
|
self._test_crd_check_reconfiguration('org/project1', 'org/project2')
|
|
|
|
def test_crd_undefined_project(self):
|
|
"""Test that undefined projects in dependencies are handled for
|
|
independent pipelines"""
|
|
# It's a hack for fake gerrit,
|
|
# as it implies repo creation upon the creation of any change
|
|
self.init_repo("org/unknown", tag='init')
|
|
self._test_crd_check_reconfiguration('org/project1', 'org/unknown')
|
|
|
|
@simple_layout('layouts/ignore-dependencies.yaml')
|
|
def test_crd_check_ignore_dependencies(self):
|
|
"Test cross-repo dependencies can be ignored"
|
|
|
|
self.gearman_server.hold_jobs_in_queue = True
|
|
A = self.fake_gerrit.addFakeChange('org/project1', 'master', 'A')
|
|
B = self.fake_gerrit.addFakeChange('org/project2', 'master', 'B')
|
|
C = self.fake_gerrit.addFakeChange('org/project2', 'master', 'C')
|
|
|
|
# A Depends-On: B
|
|
A.data['commitMessage'] = '%s\n\nDepends-On: %s\n' % (
|
|
A.subject, B.data['url'])
|
|
# C git-depends on B
|
|
C.setDependsOn(B, 1)
|
|
self.fake_gerrit.addEvent(A.getPatchsetCreatedEvent(1))
|
|
self.fake_gerrit.addEvent(B.getPatchsetCreatedEvent(1))
|
|
self.fake_gerrit.addEvent(C.getPatchsetCreatedEvent(1))
|
|
self.waitUntilSettled()
|
|
|
|
# Make sure none of the items share a change queue, and all
|
|
# are live.
|
|
tenant = self.sched.abide.tenants.get('tenant-one')
|
|
check_pipeline = tenant.layout.pipelines['check']
|
|
self.assertEqual(len(check_pipeline.queues), 3)
|
|
self.assertEqual(len(check_pipeline.getAllItems()), 3)
|
|
for item in check_pipeline.getAllItems():
|
|
self.assertTrue(item.live)
|
|
|
|
self.gearman_server.hold_jobs_in_queue = False
|
|
self.gearman_server.release()
|
|
self.waitUntilSettled()
|
|
|
|
self.assertEqual(A.data['status'], 'NEW')
|
|
self.assertEqual(B.data['status'], 'NEW')
|
|
self.assertEqual(C.data['status'], 'NEW')
|
|
self.assertEqual(A.reported, 1)
|
|
self.assertEqual(B.reported, 1)
|
|
self.assertEqual(C.reported, 1)
|
|
|
|
# Each job should have tested exactly one change
|
|
for job in self.history:
|
|
self.assertEqual(len(job.changes.split()), 1)
|
|
|
|
def test_crd_check_triangle(self):
|
|
A = self.fake_gerrit.addFakeChange('org/project1', 'master', 'A')
|
|
B = self.fake_gerrit.addFakeChange('org/project2', 'master', 'B')
|
|
C = self.fake_gerrit.addFakeChange('org/project2', 'master', 'C')
|
|
|
|
# C-->B
|
|
# \ /
|
|
# v
|
|
# A
|
|
|
|
# C Depends-On: A
|
|
C.data['commitMessage'] = '%s\n\nDepends-On: %s\n' % (
|
|
C.subject, A.data['url'])
|
|
# B Depends-On: A
|
|
B.data['commitMessage'] = '%s\n\nDepends-On: %s\n' % (
|
|
B.subject, A.data['url'])
|
|
# C git-depends on B
|
|
C.setDependsOn(B, 1)
|
|
self.fake_gerrit.addEvent(C.getPatchsetCreatedEvent(1))
|
|
self.waitUntilSettled()
|
|
|
|
self.assertEqual(C.reported, 1)
|
|
self.assertEqual(self.history[0].changes, '1,1 2,1 3,1')
|
|
|
|
@simple_layout('layouts/three-projects.yaml')
|
|
def test_crd_check_transitive(self):
|
|
"Test transitive cross-repo dependencies"
|
|
# Specifically, if A -> B -> C, and C gets a new patchset and
|
|
# A gets a new patchset, ensure the test of A,2 includes B,1
|
|
# and C,2 (not C,1 which would indicate stale data in the
|
|
# cache for B).
|
|
A = self.fake_gerrit.addFakeChange('org/project1', 'master', 'A')
|
|
B = self.fake_gerrit.addFakeChange('org/project2', 'master', 'B')
|
|
C = self.fake_gerrit.addFakeChange('org/project3', 'master', 'C')
|
|
|
|
# A Depends-On: B
|
|
A.data['commitMessage'] = '%s\n\nDepends-On: %s\n' % (
|
|
A.subject, B.data['url'])
|
|
|
|
# B Depends-On: C
|
|
B.data['commitMessage'] = '%s\n\nDepends-On: %s\n' % (
|
|
B.subject, C.data['url'])
|
|
|
|
self.fake_gerrit.addEvent(A.getPatchsetCreatedEvent(1))
|
|
self.waitUntilSettled()
|
|
self.assertEqual(self.history[-1].changes, '3,1 2,1 1,1')
|
|
|
|
self.fake_gerrit.addEvent(B.getPatchsetCreatedEvent(1))
|
|
self.waitUntilSettled()
|
|
self.assertEqual(self.history[-1].changes, '3,1 2,1')
|
|
|
|
self.fake_gerrit.addEvent(C.getPatchsetCreatedEvent(1))
|
|
self.waitUntilSettled()
|
|
self.assertEqual(self.history[-1].changes, '3,1')
|
|
|
|
C.addPatchset()
|
|
self.fake_gerrit.addEvent(C.getPatchsetCreatedEvent(2))
|
|
self.waitUntilSettled()
|
|
self.assertEqual(self.history[-1].changes, '3,2')
|
|
|
|
A.addPatchset()
|
|
self.fake_gerrit.addEvent(A.getPatchsetCreatedEvent(2))
|
|
self.waitUntilSettled()
|
|
self.assertEqual(self.history[-1].changes, '3,2 2,1 1,2')
|
|
|
|
def test_crd_check_unknown(self):
|
|
"Test unknown projects in independent pipeline"
|
|
self.init_repo("org/unknown", tag='init')
|
|
A = self.fake_gerrit.addFakeChange('org/project1', 'master', 'A')
|
|
B = self.fake_gerrit.addFakeChange('org/unknown', 'master', 'D')
|
|
# A Depends-On: B
|
|
A.data['commitMessage'] = '%s\n\nDepends-On: %s\n' % (
|
|
A.subject, B.data['url'])
|
|
|
|
# Make sure zuul has seen an event on B.
|
|
self.fake_gerrit.addEvent(B.getPatchsetCreatedEvent(1))
|
|
self.fake_gerrit.addEvent(A.getPatchsetCreatedEvent(1))
|
|
self.waitUntilSettled()
|
|
|
|
self.assertEqual(A.data['status'], 'NEW')
|
|
self.assertEqual(A.reported, 1)
|
|
self.assertEqual(B.data['status'], 'NEW')
|
|
self.assertEqual(B.reported, 0)
|
|
|
|
def test_crd_cycle_join(self):
|
|
"Test an updated change creates a cycle"
|
|
A = self.fake_gerrit.addFakeChange('org/project2', 'master', 'A')
|
|
|
|
self.fake_gerrit.addEvent(A.getPatchsetCreatedEvent(1))
|
|
self.waitUntilSettled()
|
|
self.assertEqual(A.reported, 1)
|
|
|
|
# Create B->A
|
|
B = self.fake_gerrit.addFakeChange('org/project1', 'master', 'B')
|
|
B.data['commitMessage'] = '%s\n\nDepends-On: %s\n' % (
|
|
B.subject, A.data['url'])
|
|
self.fake_gerrit.addEvent(B.getPatchsetCreatedEvent(1))
|
|
self.waitUntilSettled()
|
|
|
|
# Dep is there so zuul should have reported on B
|
|
self.assertEqual(B.reported, 1)
|
|
|
|
# Update A to add A->B (a cycle).
|
|
A.addPatchset()
|
|
A.data['commitMessage'] = '%s\n\nDepends-On: %s\n' % (
|
|
A.subject, B.data['url'])
|
|
self.fake_gerrit.addEvent(A.getPatchsetCreatedEvent(2))
|
|
self.waitUntilSettled()
|
|
|
|
# Dependency cycle injected so zuul should not have reported again on A
|
|
self.assertEqual(A.reported, 1)
|
|
|
|
# Now if we update B to remove the depends-on, everything
|
|
# should be okay. B; A->B
|
|
|
|
B.addPatchset()
|
|
B.data['commitMessage'] = '%s\n' % (B.subject,)
|
|
self.fake_gerrit.addEvent(A.getPatchsetCreatedEvent(2))
|
|
self.waitUntilSettled()
|
|
|
|
# Cycle was removed so now zuul should have reported again on A
|
|
self.assertEqual(A.reported, 2)
|
|
|
|
self.fake_gerrit.addEvent(B.getPatchsetCreatedEvent(2))
|
|
self.waitUntilSettled()
|
|
self.assertEqual(B.reported, 2)
|
|
|
|
|
|
class TestGerritCRDAltBaseUrl(ZuulTestCase):
|
|
tenant_config_file = 'config/single-tenant/main.yaml'
|
|
|
|
def setup_config(self):
|
|
super().setup_config()
|
|
self.baseurl = 'https://review.example.com/prefixed_gerrit_ui/'
|
|
self.config.set(
|
|
'connection gerrit',
|
|
'baseurl', self.baseurl)
|
|
|
|
def test_basic_crd_check(self):
|
|
"Test basic cross-repo dependencies with an alternate gerrit baseurl"
|
|
|
|
self.executor_server.hold_jobs_in_build = True
|
|
self.gearman_server.hold_jobs_in_queue = True
|
|
A = self.fake_gerrit.addFakeChange('org/project1', 'master', 'A')
|
|
B = self.fake_gerrit.addFakeChange('org/project2', 'master', 'B')
|
|
|
|
self.assertEqual(B.data['url'], '%s/2' % self.baseurl.rstrip('/'))
|
|
# A Depends-On: B
|
|
A.data['commitMessage'] = '%s\n\nDepends-On: %s\n' % (
|
|
A.subject, B.data['url'])
|
|
|
|
self.fake_gerrit.addEvent(A.getPatchsetCreatedEvent(1))
|
|
self.waitUntilSettled()
|
|
|
|
self.gearman_server.hold_jobs_in_queue = False
|
|
self.gearman_server.release()
|
|
self.waitUntilSettled()
|
|
|
|
self.executor_server.release('.*-merge')
|
|
self.waitUntilSettled()
|
|
|
|
self.assertTrue(self.builds[0].hasChanges(A, B))
|
|
|
|
self.executor_server.hold_jobs_in_build = False
|
|
self.executor_server.release()
|
|
self.waitUntilSettled()
|
|
|
|
self.assertEqual(A.data['status'], 'NEW')
|
|
self.assertEqual(B.data['status'], 'NEW')
|
|
self.assertEqual(A.reported, 1)
|
|
self.assertEqual(B.reported, 0)
|
|
|
|
self.assertEqual(self.history[0].changes, '2,1 1,1')
|
|
tenant = self.sched.abide.tenants.get('tenant-one')
|
|
self.assertEqual(len(tenant.layout.pipelines['check'].queues), 0)
|