### Install Dependencies and Run Tests

Source: https://github.com/kros-sk/teapie/blob/master/CONTRIBUTING.md

Install project dependencies using 'dotnet restore' and run tests to ensure the project is set up correctly.

```sh
dotnet restore
```

```sh
dotnet test
```

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

### Run Test Case Examples

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/test-case/test-case.md

Demonstrates how to run test cases using the `teapie` command. Includes examples for both multi-file (.http) and single-file (.tp) formats.

```sh
# Multi-file format
teapie "./Tests/002-Cars/002-Edit-Car-req.http"

# Single-file format (.tp)
teapie "./Tests/002-Cars/004-Car-Operations.tp"
```

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

### Install TeaPie and Skills via AI Agent Prompt

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/ai-agent-skills.md

This prompt guides an AI agent to install the TeaPie.Tool globally and then download TeaPie skills for the project.

```text
Install TeaPie.Tool globally (if not already installed) and use the `teapie install-skills` command to download TeaPie skills into this project.

1. Install TeaPie.Tool:
   dotnet tool install -g TeaPie.Tool

2. Download skills:
   teapie install-skills
```

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

### Start Mock Server

Source: https://github.com/kros-sk/teapie/blob/master/demo/README.md

Starts the mock server for the demo using mockoon-cli. The server runs on http://localhost:3001 by default. Configuration can be modified in server/CarRentalServer.json.

```sh
cd demo
mockoon-cli start --data ./server/CarRentalServer.json
```

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

### AI Agent Prompt for TeaPie Setup

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/getting-started.md

A prompt to guide an AI agent in setting up TeaPie within a project, including installation, skill download, and initialization.

```text
Set up TeaPie in this project by following these steps:

1. Install TeaPie.Tool globally (if not already installed):
   dotnet tool install -g TeaPie.Tool

2. Download TeaPie skills into this project:
   teapie install-skills

3. Initialize TeaPie configuration:
   teapie init

4. Ask the user if they want to create their first TeaPie tests. If yes, use the TeaPie skill knowledge to help create appropriate test cases based on their project structure and needs.
```

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

### Install Mockoon CLI

Source: https://github.com/kros-sk/teapie/blob/master/demo/README.md

Installs the Mockoon CLI tool globally using npm. Ensure npm is installed first.

```sh
npm install -g @mockoon/cli
```

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

### Serve Documentation Locally

Source: https://github.com/kros-sk/teapie/blob/master/CONTRIBUTING.md

Start a local web server to preview the generated documentation website. The default address is http://localhost:8080.

```sh
docfx serve _site
```

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

### Basic Logging Example

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/logging.md

Demonstrates how to log an informational message using the application's logger instance.

```csharp
tp.Logger.LogInformation("I understand logging in TeaPie! Yee!");
```

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

### Install TeaPie Skills via CLI

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/ai-agent-skills.md

Use this command to download TeaPie skills into your project if TeaPie is already installed.

```sh
teapie install-skills
```

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

### Install TeaPie CLI Globally

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/getting-started.md

Use this command to install the TeaPie CLI globally on your system.

```sh
dotnet tool install -g TeaPie.Tool
```

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

### Install NuGet Package

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/directives.md

The #nuget directive installs a specified NuGet package and version for use in your scripts. Remember to use the 'using' directive to access the package's contents.

```csharp
#nuget "AutoBogus, 2.13.1"
```

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

### Quick Start: Building and Running TeaPie Application

Source: https://github.com/kros-sk/teapie/blob/master/src/TeaPie/README.md

Demonstrates how to use the ApplicationBuilder to configure and run the TeaPie application programmatically. This includes setting paths, logging, environment, initialization scripts, and pipelines.

```csharp
var appBuilder = ApplicationBuilder.Create(isCollectionRun: true);

var app = appBuilder
    .WithPath("path/to/collection")
    .WithTemporaryPath("custom/temp/folder")
    .WithLogging(LogLevel.Information, "path/to/log-file.log", LogLevel.Debug)
    .WithEnvironment("testlab")
    .WithEnvironmentFile("path/to/my/environment-file.json")
    .WithReportFile("path/to/report-file.xml")
    .WithInitializationScript("path/to/my/init-script.csx")
    .WithVariablesCaching(false)
    .WithDefaultPipeline(); // Default pipeline runs tests
    // .WithStructureExplorationPipeline() - to show structure
    .Build();

await app.Run(CancellationToken.None);
```

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

### Run All Tests with .NET CLI

Source: https://github.com/kros-sk/teapie/blob/master/demo/README.md

Executes the entire 'Tests' collection using the .NET CLI. This is an alternative if TeaPie.Tool is not installed globally.

```sh
cd ./src/TeaPie.DotnetTool
dotnet run test "../../demo/Tests"
```

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

### Access Variables Generally

Source: https://github.com/kros-sk/teapie/blob/master/proposals/API Proposal.md

Demonstrates general methods for checking, setting, getting, and removing variables, which search across all levels.

