Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

8.6 KB
Raw Blame
import {
  resolvePullRequestOAuth,
  resolveTokenReference,
  resolvePullRequestHost,
  resolvePullRequestToken,
  isPullRequestFeatureActive,
  resolvePullRequestRecording,
  resolvePullRequestProvider,
} from './settings';

describe('resolvePullRequestOAuth', () => {
  const oauth = { clientId: '${ID}', clientSecret: '${SECRET}' };
  const env = { ID: 'client', SECRET: 'secret' };

  it('resolves the app on the provider host', () => {
    expect(
      resolvePullRequestOAuth({ provider: 'gitlab', host: 'GitLab.Example.com', oauth }, env),
    ).toEqual({
      provider: 'gitlab',
      host: 'gitlab.example.com',
      clientId: 'client',
      clientSecret: 'secret',
    });
    expect(resolvePullRequestOAuth({ oauth: { ...oauth, scope: ' repo ' } }, env)).toMatchObject({
      provider: 'github',
      host: 'github.com',
      scope: 'repo',
    });
  });

  it('is null without an app, or when a reference does not resolve', () => {
    expect(resolvePullRequestOAuth({}, env)).toBeNull();
    expect(resolvePullRequestOAuth({ oauth }, { ID: 'client' })).toBeNull();
    expect(resolvePullRequestOAuth({ oauth: { ...oauth, clientId: 'literal' } }, env)).toBeNull();
  });

  it('turns the feature on without a server token or a repository list', () => {
    expect(isPullRequestFeatureActive({ oauth }, env)).toBe(true);
    expect(isPullRequestFeatureActive({ oauth, enabled: false }, env)).toBe(false);
  });
});

describe('resolvePullRequestProvider', () => {
  it('is GitHub when none is configured', () => {
    expect(resolvePullRequestProvider(undefined)).toBe('github');
  });

  it.each(['github', 'gitlab', 'bitbucket'])('accepts %s', (provider) => {
    expect(resolvePullRequestProvider(provider)).toBe(provider);
  });

  it('refuses a provider this server does not know', () => {
    expect(resolvePullRequestProvider('gitea')).toBeNull();
  });
});

describe('resolvePullRequestHost', () => {
  it('is github.com when no host is configured', () => {
    expect(resolvePullRequestHost(undefined)).toBe('github.com');
  });

  it('normalizes a configured host, which the raw YAML does not', () => {
    expect(resolvePullRequestHost('  GitHub.Example.com ')).toBe('github.example.com');
    expect(resolvePullRequestHost('ghe.local:8443')).toBe('ghe.local:8443');
    expect(resolvePullRequestHost('ghe.local:08443')).toBe('ghe.local:8443');
  });

  it('drops the https default port, which a page URL never carries', () => {
    expect(resolvePullRequestHost('github.com:443')).toBe('github.com');
    expect(resolvePullRequestHost('GHE.Example.com:443')).toBe('ghe.example.com');
  });

  it.each([
    'https://github.example.com',
    'github.example.com/api',
    '[email protected]',
    'ghe.local:0',
    'ghe.local:65536',
    'ghe.local:99999',
    '',
  ])('refuses %p rather than falling back to github.com', (host) => {
    expect(resolvePullRequestHost(host)).toBeNull();
  });

  it("defaults to the provider's own host", () => {
    expect(resolvePullRequestHost(undefined, 'gitlab')).toBe('gitlab.com');
    expect(resolvePullRequestHost(undefined, 'bitbucket')).toBe('bitbucket.org');
    expect(resolvePullRequestHost('GitLab.Example.com', 'gitlab')).toBe('gitlab.example.com');
  });

  it('refuses any Bitbucket host but Cloud, which is all this server can read', () => {
    expect(resolvePullRequestHost('bitbucket.example.com', 'bitbucket')).toBeNull();
    expect(resolvePullRequestHost('Bitbucket.org', 'bitbucket')).toBe('bitbucket.org');
  });
});

describe('resolvePullRequestToken', () => {
  it('prefers the configured reference over any fallback', () => {
    expect(
      resolvePullRequestToken('${MY_TOKEN}', { MY_TOKEN: 'mine', GITHUB_TOKEN: 'other' }),
    ).toBe('mine');
  });

  it('does not fall back when the configured reference does not resolve', () => {
    expect(resolvePullRequestToken('${MY_TOKEN}', { GITHUB_TOKEN: 'other' })).toBeNull();
    expect(resolvePullRequestToken('not-a-reference', { GITHUB_TOKEN: 'other' })).toBeNull();
  });

  it.each([
    [
      'GITHUB_PULL_REQUEST_TOKEN',
      { GITHUB_PULL_REQUEST_TOKEN: 'a', GITHUB_TOKEN: 'b', GH_TOKEN: 'c' },
      'a',
    ],
    ['GITHUB_TOKEN', { GITHUB_TOKEN: ' b ', GH_TOKEN: 'c' }, 'b'],
    ['GH_TOKEN', { GH_TOKEN: 'c' }, 'c'],
  ])('falls back to %s, in that order', (_name, env, expected) => {
    expect(resolvePullRequestToken(undefined, env)).toBe(expected);
  });

  it('is null when no token exists anywhere, or only a blank one', () => {
    expect(resolvePullRequestToken(undefined, {})).toBeNull();
    expect(resolvePullRequestToken(undefined, { GITHUB_TOKEN: '  ' })).toBeNull();
  });
});

