docs: restructure contributing docs and improve E2E test infrastructure

Move developer resources (setup, building, testing, code quality) into
CONTRIBUTING.md and refocus the website's contributing page on project
governance (roles, voting, CLA). Slim down localgit/README.md to a
summary now that CONTRIBUTING.md covers E2E setup in detail.

Rename E2E test repositories from real project names to clearly fake
names (test-owner/test-repo, e2e-org/sample-repo). Add fail-fast
pre-flight checks in E2E setup to detect missing Docker infrastructure.
Add Docker Hub login to CI workflow to avoid pull rate limits. Remove
outdated Mocha/Chai testing page from docs site and fix plugin import
paths.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Author: coopernetes

CONTRIBUTING.md

@@ -3,7 +3,7 @@ set -e  # Exit on any error
 
 # Create the git repositories directories for multiple owners
 BASE_DIR="${BASE_DIR:-"/var/git"}"
-OWNERS=("coopernetes" "finos")
+OWNERS=("test-owner" "e2e-org")
 TEMP_DIR="/tmp/git-init"
 
 # Create base directory and owner subdirectories
@@ -27,11 +27,11 @@ create_bare_repo() {
     local owner="$1"
     local repo_name="$2"
     local repo_dir="$BASE_DIR/$owner"
-    
+
     echo "Creating $repo_name in $owner's directory..."
     cd "$repo_dir" || exit 1
     git init --bare --initial-branch=main "$repo_name"
-    
+
     # Configure for HTTP access
     cd "$repo_dir/$repo_name" || exit 1
     git config http.receivepack true
@@ -47,23 +47,23 @@ add_content_to_repo() {
     local repo_name="$2"
     local repo_path="$BASE_DIR/$owner/$repo_name"
     local work_dir="$TEMP_DIR/${owner}-${repo_name%-.*}-work"
-    
+
     echo "Adding content to $owner/$repo_name..."
     cd "$TEMP_DIR" || exit 1
     git clone "$repo_path" "$work_dir"
     cd "$work_dir" || exit 1
 }
 
 # Create repositories with simple content
-echo "=== Creating coopernetes/test-repo.git ==="
-create_bare_repo "coopernetes" "test-repo.git"
-add_content_to_repo "coopernetes" "test-repo.git"
+echo "=== Creating test-owner/test-repo.git ==="
+create_bare_repo "test-owner" "test-repo.git"
+add_content_to_repo "test-owner" "test-repo.git"
 
 # Create a simple README
 cat > README.md << 'EOF'
 # Test Repository
 
-This is a test repository for the git proxy, simulating coopernetes/test-repo.
+A dummy repository used for GitProxy end-to-end testing.
 EOF
 
 # Create a simple text file
@@ -75,29 +75,29 @@ git add .
 git commit -m "Initial commit with basic content"
 git push origin main
 
-echo "=== Creating finos/git-proxy.git ==="
-create_bare_repo "finos" "git-proxy.git"
-add_content_to_repo "finos" "git-proxy.git"
+echo "=== Creating e2e-org/sample-repo.git ==="
+create_bare_repo "e2e-org" "sample-repo.git"
+add_content_to_repo "e2e-org" "sample-repo.git"
 
 # Create a simple README
 cat > README.md << 'EOF'
-# Git Proxy
+# Sample Repository
 
-This is a test instance of the FINOS Git Proxy project for isolated e2e testing.
+A dummy repository used for GitProxy end-to-end testing.
 EOF
 
-# Create a simple package.json to simulate the real project structure
+# Create a simple package.json to simulate a project structure
 cat > package.json << 'EOF'
 {
-  "name": "git-proxy",
+  "name": "sample-repo",
   "version": "1.0.0",
-  "description": "A proxy for Git operations",
+  "description": "A sample project for e2e testing",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "keywords": ["git", "proxy", "finos"],
-  "author": "FINOS",
+  "keywords": ["git", "proxy", "test"],
+  "author": "Test",
   "license": "Apache-2.0"
 }
 EOF
@@ -146,4 +146,4 @@ done
 
 echo "Successfully initialized Git repositories in $BASE_DIR"
 echo "Owners created: ${OWNERS[*]}"
-echo "Total repositories: $(find $BASE_DIR -name "*.git" -type d | wc -l)"
+echo "Total repositories: $(find $BASE_DIR -name "*.git" -type d | wc -l)"

localgit/README.md

@@ -11,14 +11,14 @@
   },
   "authorisedList": [
     {
-      "project": "coopernetes",
+      "project": "test-owner",
       "name": "test-repo",
-      "url": "https://git-server:8443/coopernetes/test-repo.git"
+      "url": "https://git-server:8443/test-owner/test-repo.git"
     },
     {
-      "project": "finos",
-      "name": "git-proxy",
-      "url": "https://git-server:8443/finos/git-proxy.git"
+      "project": "e2e-org",
+      "name": "sample-repo",
+      "url": "https://git-server:8443/e2e-org/sample-repo.git"
     }
   ],
   "sink": [

localgit/init-repos.sh

@@ -37,17 +37,17 @@ describe('Git Proxy E2E - Repository Fetch Tests', () => {
 
   describe('Repository fetching through git proxy', () => {
     it(
-      'should successfully fetch coopernetes/test-repo through git proxy',
+      'should successfully fetch test-owner/test-repo through git proxy',
       async () => {
         // Build URL with embedded credentials for reliable authentication
         const baseUrl = new URL(testConfig.gitProxyUrl);
         baseUrl.username = testConfig.gitUsername;
         baseUrl.password = testConfig.gitPassword;
-        const repoUrl = `${baseUrl.toString()}/coopernetes/test-repo.git`;
+        const repoUrl = `${baseUrl.toString()}/test-owner/test-repo.git`;
         const cloneDir: string = path.join(tempDir, 'test-repo-clone');
 
         console.log(
-          `[TEST] Cloning ${testConfig.gitProxyUrl}/coopernetes/test-repo.git to ${cloneDir}`,
+          `[TEST] Cloning ${testConfig.gitProxyUrl}/test-owner/test-repo.git to ${cloneDir}`,
         );
 
         try {
@@ -73,7 +73,7 @@ describe('Git Proxy E2E - Repository Fetch Tests', () => {
           const readmePath: string = path.join(cloneDir, 'README.md');
           expect(fs.existsSync(readmePath)).toBe(true);
 
-          console.log('[TEST] Successfully fetched and verified coopernetes/test-repo');
+          console.log('[TEST] Successfully fetched and verified test-owner/test-repo');
         } catch (error) {
           console.error('[TEST] Failed to clone repository:', error);
           throw error;
@@ -83,16 +83,18 @@ describe('Git Proxy E2E - Repository Fetch Tests', () => {
     );
 
     it(
-      'should successfully fetch finos/git-proxy through git proxy',
+      'should successfully fetch e2e-org/sample-repo through git proxy',
       async () => {
         // Build URL with embedded credentials for reliable authentication
         const baseUrl = new URL(testConfig.gitProxyUrl);
         baseUrl.username = testConfig.gitUsername;
         baseUrl.password = testConfig.gitPassword;
-        const repoUrl = `${baseUrl.toString()}/finos/git-proxy.git`;
-        const cloneDir: string = path.join(tempDir, 'git-proxy-clone');
+        const repoUrl = `${baseUrl.toString()}/e2e-org/sample-repo.git`;
+        const cloneDir: string = path.join(tempDir, 'sample-repo-clone');
 
-        console.log(`[TEST] Cloning ${testConfig.gitProxyUrl}/finos/git-proxy.git to ${cloneDir}`);
+        console.log(
+          `[TEST] Cloning ${testConfig.gitProxyUrl}/e2e-org/sample-repo.git to ${cloneDir}`,
+        );
 
         try {
           const gitCloneCommand: string = `git clone ${repoUrl} ${cloneDir}`;
@@ -120,7 +122,7 @@ describe('Git Proxy E2E - Repository Fetch Tests', () => {
           const readmePath: string = path.join(cloneDir, 'README.md');
           expect(fs.existsSync(readmePath)).toBe(true);
 
-          console.log('[TEST] Successfully fetched and verified finos/git-proxy');
+          console.log('[TEST] Successfully fetched and verified e2e-org/sample-repo');
         } catch (error) {
           console.error('[TEST] Failed to clone repository:', error);
           throw error;

test-e2e.proxy.config.json

@@ -268,7 +268,7 @@ describe('Git Proxy E2E - Repository Push Tests', () => {
       // Get the test-repo repository and add permissions
       const repos = await getRepos(adminCookie);
       const testRepo = repos.find(
-        (r: any) => r.url === 'https://git-server:8443/coopernetes/test-repo.git',
+        (r: any) => r.url === 'https://git-server:8443/test-owner/test-repo.git',
       );
 
       if (testRepo && testRepo._id) {
@@ -299,11 +299,11 @@ describe('Git Proxy E2E - Repository Push Tests', () => {
         const baseUrl = new URL(testConfig.gitProxyUrl);
         baseUrl.username = testConfig.gitUsername;
         baseUrl.password = testConfig.gitPassword;
-        const repoUrl = `${baseUrl.toString()}/coopernetes/test-repo.git`;
+        const repoUrl = `${baseUrl.toString()}/test-owner/test-repo.git`;
         const cloneDir: string = path.join(tempDir, 'test-repo-push');
 
         console.log(
-          `[TEST] Testing push operation to ${testConfig.gitProxyUrl}/coopernetes/test-repo.git`,
+          `[TEST] Testing push operation to ${testConfig.gitProxyUrl}/test-owner/test-repo.git`,
         );
 
         try {
@@ -421,7 +421,7 @@ describe('Git Proxy E2E - Repository Push Tests', () => {
         const baseUrl = new URL(testConfig.gitProxyUrl);
         baseUrl.username = authorizedUser.username;
         baseUrl.password = authorizedUser.password;
-        const repoUrl = `${baseUrl.toString()}/coopernetes/test-repo.git`;
+        const repoUrl = `${baseUrl.toString()}/test-owner/test-repo.git`;
         const cloneDir: string = path.join(tempDir, 'test-repo-authorized-push');
 
         console.log(`[TEST] Testing authorized push with user ${authorizedUser.username}`);
@@ -583,7 +583,7 @@ describe('Git Proxy E2E - Repository Push Tests', () => {
         const baseUrl = new URL(testConfig.gitProxyUrl);
         baseUrl.username = authorizedUser.username;
         baseUrl.password = authorizedUser.password;
-        const repoUrl = `${baseUrl.toString()}/coopernetes/test-repo.git`;
+        const repoUrl = `${baseUrl.toString()}/test-owner/test-repo.git`;
         const cloneDir: string = path.join(tempDir, 'test-repo-approved-push');
 
         console.log(

tests/e2e/fetch.test.ts

@@ -19,14 +19,14 @@
  */
 
 import { beforeAll } from 'vitest';
+import { execSync } from 'child_process';
 
 // Environment configuration - can be overridden for different environments
 export const testConfig = {
   gitProxyUrl: process.env.GIT_PROXY_URL || 'http://localhost:8000/git-server:8443',
   gitProxyUiUrl: process.env.GIT_PROXY_UI_URL || 'http://localhost:8081',
+  gitServerUrl: process.env.GIT_SERVER_URL || 'https://localhost:8443',
   timeout: parseInt(process.env.E2E_TIMEOUT || '30000'),
-  maxRetries: parseInt(process.env.E2E_MAX_RETRIES || '30'),
-  retryDelay: parseInt(process.env.E2E_RETRY_DELAY || '2000'),
   // Git credentials for authentication
   gitUsername: process.env.GIT_USERNAME || 'admin',
   gitPassword: process.env.GIT_PASSWORD || 'admin123',
@@ -39,96 +39,69 @@ export const testConfig = {
       : 'http://localhost:8000/'),
 };
 
+const INFRA_HINT =
+  'The E2E test infrastructure is not running. ' +
+  'Start it with: docker compose up -d\n' +
+  'See CONTRIBUTING.md for details.';
+
 /**
- * Configures git credentials for authentication in a temporary directory
- * @param {string} tempDir - The temporary directory to configure git in
+ * Verifies GitProxy is reachable by hitting its healthcheck endpoint.
+ * Fails immediately instead of retrying — if the infrastructure isn't
+ * running we want to fail fast with a helpful message.
  */
-export function configureGitCredentials(tempDir: string): void {
-  const { execSync } = require('child_process');
-
+async function checkGitProxy(): Promise<void> {
+  const healthUrl = `${testConfig.gitProxyUiUrl}/api/v1/healthcheck`;
   try {
-    // Configure git credentials using URL rewriting
-    const baseUrlParsed = new URL(testConfig.gitProxyBaseUrl);
-
-    // Initialize git if not already done
-    try {
-      execSync('git rev-parse --git-dir', { cwd: tempDir, encoding: 'utf8', stdio: 'pipe' });
-    } catch {
-      execSync('git init', { cwd: tempDir, encoding: 'utf8' });
-    }
-
-    // Configure multiple URL patterns to catch all variations
-    const patterns = [
-      // Most important: the proxy server itself (this is what's asking for auth)
-      {
-        insteadOf: `${baseUrlParsed.protocol}//${baseUrlParsed.host}`,
-        credUrl: `${baseUrlParsed.protocol}//${testConfig.gitUsername}:${testConfig.gitPassword}@${baseUrlParsed.host}`,
-      },
-      // Base URL with trailing slash
-      {
-        insteadOf: testConfig.gitProxyBaseUrl,
-        credUrl: `${baseUrlParsed.protocol}//${testConfig.gitUsername}:${testConfig.gitPassword}@${baseUrlParsed.host}${baseUrlParsed.pathname}`,
-      },
-      // Base URL without trailing slash
-      {
-        insteadOf: testConfig.gitProxyBaseUrl.replace(/\/$/, ''),
-        credUrl: `${baseUrlParsed.protocol}//${testConfig.gitUsername}:${testConfig.gitPassword}@${baseUrlParsed.host}`,
-      },
-    ];
-
-    for (const pattern of patterns) {
-      execSync(`git config url."${pattern.credUrl}".insteadOf "${pattern.insteadOf}"`, {
-        cwd: tempDir,
-        encoding: 'utf8',
-      });
+    const response = await fetch(healthUrl, {
+      method: 'GET',
+      signal: AbortSignal.timeout(5000),
+    });
+    if (response.ok || response.status < 500) {
+      console.log(`GitProxy is reachable at ${testConfig.gitProxyUiUrl}`);
+      return;
     }
-  } catch (error) {
-    console.error('Failed to configure git credentials:', error);
-    throw error;
+    throw new Error(`Healthcheck returned HTTP ${response.status}`);
+  } catch (error: any) {
+    throw new Error(`GitProxy is not reachable at ${healthUrl}.\n${INFRA_HINT}`);
   }
 }
 
-export async function waitForService(
-  url: string,
-  maxAttempts?: number,
-  delay?: number,
-): Promise<void> {
-  const attempts = maxAttempts || testConfig.maxRetries;
-  const retryDelay = delay || testConfig.retryDelay;
-
-  for (let i = 0; i < attempts; i++) {
-    try {
-      const response = await fetch(url, {
-        method: 'GET',
-        headers: { Accept: 'application/json' },
-      });
-      if (response.ok || response.status < 500) {
-        console.log(`Service at ${url} is ready`);
-        return;
-      }
-    } catch (error) {
-      // Service not ready yet
-    }
-
-    if (i < attempts - 1) {
-      console.log(`Waiting for service at ${url}... (attempt ${i + 1}/${attempts})`);
-      await new Promise((resolve) => setTimeout(resolve, retryDelay));
-    }
+/**
+ * Verifies the local git server is reachable by running `git ls-remote`
+ * against a known test repository.
+ */
+function checkGitServer(): void {
+  const repoUrl = `${testConfig.gitServerUrl}/test-owner/test-repo.git`;
+  try {
+    execSync(`git ls-remote ${repoUrl}`, {
+      encoding: 'utf8',
+      timeout: 10000,
+      env: {
+        ...process.env,
+        GIT_TERMINAL_PROMPT: '0',
+        GIT_SSL_NO_VERIFY: '1',
+      },
+      stdio: 'pipe',
+    });
+    console.log(`Git server is reachable at ${testConfig.gitServerUrl}`);
+  } catch (error: any) {
+    throw new Error(`Git server is not reachable at ${repoUrl}.\n${INFRA_HINT}`);
   }
-
-  throw new Error(`Service at ${url} failed to become ready after ${attempts} attempts`);
 }
 
 beforeAll(async () => {
   console.log('Setting up e2e test environment...');
   console.log(`Git Proxy URL: ${testConfig.gitProxyUrl}`);
   console.log(`Git Proxy UI URL: ${testConfig.gitProxyUiUrl}`);
+  console.log(`Git Server URL: ${testConfig.gitServerUrl}`);
   console.log(`Git Username: ${testConfig.gitUsername}`);
   console.log(`Git Proxy Base URL: ${testConfig.gitProxyBaseUrl}`);
 
-  // Wait for the git proxy UI service to be ready
-  // Note: Docker Compose should be started externally (e.g., in CI or manually)
-  await waitForService(`${testConfig.gitProxyUiUrl}/api/v1/healthcheck`);
+  // Pre-flight: verify both services are reachable before running any tests.
+  // These checks fail fast so developers get a clear error instead of
+  // waiting through retries when the Docker environment isn't running.
+  await checkGitProxy();
+  checkGitServer();
 
   console.log('E2E test environment is ready');
 }, testConfig.timeout);