"use strict";

const assert = require('assert');
require('../tools/js/v3-models.js');
const BrowserPrivilegedAPI = require('../public/v3/privileged-api.js').PrivilegedAPI;
const MockModels = require('./resources/mock-v3-models.js').MockModels;
const MockRemoteAPI = require('../unit-tests/resources/mock-remote-api.js').MockRemoteAPI;

function createPatch()
{
    return UploadedFile.ensureSingleton(453, {'createdAt': new Date('2017-05-01T19:16:53Z'), 'filename': 'patch.dat', 'extension': '.dat', 'author': 'some user',
        size: 534637, sha256: '169463c8125e07c577110fe144ecd63942eb9472d438fc0014f474245e5df8a1'});
}

function createAnotherPatch()
{
    return UploadedFile.ensureSingleton(454, {'createdAt': new Date('2017-05-01T19:16:53Z'), 'filename': 'patch.dat', 'extension': '.dat', 'author': 'some user',
        size: 534611, sha256: '169463c8125e07c577110fe144ecd63942eb9472d438fc0014f474245e5dfaaa'});
}

function createRoot()
{
    return UploadedFile.ensureSingleton(456, {'createdAt': new Date('2017-05-01T21:03:27Z'), 'filename': 'root.dat', 'extension': '.dat', 'author': 'some user',
        size: 16452234, sha256: '03eed7a8494ab8794c44b7d4308e55448fc56f4d6c175809ba968f78f656d58d'});
}

function createAnotherRoot()
{
    return UploadedFile.ensureSingleton(457, {'createdAt': new Date('2017-05-01T21:03:27Z'), 'filename': 'root.dat', 'extension': '.dat', 'author': 'some user',
        size: 16452111, sha256: '03eed7a8494ab8794c44b7d4308e55448fc56f4d6c175809ba968f78f656dbbb'});
}

function createSharedRoot()
{
    return UploadedFile.ensureSingleton(458, {'createdAt': new Date('2017-05-01T22:03:27Z'), 'filename': 'root.dat', 'extension': '.dat', 'author': 'some user',
        size: 16452111, sha256: '03eed7a8494ab8794c44b7d4308e55448fc56f4aac175809ba968f78f656dbbb'});
}

function customCommitSetWithoutOwnedCommit()
{
    const customCommitSet = new CustomCommitSet;
    customCommitSet.setRevisionForRepository(MockModels.osx, '10.11.4 15E65');
    customCommitSet.setRevisionForRepository(MockModels.webkit, '200805');
    return customCommitSet;
}

function customCommitSetWithOwnedCommit()
{
    const customCommitSet = new CustomCommitSet;
    customCommitSet.setRevisionForRepository(MockModels.osx, '10.11.4 15E65');
    customCommitSet.setRevisionForRepository(MockModels.ownerRepository, 'OwnerRepository-r0');
    customCommitSet.setRevisionForRepository(MockModels.ownedRepository, 'OwnedRepository-r0', null, 'OwnerRepository-r0');
    return customCommitSet;
}

function customCommitSetWithPatch()
{
    const customCommitSet = new CustomCommitSet;
    const patch = createPatch();
    customCommitSet.setRevisionForRepository(MockModels.osx, '10.11.4 15E65');
    customCommitSet.setRevisionForRepository(MockModels.webkit, '200805', patch);
    return customCommitSet;
}

function customCommitSetWithOwnedRepositoryHasSameNameAsNotOwnedRepository()
{
    const customCommitSet = new CustomCommitSet;
    customCommitSet.setRevisionForRepository(MockModels.osx, '10.11.4 15E65');
    customCommitSet.setRevisionForRepository(MockModels.webkit, '200805');
    customCommitSet.setRevisionForRepository(MockModels.ownedWebkit, 'owned-200805', null, '10.11.4 15E65');
    return customCommitSet;
}

function ownerCommit()
{
    return CommitLog.ensureSingleton(5, {
        id: 5,
        repository: MockModels.ownerRepository,
        revision: 'owner-commit-0',
        ownsCommits: true,
        time: null,
    });
}

function partialOwnerCommit()
{
    return CommitLog.ensureSingleton(5, {
        id: 5,
        repository: MockModels.ownerRepository,
        revision: 'owner-commit-0',
        ownsCommits: null,
        time: +(new Date('2016-05-13T00:55:57.841344Z')),
    });
}

