Websites/perf.webkit.org/server-tests/api-manifest-tests.js

'use strict';

const assert = require('assert');

require('../tools/js/v3-models.js');

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

describe('/api/manifest', function () {
    prepareServerTest(this);

    it("should generate an empty manifest when database is empty", () => {
        return TestServer.remoteAPI().getJSON('/api/manifest').then((manifest) => {
            assert.deepStrictEqual(Object.keys(manifest).sort(), ['all', 'bugTrackers', 'builders', 'dashboard', 'dashboards',
                'fileUploadSizeLimit', 'maxRootReuseAgeInDays', 'metrics', 'platformGroups', 'repositories', 'siteTitle',
                'status', 'summaryPages', 'testAgeToleranceInHours', 'tests', 'triggerables']);

            assert.deepStrictEqual(manifest, {
                siteTitle: TestServer.testConfig().siteTitle,
                all: {},
                bugTrackers: {},
                builders: {},
                dashboard: {},
                dashboards: {},
                fileUploadSizeLimit: 2097152, // 2MB during testing.
                maxRootReuseAgeInDays: null,
                metrics: {},
                platformGroups: {},
                repositories: {},
                testAgeToleranceInHours: null,
                tests: {},
                triggerables: {},
                summaryPages: [],
                status: 'OK'
            });
        });
    });

    const bugzillaData = {id: 1, name: 'Bugzilla', bug_url: 'https://webkit.org/b/$number', new_bug_url: 'https://bugs.webkit.org/'};
    const radarData = {id: 2, name: 'Radar'};

    it("should generate manifest with bug trackers without repositories", () => {
        return TestServer.database().insert('bug_trackers', bugzillaData).then(() => {
            return TestServer.remoteAPI().getJSON('/api/manifest');
        }).then((content) => {
            assert.deepStrictEqual(content.bugTrackers, {1: {name: 'Bugzilla', bugUrl: 'https://webkit.org/b/$number',
                newBugUrl: 'https://bugs.webkit.org/', repositories: null}});

            let manifest = Manifest._didFetchManifest(content);
            let tracker = BugTracker.findById(1);
            assert(tracker);
            assert.strictEqual(tracker.name(), 'Bugzilla');
            assert.strictEqual(tracker.bugUrl(123), 'https://webkit.org/b/123');
            assert.strictEqual(tracker.newBugUrl(), 'https://bugs.webkit.org/');
        });
    });

    it("should clear Bug and BugTracker static maps when reset", async () => {
        await TestServer.database().insert('bug_trackers', bugzillaData);
        const content = await TestServer.remoteAPI().getJSON('/api/manifest');
        assert.deepStrictEqual(content.bugTrackers, {1: {name: 'Bugzilla', bugUrl: 'https://webkit.org/b/$number',
            newBugUrl: 'https://bugs.webkit.org/', repositories: null}});

        Manifest._didFetchManifest(content);
        const trackerFromFirstFetch = BugTracker.findById(1);

        Manifest.reset();
        assert(!BugTracker.findById(1));

        Manifest._didFetchManifest(content);
        const trackerFromSecondFetch = BugTracker.findById(1);
        assert(trackerFromFirstFetch != trackerFromSecondFetch);
    });

    it("should generate manifest with bug trackers and repositories", () => {
        let db = TestServer.database();
        return Promise.all([
            db.insert('bug_trackers', bugzillaData),
            db.insert('bug_trackers', radarData),
            db.insert('repositories', {id: 11, name: 'WebKit', url: 'https://trac.webkit.org/$1'}),
            db.insert('repositories', {id: 9, name: 'macOS'}),
            db.insert('repositories', {id: 22, name: 'iOS'}),
            db.insert('tracker_repositories', {tracker: bugzillaData.id, repository: 11}),
            db.insert('tracker_repositories', {tracker: radarData.id, repository: 9}),
            db.insert('tracker_repositories', {tracker: radarData.id, repository: 22}),
        ]).then(() => {
            return TestServer.remoteAPI().getJSON('/api/manifest');
        }).then((content) => {
            let manifest = Manifest._didFetchManifest(content);

            let webkit = Repository.findById(11);
            assert(webkit);
            assert.strictEqual(webkit.name(), 'WebKit');
            assert.strictEqual(webkit.urlForRevision(123), 'https://trac.webkit.org/123');

            let macos = Repository.findById(9);
            assert(macos);
            assert.strictEqual(macos.name(), 'macOS');

            let ios = Repository.findById(22);
            assert(ios);
            assert.strictEqual(ios.name(), 'iOS');

            let tracker = BugTracker.findById(1);
            assert(tracker);
            assert.strictEqual(tracker.name(), 'Bugzilla');
            assert.strictEqual(tracker.bugUrl(123), 'https://webkit.org/b/123');
            assert.strictEqual(tracker.newBugUrl(), 'https://bugs.webkit.org/');
            assert.deepStrictEqual(tracker.repositories(), [webkit]);

            tracker = BugTracker.findById(2);
            assert(tracker);
            assert.strictEqual(tracker.name(), 'Radar');
            assert.deepStrictEqual(Repository.sortByName(tracker.repositories()), [ios, macos]);
        });
    });

    it("should generate manifest with repositories and each repository should know its owned repositories", () => {
        const db = TestServer.database();
        return Promise.all([
            db.insert('repositories', {id: 11, name: 'WebKit', url: 'https://trac.webkit.org/$1'}),
            db.insert('repositories', {id: 9, name: 'OS X'}),
            db.insert('repositories', {id: 22, name: 'iOS'}),
            db.insert('repositories', {id: 35, name: 'JavaScriptCore', owner: 9}),
        ]).then(() => {
            return TestServer.remoteAPI().getJSON('/api/manifest');
        }).then((content) => {
            let manifest = Manifest._didFetchManifest(content);

            let webkit = Repository.findById(11);
            assert(webkit);
            assert.strictEqual(webkit.name(), 'WebKit');
            assert.strictEqual(webkit.urlForRevision(123), 'https://trac.webkit.org/123');
            assert.ok(!webkit.ownedRepositories());

            let osx = Repository.findById(9);
            assert(osx);
            assert.strictEqual(osx.name(), 'OS X');
            assert.deepStrictEqual(osx.ownedRepositories(), [Repository.findById(35)]);

            let ios = Repository.findById(22);
            assert(ios);
            assert.strictEqual(ios.name(), 'iOS');
            assert.ok(!ios.ownedRepositories());
        });
    });

    it("should generate manifest with builders", () => {
        let db = TestServer.database();
        return Promise.all([
            db.insert('builders', {id: 1, name: 'SomeBuilder', password_hash: 'a',
                build_url: 'https://build.webkit.org/builders/$builderName/build/$buildTag'}),
            db.insert('builders', {id: 2, name: 'SomeOtherBuilder', password_hash: 'b'})
        ]).then(() => {
            return TestServer.remoteAPI().getJSON('/api/manifest');
        }).then((content) => {
            assert.deepStrictEqual(content.builders, {
                '1': {name: 'SomeBuilder', buildUrl: 'https://build.webkit.org/builders/$builderName/build/$buildTag'},
                '2': {name: 'SomeOtherBuilder', buildUrl: null}
            });

            let manifest = Manifest._didFetchManifest(content);

            let builder = Builder.findById(1);
            assert(builder);
            assert.strictEqual(builder.name(), 'SomeBuilder');
            assert.strictEqual(builder.urlForBuild(123), 'https://build.webkit.org/builders/SomeBuilder/build/123');

            builder = Builder.findById(2);
            assert(builder);
            assert.strictEqual(builder.name(), 'SomeOtherBuilder');
            assert.strictEqual(builder.urlForBuild(123), null);
        });
    });

    it("should generate manifest with tests, metrics, and platforms", () => {
        let db = TestServer.database();
        return Promise.all([
            db.insert('tests', {id: 1, name: 'SomeTest'}),
            db.insert('tests', {id: 2, name: 'SomeOtherTest'}),
            db.insert('tests', {id: 3, name: 'ChildTest', parent: 1}),
            db.insert('tests', {id: 4, name: 'GrandChild', parent: 3}),
            db.insert('aggregators', {id: 200, name: 'Total'}),
            db.insert('test_metrics', {id: 5, test: 1, name: 'Time'}),
            db.insert('test_metrics', {id: 6, test: 2, name: 'Time', aggregator: 200}),
            db.insert('test_metrics', {id: 7, test: 2, name: 'Malloc', aggregator: 200}),
            db.insert('test_metrics', {id: 8, test: 3, name: 'Time'}),
            db.insert('test_metrics', {id: 9, test: 4, name: 'Time'}),
            db.insert('platform_groups', {id: 1, name: 'ios'}),
            db.insert('platform_groups', {id: 2, name: 'mac'}),
            db.insert('platforms', {id: 23, name: 'iOS 9 iPhone 5s', group: 1}),
            db.insert('platforms', {id: 46, name: 'Trunk Mavericks', group: 2}),
            db.insert('test_configurations', {id: 101, metric: 5, platform: 46, type: 'current'}),
            db.insert('test_configurations', {id: 102, metric: 6, platform: 46, type: 'current'}),
            db.insert('test_configurations', {id: 103, metric: 7, platform: 46, type: 'current'}),
            db.insert('test_configurations', {id: 104, metric: 8, platform: 46, type: 'current'}),
            db.insert('test_configurations', {id: 105, metric: 9, platform: 46, type: 'current'}),
            db.insert('test_configurations', {id: 106, metric: 5, platform: 23, type: 'current'}),
            db.insert('test_configurations', {id: 107, metric: 5, platform: 23, type: 'baseline'}),
        ]).then(() => {
            return TestServer.remoteAPI().getJSON('/api/manifest');
        }).then((content) => {
            assert.deepStrictEqual(content.tests, {
                "1": {"name": "SomeTest", "parentId": null, "url": null},
                "2": {"name": "SomeOtherTest", "parentId": null, "url": null},
                "3": {"name": "ChildTest", "parentId": "1", "url": null},
                "4": {"name": "GrandChild", "parentId": "3", "url": null},
            });

            assert.deepStrictEqual(content.metrics, {
                '5': {name: 'Time', test: '1', aggregator: null},
                '6': {name: 'Time', test: '2', aggregator: 'Total'},
                '7': {name: 'Malloc', test: '2', aggregator: 'Total'},
                '8': {name: 'Time', test: '3', aggregator: null},
                '9': {name: 'Time', test: '4', aggregator: null},
            });

            let manifest = Manifest._didFetchManifest(content);

            const someTest = Test.findById(1);
            const someTestMetric = Metric.findById(5);
            const someOtherTest = Test.findById(2);
            const someOtherTestTime = Metric.findById(6);
            const someOtherTestMalloc = Metric.findById(7);
            const childTest = Test.findById(3);
            const childTestMetric = Metric.findById(8);
            const grandChildTest = Test.findById(4);
            const ios9iphone5s = Platform.findById(23);
            const mavericks = Platform.findById(46);
            const iosGroup = PlatformGroup.findById(1);
            const macGroup = PlatformGroup.findById(2);
            assert(someTest);
            assert(someTestMetric);
            assert(someOtherTest);
            assert(someOtherTestTime);
            assert(someOtherTestMalloc);
            assert(childTest);
            assert(childTestMetric);
            assert(grandChildTest);
            assert(ios9iphone5s);
            assert(mavericks);
            assert(iosGroup);
            assert(macGroup);

            assert.strictEqual(mavericks.name(), 'Trunk Mavericks');
            assert(mavericks.hasTest(someTest));
            assert(mavericks.hasTest(someOtherTest));
            assert(mavericks.hasTest(childTest));
            assert(mavericks.hasTest(grandChildTest));
            assert(mavericks.hasMetric(someTestMetric));
            assert(mavericks.hasMetric(someOtherTestTime));
            assert(mavericks.hasMetric(someOtherTestMalloc));
            assert(mavericks.hasMetric(childTestMetric));
            assert.strictEqual(mavericks.group(), macGroup);

            assert.strictEqual(ios9iphone5s.name(), 'iOS 9 iPhone 5s');
            assert(ios9iphone5s.hasTest(someTest));
            assert(!ios9iphone5s.hasTest(someOtherTest));
            assert(!ios9iphone5s.hasTest(childTest));
            assert(!ios9iphone5s.hasTest(grandChildTest));
            assert(ios9iphone5s.hasMetric(someTestMetric));
            assert(!ios9iphone5s.hasMetric(someOtherTestTime));
            assert(!ios9iphone5s.hasMetric(someOtherTestMalloc));
            assert(!ios9iphone5s.hasMetric(childTestMetric));
            assert.strictEqual(ios9iphone5s.group(), iosGroup);

            const macPlatforms = macGroup.platforms();
            assert.strictEqual(macPlatforms.length, 1);
            assert.strictEqual(macPlatforms[0], mavericks);

            const iosPlatforms = iosGroup.platforms();
            assert.strictEqual(iosPlatforms.length, 1);
            assert.strictEqual(iosPlatforms[0], ios9iphone5s);

            assert.strictEqual(someTest.name(), 'SomeTest');
            assert.ok(!someTest.parentTest());
            assert.deepStrictEqual(someTest.path(), [someTest]);
            assert(!someTest.onlyContainsSingleMetric());
            assert.deepStrictEqual(someTest.childTests(), [childTest]);
            assert.deepStrictEqual(someTest.metrics(), [someTestMetric]);

            assert.strictEqual(someTestMetric.name(), 'Time');
            assert.strictEqual(someTestMetric.aggregatorName(), null);
            assert.strictEqual(someTestMetric.label(), 'Time');
            assert.deepStrictEqual(someTestMetric.childMetrics(), childTest.metrics());
            assert.strictEqual(someTestMetric.fullName(), 'SomeTest : Time');

            assert.strictEqual(someOtherTest.name(), 'SomeOtherTest');
            assert.ok(!someOtherTest.parentTest());
            assert.deepStrictEqual(someOtherTest.path(), [someOtherTest]);
            assert(!someOtherTest.onlyContainsSingleMetric());
            assert.deepStrictEqual(someOtherTest.childTests(), []);
            assert.strictEqual(someOtherTest.metrics().length, 2);
            assert.strictEqual(someOtherTest.metrics()[0].name(), 'Time');
            assert.strictEqual(someOtherTest.metrics()[0].aggregatorName(), 'Total');
            assert.strictEqual(someOtherTest.metrics()[0].label(), 'Time : Total');
            assert.strictEqual(someOtherTest.metrics()[0].childMetrics().length, 0);
            assert.strictEqual(someOtherTest.metrics()[0].fullName(), 'SomeOtherTest : Time : Total');
            assert.strictEqual(someOtherTest.metrics()[1].name(), 'Malloc');
            assert.strictEqual(someOtherTest.metrics()[1].aggregatorName(), 'Total');
            assert.strictEqual(someOtherTest.metrics()[1].label(), 'Malloc : Total');
            assert.strictEqual(someOtherTest.metrics()[1].childMetrics().length, 0);
            assert.strictEqual(someOtherTest.metrics()[1].fullName(), 'SomeOtherTest : Malloc : Total');

            assert.strictEqual(childTest.name(), 'ChildTest');
            assert.strictEqual(childTest.parentTest(), someTest);
            assert.deepStrictEqual(childTest.path(), [someTest, childTest]);
            assert(!childTest.onlyContainsSingleMetric());
            assert.deepStrictEqual(childTest.childTests(), [grandChildTest]);
            assert.strictEqual(childTest.metrics().length, 1);
            assert.strictEqual(childTest.metrics()[0].label(), 'Time');
            assert.strictEqual(childTest.metrics()[0].fullName(), 'SomeTest \u220B ChildTest : Time');

            assert.strictEqual(grandChildTest.name(), 'GrandChild');
            assert.strictEqual(grandChildTest.parentTest(), childTest);
            assert.deepStrictEqual(grandChildTest.path(), [someTest, childTest, grandChildTest]);
            assert(grandChildTest.onlyContainsSingleMetric());
            assert.deepStrictEqual(grandChildTest.childTests(), []);
            assert.strictEqual(grandChildTest.metrics().length, 1);
            assert.strictEqual(grandChildTest.metrics()[0].label(), 'Time');
            assert.strictEqual(grandChildTest.metrics()[0].fullName(), 'SomeTest \u220B ChildTest \u220B GrandChild : Time');
        });
    });

    it("should generate manifest with triggerables", () => {
        let db = TestServer.database();
        return Promise.all([
            db.insert('repositories', {id: 11, name: 'WebKit', url: 'https://trac.webkit.org/$1'}),
            db.insert('repositories', {id: 9, name: 'macOS'}),
            db.insert('repositories', {id: 16, name: 'Shared'}),
            db.insert('repositories', {id: 101, name: 'WebKit', owner: 9, url: 'https://trac.webkit.org/$1'}),
            db.insert('build_triggerables', {id: 200, name: 'build.webkit.org'}),
            db.insert('build_triggerables', {id: 201, name: 'ios-build.webkit.org'}),
            db.insert('build_triggerables', {id: 202, name: 'mac-build.webkit.org', disabled: true}),
            db.insert('tests', {id: 1, name: 'SomeTest'}),
            db.insert('tests', {id: 2, name: 'SomeOtherTest'}),
            db.insert('tests', {id: 3, name: 'ChildTest', parent: 1}),
            db.insert('platforms', {id: 23, name: 'iOS 9 iPhone 5s'}),
            db.insert('platforms', {id: 46, name: 'Trunk Mavericks'}),
            db.insert('platforms', {id: 104, name: 'Trunk Sierra MacBookPro11,2'}),
            db.insert('test_metrics', {id: 5, test: 1, name: 'Time'}),
            db.insert('test_metrics', {id: 8, test: 2, name: 'FrameRate'}),
            db.insert('test_metrics', {id: 9, test: 3, name: 'Time'}),
            db.insert('test_configurations', {id: 101, metric: 5, platform: 46, type: 'current'}),
            db.insert('test_configurations', {id: 102, metric: 8, platform: 46, type: 'current'}),
            db.insert('test_configurations', {id: 103, metric: 9, platform: 46, type: 'current'}),
            db.insert('test_configurations', {id: 104, metric: 5, platform: 23, type: 'current'}),
            db.insert('test_configurations', {id: 105, metric: 8, platform: 23, type: 'current'}),
            db.insert('test_configurations', {id: 106, metric: 9, platform: 23, type: 'current'}),
            db.insert('test_configurations', {id: 107, metric: 5, platform: 104, type: 'current'}),
            db.insert('test_configurations', {id: 108, metric: 8, platform: 104, type: 'current'}),
            db.insert('test_configurations', {id: 109, metric: 9, platform: 104, type: 'current'}),
            db.insert('triggerable_repository_groups', {id: 300, triggerable: 200, name: 'default'}),
            db.insert('triggerable_repository_groups', {id: 301, triggerable: 201, name: 'default'}),
            db.insert('triggerable_repository_groups', {id: 302, triggerable: 202, name: 'system-and-webkit'}),
            db.insert('triggerable_repository_groups', {id: 303, triggerable: 202, name: 'system-and-roots', accepts_roots: true}),
            db.insert('triggerable_repository_groups', {id: 304, triggerable: 202, name: 'webkit-and-shared', hidden: true}),
            db.insert('triggerable_repositories', {group: 300, repository: 11}),
            db.insert('triggerable_repositories', {group: 301, repository: 11}),
            db.insert('triggerable_repositories', {group: 302, repository: 11}),
            db.insert('triggerable_repositories', {group: 304, repository: 11}),
            db.insert('triggerable_repositories', {group: 302, repository: 9}),
            db.insert('triggerable_repositories', {group: 303, repository: 9}),
            db.insert('triggerable_repositories', {group: 304, repository: 16}),
            db.insert('triggerable_configurations', {id: 1, triggerable: 200, test: 1, platform: 46}),
            db.insert('triggerable_configuration_repetition_types', {config: 1, type: 'alternating'}),
            db.insert('triggerable_configuration_repetition_types', {config: 1, type: 'sequential'}),
            db.insert('triggerable_configurations', {id: 2, triggerable: 200, test: 2, platform: 46}),
            db.insert('triggerable_configuration_repetition_types', {config: 2, type: 'alternating'}),
            db.insert('triggerable_configuration_repetition_types', {config: 2, type: 'sequential'}),
            db.insert('triggerable_configurations', {id: 3, triggerable: 201, test: 1, platform: 23}),
            db.insert('triggerable_configuration_repetition_types', {config: 3, type: 'alternating'}),
            db.insert('triggerable_configuration_repetition_types', {config: 3, type: 'sequential'}),
            db.insert('triggerable_configurations', {id: 4, triggerable: 201, test: 2, platform: 23}),
            db.insert('triggerable_configuration_repetition_types', {config: 4, type: 'alternating'}),
            db.insert('triggerable_configuration_repetition_types', {config: 4, type: 'sequential'}),
            db.insert('triggerable_configurations', {id: 5, triggerable: 202, test: 1, platform: 104}),
            db.insert('triggerable_configuration_repetition_types', {config: 5, type: 'alternating'}),
            db.insert('triggerable_configuration_repetition_types', {config: 5, type: 'sequential'}),
            db.insert('triggerable_configurations', {id: 6, triggerable: 202, test: 2, platform: 104}),
            db.insert('triggerable_configuration_repetition_types', {config: 6, type: 'alternating'}),
            db.insert('triggerable_configuration_repetition_types', {config: 6, type: 'sequential'}),
        ]).then(() => {
            return Manifest.fetch();
        }).then(() => {
            const webkit = Repository.findById(11);
            assert.strictEqual(webkit.name(), 'WebKit');
            assert.strictEqual(webkit.urlForRevision(123), 'https://trac.webkit.org/123');

            const osWebkit1 = Repository.findById(101);
            assert.strictEqual(osWebkit1.name(), 'WebKit');
            assert.strictEqual(parseInt(osWebkit1.ownerId()), 9);
            assert.strictEqual(osWebkit1.urlForRevision(123), 'https://trac.webkit.org/123');

            const macos = Repository.findById(9);
            assert.strictEqual(macos.name(), 'macOS');

            const shared = Repository.findById(16);
            assert.strictEqual(shared.name(), 'Shared');

            const someTest = Test.findById(1);
            assert.strictEqual(someTest.name(), 'SomeTest');

            const someOtherTest = Test.findById(2);
            assert.strictEqual(someOtherTest.name(), 'SomeOtherTest');

            const childTest = Test.findById(3);
            assert.strictEqual(childTest.name(), 'ChildTest');

            const ios9iphone5s = Platform.findById(23);
            assert.strictEqual(ios9iphone5s.name(), 'iOS 9 iPhone 5s');

            const mavericks = Platform.findById(46);
            assert.strictEqual(mavericks.name(), 'Trunk Mavericks');

            const sierra = Platform.findById(104);
            assert.strictEqual(sierra.name(), 'Trunk Sierra MacBookPro11,2');

            assert.strictEqual(Triggerable.all().length, 3);

            const macosTriggerable = Triggerable.findByTestConfiguration(someTest, mavericks);
            assert.strictEqual(macosTriggerable.name(), 'build.webkit.org');

            assert.strictEqual(Triggerable.findByTestConfiguration(someOtherTest, mavericks), macosTriggerable);
            assert.strictEqual(Triggerable.findByTestConfiguration(childTest, mavericks), macosTriggerable);

            const iosTriggerable = Triggerable.findByTestConfiguration(someOtherTest, ios9iphone5s);
            assert.notStrictEqual(iosTriggerable, macosTriggerable);
            assert.strictEqual(iosTriggerable.name(), 'ios-build.webkit.org');

            assert.strictEqual(Triggerable.findByTestConfiguration(someOtherTest, ios9iphone5s), iosTriggerable);
            assert.strictEqual(Triggerable.findByTestConfiguration(childTest, ios9iphone5s), iosTriggerable);

            const macTriggerable = Triggerable.findByTestConfiguration(someTest, sierra);
            assert.strictEqual(macTriggerable.name(), 'mac-build.webkit.org');
            assert(macTriggerable.acceptedTests().has(someTest));

            const groups = macTriggerable.repositoryGroups();
            assert.deepStrictEqual(groups.length, 3);
            TriggerableRepositoryGroup.sortByName(groups);

            const emptyCustomSet = new CustomCommitSet;

            const customSetWithOSX = new CustomCommitSet;
            customSetWithOSX.setRevisionForRepository(macos, '10.11 15A284');

            const cusomSetWithOSXAndWebKit = new CustomCommitSet;
            cusomSetWithOSXAndWebKit.setRevisionForRepository(webkit, '191622');
            cusomSetWithOSXAndWebKit.setRevisionForRepository(macos, '10.11 15A284');

            const cusomSetWithWebKit = new CustomCommitSet;
            cusomSetWithWebKit.setRevisionForRepository(webkit, '191622');

            const cusomSetWithWebKitAndShared = new CustomCommitSet;
            cusomSetWithWebKitAndShared.setRevisionForRepository(webkit, '191622');
            cusomSetWithWebKitAndShared.setRevisionForRepository(shared, '86456');

            assert.strictEqual(groups[0].name(), 'system-and-roots');
            assert.strictEqual(groups[0].isHidden(), false);
            assert.strictEqual(groups[0].acceptsCustomRoots(), true);
            assert.deepStrictEqual(Repository.sortByName(groups[0].repositories()), [macos]);
            assert.strictEqual(groups[0].accepts(emptyCustomSet), false);
            assert.strictEqual(groups[0].accepts(customSetWithOSX), true);
            assert.strictEqual(groups[0].accepts(cusomSetWithOSXAndWebKit), false);
            assert.strictEqual(groups[0].accepts(cusomSetWithWebKitAndShared), false);
            assert.strictEqual(groups[0].accepts(cusomSetWithWebKit), false);

            assert.strictEqual(groups[1].name(), 'system-and-webkit');
            assert.strictEqual(groups[1].isHidden(), false);
            assert.strictEqual(groups[1].acceptsCustomRoots(), false);
            assert.deepStrictEqual(Repository.sortByName(groups[1].repositories()), [webkit, macos]);
            assert.strictEqual(groups[1].accepts(emptyCustomSet), false);
            assert.strictEqual(groups[1].accepts(customSetWithOSX), false);
            assert.strictEqual(groups[1].accepts(cusomSetWithOSXAndWebKit), true);
            assert.strictEqual(groups[1].accepts(cusomSetWithWebKitAndShared), false);
            assert.strictEqual(groups[1].accepts(cusomSetWithWebKit), false);

            assert.strictEqual(groups[2].name(), 'webkit-and-shared');
            assert.strictEqual(groups[2].isHidden(), true);
            assert.strictEqual(groups[2].acceptsCustomRoots(), false);
            assert.deepStrictEqual(Repository.sortByName(groups[2].repositories()), [shared, webkit]);
            assert.strictEqual(groups[2].accepts(emptyCustomSet), false);
            assert.strictEqual(groups[2].accepts(customSetWithOSX), false);
            assert.strictEqual(groups[2].accepts(cusomSetWithOSXAndWebKit), false);
            assert.strictEqual(groups[2].accepts(cusomSetWithWebKitAndShared), true);
            assert.strictEqual(groups[2].accepts(cusomSetWithWebKit), false);
        });
    });

});