```csharp
if (!tp.ContainsVariable(IsDevlabEnvironment)){
    tp.SetVariable("IsDevlabEnvironment", false);
}

var myVar = tp.GetVariable("IsDevlabEnvironment");
tp.RemoveVariable("IsDevlabEnvironment");
tp.RemoveVariables("Temp-Collection"); 
// Removes all variables with such a prefix
```

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

### Get TeaPie Help Information

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/collection.md

Displays detailed information about all arguments and options available for the TeaPie command-line interface.

```sh
teapie --help
```

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

### Example Test in Post-Response Script

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/how-to-write-tests.md

Write a basic test in a post-response script to check the status code of an HTTP response. This uses the Xunit.Assert library, with `Equal` being statically imported.

```csharp
tp.Test("Status code should be 201.", () =>
{
    var statusCode = tp.Response.StatusCode();
    Equal(201, statusCode);
});
```

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

### Example Environment File Structure

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/environments.md

This JSON structure defines shared variables and environment-specific overrides. '$shared' variables are globally available, while others are specific to an environment like 'local'.

```json
{
    "$shared": {
        "ApiBaseUrl": "http://my-car-rental-company.com",
        "ApiCustomersSection": "/customers",
        "ApiCarsSection": "/cars",
        "ApiCarRentalSection": "/rental"
    },
    "local": {
        "ApiBaseUrl": "http://localhost:3001", // Override $shared's variable
        "DebugMode": true // Environment-specific variable
    }
}
```

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

### Run All Tests with TeaPie

Source: https://github.com/kros-sk/teapie/blob/master/demo/README.md

Executes the entire 'Tests' collection using the TeaPie tool. Assumes TeaPie.Tool is installed.

```sh
teapie Tests
```

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

### Add Theoretical Test with Input and Expected Output

Source: https://github.com/kros-sk/teapie/blob/master/proposals/API Proposal.md

Example of adding a theoretical test, setting input parameters 'm' and 'c', and defining the expected output 'E'.

```csharp
tp.AddTestTheory(theory => {
    theory.Input<int>("m", 100); 
    theory.Input<int>("c", 5); 

    theory.Expected<int>("E", 2500); 
});
```

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

### Pack TeaPie Tool

Source: https://github.com/kros-sk/teapie/blob/master/CONTRIBUTING.md

Pack the TeaPie .NET tool project in Release mode to create a .nupkg file for local installation or distribution.

```sh
dotnet pack -c Release
```

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

### Run Single Test Case with .NET CLI

Source: https://github.com/kros-sk/teapie/blob/master/demo/README.md

Executes a specific test case file using the .NET CLI. This is an alternative if TeaPie.Tool is not installed globally.

```sh
cd ./src/TeaPie.DotnetTool
dotnet run test "../../demo/Tests/002-Cars/002-Edit-Car-req.http"
```

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

### Add Another Theoretical Test

Source: https://github.com/kros-sk/teapie/blob/master/proposals/API Proposal.md

Another example of adding a theoretical test for the same test case, with different input values for 'm' and 'c'.

```csharp
// Another theory for the same test case
tp.AddTestTheory(theory => {
    theory.Input<int>("m", 1);
    theory.Input<int>("c", 5);

    theory.Expected<int>("E", 25);
});
```

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

### Using Built-in Functions in HTTP Request

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/functions.md

Demonstrates how to use built-in functions like $guid, $now, $randomInt, and $rand to generate dynamic values within an HTTP request body.

```http
# Generate values with functions
POST https://example.com/api/items
Content-Type: application/json

{
  "id": "{{$guid}}",
  "createdAt": "{{$now "yyyy-MM-dd'T'HH:mm:ss"}}",
  "score": {{$randomInt 10 20}},
  "ratio": {{$rand}}
}
```

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

### Execute a Determined Test

Source: https://github.com/kros-sk/teapie/blob/master/proposals/API Proposal.md

Example of how to execute a determined test case, asserting that the response status code is 200.

```csharp
tp.Test("Status Code Should Be 200.", () => {
    tp.Response.StatusCode.Should().Be().Equal(200);
});
```

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

### Access Variables on Specific Levels

Source: https://github.com/kros-sk/teapie/blob/master/proposals/API Proposal.md

Demonstrates how to get, check existence of, set, and remove variables on specific levels (Global, Environment, Collection, Scope, Test-Case).

```csharp
// Approaching variables
var globalVar = tp.GlobalVariables.Get<int>("MyGlobalVariable");
var enviroVar = tp.EnvironmentVariables.Get<string>("MyEnvVariable");
var collVar = tp.CollectionVariables.Get<bool>("MyCollectionVariable");
var scopeVar = tp.ScopeVariables.Get<bool>("MyScopeVariable");
var testVar = tp.TestCaseVariables.Get<DateTime>("MyTestCaseVariable");

// Checking existence of variables
var globalVar = tp.GlobalVariables.Contains("MyGlobalVariable");
var enviroVar = tp.EnvironmentVariables.Contains("MyEnvVariable");
var collVar = tp.CollectionVariables.Contains("MyCollectionVariable");
var scopeVar = tp.ScopeVariables.Contains("MyScopeVariable");
var testVar = tp.TestCaseVariables.Contains("MyTestCaseVariable");

// Altering variables
tp.GlobalVariables.Set("MyGlobalVariable", 123);
tp.EnvironmentVariables.Set("MyEnvVariable", "Testlab");
tp.CollectionVariables.Set("MyCollectionVariable", true);
tp.TestCaseVariables.Set("MyTestCaseVariable", '2024-08-01');

// Removing variables
tp.GlobalVariables.Remove("MyGlobalVariable");
tp.EnvironmentVariables.Remove("MyEnvVariable");
tp.CollectionVariables.Remove("MyCollectionVariable");
tp.TestCaseVariables.Remove("MyTestCaseVariable");
```

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