function ownedCommit()
{
    return new CommitLog(6, {
        id: 6,
        repository: MockModels.ownedRepository,
        revision: 'owned-commit-0',
        ownsCommits: null,
        time: 1456932774000
    });
}

function webkitCommit()
{
    return CommitLog.ensureSingleton(2017, {
        id: 2017,
        repository: MockModels.webkit,
        revision: 'webkit-commit-0',
        ownsCommits: false,
        time: 1456932773000
    });
}

function anotherWebKitCommit()
{
    return CommitLog.ensureSingleton(2018, {
        id: 2018,
        repository: MockModels.webkit,
        revision: 'webkit-commit-1',
        ownsCommits: false,
        time: 1456932773000
    });
}

function commitWithSVNRevision()
{
    return CommitLog.ensureSingleton(2019, {
        id: 2019,
        repository: MockModels.webkit,
        revision: '12345',
        ownsCommits: false,
        time: 1456932773000
    });
}

function anotherCommitWithSVNRevision()
{
    return CommitLog.ensureSingleton(2020, {
        id: 2020,
        repository: MockModels.webkit,
        revision: '45678',
        ownsCommits: false,
        time: 1456932773000
    });
}

function commitWithGitRevision()
{
    return CommitLog.ensureSingleton(2021, {
        id: 2021,
        repository: MockModels.webkitGit,
        revision: '13a0590d34f26fda3953c42ff833132a1a6f6f5a',
        ownsCommits: false,
        time: 1456932773000
    });
}

function anotherCommitWithGitRevision()
{
    return CommitLog.ensureSingleton(2022, {
        id: 2022,
        repository: MockModels.webkitGit,
        revision: '2f8dd3321d4f51c04f4e2019428ce9ffe97f1ef1',
        ownsCommits: false,
        time: 1456932773000
    });
}

function commitWithTestability()
{
    return CommitLog.ensureSingleton(2023, {
        id: 2023,
        repository: MockModels.webkitGit,
        revision: 'f24fc67873a0068fd5a3a9adac595f0036c21315',
        ownsCommits: false,
        time: 1456932773000,
        testability: 'Failed compilation'
    });
}

