#testcases lfsremote-on lfsremote-off

#require serve no-reposimplestore no-chg

This test splits `hg serve` with and without using the extension into separate

tests cases.  The tests are broken down as follows, where "LFS"/"No-LFS"

indicates whether or not there are commits that use an LFS file, and "D"/"E"

indicates whether or not the extension is loaded.  The "X" cases are not tested

individually, because the lfs requirement causes the process to bail early if

the extension is disabled.

.                        Server

.

.                    No-LFS        LFS

.            +----------------------------+

.            |   ||  D  |  E  |  D  |  E  |

.            |---++=======================|

.  C         | D || N/A | #1  |  X  | #4  |

.  l    No   +---++-----------------------|

.  i    LFS  | E || #2  | #2  |  X  | #5  |

.  e         +---++-----------------------|

.  n         | D ||  X  |  X  |  X  |  X  |

.  t    LFS  |---++-----------------------|

.            | E || #3  | #3  |  X  | #6  |

.            |---++-----------------------+

make command server magic visible

#if windows

  $ PYTHONPATH="$TESTDIR/../contrib;$PYTHONPATH"

#else

  $ PYTHONPATH="$TESTDIR/../contrib:$PYTHONPATH"

#endif

  $ export PYTHONPATH

  $ hg init server

  $ SERVER_REQUIRES="$TESTTMP/server/.hg/requires"

  $ cat > $TESTTMP/debugprocessors.py <<EOF

  > from mercurial import (

  >     cmdutil,

  >     commands,

  >     pycompat,

  >     registrar,

  > )

  > cmdtable = {}

  > command = registrar.command(cmdtable)

  > @command(b'debugprocessors', [], b'FILE')

  > def debugprocessors(ui, repo, file_=None, **opts):

  >     opts = pycompat.byteskwargs(opts)

  >     opts[b'changelog'] = False

  >     opts[b'manifest'] = False

  >     opts[b'dir'] = False

  >     rl = cmdutil.openrevlog(repo, b'debugprocessors', file_, opts)

  >     for flag, proc in rl._flagprocessors.items():

  >         ui.status(b"registered processor '%#x'\n" % (flag))

  > EOF

Skip the experimental.changegroup3=True config.  Failure to agree on this comes

first, and causes a "ValueError: no common changegroup version" or "abort:

HTTP Error 500: Internal Server Error", if the extension is only loaded on one

side.  If that *is* enabled, the subsequent failure is "abort: missing processor

for flag '0x2000'!" if the extension is only loaded on one side (possibly also

masked by the Internal Server Error message).

  $ cat >> $HGRCPATH <<EOF

  > [extensions]

  > debugprocessors = $TESTTMP/debugprocessors.py

  > [experimental]

  > lfs.disableusercache = True

  > [lfs]

  > threshold=10

  > [web]

  > allow_push=*

  > push_ssl=False

  > EOF

  $ cp $HGRCPATH $HGRCPATH.orig

#if lfsremote-on

  $ hg --config extensions.lfs= -R server \

  >    serve -p $HGPORT -d --pid-file=hg.pid --errorlog=$TESTTMP/errors.log

#else

  $ hg --config extensions.lfs=! -R server \

  >    serve -p $HGPORT -d --pid-file=hg.pid --errorlog=$TESTTMP/errors.log

#endif

  $ cat hg.pid >> $DAEMON_PIDS

  $ hg clone -q http://localhost:$HGPORT client

  $ grep 'lfs' client/.hg/requires $SERVER_REQUIRES

  [1]

This trivial repo will force commandserver to load the extension, but not call

reposetup() on another repo actually being operated on.  This gives coverage

that wrapper functions are not assuming reposetup() was called.

  $ hg init $TESTTMP/cmdservelfs

  $ cat >> $TESTTMP/cmdservelfs/.hg/hgrc << EOF

  > [extensions]

  > lfs =

  > EOF

--------------------------------------------------------------------------------

Case #1: client with non-lfs content and the extension disabled; server with

