1492 lines
85 KiB
JavaScript
1492 lines
85 KiB
JavaScript
'use strict';
|
|
|
|
const assert = require('assert');
|
|
|
|
const MockData = require('./resources/mock-data.js');
|
|
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 assertThrows = require('./resources/common-operations.js').assertThrows;
|
|
|
|
|
|
function createAnalysisTask(name, webkitRevisions = ["191622", "191623"])
|
|
{
|
|
const reportWithRevision = [{
|
|
"buildTag": "124",
|
|
"buildTime": "2015-10-27T15:34:51",
|
|
"revisions": {
|
|
"WebKit": {
|
|
"revision": webkitRevisions[0],
|
|
"timestamp": '2015-10-27T11:36:56.878473Z',
|
|
},
|
|
"macOS": {
|
|
"revision": "15A284",
|
|
}
|
|
},
|
|
"builderName": "someBuilder",
|
|
"workerName": "someWorker",
|
|
"workerPassword": "somePassword",
|
|
"platform": "some platform",
|
|
"tests": {
|
|
"some test": {
|
|
"metrics": {
|
|
"Time": ["Arithmetic"],
|
|
},
|
|
"tests": {
|
|
"test1": {
|
|
"metrics": {"Time": { "current": [11] }},
|
|
}
|
|
}
|
|
},
|
|
}}];
|
|
|
|
const anotherReportWithRevision = [{
|
|
"buildTag": "125",
|
|
"buildTime": "2015-10-27T17:27:41",
|
|
"revisions": {
|
|
"WebKit": {
|
|
"revision": webkitRevisions[1],
|
|
"timestamp": '2015-10-27T16:38:10.768995Z',
|
|
},
|
|
"macOS": {
|
|
"revision": "15A284",
|
|
}
|
|
},
|
|
"builderName": "someBuilder",
|
|
"workerName": "someWorker",
|
|
"workerPassword": "somePassword",
|
|
"platform": "some platform",
|
|
"tests": {
|
|
"some test": {
|
|
"metrics": {
|
|
"Time": ["Arithmetic"],
|
|
},
|
|
"tests": {
|
|
"test1": {
|
|
"metrics": {"Time": { "current": [12] }},
|
|
}
|
|
}
|
|
},
|
|
}}];
|
|
|
|
const db = TestServer.database();
|
|
const remote = TestServer.remoteAPI();
|
|
return addWorkerForReport(reportWithRevision[0]).then(() => {
|
|
return remote.postJSON('/api/report/', reportWithRevision);
|
|
}).then(() => {
|
|
return remote.postJSON('/api/report/', anotherReportWithRevision);
|
|
}).then((result) => {
|
|
return Manifest.fetch();
|
|
}).then(() => {
|
|
const test = Test.findByPath(['some test', 'test1']);
|
|
const platform = Platform.findByName('some platform');
|
|
return db.selectFirstRow('test_configurations', {metric: test.metrics()[0].id(), platform: platform.id()});
|
|
}).then((configRow) => {
|
|
return db.selectRows('test_runs', {config: configRow['id']});
|
|
}).then((testRuns) => {
|
|
assert.strictEqual(testRuns.length, 2);
|
|
return PrivilegedAPI.sendRequest('create-analysis-task', {
|
|
name: name,
|
|
startRun: testRuns[0]['id'],
|
|
endRun: testRuns[1]['id'],
|
|
});
|
|
}).then((content) => content['taskId']);
|
|
}
|
|
|
|
function addTriggerableAndCreateTask(name, webkitRevisions)
|
|
{
|
|
const report = {
|
|
'workerName': 'anotherWorker',
|
|
'workerPassword': 'anotherPassword',
|
|
'triggerable': 'build-webkit',
|
|
'configurations': [
|
|
{test: MockData.someTestId(), platform: MockData.somePlatformId()},
|
|
{test: MockData.someTestId(), platform: MockData.otherPlatformId()},
|
|
],
|
|
'repositoryGroups': [
|
|
{name: 'os-only', acceptsRoot: true, repositories: [
|
|
{repository: MockData.macosRepositoryId(), acceptsPatch: false},
|
|
]},
|
|
{name: 'webkit-only', acceptsRoot: true, repositories: [
|
|
{repository: MockData.webkitRepositoryId(), acceptsPatch: true},
|
|
]},
|
|
{name: 'system-and-webkit', acceptsRoot: true, repositories: [
|
|
{repository: MockData.macosRepositoryId(), acceptsPatch: false},
|
|
{repository: MockData.webkitRepositoryId(), acceptsPatch: true}
|
|
]},
|
|
{name: 'system-webkit-sjc', acceptsRoot: true, repositories: [
|
|
{repository: MockData.macosRepositoryId(), acceptsPatch: false},
|
|
{repository: MockData.jscRepositoryId(), acceptsPatch: false},
|
|
{repository: MockData.webkitRepositoryId(), acceptsPatch: true}
|
|
]},
|
|
]
|
|
};
|
|
return MockData.addMockData(TestServer.database()).then(() => {
|
|
return addWorkerForReport(report);
|
|
}).then(() => {
|
|
return TestServer.remoteAPI().postJSON('/api/update-triggerable/', report);
|
|
}).then(() => {
|
|
return createAnalysisTask(name, webkitRevisions);
|
|
});
|
|
}
|
|
|
|
describe('/privileged-api/create-test-group', function () {
|
|
prepareServerTest(this);
|
|
TemporaryFile.inject();
|
|
|
|
it('should return "InvalidName" on an empty request', () => {
|
|
return PrivilegedAPI.sendRequest('create-test-group', {}).then((content) => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'InvalidName');
|
|
});
|
|
});
|
|
|
|
it('should return "InvalidTask" when task is not specified', () => {
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', commitSets: [[1]]}).then((content) => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'InvalidTask');
|
|
});
|
|
});
|
|
|
|
it('should return "InvalidTask" when task is not a valid integer', () => {
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: 'foo', commitSets: [[1]]}).then((content) => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'InvalidTask');
|
|
});
|
|
});
|
|
|
|
it('should return "InvalidCommitSets" when commit sets are not specified', () => {
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: 1, repetitionCount: 1}).then((content) => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'InvalidCommitSets');
|
|
});
|
|
});
|
|
|
|
it('should return "InvalidCommitSets" when commit sets is empty', () => {
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: 1, repetitionCount: 1, commitSets: {}}).then((content) => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'InvalidCommitSets');
|
|
});
|
|
});
|
|
|
|
it('should return "InvalidTask" when there is no matching task', () => {
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: 1, repetitionCount: 1, commitSets: {'WebKit': []}}).then((content) => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'InvalidTask');
|
|
});
|
|
});
|
|
|
|
it('should return "InvalidRepetitionCount" when repetitionCount is not a valid integer', () => {
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: 1, repetitionCount: 'foo', commitSets: {'WebKit': []}}).then((content) => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'InvalidRepetitionCount');
|
|
});
|
|
});
|
|
|
|
it('should return "InvalidRepetitionCount" when repetitionCount is a negative integer', () => {
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: 1, repetitionCount: -5, commitSets: {'WebKit': []}}).then((content) => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'InvalidRepetitionCount');
|
|
});
|
|
});
|
|
|
|
it('should return "InvalidTask" when there is no matching task', () => {
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: 1, commitSets: {'WebKit': []}}).then((content) => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'InvalidTask');
|
|
});
|
|
});
|
|
|
|
it('should return "TriggerableNotFoundForTask" when there is no matching triggerable', () => {
|
|
return createAnalysisTask('some task').then((taskId) => {
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, commitSets: {'WebKit': []}}).then((content) => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'TriggerableNotFoundForTask');
|
|
});
|
|
});
|
|
});
|
|
|
|
it('should return "InvalidCommitSets" when each repository specifies zero revisions', () => {
|
|
return addTriggerableAndCreateTask('some task').then((taskId) => {
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, commitSets: {'WebKit': []}}).then((content) => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'InvalidCommitSets');
|
|
});
|
|
});
|
|
});
|
|
|
|
it('should return "InvalidRevisionSets" when a revision set is empty', () => {
|
|
return addTriggerableAndCreateTask('some task').then((taskId) => {
|
|
const webkit = Repository.all().find((repository) => repository.name() == 'WebKit');
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, revisionSets: [{[webkit.id()]: {revision: '191622'}}, {}]}).then((content) => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'InvalidRevisionSets');
|
|
});
|
|
});
|
|
});
|
|
|
|
it('should return "InvalidRevisionSets" when the number of revision sets is less than two', () => {
|
|
return addTriggerableAndCreateTask('some task').then((taskId) => {
|
|
const webkit = Repository.all().find((repository) => repository.name() == 'WebKit');
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, revisionSets: [{[webkit.id()]: {revision: '191622'}}]}).then((content) => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'InvalidRevisionSets');
|
|
});
|
|
});
|
|
});
|
|
|
|
it('should return "RepositoryNotFound" when commit sets contains an invalid repository', () => {
|
|
return addTriggerableAndCreateTask('some task').then((taskId) => {
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, commitSets: {'Foo': []}}).then((content) => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'RepositoryNotFound');
|
|
});
|
|
});
|
|
});
|
|
|
|
it('should return "RevisionNotFound" when commit sets contains an invalid revision', () => {
|
|
return addTriggerableAndCreateTask('some task').then((taskId) => {
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, commitSets: {'WebKit': ['1']}}).then((content) => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'RevisionNotFound');
|
|
});
|
|
});
|
|
});
|
|
|
|
it('should return "RevisionNotFound" when revision sets contains an invalid revision', () => {
|
|
return addTriggerableAndCreateTask('some task').then((taskId) => {
|
|
const webkit = Repository.all().find((repository) => repository.name() == 'WebKit');
|
|
const revisionSets = [{[webkit.id()]: {revision: '191622'}}, {[webkit.id()]: {revision: '1a'}}];
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, revisionSets}).then((content) => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'RevisionNotFound');
|
|
});
|
|
});
|
|
});
|
|
|
|
it('should return "AmbiguousRevision" when there are multiple commits that match the specified revision string', () => {
|
|
return addTriggerableAndCreateTask('some task', ['2ceda45d3cd63cde58d0dbf5767714e03d902e43', '2c71a8ddc1f661663ccfd1a29c633ba57e879533']).then((taskId) => {
|
|
const webkit = Repository.all().find((repository) => repository.name() == 'WebKit');
|
|
const revisionSets = [{[webkit.id()]: {revision: '2ceda'}}, {[webkit.id()]: {revision: '2c'}}];
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, revisionSets}).then((content) => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'AmbiguousRevision');
|
|
});
|
|
});
|
|
});
|
|
|
|
it('should return "RevisionNotFound" when the end of a Git hash is specified', () => {
|
|
return addTriggerableAndCreateTask('some task', ['2ceda45d3cd63cde58d0dbf5767714e03d902e43', '5471a8ddc1f661663ccfd1a29c633ba57e879533']).then((taskId) => {
|
|
const webkit = Repository.all().find((repository) => repository.name() == 'WebKit');
|
|
const revisionSets = [{[webkit.id()]: {revision: '2ceda45d3cd63cde58d0dbf5767714e03d902e43'}}, {[webkit.id()]: {revision: '57e879533'}}];
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, revisionSets}).then((content) => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'RevisionNotFound');
|
|
});
|
|
});
|
|
});
|
|
|
|
it('should return "InvalidUploadedFile" when revision sets contains an invalid file ID', () => {
|
|
return addTriggerableAndCreateTask('some task').then((taskId) => {
|
|
const webkit = Repository.all().find((repository) => repository.name() == 'WebKit');
|
|
const revisionSets = [{[webkit.id()]: {revision: '191622'}, 'customRoots': ['1']}, {[webkit.id()]: {revision: '1'}}];
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, revisionSets}).then((content) => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'InvalidUploadedFile');
|
|
});
|
|
});
|
|
});
|
|
|
|
it('should return "InvalidRepository" when a revision set uses a repository name instead of a repository id', () => {
|
|
return addTriggerableAndCreateTask('some task').then((taskId) => {
|
|
const revisionSets = [{'WebKit': {revision: '191622'}}, {}];
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, revisionSets}).then((content) => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'InvalidRepository');
|
|
});
|
|
});
|
|
});
|
|
|
|
it('should return "InvalidCommitSets" when commit sets contains an inconsistent number of revisions', () => {
|
|
return addTriggerableAndCreateTask('some task').then((taskId) => {
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, commitSets: {'WebKit': ['191622', '191623'], 'macOS': ['15A284']}}).then((content) => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'InvalidCommitSets');
|
|
});
|
|
});
|
|
});
|
|
|
|
it('should return "DuplicateTestGroupName" when there is already a test group of the same name', () => {
|
|
return addTriggerableAndCreateTask('some task').then((taskId) => {
|
|
const commitSets = {'WebKit': ['191622', '191623']};
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, commitSets}).then((content) => {
|
|
assert(content['testGroupId']);
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, commitSets});
|
|
}).then(() => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'DuplicateTestGroupName');
|
|
});
|
|
});
|
|
});
|
|
|
|
it('should return "InvalidOwnerRevision" when commit ownership is not valid', () => {
|
|
let taskId;
|
|
return addTriggerableAndCreateTask('some task').then((id) => taskId = id).then(() => {
|
|
const webkit = Repository.all().filter((repository) => repository.name() == 'WebKit')[0];
|
|
const macos = Repository.all().filter((repository) => repository.name() == 'macOS')[0];
|
|
const ownedJSC = Repository.all().filter((repository) => repository.name() == 'JavaScriptCore' && repository.ownerId())[0];
|
|
const revisionSets = [{[webkit.id()]: {revision: '191622'}, [macos.id()]: {revision: '15A284'}, [ownedJSC.id()]: {revision: 'owned-jsc-6161', ownerRevision: '191621'}},
|
|
{[webkit.id()]: {revision: '191622'}, [macos.id()]: {revision: '15A284'}, [ownedJSC.id()]: {revision: 'owned-jsc-9191', ownerRevision: '191622'}}];
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, repetitionCount: 2, revisionSets});
|
|
}).then(() => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'InvalidOwnerRevision');
|
|
});
|
|
});
|
|
|
|
it('should return "InvalidCommitOwnership" when commit ownership is not valid', () => {
|
|
let taskId;
|
|
return addTriggerableAndCreateTask('some task').then((id) => taskId = id).then(() => {
|
|
const webkit = Repository.all().filter((repository) => repository.name() == 'WebKit')[0];
|
|
const macos = Repository.all().filter((repository) => repository.name() == 'macOS')[0];
|
|
const ownedJSC = Repository.all().filter((repository) => repository.name() == 'JavaScriptCore' && repository.ownerId())[0];
|
|
const revisionSets = [{[webkit.id()]: {revision: '191622'}, [macos.id()]: {revision: '15A284'}, [ownedJSC.id()]: {revision: 'owned-jsc-6161', ownerRevision: '191622'}},
|
|
{[webkit.id()]: {revision: '191622'}, [macos.id()]: {revision: '15A284'}, [ownedJSC.id()]: {revision: 'owned-jsc-9191', ownerRevision: '191622'}}];
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, repetitionCount: 2, revisionSets});
|
|
}).then(() => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'InvalidCommitOwnership');
|
|
});
|
|
});
|
|
|
|
it('should allow a commit set in which owner of a commit is not in the same set', () => {
|
|
let taskId;
|
|
let groupId;
|
|
return addTriggerableAndCreateTask('some task').then((id) => taskId = id).then(() => {
|
|
const webkit = Repository.all().filter((repository) => repository.name() == 'WebKit')[0];
|
|
const macos = Repository.all().filter((repository) => repository.name() == 'macOS')[0];
|
|
const ownedJSC = Repository.all().filter((repository) => repository.name() == 'JavaScriptCore' && repository.ownerId())[0];
|
|
const revisionSets = [{[webkit.id()]: {revision: '191622'}, [macos.id()]: {revision: '15A284'}, [ownedJSC.id()]: {revision: 'owned-jsc-6161', ownerRevision: '191622'}},
|
|
{[webkit.id()]: {revision: '191622'}, [macos.id()]: {revision: '15A284'}, [ownedJSC.id()]: {revision: 'owned-jsc-9191', ownerRevision: '192736'}}];
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, repetitionCount: 1, revisionSets});
|
|
}).then((content) => {
|
|
assert.strictEqual(content['status'], 'OK');
|
|
groupId = content['testGroupId'];
|
|
return TestGroup.fetchForTask(taskId, true);
|
|
}).then((testGroups) => {
|
|
assert.strictEqual(testGroups.length, 1);
|
|
const group = testGroups[0];
|
|
assert.strictEqual(group.id(), groupId);
|
|
assert.strictEqual(group.initialRepetitionCount(), 1);
|
|
assert.ok(!group.needsNotification());
|
|
const requests = group.buildRequests();
|
|
assert.strictEqual(requests.length, 4);
|
|
assert(requests[0].isBuild());
|
|
assert(!requests[0].isTest());
|
|
assert(requests[1].isBuild());
|
|
assert(!requests[1].isTest());
|
|
assert(!requests[2].isBuild());
|
|
assert(requests[2].isTest());
|
|
assert(!requests[3].isBuild());
|
|
assert(requests[3].isTest());
|
|
|
|
const macos = Repository.findById(MockData.macosRepositoryId());
|
|
const webkit = Repository.findById(MockData.webkitRepositoryId());
|
|
const ownedJSC = Repository.findById(MockData.ownedJSCRepositoryId());
|
|
const set0 = requests[0].commitSet();
|
|
const set1 = requests[1].commitSet();
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set0.repositories()), [ownedJSC, webkit, macos]);
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set1.repositories()), [ownedJSC, webkit, macos]);
|
|
assert.strictEqual(set0.revisionForRepository(macos), '15A284');
|
|
assert.strictEqual(set0.revisionForRepository(webkit), '191622');
|
|
assert.strictEqual(set0.revisionForRepository(ownedJSC), 'owned-jsc-6161');
|
|
assert.strictEqual(set1.revisionForRepository(macos), '15A284');
|
|
assert.strictEqual(set1.revisionForRepository(webkit), '191622');
|
|
assert.strictEqual(set1.revisionForRepository(ownedJSC), 'owned-jsc-9191');
|
|
});
|
|
});
|
|
|
|
it('should allow a commit set in which repository of owner commit is not specified at all', () => {
|
|
let taskId;
|
|
let groupId;
|
|
return addTriggerableAndCreateTask('some task').then((id) => taskId = id).then(() => {
|
|
const webkit = Repository.all().filter((repository) => repository.name() == 'WebKit')[0];
|
|
const macos = Repository.all().filter((repository) => repository.name() == 'macOS')[0];
|
|
const jsc = Repository.all().filter((repository) => repository.name() == 'JavaScriptCore' && repository.ownerId())[0];
|
|
const revisionSets = [{[webkit.id()]: {revision: '191622'}, [macos.id()]: {revision: '15A284'}, [jsc.id()]: {revision: 'owned-jsc-6161', ownerRevision: '191622'}},
|
|
{[macos.id()]: {revision: '15A284'}, [jsc.id()]: {revision: 'owned-jsc-9191', ownerRevision: '192736'}}];
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, repetitionCount: 1, revisionSets});
|
|
}).then((content) => {
|
|
assert.strictEqual(content['status'], 'OK');
|
|
groupId = content['testGroupId'];
|
|
return TestGroup.fetchForTask(taskId, true);
|
|
}).then((testGroups) => {
|
|
assert.strictEqual(testGroups.length, 1);
|
|
const group = testGroups[0];
|
|
assert.strictEqual(group.id(), groupId);
|
|
assert.strictEqual(group.initialRepetitionCount(), 1);
|
|
assert.ok(!group.needsNotification());
|
|
const requests = group.buildRequests();
|
|
assert.strictEqual(requests.length, 4);
|
|
assert(requests[0].isBuild());
|
|
assert(!requests[0].isTest());
|
|
assert(requests[1].isBuild());
|
|
assert(!requests[1].isTest());
|
|
assert(!requests[2].isBuild());
|
|
assert(requests[2].isTest());
|
|
assert(!requests[3].isBuild());
|
|
assert(requests[3].isTest());
|
|
|
|
const macos = Repository.findById(MockData.macosRepositoryId());
|
|
const webkit = Repository.findById(MockData.webkitRepositoryId());
|
|
const ownedJSC = Repository.findById(MockData.ownedJSCRepositoryId());
|
|
const set0 = requests[0].commitSet();
|
|
const set1 = requests[1].commitSet();
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set0.repositories()), [ownedJSC, webkit, macos]);
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set1.repositories()), [ownedJSC, macos]);
|
|
assert.strictEqual(set0.revisionForRepository(macos), '15A284');
|
|
assert.strictEqual(set0.revisionForRepository(webkit), '191622');
|
|
assert.strictEqual(set0.revisionForRepository(ownedJSC), 'owned-jsc-6161');
|
|
assert.strictEqual(set1.revisionForRepository(macos), '15A284');
|
|
assert.strictEqual(set1.revisionForRepository(ownedJSC), 'owned-jsc-9191');
|
|
});
|
|
});
|
|
|
|
it('should create a test group from commitSets with the repetition count of one when repetitionCount is omitted', () => {
|
|
return addTriggerableAndCreateTask('some task').then((taskId) => {
|
|
let insertedGroupId;
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, commitSets: {'macOS': ['15A284', '15A284'], 'WebKit': ['191622', '191623']}}).then((content) => {
|
|
insertedGroupId = content['testGroupId'];
|
|
return TestGroup.fetchForTask(taskId, true);
|
|
}).then((testGroups) => {
|
|
assert.strictEqual(testGroups.length, 1);
|
|
const group = testGroups[0];
|
|
assert.strictEqual(group.id(), insertedGroupId);
|
|
assert.strictEqual(group.initialRepetitionCount(), 1);
|
|
assert.ok(!group.needsNotification());
|
|
const requests = group.buildRequests();
|
|
assert.strictEqual(requests.length, 2);
|
|
|
|
const macos = Repository.findById(MockData.macosRepositoryId());
|
|
const webkit = Repository.findById(MockData.webkitRepositoryId());
|
|
const set0 = requests[0].commitSet();
|
|
const set1 = requests[1].commitSet();
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set0.repositories()), [webkit, macos]);
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set1.repositories()), [webkit, macos]);
|
|
assert.strictEqual(set0.revisionForRepository(macos), '15A284');
|
|
assert.strictEqual(set0.revisionForRepository(webkit), '191622');
|
|
assert.strictEqual(set1.revisionForRepository(macos), '15A284');
|
|
assert.strictEqual(set1.revisionForRepository(webkit), '191623');
|
|
|
|
const repositoryGroup = requests[0].repositoryGroup();
|
|
assert.strictEqual(repositoryGroup.name(), 'system-and-webkit');
|
|
assert.strictEqual(requests[1].repositoryGroup(), repositoryGroup);
|
|
assert(repositoryGroup.accepts(set0));
|
|
assert(repositoryGroup.accepts(set1));
|
|
});
|
|
});
|
|
});
|
|
|
|
it('should create a test group from revisionSets with the repetition count of one when repetitionCount is omitted', () => {
|
|
let webkit;
|
|
return addTriggerableAndCreateTask('some task').then((taskId) => {
|
|
const webkit = Repository.findById(MockData.webkitRepositoryId());
|
|
const revisionSets = [{[webkit.id()]: {revision: '191622'}}, {[webkit.id()]: {revision: '191623'}}];
|
|
const params = {name: 'test', task: taskId, revisionSets};
|
|
let insertedGroupId;
|
|
return PrivilegedAPI.sendRequest('create-test-group', params).then((content) => {
|
|
insertedGroupId = content['testGroupId'];
|
|
return TestGroup.fetchForTask(taskId, true);
|
|
}).then((testGroups) => {
|
|
assert.strictEqual(testGroups.length, 1);
|
|
const group = testGroups[0];
|
|
assert.strictEqual(group.id(), insertedGroupId);
|
|
assert.strictEqual(group.initialRepetitionCount(), 1);
|
|
assert.ok(!group.needsNotification());
|
|
const requests = group.buildRequests();
|
|
assert.strictEqual(requests.length, 2);
|
|
|
|
const set0 = requests[0].commitSet();
|
|
const set1 = requests[1].commitSet();
|
|
assert.deepStrictEqual(set0.repositories(), [webkit]);
|
|
assert.deepStrictEqual(set1.repositories(), [webkit]);
|
|
assert.strictEqual(set0.revisionForRepository(webkit), '191622');
|
|
assert.strictEqual(set1.revisionForRepository(webkit), '191623');
|
|
|
|
const repositoryGroup = requests[0].repositoryGroup();
|
|
assert.strictEqual(repositoryGroup.name(), 'webkit-only');
|
|
assert.strictEqual(repositoryGroup, requests[1].repositoryGroup());
|
|
assert(repositoryGroup.accepts(set0));
|
|
assert(repositoryGroup.accepts(set1));
|
|
});
|
|
});
|
|
});
|
|
|
|
it('should create a test group with the repetition count of two with two repositories', () => {
|
|
return addTriggerableAndCreateTask('some task').then((taskId) => {
|
|
let insertedGroupId;
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, repetitionCount: 2,
|
|
commitSets: {'WebKit': ['191622', '191623'], 'macOS': ['15A284', '15A284']}}).then((content) => {
|
|
insertedGroupId = content['testGroupId'];
|
|
return TestGroup.fetchForTask(taskId, true);
|
|
}).then((testGroups) => {
|
|
assert.strictEqual(testGroups.length, 1);
|
|
const group = testGroups[0];
|
|
assert.strictEqual(group.id(), insertedGroupId);
|
|
assert.strictEqual(group.initialRepetitionCount(), 2);
|
|
assert.ok(!group.needsNotification());
|
|
const requests = group.buildRequests();
|
|
assert.strictEqual(requests.length, 4);
|
|
const webkit = Repository.all().filter((repository) => repository.name() == 'WebKit')[0];
|
|
const macos = Repository.all().filter((repository) => repository.name() == 'macOS')[0];
|
|
|
|
const set0 = requests[0].commitSet();
|
|
const set1 = requests[1].commitSet();
|
|
assert.strictEqual(requests[2].commitSet(), set0);
|
|
assert.strictEqual(requests[3].commitSet(), set1);
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set0.repositories()), [webkit, macos]);
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set1.repositories()), [webkit, macos]);
|
|
assert.strictEqual(set0.revisionForRepository(webkit), '191622');
|
|
assert.strictEqual(set0.revisionForRepository(macos), '15A284');
|
|
assert.strictEqual(set1.revisionForRepository(webkit), '191623');
|
|
assert.strictEqual(set1.revisionForRepository(macos), '15A284');
|
|
assert.strictEqual(set0.commitForRepository(macos), set1.commitForRepository(macos));
|
|
|
|
const repositoryGroup = requests[0].repositoryGroup();
|
|
assert.strictEqual(repositoryGroup.name(), 'system-and-webkit');
|
|
assert.strictEqual(requests[1].repositoryGroup(), repositoryGroup);
|
|
assert.strictEqual(requests[2].repositoryGroup(), repositoryGroup);
|
|
assert.strictEqual(requests[3].repositoryGroup(), repositoryGroup);
|
|
assert(repositoryGroup.accepts(set0));
|
|
assert(repositoryGroup.accepts(set1));
|
|
});
|
|
});
|
|
});
|
|
|
|
it('should create a test group using Git partial hashes', () => {
|
|
let webkit;
|
|
let macos;
|
|
return addTriggerableAndCreateTask('some task', ['2ceda45d3cd63cde58d0dbf5767714e03d902e43', '5471a8ddc1f661663ccfd1a29c633ba57e879533']).then((taskId) => {
|
|
webkit = Repository.findById(MockData.webkitRepositoryId());
|
|
macos = Repository.findById(MockData.macosRepositoryId());
|
|
const revisionSets = [{[macos.id()]: {revision: '15A284'}, [webkit.id()]: {revision: '2ceda'}},
|
|
{[macos.id()]: {revision: '15A284'}, [webkit.id()]: {revision: '5471a'}}];
|
|
const params = {name: 'test', task: taskId, repetitionCount: 2, revisionSets};
|
|
let insertedGroupId;
|
|
return PrivilegedAPI.sendRequest('create-test-group', params).then((content) => {
|
|
insertedGroupId = content['testGroupId'];
|
|
return TestGroup.fetchForTask(taskId, true);
|
|
}).then((testGroups) => {
|
|
assert.strictEqual(testGroups.length, 1);
|
|
const group = testGroups[0];
|
|
assert.strictEqual(group.id(), insertedGroupId);
|
|
assert.strictEqual(group.initialRepetitionCount(), 2);
|
|
assert.ok(!group.needsNotification());
|
|
const requests = group.buildRequests();
|
|
assert.strictEqual(requests.length, 4);
|
|
|
|
const set0 = requests[0].commitSet();
|
|
const set1 = requests[1].commitSet();
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set0.repositories()), [webkit, macos]);
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set1.repositories()), [webkit, macos]);
|
|
assert.strictEqual(set0.revisionForRepository(webkit), '2ceda45d3cd63cde58d0dbf5767714e03d902e43');
|
|
assert.strictEqual(set0.revisionForRepository(macos), '15A284');
|
|
assert.strictEqual(set1.revisionForRepository(webkit), '5471a8ddc1f661663ccfd1a29c633ba57e879533');
|
|
assert.strictEqual(set1.revisionForRepository(macos), '15A284');
|
|
|
|
const repositoryGroup0 = requests[0].repositoryGroup();
|
|
assert.strictEqual(repositoryGroup0.name(), 'system-and-webkit');
|
|
assert.strictEqual(repositoryGroup0, requests[2].repositoryGroup());
|
|
const repositoryGroup1 = requests[1].repositoryGroup();
|
|
assert.strictEqual(repositoryGroup1, repositoryGroup0);
|
|
assert(repositoryGroup0.accepts(set0));
|
|
assert(repositoryGroup0.accepts(set1));
|
|
});
|
|
});
|
|
});
|
|
|
|
it('should create a test group using different repository groups if needed', () => {
|
|
let webkit;
|
|
let macos;
|
|
return addTriggerableAndCreateTask('some task').then((taskId) => {
|
|
webkit = Repository.findById(MockData.webkitRepositoryId());
|
|
macos = Repository.findById(MockData.macosRepositoryId());
|
|
const revisionSets = [{[macos.id()]: {revision: '15A284'}, [webkit.id()]: {revision: '191622'}},
|
|
{[webkit.id()]: {revision: '191623'}}];
|
|
const params = {name: 'test', task: taskId, repetitionCount: 2, revisionSets};
|
|
let insertedGroupId;
|
|
return PrivilegedAPI.sendRequest('create-test-group', params).then((content) => {
|
|
insertedGroupId = content['testGroupId'];
|
|
return TestGroup.fetchForTask(taskId, true);
|
|
}).then((testGroups) => {
|
|
assert.strictEqual(testGroups.length, 1);
|
|
const group = testGroups[0];
|
|
assert.strictEqual(group.id(), insertedGroupId);
|
|
assert.strictEqual(group.initialRepetitionCount(), 2);
|
|
assert.ok(!group.needsNotification());
|
|
const requests = group.buildRequests();
|
|
assert.strictEqual(requests.length, 4);
|
|
|
|
const set0 = requests[0].commitSet();
|
|
const set1 = requests[1].commitSet();
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set0.repositories()), [webkit, macos]);
|
|
assert.deepStrictEqual(set1.repositories(), [webkit]);
|
|
assert.strictEqual(set0.revisionForRepository(webkit), '191622');
|
|
assert.strictEqual(set0.revisionForRepository(macos), '15A284');
|
|
assert.strictEqual(set1.revisionForRepository(webkit), '191623');
|
|
assert.strictEqual(set1.revisionForRepository(macos), null);
|
|
|
|
const repositoryGroup0 = requests[0].repositoryGroup();
|
|
assert.strictEqual(repositoryGroup0.name(), 'system-and-webkit');
|
|
assert.strictEqual(repositoryGroup0, requests[2].repositoryGroup());
|
|
assert(repositoryGroup0.accepts(set0));
|
|
assert(!repositoryGroup0.accepts(set1));
|
|
|
|
const repositoryGroup1 = requests[1].repositoryGroup();
|
|
assert.strictEqual(repositoryGroup1.name(), 'webkit-only');
|
|
assert.strictEqual(repositoryGroup1, requests[3].repositoryGroup());
|
|
assert(!repositoryGroup1.accepts(set0));
|
|
assert(repositoryGroup1.accepts(set1));
|
|
});
|
|
});
|
|
});
|
|
|
|
it('should create a test group with a custom root', () => {
|
|
return addTriggerableAndCreateTask('some task').then((taskId) => {
|
|
let insertedGroupId;
|
|
const webkit = Repository.all().filter((repository) => repository.name() == 'WebKit')[0];
|
|
const macos = Repository.all().filter((repository) => repository.name() == 'macOS')[0];
|
|
let uploadedFile;
|
|
return TemporaryFile.makeTemporaryFile('some.dat', 'some content').then((stream) => {
|
|
return PrivilegedAPI.sendRequest('upload-file', {newFile: stream}, {useFormData: true});
|
|
}).then((response) => {
|
|
uploadedFile = response['uploadedFile'];
|
|
const revisionSets = [{[webkit.id()]: {revision: '191622'}, [macos.id()]: {revision: '15A284'}},
|
|
{[webkit.id()]: {revision: '191622'}, [macos.id()]: {revision: '15A284'}, 'customRoots': [uploadedFile['id']]}];
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, repetitionCount: 2, revisionSets}).then((content) => {
|
|
insertedGroupId = content['testGroupId'];
|
|
return TestGroup.fetchForTask(taskId, true);
|
|
});
|
|
}).then((testGroups) => {
|
|
assert.strictEqual(testGroups.length, 1);
|
|
const group = testGroups[0];
|
|
assert.strictEqual(group.id(), insertedGroupId);
|
|
assert.strictEqual(group.initialRepetitionCount(), 2);
|
|
assert.ok(!group.needsNotification());
|
|
const requests = group.buildRequests();
|
|
assert.strictEqual(requests.length, 4);
|
|
|
|
const set0 = requests[0].commitSet();
|
|
const set1 = requests[1].commitSet();
|
|
assert.strictEqual(requests[2].commitSet(), set0);
|
|
assert.strictEqual(requests[3].commitSet(), set1);
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set0.repositories()), [webkit, macos]);
|
|
assert.deepStrictEqual(set0.customRoots(), []);
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set1.repositories()), [webkit, macos]);
|
|
assert.deepStrictEqual(set1.customRoots(), [UploadedFile.ensureSingleton(uploadedFile['id'], uploadedFile)]);
|
|
assert.strictEqual(set0.revisionForRepository(webkit), '191622');
|
|
assert.strictEqual(set0.revisionForRepository(webkit), set1.revisionForRepository(webkit));
|
|
assert.strictEqual(set0.commitForRepository(webkit), set1.commitForRepository(webkit));
|
|
assert.strictEqual(set0.revisionForRepository(macos), '15A284');
|
|
assert.strictEqual(set0.commitForRepository(macos), set1.commitForRepository(macos));
|
|
assert.strictEqual(set0.revisionForRepository(macos), set1.revisionForRepository(macos));
|
|
assert(!set0.equals(set1));
|
|
});
|
|
});
|
|
});
|
|
|
|
it('should create a build test group with a patch', () => {
|
|
let taskId;
|
|
let webkit;
|
|
let macos;
|
|
let insertedGroupId;
|
|
let uploadedFile;
|
|
return addTriggerableAndCreateTask('some task').then((id) => taskId = id).then(() => {
|
|
webkit = Repository.all().filter((repository) => repository.name() == 'WebKit')[0];
|
|
macos = Repository.all().filter((repository) => repository.name() == 'macOS')[0];
|
|
return TemporaryFile.makeTemporaryFile('some.dat', 'some content');
|
|
}).then((stream) => {
|
|
return PrivilegedAPI.sendRequest('upload-file', {newFile: stream}, {useFormData: true});
|
|
}).then((response) => {
|
|
const rawFile = response['uploadedFile'];
|
|
uploadedFile = UploadedFile.ensureSingleton(rawFile.id, rawFile);
|
|
const revisionSets = [{[webkit.id()]: {revision: '191622', patch: uploadedFile.id()}, [macos.id()]: {revision: '15A284'}},
|
|
{[webkit.id()]: {revision: '191622'}, [macos.id()]: {revision: '15A284'}}];
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, repetitionCount: 2, revisionSets});
|
|
}).then((content) => {
|
|
insertedGroupId = content['testGroupId'];
|
|
return TestGroup.fetchForTask(taskId, true);
|
|
}).then((testGroups) => {
|
|
assert.strictEqual(testGroups.length, 1);
|
|
const group = testGroups[0];
|
|
assert.strictEqual(group.id(), insertedGroupId);
|
|
assert.strictEqual(group.initialRepetitionCount(), 2);
|
|
assert.ok(!group.needsNotification());
|
|
assert.strictEqual(group.test(), Test.findById(MockData.someTestId()));
|
|
assert.strictEqual(group.platform(), Platform.findById(MockData.somePlatformId()));
|
|
const requests = group.buildRequests();
|
|
assert.strictEqual(requests.length, 6);
|
|
|
|
assert.strictEqual(requests[0].isBuild(), true);
|
|
assert.strictEqual(requests[1].isBuild(), true);
|
|
assert.strictEqual(requests[2].isBuild(), false);
|
|
assert.strictEqual(requests[3].isBuild(), false);
|
|
assert.strictEqual(requests[4].isBuild(), false);
|
|
assert.strictEqual(requests[5].isBuild(), false);
|
|
|
|
assert.strictEqual(requests[0].isTest(), false);
|
|
assert.strictEqual(requests[1].isTest(), false);
|
|
assert.strictEqual(requests[2].isTest(), true);
|
|
assert.strictEqual(requests[3].isTest(), true);
|
|
assert.strictEqual(requests[4].isTest(), true);
|
|
assert.strictEqual(requests[5].isTest(), true);
|
|
|
|
const set0 = requests[0].commitSet();
|
|
const set1 = requests[1].commitSet();
|
|
assert.strictEqual(requests[2].commitSet(), set0);
|
|
assert.strictEqual(requests[3].commitSet(), set1);
|
|
assert.strictEqual(requests[4].commitSet(), set0);
|
|
assert.strictEqual(requests[5].commitSet(), set1);
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set0.repositories()), [webkit, macos]);
|
|
assert.deepStrictEqual(set0.customRoots(), []);
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set1.repositories()), [webkit, macos]);
|
|
assert.deepStrictEqual(set1.customRoots(), []);
|
|
assert.strictEqual(set0.revisionForRepository(webkit), '191622');
|
|
assert.strictEqual(set0.revisionForRepository(webkit), set1.revisionForRepository(webkit));
|
|
assert.strictEqual(set0.commitForRepository(webkit), set1.commitForRepository(webkit));
|
|
assert.strictEqual(set0.patchForRepository(webkit), uploadedFile);
|
|
assert.strictEqual(set1.patchForRepository(webkit), null);
|
|
assert.strictEqual(set0.revisionForRepository(macos), '15A284');
|
|
assert.strictEqual(set0.revisionForRepository(macos), set1.revisionForRepository(macos));
|
|
assert.strictEqual(set0.commitForRepository(macos), set1.commitForRepository(macos));
|
|
assert.strictEqual(set0.patchForRepository(macos), null);
|
|
assert.strictEqual(set1.patchForRepository(macos), null);
|
|
assert(!set0.equals(set1));
|
|
});
|
|
});
|
|
|
|
it('should create a build test group with a owned commits even when one of group does not contain an owned commit', () => {
|
|
let taskId;
|
|
let webkit;
|
|
let jsc;
|
|
let macos;
|
|
let insertedGroupId;
|
|
return addTriggerableAndCreateTask('some task').then((id) => taskId = id).then(() => {
|
|
webkit = Repository.all().filter((repository) => repository.name() == 'WebKit')[0];
|
|
macos = Repository.all().filter((repository) => repository.name() == 'macOS')[0];
|
|
jsc = Repository.all().filter((repository) => repository.name() == 'JavaScriptCore')[0];
|
|
const revisionSets = [{[webkit.id()]: {revision: '191622'}, [macos.id()]: {revision: '15A284'}},
|
|
{[webkit.id()]: {revision: '192736'}, [macos.id()]: {revision: '15A284'}, [jsc.id()]: {revision: 'owned-jsc-9191', ownerRevision: '192736'}}];
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, repetitionCount: 2, revisionSets});
|
|
}).then((content) => {
|
|
insertedGroupId = content['testGroupId'];
|
|
return TestGroup.fetchForTask(taskId, true);
|
|
}).then((testGroups) => {
|
|
assert.strictEqual(testGroups.length, 1);
|
|
const group = testGroups[0];
|
|
assert.strictEqual(group.id(), insertedGroupId);
|
|
assert.strictEqual(group.initialRepetitionCount(), 2);
|
|
assert.ok(!group.needsNotification());
|
|
assert.strictEqual(group.test(), Test.findById(MockData.someTestId()));
|
|
assert.strictEqual(group.platform(), Platform.findById(MockData.somePlatformId()));
|
|
const requests = group.buildRequests();
|
|
assert.strictEqual(requests.length, 6);
|
|
|
|
assert.strictEqual(requests[0].isBuild(), true);
|
|
assert.strictEqual(requests[1].isBuild(), true);
|
|
assert.strictEqual(requests[2].isBuild(), false);
|
|
assert.strictEqual(requests[3].isBuild(), false);
|
|
assert.strictEqual(requests[4].isBuild(), false);
|
|
assert.strictEqual(requests[5].isBuild(), false);
|
|
|
|
assert.strictEqual(requests[0].isTest(), false);
|
|
assert.strictEqual(requests[1].isTest(), false);
|
|
assert.strictEqual(requests[2].isTest(), true);
|
|
assert.strictEqual(requests[3].isTest(), true);
|
|
assert.strictEqual(requests[4].isTest(), true);
|
|
assert.strictEqual(requests[5].isTest(), true);
|
|
|
|
const set0 = requests[0].commitSet();
|
|
const set1 = requests[1].commitSet();
|
|
assert.strictEqual(requests[2].commitSet(), set0);
|
|
assert.strictEqual(requests[3].commitSet(), set1);
|
|
assert.strictEqual(requests[4].commitSet(), set0);
|
|
assert.strictEqual(requests[5].commitSet(), set1);
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set0.repositories()), [webkit, macos]);
|
|
assert.deepStrictEqual(set0.customRoots(), []);
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set1.repositories()), [jsc, webkit, macos]);
|
|
assert.deepStrictEqual(set1.customRoots(), []);
|
|
assert.strictEqual(set0.revisionForRepository(webkit), '191622');
|
|
assert.strictEqual(set1.revisionForRepository(webkit), '192736');
|
|
assert.strictEqual(set0.patchForRepository(webkit), null);
|
|
assert.strictEqual(set1.patchForRepository(webkit), null);
|
|
assert.strictEqual(set0.requiresBuildForRepository(webkit), false);
|
|
assert.strictEqual(set1.requiresBuildForRepository(webkit), false);
|
|
assert.strictEqual(set0.revisionForRepository(macos), '15A284');
|
|
assert.strictEqual(set0.revisionForRepository(macos), set1.revisionForRepository(macos));
|
|
assert.strictEqual(set0.commitForRepository(macos), set1.commitForRepository(macos));
|
|
assert.strictEqual(set0.patchForRepository(macos), null);
|
|
assert.strictEqual(set1.patchForRepository(macos), null);
|
|
assert.strictEqual(set0.requiresBuildForRepository(macos), false);
|
|
assert.strictEqual(set1.requiresBuildForRepository(macos), false);
|
|
assert.strictEqual(set0.revisionForRepository(jsc), null);
|
|
assert.strictEqual(set1.revisionForRepository(jsc), 'owned-jsc-9191');
|
|
assert.ok(!set0.patchForRepository(jsc));
|
|
assert.strictEqual(set1.patchForRepository(jsc), null);
|
|
assert.strictEqual(set0.ownerRevisionForRepository(jsc), null);
|
|
assert.strictEqual(set1.ownerRevisionForRepository(jsc), '192736');
|
|
assert.strictEqual(set1.requiresBuildForRepository(jsc), true);
|
|
assert(!set0.equals(set1));
|
|
});
|
|
});
|
|
|
|
it('should create a test group with a owned commits even when no patch is specified', () => {
|
|
let taskId;
|
|
let webkit;
|
|
let jsc;
|
|
let macos;
|
|
let insertedGroupId;
|
|
return addTriggerableAndCreateTask('some task').then((id) => taskId = id).then(() => {
|
|
webkit = Repository.all().filter((repository) => repository.name() == 'WebKit')[0];
|
|
macos = Repository.all().filter((repository) => repository.name() == 'macOS')[0];
|
|
jsc = Repository.all().filter((repository) => repository.name() == 'JavaScriptCore')[0];
|
|
const revisionSets = [{[webkit.id()]: {revision: '191622'}, [macos.id()]: {revision: '15A284'}, [jsc.id()]: {revision: 'owned-jsc-6161', ownerRevision: '191622'}},
|
|
{[webkit.id()]: {revision: '192736'}, [macos.id()]: {revision: '15A284'}, [jsc.id()]: {revision: 'owned-jsc-9191', ownerRevision: '192736'}}];
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, repetitionCount: 2, revisionSets});
|
|
}).then((content) => {
|
|
insertedGroupId = content['testGroupId'];
|
|
return TestGroup.fetchForTask(taskId, true);
|
|
}).then((testGroups) => {
|
|
assert.strictEqual(testGroups.length, 1);
|
|
const group = testGroups[0];
|
|
assert.strictEqual(group.id(), insertedGroupId);
|
|
assert.strictEqual(group.initialRepetitionCount(), 2);
|
|
assert.ok(!group.needsNotification());
|
|
assert.strictEqual(group.test(), Test.findById(MockData.someTestId()));
|
|
assert.strictEqual(group.platform(), Platform.findById(MockData.somePlatformId()));
|
|
const requests = group.buildRequests();
|
|
assert.strictEqual(requests.length, 6);
|
|
|
|
assert.strictEqual(requests[0].isBuild(), true);
|
|
assert.strictEqual(requests[1].isBuild(), true);
|
|
assert.strictEqual(requests[2].isBuild(), false);
|
|
assert.strictEqual(requests[3].isBuild(), false);
|
|
assert.strictEqual(requests[4].isBuild(), false);
|
|
assert.strictEqual(requests[5].isBuild(), false);
|
|
|
|
assert.strictEqual(requests[0].isTest(), false);
|
|
assert.strictEqual(requests[1].isTest(), false);
|
|
assert.strictEqual(requests[2].isTest(), true);
|
|
assert.strictEqual(requests[3].isTest(), true);
|
|
assert.strictEqual(requests[4].isTest(), true);
|
|
assert.strictEqual(requests[5].isTest(), true);
|
|
|
|
const set0 = requests[0].commitSet();
|
|
const set1 = requests[1].commitSet();
|
|
assert.strictEqual(requests[2].commitSet(), set0);
|
|
assert.strictEqual(requests[3].commitSet(), set1);
|
|
assert.strictEqual(requests[4].commitSet(), set0);
|
|
assert.strictEqual(requests[5].commitSet(), set1);
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set0.repositories()), [jsc, webkit, macos]);
|
|
assert.deepStrictEqual(set0.customRoots(), []);
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set1.repositories()), [jsc, webkit, macos]);
|
|
assert.deepStrictEqual(set1.customRoots(), []);
|
|
assert.strictEqual(set0.revisionForRepository(webkit), '191622');
|
|
assert.strictEqual(set1.revisionForRepository(webkit), '192736');
|
|
assert.strictEqual(set0.patchForRepository(webkit), null);
|
|
assert.strictEqual(set1.patchForRepository(webkit), null);
|
|
assert.strictEqual(set0.requiresBuildForRepository(webkit), false);
|
|
assert.strictEqual(set1.requiresBuildForRepository(webkit), false);
|
|
assert.strictEqual(set0.revisionForRepository(macos), '15A284');
|
|
assert.strictEqual(set0.revisionForRepository(macos), set1.revisionForRepository(macos));
|
|
assert.strictEqual(set0.commitForRepository(macos), set1.commitForRepository(macos));
|
|
assert.strictEqual(set0.patchForRepository(macos), null);
|
|
assert.strictEqual(set1.patchForRepository(macos), null);
|
|
assert.strictEqual(set0.requiresBuildForRepository(macos), false);
|
|
assert.strictEqual(set1.requiresBuildForRepository(macos), false);
|
|
assert.strictEqual(set0.revisionForRepository(jsc), 'owned-jsc-6161');
|
|
assert.strictEqual(set1.revisionForRepository(jsc), 'owned-jsc-9191');
|
|
assert.strictEqual(set0.patchForRepository(jsc), null);
|
|
assert.strictEqual(set1.patchForRepository(jsc), null);
|
|
assert.strictEqual(set0.ownerRevisionForRepository(jsc), '191622');
|
|
assert.strictEqual(set1.ownerRevisionForRepository(jsc), '192736');
|
|
assert.strictEqual(set0.requiresBuildForRepository(jsc), true);
|
|
assert.strictEqual(set1.requiresBuildForRepository(jsc), true);
|
|
assert(!set0.equals(set1));
|
|
});
|
|
});
|
|
|
|
it('should create a test group with a owned commits and a patch', () => {
|
|
let taskId;
|
|
let webkit;
|
|
let macos;
|
|
let jsc;
|
|
let insertedGroupId;
|
|
let uploadedFile;
|
|
return addTriggerableAndCreateTask('some task').then((id) => taskId = id).then(() => {
|
|
webkit = Repository.all().filter((repository) => repository.name() == 'WebKit')[0];
|
|
macos = Repository.all().filter((repository) => repository.name() == 'macOS')[0];
|
|
jsc = Repository.all().filter((repository) => repository.name() == 'JavaScriptCore')[0];
|
|
return TemporaryFile.makeTemporaryFile('some.dat', 'some content');
|
|
}).then((stream) => {
|
|
return PrivilegedAPI.sendRequest('upload-file', {newFile: stream}, {useFormData: true});
|
|
}).then((response) => {
|
|
const rawFile = response['uploadedFile'];
|
|
uploadedFile = UploadedFile.ensureSingleton(rawFile.id, rawFile);
|
|
const revisionSets = [{[webkit.id()]: {revision: '191622'}, [macos.id()]: {revision: '15A284'}, [jsc.id()]: {revision: 'owned-jsc-6161', ownerRevision: '191622'}},
|
|
{[webkit.id()]: {revision: '192736', patch: uploadedFile.id()}, [macos.id()]: {revision: '15A284'}, [jsc.id()]: {revision: 'owned-jsc-9191', ownerRevision: '192736'}}];
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, repetitionCount: 2, revisionSets});
|
|
}).then((content) => {
|
|
insertedGroupId = content['testGroupId'];
|
|
return TestGroup.fetchForTask(taskId, true);
|
|
}).then((testGroups) => {
|
|
assert.strictEqual(testGroups.length, 1);
|
|
const group = testGroups[0];
|
|
assert.strictEqual(group.id(), insertedGroupId);
|
|
assert.strictEqual(group.initialRepetitionCount(), 2);
|
|
assert.ok(!group.needsNotification());
|
|
assert.strictEqual(group.test(), Test.findById(MockData.someTestId()));
|
|
assert.strictEqual(group.platform(), Platform.findById(MockData.somePlatformId()));
|
|
const requests = group.buildRequests();
|
|
assert.strictEqual(requests.length, 6);
|
|
|
|
assert.strictEqual(requests[0].isBuild(), true);
|
|
assert.strictEqual(requests[1].isBuild(), true);
|
|
assert.strictEqual(requests[2].isBuild(), false);
|
|
assert.strictEqual(requests[3].isBuild(), false);
|
|
assert.strictEqual(requests[4].isBuild(), false);
|
|
assert.strictEqual(requests[5].isBuild(), false);
|
|
|
|
assert.strictEqual(requests[0].isTest(), false);
|
|
assert.strictEqual(requests[1].isTest(), false);
|
|
assert.strictEqual(requests[2].isTest(), true);
|
|
assert.strictEqual(requests[3].isTest(), true);
|
|
assert.strictEqual(requests[4].isTest(), true);
|
|
assert.strictEqual(requests[5].isTest(), true);
|
|
|
|
const set0 = requests[0].commitSet();
|
|
const set1 = requests[1].commitSet();
|
|
assert.strictEqual(requests[2].commitSet(), set0);
|
|
assert.strictEqual(requests[3].commitSet(), set1);
|
|
assert.strictEqual(requests[4].commitSet(), set0);
|
|
assert.strictEqual(requests[5].commitSet(), set1);
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set0.repositories()), [jsc, webkit, macos]);
|
|
assert.deepStrictEqual(set0.customRoots(), []);
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set1.repositories()), [jsc, webkit, macos]);
|
|
assert.deepStrictEqual(set1.customRoots(), []);
|
|
|
|
assert.strictEqual(set0.revisionForRepository(webkit), '191622');
|
|
assert.strictEqual(set1.revisionForRepository(webkit), '192736');
|
|
assert.strictEqual(set0.patchForRepository(webkit), null);
|
|
assert.strictEqual(set1.patchForRepository(webkit), uploadedFile);
|
|
assert.strictEqual(set0.ownerRevisionForRepository(webkit), null);
|
|
assert.strictEqual(set1.ownerRevisionForRepository(webkit), null);
|
|
assert.strictEqual(set0.requiresBuildForRepository(webkit), true);
|
|
assert.strictEqual(set1.requiresBuildForRepository(webkit), true);
|
|
|
|
assert.strictEqual(set0.revisionForRepository(macos), '15A284');
|
|
assert.strictEqual(set0.revisionForRepository(macos), set1.revisionForRepository(macos));
|
|
assert.strictEqual(set0.commitForRepository(macos), set1.commitForRepository(macos));
|
|
assert.strictEqual(set0.patchForRepository(macos), null);
|
|
assert.strictEqual(set1.patchForRepository(macos), null);
|
|
assert.strictEqual(set0.ownerRevisionForRepository(macos), null);
|
|
assert.strictEqual(set1.ownerRevisionForRepository(macos), null);
|
|
assert.strictEqual(set0.requiresBuildForRepository(macos), false);
|
|
assert.strictEqual(set1.requiresBuildForRepository(macos), false);
|
|
|
|
assert.strictEqual(set0.revisionForRepository(jsc), 'owned-jsc-6161');
|
|
assert.strictEqual(set1.revisionForRepository(jsc), 'owned-jsc-9191');
|
|
assert.strictEqual(set0.patchForRepository(jsc), null);
|
|
assert.strictEqual(set1.patchForRepository(jsc), null);
|
|
assert.strictEqual(set0.ownerRevisionForRepository(jsc), '191622');
|
|
assert.strictEqual(set1.ownerRevisionForRepository(jsc), '192736');
|
|
assert.strictEqual(set0.requiresBuildForRepository(jsc), true);
|
|
assert.strictEqual(set1.requiresBuildForRepository(jsc), true);
|
|
assert(!set0.equals(set1));
|
|
});
|
|
});
|
|
|
|
it('should still work even if components with same name but one is owned, one is not', () => {
|
|
let taskId;
|
|
let webkit;
|
|
let macos;
|
|
let jsc;
|
|
let ownedJSC;
|
|
let insertedGroupId;
|
|
let uploadedFile;
|
|
return addTriggerableAndCreateTask('some task').then((id) => taskId = id).then(() => {
|
|
return MockData.addAnotherTriggerable(TestServer.database());
|
|
}).then(() => {
|
|
webkit = Repository.all().filter((repository) => repository.name() == 'WebKit')[0];
|
|
macos = Repository.all().filter((repository) => repository.name() == 'macOS')[0];
|
|
jsc = Repository.all().filter((repository) => repository.name() == 'JavaScriptCore' && !repository.ownerId())[0];
|
|
ownedJSC = Repository.all().filter((repository) => repository.name() == 'JavaScriptCore' && repository.ownerId())[0];
|
|
return TemporaryFile.makeTemporaryFile('some.dat', 'some content');
|
|
}).then((stream) => {
|
|
return PrivilegedAPI.sendRequest('upload-file', {newFile: stream}, {useFormData: true});
|
|
}).then((response) => {
|
|
const rawFile = response['uploadedFile'];
|
|
uploadedFile = UploadedFile.ensureSingleton(rawFile.id, rawFile);
|
|
const revisionSets = [{[jsc.id()]: {revision: 'jsc-6161'}, [webkit.id()]: {revision: '191622'}, [macos.id()]: {revision: '15A284'}, [ownedJSC.id()]: {revision: 'owned-jsc-6161', ownerRevision: '191622'}},
|
|
{[jsc.id()]: {revision: 'jsc-9191'}, [webkit.id()]: {revision: '192736', patch: uploadedFile.id()}, [macos.id()]: {revision: '15A284'}, [ownedJSC.id()]: {revision: 'owned-jsc-9191', ownerRevision: '192736'}}];
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, repetitionCount: 2, revisionSets});
|
|
}).then((content) => {
|
|
insertedGroupId = content['testGroupId'];
|
|
return TestGroup.fetchForTask(taskId, true);
|
|
}).then((testGroups) => {
|
|
assert.strictEqual(testGroups.length, 1);
|
|
const group = testGroups[0];
|
|
assert.strictEqual(group.id(), insertedGroupId);
|
|
assert.strictEqual(group.initialRepetitionCount(), 2);
|
|
assert.strictEqual(group.test(), Test.findById(MockData.someTestId()));
|
|
assert.ok(!group.needsNotification());
|
|
assert.strictEqual(group.platform(), Platform.findById(MockData.somePlatformId()));
|
|
const requests = group.buildRequests();
|
|
assert.strictEqual(requests.length, 6);
|
|
|
|
assert.strictEqual(requests[0].isBuild(), true);
|
|
assert.strictEqual(requests[1].isBuild(), true);
|
|
assert.strictEqual(requests[2].isBuild(), false);
|
|
assert.strictEqual(requests[3].isBuild(), false);
|
|
assert.strictEqual(requests[4].isBuild(), false);
|
|
assert.strictEqual(requests[5].isBuild(), false);
|
|
|
|
assert.strictEqual(requests[0].isTest(), false);
|
|
assert.strictEqual(requests[1].isTest(), false);
|
|
assert.strictEqual(requests[2].isTest(), true);
|
|
assert.strictEqual(requests[3].isTest(), true);
|
|
assert.strictEqual(requests[4].isTest(), true);
|
|
assert.strictEqual(requests[5].isTest(), true);
|
|
|
|
const set0 = requests[0].commitSet();
|
|
const set1 = requests[1].commitSet();
|
|
assert.strictEqual(requests[2].commitSet(), set0);
|
|
assert.strictEqual(requests[3].commitSet(), set1);
|
|
assert.strictEqual(requests[4].commitSet(), set0);
|
|
assert.strictEqual(requests[5].commitSet(), set1);
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set0.repositories()), [ownedJSC, jsc, webkit, macos]);
|
|
assert.deepStrictEqual(set0.customRoots(), []);
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set1.repositories()), [ownedJSC, jsc, webkit, macos]);
|
|
assert.deepStrictEqual(set1.customRoots(), []);
|
|
|
|
assert.strictEqual(set0.revisionForRepository(webkit), '191622');
|
|
assert.strictEqual(set1.revisionForRepository(webkit), '192736');
|
|
assert.strictEqual(set0.patchForRepository(webkit), null);
|
|
assert.strictEqual(set1.patchForRepository(webkit), uploadedFile);
|
|
assert.strictEqual(set0.ownerRevisionForRepository(webkit), null);
|
|
assert.strictEqual(set1.ownerRevisionForRepository(webkit), null);
|
|
assert.strictEqual(set0.requiresBuildForRepository(webkit), true);
|
|
assert.strictEqual(set1.requiresBuildForRepository(webkit), true);
|
|
|
|
assert.strictEqual(set0.revisionForRepository(macos), '15A284');
|
|
assert.strictEqual(set0.revisionForRepository(macos), set1.revisionForRepository(macos));
|
|
assert.strictEqual(set0.commitForRepository(macos), set1.commitForRepository(macos));
|
|
assert.strictEqual(set0.patchForRepository(macos), null);
|
|
assert.strictEqual(set1.patchForRepository(macos), null);
|
|
assert.strictEqual(set0.ownerRevisionForRepository(macos), null);
|
|
assert.strictEqual(set1.ownerRevisionForRepository(macos), null);
|
|
assert.strictEqual(set0.requiresBuildForRepository(macos), false);
|
|
assert.strictEqual(set1.requiresBuildForRepository(macos), false);
|
|
|
|
assert.strictEqual(set0.revisionForRepository(ownedJSC), 'owned-jsc-6161');
|
|
assert.strictEqual(set1.revisionForRepository(ownedJSC), 'owned-jsc-9191');
|
|
assert.strictEqual(set0.patchForRepository(ownedJSC), null);
|
|
assert.strictEqual(set1.patchForRepository(ownedJSC), null);
|
|
assert.strictEqual(set0.ownerRevisionForRepository(ownedJSC), '191622');
|
|
assert.strictEqual(set1.ownerRevisionForRepository(ownedJSC), '192736');
|
|
assert.strictEqual(set0.requiresBuildForRepository(ownedJSC), true);
|
|
assert.strictEqual(set1.requiresBuildForRepository(ownedJSC), true);
|
|
|
|
assert.strictEqual(set0.revisionForRepository(jsc), 'jsc-6161');
|
|
assert.strictEqual(set1.revisionForRepository(jsc), 'jsc-9191');
|
|
assert.strictEqual(set0.patchForRepository(jsc), null);
|
|
assert.strictEqual(set1.patchForRepository(jsc), null);
|
|
assert.strictEqual(set0.ownerRevisionForRepository(jsc), null);
|
|
assert.strictEqual(set1.ownerRevisionForRepository(jsc), null);
|
|
assert.strictEqual(set0.requiresBuildForRepository(jsc), false);
|
|
assert.strictEqual(set1.requiresBuildForRepository(jsc), false);
|
|
assert(!set0.equals(set1));
|
|
});
|
|
});
|
|
|
|
it('should not create a build request to build a patch when the commit set does not have a patch', () => {
|
|
let taskId;
|
|
let webkit;
|
|
let macos;
|
|
let insertedGroupId;
|
|
let uploadedFile;
|
|
return addTriggerableAndCreateTask('some task').then((id) => taskId = id).then(() => {
|
|
webkit = Repository.all().filter((repository) => repository.name() == 'WebKit')[0];
|
|
macos = Repository.all().filter((repository) => repository.name() == 'macOS')[0];
|
|
return TemporaryFile.makeTemporaryFile('some.dat', 'some content');
|
|
}).then((stream) => {
|
|
return PrivilegedAPI.sendRequest('upload-file', {newFile: stream}, {useFormData: true});
|
|
}).then((response) => {
|
|
const rawFile = response['uploadedFile'];
|
|
uploadedFile = UploadedFile.ensureSingleton(rawFile.id, rawFile);
|
|
const revisionSets = [{[macos.id()]: {revision: '15A284'}},
|
|
{[webkit.id()]: {revision: '191622', patch: uploadedFile.id()}, [macos.id()]: {revision: '15A284'}}];
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, repetitionCount: 2, revisionSets});
|
|
}).then((content) => {
|
|
insertedGroupId = content['testGroupId'];
|
|
return TestGroup.fetchForTask(taskId, true);
|
|
}).then((testGroups) => {
|
|
assert.strictEqual(testGroups.length, 1);
|
|
const group = testGroups[0];
|
|
assert.strictEqual(group.id(), insertedGroupId);
|
|
assert.strictEqual(group.initialRepetitionCount(), 2);
|
|
assert.ok(!group.needsNotification());
|
|
assert.strictEqual(group.test(), Test.findById(MockData.someTestId()));
|
|
assert.strictEqual(group.platform(), Platform.findById(MockData.somePlatformId()));
|
|
const requests = group.buildRequests();
|
|
assert.strictEqual(requests.length, 5);
|
|
|
|
assert.strictEqual(requests[0].isBuild(), true);
|
|
assert.strictEqual(requests[1].isBuild(), false);
|
|
assert.strictEqual(requests[2].isBuild(), false);
|
|
assert.strictEqual(requests[3].isBuild(), false);
|
|
assert.strictEqual(requests[4].isBuild(), false);
|
|
|
|
assert.strictEqual(requests[0].isTest(), false);
|
|
assert.strictEqual(requests[1].isTest(), true);
|
|
assert.strictEqual(requests[2].isTest(), true);
|
|
assert.strictEqual(requests[3].isTest(), true);
|
|
assert.strictEqual(requests[4].isTest(), true);
|
|
|
|
const set0 = requests[0].commitSet();
|
|
const set1 = requests[1].commitSet();
|
|
assert.strictEqual(requests[2].commitSet(), set0);
|
|
assert.strictEqual(requests[3].commitSet(), set1);
|
|
assert.strictEqual(requests[4].commitSet(), set0);
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set0.repositories()), [webkit, macos]);
|
|
assert.deepStrictEqual(set0.customRoots(), []);
|
|
assert.deepStrictEqual(Repository.sortByNamePreferringOnesWithURL(set1.repositories()), [macos]);
|
|
assert.deepStrictEqual(set1.customRoots(), []);
|
|
assert.strictEqual(set0.revisionForRepository(webkit), '191622');
|
|
assert.strictEqual(set1.revisionForRepository(webkit), null);
|
|
assert.strictEqual(set0.patchForRepository(webkit), uploadedFile);
|
|
assert.strictEqual(set0.revisionForRepository(macos), '15A284');
|
|
assert.strictEqual(set0.revisionForRepository(macos), set1.revisionForRepository(macos));
|
|
assert.strictEqual(set0.commitForRepository(macos), set1.commitForRepository(macos));
|
|
assert.strictEqual(set0.patchForRepository(macos), null);
|
|
assert.strictEqual(set1.patchForRepository(macos), null);
|
|
assert(!set0.equals(set1));
|
|
});
|
|
});
|
|
|
|
it('should return "PatchNotAccepted" when a patch is specified for a repository that does not accept a patch', () => {
|
|
let taskId;
|
|
let webkit;
|
|
let macos;
|
|
let uploadedFile;
|
|
return addTriggerableAndCreateTask('some task').then((id) => taskId = id).then(() => {
|
|
webkit = Repository.all().filter((repository) => repository.name() == 'WebKit')[0];
|
|
macos = Repository.all().filter((repository) => repository.name() == 'macOS')[0];
|
|
return TemporaryFile.makeTemporaryFile('some.dat', 'some content');
|
|
}).then((stream) => {
|
|
return PrivilegedAPI.sendRequest('upload-file', {newFile: stream}, {useFormData: true});
|
|
}).then((response) => {
|
|
const rawFile = response['uploadedFile'];
|
|
uploadedFile = UploadedFile.ensureSingleton(rawFile.id, rawFile);
|
|
const revisionSets = [{[webkit.id()]: {revision: '191622'}, [macos.id()]: {revision: '15A284', patch: uploadedFile.id()}},
|
|
{[webkit.id()]: {revision: '192736'}, [macos.id()]: {revision: '15A284'}}];
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId, repetitionCount: 2, revisionSets});
|
|
}).then(() => {
|
|
assert(false, 'should never be reached');
|
|
}, (error) => {
|
|
assert.strictEqual(error, 'PatchNotAccepted');
|
|
});
|
|
});
|
|
|
|
it('should create a test group with an analysis task with needs-notification flag set', async () => {
|
|
await addTriggerableAndCreateTask('some task');
|
|
const webkit = Repository.all().filter((repository) => repository.name() == 'WebKit')[0];
|
|
const revisionSets = [{[webkit.id()]: {revision: '191622'}}, {[webkit.id()]: {revision: '191623'}}];
|
|
let result = await PrivilegedAPI.sendRequest('create-test-group',
|
|
{name: 'test', taskName: 'other task', platform: MockData.somePlatformId(), test: MockData.someTestId(), needsNotification: true, revisionSets});
|
|
const insertedGroupId = result['testGroupId'];
|
|
|
|
const [analysisTask, testGroups] = await Promise.all([AnalysisTask.fetchById(result['taskId']), TestGroup.fetchForTask(result['taskId'], true)]);
|
|
assert.strictEqual(analysisTask.name(), 'other task');
|
|
|
|
assert.strictEqual(testGroups.length, 1);
|
|
const group = testGroups[0];
|
|
assert.strictEqual(group.id(), insertedGroupId);
|
|
assert.strictEqual(group.initialRepetitionCount(), 1);
|
|
assert.ok(group.needsNotification());
|
|
const requests = group.buildRequests();
|
|
assert.strictEqual(requests.length, 2);
|
|
|
|
const set0 = requests[0].commitSet();
|
|
const set1 = requests[1].commitSet();
|
|
assert.deepStrictEqual(set0.repositories(), [webkit]);
|
|
assert.deepStrictEqual(set0.customRoots(), []);
|
|
assert.deepStrictEqual(set1.repositories(), [webkit]);
|
|
assert.deepStrictEqual(set1.customRoots(), []);
|
|
assert.strictEqual(set0.revisionForRepository(webkit), '191622');
|
|
assert.strictEqual(set1.revisionForRepository(webkit), '191623');
|
|
});
|
|
|
|
it('should be able to create a test group with needs-notification flag unset', async () => {
|
|
await addTriggerableAndCreateTask('some task');
|
|
const webkit = Repository.all().filter((repository) => repository.name() == 'WebKit')[0];
|
|
const revisionSets = [{[webkit.id()]: {revision: '191622'}}, {[webkit.id()]: {revision: '191623'}}];
|
|
let result = await PrivilegedAPI.sendRequest('create-test-group',
|
|
{name: 'test', taskName: 'other task', platform: MockData.somePlatformId(), test: MockData.someTestId(), needsNotification: false, revisionSets});
|
|
const insertedGroupId = result['testGroupId'];
|
|
|
|
const [analysisTask, testGroups] = await Promise.all([AnalysisTask.fetchById(result['taskId']), TestGroup.fetchForTask(result['taskId'], true)]);
|
|
assert.strictEqual(analysisTask.name(), 'other task');
|
|
|
|
assert.strictEqual(testGroups.length, 1);
|
|
const group = testGroups[0];
|
|
assert.strictEqual(group.id(), insertedGroupId);
|
|
assert.strictEqual(group.initialRepetitionCount(), 1);
|
|
assert.ok(!group.needsNotification());
|
|
const requests = group.buildRequests();
|
|
assert.strictEqual(requests.length, 2);
|
|
|
|
const set0 = requests[0].commitSet();
|
|
const set1 = requests[1].commitSet();
|
|
assert.deepStrictEqual(set0.repositories(), [webkit]);
|
|
assert.deepStrictEqual(set0.customRoots(), []);
|
|
assert.deepStrictEqual(set1.repositories(), [webkit]);
|
|
assert.deepStrictEqual(set1.customRoots(), []);
|
|
assert.strictEqual(set0.revisionForRepository(webkit), '191622');
|
|
assert.strictEqual(set1.revisionForRepository(webkit), '191623');
|
|
});
|
|
|
|
it('should create a custom test group for an existing custom analysis task', () => {
|
|
let firstResult;
|
|
let secondResult;
|
|
let webkit;
|
|
let test = MockData.someTestId();
|
|
return addTriggerableAndCreateTask('some task').then(() => {
|
|
webkit = Repository.all().filter((repository) => repository.name() == 'WebKit')[0];
|
|
const revisionSets = [{[webkit.id()]: {revision: '191622'}}, {[webkit.id()]: {revision: '191623'}}];
|
|
return PrivilegedAPI.sendRequest('create-test-group',
|
|
{name: 'test1', taskName: 'other task', platform: MockData.somePlatformId(), test, revisionSets});
|
|
}).then((result) => {
|
|
firstResult = result;
|
|
const revisionSets = [{[webkit.id()]: {revision: '191622'}}, {[webkit.id()]: {revision: '192736'}}];
|
|
return PrivilegedAPI.sendRequest('create-test-group',
|
|
{name: 'test2', task: result['taskId'], platform: MockData.otherPlatformId(), test, revisionSets, repetitionCount: 2});
|
|
}).then((result) => {
|
|
secondResult = result;
|
|
// pg funtions will return all data as string, so we need make sure that we compare as int
|
|
assert.strictEqual(parseInt(firstResult['taskId']), parseInt(secondResult['taskId']));
|
|
return Promise.all([AnalysisTask.fetchById(result['taskId']), TestGroup.fetchForTask(result['taskId'], true)]);
|
|
}).then((result) => {
|
|
const [analysisTask, testGroups] = result;
|
|
|
|
assert.strictEqual(analysisTask.name(), 'other task');
|
|
|
|
assert.strictEqual(testGroups.length, 2);
|
|
TestGroup.sortByName(testGroups);
|
|
|
|
assert.strictEqual(testGroups[0].name(), 'test1');
|
|
assert.strictEqual(testGroups[0].initialRepetitionCount(), 1);
|
|
let requests = testGroups[0].buildRequests();
|
|
assert.strictEqual(requests.length, 2);
|
|
let set0 = requests[0].commitSet();
|
|
let set1 = requests[1].commitSet();
|
|
assert.deepStrictEqual(set0.repositories(), [webkit]);
|
|
assert.deepStrictEqual(set0.customRoots(), []);
|
|
assert.deepStrictEqual(set1.repositories(), [webkit]);
|
|
assert.deepStrictEqual(set1.customRoots(), []);
|
|
assert.strictEqual(set0.revisionForRepository(webkit), '191622');
|
|
assert.strictEqual(set1.revisionForRepository(webkit), '191623');
|
|
|
|
assert.strictEqual(testGroups[1].name(), 'test2');
|
|
assert.strictEqual(testGroups[1].initialRepetitionCount(), 2);
|
|
requests = testGroups[1].buildRequests();
|
|
assert.strictEqual(requests.length, 4);
|
|
set0 = requests[0].commitSet();
|
|
set1 = requests[1].commitSet();
|
|
assert.deepStrictEqual(requests[2].commitSet(), set0);
|
|
assert.deepStrictEqual(requests[3].commitSet(), set1);
|
|
assert.deepStrictEqual(set0.repositories(), [webkit]);
|
|
assert.deepStrictEqual(set0.customRoots(), []);
|
|
assert.deepStrictEqual(set1.repositories(), [webkit]);
|
|
assert.deepStrictEqual(set1.customRoots(), []);
|
|
assert.strictEqual(set0.revisionForRepository(webkit), '191622');
|
|
assert.strictEqual(set1.revisionForRepository(webkit), '192736');
|
|
});
|
|
});
|
|
|
|
it('should create a sequential test group with an analysis task', async () => {
|
|
await addTriggerableAndCreateTask('some task');
|
|
const webkit = Repository.all().filter((repository) => repository.name() == 'WebKit')[0];
|
|
const revisionSets = [{[webkit.id()]: {revision: '191622'}}, {[webkit.id()]: {revision: '191623'}}];
|
|
let result = await PrivilegedAPI.sendRequest('create-test-group',
|
|
{name: 'test', taskName: 'other task', platform: MockData.somePlatformId(), test: MockData.someTestId(),
|
|
needsNotification: true, revisionSets, repetitionType: 'sequential', repetitionCount: 2});
|
|
const insertedGroupId = result['testGroupId'];
|
|
|
|
const [analysisTask, testGroups] = await Promise.all([AnalysisTask.fetchById(result['taskId']), TestGroup.fetchForTask(result['taskId'], true)]);
|
|
assert.strictEqual(analysisTask.name(), 'other task');
|
|
|
|
assert.strictEqual(testGroups.length, 1);
|
|
const group = testGroups[0];
|
|
assert.strictEqual(group.id(), insertedGroupId);
|
|
assert.strictEqual(group.initialRepetitionCount(), 2);
|
|
assert.strictEqual(group.repetitionType(), 'sequential')
|
|
assert.ok(group.needsNotification());
|
|
const requests = group.buildRequests();
|
|
assert.strictEqual(requests.length, 4);
|
|
|
|
assert.strictEqual(requests[0].order(), 0);
|
|
assert.strictEqual(requests[1].order(), 1);
|
|
assert.strictEqual(requests[2].order(), 2);
|
|
assert.strictEqual(requests[3].order(), 3);
|
|
|
|
assert.strictEqual(group.requestedCommitSets().length, 2)
|
|
assert(requests[0].commitSet().equals(requests[1].commitSet()));
|
|
assert(requests[2].commitSet().equals(requests[3].commitSet()));
|
|
|
|
const set0 = requests[0].commitSet();
|
|
const set1 = requests[2].commitSet();
|
|
assert.deepStrictEqual(set0.repositories(), [webkit]);
|
|
assert.deepStrictEqual(set0.customRoots(), []);
|
|
assert.deepStrictEqual(set1.repositories(), [webkit]);
|
|
assert.deepStrictEqual(set1.customRoots(), []);
|
|
assert.strictEqual(set0.revisionForRepository(webkit), '191622');
|
|
assert.strictEqual(set1.revisionForRepository(webkit), '191623');
|
|
});
|
|
|
|
it('should create an alternating test group with an analysis task', async () => {
|
|
await addTriggerableAndCreateTask('some task');
|
|
const webkit = Repository.all().filter((repository) => repository.name() == 'WebKit')[0];
|
|
const revisionSets = [{[webkit.id()]: {revision: '191622'}}, {[webkit.id()]: {revision: '191623'}}];
|
|
let result = await PrivilegedAPI.sendRequest('create-test-group',
|
|
{name: 'test', taskName: 'other task', platform: MockData.somePlatformId(), test: MockData.someTestId(),
|
|
needsNotification: true, revisionSets, repetitionType: 'alternating', repetitionCount: 2});
|
|
const insertedGroupId = result['testGroupId'];
|
|
|
|
const [analysisTask, testGroups] = await Promise.all([AnalysisTask.fetchById(result['taskId']), TestGroup.fetchForTask(result['taskId'], true)]);
|
|
assert.strictEqual(analysisTask.name(), 'other task');
|
|
|
|
assert.strictEqual(testGroups.length, 1);
|
|
const group = testGroups[0];
|
|
assert.strictEqual(group.id(), insertedGroupId);
|
|
assert.strictEqual(group.initialRepetitionCount(), 2);
|
|
assert.strictEqual(group.repetitionType(), 'alternating')
|
|
assert.ok(group.needsNotification());
|
|
const requests = group.buildRequests();
|
|
assert.strictEqual(requests.length, 4);
|
|
|
|
assert.strictEqual(requests[0].order(), 0);
|
|
assert.strictEqual(requests[1].order(), 1);
|
|
assert.strictEqual(requests[2].order(), 2);
|
|
assert.strictEqual(requests[3].order(), 3);
|
|
|
|
assert.strictEqual(group.requestedCommitSets().length, 2)
|
|
assert(requests[0].commitSet().equals(requests[2].commitSet()));
|
|
assert(requests[1].commitSet().equals(requests[3].commitSet()));
|
|
|
|
const set0 = requests[0].commitSet();
|
|
const set1 = requests[1].commitSet();
|
|
assert.deepStrictEqual(set0.repositories(), [webkit]);
|
|
assert.deepStrictEqual(set0.customRoots(), []);
|
|
assert.deepStrictEqual(set1.repositories(), [webkit]);
|
|
assert.deepStrictEqual(set1.customRoots(), []);
|
|
assert.strictEqual(set0.revisionForRepository(webkit), '191622');
|
|
assert.strictEqual(set1.revisionForRepository(webkit), '191623');
|
|
});
|
|
|
|
it('should create a sequential test group in an existing analysis task', async () => {
|
|
const taskId = await addTriggerableAndCreateTask('some task');
|
|
const ignoreCache = true;
|
|
|
|
let [analysisTask, testGroups] = await Promise.all([AnalysisTask.fetchById(taskId), TestGroup.fetchForTask(taskId, ignoreCache)]);
|
|
assert.strictEqual(analysisTask.name(), 'some task');
|
|
assert.strictEqual(testGroups.length, 0);
|
|
|
|
const webkit = Repository.all().filter((repository) => repository.name() == 'WebKit')[0];
|
|
const revisionSets = [{[webkit.id()]: {revision: '191622'}}, {[webkit.id()]: {revision: '191623'}}];
|
|
let result = await PrivilegedAPI.sendRequest('create-test-group',
|
|
{name: 'test', task: taskId, platform: MockData.somePlatformId(), test: MockData.someTestId(),
|
|
needsNotification: true, revisionSets, repetitionType: 'sequential', repetitionCount: 2});
|
|
const insertedGroupId = result['testGroupId'];
|
|
|
|
[analysisTask, testGroups] = await Promise.all([AnalysisTask.fetchById(result['taskId']), TestGroup.fetchForTask(result['taskId'], ignoreCache)]);
|
|
assert.strictEqual(analysisTask.name(), 'some task');
|
|
|
|
assert.strictEqual(testGroups.length, 1);
|
|
const group = testGroups[0];
|
|
assert.strictEqual(group.id(), insertedGroupId);
|
|
assert.strictEqual(group.initialRepetitionCount(), 2);
|
|
assert.strictEqual(group.repetitionType(), 'sequential')
|
|
assert.ok(group.needsNotification());
|
|
const requests = group.buildRequests();
|
|
assert.strictEqual(requests.length, 4);
|
|
|
|
assert.strictEqual(requests[0].order(), 0);
|
|
assert.strictEqual(requests[1].order(), 1);
|
|
assert.strictEqual(requests[2].order(), 2);
|
|
assert.strictEqual(requests[3].order(), 3);
|
|
|
|
assert.strictEqual(group.requestedCommitSets().length, 2)
|
|
assert(requests[0].commitSet().equals(requests[1].commitSet()));
|
|
assert(requests[2].commitSet().equals(requests[3].commitSet()));
|
|
|
|
const set0 = requests[0].commitSet();
|
|
const set1 = requests[2].commitSet();
|
|
assert.deepStrictEqual(set0.repositories(), [webkit]);
|
|
assert.deepStrictEqual(set0.customRoots(), []);
|
|
assert.deepStrictEqual(set1.repositories(), [webkit]);
|
|
assert.deepStrictEqual(set1.customRoots(), []);
|
|
assert.strictEqual(set0.revisionForRepository(webkit), '191622');
|
|
assert.strictEqual(set1.revisionForRepository(webkit), '191623');
|
|
});
|
|
|
|
it('should reject with "InvalidRepetitionType" if repetition type is not "alternating" or "sequential"', async () => {
|
|
await addTriggerableAndCreateTask('some task');
|
|
const webkit = Repository.all().filter((repository) => repository.name() == 'WebKit')[0];
|
|
const revisionSets = [{[webkit.id()]: {revision: '191622'}}, {[webkit.id()]: {revision: '191623'}}];
|
|
|
|
await assertThrows('InvalidRepetitionType', () => {
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', taskName: 'other task',
|
|
platform: MockData.somePlatformId(), test: MockData.someTestId(),
|
|
needsNotification: true, repetitionType: 'invalid-mode', repetitionCount: 2, revisionSets})
|
|
});
|
|
});
|
|
|
|
it('should reject with "InvalidRepetitionType" when creating a test group with a bad repetition type for an existing analysis task', async () => {
|
|
const taskId = await addTriggerableAndCreateTask('some task');
|
|
const webkit = Repository.all().filter((repository) => repository.name() == 'WebKit')[0];
|
|
const revisionSets = [{[webkit.id()]: {revision: '191622'}}, {[webkit.id()]: {revision: '191623'}}];
|
|
|
|
await assertThrows('InvalidRepetitionType', () => {
|
|
return PrivilegedAPI.sendRequest('create-test-group', {name: 'test', task: taskId,
|
|
platform: MockData.somePlatformId(), test: MockData.someTestId(),
|
|
needsNotification: true, repetitionType: 'invalid-mode', repetitionCount: 2, revisionSets})
|
|
});
|
|
});
|
|
});
|