describe('CommitSet', () => {
    MockRemoteAPI.inject(null, BrowserPrivilegedAPI);
    MockModels.inject();

    function oneCommitSet()
    {
        return CommitSet.ensureSingleton(1, {
            revisionItems: [{ commit: webkitCommit(), requiresBuild: false }],
            customRoots: []
        });
    }

    function anotherCommitSet()
    {
        return CommitSet.ensureSingleton(2, {
            revisionItems: [{ commit: webkitCommit(), requiresBuild: false }],
            customRoots: []
        });
    }

    function commitSetWithPatch()
    {
        return CommitSet.ensureSingleton(3, {
            revisionItems: [{ commit: webkitCommit(), requiresBuild: false, patch: createPatch() }],
            customRoots: []
        });
    }

    function commitSetWithAnotherPatch()
    {
        return CommitSet.ensureSingleton(4, {
            revisionItems: [{ commit: webkitCommit(), requiresBuild: false, patch: createAnotherPatch() }],
            customRoots: []
        });
    }

    function commitSetWithRoot()
    {
        return CommitSet.ensureSingleton(5, {
            revisionItems: [{ commit: webkitCommit(), requiresBuild: false }],
            customRoots: [createRoot()]
        });
    }

    function anotherCommitSetWithRoot()
    {
        return CommitSet.ensureSingleton(6, {
            revisionItems: [{ commit: webkitCommit(), requiresBuild: false }],
            customRoots: [createAnotherRoot()]
        });
    }

    function commitSetWithTwoRoots()
    {
        return CommitSet.ensureSingleton(7, {
            revisionItems: [{ commit: webkitCommit(), requiresBuild: false }],
            customRoots: [createRoot(), createSharedRoot()]
        });
    }

    function commitSetWithAnotherWebKitCommit()
    {
        return CommitSet.ensureSingleton(8, {
            revisionItems: [{ commit: anotherWebKitCommit(), requiresBuild: false }],
            customRoots: []
        });
    }

    function commitSetWithAnotherCommitPatchAndRoot()
    {
        return CommitSet.ensureSingleton(9, {
            revisionItems: [{ commit: anotherWebKitCommit(), requiresBuild: true, patch: createPatch()}],
            customRoots: [createRoot(), createSharedRoot()]
        });
    }

    function commitSetWithSVNCommit()
    {
        return CommitSet.ensureSingleton(10, {
            revisionItems: [{ commit: commitWithSVNRevision(), requiresBuild: false }],
            customRoots: []
        });
    }

    function anotherCommitSetWithSVNCommit()
    {
        return CommitSet.ensureSingleton(11, {
            revisionItems: [{ commit: anotherCommitWithSVNRevision(), requiresBuild: false }],
            customRoots: []
        });
    }

    function commitSetWithGitCommit()
    {
        return CommitSet.ensureSingleton(12, {
            revisionItems: [{ commit: commitWithGitRevision(), requiresBuild: false }],
            customRoots: []
        });
    }

    function anotherCommitSetWithGitCommit()
    {
        return CommitSet.ensureSingleton(13, {
            revisionItems: [{ commit: anotherCommitWithGitRevision(), requiresBuild: false }],
            customRoots: []
        });
    }

    function commitSetWithTwoCommits()
    {
        return CommitSet.ensureSingleton(14, {
            revisionItems: [{ commit: commitWithGitRevision(), requiresBuild: false }, { commit: commitWithSVNRevision(), requiresBuild: false }],
            customRoots: []
        });
    }

    function anotherCommitSetWithTwoCommits()
    {
        return CommitSet.ensureSingleton(15, {
            revisionItems: [{ commit: anotherCommitWithGitRevision(), requiresBuild: false }, { commit: anotherCommitWithSVNRevision(), requiresBuild: false }],
            customRoots: []
        });
    }

    function commitSetWithTestability()
    {
        return CommitSet.ensureSingleton(16, {
            revisionItems: [{ commit: commitWithTestability(), requiresBuild: false },
                { commit: webkitCommit(), requiresBuild: false }],
            customRoots: []
        });
    }

    function oneMeasurementCommitSet()
    {
        return MeasurementCommitSet.ensureSingleton(1, [
            [2017, 11, 'webkit-commit-0', null, 1456932773000]
        ]);
    }

    describe('equals', () => {
        it('should return false if patches for same repository are different', () => {
            assert(!commitSetWithPatch().equals(commitSetWithAnotherPatch()));
            assert(!commitSetWithAnotherPatch().equals(commitSetWithPatch()));
        });

        it('should return false if patch is only specified in one commit set', () => {
            assert(!oneCommitSet().equals(commitSetWithPatch()));
            assert(!commitSetWithPatch().equals(oneCommitSet()));
        });

        it('should return false if roots for same repository are different', () => {
            assert(!commitSetWithRoot().equals(anotherCommitSetWithRoot()));
            assert(!anotherCommitSetWithRoot().equals(commitSetWithRoot()));
        });

        it('should return false if root is only specified in one commit set', () => {
            assert(!commitSetWithRoot().equals(oneCommitSet()));
            assert(!oneCommitSet().equals(commitSetWithRoot()));
        });

        it('should return true when comparing two identical commit set', () => {
            assert(oneCommitSet().equals(oneCommitSet()));
            assert(anotherCommitSet().equals(anotherCommitSet()));
            assert(commitSetWithPatch().equals(commitSetWithPatch()));
            assert(commitSetWithAnotherPatch().equals(commitSetWithAnotherPatch()));
            assert(oneMeasurementCommitSet().equals(oneMeasurementCommitSet()));
            assert(commitSetWithRoot().equals(commitSetWithRoot()));
            assert(anotherCommitSetWithRoot().equals(anotherCommitSetWithRoot()));
        });

        it('should be able to compare between CommitSet and MeasurementCommitSet', () => {
            assert(oneCommitSet().equals(oneMeasurementCommitSet()));
            assert(oneMeasurementCommitSet().equals(oneCommitSet()));
        });
    });

    describe('containsRootOrPatchOrOwnedCommit', () => {
        it('should return false if commit does not contain root, patch or owned commit', () => {
            assert.ok(!oneCommitSet().containsRootOrPatchOrOwnedCommit());
            assert.ok(!anotherCommitSet().containsRootOrPatchOrOwnedCommit());
            assert.ok(!commitSetWithAnotherWebKitCommit().containsRootOrPatchOrOwnedCommit());
            assert.ok(!commitSetWithSVNCommit().containsRootOrPatchOrOwnedCommit());
            assert.ok(!anotherCommitSetWithSVNCommit().containsRootOrPatchOrOwnedCommit());
            assert.ok(!commitSetWithGitCommit().containsRootOrPatchOrOwnedCommit());
            assert.ok(!anotherCommitSetWithGitCommit().containsRootOrPatchOrOwnedCommit());
            assert.ok(!commitSetWithTwoCommits().containsRootOrPatchOrOwnedCommit());
            assert.ok(!anotherCommitSetWithTwoCommits().containsRootOrPatchOrOwnedCommit());
            assert.ok(!oneMeasurementCommitSet().containsRootOrPatchOrOwnedCommit());
        });

        it('should return true if commit contains root, patch or owned commit', () => {
            assert.ok(commitSetWithPatch().containsRootOrPatchOrOwnedCommit());
            assert.ok(commitSetWithAnotherPatch().containsRootOrPatchOrOwnedCommit());
            assert.ok(commitSetWithRoot().containsRootOrPatchOrOwnedCommit());
            assert.ok(anotherCommitSetWithRoot().containsRootOrPatchOrOwnedCommit());
            assert.ok(commitSetWithTwoRoots().containsRootOrPatchOrOwnedCommit());
            assert.ok(commitSetWithAnotherCommitPatchAndRoot().containsRootOrPatchOrOwnedCommit());
        });
    });

    describe('hasSameRepositories', () => {
        it('should return true if two commit sets have same repositories', () => {
            assert.ok(oneCommitSet().hasSameRepositories(anotherCommitSet()));
            assert.ok(commitSetWithGitCommit().hasSameRepositories(anotherCommitSetWithGitCommit()));
            assert.ok(oneCommitSet().hasSameRepositories(oneCommitSet()));
        });

        it('should return false if two commit sets have differen repositories', () => {
            assert.ok(!commitSetWithGitCommit().hasSameRepositories(commitSetWithSVNCommit()));
            assert.ok(!commitSetWithTwoCommits().hasSameRepositories(commitSetWithGitCommit()));
        });
    });

    describe('diff',  () => {
        it('should describe patch difference', () => {
            assert.equal(CommitSet.diff(commitSetWithPatch(), commitSetWithAnotherPatch()), 'WebKit: patch.dat - patch.dat (2)');
        });

        it('should describe root difference', () => {
            assert.equal(CommitSet.diff(commitSetWithRoot(), anotherCommitSetWithRoot()), 'Roots: root.dat - root.dat (2)');
            assert.equal(CommitSet.diff(commitSetWithRoot(), commitSetWithTwoRoots()), 'Roots: none - root.dat');
            assert.equal(CommitSet.diff(commitSetWithTwoRoots(), oneCommitSet()), 'Roots: root.dat, root.dat (2) - none');
        });

        it('should describe commit difference', () => {
            assert.equal(CommitSet.diff(oneCommitSet(), commitSetWithAnotherWebKitCommit()), 'WebKit: webkit-commit-0 - webkit-commit-1');
            assert.equal(CommitSet.diff(commitSetWithSVNCommit(), anotherCommitSetWithSVNCommit()), 'WebKit: r12345-r45678');
            assert.equal(CommitSet.diff(commitSetWithGitCommit(), anotherCommitSetWithGitCommit()), 'WebKit-Git: 13a0590d34f2..2f8dd3321d4f');
            assert.equal(CommitSet.diff(commitSetWithTwoCommits(), anotherCommitSetWithTwoCommits()), 'WebKit: r12345-r45678 WebKit-Git: 13a0590d34f2..2f8dd3321d4f');
        });

        it('should describe commit root and patch difference', () => {
            assert.equal(CommitSet.diff(oneCommitSet(), commitSetWithAnotherCommitPatchAndRoot()), 'WebKit: webkit-commit-0 with none - webkit-commit-1 with patch.dat Roots: none - root.dat, root.dat (2)');
        });
    });

    describe('revisionSetsFromCommitSets', () => {
        it('should create revision sets from commit sets', () => {
            assert.deepEqual(CommitSet.revisionSetsFromCommitSets([oneCommitSet(), commitSetWithRoot(), commitSetWithTwoRoots()]),
                [{'11': { revision: 'webkit-commit-0', ownerRevision: null, patch: null}},
                    {'11': { revision: 'webkit-commit-0', ownerRevision: null, patch: null}, customRoots: [456]},
                    {'11': { revision: 'webkit-commit-0', ownerRevision: null, patch: null}, customRoots: [456, 458]}]);
        });
    });

    describe('commitsWithTestability', () => {
        it('should return commits with testability', () => {
            const commits = commitSetWithTestability().commitsWithTestability();
            assert.equal(commits.length, 1);
            assert.equal(commits[0], commitWithTestability());
        });

        it('should return empty list if no commit in commit set contains testability', () => {
            const commits = commitSetWithTwoCommits().commitsWithTestability();
            assert.equal(commits.length, 0);
        });
    });

    describe('commits', () => {
        it('should return all commits in commit set', () => {
            assert.equal(commitSetWithTwoCommits().commits().length, 2);
        });
    });
});

