# Forgejo end-to-end tests

- [Forgejo end-to-end tests](#forgejo-end-to-end-tests)
  - [Removing legacy tests](#removing-legacy-tests)
  - [Hacking](#hacking)
    - [Running from locally built binary](#running-from-locally-built-binary)
      - [Forgejo](#forgejo)
      - [Forgejo runner](#forgejo-runner)
    - [Running from locally built container image](#running-from-locally-built-container-image)
  - [Running actions tests locally](#running-actions-tests-locally)
  - [Running federation tests locally](#running-federation-tests-locally)
    - [Federated Mastodon Follow Test](#federated-mastodon-follow-test)
  - [Running other tests locally](#running-other-tests-locally)
  - [Running tests in Docker/Podman](#running-tests-in-dockerpodman)

A series of tests scenarios and assertions covering
[Forgejo](https://codeberg.org/forgejo/forgejo) and the [Forgejo
runner](https://code.forgejo.org/forgejo/runner).

They are designed to run using Forgejo releases and development
versions compiled from designated repositories.

## Removing legacy tests

End-to-end tests cover the supported range of releases and when one of
them is EOL, it must be removed as well as the tests that target it
specifically. Otherwise the test suite would grow indefinitely.

When a release is EOL, a branch is cut with a name following the
pattern `legacy/vX.Y-vA.B`. For instance when `v8.0` is published and
`v1.21` is EOL, the branch `legacy/v8.0-v1.21` is cut.

## Hacking

docker and sudo must be installed with insecure registries allowed in
/etc/docker/daemon.json for the IP that will be used for forgejo such
as:

```json
{
  "insecure-registries": [ "10.0.0.0/8" ]
}
```

Use setup-forgejo from source.

The [setup-forgejo](https://code.forgejo.org/actions/setup-forgejo)
repository is a [Forgejo
Action](https://forgejo.org/docs/v7.0/user/actions/) which is meant
to be used in workflows. However, it is implemented as shell scripts that
can also be used to create Forgejo instances and runners locally. This
is convenient for testing and the reason why it needs to be added to the PATH.
For instance, it is a dependency of the `end-to-end.sh` script.

```sh
git clone https://code.forgejo.org/actions/setup-forgejo
export PATH=$(pwd)/setup-forgejo:$PATH
git clone https://code.forgejo.org/forgejo/end-to-end
cd end-to-end
```

### Running from locally built binary

Before injecting a manually built binary, make sure a simple test was
run so that the directories are populated.

#### Forgejo

From a checkout of https://codeberg.org/forgejo/forgejo/

```sh
make clean-all && make frontend && make TAGS='bindata sqlite sqlite_unlock_notify' generate forgejo
cp -a forgejo /srv/forgejo-binaries/forgejo-11.0
```

It will be used whenever the version `11.0` is specified in a test.

#### Forgejo runner

From a checkout of https://code.forgejo.org/forgejo/runner

```sh
make --always-make forgejo-runner
cp forgejo-runner /tmp/forgejo-end-to-end/forgejo-runner
```

### Running from locally built container image

```bash
docker buildx build --output=type=docker --tag codeberg.org/forgejo/forgejo:latest .
```

## Running actions tests locally

To run and debug workflows from `actions/example-*`, from the root of
the source directory, with docker and forgejo-curl.sh installed, mimic
what `.forgejo/workflows/end-to-end.yml` does. There may be some manual
tweaking (such as creating temporary directories) because the tests
run as root in the context of Forgejo Actions and assume they have
admin permissions. But they do not need to run as root and must work
fine when run as a regular user.

```sh
export FORGEJO_RUNNER_LOGS=/tmp/forgejo-end-to-end/forgejo-runner.log
./end-to-end.sh run dependencies
./end-to-end.sh actions_setup 10.0
firefox 0.0.0.0:3000 # user root / admin1234
./end-to-end.sh actions_verify_example echo
./end-to-end.sh actions_teardown
```

Note that `with-docker-tcp` requires the docker daemon listens to
tcp://127.0.0.1:2375. See `actions/actions.sh` for how to do that.

## Running federation tests locally

To run and debug scenarios from `federation/*`, from the root of
the source directory, mimic what `.forgejo/workflows/end-to-end.yml` does.

```sh
./end-to-end.sh run dependencies
./end-to-end.sh federation_setup 12.0
firefox 0.0.0.0:3001 # user root / admin1234
firefox 0.0.0.0:3002 # user root / admin1234
firefox 0.0.0.0:3003 # user root / admin1234
./end-to-end.sh federation_verify_scenario star
./end-to-end.sh federation_verify_scenario gotosocial
./end-to-end.sh federation_verify_scenario mastodon
./end-to-end.sh federation_teardown
```

## Running other tests locally

To run and debug tests, from the root of the source directory.

Run one test. When the test fails the instance can be inspected at http://0.0.0.0:3000

```sh
./end-to-end.sh test_packages_alpine
./end-to-end.sh test_storage_stable_s3 minio
```

Cleanup. It will teardown the Forgejo instance.

```sh
./end-to-end.sh stop
```

## Running tests in Docker/Podman

There is an included Dockerfile in which the tests can be run. Building the
conatiner will copy the the entire repo state into the container from which
changes to the tests can be tested. Note: running in podman requires the
`--privileged` flag because this will run podman in podman for some tests.