@theia/scm 1.75.0-next.8 → 1.75.0

package/src/browser/scm-history-graph-model.spec.ts

@@ -17,20 +17,21 @@
 import { expect } from 'chai';
 import { Emitter } from '@theia/core/lib/common/event';
 import { ScmHistoryGraphModel, PAGE_SIZE } from './scm-history-graph-model';
-import { ScmHistoryItem, ScmHistoryItemRef, ScmHistoryItemChange, ScmHistoryOptions, ScmHistoryProvider } from './scm-provider';
+import { ScmHistoryItem, ScmHistoryItemRef, ScmHistoryItemRefsChangeEvent, ScmHistoryItemChange, ScmHistoryOptions, ScmHistoryProvider } from './scm-provider';
 import { ScmRepository } from './scm-repository';
 
 class StubHistoryProvider implements ScmHistoryProvider {
-    readonly currentHistoryItemRef: ScmHistoryItemRef | undefined;
-    readonly currentHistoryItemRemoteRef: ScmHistoryItemRef | undefined;
-    readonly currentHistoryItemBaseRef: ScmHistoryItemRef | undefined;
+    currentHistoryItemRef: ScmHistoryItemRef | undefined;
+    currentHistoryItemRemoteRef: ScmHistoryItemRef | undefined;
+    currentHistoryItemBaseRef: ScmHistoryItemRef | undefined;
 
     readonly onDidChangeCurrentHistoryItemRefs = new Emitter<void>().event;
-    readonly onDidChangeHistoryItemRefs = new Emitter<{
-        readonly added: readonly ScmHistoryItemRef[];
-        readonly removed: readonly ScmHistoryItemRef[];
-        readonly modified: readonly ScmHistoryItemRef[];
-    }>().event;
+    protected readonly onDidChangeHistoryItemRefsEmitter = new Emitter<ScmHistoryItemRefsChangeEvent>();
+    readonly onDidChangeHistoryItemRefs = this.onDidChangeHistoryItemRefsEmitter.event;
+
+    fireHistoryItemRefsChanged(event: ScmHistoryItemRefsChangeEvent): void {
+        this.onDidChangeHistoryItemRefsEmitter.fire(event);
+    }
 
     /** Pages this provider will return on consecutive calls (FIFO). */
     pages: ScmHistoryItem[][] = [];
@@ -75,30 +76,46 @@ function makeItems(start: number, count: number): ScmHistoryItem[] {
 /**
  * Instantiates the model with a stub provider, bypassing inversify and the
  * SCM service so tests can drive pagination directly via loadPage().
+ * When `wireRepository` is set, the provider is instead wired through a stub
+ * selected repository and refresh(), so provider event subscriptions are live.
  */
-function createModel(provider: ScmHistoryProvider): { model: ScmHistoryGraphModel; loadPage(): Promise<void> } {
+function createModel(
+    provider: ScmHistoryProvider,
+    preferences: Record<string, unknown> = {},
+    wireRepository = false
+): { model: ScmHistoryGraphModel; loadPage(): Promise<void>; firePreferenceChanged(preferenceName: string): void } {
     const model = new ScmHistoryGraphModel();
     const internals = model as unknown as {
         scmService: {
             onDidChangeSelectedRepository: Emitter<ScmRepository | undefined>['event'];
             selectedRepository: ScmRepository | undefined;
         };
+        scmPreferences: Record<string, unknown>;
         _provider: ScmHistoryProvider | undefined;
         init(): void;
         loadPage(): Promise<void>;
     };
+    const preferenceEmitter = new Emitter<{ preferenceName: string }>();
     internals.scmService = {
         onDidChangeSelectedRepository: new Emitter<ScmRepository | undefined>().event,
-        selectedRepository: undefined,
+        selectedRepository: wireRepository ? { provider: { historyProvider: provider } } as unknown as ScmRepository : undefined,
     };
+    internals.scmPreferences = Object.assign(preferences, { onPreferenceChanged: preferenceEmitter.event });
     internals.init();
-    internals._provider = provider;
+    if (!wireRepository) {
+        internals._provider = provider;
+    }
     return {
         model,
         loadPage: () => internals.loadPage(),
+        firePreferenceChanged: preferenceName => preferenceEmitter.fire({ preferenceName }),
     };
 }
 
+async function nextTick(): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, 0));
+}
+
 describe('ScmHistoryGraphModel - pagination', () => {
 
     it('hasMore is true when a full page returns', async () => {
@@ -169,3 +186,352 @@ describe('ScmHistoryGraphModel - pagination', () => {
         expect(model.entries).to.have.length(PAGE_SIZE, 'should not grow when all items are duplicates');
     });
 });
+
+describe('ScmHistoryGraphModel - page size preference', () => {
+
+    it('requests the configured page size and paginates by it', async () => {
+        const provider = new StubHistoryProvider();
+        provider.pages = [makeItems(1, 10)];
+        const { model, loadPage } = createModel(provider, { 'scm.graph.pageSize': 10 });
+
+        await loadPage();
+
+        expect(provider.receivedOptions[0].limit).to.equal(10);
+        expect(model.entries).to.have.length(10);
+        expect(model.hasMore).to.be.true;
+    });
+
+    it('falls back to the default page size without a preference value', async () => {
+        const provider = new StubHistoryProvider();
+        provider.pages = [makeItems(1, 10)];
+        const { loadPage } = createModel(provider);
+
+        await loadPage();
+
+        expect(provider.receivedOptions[0].limit).to.equal(PAGE_SIZE);
+    });
+
+    it('reloads from the start when scm.graph.pageSize changes', async () => {
+        const provider = new StubHistoryProvider();
+        provider.pages = [makeItems(1, 10), makeItems(1, 5)];
+        const preferences: Record<string, unknown> = { 'scm.graph.pageSize': 10 };
+        const { loadPage, firePreferenceChanged } = createModel(provider, preferences);
+
+        await loadPage();
+        expect(provider.receivedOptions[0].limit).to.equal(10);
+
+        preferences['scm.graph.pageSize'] = 5;
+        firePreferenceChanged('scm.graph.pageSize');
+        await nextTick();
+
+        expect(provider.receivedOptions[1].limit).to.equal(5);
+        expect(provider.receivedOptions[1].skip).to.equal(0);
+    });
+});
+
+describe('ScmHistoryGraphModel - history item ref filter', () => {
+
+    const mainRef: ScmHistoryItemRef = { id: 'refs/heads/main', name: 'main', revision: 'c1' };
+
+    function createFilterProvider(): StubHistoryProvider {
+        const provider = new StubHistoryProvider();
+        provider.currentHistoryItemRef = mainRef;
+        provider.pages = [makeItems(1, 3), makeItems(1, 3), makeItems(1, 3)];
+        return provider;
+    }
+
+    it('is in auto mode by default: current ref revisions are requested and the current ref is in the filter', async () => {
+        const provider = createFilterProvider();
+        const { model, loadPage } = createModel(provider);
+        await loadPage();
+        expect(provider.receivedOptions[0].historyItemRefs).to.deep.equal(['c1']);
+        expect(model.historyItemRefFilter).to.be.undefined;
+        expect(model.isCurrentRefInFilter()).to.be.true;
+    });
+
+    it('passes the picked ref ids to the provider and reloads', async () => {
+        const provider = createFilterProvider();
+        const { model } = createModel(provider);
+        model.setHistoryItemRefFilter(['refs/heads/feature']);
+        await nextTick();
+        expect(provider.receivedOptions[0].historyItemRefs).to.deep.equal(['refs/heads/feature']);
+        expect(model.historyItemRefFilter).to.deep.equal(['refs/heads/feature']);
+    });
+
+    it('reports whether the current ref is part of the filter', async () => {
+        const provider = createFilterProvider();
+        const { model } = createModel(provider);
+        model.setHistoryItemRefFilter(['refs/heads/feature']);
+        await nextTick();
+        expect(model.isCurrentRefInFilter()).to.be.false;
+        model.setHistoryItemRefFilter(['refs/heads/feature', 'refs/heads/main']);
+        await nextTick();
+        expect(model.isCurrentRefInFilter()).to.be.true;
+    });
+
+    it('returns to auto mode when the filter is cleared', async () => {
+        const provider = createFilterProvider();
+        const { model } = createModel(provider);
+        model.setHistoryItemRefFilter(['refs/heads/feature']);
+        await nextTick();
+        model.setHistoryItemRefFilter(undefined);
+        await nextTick();
+        expect(model.historyItemRefFilter).to.be.undefined;
+        expect(provider.receivedOptions[1].historyItemRefs).to.deep.equal(['c1']);
+    });
+
+    it('does not apply ref role colors to refs excluded by the filter', async () => {
+        const provider = createFilterProvider();
+        provider.pages = [[
+            { id: 'c1', subject: 'head', parentIds: ['c2'], references: [mainRef] },
+            { id: 'c2', subject: 'base', parentIds: [] },
+        ]];
+        const { model } = createModel(provider);
+        model.setHistoryItemRefFilter(['refs/heads/feature']);
+        await nextTick();
+        expect(model.entries[0].graphRow.color).to.not.equal(0);
+    });
+});
+
+describe('ScmHistoryGraphModel - ref filter pruning', () => {
+
+    const mainRef: ScmHistoryItemRef = { id: 'refs/heads/main', name: 'main', revision: 'c1' };
+    const featureRef: ScmHistoryItemRef = { id: 'refs/heads/feature', name: 'feature', revision: 'c5' };
+
+    function createWiredProvider(): StubHistoryProvider {
+        const provider = new StubHistoryProvider();
+        provider.currentHistoryItemRef = mainRef;
+        return provider;
+    }
+
+    it('drops a removed ref from the filter and keeps the remaining ones', async () => {
+        const provider = createWiredProvider();
+        const { model } = createModel(provider, {}, true);
+        model.setHistoryItemRefFilter([featureRef.id, mainRef.id]);
+        await nextTick();
+
+        provider.fireHistoryItemRefsChanged({ added: [], removed: [featureRef], modified: [] });
+        await nextTick();
+
+        expect(model.historyItemRefFilter).to.deep.equal([mainRef.id]);
+        const last = provider.receivedOptions[provider.receivedOptions.length - 1];
+        expect(last.historyItemRefs).to.deep.equal([mainRef.id]);
+    });
+
+    it('falls back to auto mode when all filtered refs are removed', async () => {
+        const provider = createWiredProvider();
+        const { model } = createModel(provider, {}, true);
+        model.setHistoryItemRefFilter([featureRef.id]);
+        await nextTick();
+
+        provider.fireHistoryItemRefsChanged({ added: [], removed: [featureRef], modified: [] });
+        await nextTick();
+
+        expect(model.historyItemRefFilter).to.be.undefined;
+        const last = provider.receivedOptions[provider.receivedOptions.length - 1];
+        expect(last.historyItemRefs).to.deep.equal(['c1']);
+    });
+
+    it('keeps the filter when unrelated refs are removed', async () => {
+        const provider = createWiredProvider();
+        const { model } = createModel(provider, {}, true);
+        model.setHistoryItemRefFilter([mainRef.id]);
+        await nextTick();
+
+        provider.fireHistoryItemRefsChanged({ added: [], removed: [featureRef], modified: [] });
+        await nextTick();
+
+        expect(model.historyItemRefFilter).to.deep.equal([mainRef.id]);
+    });
+});
+
+describe('ScmHistoryGraphModel - ref colors and current item', () => {
+
+    const mainRef: ScmHistoryItemRef = { id: 'refs/heads/main', name: 'main', revision: 'c2' };
+    const originMainRef: ScmHistoryItemRef = { id: 'refs/remotes/origin/main', name: 'origin/main', revision: 'c1' };
+
+    /** Remote is one commit ahead: c1 (origin/main) → c2 (main = HEAD) → c3. */
+    function createBehindProvider(): StubHistoryProvider {
+        const provider = new StubHistoryProvider();
+        provider.currentHistoryItemRef = mainRef;
+        provider.currentHistoryItemRemoteRef = originMainRef;
+        provider.pages = [[
+            { id: 'c1', subject: 'remote only', parentIds: ['c2'], references: [originMainRef] },
+            { id: 'c2', subject: 'local head', parentIds: ['c3'], references: [mainRef] },
+            { id: 'c3', subject: 'base', parentIds: [] },
+        ]];
+        return provider;
+    }
+
+    it('colors the remote ref tip with the remote ref color', async () => {
+        const { model, loadPage } = createModel(createBehindProvider());
+        await loadPage();
+        expect(model.entries[0].graphRow.color).to.equal(1);
+    });
+
+    it('colors the current ref chain with the current ref color', async () => {
+        const { model, loadPage } = createModel(createBehindProvider());
+        await loadPage();
+        expect(model.entries[1].graphRow.color).to.equal(0);
+        expect(model.entries[2].graphRow.color).to.equal(0);
+    });
+
+    it('prefers the current ref color when a commit carries both local and remote refs', async () => {
+        const provider = new StubHistoryProvider();
+        const syncedMain: ScmHistoryItemRef = { ...mainRef, revision: 'c1' };
+        const syncedRemote: ScmHistoryItemRef = { ...originMainRef, revision: 'c1' };
+        provider.currentHistoryItemRef = syncedMain;
+        provider.currentHistoryItemRemoteRef = syncedRemote;
+        provider.pages = [[
+            { id: 'c1', subject: 'in sync', parentIds: [], references: [syncedRemote, syncedMain] },
+        ]];
+        const { model, loadPage } = createModel(provider);
+        await loadPage();
+        expect(model.entries[0].graphRow.color).to.equal(0);
+    });
+
+    it('marks only the entry at the current ref revision as current', async () => {
+        const { model, loadPage } = createModel(createBehindProvider());
+        await loadPage();
+        expect(model.entries.map(e => e.isCurrent)).to.deep.equal([false, true, false]);
+    });
+
+    it('marks no entry as current when the provider has no current ref', async () => {
+        const provider = new StubHistoryProvider();
+        provider.pages = [makeItems(1, 3)];
+        const { model, loadPage } = createModel(provider);
+        await loadPage();
+        expect(model.entries.every(e => !e.isCurrent)).to.be.true;
+    });
+});
+
+describe('ScmHistoryGraphModel - view mode', () => {
+
+    it('shows the changes of a history item as a list by default', () => {
+        const { model } = createModel(new StubHistoryProvider());
+        expect(model.viewMode).to.equal('list');
+    });
+
+    it('switches the view mode', () => {
+        const { model } = createModel(new StubHistoryProvider());
+        model.setViewMode('tree');
+        expect(model.viewMode).to.equal('tree');
+    });
+
+    it('notifies listeners when the view mode changes', () => {
+        const { model } = createModel(new StubHistoryProvider());
+        let changes = 0;
+        model.onDidChange(() => changes++);
+
+        model.setViewMode('tree');
+
+        expect(changes).to.equal(1);
+    });
+
+    it('does not notify listeners when the view mode is unchanged', () => {
+        const { model } = createModel(new StubHistoryProvider());
+        model.setViewMode('tree');
+        let changes = 0;
+        model.onDidChange(() => changes++);
+
+        model.setViewMode('tree');
+
+        expect(changes).to.equal(0);
+    });
+
+    it('does not reload history when the view mode changes', async () => {
+        const provider = new StubHistoryProvider();
+        provider.pages = [makeItems(1, 10)];
+        const { model, loadPage } = createModel(provider);
+        await loadPage();
+        const requestsBefore = provider.receivedOptions.length;
+
+        model.setViewMode('tree');
+        await nextTick();
+
+        expect(provider.receivedOptions).to.have.length(requestsBefore);
+    });
+});
+
+describe('ScmHistoryGraphModel - revealing the current history item', () => {
+
+    function createProviderAt(revision: string): StubHistoryProvider {
+        const provider = new StubHistoryProvider();
+        provider.currentHistoryItemRef = { id: 'refs/heads/main', name: 'main', revision };
+        return provider;
+    }
+
+    it('requests a reveal of the index of the current history item', async () => {
+        const provider = createProviderAt('c3');
+        provider.pages = [makeItems(1, 10)];
+        const { model, loadPage } = createModel(provider);
+        await loadPage();
+        const revealed: number[] = [];
+        model.onDidRequestReveal(revealedIndex => revealed.push(revealedIndex));
+
+        const index = await model.revealCurrentHistoryItem();
+
+        expect(index).to.equal(2);
+        expect(revealed).to.deep.equal([2]);
+    });
+
+    it('loads further pages until the current history item is found', async () => {
+        const provider = createProviderAt('c55');
+        provider.pages = [makeItems(1, PAGE_SIZE), makeItems(PAGE_SIZE + 1, PAGE_SIZE)];
+        const { model, loadPage } = createModel(provider);
+        await loadPage();
+        expect(model.entries).to.have.length(PAGE_SIZE);
+
+        const index = await model.revealCurrentHistoryItem();
+
+        expect(index).to.equal(54);
+        expect(model.entries).to.have.length(2 * PAGE_SIZE);
+    });
+
+    it('does not request a reveal when the current history item is not in the history', async () => {
+        const provider = createProviderAt('not-loaded');
+        provider.pages = [makeItems(1, 10)];
+        const { model, loadPage } = createModel(provider);
+        await loadPage();
+        const revealed: number[] = [];
+        model.onDidRequestReveal(revealedIndex => revealed.push(revealedIndex));
+
+        const index = await model.revealCurrentHistoryItem();
+
+        expect(index).to.be.undefined;
+        expect(revealed).to.be.empty;
+    });
+
+    it('does not request a reveal when the provider has no current history item ref', async () => {
+        const provider = new StubHistoryProvider();
+        provider.pages = [makeItems(1, 10)];
+        const { model, loadPage } = createModel(provider);
+        await loadPage();
+        const revealed: number[] = [];
+        model.onDidRequestReveal(revealedIndex => revealed.push(revealedIndex));
+
+        const index = await model.revealCurrentHistoryItem();
+
+        expect(index).to.be.undefined;
+        expect(revealed).to.be.empty;
+    });
+
+    it('stops paging when further pages add no new items', async () => {
+        const provider = createProviderAt('never-returned');
+        const page = makeItems(1, PAGE_SIZE);
+        // A provider that keeps returning the same full page: `hasMore` stays true
+        // forever, so only a no-progress guard can end the search.
+        provider.provideHistoryItems = async options => {
+            provider.receivedOptions.push(options);
+            return page;
+        };
+        const { model, loadPage } = createModel(provider);
+        await loadPage();
+        expect(model.hasMore).to.be.true;
+
+        const index = await model.revealCurrentHistoryItem();
+
+        expect(index).to.be.undefined;
+        expect(model.entries).to.have.length(PAGE_SIZE);
+    });
+});