### Run Single Test Case with TeaPie

Source: https://github.com/kros-sk/teapie/blob/master/demo/README.md

Executes a specific test case file using the TeaPie tool. This example runs the '002-Edit-Car-req.http' test.

```sh
teapie "./Tests/002-Cars/002-Edit-Car-req.http"
```

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

### Single Test Case Example

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/test-case/tp-file.md

Defines a single test case with HTTP request and C# script for response validation. Use directives like TEST-EXPECT-STATUS in the HTTP section for status code validation.

```text
--- TESTCASE Health Check

--- HTTP
## TEST-EXPECT-STATUS: [200]
## TEST-HAS-BODY
GET {{ApiBaseUrl}}/health

--- TEST
tp.Test("Health response should contain status field.", async () =>
{
    dynamic responseJson = await tp.Response.GetBodyAsExpandoAsync();
    NotNull(responseJson);
    NotNull(responseJson.status);
});

--- END
```

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

### Example PUT Request for Car API

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/how-to-write-tests.md

This snippet shows a sample PUT request to the car API, including the endpoint and content type.

```http
PUT {{ApiBaseUrl}}{{ApiCarsSection}}/{{AddCarRequest.request.body.$.Id}}
Content-Type: {{AddCarRequest.request.headers.Content-Type}}
```

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

### Register Custom Authentication Provider as Default

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/authentication.md

Registers a custom authentication provider and sets it as the default for all requests. This simplifies authentication setup when a custom provider is consistently used.

```csharp
tp.RegisterDefaultAuthProvider(
    "MyAuth",
    new MyAuthProvider(tp.ApplicationContext)
        .ConfigureOptions(new MyAuthProviderOptions { AuthUrl = authUrl })
);
```

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

### Example HTTP Request Log Entry

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/requests-logging.md

This JSON object represents a single log entry for an HTTP request, including details about the request, response, timing, authentication, and any errors encountered.

```json
[
  {
    "Timestamp": "2025-12-03T14:06:09.3239022+01:00",
    "Level": "Information",
    "MessageTemplate": "{@RequestLogFileEntry}",
    "Properties": {
      "RequestLogFileEntry": {
        "RequestId": "28ccf092-0240-4d91-8acc-108ef45c8acb",
        "StartTime": "2025-12-03T13:06:09.1820864Z",
        "EndTime": "2025-12-03T13:06:09.3237782Z",
        "DurationMs": 141.6918,
        "Request": {
          "Name": "GetEditedCarRequest",
          "Method": "GET",
          "Uri": "http://localhost:3001/cars/6",
          "Headers": {
            "Authorization": "Bearer authToken"
          },
          "Body": "",
          "ContentType": "text/plain",
          "FilePath": "002-Cars\002-Edit-Car-req.http",
          "_typeTag": "RequestInfo"
        },
        "Response": {
          "StatusCode": 200,
          "ReasonPhrase": "OK",
          "Headers": {
            "Access-Control-Allow-Origin": "*",
            "Access-Control-Allow-Methods": "GET,POST,PUT,PATCH,DELETE,HEAD,OPTIONS",
            "Access-Control-Allow-Headers": "Content-Type, Origin, Accept, Authorization, Content-Length, X-Requested-With",
            "Date": "Wed, 03 Dec 2025 13:06:09 GMT",
            "Connection": "keep-alive",
            "Keep-Alive": "timeout=5"
          },
          "Body": "{\"Id\":6,\"Brand\":\"Toyota\",\"Model\":\"RAV4\",\"EngineType\":\"3.0 TDI\",\"TransmissionType\":\"Manual\",\"PeopleCapacity\":5,\"Color\":\"silver\",\"Year\":2022,\"DrivenKilometres\":21000,\"Description\":\""}",
          "ContentType": "application/json",
          "ReceivedAt": "2025-12-03T13:06:09.3238287Z",
          "_typeTag": "ResponseInfo"
        },
        "Authentication": {
          "ProviderType": "OAuth2Provider",
          "IsDefault": true,
          "AuthenticatedAt": "2025-12-03T13:06:09.3238312Z",
          "_typeTag": "AuthInfo"
        },
        "Errors": [],
        "_typeTag": "RequestLogFileEntry"
      },
      "SourceContext": "HttpRequests",
      "HttpMethod": "GET",
      "Uri": "http://localhost:3001/cars/6",
      "Scope": [
        "HTTP GET http://localhost:3001/cars/6"
      ]
    }
  }
]
```

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

### Initialize TeaPie project

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/commands.md