describe('IntermediateCommitSet', () => {
    MockRemoteAPI.inject(null, BrowserPrivilegedAPI);
    MockModels.inject();

    describe('setCommitForRepository', () => {
        it('should allow set commit for owner repository', () => {
            const commitSet = new IntermediateCommitSet(new CommitSet);
            const commit = ownerCommit();
            commitSet.setCommitForRepository(MockModels.ownerRepository, commit);
            assert.equal(commit, commitSet.commitForRepository(MockModels.ownerRepository));
        });

        it('should allow set commit for owned repository', () => {
            const commitSet = new IntermediateCommitSet(new CommitSet);
            const commit = ownerCommit();

            const fetchingPromise = commit.fetchOwnedCommits();
            const requests = MockRemoteAPI.requests;
            assert.equal(requests.length, 1);
            assert.equal(requests[0].url, '../api/commits/111/owned-commits?owner-revision=owner-commit-0');
            assert.equal(requests[0].method, 'GET');

            requests[0].resolve({commits: [{
                id: 233,
                repository: MockModels.ownedRepository.id(),
                revision: '6f8b0dbbda95a440503b88db1dd03dad3a7b07fb',
                time: +(new Date('2016-05-13T00:55:57.841344Z')),
            }]});

            return fetchingPromise.then(() => {
                const ownedCommit = commit.ownedCommits()[0];
                commitSet.setCommitForRepository(MockModels.ownerRepository, commit);
                commitSet.setCommitForRepository(MockModels.ownedRepository, ownedCommit);
                assert.equal(commit, commitSet.commitForRepository(MockModels.ownerRepository));
                assert.equal(ownedCommit, commitSet.commitForRepository(MockModels.ownedRepository));
                assert.deepEqual(commitSet.repositories(), [MockModels.ownerRepository, MockModels.ownedRepository]);
            });
        });
    });

    describe('fetchCommitLogs', () => {

        it('should fetch CommitLog object with owned commits information',  () => {
            const commit = partialOwnerCommit();
            assert.equal(commit.ownsCommits(), null);
            const owned = ownedCommit();

            const commitSet = CommitSet.ensureSingleton('53246456', {revisionItems: [{commit}, {commit: owned, ownerCommit: commit}]});
            const intermediateCommitSet = new IntermediateCommitSet(commitSet);
            const fetchingPromise = intermediateCommitSet.fetchCommitLogs();

            const requests = MockRemoteAPI.requests;
            assert.equal(requests.length, 2);
            assert.equal(requests[0].url, '/api/commits/111/owner-commit-0?prefix-match=true');
            assert.equal(requests[0].method, 'GET');
            assert.equal(requests[1].url, '/api/commits/112/owned-commit-0?prefix-match=true');
            assert.equal(requests[1].method, 'GET');

            requests[0].resolve({commits: [{
                id: 5,
                repository: MockModels.ownerRepository.id(),
                revision: 'owner-commit-0',
                ownsCommits: true,
                time: +(new Date('2016-05-13T00:55:57.841344Z')),
            }]});
            requests[1].resolve({commits: [{
                id: 6,
                repository: MockModels.ownedRepository.id(),
                revision: 'owned-commit-0',
                ownsCommits: false,
                time: 1456932774000,
            }]});

            return MockRemoteAPI.waitForRequest().then(() => {
                assert.equal(requests.length, 3);
                assert.equal(requests[2].url, '../api/commits/111/owned-commits?owner-revision=owner-commit-0');
                assert.equal(requests[2].method, 'GET');

                requests[2].resolve({commits: [{
                    id: 6,
                    repository: MockModels.ownedRepository.id(),
                    revision: 'owned-commit-0',
                    ownsCommits: false,
                    time: 1456932774000,
                }]});
                return fetchingPromise;
            }).then(() => {
                assert(commit.ownsCommits());
                assert.equal(commit.ownedCommits().length, 1);
                assert.equal(commit.ownedCommits()[0], owned);
                assert.equal(owned.ownerCommit(), commit);
                assert.equal(owned.repository(), MockModels.ownedRepository);
                assert.equal(intermediateCommitSet.commitForRepository(MockModels.ownedRepository), owned);
                assert.equal(intermediateCommitSet.ownerCommitForRepository(MockModels.ownedRepository), commit);
                assert.deepEqual(intermediateCommitSet.repositories(), [MockModels.ownerRepository, MockModels.ownedRepository]);
            });
        });
    });

    describe('updateRevisionForOwnerRepository', () => {

        it('should update CommitSet based on the latest invocation', () => {
            const commitSet = new IntermediateCommitSet(new CommitSet);
            const firstUpdatePromise = commitSet.updateRevisionForOwnerRepository(MockModels.webkit, 'webkit-commit-0');
            const secondUpdatePromise = commitSet.updateRevisionForOwnerRepository(MockModels.webkit, 'webkit-commit-1');
            const requests = MockRemoteAPI.requests;

            assert(requests.length, 2);
            assert.equal(requests[0].url, '/api/commits/11/webkit-commit-0?prefix-match=true');
            assert.equal(requests[0].method, 'GET');
            assert.equal(requests[1].url, '/api/commits/11/webkit-commit-1?prefix-match=true');
            assert.equal(requests[1].method, 'GET');

            requests[1].resolve({commits: [{
                id: 2018,
                repository: MockModels.webkit.id(),
                revision: 'webkit-commit-1',
                ownsCommits: false,
                time: 1456932774000,
            }]});

            let commit = null;
            return secondUpdatePromise.then(() => {
                commit = commitSet.commitForRepository(MockModels.webkit);

                requests[0].resolve({commits: [{
                    id: 2017,
                    repository: MockModels.webkit.id(),
                    revision: 'webkit-commit-0',
                    ownsCommits: false,
                    time: 1456932773000,
                }]});

                assert.equal(commit.revision(), 'webkit-commit-1');
                assert.equal(commit.id(), 2018);

                return firstUpdatePromise;
            }).then(() => {
                const currentCommit = commitSet.commitForRepository(MockModels.webkit);
                assert.equal(commit, currentCommit);
            });
        });

    });

    describe('removeCommitForRepository', () => {
        it('should remove owned commits when owner commit is removed', () => {
            const commitSet = new IntermediateCommitSet(new CommitSet);
            const commit = ownerCommit();

            const fetchingPromise = commit.fetchOwnedCommits();
            const requests = MockRemoteAPI.requests;
            assert.equal(requests.length, 1);
            assert.equal(requests[0].url, '../api/commits/111/owned-commits?owner-revision=owner-commit-0');
            assert.equal(requests[0].method, 'GET');

            requests[0].resolve({commits: [{
                id: 233,
                repository: MockModels.ownedRepository.id(),
                revision: '6f8b0dbbda95a440503b88db1dd03dad3a7b07fb',
                ownsCommits: true
            }]});

            return fetchingPromise.then(() => {
                commitSet.setCommitForRepository(MockModels.ownerRepository, commit);
                commitSet.setCommitForRepository(MockModels.ownedRepository, commit.ownedCommits()[0]);
                commitSet.removeCommitForRepository(MockModels.ownerRepository);
                assert.deepEqual(commitSet.repositories(), []);
            });
        });

        it('should not remove owner commits when owned commit is removed', () => {
            const commitSet = new IntermediateCommitSet(new CommitSet);
            const commit = ownerCommit();

            const fetchingPromise = commit.fetchOwnedCommits();
            const requests = MockRemoteAPI.requests;
            assert.equal(requests.length, 1);
            assert.equal(requests[0].url, '../api/commits/111/owned-commits?owner-revision=owner-commit-0');
            assert.equal(requests[0].method, 'GET');

            requests[0].resolve({commits: [{
                id: 233,
                repository: MockModels.ownedRepository.id(),
                revision: '6f8b0dbbda95a440503b88db1dd03dad3a7b07fb',
                time: +(new Date('2016-05-13T00:55:57.841344Z')),
            }]});

            return fetchingPromise.then(() => {
                commitSet.setCommitForRepository(MockModels.ownerRepository, commit);
                commitSet.setCommitForRepository(MockModels.ownedRepository, commit.ownedCommits()[0]);
                commitSet.removeCommitForRepository(MockModels.ownedRepository);
                assert.deepEqual(commitSet.repositories(), [MockModels.ownerRepository]);
            });
        });

        it('should not update commit set for repository if removeCommitForRepository called before updateRevisionForOwnerRepository finishes', () => {
            const commitSet = new IntermediateCommitSet(new CommitSet);
            const commit = webkitCommit();
            commitSet.setCommitForRepository(MockModels.webkit, commit);
            const updatePromise = commitSet.updateRevisionForOwnerRepository(MockModels.webkit, 'webkit-commit-1');

            commitSet.removeCommitForRepository(MockModels.webkit);

            const requests = MockRemoteAPI.requests;
            assert.equal(requests[0].url, '/api/commits/11/webkit-commit-1?prefix-match=true');
            assert.equal(requests[0].method, 'GET');

            requests[0].resolve({commits: [{
                id: 2018,
                repository: MockModels.webkit.id(),
                revision: 'webkit-commit-1',
                ownsCommits: false,
                time: 1456932774000,
            }]});

            return updatePromise.then(() => {
                assert.deepEqual(commitSet.repositories(), []);
                assert(!commitSet.commitForRepository(MockModels.webkit));
            });
        });
    });
});

