'use strict';

let assert = require('assert');

let MockData = require('./resources/mock-data.js');
let TestServer = require('./resources/test-server.js');
const addBuilderForReport = require('./resources/common-operations.js').addBuilderForReport;
const prepareServerTest = require('./resources/common-operations.js').prepareServerTest;
const assertThrows = require('./resources/common-operations.js').assertThrows;

const reportWithRevision = [{
    "buildTag": "124",
    "buildTime": "2015-10-27T15:34:51",
    "revisions": {
        "WebKit": {
            "revision": "191622",
            "timestamp": '2015-10-27T11:36:56.878473Z',
        },
    },
    "builderName": "someBuilder",
    "builderPassword": "somePassword",
    "platform": "some platform",
    "tests": {
        "Suite": {
            "metrics": {
                "Time": ["Arithmetic"],
            },
            "tests": {
                "test1": {
                    "metrics": {"Time": { "current": [11] }},
                }
            }
        },
    }}];

const reportWithRevisionNoTimestamp = [{
    "buildTag": "124",
    "buildTime": "2015-10-27T15:34:51",
    "revisions": {
        "WebKit": {
            "revision": "191622",
        },
    },
    "builderName": "someBuilder",
    "builderPassword": "somePassword",
    "platform": "some platform",
    "tests": {
        "Suite": {
            "metrics": {
                "Time": ["Arithmetic"],
            },
            "tests": {
                "test1": {
                    "metrics": {"Time": { "current": [11] }},
                }
            }
        },
    }}];

const anotherReportWithRevision = [{
    "buildTag": "125",
    "buildTime": "2015-10-27T17:27:41",
    "revisions": {
        "WebKit": {
            "revision": "191623",
            "timestamp": '2015-10-27T16:38:10.768995Z',
        },
    },
    "builderName": "someBuilder",
    "builderPassword": "somePassword",
    "platform": "some platform",
    "tests": {
        "Suite": {
            "metrics": {
                "Time": ["Arithmetic"],
            },
            "tests": {
                "test1": {
                    "metrics": {"Time": { "current": [12] }},
                }
            }
        },
    }}];

const anotherReportWithRevisionNoTimestamp = [{
    "buildTag": "125",
    "buildTime": "2015-10-27T17:27:41",
    "revisions": {
        "WebKit": {
            "revision": "191623",
        },
    },
    "builderName": "someBuilder",
    "builderPassword": "somePassword",
    "platform": "some platform",
    "tests": {
        "Suite": {
            "metrics": {
                "Time": ["Arithmetic"],
            },
            "tests": {
                "test1": {
                    "metrics": {"Time": { "current": [12] }},
                }
            }
        },
    }}];

