[server] Extend and fix context parser tests around prebuild discovery

Author: geropl

components/server/src/prebuilds/incremental-workspace-service.ts

@@ -66,7 +66,7 @@ export class IncrementalWorkspaceService {
         return history;
     }
 
-    public async findGoodBaseForIncrementalBuild(
+    public async findBaseForIncrementalWorkspace(
         context: CommitContext,
         config: WorkspaceConfig,
         history: WithCommitHistory,

components/server/src/prebuilds/prebuild-manager.ts

@@ -407,7 +407,7 @@ export class PrebuildManager {
                         commitHistory: repoHist.commitHistory.slice(0, prebuildInterval),
                     })),
                 };
-                const prebuild = await this.incrementalPrebuildsService.findGoodBaseForIncrementalBuild(
+                const prebuild = await this.incrementalPrebuildsService.findBaseForIncrementalWorkspace(
                     context,
                     config,
                     history,
@@ -416,6 +416,7 @@ export class PrebuildManager {
                     true,
                 );
                 if (prebuild) {
+                    // TODO(gpl): Why not "done: prebuild.state === "available""?
                     return { prebuildId: prebuild.id, wsid: prebuild.buildWorkspaceId, done: true };
                 }
             }

components/server/src/workspace/context-service.spec.db.ts

@@ -17,6 +17,10 @@ import {
     StartPrebuildResult,
     SnapshotContext,
     PrebuiltWorkspaceContext,
+    Branch,
+    CommitInfo,
+    Repository,
+    RepositoryInfo,
 } from "@gitpod/gitpod-protocol";
 import * as chai from "chai";
 import { Container } from "inversify";
@@ -36,6 +40,7 @@ import { HostContextProvider } from "../auth/host-context-provider";
 import { AuthProvider } from "../auth/auth-provider";
 import { Experiments } from "@gitpod/gitpod-protocol/lib/experiments/configcat-server";
 import { SYSTEM_USER } from "../authorization/authorizer";
+import { RepositoryProvider } from "../repohost";
 
 const expect = chai.expect;
 
@@ -54,14 +59,98 @@ const gitpodEmptyContext = {
         private: false,
     },
     normalizedContextURL: "https://github.com/gitpod-io/empty",
-    revision: "asdf",
+    revision: "123456",
     title: "gitpod-io/empty - main",
 };
 
