e2e: allow external bundle URI testing

Testing performance via localhost may be a bit of a cheat, in some
views. The existing performance test also constructs a fresh bundle
containing all of the existing objects, without needing incremental
bundles and the creationToken heuristic.

To get a possibly more accurate result, we can test across a real
network boundary and on a machine that has been updating bundles based
on our existing bundle schedule, demonstrating performance for a bundle
server after some time in use.

To promote this, add a performance test (marked @slow) but with a
"Given" that expects a TEST_BUNDLE_SERVER_URI environment variable. If
this variable does not exist, the test will fail quickly. But, if it
exists, it will append one of the 'route' values for the test so we can
compare cloning with that bundle URI versus without.

Here is the output I got for my machines (testing on a Linux machine
connected over LAN to the bundle URI Linux machine):

Clone execution time for https://github.com/git/git.git: 13.045381171941758s (bundle URI) vs. 17.917231523036957s (no bundle URI)
Clone execution time for https://github.com/kubernetes/kubernetes.git: 46.17043500101566s (bundle URI) vs. 41.95928572797775s (no bundle URI)
Clone execution time for https://github.com/homebrew/homebrew-core: 36.88277485907078s (bundle URI) vs. 358.64118642401695s (no bundle URI)
Clone execution time for https://github.com/torvalds/linux.git: 203.00328045904635s (bundle URI) vs. 292.6792869710922s (no bundle URI)

It is interesting to me that in this test _and_ the existing performance
test that bundle URIs do not do as good of a job on
kubernetes/kubernetes as cloning completely from GitHub. Perhaps there
is something with our pack-objects settings that could be improved
during bundle creation that would make it easier to unpack the bundle.
Some investigation is worthwhile for that case. However, there are also
interesting cases like homebrew/homebrew-core that are substantially
slower from GitHub. There are definitely a few trees that are
particularly difficult to parse in that repo, so there could be more
time computing the reachability on the server _or_ it could be worse
deltas for those big trees.

Author: derrickstolee

test/e2e/features/performance.feature

@@ -14,6 +14,22 @@ Feature: Bundle server performance
     Examples:
       | repo                                          |
       | https://github.com/git/git.git                | # takes ~2 minutes
-      | https://github.com/git-for-windows/git.git    | # takes ~2 minutes
       | https://github.com/kubernetes/kubernetes.git  | # takes ~3 minutes
+      | https://github.com/homebrew/homebrew-core     | # takes ~15(!) minutes
       | https://github.com/torvalds/linux.git         | # takes ~30(!) minutes
+
+  @slow
+  Scenario Outline: Comparing clone performance with external bundle server
+    Given a remote repository '<repo>'
+    Given a bundle URI from TEST_BUNDLE_SERVER_URI
+    Given a bundle route '<route>'
+    When I clone from the remote repo with a bundle URI
+    When another developer clones from the remote repo without a bundle URI
+    Then I compare the clone execution times
+
+    Examples:
+      | repo                                          | route                  |
+      | https://github.com/git/git.git                | git/git                |
+      | https://github.com/kubernetes/kubernetes.git  | kubernetes/kubernetes  |
+      | https://github.com/homebrew/homebrew-core     | homebrew/homebrew-core |
+      | https://github.com/torvalds/linux.git         | torvalds/linux         |

test/e2e/features/step_definitions/remote.ts

@@ -2,6 +2,7 @@ import { Given, } from '@cucumber/cucumber'
 import { RemoteRepo } from '../classes/remote'
 import { BundleServerWorld } from '../support/world'
 import * as path from 'path'
+import { env } from 'process'
 
 /**
  * Steps relating to the setup of the remote repository users will clone from.
@@ -11,6 +12,18 @@ Given('a remote repository {string}', async function (this: BundleServerWorld, u
   this.remote = new RemoteRepo(false, url)
 })
 
+Given('a bundle URI from TEST_BUNDLE_SERVER_URI', async function (this: BundleServerWorld) {
+  this.bundleURIBase = env["TEST_BUNDLE_SERVER_URI"]
+
+  if (this.bundleURIBase == "") {
+    throw new Error("This test requires TEST_BUNDLE_SERVER_URI")
+  }
+})
+
+Given('a bundle route {string}', async function (this: BundleServerWorld, route: string) {
+  this.bundleURI = this.bundleURIBase + route
+})
+
 Given('a new remote repository with main branch {string}', async function (this: BundleServerWorld, mainBranch: string) {
   this.remote = new RemoteRepo(true, path.join(this.trashDirectory, "server"), mainBranch)
 })

test/e2e/features/step_definitions/repository.ts

@@ -42,12 +42,20 @@ Given('another user removed {int} commits and added {int} commits to {string}',
 
 Given('I cloned from the remote repo with a bundle URI', async function (this: BundleServerWorld) {
   const user = User.Me
-  this.cloneRepositoryFor(user, this.bundleServer.bundleUri())
+  if (this.bundleURI !== undefined) {
+    this.cloneRepositoryFor(User.Me, this.bundleURI)
+  } else {
+    this.cloneRepositoryFor(User.Me, this.bundleServer.bundleUri())
+  }
   utils.assertStatus(0, this.getRepo(user).cloneResult)
 })
 
 When('I clone from the remote repo with a bundle URI', async function (this: BundleServerWorld) {
-  this.cloneRepositoryFor(User.Me, this.bundleServer.bundleUri())
+  if (this.bundleURI !== undefined) {
+    this.cloneRepositoryFor(User.Me, this.bundleURI)
+  } else {
+    this.cloneRepositoryFor(User.Me, this.bundleServer.bundleUri())
+  }
 })
 
 When('another developer clones from the remote repo without a bundle URI', async function (this: BundleServerWorld) {
@@ -76,7 +84,12 @@ Then('bundles are downloaded and used', async function (this: BundleServerWorld)
   let result = clonedRepo.runGit("config", "--get", "fetch.bundleURI")
   utils.assertStatus(0, result, "'fetch.bundleURI' is not set after clone")
   const actualURI = result.stdout.toString().trim()
-  assert.strictEqual(actualURI, this.bundleServer.bundleUri())
+
+  if (this.bundleURI !== undefined) {
+    assert.strictEqual(actualURI, this.bundleURI)
+  } else {
+    assert.strictEqual(actualURI, this.bundleServer.bundleUri())
+  }
 
   result = clonedRepo.runGit("for-each-ref", "--format=%(refname)")
   utils.assertStatus(0, result, "git for-each-ref failed")

test/e2e/features/support/world.ts

@@ -25,6 +25,8 @@ export class BundleServerWorld extends World<BundleServerParameters> {
   // Bundle server
   bundleServer: BundleServer
   remote: RemoteRepo | undefined
+  bundleURIBase: string | undefined
+  bundleURI: string | undefined
 
   // Users
   repoMap: Map<User, ClonedRepository>