Prepare your working directory for TeaPie by running the `init` command. This creates a `.teapie` folder and updates `.gitignore`. An optional path can be provided for the `.teapie` folder.

```sh
teapie init [path-to-teapie-folder] [--no-logo]
```

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

### Build Documentation with DocFX

Source: https://github.com/kros-sk/teapie/blob/master/CLAUDE.md

Commands to build and serve documentation using DocFX.

```sh
docfx "./docs/docfx.json"
docfx serve _site
```

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

### Generate Documentation Website

Source: https://github.com/kros-sk/teapie/blob/master/CONTRIBUTING.md

Generate the static website output for the documentation by running DocFX on the specified configuration file.

```sh
docfx "./docs/docfx.json"
```

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

### Set up Local NuGet Feed

Source: https://github.com/kros-sk/teapie/blob/master/CONTRIBUTING.md

Create a new directory for a local NuGet feed and add it as a source in your NuGet configuration. This is useful for local development and testing.

```sh
mkdir "path/to/your/new/local/feed/directory"
dotnet nuget add source "path/to/your/local/feed" --name LocalNuGetFeed
```

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

### Explore Collection or Test Case

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/commands.md

Use the `explore` command to explore a collection, request file (.http), or test case (.tp). It allows specifying an environment file and an initialization script.

```sh
teapie explore [path] [--log-file <file>] [--log-file-log-level <level>] [-l|--log-level <level>] [-d|--debug] [-v|--verbose] [-q|--quiet] [--env-file <file>] [--init-script <script>] [--no-logo]
```

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

### Multiple Test Cases in One File

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/test-case/tp-file.md

Demonstrates defining multiple test cases within a single .tp file, each with its own INIT, HTTP, and TEST sections. The INIT section can load external scripts and set variables.

```text
---
--- TESTCASE Add Another Car

--- INIT
#load "$teapie/Definitions/GenerateNewCar.csx"
var car = GenerateCar();
tp.SetVariable("AnotherCar", car.ToJsonString(), "cars");

--- HTTP
## TEST-EXPECT-STATUS: [201]
## TEST-HAS-BODY
# @name AddAnotherCarRequest
POST {{ApiBaseUrl}}{{ApiCarsSection}}
Content-Type: application/json

{{AnotherCar}}

--- TEST
await tp.Test("Newly added car should be returned with an assigned Id.", async () =>
{
    dynamic responseJson = await tp.Responses["AddAnotherCarRequest"].GetBodyAsExpandoAsync();
    NotNull(responseJson);
    True(responseJson.Id > 0);
    tp.SetVariable("AnotherCarId", (long)responseJson.Id, "cars");
});

--- END

--- TESTCASE Get All Cars

--- HTTP
## TEST-EXPECT-STATUS: [200]
## TEST-HAS-BODY
# @name GetAllCarsRequest
GET {{ApiBaseUrl}}{{ApiCarsSection}}

--- TEST
await tp.Test("Response should contain array of cars.", async () =>
{
    var body = await tp.Response.Content.ReadAsStringAsync();
    NotNull(body);
    True(body.StartsWith("[") && body.EndsWith("]"));
});

--- END
```

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

### Run tests with various options

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/commands.md

Execute tests using the `test` command. This command supports specifying a path to test files, environment configurations, reporting options, and detailed logging levels.

```sh
teapie test [path] [--temp-path <path>] [-e|--env <envName>] [--env-file <file>] [-r|--report-file <file>] [-i|--init-script <script>] [--no-cache-vars] [--log-file <file>] [--log-file-log-level <level>] [--requests-log-file <file>] [-l|--log-level <level>]  [-d|--debug] [-v|--verbose] [-q|--quiet] [--no-logo]
```

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

### Custom Initialization Script Option

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/initialization-script.md

Use this command-line option to specify a custom path to your initialization script instead of relying on the default detection.

```bash
-i | --init-script | --initialization-script <path-to-script>
```

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

### Set and Get Variables

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/test-case/pre-request-script.md

Use the `tp` identifier to set and retrieve variables within the test runner context. This is useful for managing state across script executions.

```csharp
tp.SetVariable("TimeOfExecution", DateTime.UtcNow);
...
var time = tp.GetVariable("TimeOfExecution");
```

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

### Restore, Build, and Test Commands

Source: https://github.com/kros-sk/teapie/blob/master/CLAUDE.md

Common dotnet CLI commands for managing dependencies, building projects, and running tests within the TeaPie project.

```sh
dotnet restore                    # Restore dependencies
dotnet build                      # Build all projects
dotnet build -warnaserror         # Build as CI does (warnings are errors)
dotnet test                       # Run all tests
dotnet test --filter "FullyQualifiedName~ClassName.MethodName"  # Run a single test
```

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

### Using Registered Functions in .http Files

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/functions.md

Illustrates how to call custom functions registered in C# directly within .http files using the standard function notation.

```http
{{$upper "hello"}}
{{$add 40 2}}
```

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

### Named HTTP Request Definition

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/test-case/request-file.md

Defines a named HTTP GET request with a JSON body. Use this to structure individual requests within a test case and refer to them by name.