+// MockRepositoryProvider is a class implementing the RepositoryProvider interface, which allows to pass in commitHistory and commitInfo as needed
+class MockRepositoryProvider implements RepositoryProvider {
+    branches: Map<string, { branch: Branch; commits: CommitInfo[] }> = new Map();
+
+    addBranch(branch: Omit<Branch, "commit">, commits: CommitInfo[]) {
+        this.branches.set(branch.name, {
+            branch: {
+                ...branch,
+                commit: {
+                    sha: head(commits).sha,
+                    author: head(commits).author,
+                    commitMessage: head(commits).commitMessage,
+                },
+            },
+            commits,
+        });
+    }
+
+    async hasReadAccess(user: any, owner: string, repo: string): Promise<boolean> {
+        return true;
+    }
+    async getBranch(user: User, owner: string, repo: string, branchName: string): Promise<Branch> {
+        const branch = this.branches.get(branchName);
+        if (!branch) {
+            throw new Error("branch not found");
+        }
+        return branch.branch;
+    }
+    async getRepo(user: User, owner: string, repo: string): Promise<Repository> {
+        return {
+            host: "github.com",
+            owner: "gitpod-io",
+            name: "empty",
+            cloneUrl: "https://github.com/gitpod-io/empty.git",
+            defaultBranch: "main",
+        };
+    }
+    async getCommitHistory(user: User, owner: string, repo: string, ref: string, maxDepth: number): Promise<string[]> {
+        const branch = this.branches.get(ref);
+        if (branch) {
+            return branch.commits.map((c) => c.sha);
+        }
+
+        for (const b of this.branches.values()) {
+            for (const [i, c] of b.commits.entries()) {
+                if (c.sha === ref) {
+                    // this commit, and everything before it
+                    return b.commits.slice(0, i + 1).map((c) => c.sha);
+                }
+            }
+        }
+        throw new Error(`ref ${ref} not found`);
+    }
+    async getCommitInfo(user: User, owner: string, repo: string, ref: string): Promise<CommitInfo | undefined> {
+        return headu(this.branches.get(ref)?.commits);
+    }
+
+    async getBranches(user: User, owner: string, repo: string): Promise<Branch[]> {
+        return Array.from(this.branches.values()).map((b) => b.branch);
+    }
+
+    async getUserRepos(user: User): Promise<RepositoryInfo[]> {
+        return [];
+    }
+    async searchRepos(user: User, searchString: string, limit: number): Promise<RepositoryInfo[]> {
+        return [];
+    }
+}
+
+function headu<T>(arr: T[] | undefined): T | undefined {
+    if (!arr || arr.length === 0) {
+        return undefined;
+    }
+    return arr[arr.length - 1];
+}
+
+function head<T>(arr: T[]): T {
+    if (arr.length === 0) {
+        throw new Error("empty array");
+    }
+    return arr[arr.length - 1];
+}
+
 const SNAPSHOT_BUCKET = "https://gitpod.io/none-bucket";
 
 describe("ContextService", async () => {
     let container: Container;
+    let mockRepositoryProvider: MockRepositoryProvider;
     let owner: User;
     let member: User;
     let stranger: User;
@@ -91,41 +180,73 @@ describe("ContextService", async () => {
                 normalizeContextURL: function (contextURL: string): string {
                     return contextURL + "normalizeContextURL";
                 },
-                handle: function (ctx: TraceContext, user: User, contextURL: string): Promise<WorkspaceContext> {
+                handle: async function (ctx: TraceContext, user: User, contextURL: string): Promise<WorkspaceContext> {
                     const url = contextURL.replace("normalizeContextURL", "");
-                    switch (url) {
-                        case "https://github.com/gitpod-io/empty":
-                            return gitpodEmptyContext as any;
-                        case `open-prebuild/${prebuild.prebuildId}/https://github.com/gitpod-io/empty/tree/main`:
-                            return {
-                                ...gitpodEmptyContext,
-                                openPrebuildID: prebuild.prebuildId,
-                            } as any;
-                        case `snapshot/${snapshot.id}`: {
+
+                    const cases = new Map<string, () => WorkspaceContext>();
+                    cases.set("https://github.com/gitpod-io/empty", () => {
+                        return gitpodEmptyContext as any;
+                    });
+
+                    if (prebuild) {
+                        cases.set(
+                            `open-prebuild/${prebuild.prebuildId}/https://github.com/gitpod-io/empty/tree/main`,
+                            () => {
+                                return {
+                                    ...gitpodEmptyContext,
+                                    openPrebuildID: prebuild.prebuildId,
+                                } as any;
+                            },
+                        );
+                    }
+                    if (snapshot) {
+                        cases.set(`snapshot/${snapshot.id}`, () => {
                             return {
                                 ...gitpodEmptyContext,
                                 snapshotId: snapshot.id,
                                 snapshotBucketId: SNAPSHOT_BUCKET,
                             } as any;
-                        }
-                        case `snapshot/${snapshot_stranger.id}`: {
+                        });
+                    }
+                    if (snapshot_stranger) {
+                        cases.set(`snapshot/${snapshot_stranger.id}`, () => {
                             return {
                                 ...gitpodEmptyContext,
                                 snapshotId: snapshot_stranger.id,
                                 snapshotBucketId: SNAPSHOT_BUCKET,
                             } as any;
-                        }
-                        default:
-                            return {
-                                ref: "master",
-                            } as any;
+                        });
+                    }
+                    const c = cases.get(url);
+                    if (c) {
+                        return c();
                     }
+
+                    const mainBranch = await mockRepositoryProvider.getBranch(user, "gitpod-io", "empty", "main");
+                    const r: CommitContext = {
+                        title: mainBranch.commit.commitMessage,
+                        ref: mainBranch.name,
+                        refType: "branch",
+                        revision: mainBranch.commit.sha,
+                        repository: await mockRepositoryProvider.getRepo(user, "gitpod-io", "empty"),
+                        normalizedContextURL: mainBranch.htmlUrl,
+                    };
+                    return r;
                 },
             } as any as ContextParser);
         };
 
         bindContextParser();
 
+        mockRepositoryProvider = new MockRepositoryProvider();
+        mockRepositoryProvider.addBranch({ name: "main", htmlUrl: "https://github.com/gitpod-io/empty/tree/main" }, [
+            {
+                sha: gitpodEmptyContext.revision,
+                author: "some-dude",
+                commitMessage: "some message",
+            },
+        ]);
+
         container.rebind(HostContextProvider).toConstantValue({
             get: () => {
                 const authProviderId = "Public-GitHub";
@@ -138,30 +259,7 @@ describe("ContextService", async () => {
                         },
                     },
                     services: {
-                        repositoryProvider: {
-                            hasReadAccess: async (user: any, owner: string, repo: string) => {
-                                return true;
-                            },
-                            getBranch: () => {
-                                return {
-                                    url: "https://github.com/gitpod-io/empty.git",
-                                    name: "main",
-                                    htmlUrl: "https://github.com/gitpod-io/empty",
-                                    commit: {},
-                                };
-                            },
-                            getRepo: () => {
-                                return {
-                                    defaultBranch: "main",
-                                };
-                            },
-                            getCommitHistory: () => {
-                                return [];
-                            },
-                            getCommitInfo: () => {
-                                return undefined;
-                            },
-                        },
+                        repositoryProvider: mockRepositoryProvider,
                     },
                 };
             },

components/server/src/workspace/context-service.ts

@@ -29,7 +29,7 @@ export class ContextService {
     constructor(
         @inject(TracedWorkspaceDB) private readonly workspaceDb: DBWithTracing<WorkspaceDB>,
         @inject(ContextParser) private contextParser: ContextParser,
-        @inject(IncrementalWorkspaceService) private readonly incrementalPrebuildsService: IncrementalWorkspaceService,
+        @inject(IncrementalWorkspaceService) private readonly incrementalWorkspaceService: IncrementalWorkspaceService,
         @inject(ConfigProvider) private readonly configProvider: ConfigProvider,
 
         @inject(ProjectsService) private readonly projectsService: ProjectsService,
@@ -57,14 +57,15 @@ export class ContextService {
             }
         } else {
             const configPromise = this.configProvider.fetchConfig({}, user, context, organizationId);
-            const history = await this.incrementalPrebuildsService.getCommitHistoryForContext(context, user);
+            const history = await this.incrementalWorkspaceService.getCommitHistoryForContext(context, user);
             const { config } = await configPromise;
-            prebuiltWorkspace = await this.incrementalPrebuildsService.findGoodBaseForIncrementalBuild(
+            prebuiltWorkspace = await this.incrementalWorkspaceService.findBaseForIncrementalWorkspace(
                 context,
                 config,
                 history,
                 user,
                 projectId,
+                false,
             );
         }
         if (!prebuiltWorkspace?.projectId) {