non-lfs content, and the extension enabled.

  $ cd client

  $ echo 'non-lfs' > nonlfs.txt

  >>> from __future__ import absolute_import

  >>> from hgclient import check, readchannel, runcommand

  >>> @check

  ... def diff(server):

  ...     readchannel(server)

  ...     # run an arbitrary command in the repo with the extension loaded

  ...     runcommand(server, [b'id', b'-R', b'../cmdservelfs'])

  ...     # now run a command in a repo without the extension to ensure that

  ...     # files are added safely..

  ...     runcommand(server, [b'ci', b'-Aqm', b'non-lfs'])

  ...     # .. and that scmutil.prefetchfiles() safely no-ops..

  ...     runcommand(server, [b'diff', b'-r', b'.~1'])

  ...     # .. and that debugupgraderepo safely no-ops.

  ...     runcommand(server, [b'debugupgraderepo', b'-q', b'--run'])

  *** runcommand id -R ../cmdservelfs

  000000000000 tip

  *** runcommand ci -Aqm non-lfs

  *** runcommand diff -r .~1

  diff -r 000000000000 nonlfs.txt

  --- /dev/null	Thu Jan 01 00:00:00 1970 +0000

  +++ b/nonlfs.txt	Thu Jan 01 00:00:00 1970 +0000

  @@ -0,0 +1,1 @@

  +non-lfs

  *** runcommand debugupgraderepo -q --run

  upgrade will perform the following actions:

  requirements

     preserved: dotencode, fncache, generaldelta, revlogv1, sparserevlog, store

  beginning upgrade...

  repository locked and read-only

  creating temporary repository to stage migrated data: * (glob)

  (it is safe to interrupt this process any time before data migration completes)

  migrating 3 total revisions (1 in filelogs, 1 in manifests, 1 in changelog)

  migrating 324 bytes in store; 129 bytes tracked data

  migrating 1 filelogs containing 1 revisions (73 bytes in store; 8 bytes tracked data)

  finished migrating 1 filelog revisions across 1 filelogs; change in size: 0 bytes

  migrating 1 manifests containing 1 revisions (117 bytes in store; 52 bytes tracked data)

  finished migrating 1 manifest revisions across 1 manifests; change in size: 0 bytes

  migrating changelog containing 1 revisions (134 bytes in store; 69 bytes tracked data)

  finished migrating 1 changelog revisions; change in size: 0 bytes

  finished migrating 3 total revisions; total change in store size: 0 bytes

  copying phaseroots

  data fully migrated to temporary repository

  marking source repository as being upgraded; clients will be unable to read from repository

  starting in-place swap of repository data

  replaced files will be backed up at * (glob)

  replacing store...

  store replacement complete; repository was inconsistent for *s (glob)

  finalizing requirements file and making repository readable again

  removing temporary repository * (glob)

  copy of old repository backed up at * (glob)

  the old repository will not be deleted; remove it to free up disk space once the upgraded repository is verified

  $ grep 'lfs' .hg/requires $SERVER_REQUIRES

  [1]

#if lfsremote-on

  $ hg push -q

  $ grep 'lfs' .hg/requires $SERVER_REQUIRES

  [1]

  $ hg clone -q http://localhost:$HGPORT $TESTTMP/client1_clone

  $ grep 'lfs' $TESTTMP/client1_clone/.hg/requires $SERVER_REQUIRES

  [1]

  $ hg init $TESTTMP/client1_pull

  $ hg -R $TESTTMP/client1_pull pull -q http://localhost:$HGPORT

  $ grep 'lfs' $TESTTMP/client1_pull/.hg/requires $SERVER_REQUIRES

  [1]

  $ hg identify http://localhost:$HGPORT

  d437e1d24fbd

#endif

--------------------------------------------------------------------------------

Case #2: client with non-lfs content and the extension enabled; server with

non-lfs content, and the extension state controlled by #testcases.

  $ cat >> $HGRCPATH <<EOF

  > [extensions]

  > lfs =

  > EOF

  $ echo 'non-lfs' > nonlfs2.txt

  $ hg ci -Aqm 'non-lfs file with lfs client'

Since no lfs content has been added yet, the push is allowed, even when the

extension is not enabled remotely.

  $ hg push -q

  $ grep 'lfs' .hg/requires $SERVER_REQUIRES

  [1]

  $ hg clone -q http://localhost:$HGPORT $TESTTMP/client2_clone

  $ grep 'lfs' $TESTTMP/client2_clone/.hg/requires $SERVER_REQUIRES

  [1]

  $ hg init $TESTTMP/client2_pull

  $ hg -R $TESTTMP/client2_pull pull -q http://localhost:$HGPORT

  $ grep 'lfs' $TESTTMP/client2_pull/.hg/requires $SERVER_REQUIRES

  [1]

  $ hg identify http://localhost:$HGPORT

  1477875038c6

--------------------------------------------------------------------------------

Case #3: client with lfs content and the extension enabled; server with

non-lfs content, and the extension state controlled by #testcases.  The server

should have an 'lfs' requirement after it picks up its first commit with a blob.

  $ echo 'this is a big lfs file' > lfs.bin

  $ hg ci -Aqm 'lfs'

  $ grep 'lfs' .hg/requires $SERVER_REQUIRES

  .hg/requires:lfs

#if lfsremote-off

  $ hg push -q

  abort: required features are not supported in the destination: lfs

  (enable the lfs extension on the server)

  [255]

#else

  $ hg push -q