```http
# @name RequestName
GET https:/localhost:3001/customers
Content-Type: application/json

{
    "Id": 3,
    "FirstName": "Alice",
    "LastName": "Johnson",
    "Email": "alice.johnson@example.com"
}
```

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

### Registering Functions in C#

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/functions.md

Shows how to register custom functions with 0, 1, or 2 arguments using the TeaPie instance in C#. These functions can then be used in .http files.

```csharp
// 0-arg
tp.RegisterFunction("$buildNumber", () => Environment.GetEnvironmentVariable("BUILD_NUMBER") ?? "local");

// 1-arg
tp.RegisterFunction("$upper", (string s) => s.ToUpperInvariant());

// 2-arg (maximum)
tp.RegisterFunction("$add", (int a, int b) => a + b);
```

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

### Run All Test Cases in a Collection

Source: https://github.com/kros-sk/teapie/blob/master/README.md

Executes all test cases within the 'demo' collection.

```sh
teapie test demo
```

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

### Run Demo Collection

Source: https://github.com/kros-sk/teapie/blob/master/CONTRIBUTING.md

Execute all test cases in the 'demo' collection for debugging purposes. This command runs 'teapie test' on the specified demo collection.

```sh
dotnet run test "../../demo"
```

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

### Instantiate TeaPie Class

Source: https://github.com/kros-sk/teapie/blob/master/proposals/API Proposal.md

Create an instance of the public class 'TeaPie' during the application's initialization phase.

```csharp
TeaPie tp = new();
```

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

### Extracting Request Variables from Response Body

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/variables.md

Access specific data from a named request's response body using a defined syntax. This example extracts the 'id' property from the JSON response of the 'NewBook' request.

```plaintext
{{NewBook.response.body.$.id}}
```

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

### Initialize .teapie Folder

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/teapie-folder.md

Initializes the .teapie folder in the repository root and updates .gitignore. This command helps in setting up the necessary structure for TeaPie's shared functionality and temporary files.

```sh
teapie init
```

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

### Specify Custom Environment File

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/environments.md

Use this option to specify a custom path to your environment file instead of relying on the default.

```sh
--env-file|--environment-file <path-to-environment-file>
```

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

### Executing Functions via TeaPie Instance in C#

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/functions.md

Demonstrates how to execute registered or built-in functions directly from C# code using the `ExecFunction` method on the TeaPie instance, specifying the function name and arguments.

```csharp
var id = tp.ExecFunction<Guid>("$guid");
var timeStamp = tp.ExecFunction<string>("$now", "yyyy-MM-dd");
var sum = tp.ExecFunction<int>("$add", 2, 3);
```

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

### Update Documentation Metadata and Build

Source: https://github.com/kros-sk/teapie/blob/master/CONTRIBUTING.md

Update documentation metadata and rebuild the site when API or code changes affect the documentation content.

```sh
docfx metadata
docfx build
```

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

### Set Initial Test Order and Skips

Source: https://github.com/kros-sk/teapie/blob/master/proposals/API Proposal.md

Allows setting the initial order of test cases and specifying which test cases to skip at the beginning of a test run.

```APIDOC
## Test Runner API - Set Order

### Description
Allows setting the initial order of test cases and specifying which test cases to skip at the beginning of a test run.

### Method
`SetRunner(Action<Runner> configureRunner)`: Configures the test runner with a specific order and skips.

### Parameters
- `configureRunner` (Action<Runner>): A delegate that receives the runner instance to configure.
  - `SetOrder(params string[] testCaseNames)`: Sets the explicit order of test cases to execute.
  - `Skip(params string[] testCaseNames)`: Specifies test cases to be skipped.

### Usage Example
```csharp
tp.SetRunner(runner => {
    runner.SetOrder("Test 1", "Test 25", "Auto Test");
    runner.Skip("Ignor Me Test", "Test 0");
});
```
```

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

### Explore Collection Structure

Source: https://github.com/kros-sk/teapie/blob/master/proposals/Class Structure Proposal.md

Examines the folder structure to find test cases and configuration files for a collection, returning a tree-like structure.

```csharp
public static CollectionStructure ExploreCollection(string collectionName);
```

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

### Explore Test Case Structure

Source: https://github.com/kros-sk/teapie/blob/master/proposals/Class Structure Proposal.md

Explores the structure of a single test case, checking for implicit pre-request/post-response scripts and configuration files.

```csharp
public static TestCaseStructure ExploreTestCase(string testCaseName);
```

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

### Run TeaPie Tests

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/running-tests.md

Execute all test cases in the current directory or a specified path. This is the primary command for running tests.

```sh
teapie
```

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

### Enable HTTP Request Logging

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/requests-logging.md

Use the `--requests-log-file` parameter to specify a file for capturing structured HTTP request and response logs. This creates a JSONL file with one JSON object per line.

```bash
teapie test my-requests.http --requests-log-file requests.json
```

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

### Clone the Repository

Source: https://github.com/kros-sk/teapie/blob/master/CONTRIBUTING.md

Clone the TeaPie repository to your local machine and navigate into the project directory.

```sh
git clone https://github.com/Kros-sk/TeaPie.git
cd TeaPie
```

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