describe('CustomCommitSet', () => {
    MockModels.inject();

    describe('Test custom commit set without owned commit', () => {
        it('should have right revision for a given repository', () => {
            const commitSet = customCommitSetWithoutOwnedCommit();
            assert.equal(commitSet.revisionForRepository(MockModels.osx), '10.11.4 15E65');
            assert.equal(commitSet.revisionForRepository(MockModels.webkit), '200805');
        });

        it('should have no patch for any repository', () => {
            const commitSet = customCommitSetWithoutOwnedCommit();
            assert.equal(commitSet.patchForRepository(MockModels.osx), null);
            assert.equal(commitSet.patchForRepository(MockModels.webkit), null);
        });

        it('should have no owner revision for a given repository', () => {
            const commitSet = customCommitSetWithoutOwnedCommit();
            assert.equal(commitSet.ownerRevisionForRepository(MockModels.osx), null);
            assert.equal(commitSet.ownerRevisionForRepository(MockModels.webkit), null);
        });

        it('should return all repositories in it', () => {
            const commitSet = customCommitSetWithoutOwnedCommit();
            assert.deepEqual(commitSet.repositories(), [MockModels.osx, MockModels.webkit]);
        });

        it('should return only top level repositories', () => {
            const commitSet = customCommitSetWithoutOwnedCommit();
            assert.deepEqual(commitSet.topLevelRepositories(), [MockModels.osx, MockModels.webkit]);
        });
    });

    describe('Test custom commit set with owned commit', () => {
        it('should have right revision for a given repository', () => {
            const commitSet = customCommitSetWithOwnedCommit();
            assert.equal(commitSet.revisionForRepository(MockModels.osx), '10.11.4 15E65');
            assert.equal(commitSet.revisionForRepository(MockModels.ownerRepository), 'OwnerRepository-r0');
            assert.equal(commitSet.revisionForRepository(MockModels.ownedRepository), 'OwnedRepository-r0');
        });

        it('should have no patch for any repository', () => {
            const commitSet = customCommitSetWithOwnedCommit();
            assert.equal(commitSet.patchForRepository(MockModels.osx), null);
            assert.equal(commitSet.patchForRepository(MockModels.ownerRepository), null);
            assert.equal(commitSet.patchForRepository(MockModels.ownedRepository), null);
        });

        it('should have right owner revision for an owned repository', () => {
            const commitSet = customCommitSetWithOwnedCommit();
            assert.equal(commitSet.ownerRevisionForRepository(MockModels.osx), null);
            assert.equal(commitSet.ownerRevisionForRepository(MockModels.ownerRepository), null);
            assert.equal(commitSet.ownerRevisionForRepository(MockModels.ownedRepository), 'OwnerRepository-r0');
        });

        it('should return all repositories in it', () => {
            const commitSet = customCommitSetWithOwnedCommit();
            assert.deepEqual(commitSet.repositories(), [MockModels.osx, MockModels.ownerRepository, MockModels.ownedRepository]);
        });

        it('should return only top level repositories', () => {
            const commitSet = customCommitSetWithOwnedCommit();
            assert.deepEqual(commitSet.topLevelRepositories(), [MockModels.osx, MockModels.ownerRepository]);
        });
    });

    describe('Test custom commit set with patch', () => {
        it('should have right revision for a given repository', () => {
            const commitSet = customCommitSetWithPatch();
            assert.equal(commitSet.revisionForRepository(MockModels.osx), '10.11.4 15E65');
            assert.equal(commitSet.revisionForRepository(MockModels.webkit), '200805');
        });

        it('should have a patch for a repository with patch specified', () => {
            const commitSet = customCommitSetWithPatch();
            assert.equal(commitSet.patchForRepository(MockModels.osx), null);
            assert.deepEqual(commitSet.patchForRepository(MockModels.webkit), createPatch());
        });

        it('should have no owner revision for a given repository', () => {
            const commitSet = customCommitSetWithPatch();
            assert.equal(commitSet.ownerRevisionForRepository(MockModels.osx), null);
            assert.equal(commitSet.ownerRevisionForRepository(MockModels.webkit), null);
        });

        it('should return all repositories in it', () => {
            const commitSet = customCommitSetWithPatch();
            assert.deepEqual(commitSet.repositories(), [MockModels.osx, MockModels.webkit]);
        });

        it('should return only top level repositories', () => {
            const commitSet = customCommitSetWithPatch();
            assert.deepEqual(commitSet.topLevelRepositories(), [MockModels.osx, MockModels.webkit]);
        });
    });

    describe('Test custom commit set with owned repository has same name as non-owned repository',  () => {
        it('should have right revision for a given repository', () => {
            const commitSet = customCommitSetWithOwnedRepositoryHasSameNameAsNotOwnedRepository();
            assert.equal(commitSet.revisionForRepository(MockModels.osx), '10.11.4 15E65');
            assert.equal(commitSet.revisionForRepository(MockModels.webkit), '200805');
            assert.equal(commitSet.revisionForRepository(MockModels.ownedWebkit), 'owned-200805');
        });

        it('should have no patch for any repository', () => {
            const commitSet = customCommitSetWithOwnedRepositoryHasSameNameAsNotOwnedRepository();
            assert.equal(commitSet.patchForRepository(MockModels.osx), null);
            assert.equal(commitSet.patchForRepository(MockModels.webkit), null);
            assert.equal(commitSet.patchForRepository(MockModels.ownedWebkit), null);
        });

        it('should have right owner revision for an owned repository', () => {
            const commitSet = customCommitSetWithOwnedRepositoryHasSameNameAsNotOwnedRepository();
            assert.equal(commitSet.ownerRevisionForRepository(MockModels.osx), null);
            assert.equal(commitSet.ownerRevisionForRepository(MockModels.webkit), null);
            assert.equal(commitSet.ownerRevisionForRepository(MockModels.ownedWebkit), '10.11.4 15E65');
        });

        it('should return all repositories in it', () => {
            const commitSet = customCommitSetWithOwnedRepositoryHasSameNameAsNotOwnedRepository();
            assert.deepEqual(commitSet.repositories(), [MockModels.osx, MockModels.webkit, MockModels.ownedWebkit]);
        });

        it('should return only top level repositories', () => {
            const commitSet = customCommitSetWithOwnedRepositoryHasSameNameAsNotOwnedRepository();
            assert.deepEqual(commitSet.topLevelRepositories(), [MockModels.osx, MockModels.webkit]);
        });
    });

    describe('Test custom commit set equality function', () => {
        it('should be equal to same custom commit set', () => {
            assert.deepEqual(customCommitSetWithoutOwnedCommit(), customCommitSetWithoutOwnedCommit());
            assert.deepEqual(customCommitSetWithOwnedCommit(), customCommitSetWithOwnedCommit());
            assert.deepEqual(customCommitSetWithPatch(), customCommitSetWithPatch());
            assert.deepEqual(customCommitSetWithOwnedRepositoryHasSameNameAsNotOwnedRepository(),
                customCommitSetWithOwnedRepositoryHasSameNameAsNotOwnedRepository());
        });

        it('should not be equal even if non-owned revisions are the same', () => {
            const commitSet0 = customCommitSetWithoutOwnedCommit();
            const commitSet1 = customCommitSetWithOwnedRepositoryHasSameNameAsNotOwnedRepository();
            assert.equal(commitSet0.equals(commitSet1), false);
        });
    });

    describe('Test custom commit set custom root operations', () => {
        it('should return empty custom roots if no custom root specified', () => {
            assert.deepEqual(customCommitSetWithoutOwnedCommit().customRoots(), []);
        });

        it('should return root if root is added into commit set', () => {
            const commitSet = customCommitSetWithoutOwnedCommit();
            commitSet.addCustomRoot(createRoot());
            assert.deepEqual(commitSet.customRoots(), [createRoot()]);
        });
    });
});