describe('/privileged-api/create-analysis-task with browser privileged api', function () {
    prepareServerTest(this);

    it('should return "MissingName" on an empty request', () => {
        return PrivilegedAPI.sendRequest('create-analysis-task', {}).then((content) => {
            assert(false, 'should never be reached');
        }, (error) => {
            assert.strictEqual(error, 'MissingName');
        });
    });

    it('should return "InvalidStartRun" when startRun is missing but endRun is set', () => {
        return PrivilegedAPI.sendRequest('create-analysis-task', {name: 'hi', endRun: 1}).then((content) => {
            assert(false, 'should never be reached');
        }, (error) => {
            assert.strictEqual(error, 'InvalidStartRun');
        });
    });

    it('should return "InvalidEndRun" when endRun is missing but startRun is set', () => {
        return PrivilegedAPI.sendRequest('create-analysis-task', {name: 'hi', startRun: 1}).then((content) => {
            assert(false, 'should never be reached');
        }, (error) => {
            assert.strictEqual(error, 'InvalidEndRun');
        });
    });

    it('should return "InvalidStartRun" when startRun is not a valid integer', () => {
        return PrivilegedAPI.sendRequest('create-analysis-task', {name: 'hi', startRun: "foo", endRun: 1}).then((content) => {
            assert(false, 'should never be reached');
        }, (error) => {
            assert.strictEqual(error, 'InvalidStartRun');
        });
    });

    it('should return "InvalidEndRun" when endRun is not a valid integer', () => {
        return PrivilegedAPI.sendRequest('create-analysis-task', {name: 'hi', startRun: 1, endRun: "foo"}).then((content) => {
            assert(false, 'should never be reached');
        }, (error) => {
            assert.strictEqual(error, 'InvalidEndRun');
        });
    });

    it('should return "InvalidStartRun" when startRun is invalid', () => {
        return addBuilderForReport(reportWithRevision[0]).then(() => {
            return TestServer.remoteAPI().postJSON('/api/report/', reportWithRevision);
        }).then(() => {
            return PrivilegedAPI.sendRequest('create-analysis-task', {name: 'hi', startRun: 100, endRun: 1}).then((content) => {
                assert(false, 'should never be reached');
            }, (error) => {
                assert.strictEqual(error, 'InvalidStartRun');
            });
        });
    });

    it('should return "InvalidEndRun" when endRun is invalid', () => {
        return addBuilderForReport(reportWithRevision[0]).then(() => {
            return TestServer.remoteAPI().postJSON('/api/report/', reportWithRevision);
        }).then(() => {
            return PrivilegedAPI.sendRequest('create-analysis-task', {name: 'hi', startRun: 1, endRun: 100}).then((content) => {
                assert(false, 'should never be reached');
            }, (error) => {
                assert.strictEqual(error, 'InvalidEndRun');
            });
        });
    });

    it('should return "InvalidTimeRange" when startRun and endRun are identical', () => {
        return addBuilderForReport(reportWithRevision[0]).then(() => {
            return TestServer.remoteAPI().postJSON('/api/report/', reportWithRevision);
        }).then(() => {
            return PrivilegedAPI.sendRequest('create-analysis-task', {name: 'hi', startRun: 1, endRun: 1}).then((content) => {
                assert(false, 'should never be reached');
            }, (error) => {
                assert.strictEqual(error, 'InvalidTimeRange');
            });
        });
    });

    it('should return "RunConfigMismatch" when startRun and endRun come from a different test configurations', () => {
        return addBuilderForReport(reportWithRevision[0]).then(() => {
            return TestServer.remoteAPI().postJSON('/api/report/', reportWithRevision);
        }).then(() => {
            return PrivilegedAPI.sendRequest('create-analysis-task', {name: 'hi', startRun: 1, endRun: 2}).then((content) => {
                assert(false, 'should never be reached');
            }, (error) => {
                assert.strictEqual(error, 'RunConfigMismatch');
            });
        });
    });

    it('should create an analysis task when name, startRun, and endRun are set properly', () => {
        const db = TestServer.database();
        return addBuilderForReport(reportWithRevision[0]).then(() => {
            return TestServer.remoteAPI().postJSON('/api/report/', reportWithRevision);
        }).then(() => {
            return TestServer.remoteAPI().postJSON('/api/report/', anotherReportWithRevision);
        }).then(() => {
            return Manifest.fetch();
        }).then(() => {
            const test1 = Test.findByPath(['Suite', 'test1']);
            const platform = Platform.findByName('some platform');
            return db.selectFirstRow('test_configurations', {metric: test1.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: 'hi', startRun: testRuns[0]['id'], endRun: testRuns[1]['id']});
        }).then((content) => {
            return AnalysisTask.fetchById(content['taskId']);
        }).then((task) => {
            assert.strictEqual(task.name(), 'hi');
            assert(!task.hasResults());
            assert(!task.hasPendingRequests());
            assert.deepStrictEqual(task.bugs(), []);
            assert.deepStrictEqual(task.causes(), []);
            assert.deepStrictEqual(task.fixes(), []);
            assert.strictEqual(task.changeType(), null);
            assert.strictEqual(task.platform().label(), 'some platform');
            assert.strictEqual(task.metric().test().label(), 'test1');
        });
    });

    it('should create an analysis task and use build time as fallback when commit time is not available', () => {
        const db = TestServer.database();
        return addBuilderForReport(reportWithRevisionNoTimestamp[0]).then(() => {
            return TestServer.remoteAPI().postJSON('/api/report/', reportWithRevisionNoTimestamp);
        }).then(() => {
            return TestServer.remoteAPI().postJSON('/api/report/', anotherReportWithRevisionNoTimestamp);
        }).then(() => {
            return Manifest.fetch();
        }).then(() => {
            const test1 = Test.findByPath(['Suite', 'test1']);
            const platform = Platform.findByName('some platform');
            return db.selectFirstRow('test_configurations', {metric: test1.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: 'hi', startRun: testRuns[0]['id'], endRun: testRuns[1]['id']});
        }).then((content) => {
            return AnalysisTask.fetchById(content['taskId']);
        }).then((task) => {
            assert.strictEqual(task.name(), 'hi');
            assert(!task.hasResults());
            assert(!task.hasPendingRequests());
            assert.deepStrictEqual(task.bugs(), []);
            assert.deepStrictEqual(task.causes(), []);
            assert.deepStrictEqual(task.fixes(), []);
            assert.strictEqual(task.changeType(), null);
            assert.strictEqual(task.platform().label(), 'some platform');
            assert.strictEqual(task.metric().test().label(), 'test1');
            assert.strictEqual(task.startTime(), 1445960091000);
            assert.strictEqual(task.endTime(), 1445966861000);
        });
    });

    it('should return "DuplicateAnalysisTask" when there is already an analysis task for the specified range', () => {
        const db = TestServer.database();
        let startId;
        let endId;
        return addBuilderForReport(reportWithRevision[0]).then(() => {
            return TestServer.remoteAPI().postJSON('/api/report/', reportWithRevision);
        }).then(() => {
            return TestServer.remoteAPI().postJSON('/api/report/', anotherReportWithRevision);
        }).then(() => {
            return Manifest.fetch();
        }).then(() => {
            const test1 = Test.findByPath(['Suite', 'test1']);
            const platform = Platform.findByName('some platform');
            return db.selectFirstRow('test_configurations', {metric: test1.metrics()[0].id(), platform: platform.id()});
        }).then((configRow) => {
            return db.selectRows('test_runs', {config: configRow['id']});
        }).then((testRuns) => {
            assert.strictEqual(testRuns.length, 2);
            startId = testRuns[0]['id'];
            endId = testRuns[1]['id'];
            return PrivilegedAPI.sendRequest('create-analysis-task', {name: 'hi', startRun: startId, endRun: endId});
        }).then((content) => {
            return PrivilegedAPI.sendRequest('create-analysis-task', {name: 'hi', startRun: startId, endRun: endId}).then(() => {
                assert(false, 'should never be reached');
            }, (error) => {
                assert.strictEqual(error, 'DuplicateAnalysisTask');
            });
        }).then(() => {
            return db.selectAll('analysis_tasks');
        }).then((tasks) => {
            assert.strictEqual(tasks.length, 1);
        });
    });

    it('should create an analysis task with analysis strategies when they are specified', () => {
        const db = TestServer.database();
        return addBuilderForReport(reportWithRevision[0]).then(() => {
            return TestServer.remoteAPI().postJSON('/api/report/', reportWithRevision);
        }).then(() => {
            return TestServer.remoteAPI().postJSON('/api/report/', anotherReportWithRevision);
        }).then(() => {
            return Manifest.fetch();
        }).then(() => {
            const test1 = Test.findByPath(['Suite', 'test1']);
            const platform = Platform.findByName('some platform');
            return db.selectFirstRow('test_configurations', {metric: test1.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: 'hi',
                startRun: testRuns[0]['id'],
                endRun: testRuns[1]['id'],
                segmentationStrategy: "time series segmentation",
                testRangeStrategy: "student's t-test"});
        }).then(() => {
            return Promise.all([db.selectFirstRow('analysis_tasks'), db.selectAll('analysis_strategies')]);
        }).then((results) => {
            const [taskRow, strategies] = results;
            assert(taskRow['segmentation']);
            assert(taskRow['test_range']);

            const strategyIdMap = {};
            for (let strategy of strategies)
                strategyIdMap[strategy['id']] = strategy;

            assert.strictEqual(strategyIdMap[taskRow['segmentation']]['name'], "time series segmentation");
            assert.strictEqual(strategyIdMap[taskRow['test_range']]['name'], "student's t-test");
        });
    });

    it('should failed with "TriggerableNotFoundForTask" when there is no matching triggerable', async () => {
        const db = TestServer.database();
        await addBuilderForReport(reportWithRevision[0]);
        await TestServer.remoteAPI().postJSON('/api/report/', reportWithRevision);
        await TestServer.remoteAPI().postJSON('/api/report/', anotherReportWithRevision);
        await Manifest.fetch();

        const test1 = Test.findByPath(['Suite', 'test1']);
        const somePlatform = Platform.findByName('some platform');
        const configRow = await db.selectFirstRow('test_configurations', {metric: test1.metrics()[0].id(), platform: somePlatform.id()});
        const testRuns = await db.selectRows('test_runs', {config: configRow['id']});
        assert.strictEqual(testRuns.length, 2);

        const webkitRepositoryRow = await db.selectFirstRow('repositories', {name: 'WebKit'});
        const webkitId = webkitRepositoryRow.id;

        const oneRevisionSet = {[webkitId]: {revision: '191622'}};
        const anotherRevisionSet = {[webkitId]: {revision: '191623'}};

        await assertThrows('TriggerableNotFoundForTask', () =>
            PrivilegedAPI.sendRequest('create-analysis-task', {name: 'confirm', repetitionCount: 1,
                revisionSets: [oneRevisionSet, anotherRevisionSet],
                startRun: testRuns[0]['id'], endRun: testRuns[1]['id']}));
    });

    it('should create an analysis task with no test group when repetition count is 0', async () => {
        const db = TestServer.database();
        await addBuilderForReport(reportWithRevision[0]);
        await TestServer.remoteAPI().postJSON('/api/report/', reportWithRevision);
        await TestServer.remoteAPI().postJSON('/api/report/', anotherReportWithRevision);
        await Manifest.fetch();

        const test1 = Test.findByPath(['Suite', 'test1']);
        const platform = Platform.findByName('some platform');
        const configRow = await db.selectFirstRow('test_configurations', {metric: test1.metrics()[0].id(), platform: platform.id()});
        const testRuns = await db.selectRows('test_runs', {config: configRow['id']});
        assert.strictEqual(testRuns.length, 2);

        const webkitRepositoryRow = await db.selectFirstRow('repositories', {name: 'WebKit'});
        const webkitId = webkitRepositoryRow.id;

        const oneRevisionSet = {[webkitId]: {revision: '191622'}};
        const anotherRevisionSet = {[webkitId]: {revision: '191623'}};

        const content = await PrivilegedAPI.sendRequest('create-analysis-task', {name: 'confirm', repetitionCount: 0,
            revisionSets: [oneRevisionSet, anotherRevisionSet],
            startRun: testRuns[0]['id'], endRun: testRuns[1]['id']});

        TestServer.cleanDataDirectory();
        await Manifest.fetch();

        const task = await AnalysisTask.fetchById(content['taskId']);
        assert.strictEqual(task.name(), 'confirm');
        assert(!task.hasResults());
        assert(!task.hasPendingRequests());
        assert.deepStrictEqual(task.bugs(), []);
        assert.deepStrictEqual(task.causes(), []);
        assert.deepStrictEqual(task.fixes(), []);
        assert.strictEqual(task.changeType(), null);
        assert.strictEqual(task.platform().label(), 'some platform');
        assert.strictEqual(task.metric().test().label(), 'test1');

        const testGroups = await TestGroup.fetchForTask(task.id());
        assert.strictEqual(testGroups.length, 0);
    });

    it('should create an analysis task with test group when commit set list and a positive repetition count is specified', async () => {
        const webkitId = 1;
        const platformId = 1;
        const test1Id = 2;
        const triggerableId = 1234;

        const db = TestServer.database();
        await db.insert('tests', {id: 1, name: 'Suite'});
        await db.insert('tests', {id: test1Id, name: 'test1', parent: 1});
        await db.insert('repositories', {id: webkitId, name: 'WebKit'});
        await db.insert('platforms', {id: platformId, name: 'some platform'});
        await db.insert('build_triggerables', {id: 1234, name: 'test-triggerable'});
        await db.insert('triggerable_repository_groups', {id: 2345, name: 'webkit-only', triggerable: triggerableId});
        await db.insert('triggerable_repositories', {repository: webkitId, group: 2345});
        await db.insert('triggerable_configurations', {test: test1Id, platform: platformId, triggerable: triggerableId});
        await addBuilderForReport(reportWithRevision[0]);

        await TestServer.remoteAPI().postJSON('/api/report/', reportWithRevision);
        await TestServer.remoteAPI().postJSON('/api/report/', anotherReportWithRevision);
        await Manifest.fetch();

        let test1 = Test.findById(test1Id);
        let somePlatform = Platform.findById(platformId);
        const configRow = await db.selectFirstRow('test_configurations', {metric: test1.metrics()[0].id(), platform: somePlatform.id()});
        const testRuns = await db.selectRows('test_runs', {config: configRow['id']});
        assert.strictEqual(testRuns.length, 2);

        const oneRevisionSet = {[webkitId]: {revision: '191622'}};
        const anotherRevisionSet = {[webkitId]: {revision: '191623'}};

        const content = await PrivilegedAPI.sendRequest('create-analysis-task', {name: 'confirm', repetitionCount: 1,
            testGroupName: 'Confirm', revisionSets: [oneRevisionSet, anotherRevisionSet],
            startRun: testRuns[0]['id'], endRun: testRuns[1]['id']});

        const task = await AnalysisTask.fetchById(content['taskId']);
        assert.strictEqual(task.name(), 'confirm');
        assert(!task.hasResults());
        assert(task.hasPendingRequests());
        assert.deepStrictEqual(task.bugs(), []);
        assert.deepStrictEqual(task.causes(), []);
        assert.deepStrictEqual(task.fixes(), []);
        assert.strictEqual(task.changeType(), null);
        assert.strictEqual(task.platform().label(), 'some platform');
        assert.strictEqual(task.metric().test().label(), 'test1');

        const testGroups = await TestGroup.fetchForTask(task.id());
        assert.strictEqual(testGroups.length, 1);
        const testGroup = testGroups[0];
        assert.strictEqual(testGroup.name(), 'Confirm');
        assert.ok(!testGroup.needsNotification());
        const buildRequests = testGroup.buildRequests();
        assert.strictEqual(buildRequests.length, 2);

        assert.strictEqual(parseInt(buildRequests[0].triggerable().id()), triggerableId);
        assert.strictEqual(parseInt(buildRequests[0].triggerable().id()), triggerableId);

        assert.strictEqual(buildRequests[0].testGroup(), testGroup);
        assert.strictEqual(buildRequests[1].testGroup(), testGroup);

        assert.strictEqual(buildRequests[0].platform(), task.platform());
        assert.strictEqual(buildRequests[1].platform(), task.platform());

        assert.strictEqual(buildRequests[0].analysisTaskId(), task.id());
        assert.strictEqual(buildRequests[1].analysisTaskId(), task.id());

        assert.strictEqual(buildRequests[0].test(), test1);
        assert.strictEqual(buildRequests[1].test(), test1);

        assert.ok(!buildRequests[0].isBuild());
        assert.ok(!buildRequests[1].isBuild());
        assert.ok(buildRequests[0].isTest());
        assert.ok(buildRequests[1].isTest());

        const firstCommitSet = buildRequests[0].commitSet();
        const secondCommitSet = buildRequests[1].commitSet();
        const webkitRepository = Repository.findById(webkitId);
        assert.strictEqual(firstCommitSet.commitForRepository(webkitRepository).revision(), '191622');
        assert.strictEqual(secondCommitSet.commitForRepository(webkitRepository).revision(), '191623');
    });
});