### CI Build Command

Source: https://github.com/kros-sk/teapie/blob/master/CLAUDE.md

Command for building the project in a Continuous Integration environment, ensuring all warnings are resolved.

```sh
dotnet build --configuration Release --no-restore -warnaserror
```

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

### Run Single Test Case

Source: https://github.com/kros-sk/teapie/blob/master/proposals/Class Structure Proposal.md

Runs a single test case, taking its structure as input, which includes details about pre-request scripts, post-response scripts, and configuration files.

```csharp
public TestCaseRunResults Run(TestCaseStructure structure);
```

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

### Generate a new test case

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/commands.md

Use the `generate` command to create a new test case with optional pre-request or post-response scripts. Specify the test case name and an optional path for generation.

```sh
teapie generate <test-case-name> [path] [-i|--init|--pre-request] [-t|--test|--post-response] [--no-logo]
```

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

### Integrate TeaPie Package into Project

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/getting-started.md

Add the TeaPie package to your project to integrate its tooling.

```sh
dotnet add package TeaPie
```

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

### Full TeaPie Collection Run Command Specification

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/collection.md

Provides the complete command with all available arguments and options for running a TeaPie collection, including temporary path, debug, verbose, quiet, log levels, environment files, report files, and initialization scripts.

```sh
teapie test [path-to-collection] [--temp-path <path-to-temporary-folder>] [-d|--debug] [-v|--verbose] [-q|--quiet] [--log-level <minimal-log-level>] [--log-file <path-to-log-file>] [--log-file-log-level <minimal-log-level-for-log-file>] [-e|--env|--environment <environment-name>] [--env-file|--environment-file <path-to-environment-file>] [-r|--report-file <path-to-report-file>] [-i|--init-script|--initialization-script <path-to-initialization-script>]
```

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

### Specify Active Environment via Command Line

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/environments.md

Use the -e option to set the active environment for running tests. Aliases --env and --environment are also supported.

```sh
-e local
```

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

### JSON Configuration for Test Case Order and Skipping

Source: https://github.com/kros-sk/teapie/blob/master/proposals/Configuration Proposal.md

Defines the desired order of test case execution and specifies test cases to be skipped.

```json
{
    "order": [], // desired order of test cases, enumerated by names
    "skip": [] // names of test cases to be ignored
}

```

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

### C# Configuration for Delay and Timeout

Source: https://github.com/kros-sk/teapie/blob/master/proposals/Configuration Proposal.md

Programmatically sets request delay, request timeout, and enables/disables the timeout policy.

```csharp
tp.DelayRequest(2200);
tp.SetTimeout(1200);
tp.DisableTimeout();
tp.EnableTimeout();

```

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

### Configure and Set Custom Logger Instance

Source: https://github.com/kros-sk/teapie/blob/master/proposals/API Proposal.md

Configure a custom logger instance, such as Serilog, and set it for the Teapie framework. This allows for advanced logging configurations and integrations.

```csharp
Log.Logger = new LoggerConfiguration()
    .WriteTo.Console()
    .CreateLogger();

var loggerFactory = LoggerFactory.Create(builder => {
    builder.AddSerilog();
});

tp.SetLogger(loggerFactory.CreateLogger<TeaPie>());
```

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

### Rebuild Documentation

Source: https://github.com/kros-sk/teapie/blob/master/CONTRIBUTING.md

Rebuild the documentation website after making changes to Markdown files. This command is used to reflect content updates.

```sh
docfx build
```

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

### Reference Shared Files using $teapie Wildcard

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/teapie-folder.md

Demonstrates how to reference shared C# script files located within the .teapie folder using the special $teapie wildcard. This allows for centralized management of reusable code across different collections.

```csharp
#load "$teapie/ClearVariables.csx"
```

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

### Execute a Single TeaPie Test Case

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/getting-started.md

Runs a specific test case file. Ensure the path to the file is correctly specified.

```sh
teapie test "./demo/Tests/002-Cars/002-Edit-Car-req.http"
```

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

### Environment File Schema

Source: https://github.com/kros-sk/teapie/blob/master/proposals/General Proposal.md

Specifies the structure for an environment file, including its name, version, and environment-specific variables.

```json
{
    "name": "",
    "version": "",
    "variables": [
        {
            "name": "",
            "value": ""
        },
        {
            "name": "",
            "value": ""
        },
        {
            "name": "",
            "value": ""
        }
    ]
}
```

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

### Execute a Single .tp Test Case

Source: https://github.com/kros-sk/teapie/blob/master/README.md

Runs a specific API test defined in a single-file .tp format.

```sh
teapie test ".\demo\Tests\002-Cars\004-Car-Operations.tp"
```

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

### Generate New Test Case

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/test-case/test-case.md

Command to scaffold a new test case. It can generate the multi-file format by default or a single-file format using the `-s` flag. Optional flags can disable pre-request or post-response script generation.

```sh
teapie generate <test-case-name> [path] [-i|--init|--pre-request] [-t|--test|--post-response]
```

```sh
teapie generate <test-case-name> [path] -s [-i] [-t]
```

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

### Run Collection of Test Cases

