| 'use strict'; |
| |
| const assert = require('assert'); |
| |
| require('../tools/js/v3-models.js'); |
| |
| const BuildbotTriggerable = require('../tools/js/buildbot-triggerable.js').BuildbotTriggerable; |
| const MockData = require('./resources/mock-data.js'); |
| const MockLogger = require('./resources/mock-logger.js').MockLogger; |
| const MockRemoteAPI = require('../unit-tests/resources/mock-remote-api.js').MockRemoteAPI; |
| const TestServer = require('./resources/test-server.js'); |
| const TemporaryFile = require('./resources/temporary-file.js').TemporaryFile; |
| const addWorkerForReport = require('./resources/common-operations.js').addWorkerForReport; |
| const prepareServerTest = require('./resources/common-operations.js').prepareServerTest; |
| const BrowserPrivilegedAPI = require('../public/v3/privileged-api.js').PrivilegedAPI; |
| |
| function configWithOneTesterTwoBuilders(testConfigurationsOverride = [{types: ['some'], platforms: ['some platform'], builders: ['builder-1'], |
| supportedRepetitionTypes: ['alternating', 'sequential']}]) |
| { |
| return { |
| triggerableName: 'build-webkit', |
| lookbackCount: 2, |
| buildRequestArgument: 'build-request-id', |
| workerName: 'sync-worker', |
| workerPassword: 'password', |
| repositoryGroups: { |
| 'webkit': { |
| repositories: {'WebKit': {acceptsPatch: true}}, |
| testProperties: {'wk': {'revision': 'WebKit'}, 'roots': {'roots': {}}}, |
| buildProperties: {'wk': {'revision': 'WebKit'}, 'wk-patch': {'patch': 'WebKit'}, |
| 'checkbox': {'ifRepositorySet': ['WebKit'], 'value': 'build-wk'}, |
| 'build-wk': {'ifRepositorySet': ['WebKit'], 'value': true}, |
| 'owned-commits': {'ownedRevisions': 'WebKit'}}, |
| acceptsRoots: true, |
| } |
| }, |
| types: { |
| 'some': { |
| test: ['some test'], |
| properties: {'test': 'some-test'}, |
| } |
| }, |
| builders: { |
| 'builder-1': { |
| builder: 'some tester', |
| properties: {forcescheduler: 'force-ab-tests'}, |
| supportedRepetitionTypes: ['alternating', 'sequential'] |
| }, |
| 'builder-2': { |
| builder: 'some builder', |
| properties: {forcescheduler: 'force-ab-builds'}, |
| supportedRepetitionTypes: ['alternating', 'sequential', 'paired-parallel'] |
| }, |
| 'builder-3': { |
| builder: 'other builder', |
| properties: {forcescheduler: 'force-ab-builds'}, |
| supportedRepetitionTypes: ['alternating', 'sequential', 'paired-parallel'] |
| }, |
| }, |
| buildConfigurations: [ |
| { |
| platforms: ['some platform'], |
| builders: ['builder-2', 'builder-3'], |
| supportedRepetitionTypes: ['alternating', 'sequential', 'paired-parallel'] |
| }, |
| ], |
| testConfigurations: testConfigurationsOverride |
| }; |
| } |
| |
| const configWithPlatformName = { |
| triggerableName: 'build-webkit', |
| lookbackCount: 2, |
| buildRequestArgument: 'build-request-id', |
| workerName: 'sync-worker', |
| workerPassword: 'password', |
| platformArgument: 'platform-name', |
| repositoryGroups: { |
| 'webkit': { |
| repositories: {'WebKit': {acceptsPatch: true}}, |
| testProperties: {'wk': {'revision': 'WebKit'}, 'roots': {'roots': {}}}, |
| buildProperties: {'wk': {'revision': 'WebKit'}, 'wk-patch': {'patch': 'WebKit'}, |
| 'checkbox': {'ifRepositorySet': ['WebKit'], 'value': 'build-wk'}, |
| 'build-wk': {'ifRepositorySet': ['WebKit'], 'value': true}, |
| 'owned-commits': {'ownedRevisions': 'WebKit'}}, |
| acceptsRoots: true, |
| } |
| }, |
| types: { |
| 'some': { |
| test: ['some test'], |
| properties: {'test': 'some-test'}, |
| } |
| }, |
| builders: { |
| 'builder-1': { |
| builder: 'some tester', |
| properties: {forcescheduler: 'force-ab-tests'}, |
| supportedRepetitionTypes: ['alternating', 'sequential'] |
| }, |
| 'builder-2': { |
| builder: 'some builder', |
| properties: {forcescheduler: 'force-ab-builds'}, |
| supportedRepetitionTypes: ['alternating', 'sequential', 'paired-parallel'] |
| }, |
| 'builder-3': { |
| builder: 'other builder', |
| properties: {forcescheduler: 'force-ab-builds'}, |
| supportedRepetitionTypes: ['alternating', 'sequential', 'paired-parallel'] |
| }, |
| }, |
| buildConfigurations: [ |
| { |
| platforms: ['some platform'], |
| builders: ['builder-2', 'builder-3'], |
| supportedRepetitionTypes: ['alternating', 'sequential', 'paired-parallel'], |
| }, |
| ], |
| testConfigurations: [ |
| { |
| types: ['some'], |
| platforms: ['some platform'], |
| builders: ['builder-1'], |
| supportedRepetitionTypes: ['alternating', 'sequential'], |
| }, |
| ], |
| }; |
| |
| const configWithTwoTesters = { |
| triggerableName: 'build-webkit', |
| lookbackCount: 2, |
| buildRequestArgument: 'build-request-id', |
| workerName: 'sync-worker', |
| workerPassword: 'password', |
| repositoryGroups: { |
| 'webkit': { |
| repositories: {'WebKit': {acceptsPatch: true}}, |
| testProperties: {'wk': {'revision': 'WebKit'}, 'roots': {'roots': {}}}, |
| buildProperties: {'wk': {'revision': 'WebKit'}, 'wk-patch': {'patch': 'WebKit'}, |
| 'checkbox': {'ifRepositorySet': ['WebKit'], 'value': 'build-wk'}, |
| 'build-wk': {'ifRepositorySet': ['WebKit'], 'value': true}, |
| 'owned-commits': {'ownedRevisions': 'WebKit'}}, |
| acceptsRoots: true, |
| } |
| }, |
| types: { |
| 'some': { |
| test: ['some test'], |
| properties: {'test': 'some-test'}, |
| } |
| }, |
| builders: { |
| 'builder-1': { |
| builder: 'some tester', |
| properties: {forcescheduler: 'force-ab-tests'}, |
| supportedRepetitionTypes: ['alternating', 'sequential'] |
| }, |
| 'builder-2': { |
| builder: 'another tester', |
| properties: {forcescheduler: 'force-ab-builds'}, |
| supportedRepetitionTypes: ['alternating', 'sequential'] |
| }, |
| }, |
| testConfigurations: [ |
| { |
| types: ['some'], |
| platforms: ['some platform'], |
| builders: ['builder-1', 'builder-2'], |
| supportedRepetitionTypes: ['alternating', 'sequential'], |
| }, |
| ] |
| }; |
| |
| function assertAndResolveRequest(request, method, url, contentToResolve) |
| { |
| assert.strictEqual(request.method, method); |
| assert.strictEqual(request.url, url); |
| request.resolve(contentToResolve); |
| } |
| |
| function createTriggerable(config = configWithOneTesterTwoBuilders()) |
| { |
| let triggerable; |
| return MockData.addMockConfiguration(TestServer.database()).then(() => { |
| return Manifest.fetch(); |
| }).then(() => { |
| triggerable = new BuildbotTriggerable(config, TestServer.remoteAPI(), MockRemoteAPI, {name: 'sync-worker', password: 'password'}, new MockLogger); |
| const syncPromise = triggerable.initSyncers().then(() => triggerable.updateTriggerable()); |
| assertAndResolveRequest(MockRemoteAPI.requests[0], 'GET', MockData.buildbotBuildersURL(), MockData.mockBuildbotBuilders()); |
| MockRemoteAPI.reset(); |
| return syncPromise; |
| }).then(() => Manifest.fetch()).then(() => { |
| return new BuildbotTriggerable(config, TestServer.remoteAPI(), MockRemoteAPI, {name: 'sync-worker', password: 'password'}, new MockLogger); |
| }); |
| } |
| |
| function createTestGroup(task_name='custom task') { |
| const someTest = Test.findById(MockData.someTestId()); |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| const set1 = new CustomCommitSet; |
| set1.setRevisionForRepository(webkit, '191622'); |
| const set2 = new CustomCommitSet; |
| set2.setRevisionForRepository(webkit, '192736'); |
| return TestGroup.createWithTask('custom task', Platform.findById(MockData.somePlatformId()), someTest, 'some group', 2, 'alternating', [set1, set2]).then((task) => { |
| return TestGroup.findAllByTask(task.id())[0]; |
| }); |
| } |
| |
| async function createTestGroupWithPatch(repetitionType = 'alternating') |
| { |
| const patchFile = await TemporaryFile.makeTemporaryFile('patch.dat', 'patch file'); |
| const originalPrivilegedAPI = global.PrivilegedAPI; |
| BrowserPrivilegedAPI._token = null; |
| global.PrivilegedAPI = BrowserPrivilegedAPI; |
| const uploadedPatchFile = await UploadedFile.uploadFile(patchFile); |
| global.PrivilegedAPI = originalPrivilegedAPI; |
| |
| const someTest = Test.findById(MockData.someTestId()); |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| const set1 = new CustomCommitSet; |
| set1.setRevisionForRepository(webkit, '191622', uploadedPatchFile); |
| const set2 = new CustomCommitSet; |
| set2.setRevisionForRepository(webkit, '191622'); |
| const task = await TestGroup.createWithTask('custom task', Platform.findById(MockData.somePlatformId()), someTest, 'some group', 2, repetitionType, [set1, set2]); |
| |
| return TestGroup.findAllByTask(task.id())[0]; |
| } |
| |
| function createTestGroupWihOwnedCommit() |
| { |
| const someTest = Test.findById(MockData.someTestId()); |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| const ownedSJC = Repository.findById(MockData.ownedJSCRepositoryId()); |
| const set1 = new CustomCommitSet; |
| set1.setRevisionForRepository(webkit, '191622'); |
| set1.setRevisionForRepository(ownedSJC, 'owned-jsc-6161', null, '191622'); |
| const set2 = new CustomCommitSet; |
| set2.setRevisionForRepository(webkit, '192736'); |
| set2.setRevisionForRepository(ownedSJC, 'owned-jsc-9191', null, '192736'); |
| return TestGroup.createWithTask('custom task', Platform.findById(MockData.somePlatformId()), someTest, 'some group', 2, 'alternating', [set1, set2]).then((task) => { |
| return TestGroup.findAllByTask(task.id())[0]; |
| }); |
| } |
| |
| function uploadRoot(buildRequestId, buildTag, repositoryList = ["WebKit"], buildTime = '2017-05-10T02:54:08.666') |
| { |
| return TemporaryFile.makeTemporaryFile(`root${buildTag}.dat`, `root for build ${buildTag} and repository list at ${buildTime}`).then((rootFile) => { |
| return TestServer.remoteAPI().postFormData('/api/upload-root/', { |
| workerName: 'sync-worker', |
| workerPassword: 'password', |
| builderName: 'some builder', |
| buildTag: buildTag, |
| buildTime: buildTime, |
| buildRequest: buildRequestId, |
| rootFile, |
| repositoryList: JSON.stringify(repositoryList), |
| }); |
| }); |
| } |
| |
| describe('sync-buildbot', function () { |
| prepareServerTest(this, 'node'); |
| TemporaryFile.inject(); |
| |
| beforeEach(() => { |
| MockRemoteAPI.reset('http://build.webkit.org'); |
| PrivilegedAPI.configure('test', 'password'); |
| }); |
| |
| it('should not schedule on another builder if the build was scheduled on one builder before', () => { |
| const requests = MockRemoteAPI.requests; |
| let firstTestGroup; |
| let firstTestGroupFirstBuildRequest; |
| let secondTestGroup; |
| let secondTestGroupFirstBuildRequest; |
| let syncPromise; |
| let triggerable; |
| let taskId = null; |
| let anotherTaskId = null; |
| return createTriggerable(configWithTwoTesters).then((newTriggerable) => { |
| triggerable = newTriggerable; |
| return Promise.all([createTestGroup(), createTestGroup('another custom task')]); |
| }).then((testGroups) => { |
| firstTestGroup = testGroups[0]; |
| secondTestGroup = testGroups[1]; |
| firstTestGroupFirstBuildRequest = firstTestGroup.buildRequests()[0].id(); |
| secondTestGroupFirstBuildRequest = secondTestGroup.buildRequests()[0].id(); |
| taskId = firstTestGroup.task().id(); |
| anotherTaskId = secondTestGroup.task().id(); |
| syncPromise = triggerable.initSyncers().then(() => triggerable.syncOnce()); |
| assertAndResolveRequest(requests[0], 'GET', MockData.buildbotBuildersURL(), MockData.mockBuildbotBuilders()); |
| MockRemoteAPI.reset(); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 2); |
| assertAndResolveRequest(requests[0], 'GET', MockData.pendingBuildsUrl('some tester'), MockData.pendingBuild({builderId: MockData.builderIDForName('some tester'), buildRequestId: secondTestGroupFirstBuildRequest})); |
| assertAndResolveRequest(requests[1], 'GET', MockData.pendingBuildsUrl('another tester'), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 4); |
| assertAndResolveRequest(requests[2], 'GET', MockData.recentBuildsUrl('some tester', 2), |
| MockData.runningBuild({builderId: MockData.builderIDForName('some tester'), buildRequestId: firstTestGroupFirstBuildRequest})); |
| assertAndResolveRequest(requests[3], 'GET', MockData.recentBuildsUrl('another tester', 2), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 6); |
| assertAndResolveRequest(requests[4], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[5], 'GET', MockData.pendingBuildsUrl('another tester'), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 8); |
| assertAndResolveRequest(requests[6], 'GET', MockData.recentBuildsUrl('some tester', 2), { |
| 'builds': [ |
| MockData.runningBuildData({builderId: MockData.builderIDForName('some tester'), buildRequestId: secondTestGroupFirstBuildRequest}), |
| MockData.finishedBuildData({builderId: MockData.builderIDForName('some tester'), buildRequestId: firstTestGroupFirstBuildRequest})] |
| }); |
| assertAndResolveRequest(requests[7], 'GET', MockData.recentBuildsUrl('another tester', 2), {}); |
| return syncPromise; |
| }).then(() => { |
| return TestGroup.fetchForTask(taskId, true); |
| }).then((testGroups) => { |
| assert.strictEqual(testGroups.length, 1); |
| const testGroup = testGroups[0]; |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert.strictEqual(testGroup.buildRequests().length, 4); |
| assert(!buildRequest.isBuild()); |
| assert(buildRequest.isTest()); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(!otherBuildRequest.isBuild()); |
| assert(otherBuildRequest.isTest()); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '192736'); |
| |
| return TestGroup.fetchForTask(anotherTaskId, true); |
| }).then((testGroups) => { |
| assert.strictEqual(testGroups.length, 1); |
| const testGroup = testGroups[0]; |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert.strictEqual(testGroup.buildRequests().length, 4); |
| assert(!buildRequest.isBuild()); |
| assert(buildRequest.isTest()); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(!otherBuildRequest.isBuild()); |
| assert(otherBuildRequest.isTest()); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '192736'); |
| }); |
| }); |
| |
| it('should keep updating build status', async () => { |
| const requests = MockRemoteAPI.requests; |
| let syncPromise; |
| const triggerable = await createTriggerable(); |
| const firstBuildNumber = 123; |
| const secondBuildNumber = 124; |
| let testGroup = await createTestGroupWithPatch(); |
| |
| const taskId = testGroup.task().id(); |
| let webkit = Repository.findById(MockData.webkitRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| let buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(buildRequest.statusUrl(), null); |
| assert.strictEqual(buildRequest.statusDescription(), null); |
| assert.strictEqual(buildRequest.buildId(), null); |
| |
| let commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| let webkitPatch = commitSet.patchForRepository(webkit); |
| assert(webkitPatch instanceof UploadedFile); |
| assert.strictEqual(webkitPatch.filename(), 'patch.dat'); |
| assert.strictEqual(commitSet.rootForRepository(webkit), null); |
| assert.deepEqual(commitSet.allRootFiles(), []); |
| |
| let otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), null); |
| assert.strictEqual(otherBuildRequest.statusDescription(), null); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| let otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.rootForRepository(webkit), null); |
| assert.deepEqual(otherCommitSet.allRootFiles(), []); |
| |
| syncPromise = triggerable.initSyncers().then(() => triggerable.syncOnce()); |
| assertAndResolveRequest(requests[0], 'GET', MockData.buildbotBuildersURL(), MockData.mockBuildbotBuilders()); |
| MockRemoteAPI.reset(); |
| await MockRemoteAPI.waitForRequest(); |
| |
| assert.strictEqual(requests.length, 3); |
| assertAndResolveRequest(requests[0], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[1], 'GET', MockData.pendingBuildsUrl('some builder'), {}); |
| assertAndResolveRequest(requests[2], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| await MockRemoteAPI.waitForRequest(); |
| |
| assert.strictEqual(requests.length, 6); |
| assertAndResolveRequest(requests[3], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[4], 'GET', MockData.recentBuildsUrl('some builder', 2), {}); |
| assertAndResolveRequest(requests[5], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| await MockRemoteAPI.waitForRequest(); |
| |
| assert.strictEqual(requests.length, 7); |
| assertAndResolveRequest(requests[6], 'POST', '/api/v2/forceschedulers/force-ab-builds', 'OK'); |
| assert.deepEqual(requests[6].data, {'id': '1', 'jsonrpc': '2.0', 'method': 'force', 'params': |
| {'wk': '191622', 'wk-patch': RemoteAPI.url('/api/uploaded-file/1.dat'), 'checkbox': 'build-wk', 'build-wk': true, 'build-request-id': '1', 'forcescheduler': 'force-ab-builds'}}); |
| await MockRemoteAPI.waitForRequest(); |
| |
| assert.strictEqual(requests.length, 10); |
| assertAndResolveRequest(requests[7], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[8], 'GET', MockData.pendingBuildsUrl('some builder'), |
| MockData.pendingBuild({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1})); |
| assertAndResolveRequest(requests[9], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| await MockRemoteAPI.waitForRequest(); |
| |
| assert.strictEqual(requests.length, 13); |
| assertAndResolveRequest(requests[10], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[11], 'GET', MockData.recentBuildsUrl('some builder', 2), |
| MockData.runningBuild({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1, buildNumber: firstBuildNumber, statusDescription: 'Building WebKit'})); |
| assertAndResolveRequest(requests[12], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| await syncPromise; |
| |
| let testGroups = await TestGroup.fetchForTask(taskId, true); |
| |
| assert.strictEqual(testGroups.length, 1); |
| testGroup = testGroups[0]; |
| webkit = Repository.findById(MockData.webkitRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Running'); |
| assert.strictEqual(buildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.strictEqual(buildRequest.statusDescription(), 'Building WebKit'); |
| assert.strictEqual(buildRequest.buildId(), null); |
| |
| commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| webkitPatch = commitSet.patchForRepository(webkit); |
| assert(webkitPatch instanceof UploadedFile); |
| assert.strictEqual(webkitPatch.filename(), 'patch.dat'); |
| assert.strictEqual(commitSet.rootForRepository(webkit), null); |
| assert.deepEqual(commitSet.allRootFiles(), []); |
| |
| otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), null); |
| assert.strictEqual(otherBuildRequest.statusDescription(), null); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.rootForRepository(webkit), null); |
| assert.deepEqual(otherCommitSet.allRootFiles(), []); |
| |
| MockRemoteAPI.reset(); |
| syncPromise = triggerable.initSyncers().then(() => triggerable.syncOnce()); |
| assertAndResolveRequest(requests[0], 'GET', MockData.buildbotBuildersURL(), MockData.mockBuildbotBuilders()); |
| MockRemoteAPI.reset(); |
| await MockRemoteAPI.waitForRequest(); |
| |
| assert.strictEqual(requests.length, 3); |
| assertAndResolveRequest(requests[0], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[1], 'GET', MockData.pendingBuildsUrl('some builder'), {}); |
| assertAndResolveRequest(requests[2], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| await MockRemoteAPI.waitForRequest(); |
| |
| assert.strictEqual(requests.length, 6); |
| assertAndResolveRequest(requests[3], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[4], 'GET', MockData.recentBuildsUrl('some builder', 2), |
| MockData.runningBuild({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1, buildTag: firstBuildNumber, statusDescription: 'Compiling WTF'})); |
| assertAndResolveRequest(requests[5], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| await MockRemoteAPI.waitForRequest(); |
| |
| assert.strictEqual(requests.length, 9); |
| assertAndResolveRequest(requests[6], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[7], 'GET', MockData.pendingBuildsUrl('some builder'), {}); |
| assertAndResolveRequest(requests[8], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| await MockRemoteAPI.waitForRequest(); |
| |
| assert.strictEqual(requests.length, 12); |
| assertAndResolveRequest(requests[9], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[10], 'GET', MockData.recentBuildsUrl('some builder', 2), |
| MockData.runningBuild({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1, buildTag: firstBuildNumber, statusDescription: 'Compiling WTF'})); |
| assertAndResolveRequest(requests[11], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| await syncPromise; |
| |
| await TestGroup.fetchForTask(taskId, true); |
| |
| assert.strictEqual(testGroups.length, 1); |
| testGroup = testGroups[0]; |
| webkit = Repository.findById(MockData.webkitRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Running'); |
| assert.strictEqual(buildRequest.statusUrl(), MockData.statusUrl('some builder', firstBuildNumber)); |
| assert.strictEqual(buildRequest.statusDescription(), 'Compiling WTF'); |
| assert.strictEqual(buildRequest.buildId(), null); |
| |
| commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| webkitPatch = commitSet.patchForRepository(webkit); |
| assert(webkitPatch instanceof UploadedFile); |
| assert.strictEqual(webkitPatch.filename(), 'patch.dat'); |
| assert.strictEqual(commitSet.rootForRepository(webkit), null); |
| assert.deepEqual(commitSet.allRootFiles(), []); |
| |
| otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), null); |
| assert.strictEqual(otherBuildRequest.statusDescription(), null); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.rootForRepository(webkit), null); |
| assert.deepEqual(otherCommitSet.allRootFiles(), []); |
| |
| await uploadRoot(parseInt(buildRequest.id()), firstBuildNumber); |
| |
| testGroups = await TestGroup.fetchForTask(taskId, true); |
| |
| assert.strictEqual(testGroups.length, 1); |
| testGroup = testGroups[0]; |
| webkit = Repository.findById(MockData.webkitRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Completed'); |
| assert.strictEqual(buildRequest.statusUrl(), MockData.statusUrl('some builder', firstBuildNumber)); |
| assert.strictEqual(buildRequest.statusDescription(), 'Compiling WTF'); |
| assert.notEqual(buildRequest.buildId(), null); |
| |
| commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| webkitPatch = commitSet.patchForRepository(webkit); |
| assert(webkitPatch instanceof UploadedFile); |
| assert.strictEqual(webkitPatch.filename(), 'patch.dat'); |
| let webkitRoot = commitSet.rootForRepository(webkit); |
| assert(webkitRoot instanceof UploadedFile); |
| assert.strictEqual(webkitRoot.filename(), 'root123.dat'); |
| assert.deepEqual(commitSet.allRootFiles(), [webkitRoot]); |
| |
| otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), null); |
| assert.strictEqual(otherBuildRequest.statusDescription(), null); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.rootForRepository(webkit), null); |
| assert.deepEqual(otherCommitSet.allRootFiles(), []); |
| |
| MockRemoteAPI.reset(); |
| syncPromise = triggerable.initSyncers().then(() => triggerable.syncOnce()); |
| assertAndResolveRequest(requests[0], 'GET', MockData.buildbotBuildersURL(), MockData.mockBuildbotBuilders()); |
| MockRemoteAPI.reset(); |
| await MockRemoteAPI.waitForRequest(); |
| |
| assert.strictEqual(requests.length, 3); |
| assertAndResolveRequest(requests[0], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[1], 'GET', MockData.pendingBuildsUrl('some builder'), {}); |
| assertAndResolveRequest(requests[2], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| await MockRemoteAPI.waitForRequest(); |
| |
| assert.strictEqual(requests.length, 6); |
| assertAndResolveRequest(requests[3], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[4], 'GET', MockData.recentBuildsUrl('some builder', 2), |
| MockData.finishedBuild({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1, buildTag: firstBuildNumber})); |
| assertAndResolveRequest(requests[5], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| await MockRemoteAPI.waitForRequest(); |
| |
| assert.strictEqual(requests.length, 7); |
| assertAndResolveRequest(requests[6], 'POST', '/api/v2/forceschedulers/force-ab-builds', 'OK'); |
| assert.deepEqual(requests[6].data, {'id': '2', 'jsonrpc': '2.0', 'method': 'force', 'params': |
| {'wk': '191622', 'build-request-id': '2', 'forcescheduler': 'force-ab-builds', 'checkbox': 'build-wk', 'build-wk': true}}); |
| await MockRemoteAPI.waitForRequest(); |
| |
| assert.strictEqual(requests.length, 10); |
| assertAndResolveRequest(requests[7], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[8], 'GET', MockData.pendingBuildsUrl('some builder'), {}); |
| assertAndResolveRequest(requests[9], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| await MockRemoteAPI.waitForRequest(); |
| |
| assert.strictEqual(requests.length, 13); |
| assertAndResolveRequest(requests[10], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[11], 'GET', MockData.recentBuildsUrl('some builder', 2), { |
| 'builds': [ |
| MockData.runningBuildData({builderId: MockData.builderIDForName('some builder'), buildRequestId: 2, buildTag: secondBuildNumber}), |
| MockData.finishedBuildData({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1, buildTag: firstBuildNumber})] |
| }); |
| assertAndResolveRequest(requests[12], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| await syncPromise; |
| |
| await TestGroup.fetchForTask(taskId, true); |
| |
| assert.strictEqual(testGroups.length, 1); |
| testGroup = testGroups[0]; |
| webkit = Repository.findById(MockData.webkitRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Completed'); |
| assert.strictEqual(buildRequest.statusUrl(), MockData.statusUrl('some builder', firstBuildNumber)); |
| assert.strictEqual(buildRequest.statusDescription(), null); |
| assert.notEqual(buildRequest.buildId(), null); |
| |
| commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| webkitPatch = commitSet.patchForRepository(webkit); |
| assert(webkitPatch instanceof UploadedFile); |
| assert.strictEqual(webkitPatch.filename(), 'patch.dat'); |
| webkitRoot = commitSet.rootForRepository(webkit); |
| assert(webkitRoot instanceof UploadedFile); |
| assert.strictEqual(webkitRoot.filename(), 'root123.dat'); |
| assert.deepEqual(commitSet.allRootFiles(), [webkitRoot]); |
| |
| otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Running'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), MockData.statusUrl('some builder', secondBuildNumber)); |
| assert.strictEqual(otherBuildRequest.statusDescription(), null); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.rootForRepository(webkit), null); |
| assert.deepEqual(otherCommitSet.allRootFiles(), []); |
| await uploadRoot(parseInt(otherBuildRequest.id()), 124); |
| |
| testGroups = await TestGroup.fetchForTask(taskId, true); |
| |
| assert.strictEqual(testGroups.length, 1); |
| testGroup = testGroups[0]; |
| webkit = Repository.findById(MockData.webkitRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Completed'); |
| assert.strictEqual(buildRequest.statusUrl(), MockData.statusUrl('some builder', firstBuildNumber)); |
| assert.strictEqual(buildRequest.statusDescription(), null); |
| assert.notEqual(buildRequest.buildId(), null); |
| |
| commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| webkitPatch = commitSet.patchForRepository(webkit); |
| assert(webkitPatch instanceof UploadedFile); |
| assert.strictEqual(webkitPatch.filename(), 'patch.dat'); |
| webkitRoot = commitSet.rootForRepository(webkit); |
| assert(webkitRoot instanceof UploadedFile); |
| assert.strictEqual(webkitRoot.filename(), 'root123.dat'); |
| assert.deepEqual(commitSet.allRootFiles(), [webkitRoot]); |
| |
| otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Completed'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), MockData.statusUrl('some builder', secondBuildNumber)); |
| assert.strictEqual(otherBuildRequest.statusDescription(), null); |
| assert.notEqual(otherBuildRequest.buildId(), null); |
| |
| otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| const otherWebkitRoot = otherCommitSet.rootForRepository(webkit); |
| assert(otherWebkitRoot instanceof UploadedFile); |
| assert.strictEqual(otherWebkitRoot.filename(), 'root124.dat'); |
| assert.deepEqual(otherCommitSet.allRootFiles(), [otherWebkitRoot]); |
| }); |
| |
| async function resolveSyncerToBuildBotRequests(requestResolutionList) |
| { |
| const requests = MockRemoteAPI.requests; |
| let resolutionIndexOffset = 0; |
| for (let i = 0; i < requestResolutionList.length; i++) { |
| const resolutions = requestResolutionList[i]; |
| assert.strictEqual(requests.length, resolutionIndexOffset + resolutions.length); |
| resolutions.forEach((resolution, index) => { |
| assertAndResolveRequest(requests[resolutionIndexOffset + index], resolution.method, resolution.url, resolution.resolve); |
| if ('data' in resolution) |
| assert.deepEqual(requests[resolutionIndexOffset + index].data, resolution.data) |
| }); |
| resolutionIndexOffset += resolutions.length; |
| if (i != requestResolutionList.length - 1) |
| await MockRemoteAPI.waitForRequest(); |
| } |
| MockRemoteAPI.reset(); |
| } |
| |
| function validateFirstTwoBuildRequestsInTestGroup(testGroup, buildRequestOverride = {}, otherBuildRequestOverride = {}) |
| { |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), buildRequestOverride.statusLabel || 'Waiting'); |
| assert.strictEqual(buildRequest.statusUrl(), buildRequestOverride.statusUrl || null); |
| assert.strictEqual(buildRequest.statusDescription(), buildRequestOverride.statusDescription || null); |
| assert.strictEqual(buildRequest.buildId(), buildRequestOverride.buildId || null); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| const webkitPatch = commitSet.patchForRepository(webkit); |
| assert(webkitPatch instanceof UploadedFile); |
| assert.strictEqual(webkitPatch.filename(), 'patch.dat'); |
| if (!buildRequestOverride.webkitRootUploaded) { |
| assert.strictEqual(commitSet.rootForRepository(webkit), null); |
| assert.deepEqual(commitSet.allRootFiles(), []); |
| } |
| else { |
| const webkitRoot = commitSet.rootForRepository(webkit); |
| assert(webkitRoot instanceof UploadedFile); |
| assert.strictEqual(webkitRoot.filename(), 'root123.dat'); |
| assert.deepEqual(commitSet.allRootFiles(), [webkitRoot]); |
| } |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), otherBuildRequestOverride.statusLabel || 'Waiting'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), otherBuildRequestOverride.statusUrl || null); |
| assert.strictEqual(otherBuildRequest.statusDescription(), otherBuildRequestOverride.statusDescription || null); |
| assert.strictEqual(otherBuildRequest.buildId(), otherBuildRequestOverride.buildId || null); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| |
| if (!otherBuildRequestOverride.webkitRootUploaded) { |
| assert.strictEqual(otherCommitSet.rootForRepository(webkit), null); |
| assert.deepEqual(otherCommitSet.allRootFiles(), []); |
| } |
| else { |
| const otherWebkitRoot = otherCommitSet.rootForRepository(webkit); |
| assert(otherWebkitRoot instanceof UploadedFile); |
| assert.strictEqual(otherWebkitRoot.filename(), 'root124.dat'); |
| assert.deepEqual(otherCommitSet.allRootFiles(), [otherWebkitRoot]); |
| } |
| } |
| |
| it('should be able to schedule a "paired-parallel" build request for building a patch on buildbot', async () => { |
| let syncPromise; |
| const triggerable = await createTriggerable(configWithOneTesterTwoBuilders([ |
| { builders: ['builder-1'], types: ['some'], platforms: ['some platform'], supportedRepetitionTypes: ['alternating', 'paired-parallel'] }])); |
| const firstBuildNumber = 123; |
| const secondBuildNumber = 124; |
| let testGroup = await createTestGroupWithPatch('paired-parallel'); |
| |
| const taskId = testGroup.task().id(); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| validateFirstTwoBuildRequestsInTestGroup(testGroup); |
| |
| syncPromise = triggerable.initSyncers().then(() => triggerable.syncOnce()); |
| await resolveSyncerToBuildBotRequests([ |
| [ |
| { method: 'GET', url: MockData.buildbotBuildersURL(), resolve: MockData.mockBuildbotBuilders() }, |
| ], |
| [ |
| { method: 'GET', url: MockData.pendingBuildsUrl('some tester'), resolve: {} }, |
| { method: 'GET', url: MockData.pendingBuildsUrl('some builder'), resolve: {} }, |
| { method: 'GET', url: MockData.pendingBuildsUrl('other builder'), resolve: {} }, |
| ], |
| [ |
| { method: 'GET', url: MockData.recentBuildsUrl('some tester', 2), resolve: {} }, |
| { method: 'GET', url: MockData.recentBuildsUrl('some builder', 2), resolve: MockData.runningBuild({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1, buildTag: firstBuildNumber, statusDescription: 'Compiling WTF'}) }, |
| { method: 'GET', url: MockData.recentBuildsUrl('other builder', 2), resolve: {} }, |
| ], |
| [ |
| { method: 'GET', url: MockData.pendingBuildsUrl('some tester'), resolve: {} }, |
| { method: 'GET', url: MockData.pendingBuildsUrl('some builder'), resolve: {} }, |
| { method: 'GET', url: MockData.pendingBuildsUrl('other builder'), resolve: {} }, |
| ], |
| [ |
| { method: 'GET', url: MockData.recentBuildsUrl('some tester', 2), resolve: {} }, |
| { method: 'GET', url: MockData.recentBuildsUrl('some builder', 2), resolve: MockData.runningBuild({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1, buildTag: firstBuildNumber, statusDescription: 'Compiling WTF'}) }, |
| { method: 'GET', url: MockData.recentBuildsUrl('other builder', 2), resolve: {} }, |
| ] |
| ]); |
| await syncPromise; |
| |
| let testGroups = await TestGroup.fetchForTask(taskId, true); |
| assert.strictEqual(testGroups.length, 1); |
| assert.strictEqual(testGroups[0].buildRequests().length, 6); |
| validateFirstTwoBuildRequestsInTestGroup(testGroups[0], {statusLabel: 'Running', statusUrl: MockData.statusUrl('some builder', firstBuildNumber), statusDescription: 'Compiling WTF'}); |
| |
| await uploadRoot(parseInt(testGroups[0].buildRequests()[0].id()), firstBuildNumber); |
| testGroups = await TestGroup.fetchForTask(taskId, true); |
| assert.strictEqual(testGroups.length, 1); |
| validateFirstTwoBuildRequestsInTestGroup(testGroups[0], {statusLabel: 'Completed', statusUrl: MockData.statusUrl('some builder', firstBuildNumber), statusDescription: 'Compiling WTF', buildId: '1', webkitRootUploaded: true}); |
| |
| syncPromise = triggerable.initSyncers().then(() => triggerable.syncOnce()); |
| await resolveSyncerToBuildBotRequests([ |
| [ |
| { method: 'GET', url: MockData.buildbotBuildersURL(), resolve: MockData.mockBuildbotBuilders() }, |
| ], |
| [ |
| { method: 'GET', url: MockData.pendingBuildsUrl('some tester'), resolve: {} }, |
| { method: 'GET', url: MockData.pendingBuildsUrl('some builder'), resolve: {} }, |
| { method: 'GET', url: MockData.pendingBuildsUrl('other builder'), resolve: {} }, |
| ], |
| [ |
| { method: 'GET', url: MockData.recentBuildsUrl('some tester', 2), resolve: {} }, |
| { method: 'GET', url: MockData.recentBuildsUrl('some builder', 2), resolve: MockData.finishedBuild({builderId: MockData.builderIDForName('some builder'), buildRequestId: '1', buildTag: firstBuildNumber}) }, |
| { method: 'GET', url: MockData.recentBuildsUrl('other builder', 2), resolve: {} }, |
| ], |
| [ |
| { |
| method: 'POST', url: '/api/v2/forceschedulers/force-ab-builds', resolve: 'OK', |
| data: {'id': '2', 'jsonrpc': '2.0', 'method': 'force', 'params': {'wk': '191622', 'build-request-id': '2', 'forcescheduler': 'force-ab-builds', 'checkbox': 'build-wk', 'build-wk': true}} |
| }, |
| ], |
| [ |
| { method: 'GET', url: MockData.pendingBuildsUrl('some tester'), resolve: {} }, |
| { method: 'GET', url: MockData.pendingBuildsUrl('some builder'), resolve: {} }, |
| { method: 'GET', url: MockData.pendingBuildsUrl('other builder'), resolve: {} }, |
| ], |
| [ |
| { method: 'GET', url: MockData.recentBuildsUrl('some tester', 2), resolve: {} }, |
| { method: 'GET', url: MockData.recentBuildsUrl('some builder', 2), resolve: { |
| builds: [ |
| MockData.runningBuildData({builderId: MockData.builderIDForName('some builder'), buildRequestId: 2, buildTag: secondBuildNumber}), |
| MockData.finishedBuildData({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1, buildTag: firstBuildNumber}) |
| ]} }, |
| { method: 'GET', url: MockData.recentBuildsUrl('other builder', 2), resolve: {} }, |
| ] |
| ]); |
| await syncPromise; |
| |
| await TestGroup.fetchForTask(taskId, true); |
| assert.strictEqual(testGroups.length, 1); |
| validateFirstTwoBuildRequestsInTestGroup(testGroups[0], {statusLabel: 'Completed', statusUrl: MockData.statusUrl('some builder', firstBuildNumber), buildId: '1', webkitRootUploaded: true}, |
| {statusLabel: 'Running', statusUrl: MockData.statusUrl('some builder', secondBuildNumber)}); |
| |
| await uploadRoot(parseInt(testGroups[0].buildRequests()[1].id()), 124); |
| testGroups = await TestGroup.fetchForTask(taskId, true); |
| assert.strictEqual(testGroups.length, 1); |
| validateFirstTwoBuildRequestsInTestGroup(testGroups[0], {statusLabel: 'Completed', statusUrl: MockData.statusUrl('some builder', firstBuildNumber), buildId: '1', webkitRootUploaded: true}, |
| {statusLabel: 'Completed', statusUrl: MockData.statusUrl('some builder', secondBuildNumber), buildId: '2', webkitRootUploaded: true}); |
| |
| syncPromise = triggerable.initSyncers().then(() => triggerable.syncOnce()); |
| await resolveSyncerToBuildBotRequests([ |
| [ |
| { method: 'GET', url: MockData.buildbotBuildersURL(), resolve: MockData.mockBuildbotBuilders() }, |
| ], |
| [ |
| { method: 'GET', url: MockData.pendingBuildsUrl('some tester'), resolve: {} }, |
| { method: 'GET', url: MockData.pendingBuildsUrl('some builder'), resolve: {} }, |
| { method: 'GET', url: MockData.pendingBuildsUrl('other builder'), resolve: {} }, |
| ], |
| [ |
| { method: 'GET', url: MockData.recentBuildsUrl('some tester', 2), resolve: {} }, |
| { method: 'GET', url: MockData.recentBuildsUrl('some builder', 2), resolve: { builds: [ |
| MockData.finishedBuildData({builderId: MockData.builderIDForName('some builder'), buildRequestId: 2, buildTag: secondBuildNumber}), |
| MockData.finishedBuildData({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1, buildTag: firstBuildNumber})]}}, |
| { method: 'GET', url: MockData.recentBuildsUrl('other builder', 2), resolve: {} }, |
| ], |
| [ |
| { method: 'GET', url: MockData.pendingBuildsUrl('some tester'), resolve: {} }, |
| { method: 'GET', url: MockData.pendingBuildsUrl('some builder'), resolve: {} }, |
| { method: 'GET', url: MockData.pendingBuildsUrl('other builder'), resolve: {} }, |
| ], |
| [ |
| { method: 'GET', url: MockData.recentBuildsUrl('some tester', 2), resolve: {} }, |
| { method: 'GET', url: MockData.recentBuildsUrl('some builder', 2), resolve: { builds: [ |
| MockData.finishedBuildData({builderId: MockData.builderIDForName('some builder'), buildRequestId: 2, buildTag: secondBuildNumber}), |
| MockData.finishedBuildData({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1, buildTag: firstBuildNumber})]}}, |
| { method: 'GET', url: MockData.recentBuildsUrl('other builder', 2), resolve: {} }, |
| ] |
| ]); |
| await syncPromise; |
| |
| await TestGroup.fetchForTask(taskId, true); |
| assert.strictEqual(testGroups.length, 1); |
| assert.strictEqual(testGroups[0].buildRequests().length, 6); |
| |
| const buildRequest = testGroups[0].buildRequests()[2]; |
| assert(buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Waiting'); |
| }); |
| |
| it('should schedule a build to build a patch', () => { |
| const requests = MockRemoteAPI.requests; |
| let triggerable; |
| let taskId = null; |
| let syncPromise; |
| return createTriggerable().then((newTriggerable) => { |
| triggerable = newTriggerable; |
| return createTestGroupWithPatch(); |
| }).then((testGroup) => { |
| taskId = testGroup.task().id(); |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(buildRequest.statusUrl(), null); |
| assert.strictEqual(buildRequest.buildId(), null); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| const webkitPatch = commitSet.patchForRepository(webkit); |
| assert(webkitPatch instanceof UploadedFile); |
| assert.strictEqual(webkitPatch.filename(), 'patch.dat'); |
| assert.strictEqual(commitSet.rootForRepository(webkit), null); |
| assert.deepEqual(commitSet.allRootFiles(), []); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), null); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.rootForRepository(webkit), null); |
| assert.deepEqual(otherCommitSet.allRootFiles(), []); |
| |
| syncPromise = triggerable.initSyncers().then(() => triggerable.syncOnce()); |
| assertAndResolveRequest(requests[0], 'GET', MockData.buildbotBuildersURL(), MockData.mockBuildbotBuilders()); |
| MockRemoteAPI.reset(); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 3); |
| assertAndResolveRequest(requests[0], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[1], 'GET', MockData.pendingBuildsUrl('some builder'), {}); |
| assertAndResolveRequest(requests[2], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 6); |
| assertAndResolveRequest(requests[3], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[4], 'GET', MockData.recentBuildsUrl('some builder', 2), {}); |
| assertAndResolveRequest(requests[5], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 7); |
| assertAndResolveRequest(requests[6], 'POST', '/api/v2/forceschedulers/force-ab-builds', 'OK'); |
| assert.deepEqual(requests[6].data, {'id': '1', 'jsonrpc': '2.0', 'method': 'force', 'params': |
| {'wk': '191622', 'wk-patch': RemoteAPI.url('/api/uploaded-file/1.dat'), 'checkbox': 'build-wk', 'build-wk': true, 'build-request-id': '1', 'forcescheduler': 'force-ab-builds'}}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 10); |
| assertAndResolveRequest(requests[7], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[8], 'GET', MockData.pendingBuildsUrl('some builder'), |
| MockData.pendingBuild({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1})); |
| assertAndResolveRequest(requests[9], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 13); |
| assertAndResolveRequest(requests[10], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[11], 'GET', MockData.recentBuildsUrl('some builder', 2), |
| MockData.runningBuild({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1})); |
| assertAndResolveRequest(requests[12], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| return syncPromise; |
| }).then(() => { |
| return TestGroup.fetchForTask(taskId, true); |
| }).then((testGroups) => { |
| assert.strictEqual(testGroups.length, 1); |
| const testGroup = testGroups[0]; |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Running'); |
| assert.strictEqual(buildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.strictEqual(buildRequest.buildId(), null); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| const webkitPatch = commitSet.patchForRepository(webkit); |
| assert(webkitPatch instanceof UploadedFile); |
| assert.strictEqual(webkitPatch.filename(), 'patch.dat'); |
| assert.strictEqual(commitSet.rootForRepository(webkit), null); |
| assert.deepEqual(commitSet.allRootFiles(), []); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), null); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.rootForRepository(webkit), null); |
| assert.deepEqual(otherCommitSet.allRootFiles(), []); |
| |
| return uploadRoot(parseInt(buildRequest.id()), 123); |
| }).then(() => { |
| return TestGroup.fetchForTask(taskId, true); |
| }).then((testGroups) => { |
| assert.strictEqual(testGroups.length, 1); |
| const testGroup = testGroups[0]; |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Completed'); |
| assert.strictEqual(buildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.notEqual(buildRequest.buildId(), null); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| const webkitPatch = commitSet.patchForRepository(webkit); |
| assert(webkitPatch instanceof UploadedFile); |
| assert.strictEqual(webkitPatch.filename(), 'patch.dat'); |
| const webkitRoot = commitSet.rootForRepository(webkit); |
| assert(webkitRoot instanceof UploadedFile); |
| assert.strictEqual(webkitRoot.filename(), 'root123.dat'); |
| assert.deepEqual(commitSet.allRootFiles(), [webkitRoot]); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), null); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.rootForRepository(webkit), null); |
| assert.deepEqual(otherCommitSet.allRootFiles(), []); |
| |
| MockRemoteAPI.reset(); |
| syncPromise = triggerable.initSyncers().then(() => triggerable.syncOnce()); |
| assertAndResolveRequest(requests[0], 'GET', MockData.buildbotBuildersURL(), MockData.mockBuildbotBuilders()); |
| MockRemoteAPI.reset(); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 3); |
| assertAndResolveRequest(requests[0], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[1], 'GET', MockData.pendingBuildsUrl('some builder'), {}); |
| assertAndResolveRequest(requests[2], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 6); |
| assertAndResolveRequest(requests[3], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[4], 'GET', MockData.recentBuildsUrl('some builder', 2), |
| MockData.finishedBuild({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1})); |
| assertAndResolveRequest(requests[5], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 7); |
| assertAndResolveRequest(requests[6], 'POST', '/api/v2/forceschedulers/force-ab-builds', 'OK'); |
| assert.deepEqual(requests[6].data, {'id': '2', 'jsonrpc': '2.0', 'method': 'force', 'params': |
| {'wk': '191622', 'build-request-id': '2', 'forcescheduler': 'force-ab-builds', 'checkbox': 'build-wk', 'build-wk': true}}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 10); |
| assertAndResolveRequest(requests[7], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[8], 'GET', MockData.pendingBuildsUrl('some builder'), {}); |
| assertAndResolveRequest(requests[9], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 13); |
| assertAndResolveRequest(requests[10], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[11], 'GET', MockData.recentBuildsUrl('some builder', 2), { |
| 'builds': [ |
| MockData.runningBuildData({builderId: MockData.builderIDForName('some builder'), buildRequestId: 2}), |
| MockData.finishedBuildData({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1})] |
| }); |
| assertAndResolveRequest(requests[12], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| return syncPromise; |
| }).then(() => { |
| return TestGroup.fetchForTask(taskId, true); |
| }).then((testGroups) => { |
| assert.strictEqual(testGroups.length, 1); |
| const testGroup = testGroups[0]; |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Completed'); |
| assert.strictEqual(buildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.notEqual(buildRequest.buildId(), null); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| const webkitPatch = commitSet.patchForRepository(webkit); |
| assert(webkitPatch instanceof UploadedFile); |
| assert.strictEqual(webkitPatch.filename(), 'patch.dat'); |
| const webkitRoot = commitSet.rootForRepository(webkit); |
| assert(webkitRoot instanceof UploadedFile); |
| assert.strictEqual(webkitRoot.filename(), 'root123.dat'); |
| assert.deepEqual(commitSet.allRootFiles(), [webkitRoot]); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Running'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.rootForRepository(webkit), null); |
| assert.deepEqual(otherCommitSet.allRootFiles(), []); |
| |
| return uploadRoot(parseInt(otherBuildRequest.id()), 124); |
| }).then(() => { |
| return TestGroup.fetchForTask(taskId, true); |
| }).then((testGroups) => { |
| assert.strictEqual(testGroups.length, 1); |
| const testGroup = testGroups[0]; |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Completed'); |
| assert.strictEqual(buildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.notEqual(buildRequest.buildId(), null); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| const webkitPatch = commitSet.patchForRepository(webkit); |
| assert(webkitPatch instanceof UploadedFile); |
| assert.strictEqual(webkitPatch.filename(), 'patch.dat'); |
| const webkitRoot = commitSet.rootForRepository(webkit); |
| assert(webkitRoot instanceof UploadedFile); |
| assert.strictEqual(webkitRoot.filename(), 'root123.dat'); |
| assert.deepEqual(commitSet.allRootFiles(), [webkitRoot]); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Completed'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.notEqual(otherBuildRequest.buildId(), null); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| const otherWebkitRoot = otherCommitSet.rootForRepository(webkit); |
| assert(otherWebkitRoot instanceof UploadedFile); |
| assert.strictEqual(otherWebkitRoot.filename(), 'root124.dat'); |
| assert.deepEqual(otherCommitSet.allRootFiles(), [otherWebkitRoot]); |
| }); |
| }); |
| |
| it('should schedule a build with platform in build property', () => { |
| const requests = MockRemoteAPI.requests; |
| let triggerable; |
| let taskId = null; |
| let syncPromise; |
| return createTriggerable(configWithPlatformName).then((newTriggerable) => { |
| triggerable = newTriggerable; |
| return createTestGroupWithPatch(); |
| }).then((testGroup) => { |
| taskId = testGroup.task().id(); |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(buildRequest.statusUrl(), null); |
| assert.strictEqual(buildRequest.buildId(), null); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| const webkitPatch = commitSet.patchForRepository(webkit); |
| assert(webkitPatch instanceof UploadedFile); |
| assert.strictEqual(webkitPatch.filename(), 'patch.dat'); |
| assert.strictEqual(commitSet.rootForRepository(webkit), null); |
| assert.deepEqual(commitSet.allRootFiles(), []); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), null); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.rootForRepository(webkit), null); |
| assert.deepEqual(otherCommitSet.allRootFiles(), []); |
| |
| syncPromise = triggerable.initSyncers().then(() => triggerable.syncOnce()); |
| assertAndResolveRequest(requests[0], 'GET', MockData.buildbotBuildersURL(), MockData.mockBuildbotBuilders()); |
| MockRemoteAPI.reset(); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 3); |
| assertAndResolveRequest(requests[0], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[1], 'GET', MockData.pendingBuildsUrl('some builder'), {}); |
| assertAndResolveRequest(requests[2], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 6); |
| assertAndResolveRequest(requests[3], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[4], 'GET', MockData.recentBuildsUrl('some builder', 2), {}); |
| assertAndResolveRequest(requests[5], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 7); |
| assertAndResolveRequest(requests[6], 'POST', '/api/v2/forceschedulers/force-ab-builds', 'OK'); |
| assert.deepEqual(requests[6].data, {'id': '1', 'jsonrpc': '2.0', 'method': 'force', 'params': |
| {'wk': '191622', 'wk-patch': RemoteAPI.url('/api/uploaded-file/1.dat'), 'build-request-id': '1', 'forcescheduler': 'force-ab-builds', 'checkbox': 'build-wk', 'build-wk': true, 'platform-name': 'some platform'}}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 10); |
| assertAndResolveRequest(requests[7], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[8], 'GET', MockData.pendingBuildsUrl('some builder'), |
| MockData.pendingBuild({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1})); |
| assertAndResolveRequest(requests[9], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 13); |
| assertAndResolveRequest(requests[10], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[11], 'GET', MockData.recentBuildsUrl('some builder', 2), |
| MockData.runningBuild({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1})); |
| assertAndResolveRequest(requests[12], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| return syncPromise; |
| }).then(() => { |
| return TestGroup.fetchForTask(taskId, true); |
| }).then((testGroups) => { |
| assert.strictEqual(testGroups.length, 1); |
| const testGroup = testGroups[0]; |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Running'); |
| assert.strictEqual(buildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.strictEqual(buildRequest.buildId(), null); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| const webkitPatch = commitSet.patchForRepository(webkit); |
| assert(webkitPatch instanceof UploadedFile); |
| assert.strictEqual(webkitPatch.filename(), 'patch.dat'); |
| assert.strictEqual(commitSet.rootForRepository(webkit), null); |
| assert.deepEqual(commitSet.allRootFiles(), []); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), null); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.rootForRepository(webkit), null); |
| assert.deepEqual(otherCommitSet.allRootFiles(), []); |
| |
| return uploadRoot(parseInt(buildRequest.id()), 123); |
| }).then(() => { |
| return TestGroup.fetchForTask(taskId, true); |
| }).then((testGroups) => { |
| assert.strictEqual(testGroups.length, 1); |
| const testGroup = testGroups[0]; |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Completed'); |
| assert.strictEqual(buildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.notEqual(buildRequest.buildId(), null); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| const webkitPatch = commitSet.patchForRepository(webkit); |
| assert(webkitPatch instanceof UploadedFile); |
| assert.strictEqual(webkitPatch.filename(), 'patch.dat'); |
| const webkitRoot = commitSet.rootForRepository(webkit); |
| assert(webkitRoot instanceof UploadedFile); |
| assert.strictEqual(webkitRoot.filename(), 'root123.dat'); |
| assert.deepEqual(commitSet.allRootFiles(), [webkitRoot]); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), null); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.rootForRepository(webkit), null); |
| assert.deepEqual(otherCommitSet.allRootFiles(), []); |
| |
| MockRemoteAPI.reset(); |
| syncPromise = triggerable.initSyncers().then(() => triggerable.syncOnce()); |
| assertAndResolveRequest(requests[0], 'GET', MockData.buildbotBuildersURL(), MockData.mockBuildbotBuilders()); |
| MockRemoteAPI.reset(); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 3); |
| assertAndResolveRequest(requests[0], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[1], 'GET', MockData.pendingBuildsUrl('some builder'), {}); |
| assertAndResolveRequest(requests[2], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 6); |
| assertAndResolveRequest(requests[3], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[4], 'GET', MockData.recentBuildsUrl('some builder', 2), |
| MockData.finishedBuild({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1})); |
| assertAndResolveRequest(requests[5], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 7); |
| assertAndResolveRequest(requests[6], 'POST', '/api/v2/forceschedulers/force-ab-builds', 'OK'); |
| assert.deepEqual(requests[6].data, {'id': '2', 'jsonrpc': '2.0', 'method': 'force', 'params': |
| {'wk': '191622', 'build-request-id': '2', 'forcescheduler': 'force-ab-builds', 'checkbox': 'build-wk', 'build-wk': true, 'platform-name': 'some platform'}}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 10); |
| assertAndResolveRequest(requests[7], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[8], 'GET', MockData.pendingBuildsUrl('some builder'), {}); |
| assertAndResolveRequest(requests[9], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 13); |
| assertAndResolveRequest(requests[10], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[11], 'GET', MockData.recentBuildsUrl('some builder', 2), { |
| 'builds': [ |
| MockData.runningBuildData({builderId: MockData.builderIDForName('some builder'), buildRequestId: 2}), |
| MockData.finishedBuildData({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1})] |
| }); |
| assertAndResolveRequest(requests[12], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| return syncPromise; |
| }).then(() => { |
| return TestGroup.fetchForTask(taskId, true); |
| }).then((testGroups) => { |
| assert.strictEqual(testGroups.length, 1); |
| const testGroup = testGroups[0]; |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Completed'); |
| assert.strictEqual(buildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.notEqual(buildRequest.buildId(), null); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| const webkitPatch = commitSet.patchForRepository(webkit); |
| assert(webkitPatch instanceof UploadedFile); |
| assert.strictEqual(webkitPatch.filename(), 'patch.dat'); |
| const webkitRoot = commitSet.rootForRepository(webkit); |
| assert(webkitRoot instanceof UploadedFile); |
| assert.strictEqual(webkitRoot.filename(), 'root123.dat'); |
| assert.deepEqual(commitSet.allRootFiles(), [webkitRoot]); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Running'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.rootForRepository(webkit), null); |
| assert.deepEqual(otherCommitSet.allRootFiles(), []); |
| |
| return uploadRoot(parseInt(otherBuildRequest.id()), 124); |
| }).then(() => { |
| return TestGroup.fetchForTask(taskId, true); |
| }).then((testGroups) => { |
| assert.strictEqual(testGroups.length, 1); |
| const testGroup = testGroups[0]; |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Completed'); |
| assert.strictEqual(buildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.notEqual(buildRequest.buildId(), null); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| const webkitPatch = commitSet.patchForRepository(webkit); |
| assert(webkitPatch instanceof UploadedFile); |
| assert.strictEqual(webkitPatch.filename(), 'patch.dat'); |
| const webkitRoot = commitSet.rootForRepository(webkit); |
| assert(webkitRoot instanceof UploadedFile); |
| assert.strictEqual(webkitRoot.filename(), 'root123.dat'); |
| assert.deepEqual(commitSet.allRootFiles(), [webkitRoot]); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Completed'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.notEqual(otherBuildRequest.buildId(), null); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| const otherWebkitRoot = otherCommitSet.rootForRepository(webkit); |
| assert(otherWebkitRoot instanceof UploadedFile); |
| assert.strictEqual(otherWebkitRoot.filename(), 'root124.dat'); |
| assert.deepEqual(otherCommitSet.allRootFiles(), [otherWebkitRoot]); |
| }); |
| }); |
| |
| it('should schedule a build to test after building a patch', () => { |
| const requests = MockRemoteAPI.requests; |
| let triggerable; |
| let taskId = null; |
| let syncPromise; |
| let firstRoot = null; |
| return createTriggerable().then((newTriggerable) => { |
| triggerable = newTriggerable; |
| return createTestGroupWithPatch(); |
| }).then((testGroup) => { |
| taskId = testGroup.task().id(); |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert.strictEqual(parseInt(buildRequest.id()), 1); |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(buildRequest.buildId(), null); |
| assert.deepEqual(buildRequest.commitSet().allRootFiles(), []); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert.strictEqual(parseInt(otherBuildRequest.id()), 2); |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| assert.deepEqual(otherBuildRequest.commitSet().allRootFiles(), []); |
| |
| return uploadRoot(1, 45); |
| }).then(() => { |
| return uploadRoot(2, 46); |
| }).then(() => { |
| return TestGroup.fetchForTask(taskId, true); |
| }).then((testGroups) => { |
| assert.strictEqual(testGroups.length, 1); |
| const testGroup = testGroups[0]; |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Completed'); |
| assert.notEqual(buildRequest.buildId(), null); |
| const roots = buildRequest.commitSet().allRootFiles(); |
| assert.strictEqual(roots.length, 1); |
| firstRoot = roots[0]; |
| assert.deepEqual(roots[0].filename(), 'root45.dat'); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Completed'); |
| assert.notEqual(otherBuildRequest.buildId(), null); |
| const otherRoots = otherBuildRequest.commitSet().allRootFiles(); |
| assert.strictEqual(otherRoots.length, 1); |
| assert.deepEqual(otherRoots[0].filename(), 'root46.dat'); |
| syncPromise = triggerable.initSyncers().then(() => triggerable.syncOnce()); |
| assertAndResolveRequest(requests[0], 'GET', MockData.buildbotBuildersURL(), MockData.mockBuildbotBuilders()); |
| MockRemoteAPI.reset(); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 3); |
| assertAndResolveRequest(requests[0], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[1], 'GET', MockData.pendingBuildsUrl('some builder'), {}); |
| assertAndResolveRequest(requests[2], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 6); |
| assertAndResolveRequest(requests[3], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[4], 'GET', MockData.recentBuildsUrl('some builder', 2), { |
| 'builds': [ |
| MockData.finishedBuildData({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1}), |
| MockData.finishedBuildData({builderId: MockData.builderIDForName('some builder'), buildRequestId: 2})] |
| }); |
| assertAndResolveRequest(requests[5], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 7); |
| assertAndResolveRequest(requests[6], 'POST', '/api/v2/forceschedulers/force-ab-tests', 'OK'); |
| assert.deepEqual(requests[6].data, {'id': '3', 'jsonrpc': '2.0', 'method': 'force', 'params': |
| {'test': 'some-test', 'wk': '191622', 'build-request-id': '3','forcescheduler': 'force-ab-tests', 'roots': JSON.stringify([{url: firstRoot.url()}])}}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 10); |
| assertAndResolveRequest(requests[7], 'GET', MockData.pendingBuildsUrl('some tester'), [ |
| MockData.pendingBuild({builderId: MockData.builderIDForName('some tester'), buildRequestId: 3}), |
| ]); |
| assertAndResolveRequest(requests[8], 'GET', MockData.pendingBuildsUrl('some builder'), {}); |
| assertAndResolveRequest(requests[9], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 13); |
| assertAndResolveRequest(requests[10], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[11], 'GET', MockData.recentBuildsUrl('some builder', 2), { |
| 'builds': [ |
| MockData.finishedBuildData({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1}), |
| MockData.finishedBuildData({builderId: MockData.builderIDForName('some builder'), buildRequestId: 2})] |
| }); |
| assertAndResolveRequest(requests[12], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| return syncPromise; |
| }); |
| }); |
| |
| it('should not schedule a build to test while building a patch', () => { |
| const requests = MockRemoteAPI.requests; |
| let triggerable; |
| let taskId = null; |
| let syncPromise; |
| return createTriggerable().then((newTriggerable) => { |
| triggerable = newTriggerable; |
| return createTestGroupWithPatch(); |
| }).then((testGroup) => { |
| taskId = testGroup.task().id(); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert.strictEqual(parseInt(buildRequest.id()), 1); |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(buildRequest.statusUrl(), null); |
| assert.strictEqual(buildRequest.buildId(), null); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert.strictEqual(parseInt(otherBuildRequest.id()), 2); |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), null); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| syncPromise = triggerable.initSyncers().then(() => triggerable.syncOnce()); |
| assertAndResolveRequest(requests[0], 'GET', MockData.buildbotBuildersURL(), MockData.mockBuildbotBuilders()); |
| MockRemoteAPI.reset(); |
| return Promise.all([MockRemoteAPI.waitForRequest(), uploadRoot(1, 123)]); |
| }).then(() => { |
| assert.strictEqual(requests.length, 3); |
| assertAndResolveRequest(requests[0], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[1], 'GET', MockData.pendingBuildsUrl('some builder'), {}); |
| assertAndResolveRequest(requests[2], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 6); |
| assertAndResolveRequest(requests[3], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[4], 'GET', MockData.recentBuildsUrl('some builder', 2), { |
| 'builds': [ |
| MockData.runningBuildData({builderId: MockData.builderIDForName('some builder'), buildRequestId: 2}), |
| MockData.finishedBuildData({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1}) |
| ] |
| }); |
| assertAndResolveRequest(requests[5], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 9); |
| assertAndResolveRequest(requests[6], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[7], 'GET', MockData.pendingBuildsUrl('some builder'), {}); |
| assertAndResolveRequest(requests[8], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 12); |
| assertAndResolveRequest(requests[9], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[10], 'GET', MockData.recentBuildsUrl('some builder', 2), { |
| 'builds': [ |
| MockData.runningBuildData({builderId: MockData.builderIDForName('some builder'), buildRequestId: 2, buildTag: 1002}), |
| MockData.finishedBuildData({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1})] |
| }); |
| assertAndResolveRequest(requests[11], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| return syncPromise; |
| }).then(() => { |
| return TestGroup.fetchForTask(taskId, true); |
| }).then((testGroups) => { |
| assert.strictEqual(testGroups.length, 1); |
| |
| const testGroup = testGroups[0]; |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert.strictEqual(parseInt(buildRequest.id()), 1); |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Completed'); |
| assert.strictEqual(buildRequest.statusUrl(), 'http://build.webkit.org/#/builders/1/builds/123'); |
| assert.notEqual(buildRequest.buildId(), null); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert.strictEqual(parseInt(otherBuildRequest.id()), 2); |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Running'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), MockData.statusUrl('some builder', 1002)); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| }); |
| }); |
| |
| it('should cancel builds for testing when a build to build a patch fails', () => { |
| const requests = MockRemoteAPI.requests; |
| let triggerable; |
| let taskId = null; |
| let syncPromise; |
| return createTriggerable().then((newTriggerable) => { |
| triggerable = newTriggerable; |
| return createTestGroupWithPatch(); |
| }).then((testGroup) => { |
| taskId = testGroup.task().id(); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert.strictEqual(parseInt(buildRequest.id()), 1); |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(buildRequest.statusUrl(), null); |
| assert.strictEqual(buildRequest.buildId(), null); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert.strictEqual(parseInt(otherBuildRequest.id()), 2); |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), null); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| syncPromise = triggerable.initSyncers().then(() => triggerable.syncOnce()); |
| assertAndResolveRequest(requests[0], 'GET', MockData.buildbotBuildersURL(), MockData.mockBuildbotBuilders()); |
| MockRemoteAPI.reset(); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 3); |
| assertAndResolveRequest(requests[0], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[1], 'GET', MockData.pendingBuildsUrl('some builder'), {}); |
| assertAndResolveRequest(requests[2], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 6); |
| assertAndResolveRequest(requests[3], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[4], 'GET', MockData.recentBuildsUrl('some builder', 2), {}); |
| assertAndResolveRequest(requests[5], 'GET', MockData.recentBuildsUrl('other builder', 2), |
| MockData.finishedBuild({builderId: MockData.builderIDForName('other builder'), buildRequestId: 1, buildTag: 312})); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 9); |
| assertAndResolveRequest(requests[6], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[7], 'GET', MockData.pendingBuildsUrl('some builder'), {}); |
| assertAndResolveRequest(requests[8], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 12); |
| assertAndResolveRequest(requests[9], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[10], 'GET', MockData.recentBuildsUrl('some builder', 2), {}); |
| assertAndResolveRequest(requests[11], 'GET', MockData.recentBuildsUrl('other builder', 2), |
| MockData.finishedBuild({builderId: MockData.builderIDForName('other builder'), buildRequestId: 1, buildTag: 312})); |
| return syncPromise; |
| }).then(() => { |
| return TestGroup.fetchForTask(taskId, true); |
| }).then((testGroups) => { |
| assert.strictEqual(testGroups.length, 1); |
| |
| const buildReqeusts = testGroups[0].buildRequests(); |
| assert(buildReqeusts[0].isBuild()); |
| assert(!buildReqeusts[0].isTest()); |
| assert.strictEqual(buildReqeusts[0].statusLabel(), 'Failed'); |
| assert.strictEqual(buildReqeusts[0].statusUrl(), MockData.statusUrl('other builder', 312)); |
| assert.strictEqual(buildReqeusts[0].buildId(), null); |
| |
| assert(buildReqeusts[1].isBuild()); |
| assert(!buildReqeusts[1].isTest()); |
| assert.strictEqual(buildReqeusts[1].statusLabel(), 'Failed'); |
| assert.strictEqual(buildReqeusts[1].statusUrl(), null); |
| assert.strictEqual(buildReqeusts[1].buildId(), null); |
| |
| function assertTestBuildHasFailed(request) |
| { |
| assert(!request.isBuild()); |
| assert(request.isTest()); |
| assert.strictEqual(request.statusLabel(), 'Failed'); |
| assert.strictEqual(request.statusUrl(), null); |
| assert.strictEqual(request.buildId(), null); |
| } |
| |
| assertTestBuildHasFailed(buildReqeusts[2]); |
| assertTestBuildHasFailed(buildReqeusts[3]); |
| }); |
| }); |
| |
| it('should schedule a build to build binary for owned commits', () => { |
| const requests = MockRemoteAPI.requests; |
| let triggerable; |
| let taskId = null; |
| let syncPromise; |
| return createTriggerable().then((newTriggerable) => { |
| triggerable = newTriggerable; |
| return createTestGroupWihOwnedCommit(); |
| }).then((testGroup) => { |
| taskId = testGroup.task().id(); |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| const ownedJSC = Repository.findById(MockData.ownedJSCRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(buildRequest.statusUrl(), null); |
| assert.strictEqual(buildRequest.buildId(), null); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(commitSet.patchForRepository(webkit), null); |
| assert.strictEqual(commitSet.rootForRepository(webkit), null); |
| assert.strictEqual(commitSet.ownerRevisionForRepository(webkit), null); |
| assert.strictEqual(commitSet.ownerRevisionForRepository(ownedJSC), commitSet.revisionForRepository(webkit)); |
| assert.deepEqual(commitSet.allRootFiles(), []); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), null); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '192736'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.rootForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.ownerRevisionForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.ownerRevisionForRepository(ownedJSC), otherCommitSet.revisionForRepository(webkit)); |
| assert.deepEqual(otherCommitSet.allRootFiles(), []); |
| |
| syncPromise = triggerable.initSyncers().then(() => triggerable.syncOnce()); |
| assertAndResolveRequest(requests[0], 'GET', MockData.buildbotBuildersURL(), MockData.mockBuildbotBuilders()); |
| MockRemoteAPI.reset(); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 3); |
| assertAndResolveRequest(requests[0], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[1], 'GET', MockData.pendingBuildsUrl('some builder'), {}); |
| assertAndResolveRequest(requests[2], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 6); |
| assertAndResolveRequest(requests[3], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[4], 'GET', MockData.recentBuildsUrl('some builder', 2), {}); |
| assertAndResolveRequest(requests[5], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 7); |
| assertAndResolveRequest(requests[6], 'POST', '/api/v2/forceschedulers/force-ab-builds', 'OK'); |
| assert.deepEqual(requests[6].data, {'id': '1', 'jsonrpc': '2.0', 'method': 'force', 'params': |
| {'wk': '191622', 'build-request-id': '1', 'forcescheduler': 'force-ab-builds', 'owned-commits': `{"WebKit":[{"revision":"owned-jsc-6161","repository":"JavaScriptCore","ownerRevision":"191622"}]}`}}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 10); |
| assertAndResolveRequest(requests[7], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[8], 'GET', MockData.pendingBuildsUrl('some builder'), |
| MockData.pendingBuild({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1})); |
| assertAndResolveRequest(requests[9], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 13); |
| assertAndResolveRequest(requests[10], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[11], 'GET', MockData.recentBuildsUrl('some builder', 2), |
| MockData.runningBuild({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1})); |
| assertAndResolveRequest(requests[12], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| return syncPromise; |
| }).then(() => { |
| return TestGroup.fetchForTask(taskId, true); |
| }).then((testGroups) => { |
| assert.strictEqual(testGroups.length, 1); |
| const testGroup = testGroups[0]; |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| const ownedJSC = Repository.findById(MockData.ownedJSCRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Running'); |
| assert.strictEqual(buildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.strictEqual(buildRequest.buildId(), null); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(commitSet.patchForRepository(webkit), null); |
| assert.strictEqual(commitSet.rootForRepository(webkit), null); |
| assert.strictEqual(commitSet.ownerRevisionForRepository(webkit), null); |
| assert.strictEqual(commitSet.ownerRevisionForRepository(ownedJSC), commitSet.revisionForRepository(webkit)); |
| assert.deepEqual(commitSet.allRootFiles(), []); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), null); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '192736'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.rootForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.ownerRevisionForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.ownerRevisionForRepository(ownedJSC), otherCommitSet.revisionForRepository(webkit)); |
| assert.deepEqual(otherCommitSet.allRootFiles(), []); |
| |
| return uploadRoot(parseInt(buildRequest.id()), 123).then(() => uploadRoot(parseInt(buildRequest.id()), 123, [{ownerRepository: 'WebKit', ownedRepository: 'JavaScriptCore'}], '2017-05-10T02:54:09.666')); |
| }).then(() => { |
| return TestGroup.fetchForTask(taskId, true); |
| }).then((testGroups) => { |
| assert.strictEqual(testGroups.length, 1); |
| const testGroup = testGroups[0]; |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| const ownedJSC = Repository.findById(MockData.ownedJSCRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Completed'); |
| assert.strictEqual(buildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.notEqual(buildRequest.buildId(), null); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(commitSet.patchForRepository(webkit), null); |
| assert.strictEqual(commitSet.ownerRevisionForRepository(webkit), null); |
| assert.strictEqual(commitSet.ownerRevisionForRepository(ownedJSC), commitSet.revisionForRepository(webkit)); |
| const webkitRoot = commitSet.rootForRepository(webkit); |
| assert(webkitRoot instanceof UploadedFile); |
| assert.strictEqual(webkitRoot.filename(), 'root123.dat'); |
| const jscRoot = commitSet.rootForRepository(ownedJSC); |
| assert(jscRoot instanceof UploadedFile); |
| assert.strictEqual(jscRoot.filename(), 'root123.dat'); |
| assert.deepEqual(commitSet.allRootFiles(), [webkitRoot, jscRoot]); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), null); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '192736'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.rootForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.ownerRevisionForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.ownerRevisionForRepository(ownedJSC), otherCommitSet.revisionForRepository(webkit)); |
| assert.deepEqual(otherCommitSet.allRootFiles(), []); |
| |
| MockRemoteAPI.reset(); |
| syncPromise = triggerable.initSyncers().then(() => triggerable.syncOnce()); |
| assertAndResolveRequest(requests[0], 'GET', MockData.buildbotBuildersURL(), MockData.mockBuildbotBuilders()); |
| MockRemoteAPI.reset(); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 3); |
| assertAndResolveRequest(requests[0], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[1], 'GET', MockData.pendingBuildsUrl('some builder'), {}); |
| assertAndResolveRequest(requests[2], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 6); |
| assertAndResolveRequest(requests[3], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[4], 'GET', MockData.recentBuildsUrl('some builder', 2), |
| MockData.finishedBuild({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1})); |
| assertAndResolveRequest(requests[5], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 7); |
| assertAndResolveRequest(requests[6], 'POST', '/api/v2/forceschedulers/force-ab-builds', 'OK'); |
| assert.deepEqual(requests[6].data, {'id': '2', 'jsonrpc': '2.0', 'method': 'force', 'params': |
| {'wk': '192736', 'build-request-id': '2', 'forcescheduler': 'force-ab-builds', 'owned-commits': `{"WebKit":[{"revision":"owned-jsc-9191","repository":"JavaScriptCore","ownerRevision":"192736"}]}`}}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 10); |
| assertAndResolveRequest(requests[7], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[8], 'GET', MockData.pendingBuildsUrl('some builder'), {}); |
| assertAndResolveRequest(requests[9], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 13); |
| assertAndResolveRequest(requests[10], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[11], 'GET', MockData.recentBuildsUrl('some builder', 2), { |
| 'builds': [ |
| MockData.runningBuildData({builderId: MockData.builderIDForName('some builder'), buildRequestId: 2}), |
| MockData.finishedBuildData({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1})] |
| }); |
| assertAndResolveRequest(requests[12], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| return syncPromise; |
| }).then(() => { |
| return TestGroup.fetchForTask(taskId, true); |
| }).then((testGroups) => { |
| assert.strictEqual(testGroups.length, 1); |
| const testGroup = testGroups[0]; |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| const ownedJSC = Repository.findById(MockData.ownedJSCRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Completed'); |
| assert.strictEqual(buildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.notEqual(buildRequest.buildId(), null); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(commitSet.patchForRepository(webkit), null); |
| assert.strictEqual(commitSet.ownerRevisionForRepository(webkit), null); |
| assert.strictEqual(commitSet.ownerRevisionForRepository(ownedJSC), commitSet.revisionForRepository(webkit)); |
| const webkitRoot = commitSet.rootForRepository(webkit); |
| assert(webkitRoot instanceof UploadedFile); |
| assert.strictEqual(webkitRoot.filename(), 'root123.dat'); |
| const jscRoot = commitSet.rootForRepository(ownedJSC); |
| assert(jscRoot instanceof UploadedFile); |
| assert.strictEqual(jscRoot.filename(), 'root123.dat'); |
| assert.deepEqual(commitSet.allRootFiles(), [webkitRoot, jscRoot]); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Running'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '192736'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.rootForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.ownerRevisionForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.ownerRevisionForRepository(ownedJSC), otherCommitSet.revisionForRepository(webkit)); |
| assert.deepEqual(otherCommitSet.allRootFiles(), []); |
| |
| return uploadRoot(parseInt(otherBuildRequest.id()), 124).then(() => uploadRoot(parseInt(otherBuildRequest.id()), 124, [{ownerRepository: 'WebKit', ownedRepository: 'JavaScriptCore'}], '2017-05-10T02:54:09.666')); |
| }).then(() => { |
| return TestGroup.fetchForTask(taskId, true); |
| }).then((testGroups) => { |
| assert.strictEqual(testGroups.length, 1); |
| const testGroup = testGroups[0]; |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| const ownedJSC = Repository.findById(MockData.ownedJSCRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Completed'); |
| assert.strictEqual(buildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.notEqual(buildRequest.buildId(), null); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(commitSet.patchForRepository(webkit), null); |
| assert.strictEqual(commitSet.ownerRevisionForRepository(webkit), null); |
| assert.strictEqual(commitSet.ownerRevisionForRepository(ownedJSC), commitSet.revisionForRepository(webkit)); |
| const webkitRoot = commitSet.rootForRepository(webkit); |
| assert(webkitRoot instanceof UploadedFile); |
| assert.strictEqual(webkitRoot.filename(), 'root123.dat'); |
| const jscRoot = commitSet.rootForRepository(ownedJSC); |
| assert(jscRoot instanceof UploadedFile); |
| assert.strictEqual(jscRoot.filename(), 'root123.dat'); |
| assert.deepEqual(commitSet.allRootFiles(), [webkitRoot, jscRoot]); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Completed'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.notEqual(otherBuildRequest.buildId(), null); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '192736'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.ownerRevisionForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.ownerRevisionForRepository(ownedJSC), otherCommitSet.revisionForRepository(webkit)); |
| const otherWebkitRoot = otherCommitSet.rootForRepository(webkit); |
| assert(otherWebkitRoot instanceof UploadedFile); |
| assert.strictEqual(otherWebkitRoot.filename(), 'root124.dat'); |
| const otherJSCRoot = otherCommitSet.rootForRepository(ownedJSC); |
| assert(otherJSCRoot instanceof UploadedFile); |
| assert.strictEqual(otherJSCRoot.filename(), 'root124.dat'); |
| assert.deepEqual(otherCommitSet.allRootFiles(), [otherWebkitRoot, otherJSCRoot]); |
| }); |
| }); |
| |
| it('should not update a build request to "completed" until all roots needed in the commit set are uploaded', () => { |
| const requests = MockRemoteAPI.requests; |
| let triggerable; |
| let taskId = null; |
| let syncPromise; |
| return createTriggerable().then((newTriggerable) => { |
| triggerable = newTriggerable; |
| return createTestGroupWihOwnedCommit(); |
| }).then((testGroup) => { |
| taskId = testGroup.task().id(); |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| const ownedJSC = Repository.findById(MockData.ownedJSCRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(buildRequest.statusUrl(), null); |
| assert.strictEqual(buildRequest.buildId(), null); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(commitSet.patchForRepository(webkit), null); |
| assert.strictEqual(commitSet.rootForRepository(webkit), null); |
| assert.strictEqual(commitSet.ownerRevisionForRepository(webkit), null); |
| assert.strictEqual(commitSet.ownerRevisionForRepository(ownedJSC), commitSet.revisionForRepository(webkit)); |
| assert.deepEqual(commitSet.allRootFiles(), []); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), null); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '192736'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.rootForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.ownerRevisionForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.ownerRevisionForRepository(ownedJSC), otherCommitSet.revisionForRepository(webkit)); |
| assert.deepEqual(otherCommitSet.allRootFiles(), []); |
| |
| syncPromise = triggerable.initSyncers().then(() => triggerable.syncOnce()); |
| assertAndResolveRequest(requests[0], 'GET', MockData.buildbotBuildersURL(), MockData.mockBuildbotBuilders()); |
| MockRemoteAPI.reset(); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 3); |
| assertAndResolveRequest(requests[0], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[1], 'GET', MockData.pendingBuildsUrl('some builder'), {}); |
| assertAndResolveRequest(requests[2], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 6); |
| assertAndResolveRequest(requests[3], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[4], 'GET', MockData.recentBuildsUrl('some builder', 2), {}); |
| assertAndResolveRequest(requests[5], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 7); |
| assertAndResolveRequest(requests[6], 'POST', '/api/v2/forceschedulers/force-ab-builds', 'OK'); |
| assert.deepEqual(requests[6].data, {'id': '1', 'jsonrpc': '2.0', 'method': 'force', 'params': |
| {'wk': '191622', 'build-request-id': '1', 'forcescheduler': 'force-ab-builds', 'owned-commits': `{"WebKit":[{"revision":"owned-jsc-6161","repository":"JavaScriptCore","ownerRevision":"191622"}]}`}}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 10); |
| assertAndResolveRequest(requests[7], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[8], 'GET', MockData.pendingBuildsUrl('some builder'), |
| MockData.pendingBuild({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1})); |
| assertAndResolveRequest(requests[9], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 13); |
| assertAndResolveRequest(requests[10], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[11], 'GET', MockData.recentBuildsUrl('some builder', 2), |
| MockData.runningBuild({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1})); |
| assertAndResolveRequest(requests[12], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| return syncPromise; |
| }).then(() => { |
| return TestGroup.fetchForTask(taskId, true); |
| }).then((testGroups) => { |
| assert.strictEqual(testGroups.length, 1); |
| const testGroup = testGroups[0]; |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| const ownedJSC = Repository.findById(MockData.ownedJSCRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Running'); |
| assert.strictEqual(buildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.strictEqual(buildRequest.buildId(), null); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(commitSet.patchForRepository(webkit), null); |
| assert.strictEqual(commitSet.rootForRepository(webkit), null); |
| assert.strictEqual(commitSet.ownerRevisionForRepository(webkit), null); |
| assert.strictEqual(commitSet.ownerRevisionForRepository(ownedJSC), commitSet.revisionForRepository(webkit)); |
| assert.deepEqual(commitSet.allRootFiles(), []); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), null); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '192736'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.rootForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.ownerRevisionForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.ownerRevisionForRepository(ownedJSC), otherCommitSet.revisionForRepository(webkit)); |
| assert.deepEqual(otherCommitSet.allRootFiles(), []); |
| |
| return uploadRoot(parseInt(buildRequest.id()), 123); |
| }).then(() => { |
| return TestGroup.fetchForTask(taskId, true); |
| }).then((testGroups) => { |
| assert.strictEqual(testGroups.length, 1); |
| const testGroup = testGroups[0]; |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| const ownedJSC = Repository.findById(MockData.ownedJSCRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Running'); |
| assert.strictEqual(buildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.strictEqual(buildRequest.buildId(), null); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(commitSet.patchForRepository(webkit), null); |
| assert.strictEqual(commitSet.ownerRevisionForRepository(webkit), null); |
| assert.strictEqual(commitSet.ownerRevisionForRepository(ownedJSC), commitSet.revisionForRepository(webkit)); |
| const webkitRoot = commitSet.rootForRepository(webkit); |
| assert(webkitRoot instanceof UploadedFile); |
| assert.strictEqual(webkitRoot.filename(), 'root123.dat'); |
| assert.deepEqual(commitSet.allRootFiles(), [webkitRoot]); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), null); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '192736'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.rootForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.ownerRevisionForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.ownerRevisionForRepository(ownedJSC), otherCommitSet.revisionForRepository(webkit)); |
| assert.deepEqual(otherCommitSet.allRootFiles(), []); |
| return uploadRoot(parseInt(buildRequest.id()), 123, [{ownerRepository: 'WebKit', ownedRepository: 'JavaScriptCore'}], '2017-05-10T02:54:09.666'); |
| }).then(() => { |
| return TestGroup.fetchForTask(taskId, true); |
| }).then((testGroups) => { |
| assert.strictEqual(testGroups.length, 1); |
| const testGroup = testGroups[0]; |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| const ownedJSC = Repository.findById(MockData.ownedJSCRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Completed'); |
| assert.strictEqual(buildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.notEqual(buildRequest.buildId(), null); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(commitSet.patchForRepository(webkit), null); |
| assert.strictEqual(commitSet.ownerRevisionForRepository(webkit), null); |
| assert.strictEqual(commitSet.ownerRevisionForRepository(ownedJSC), commitSet.revisionForRepository(webkit)); |
| const webkitRoot = commitSet.rootForRepository(webkit); |
| assert(webkitRoot instanceof UploadedFile); |
| assert.strictEqual(webkitRoot.filename(), 'root123.dat'); |
| const jscRoot = commitSet.rootForRepository((ownedJSC)); |
| assert(jscRoot instanceof UploadedFile); |
| assert.strictEqual(jscRoot.filename(), 'root123.dat'); |
| assert.deepEqual(commitSet.allRootFiles(), [webkitRoot, jscRoot]); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Waiting'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), null); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '192736'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.rootForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.ownerRevisionForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.ownerRevisionForRepository(ownedJSC), otherCommitSet.revisionForRepository(webkit)); |
| assert.deepEqual(otherCommitSet.allRootFiles(), []); |
| |
| MockRemoteAPI.reset(); |
| syncPromise = triggerable.initSyncers().then(() => triggerable.syncOnce()); |
| assertAndResolveRequest(requests[0], 'GET', MockData.buildbotBuildersURL(), MockData.mockBuildbotBuilders()); |
| MockRemoteAPI.reset(); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 3); |
| assertAndResolveRequest(requests[0], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[1], 'GET', MockData.pendingBuildsUrl('some builder'), {}); |
| assertAndResolveRequest(requests[2], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 6); |
| assertAndResolveRequest(requests[3], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[4], 'GET', MockData.recentBuildsUrl('some builder', 2), |
| MockData.finishedBuild({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1})); |
| assertAndResolveRequest(requests[5], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 7); |
| assertAndResolveRequest(requests[6], 'POST', '/api/v2/forceschedulers/force-ab-builds', 'OK'); |
| assert.deepEqual(requests[6].data, {'id': '2', 'jsonrpc': '2.0', 'method': 'force', 'params': |
| {'wk': '192736', 'build-request-id': '2', 'forcescheduler': 'force-ab-builds', 'owned-commits': `{"WebKit":[{"revision":"owned-jsc-9191","repository":"JavaScriptCore","ownerRevision":"192736"}]}`}}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 10); |
| assertAndResolveRequest(requests[7], 'GET', MockData.pendingBuildsUrl('some tester'), {}); |
| assertAndResolveRequest(requests[8], 'GET', MockData.pendingBuildsUrl('some builder'), {}); |
| assertAndResolveRequest(requests[9], 'GET', MockData.pendingBuildsUrl('other builder'), {}); |
| return MockRemoteAPI.waitForRequest(); |
| }).then(() => { |
| assert.strictEqual(requests.length, 13); |
| assertAndResolveRequest(requests[10], 'GET', MockData.recentBuildsUrl('some tester', 2), {}); |
| assertAndResolveRequest(requests[11], 'GET', MockData.recentBuildsUrl('some builder', 2), { |
| 'builds': [ |
| MockData.runningBuildData({builderId: MockData.builderIDForName('some builder'), buildRequestId: 2}), |
| MockData.finishedBuildData({builderId: MockData.builderIDForName('some builder'), buildRequestId: 1})] |
| }); |
| assertAndResolveRequest(requests[12], 'GET', MockData.recentBuildsUrl('other builder', 2), {}); |
| return syncPromise; |
| }).then(() => { |
| return TestGroup.fetchForTask(taskId, true); |
| }).then((testGroups) => { |
| assert.strictEqual(testGroups.length, 1); |
| const testGroup = testGroups[0]; |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| const ownedJSC = Repository.findById(MockData.ownedJSCRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Completed'); |
| assert.strictEqual(buildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.notEqual(buildRequest.buildId(), null); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(commitSet.patchForRepository(webkit), null); |
| assert.strictEqual(commitSet.ownerRevisionForRepository(webkit), null); |
| assert.strictEqual(commitSet.ownerRevisionForRepository(ownedJSC), commitSet.revisionForRepository(webkit)); |
| const webkitRoot = commitSet.rootForRepository(webkit); |
| assert(webkitRoot instanceof UploadedFile); |
| assert.strictEqual(webkitRoot.filename(), 'root123.dat'); |
| const jscRoot = commitSet.rootForRepository(ownedJSC); |
| assert(jscRoot instanceof UploadedFile); |
| assert.strictEqual(jscRoot.filename(), 'root123.dat'); |
| assert.deepEqual(commitSet.allRootFiles(), [webkitRoot, jscRoot]); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Running'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '192736'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.rootForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.ownerRevisionForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.ownerRevisionForRepository(ownedJSC), otherCommitSet.revisionForRepository(webkit)); |
| assert.deepEqual(otherCommitSet.allRootFiles(), []); |
| |
| return uploadRoot(parseInt(otherBuildRequest.id()), 124); |
| }).then(() => { |
| return TestGroup.fetchForTask(taskId, true); |
| }).then((testGroups) => { |
| assert.strictEqual(testGroups.length, 1); |
| const testGroup = testGroups[0]; |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| const ownedJSC = Repository.findById(MockData.ownedJSCRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Completed'); |
| assert.strictEqual(buildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.notEqual(buildRequest.buildId(), null); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(commitSet.patchForRepository(webkit), null); |
| assert.strictEqual(commitSet.ownerRevisionForRepository(webkit), null); |
| assert.strictEqual(commitSet.ownerRevisionForRepository(ownedJSC), commitSet.revisionForRepository(webkit)); |
| const webkitRoot = commitSet.rootForRepository(webkit); |
| assert(webkitRoot instanceof UploadedFile); |
| assert.strictEqual(webkitRoot.filename(), 'root123.dat'); |
| const jscRoot = commitSet.rootForRepository(ownedJSC); |
| assert(jscRoot instanceof UploadedFile); |
| assert.strictEqual(jscRoot.filename(), 'root123.dat'); |
| assert.deepEqual(commitSet.allRootFiles(), [webkitRoot, jscRoot]); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Running'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.strictEqual(otherBuildRequest.buildId(), null); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '192736'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.ownerRevisionForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.ownerRevisionForRepository(ownedJSC), otherCommitSet.revisionForRepository(webkit)); |
| const otherWebkitRoot = otherCommitSet.rootForRepository(webkit); |
| assert(otherWebkitRoot instanceof UploadedFile); |
| assert.strictEqual(otherWebkitRoot.filename(), 'root124.dat'); |
| assert.deepEqual(otherCommitSet.allRootFiles(), [otherWebkitRoot]); |
| return uploadRoot(parseInt(otherBuildRequest.id()), 124, [{ownerRepository: 'WebKit', ownedRepository: 'JavaScriptCore'}], '2017-05-10T02:54:09.666'); |
| }).then(() => { |
| return TestGroup.fetchForTask(taskId, true); |
| }).then((testGroups) => { |
| assert.strictEqual(testGroups.length, 1); |
| const testGroup = testGroups[0]; |
| const webkit = Repository.findById(MockData.webkitRepositoryId()); |
| const ownedJSC = Repository.findById(MockData.ownedJSCRepositoryId()); |
| assert.strictEqual(testGroup.buildRequests().length, 6); |
| |
| const buildRequest = testGroup.buildRequests()[0]; |
| assert(buildRequest.isBuild()); |
| assert(!buildRequest.isTest()); |
| assert.strictEqual(buildRequest.statusLabel(), 'Completed'); |
| assert.strictEqual(buildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.notEqual(buildRequest.buildId(), null); |
| |
| const commitSet = buildRequest.commitSet(); |
| assert.strictEqual(commitSet.revisionForRepository(webkit), '191622'); |
| assert.strictEqual(commitSet.patchForRepository(webkit), null); |
| assert.strictEqual(commitSet.ownerRevisionForRepository(webkit), null); |
| assert.strictEqual(commitSet.ownerRevisionForRepository(ownedJSC), commitSet.revisionForRepository(webkit)); |
| const webkitRoot = commitSet.rootForRepository(webkit); |
| assert(webkitRoot instanceof UploadedFile); |
| assert.strictEqual(webkitRoot.filename(), 'root123.dat'); |
| const jscRoot = commitSet.rootForRepository(ownedJSC); |
| assert(jscRoot instanceof UploadedFile); |
| assert.strictEqual(jscRoot.filename(), 'root123.dat'); |
| assert.deepEqual(commitSet.allRootFiles(), [webkitRoot, jscRoot]); |
| |
| const otherBuildRequest = testGroup.buildRequests()[1]; |
| assert(otherBuildRequest.isBuild()); |
| assert(!otherBuildRequest.isTest()); |
| assert.strictEqual(otherBuildRequest.statusLabel(), 'Completed'); |
| assert.strictEqual(otherBuildRequest.statusUrl(), MockData.statusUrl('some builder', 124)); |
| assert.notEqual(otherBuildRequest.buildId(), null); |
| |
| const otherCommitSet = otherBuildRequest.commitSet(); |
| assert.strictEqual(otherCommitSet.revisionForRepository(webkit), '192736'); |
| assert.strictEqual(otherCommitSet.patchForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.ownerRevisionForRepository(webkit), null); |
| assert.strictEqual(otherCommitSet.ownerRevisionForRepository(ownedJSC), otherCommitSet.revisionForRepository(webkit)); |
| const otherWebkitRoot = otherCommitSet.rootForRepository(webkit); |
| assert(otherWebkitRoot instanceof UploadedFile); |
| assert.strictEqual(otherWebkitRoot.filename(), 'root124.dat'); |
| const otherJSCRoot = otherCommitSet.rootForRepository(ownedJSC); |
| assert(otherJSCRoot instanceof UploadedFile); |
| assert.strictEqual(otherJSCRoot.filename(), 'root124.dat'); |
| assert.deepEqual(otherCommitSet.allRootFiles(), [otherWebkitRoot, otherJSCRoot]); |
| }); |
| }); |
| }); |
