#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 an "abort: no common changegroup version" 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.worker-enable = False

  > [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

  $ 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 http://localhost:$HGPORT

  pulling from http://localhost:$HGPORT/

  requesting all changes

  remote: abort: no common changegroup version

  abort: pull failed on remote

  [100]

  $ 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

  $TESTTMP/server/.hg/requires:lfs

  $ hg identify http://localhost:$HGPORT

  c729025cc5e3

  $ mv $HGRCPATH $HGRCPATH.tmp

  $ cp $HGRCPATH.orig $HGRCPATH

  >>> from __future__ import absolute_import

  >>> from hgclient import bprint, check, readchannel, runcommand, stdout

  >>> @check

  ... def checkflags(server):

  ...     readchannel(server)

  ...     bprint(b'')

  ...     bprint(b'# LFS required- both lfs and non-lfs revlogs have 0x2000 flag')

  ...     stdout.flush()

  ...     runcommand(server, [b'debugprocessors', b'lfs.bin', b'-R',

  ...                b'../server'])

  ...     runcommand(server, [b'debugprocessors', b'nonlfs2.txt', b'-R',

  ...                b'../server'])

  ...     runcommand(server, [b'config', b'extensions', b'--cwd',

  ...                b'../server'])

  ... 

  ...     bprint(b"\n# LFS not enabled- revlogs don't have 0x2000 flag")

  ...     stdout.flush()

  ...     runcommand(server, [b'debugprocessors', b'nonlfs3.txt'])

  ...     runcommand(server, [b'config', b'extensions'])

  # LFS required- both lfs and non-lfs revlogs have 0x2000 flag

  *** runcommand debugprocessors lfs.bin -R ../server