Source: https://github.com/kros-sk/teapie/blob/master/proposals/Class Structure Proposal.md

Runs an entire collection of test cases, using the collection's structure which defines the organization of test cases in the file system and their order.

```csharp
public CollectionRunResults Run(CollectionStructure structure);
```

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

### Set Test Order and Skip Test Cases Programmatically

Source: https://github.com/kros-sk/teapie/blob/master/proposals/API Proposal.md

Set the order of test cases and specify which test cases to skip at the beginning of a test run. Be cautious to avoid creating endless loops.

```csharp
tp.SetRunner(runner => {
    runner.SetOrder(
        "Test 1",
        "Test 25",
        "Auto Test");

    runner.Skip(
        "Ignor Me Test",
        "Test 0"
    );
})
```

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

### Execute a Single .http Test Case

Source: https://github.com/kros-sk/teapie/blob/master/README.md

Runs a specific API test defined in an .http file.

```sh
teapie test ".\demo\Tests\002-Cars\002-Edit-Car-req.http"
```

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

### Compile Script or Test Case

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/commands.md

The `compile` command compiles a specified script (.csx) or test case (.tp) file. It offers various logging and verbosity options.

```sh
teapie compile <path> [--log-file <file>] [--log-file-log-level <level>] [-l|--log-level <level>] [-d|--debug] [-v|--verbose] [-q|--quiet] [--no-logo]
```

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

### Accessing JSON Body as Expando Object

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/test-case/post-response-script.md

Demonstrates how to retrieve and work with a JSON response body using an expando object for easier property access. Ensure the variable is explicitly declared as 'dynamic'.

```csharp
tp.Test("Identifier should be a positive integer.", () =>
{
    // Expando object has to be marked epxlicitly as 'dynamic'
    dynamic responseBody = tp.Response.GetBodyAsExpando();
    True(responseBody.id > 0);
});
```

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

### Implement and Register Custom Reporter Class

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/reporting.md

Implement the IReporter interface to create a custom reporter class for advanced reporting needs. Register an instance of this class with TeaPie.

```csharp
public class MyReporter : IReporter<TestsResultsSummary>
{
    public void Report(TestsResultsSummary summary)
    {
        // Custom reporting logic...
    }
}

tp.RegisterReporter(new MyReporter());
```

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

### C# Configuration for Test Runner Order and Skipping

Source: https://github.com/kros-sk/teapie/blob/master/proposals/Configuration Proposal.md

Programmatically sets the order of test case execution and defines which test cases should be skipped.

```csharp
tp.SetRunner(runner => {
    runner.SetOrder(
        "Test 1",
        "Test 25",
        "Auto Test");

    runner.Skip(
        "Ignor Me Test",
        "Test 0"
    );
})

```

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

### Test Configuration File Schema

Source: https://github.com/kros-sk/teapie/blob/master/proposals/General Proposal.md

Defines the structure for test configuration, including retry policies, delays, timeouts, and variables.

```json
{
    "retryPolicy": {
        "maxRertryAttempts": 3,
        "backoffType": "Exponential",
        "delay": "00:00:03"
    },
    "delayRequestFor": number, // in milliseconds
    "timeoutPolicy": {
        "requestTimeout": number, // in milliseconds
        "disableTimeout": boolean
    },
    "variables": [
        {
            "name": string,
            "value": any
        },
        {
            "name": string,
            "value": any
        },
        {
            "name": string,
            "value": any
        }
    ]
}
```

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

### Create a New Feature Branch

Source: https://github.com/kros-sk/teapie/blob/master/CONTRIBUTING.md

Create a new branch for your contributions following the specified naming convention (e.g., feature/your-feature-name).

```sh
git checkout -b feature/your-feature-name
```

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

### Run All Test Cases in a Collection

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/getting-started.md

Executes all test cases located within the specified directory or collection.

```sh
teapie test ./demo/Tests
```

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

### Run a TeaPie Collection

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/collection.md

Executes the collection defined by the current directory. You can also specify a relative or absolute path to a collection directory.

```sh
teapie
```

```sh
teapie [path-to-collection]
```

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

### Full TeaPie Test Command Specification

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/running-tests.md

Use this command for advanced test execution, specifying paths, temporary directories, debug modes, verbosity, logging, environment configurations, reports, and initialization scripts.

```sh
teapie test [path-to-collection-or-test-case] [--temp-path <path-to-temporary-folder>] [-d|--debug] [-v|--verbose] [-q|--quiet] [--log-level <minimal-log-level>] [--log-file <path-to-log-file>] [--log-file-log-level <minimal-log-level-for-log-file>] [--requests-log-file <path-to-log-file>] [-e|--env|--environment <environment-name>] [--env-file|--environment-file <path-to-environment-file>] [-r|--report-file <path-to-report-file>] [-i|--init-script|--initialization-script <path-to-initialization-script>] [--no-cache-vars|--no-cache-variables]
```

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

### Collection Configuration File Schema

Source: https://github.com/kros-sk/teapie/blob/master/proposals/General Proposal.md

Defines the structure for collection configuration, including ignored tests, execution order, retry policies, timeouts, and variables.

