wip: adding db tests for auth provider server

Author: AlexTugarev

components/gitpod-db/src/typeorm/entity/db-auth-provider-entry.ts

@@ -18,7 +18,11 @@ export class DBAuthProviderEntry implements AuthProviderEntry {
     @Column()
     ownerId: string;
 
-    @Column()
+    @Column({
+        ...TypeORM.UUID_COLUMN_TYPE,
+        default: "",
+        transformer: Transformer.MAP_EMPTY_STR_TO_UNDEFINED,
+    })
     organizationId?: string;
 
     @Column("varchar")

components/server/src/auth/auth-provider-service.spec.db.ts

@@ -0,0 +1,183 @@
+/**
+ * Copyright (c) 2023 Gitpod GmbH. All rights reserved.
+ * Licensed under the GNU Affero General Public License (AGPL).
+ * See License.AGPL.txt in the project root for license information.
+ */
+
+import { TypeORM } from "@gitpod/gitpod-db/lib";
+import { Organization, User } from "@gitpod/gitpod-protocol";
+import { Experiments } from "@gitpod/gitpod-protocol/lib/experiments/configcat-server";
+import * as chai from "chai";
+import { Container } from "inversify";
+import "mocha";
+import { createTestContainer } from "../test/service-testing-container-module";
+import { resetDB } from "@gitpod/gitpod-db/lib/test/reset-db";
+import { UserService } from "../user/user-service";
+import { AuthProviderService } from "./auth-provider-service";
+import { Config } from "../config";
+import { ErrorCodes } from "@gitpod/gitpod-protocol/lib/messaging/error";
+import { expectError } from "../test/expect-utils";
+import { AuthProviderEntry } from "@gitpod/gitpod-protocol";
+import { AuthProviderParams } from "./auth-provider";
+import { OrganizationService } from "../orgs/organization-service";
+
+const expect = chai.expect;
+
+describe("AuthProviderService", async () => {
+    let service: AuthProviderService;
+    let container: Container;
+    let owner: User;
+    let org: Organization;
+
+    const newEntry = () =>
+        <AuthProviderEntry.NewEntry>{
+            host: "github.com",
+            ownerId: owner.id,
+            type: "GitHub",
+            clientId: "123",
+            clientSecret: "secret-123",
+        };
+    const expectedProviderPartial = () =>
+        <Partial<AuthProviderParams>>{
+            builtin: false,
+            host: "github.com",
+            disallowLogin: false,
+            oauth: {
+                authorizationUrl: "https://github.com/login/oauth/authorize",
+                callBackUrl: "https://gitpod.io/auth/callback",
+                clientId: "123",
+                clientSecret: "secret-123",
+                tokenUrl: "https://github.com/login/oauth/access_token",
+            },
+            organizationId: undefined,
+            type: "GitHub",
+            verified: false,
+            status: "pending",
+            ownerId: owner.id,
+        };
+
+    const newOrgEntry = () =>
+        <AuthProviderEntry.NewOrgEntry>{
+            host: "github.com",
+            ownerId: owner.id,
+            type: "GitHub",
+            clientId: "123",
+            clientSecret: "secret-123",
+            organizationId: org.id,
+        };
+    const expectedOrgProviderPartial = () =>
+        <Partial<AuthProviderParams>>{
+            builtin: false,
+            host: "github.com",
+            disallowLogin: true,
+            oauth: {
+                authorizationUrl: "https://github.com/login/oauth/authorize",
+                callBackUrl: "https://gitpod.io/auth/callback",
+                clientId: "123",
+                clientSecret: "secret-123",
+                tokenUrl: "https://github.com/login/oauth/access_token",
+            },
+            organizationId: org.id,
+            type: "GitHub",
+            verified: false,
+            status: "pending",
+            ownerId: owner.id,
+        };
+
+    beforeEach(async () => {
+        container = createTestContainer();
+        Experiments.configureTestingClient({
+            centralizedPermissions: true,
+        });
+        service = container.get(AuthProviderService);
+        const userService = container.get<UserService>(UserService);
+        owner = await userService.createUser({
+            identity: {
+                authId: "gh-user-1",
+                authName: "user",
+                authProviderId: "public-github",
+            },
+        });
+        const os = container.get<OrganizationService>(OrganizationService);
+        org = await os.createOrganization(owner.id, "myorg");
+    });
+
+    afterEach(async () => {
+        // Clean-up database
+        await resetDB(container.get(TypeORM));
+    });
+
+    describe("createAuthProviderOfUser", async () => {
+        it("should create user-level provider", async () => {
+            const providersAtStart = await service.getAllAuthProviders();
+            expect(providersAtStart).to.be.empty;
+
+            await service.createAuthProviderOfUser(owner.id, newEntry());
+
+            const providers = await service.getAllAuthProviders();
+            expect(providers).to.have.lengthOf(1);
+            expect(providers[0]).to.deep.include(expectedProviderPartial());
+        });
+
+        it("should fail in case of conflict with built-in provider", async () => {
+            const config = container.get<Config>(Config);
+            config.builtinAuthProvidersConfigured = true;
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            config.authProviderConfigs.push({
+                host: "github.com",
+            } as any);
+
+            const providersAtStart = await service.getAllAuthProviders();
+            expect(providersAtStart).to.be.empty;
+
+            await expectError(ErrorCodes.CONFLICT, service.createAuthProviderOfUser(owner.id, newEntry()));
+        });
+        it("should fail if host is not reachable", async () => {
+            await expectError(
+                ErrorCodes.BAD_REQUEST,
+                service.createAuthProviderOfUser(owner.id, {
+                    ...newEntry(),
+                    host: "please-dont-register-this-domain.com:666",
+                }),
+            );
+        });
+        it("should fail if trying to register same host", async () => {
+            const providersAtStart = await service.getAllAuthProviders();
+            expect(providersAtStart).to.be.empty;
+
+            await service.createAuthProviderOfUser(owner.id, newEntry());
+
+            await expectError(ErrorCodes.CONFLICT, service.createAuthProviderOfUser(owner.id, newEntry()));
+        });
+    });
+
+    describe("createOrgAuthProvider", async () => {
+        it("should create org-level provider", async () => {
+            const providersAtStart = await service.getAllAuthProviders();
+            expect(providersAtStart).to.be.empty;
+
+            await service.createOrgAuthProvider(owner.id, newOrgEntry());
+
+            const providers = await service.getAllAuthProviders();
+            expect(providers).to.have.lengthOf(1);
+            expect(providers[0]).to.deep.include(expectedOrgProviderPartial());
+        });
+        it("should fail if host is not reachable", async () => {
+            await expectError(
+                ErrorCodes.BAD_REQUEST,
+                service.createOrgAuthProvider(owner.id, {
+                    ...newOrgEntry(),
+                    host: "please-dont-register-this-domain.com:666",
+                }),
+            );
+        });
+        it("should fail if trying to register same host", async () => {
+            const providersAtStart = await service.getAllAuthProviders();
+            expect(providersAtStart).to.be.empty;
+
+            await service.createOrgAuthProvider(owner.id, newOrgEntry());
+
+            await expectError(ErrorCodes.CONFLICT, service.createAuthProviderOfUser(owner.id, newOrgEntry()));
+        });
+    });
+});

components/server/src/auth/auth-provider.ts

@@ -18,6 +18,10 @@ export interface AuthProviderParams extends AuthProviderEntry {
 
     // properties to control behavior
     readonly hiddenOnDashboard?: boolean;
+
+    /**
+     * @deprecated: looks like this is unused after all
+     */
     readonly disallowLogin?: boolean;
 
     readonly description: string;