describe('/privileged-api/create-analysis-task with node privileged api', function () {
    prepareServerTest(this, 'node');
    beforeEach(() => {
        PrivilegedAPI.configure('test', 'password');
    });

    it('should return "WorkerNotFound" when incorrect worker user and password combination is provided and no analysis task, test group or build request should be created', async () => {
        PrivilegedAPI.configure('test', 'wrongpassword');
        const db = TestServer.database();
        await addBuilderForReport(reportWithRevision[0]);
        await TestServer.remoteAPI().postJSON('/api/report/', reportWithRevision);
        await TestServer.remoteAPI().postJSON('/api/report/', anotherReportWithRevision);
        await Manifest.fetch();

        const test1 = Test.findByPath(['Suite', 'test1']);
        const somePlatform = Platform.findByName('some platform');
        const configRow = await db.selectFirstRow('test_configurations', {metric: test1.metrics()[0].id(), platform: somePlatform.id()});
        const testRuns = await db.selectRows('test_runs', {config: configRow['id']});
        assert.strictEqual(testRuns.length, 2);

        const webkitRepositoryRow = await db.selectFirstRow('repositories', {name: 'WebKit'});
        const webkitId = webkitRepositoryRow.id;

        const oneRevisionSet = {[webkitId]: {revision: '191622'}};
        const anotherRevisionSet = {[webkitId]: {revision: '191623'}};

        await assertThrows('WorkerNotFound', () =>
            PrivilegedAPI.sendRequest('create-analysis-task', {name: 'confirm', repetitionCount: 1,
                revisionSets: [oneRevisionSet, anotherRevisionSet],
                startRun: testRuns[0]['id'], endRun: testRuns[1]['id']}));

        const allAnalysisTasks = await db.selectRows('analysis_tasks');
        assert.ok(!allAnalysisTasks.length);

        const allTestGroups = await db.selectRows('analysis_test_groups');
        assert.ok(!allTestGroups.length);

        const allBuildRequests = await db.selectRows('build_requests');
        assert.ok(!allBuildRequests.length);
    });

    it('should create an analysis task with test group when commit set list and a positive repetition count is specified', async () => {
        const webkitId = 1;
        const platformId = 1;
        const test1Id = 2;
        const triggerableId = 1234;

        const db = TestServer.database();
        await db.insert('tests', {id: 1, name: 'Suite'});
        await db.insert('tests', {id: test1Id, name: 'test1', parent: 1});
        await db.insert('repositories', {id: webkitId, name: 'WebKit'});
        await db.insert('platforms', {id: platformId, name: 'some platform'});
        await db.insert('build_triggerables', {id: 1234, name: 'test-triggerable'});
        await db.insert('triggerable_repository_groups', {id: 2345, name: 'webkit-only', triggerable: triggerableId});
        await db.insert('triggerable_repositories', {repository: webkitId, group: 2345});
        await db.insert('triggerable_configurations', {test: test1Id, platform: platformId, triggerable: triggerableId});
        await addBuilderForReport(reportWithRevision[0]);

        await TestServer.remoteAPI().postJSON('/api/report/', reportWithRevision);
        await TestServer.remoteAPI().postJSON('/api/report/', anotherReportWithRevision);
        await Manifest.fetch();

        let test1 = Test.findById(test1Id);
        let somePlatform = Platform.findById(platformId);
        const configRow = await db.selectFirstRow('test_configurations', {metric: test1.metrics()[0].id(), platform: somePlatform.id()});
        const testRuns = await db.selectRows('test_runs', {config: configRow['id']});
        assert.strictEqual(testRuns.length, 2);

        const oneRevisionSet = {[webkitId]: {revision: '191622'}};
        const anotherRevisionSet = {[webkitId]: {revision: '191623'}};

        const content = await PrivilegedAPI.sendRequest('create-analysis-task', {name: 'confirm', repetitionCount: 1,
            testGroupName: 'Confirm', revisionSets: [oneRevisionSet, anotherRevisionSet],
            startRun: testRuns[0]['id'], endRun: testRuns[1]['id']});

        const task = await AnalysisTask.fetchById(content['taskId']);
        assert.strictEqual(task.name(), 'confirm');
        assert(!task.hasResults());
        assert(task.hasPendingRequests());
        assert.deepStrictEqual(task.bugs(), []);
        assert.deepStrictEqual(task.causes(), []);
        assert.deepStrictEqual(task.fixes(), []);
        assert.strictEqual(task.changeType(), null);
        assert.strictEqual(task.platform().label(), 'some platform');
        assert.strictEqual(task.metric().test().label(), 'test1');

        const testGroups = await TestGroup.fetchForTask(task.id());
        assert.strictEqual(testGroups.length, 1);
        const testGroup = testGroups[0];
        assert.strictEqual(testGroup.name(), 'Confirm');
        assert.ok(!testGroup.needsNotification());
        const buildRequests = testGroup.buildRequests();
        assert.strictEqual(buildRequests.length, 2);

        assert.strictEqual(parseInt(buildRequests[0].triggerable().id()), triggerableId);
        assert.strictEqual(parseInt(buildRequests[0].triggerable().id()), triggerableId);

        assert.strictEqual(buildRequests[0].testGroup(), testGroup);
        assert.strictEqual(buildRequests[1].testGroup(), testGroup);

        assert.strictEqual(buildRequests[0].platform(), task.platform());
        assert.strictEqual(buildRequests[1].platform(), task.platform());

        assert.strictEqual(buildRequests[0].analysisTaskId(), task.id());
        assert.strictEqual(buildRequests[1].analysisTaskId(), task.id());

        assert.strictEqual(buildRequests[0].test(), test1);
        assert.strictEqual(buildRequests[1].test(), test1);

        assert.ok(!buildRequests[0].isBuild());
        assert.ok(!buildRequests[1].isBuild());
        assert.ok(buildRequests[0].isTest());
        assert.ok(buildRequests[1].isTest());

        const firstCommitSet = buildRequests[0].commitSet();
        const secondCommitSet = buildRequests[1].commitSet();
        const webkitRepository = Repository.findById(webkitId);
        assert.strictEqual(firstCommitSet.commitForRepository(webkitRepository).revision(), '191622');
        assert.strictEqual(secondCommitSet.commitForRepository(webkitRepository).revision(), '191623');
    });

    it('should create an analysis task with test group and respect the "needsNotification" flag in the http request', async () => {
        const webkitId = 1;
        const platformId = 1;
        const test1Id = 2;
        const triggerableId = 1234;

        const db = TestServer.database();
        await db.insert('tests', {id: 1, name: 'Suite'});
        await db.insert('tests', {id: test1Id, name: 'test1', parent: 1});
        await db.insert('repositories', {id: webkitId, name: 'WebKit'});
        await db.insert('platforms', {id: platformId, name: 'some platform'});
        await db.insert('build_triggerables', {id: 1234, name: 'test-triggerable'});
        await db.insert('triggerable_repository_groups', {id: 2345, name: 'webkit-only', triggerable: triggerableId});
        await db.insert('triggerable_repositories', {repository: webkitId, group: 2345});
        await db.insert('triggerable_configurations', {test: test1Id, platform: platformId, triggerable: triggerableId});
        await addBuilderForReport(reportWithRevision[0]);

        await TestServer.remoteAPI().postJSON('/api/report/', reportWithRevision);
        await TestServer.remoteAPI().postJSON('/api/report/', anotherReportWithRevision);
        await Manifest.fetch();

        let test1 = Test.findById(test1Id);
        let somePlatform = Platform.findById(platformId);
        const configRow = await db.selectFirstRow('test_configurations', {metric: test1.metrics()[0].id(), platform: somePlatform.id()});
        const testRuns = await db.selectRows('test_runs', {config: configRow['id']});
        assert.strictEqual(testRuns.length, 2);

        const oneRevisionSet = {[webkitId]: {revision: '191622'}};
        const anotherRevisionSet = {[webkitId]: {revision: '191623'}};

        const content = await PrivilegedAPI.sendRequest('create-analysis-task', {name: 'confirm', repetitionCount: 1,
            testGroupName: 'Confirm', revisionSets: [oneRevisionSet, anotherRevisionSet],
            startRun: testRuns[0]['id'], endRun: testRuns[1]['id'], needsNotification: true});

        const task = await AnalysisTask.fetchById(content['taskId']);
        assert.strictEqual(task.name(), 'confirm');
        assert(!task.hasResults());
        assert(task.hasPendingRequests());
        assert.deepStrictEqual(task.bugs(), []);
        assert.deepStrictEqual(task.causes(), []);
        assert.deepStrictEqual(task.fixes(), []);
        assert.strictEqual(task.changeType(), null);
        assert.strictEqual(task.platform().label(), 'some platform');
        assert.strictEqual(task.metric().test().label(), 'test1');

        const testGroups = await TestGroup.fetchForTask(task.id());
        assert.strictEqual(testGroups.length, 1);
        const testGroup = testGroups[0];
        assert.strictEqual(testGroup.name(), 'Confirm');
        assert.ok(testGroup.needsNotification());
        const buildRequests = testGroup.buildRequests();
        assert.strictEqual(buildRequests.length, 2);

        assert.strictEqual(parseInt(buildRequests[0].triggerable().id()), triggerableId);
        assert.strictEqual(parseInt(buildRequests[0].triggerable().id()), triggerableId);

        assert.strictEqual(buildRequests[0].testGroup(), testGroup);
        assert.strictEqual(buildRequests[1].testGroup(), testGroup);

        assert.strictEqual(buildRequests[0].platform(), task.platform());
        assert.strictEqual(buildRequests[1].platform(), task.platform());

        assert.strictEqual(buildRequests[0].analysisTaskId(), task.id());
        assert.strictEqual(buildRequests[1].analysisTaskId(), task.id());

        assert.strictEqual(buildRequests[0].test(), test1);
        assert.strictEqual(buildRequests[1].test(), test1);

        assert.ok(!buildRequests[0].isBuild());
        assert.ok(!buildRequests[1].isBuild());
        assert.ok(buildRequests[0].isTest());
        assert.ok(buildRequests[1].isTest());

        const firstCommitSet = buildRequests[0].commitSet();
        const secondCommitSet = buildRequests[1].commitSet();
        const webkitRepository = Repository.findById(webkitId);
        assert.strictEqual(firstCommitSet.commitForRepository(webkitRepository).revision(), '191622');
        assert.strictEqual(secondCommitSet.commitForRepository(webkitRepository).revision(), '191623');
    });

    it('should be able to create an analysis task with a sequential test group', async () => {
        const webkitId = 1;
        const platformId = 1;
        const triggerableId = 1234;

        const db = TestServer.database();
        await db.insert('tests', {name: 'Suite'});
        const testRow = await db.selectFirstRow('tests', {name: 'Suite'});
        const testId = testRow.id;
        await db.insert('repositories', {id: webkitId, name: 'WebKit'});
        await db.insert('platforms', {id: platformId, name: 'some platform'});
        await db.insert('build_triggerables', {id: 1234, name: 'test-triggerable'});
        await db.insert('triggerable_repository_groups', {id: 2345, name: 'webkit-only', triggerable: triggerableId});
        await db.insert('triggerable_repositories', {repository: webkitId, group: 2345});
        await db.insert('triggerable_configurations', {test: testId, platform: platformId, triggerable: triggerableId});
        await addBuilderForReport(reportWithRevision[0]);

        await TestServer.remoteAPI().postJSON('/api/report/', reportWithRevision);
        await TestServer.remoteAPI().postJSON('/api/report/', anotherReportWithRevision);
        await Manifest.fetch();

        const test = Test.findById(testId);
        const somePlatform = Platform.findById(platformId);
        const configRow = await db.selectFirstRow('test_configurations', {metric: test.metrics()[0].id(), platform: somePlatform.id()});
        const testRuns = await db.selectRows('test_runs', {config: configRow['id']});
        assert.strictEqual(testRuns.length, 2);

        const oneRevisionSet = {[webkitId]: {revision: '191622'}};
        const anotherRevisionSet = {[webkitId]: {revision: '191623'}};

        const content = await PrivilegedAPI.sendRequest('create-analysis-task', {name: 'confirm', repetitionCount: 2,
            testGroupName: 'Confirm', revisionSets: [oneRevisionSet, anotherRevisionSet],
            startRun: testRuns[0]['id'], endRun: testRuns[1]['id'], needsNotification: true, repetitionType: 'sequential'});

        const task = await AnalysisTask.fetchById(content['taskId']);
        assert.strictEqual(task.name(), 'confirm');
        assert(!task.hasResults());
        assert(task.hasPendingRequests());
        assert.deepStrictEqual(task.bugs(), []);
        assert.deepStrictEqual(task.causes(), []);
        assert.deepStrictEqual(task.fixes(), []);
        assert.strictEqual(task.changeType(), null);
        assert.strictEqual(task.platform().label(), 'some platform');
        assert.strictEqual(task.metric().test().label(), 'Suite');

        const testGroups = await TestGroup.fetchForTask(task.id());
        assert.strictEqual(testGroups.length, 1);
        const testGroup = testGroups[0];
        assert.strictEqual(testGroup.name(), 'Confirm');
        assert.ok(testGroup.needsNotification());
        assert.strictEqual(testGroup.repetitionType(), 'sequential')
        for (const commitSet of testGroup.requestedCommitSets())
            assert.strictEqual(testGroup.repetitionCountForCommitSet(commitSet), 2);

        const buildRequests = testGroup.buildRequests();
        assert.strictEqual(buildRequests.length, 4);

        assert.strictEqual(buildRequests[0].order(), 0);
        assert.strictEqual(buildRequests[1].order(), 1);
        assert.strictEqual(buildRequests[2].order(), 2);
        assert.strictEqual(buildRequests[3].order(), 3);

        assert(buildRequests[0].commitSet().equals(buildRequests[1].commitSet()));
        assert(buildRequests[2].commitSet().equals(buildRequests[3].commitSet()));

        const firstCommitSet = buildRequests[0].commitSet();
        const secondCommitSet = buildRequests[2].commitSet();
        const webkitRepository = Repository.findById(webkitId);
        assert.strictEqual(firstCommitSet.commitForRepository(webkitRepository).revision(), '191622');
        assert.strictEqual(secondCommitSet.commitForRepository(webkitRepository).revision(), '191623');
    });

    it('should reject with "InvalidRepetitionType" when repetition type is not "alternating" or "sequential"', async () => {
        const webkitId = 1;
        const platformId = 1;
        const triggerableId = 1234;

        const db = TestServer.database();
        await db.insert('tests', {name: 'Suite'});
        const testRow = await db.selectFirstRow('tests', {name: 'Suite'});
        const testId = testRow.id;
        await db.insert('repositories', {id: webkitId, name: 'WebKit'});
        await db.insert('platforms', {id: platformId, name: 'some platform'});
        await db.insert('build_triggerables', {id: 1234, name: 'test-triggerable'});
        await db.insert('triggerable_repository_groups', {id: 2345, name: 'webkit-only', triggerable: triggerableId});
        await db.insert('triggerable_repositories', {repository: webkitId, group: 2345});
        await db.insert('triggerable_configurations', {test: testId, platform: platformId, triggerable: triggerableId});
        await addBuilderForReport(reportWithRevision[0]);

        await TestServer.remoteAPI().postJSON('/api/report/', reportWithRevision);
        await TestServer.remoteAPI().postJSON('/api/report/', anotherReportWithRevision);
        await Manifest.fetch();

        const test = Test.findById(testId);
        const somePlatform = Platform.findById(platformId);
        const configRow = await db.selectFirstRow('test_configurations', {metric: test.metrics()[0].id(), platform: somePlatform.id()});
        const testRuns = await db.selectRows('test_runs', {config: configRow['id']});
        assert.strictEqual(testRuns.length, 2);

        const oneRevisionSet = {[webkitId]: {revision: '191622'}};
        const anotherRevisionSet = {[webkitId]: {revision: '191623'}};
        await assertThrows('InvalidRepetitionType', () => {
            return PrivilegedAPI.sendRequest('create-analysis-task', {
                name: 'confirm',
                repetitionCount: 2,
                testGroupName: 'Confirm',
                revisionSets: [oneRevisionSet, anotherRevisionSet],
                repetitionType: 'invalid-mode',
                startRun: testRuns[0]['id'],
                endRun: testRuns[1]['id'],
                needsNotification: true
            })
        });
    });
});