```json
{
    "ignore": {
        "ignoreCollections": [], // names of collections to ignore
        "ignoreTests": [] // names of tests to ignore
    },
    "testsOrder": [], // names of tests and collections in desired order, if empty or not provided, alphabetical order is applied
    "retryPolicy": {
        "maxRertryAttempts": 3,
        "backoffType": "Exponential",
        "delay": "00:00:03"
    },
    "timeoutPolicy": {
        "requestTimeout": number, // in milliseconds
        "disableTimeout": boolean
    },
    "variables": [
        {
            "name": string,
            "value": any
        },
        {
            "name": string,
            "value": any
        },
        {
            "name": string,
            "value": any
        }
    ]
}
```

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

### Explore Test Case Structure

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/test-case/test-case.md

Command to inspect the structure of a test case without executing it. This command works for both `.http` request files and `.tp` single-file test cases.

```sh
teapie explore <path-to-test-case> [-d|--debug] [-v|--verbose] [-q|--quiet] [--log-level <minimal-log-level>] [--log-file <path-to-log-file>] [--log-file-log-level <minimal-log-level-for-log-file>] [--env-file|--environment-file <path-to-environment-file>] [-i|--init-script|--initialization-script <path-to-initialization-script>]
```

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

### Logging API

Source: https://github.com/kros-sk/teapie/blob/master/proposals/API Proposal.md

Utilize the framework's detailed logging system to aid in debugging and troubleshooting test execution.

```APIDOC
## Logging API

### Description
Provides access to an `ILogger` instance for detailed logging during test execution. Users can log messages at various levels, including critical, error, warning, information, debug, and trace.

### Methods
- `tp.Logger`: Access the logger instance.
  - `LogCritical(string message)`
  - `LogError(string message)`
  - `LogWarning(string message)`
  - `LogInformation(string message)`
  - `LogDebug(string message)`
  - `LogTrace(string message)`
  - `Log(LogLevel level, Exception exception, string message, params object[] args)`

### Usage Example
```csharp
tp.Logger.LogCritical("This is also Critical!");
tp.Logger.LogError("Error occured!");
tp.Logger.LogWarning("This is warning!");
tp.Logger.LogInformation("Today is nice weather :)");
tp.Logger.LogDebug("This will help me during debugging!");
tp.Logger.LogTrace("This is the most detailed message.");
tp.Logger.Log(LogLevel.None, new Exception("No level provided"), "This is {1}!", "ignored");
```

### Future Ideas
- Allow users to specify their own logger instance.
- Programmatic setting of logger instance using `LoggerFactory` and `Serilog`.
```

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

### Generate a New TeaPie Test Case

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/getting-started.md

Command to generate a new test case file with the specified name.

```sh
teapie generate <test-case-name>
```

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

### Using Built-in Test Directives in Request File

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/how-to-write-tests.md

Apply built-in test directives in a `.http` file to automate common testing scenarios like checking status codes, response bodies, and headers.

```http
## TEST-EXPECT-STATUS: [200, 201]
## TEST-HAS-BODY
## TEST-HAS-HEADER: Content-Type
PUT {{ApiBaseUrl}}{{ApiCarsSection}}/{{AddCarRequest.request.body.$.Id}}
Content-Type: {{AddCarRequest.request.headers.Content-Type}}

...
```

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

### Switch Environments in Code

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/environments.md

Dynamically change the active environment within your .csx scripts using the tp.SetEnvironment method.

```csharp
tp.SetEnvironment("local");
```

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

### Access Response Body and Set Variables

Source: https://github.com/kros-sk/teapie/blob/master/proposals/API Proposal.md

Retrieve the response object, parse its body as JSON, and use data from the response body to set framework variables.

```csharp
var res = tp.Response;
var body = res.Body.ToJson();
tp.SetVariable("EntityId", body.Id);
```

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

### JSON Configuration for Request Delay

Source: https://github.com/kros-sk/teapie/blob/master/proposals/Configuration Proposal.md

Specifies a delay in milliseconds to be applied before a request is sent.

```json
{
    "delayRequestFor": number // in milliseconds
}

```

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

### C# Configuration for Retry Policy

Source: https://github.com/kros-sk/teapie/blob/master/proposals/Configuration Proposal.md

Programmatically sets the retry strategy options, including backoff type, maximum attempts, and delay.

```csharp
tp.RetryPolicy = new RetryStrategyOptions
{
    BackoffType = DelayBackoffType.Exponential,
    MaxRetryAttempts = 4,
    Delay = TimeSpan.FromSeconds(3),
};

```

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

### Commit and Push Changes

Source: https://github.com/kros-sk/teapie/blob/master/CONTRIBUTING.md

Commit your changes with a descriptive message and push them to your remote branch.

```sh
git commit -m "Add feature X to improve Y"
git push origin feature/your-feature-name
```

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

### Load External Script

Source: https://github.com/kros-sk/teapie/blob/master/docs/docs/test-case/pre-request-script.md

The `#load` directive allows referencing other scripts using absolute or relative paths. The referenced script is automatically executed.

```csharp
#load "path\to\your\script.csx"
```