describe('resolveTokenReference', () => {
  it.each([
    ['${GH_TOKEN}', { GH_TOKEN: ' abc ' }, 'abc'],
    ['${GH_TOKEN}', {}, null],
    ['literal-token', { 'literal-token': 'x' }, null],
    [undefined, { GH_TOKEN: 'x' }, null],
  ])('resolves %s', (reference, env, expected) => {
    expect(resolveTokenReference(reference, env)).toBe(expected);
  });
});

describe('isPullRequestFeatureActive', () => {
  const env = { GITHUB_TOKEN: 't' };

  it('is on without any switch once there is a token and a list of repositories', () => {
    expect(isPullRequestFeatureActive({ allowedRepositories: ['o/r'] }, env)).toBe(true);
  });

  it('is on with the opt-in to every repository, and no list', () => {
    expect(isPullRequestFeatureActive({ allowAllRepositories: true }, env)).toBe(true);
  });

  it('stays dormant without a repository scope, so a worker cannot name its own', () => {
    expect(isPullRequestFeatureActive({}, env)).toBe(false);
    expect(isPullRequestFeatureActive(undefined, env)).toBe(false);
    expect(isPullRequestFeatureActive({ allowedRepositories: [] }, env)).toBe(false);
    expect(isPullRequestFeatureActive({ allowAllRepositories: false }, env)).toBe(false);
  });

  it('stays dormant without any token', () => {
    expect(isPullRequestFeatureActive({ allowAllRepositories: true }, {})).toBe(false);
  });

  it('counts a configured reference as a token even before it resolves, so the failure is visible', () => {
    expect(
      isPullRequestFeatureActive({ token: '${MISSING}', allowAllRepositories: true }, {}),
    ).toBe(true);
  });

  it('is off when an administrator turns it off, whatever else is set', () => {
    expect(isPullRequestFeatureActive({ enabled: false, allowAllRepositories: true }, env)).toBe(
      false,
    );
  });

  it('falls back to the variables of the configured provider only', () => {
    const gitlab = { provider: 'gitlab' as const, allowAllRepositories: true };
    expect(isPullRequestFeatureActive(gitlab, { GITHUB_TOKEN: 't' })).toBe(false);
    expect(isPullRequestFeatureActive(gitlab, { GITLAB_TOKEN: 't' })).toBe(true);
    expect(resolvePullRequestToken(undefined, { GITLAB_TOKEN: 'g', GH_TOKEN: 'h' }, 'gitlab')).toBe(
      'g',
    );
    expect(
      resolvePullRequestToken(undefined, { BITBUCKET_PULL_REQUEST_TOKEN: 'b' }, 'bitbucket'),
    ).toBe('b');
  });

  it('stays dormant for a provider this server does not know', () => {
    expect(
      isPullRequestFeatureActive(
        { provider: 'gitea' as never, token: '${T}', allowAllRepositories: true },
        env,
      ),
    ).toBe(false);
  });

  it('stays dormant with a host that is not a host name, so the token goes nowhere', () => {
    expect(
      isPullRequestFeatureActive(
        { host: 'https://ghe.example.com', allowAllRepositories: true },
        env,
      ),
    ).toBe(false);
    expect(
      isPullRequestFeatureActive({ host: 'ghe.example.com', allowAllRepositories: true }, env),
    ).toBe(true);
  });

  it('is on when explicitly enabled and fully scoped', () => {
    expect(isPullRequestFeatureActive({ enabled: true, allowAllRepositories: true }, env)).toBe(
      true,
    );
  });
});

describe('resolvePullRequestRecording', () => {
  const env = { GITHUB_TOKEN: 't' };
  it('records with the configured host when the feature is on', () => {
    expect(
      resolvePullRequestRecording({ host: 'GHE.example.com:443', allowAllRepositories: true }, env),
    ).toEqual({ enabled: true, host: 'ghe.example.com' });
    expect(resolvePullRequestRecording({ allowAllRepositories: true }, env)).toEqual({
      enabled: true,
      host: 'github.com',
    });
  });

  it('records links on the default host of the configured provider', () => {
    expect(
      resolvePullRequestRecording(
        { provider: 'gitlab', allowAllRepositories: true },
        { GITLAB_TOKEN: 't' },
      ),
    ).toEqual({ enabled: true, host: 'gitlab.com' });
  });

  it('records nothing when the feature is off', () => {
    expect(resolvePullRequestRecording({ allowAllRepositories: true }, {})).toEqual({
      enabled: false,
    });
  });
});