# Command Line Interface

Basic syntax is:

```bash
concordia [dir] [options]
```

where:

* A parameter between`[` and `]` means that it is *optional*.
* `[dir]` is the directory that contains your `.feature` files. Whether it is not informed, the tool searches all the subdirectories from the current path.
* `[options]` changes how the tool behaves.

You can run `concordia --help` to see all the **command line interface** (CLI) options.

{% hint style="warning" %}
You need to use **`npx`** before the commands if you opted for a [local installation](https://concordialang.gitbook.io/concordialang/master#local-installation-recommended).
{% endhint %}

## Configuration

### --config

> Indicates a [configuration file](https://concordialang.gitbook.io/concordialang/introduction/configuration)

Alias: `-c`

```
concordia --config /path/to/.concordiarc
```

By default the configuration file is loaded from the current directory.

### --init

> Creates a [configuration file](https://concordialang.gitbook.io/concordialang/introduction/configuration) and optionally installs plug-ins and databases.

```
concordia --init
```

This command asks about your preferences. By hitting `Enter` without giving an answer, it will select the suggested (default) value. You can use `Up` and `Down` to navigate the answers and hit `Enter` to select it. For multiple selection (when available), hit`Space`.

By using a [configuration file](https://concordialang.gitbook.io/concordialang/introduction/configuration) (e.g.  `.concordiarc`) you avoid informing the configured parameters in the console/terminal. For instance, whether `plugin` is defined in the configuration file, you don't need to inform `--plugin` anymore.

{% hint style="info" %}
CLI options take precedence over values from [configuration files](https://concordialang.gitbook.io/concordialang/introduction/configuration).
{% endhint %}

### --save-config

> Add CLI parameters to the configuration file

The following example will consider the given `directory` and add it to the configuration file:

```
concordia --save-config --directory ./features
```

## Directories and files

### --directory

> Indicates the directory that has `.feature` and `.testcase` files.

Alias: `-d`

When not given, it will search the current directory and all subdirectories recursively.

{% hint style="info" %}
We strongly recommend to use it or set it in the [configuration file](https://concordialang.gitbook.io/concordialang/introduction/configuration).
{% endhint %}

Example:

```
concordia --directory ./features
```

This is equivalent to:

```
concordia ./features
```

{% hint style="info" %}
You can use it with [`--no-recursive`](#no-recursive) to disable recursive search.
{% endhint %}

### --file

> Specifies `.feature` files to consider

Aliases: `-f`, `--files`

Files must be separated by comma.

```
concordia --file "file1.feature,/path/to/file2.feature"
```

Whether the command also informs a directory (e.g. [`--directory`](#directory)), it searches the files inside the directory. Example:

```
concordia ./feature --file "f1.feature,f2.feature"
```

The example above will search for `./feature/f1.feature` and `./feature/f1.feature`.

### --ignore

> Specify `.feature` files to ignore when a directory is informed

Alias: `-i`

Files must be separated by comma.

```
concordia ./feature --ignore "f3.feature,f4.feature"
```

### --no-recursive

> Disables recursive search when a directory is informed

```
concordia ./features --no-recursive
```

## Output directories

{% hint style="info" %}
The directories will be used by a plug-in. We strongly recommend that you specify them in a [configuration file](https://concordialang.gitbook.io/concordialang/introduction/configuration).
{% endhint %}

### --dir-result

> Specifies the directory for test reports and screenshots.

Alias: `-O`

```
concordia --dir-result output
```

### --dir-script

> Specifies the directory for test script files.

Alias: `-o`

```
concordia --dir-script test
```

## Language and locale

### --language

> Sets the default language to consider.

Alias: `-l`

The language code must have only 2 characters and needs to be one of the [available languages](#language-list).

```bash
concordia --language pt
```

### --language-list

> Lists the available language codes.

```bash
concordia --language-list
```

### --locale-list

> Lists the available locales.

```bash
concordia --locale-list
```

## Processing and output

### --just-script

> Just generates test scripts

```bash
concordia --just-script
```

### --just-spec

> Just verifies specification files

```bash
concordia --just-spec
```

### --just-test-case

> Just generates test cases

```bash
concordia --just-script
```

### --just-run

> Just execute test script files

```bash
concordia --just-run
```

### --no-script

> Avoids generating test scripts

```bash
concordia --no-script
```

### --no-spec

> Avoids processing specification files

```bash
concordia --no-spec
```

### --no-test-case

> Avoids generating test cases

```bash
concordia --no-test-case
```

### --no-result

> Avoids reading test scripts' results

```bash
concordia --no-result
```

### --no-run

> Avoids running test scripts

```bash
concordia --no-run
```

{% hint style="info" %}
Use **`-x`** to combine **`--no-run`** and **`--no-result`**

```bash
concordia -x
```

{% endhint %}

### --verbose

> Uses a verbose output

```
concordia --verbose
```

## Test script execution

{% hint style="info" %}
These parameters require a plugin ([`--plugin`](#plugin)) and some plug-ins may not support them.
{% endhint %}

### --instances

> Number of parallel instances to execute.

Alias: `-I`

```bash
concordia --instances 2
```

### --headless

> Executes browsers in [headless mode](https://en.wikipedia.org/wiki/Headless_browser).

Alias: `-H`

```bash
concordia --headless
```

### --script-file

> Sets one or more test script files to execute

Aliases: `-F`, `--script-files`

Files must be separated by comma.

```bash
concordia --script-file "test1.js,test2.js"
```

### --script-grep

> Sets a text or regular expression to filter the files to execute

Alias: `-G`

```bash
concordia --script-grep "Sales"
```

### --target

> Sets target browsers or platforms to execute

Alias: `-T`

Browser or platforms must be separated by comma.

```bash
concordia --target "chrome,firefox,edge"
```

## Plug-in

{% hint style="info" %}
You can omit the prefix `concordialang-` from plug-in names. For instance, `concordialang-codeceptjs-playwright` becomes`codeceptjs-playwright`.
{% endhint %}

### --plugin

> Uses the given plug-in (if installed)

Alias: `-p`

```bash
concordia --plugin <plugin>
```

{% hint style="info" %}
You can use it with **`-x`** to **avoid running test scripts** and reading their output:

```bash
concordia -p <plugin> -x
```

{% endhint %}

### --plugin-about

> Shows information about an installed plug-in

Alias: `--plugin-info`

```bash
concordia --plugin-info <plugin>
```

### --plugin-install

> Installs a plug-in

```bash
concordia --plugin-install <plugin>
```

### --plugin-list

> Lists installed plug-ins

```bash
concordia --plugin-list
```

### --plugin-serve

> Starts a testing server for a plug-in

Alias: `-S`

```bash
concordia --plugin-serve <plugin>
```

The testing server will keep running. Thus, it's a good idea to open a separate terminal/console for it. To stop it later, type `Ctrl` + `C`.

### --plugin-uninstall

> Uninstalls a plug-in

```bash
concordia --plugin-uninstall <plugin>
```

## Database

{% hint style="info" %}
See [Using Databases](https://concordialang.gitbook.io/concordialang/introduction/databases) for the list of available databases.
{% endhint %}

### --db-install

> Installs a database driver

```bash
concordia --db-install <database>
```

### --db-list

> Lists installed databases

```bash
concordia --db-list
```

### --db-uninstall

> Uninstalls a database driver

```bash
concordia --db-uninstall <database>
```

## Random generation

### --random-max-string-size

> Maximum random string size to generate, when free values are allowed.

The default value is `500` .

```
concordia --random-max-string-size 100
```

### --random-min-string-size

> Minimum random string size to generate, when free values are allowed.

The default value is `0` .

```
concordia --random-min-string-size 1
```

### --random-tries

> Random tries to generate invalid values.

When there is a set of valid values and any value different from those in the set is considered an invalid, random generation is used to produce an invalid value. This parameter defines how many tries to take. Usually it gets on the first try.

The default value is `5` .

```
concordia --random-tries 10
```

### --seed

> Sets a [random seed](https://en.wikipedia.org/wiki/Random_seed)

```
concordia --seed="example"
```

Concordia Compiler can use random selection in its algorithms. By default, it generates the seed using the current date and time. Using the same seed makes the algorithms produce the same output (*e.g.*, same values and paths). While that's interesting for reproducing a past behavior, **we don't recommend it** for finding new defects. Using new seeds, Concordia Compiler will select different test data, test oracles, and test paths over time.

{% hint style="info" %}
You can also set the algorithms to use, in order to avoid random selection. Full combination (therefore full coverage of the requirements) can be achieved and it is recommend for complete checking before a new release. However, it may take some time to execute.
{% endhint %}

## Combination strategies

\--comb-data

\--comb-invalid

\--comb-state

\--comb-variant

## File formats and extensions

{% hint style="info" %}
**You probably don't need to use them, unless you're facing problems to read files.**
{% endhint %}

### --line-breaker

> Sets the character(s) used for breaking lines.

Since by default the line breaker is detected automatically, this command may not be useful for you in most cases.

```bash
concordia --line-breaker "\n"
```

Note on line breakers:

* Linux uses `"\n"`
* MacOS uses `"\r"`
* Windows uses `"\r\n"`

### --encoding

> Sets the expected file encoding

Alias: `-e`

The default is `utf8`. Possible values are:

* `ascii`
* `latin1`
* `ucs2` or `ucs-2`
* `utf16le` or `utf-16le`
* `utf8` or `utf-8`

```bash
concordia --encoding latin1
```

## Information

### --about

> Shows information about the compiler.

```bash
concordia --about
```

### --help

> Shows the available commands

```bash
concordia --help
```

### --newer

> Verify if there is a newer version.

```bash
concordia --newer
```

### --version

> Shows the current version.

```bash
concordia --version
```