NetInteractor

KO | EN

gitlite — search

#python #ai #typescript #llm #go #android #docker #nodejs #windows #awesome #kubernetes #vue #security #openai

(★ 25)

A powerful web operation automation library for .NET that enables you to define and execute complex web interactions using simple XML scripts. Supports web testing, scraping, form automation, and workflow orchestration.

NetInteractor Latest Version Download

Download Latest Version (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# NetInteractor

[![build](https://github.com/kerryjiang/NetInteractor/actions/workflows/build.yml/badge.svg)](https://github.com/kerryjiang/NetInteractor/actions/workflows/build.yml)
[![NuGet Version](https://img.shields.io/nuget/v/NetInteractor.svg?style=flat)](https://www.nuget.org/packages/NetInteractor/)
[![NuGet Downloads](https://img.shields.io/nuget/dt/NetInteractor.svg)](https://www.nuget.org/packages/NetInteractor/)
[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://raw.githubusercontent.com/kerryjiang/NetInteractor/master/LICENSE)

A powerful web operation automation library for .NET that enables you to define and execute complex web interactions using simple XML scripts.

## 🎯 Use Cases

- **Web Testing**: Automate white-box and integration testing for web applications
- **Web Scraping**: Extract data from websites using XPath expressions
- **Form Automation**: Automate form submissions and multi-step workflows
- **E-commerce Automation**: Automate checkout processes, cart management, and more

## ✨ Features

- **XML-based Scripts**: Define web interactions in easy-to-read XML configuration files
- **Input Parameters**: Pass dynamic values into your automation scripts using `$(ParameterName)` syntax
- **Output Extraction**: Extract values from HTTP responses using XPath or Regex
- **Flow Control**: Conditional execution with `if` statements
- **Reusable Targets**: Define named targets and call them from other targets
- **Modern HTTP Client**: Uses `HttpClient` for better performance and reliability
- **Cross-Platform**: Supports .NET Standard 2.0, .NET 8.0, and .NET 9.0
- **Browser Automation**: Optional Playwright integration for JavaScript-rendered pages

## 📦 Installation

Install via NuGet Package Manager:

```bash
dotnet add package NetInteractor
```

For browser automation with JavaScript rendering, also install the Playwright package:

```bash
dotnet add package NetInteractor.Playwright
```

Or via the Package Manager Console:

```powershell
Install-Package NetInteractor
```

## 🚀 Quick Start

### 1. Create an XML Script

Create a configuration file (e.g., `Shop.config`) that defines your web interaction workflow:

```xml
<InteractConfig defaultTarget="BuyItem">
    <target name="BuyItem">
        
        <get url="http://www.example-shop.com/product/12345" />
        
        
        <post clientID="cart-form">
            <formValue name="size" text="Medium" />
            <formValue name="quantity" value="1" />
        </post>
        
        
        <get url="http://www.example-shop.com/cart">
            <output name="totalPrice" 
                    xpath="//span[@class='cart-total']" 
                    attr="text()" 
                    expectedValue="$28.00" />
        </get>
        
        
        <post clientID="checkout_form">
            <formValue name="billing_name" value="$(FullName)" />
            <formValue name="email" value="$(Email)" />
            <formValue name="credit_card" value="$(CreditCardNumber)" />
            <formValue name="exp_month" value="$(CreditCardExpMonth)" />
            <formValue name="exp_year" value="$(CreditCardExpYear)" />
        </post>
    </target>
</InteractConfig>
```

### 2. Execute the Script

```csharp
using NetInteractor;
using NetInteractor.Config;
using NetInteractor.WebAccessors;
using System.Collections.Specialized;

// Load the configuration
var config = ConfigFactory.DeserializeXml<InteractConfig>("Scripts/Shop.config");

// Create the executor with an HTTP client accessor
var webAccessor = new HttpClientWebAccessor(new HttpClient());
var executor = new InterationExecutor(webAccessor);

// Prepare input parameters
var inputs = new NameValueCollection
{
    ["FullName"] = "John Doe",
    ["Email"] = "john@example.com",
    ["CreditCardNumber"] = "4111111111111111",
    ["CreditCardExpMonth"] = "12",
    ["CreditCardExpYear"] = "2027"
};

// Execute the automation
var result = await executor.ExecuteAsync(config, inputs);

// Check results
if (result.Ok)
{
    Console.WriteLine("Automation completed successfully!");
    
    // Access extracted output values
    foreach (var key in result.Outputs.AllKeys)
    {
        Console.WriteLine($"{key}: {result.Outputs[key]}");
    }
}
else
{
    Console.WriteLine($"Automation failed: {result.Message}");
}
```

### 3. Using Playwright for JavaScript-Rendered Pages

For websites that require JavaScript rendering (e.g., SPAs, dynamic content), use the Playwright web accessor:

```csharp
using NetInteractor;
using NetInteractor.Config;
using NetInteractor.WebAccessors;

// Load the configuration
var config = ConfigFactory.DeserializeXml<InteractConfig>("Scripts/Shop.config");

// Create the executor with a Playwright accessor for JavaScript support
await using var webAccessor = new PlaywrightWebAccessor();
var executor = new InterationExecutor(webAccessor);

// Execute the automation (same as before)
var result = await executor.ExecuteAsync(config, inputs);
```

> **Note**: Playwright requires browser binaries. Run `playwright install chromium` to install the required browser.

## 📖 Script Reference

### Actions

| Action | Description |
|--------|-------------|
| `<get>` | Performs an HTTP GET request |
| `<post>` | Submits a form via HTTP POST |
| `<if>` | Conditional execution based on parameter values |
| `<call>` | Calls another target by name |

### GET Action

Navigates to a URL and optionally extracts output values:

```xml
<get url="http://example.com/page">
    <output name="title" xpath="//h1" attr="text()" />
    <output name="price" xpath="//span[@class='price']" attr="text()" expectedValue="$10.00" />
</get>
```

### POST Action

Submits a form with the specified values:

```xml

<post clientID="login-form">
    <formValue name="username" value="$(Username)" />
    <formValue name="password" value="$(Password)" />
</post>

<post formIndex="0">
    <formValue name="search" value="query" />
</post>

<post formName="contactForm">
    <formValue name="message" value="Hello!" />
</post>
```

### Output Extraction

Extract values from responses using XPath or Regex:

```xml

<output name="productName" xpath="//div[@class='product-title']" attr="text()" />

<output name="imageUrl" xpath="//img[@id='product-image']" attr="src" />

<output name="status" xpath="//span[@class='status']" attr="text()" expectedValue="Success" />

<output name="orderId" regex="Order #(\d+)" />

<output name="allPrices" xpath="//span[@class='price']" attr="text()" isMultipleValue="true" />
```

### Conditional Execution

Execute actions conditionally based on parameter values:

```xml
<if property="PaymentMethod" value="CreditCard">
    <post clientID="credit-card-form">
        <formValue name="card_number" value="$(CardNumber)" />
    </post>
</if>
```

### Reusable Targets

Define and call reusable targets:

```xml
<InteractConfig defaultTarget="Main">
    <target name="Login">
        <post clientID="login-form">
            <formValue name="username" value="$(Username)" />
            <formValue name="password" value="$(Password)" />
        </post>
    </target>
    
    <target name="Main">
        
        <call target="Login" />
        
        
        <get url="http://example.com/dashboard" />
    </target>
</InteractConfig>
```

## 🔧 Configuration Reference

### InteractConfig Attributes

| Attribute | Description |
|-----------|-------------|
| `defaultTarget` | The name of the target to execute by default |

### Target Attributes

| Attribute | Description |
|-----------|-------------|
| `name` | Unique identifier for the target |

### FormValue Attributes

| Attribute | Description |
|-----------|-------------|
| `name` | The form field name |
| `value` | The value to set (supports `$(param)` syntax) |
| `text` | Alternative to `value` for setting field text |

## 🏗️ Architecture

```
NetInteractor
├── Config/           # XML configuration models
├── Interacts/        # Action implementations (Get, Post, If, Call)
├── WebAccessors/     # HTTP client abstractions
├── InteractExecutor  # Main execution engine
└── ConfigFactory     # XML deserialization
```

## 📋 Requirements

- .NET Standard 2.0+ / .NET 8.0+ / .NET 9.0+
- Dependencies:
  - HtmlAgilityPack (HTML parsing)
  - Microsoft.Extensions.Logging (Logging support)
  - Microsoft.Extensions.DependencyInjection (DI support)
- Optional Dependencies (for browser automation):
  - Microsoft.Playwright (NetInteractor.Playwright package)

## 📄 License

This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.

## 🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## 📬 Contact

- **Author**: Kerry Jiang
- **Repository**: [https://github.com/kerryjiang/NetInteractor](https://github.com/kerryjiang/NetInteractor)

NetInteractor

NetInteractor Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

NetInteractor

NetInteractor Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

Download README