#endif

  $ grep 'lfs' .hg/requires $SERVER_REQUIRES

  .hg/requires:lfs

  $TESTTMP/server/.hg/requires:lfs (lfsremote-on !)

  $ hg clone -q http://localhost:$HGPORT $TESTTMP/client3_clone

  $ grep 'lfs' $TESTTMP/client3_clone/.hg/requires $SERVER_REQUIRES || true

  $TESTTMP/client3_clone/.hg/requires:lfs (lfsremote-on !)

  $TESTTMP/server/.hg/requires:lfs (lfsremote-on !)

  $ hg init $TESTTMP/client3_pull

  $ hg -R $TESTTMP/client3_pull pull -q http://localhost:$HGPORT

  $ grep 'lfs' $TESTTMP/client3_pull/.hg/requires $SERVER_REQUIRES || true

  $TESTTMP/client3_pull/.hg/requires:lfs (lfsremote-on !)

  $TESTTMP/server/.hg/requires:lfs (lfsremote-on !)

Test that the commit/changegroup requirement check hook can be run multiple

times.

  $ hg clone -qr 0 http://localhost:$HGPORT $TESTTMP/cmdserve_client3

  $ cd ../cmdserve_client3

  >>> from __future__ import absolute_import

  >>> from hgclient import check, readchannel, runcommand

  >>> @check

  ... def addrequirement(server):

  ...     readchannel(server)

  ...     # change the repo in a way that adds the lfs requirement

  ...     runcommand(server, [b'pull', b'-qu'])

  ...     # Now cause the requirement adding hook to fire again, without going

  ...     # through reposetup() again.

  ...     with open('file.txt', 'wb') as fp:

  ...         fp.write(b'data')

  ...     runcommand(server, [b'ci', b'-Aqm', b'non-lfs'])

  *** runcommand pull -qu

  *** runcommand ci -Aqm non-lfs

  $ cd ../client

The difference here is the push failed above when the extension isn't

enabled on the server.

  $ hg identify http://localhost:$HGPORT

  8374dc4052cb (lfsremote-on !)

  1477875038c6 (lfsremote-off !)

Don't bother testing the lfsremote-off cases- the server won't be able

to launch if there's lfs content and the extension is disabled.

#if lfsremote-on

--------------------------------------------------------------------------------

Case #4: client with non-lfs content and the extension disabled; server with

lfs content, and the extension enabled.

  $ cat >> $HGRCPATH <<EOF

  > [extensions]

  > lfs = !

  > EOF

  $ hg init $TESTTMP/client4

  $ cd $TESTTMP/client4

  $ cat >> .hg/hgrc <<EOF

  > [paths]

  > default = http://localhost:$HGPORT

  > EOF

  $ echo 'non-lfs' > nonlfs2.txt

  $ hg ci -Aqm 'non-lfs'

  $ grep 'lfs' .hg/requires $SERVER_REQUIRES

  $TESTTMP/server/.hg/requires:lfs

  $ hg push -q --force

  warning: repository is unrelated

  $ grep 'lfs' .hg/requires $SERVER_REQUIRES

  $TESTTMP/server/.hg/requires:lfs

  $ hg clone http://localhost:$HGPORT $TESTTMP/client4_clone

  (remote is using large file support (lfs), but it is explicitly disabled in the local configuration)

  abort: repository requires features unknown to this Mercurial: lfs!

  (see https://mercurial-scm.org/wiki/MissingRequirement for more information)

  [255]

  $ grep 'lfs' $TESTTMP/client4_clone/.hg/requires $SERVER_REQUIRES

  grep: $TESTTMP/client4_clone/.hg/requires: $ENOENT$

  $TESTTMP/server/.hg/requires:lfs

  [2]

TODO: fail more gracefully.

  $ hg init $TESTTMP/client4_pull

  $ hg -R $TESTTMP/client4_pull pull -q http://localhost:$HGPORT

  abort: HTTP Error 500: Internal Server Error

  [255]

  $ grep 'lfs' $TESTTMP/client4_pull/.hg/requires $SERVER_REQUIRES

  $TESTTMP/server/.hg/requires:lfs

  $ hg identify http://localhost:$HGPORT

  03b080fa9d93

--------------------------------------------------------------------------------

Case #5: client with non-lfs content and the extension enabled; server with

lfs content, and the extension enabled.

  $ cat >> $HGRCPATH <<EOF

  > [extensions]

  > lfs =

  > EOF

  $ echo 'non-lfs' > nonlfs3.txt

  $ hg ci -Aqm 'non-lfs file with lfs client'

  $ hg push -q

  $ grep 'lfs' .hg/requires $SERVER_REQUIRES

  $TESTTMP/server/.hg/requires:lfs

  $ hg clone -q http://localhost:$HGPORT $TESTTMP/client5_clone

  $ grep 'lfs' $TESTTMP/client5_clone/.hg/requires $SERVER_REQUIRES

  $TESTTMP/client5_clone/.hg/requires:lfs

  $TESTTMP/server/.hg/requires:lfs

  $ hg init $TESTTMP/client5_pull

  $ hg -R $TESTTMP/client5_pull pull -q http://localhost:$HGPORT

  $ grep 'lfs' $TESTTMP/client5_pull/.hg/requires $SERVER_REQUIRES

  $TESTTMP/client5_pull/.hg/requires:lfs