agents-cli-automation 1.0.5 → 1.0.7

package/src/templates/playwright-agent-csharp.md

@@ -0,0 +1,521 @@
+name: Create Playwright Framework - UI Testing (C#)
+description: Creates a production-ready Playwright UI automation framework in C# with .NET, NUnit, and all required configurations.
+argument-hint: "framework requirements, e.g., 'C# with Playwright tests'"
+
+---
+
+# Playwright UI Testing Framework - C#
+
+This agent creates a production-ready Playwright framework in C# with .NET and NUnit optimized for UI automation.
+
+## Capabilities
+- **.NET 8+** - Chromium only with modern C# patterns
+- **NUnit** - Latest testing framework
+- **C# 12** - Latest language features and async/await
+- **Page Object Model (POM)** - Reusable page classes
+- **Dependency Injection** - Built with NUnit setup
+- **Parallel execution** - Tests run simultaneously
+- **Test data support** - JSON, CSV, YAML loading
+- **BDD Support** - SpecFlow with Gherkin syntax
+- **Explicit waits** - Proper synchronization
+- **Scalable folder structure** with best practices
+
+## Prerequisites
+- .NET 8 SDK installed
+- Visual Studio 2022 or VS Code with C# extension
+- Git (optional)
+
+## Setup Instructions
+
+### 1. Create .NET Project
+```bash
+dotnet new classlib -n PlaywrightFramework
+cd PlaywrightFramework
+dotnet new nunit --force
+```
+
+### 2. Update .csproj with Dependencies
+```xml
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <LangVersion>latest</LangVersion>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Playwright" Version="1.50.0" />
+    <PackageReference Include="NUnit" Version="4.1.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.2" />
+    
+    <!-- JSON -->
+    <PackageReference Include="System.Text.Json" Version="8.0.0" />
+    
+    <!-- YAML -->
+    <PackageReference Include="YamlDotNet" Version="13.0.1" />
+    
+    <!-- CSV -->
+    <PackageReference Include="CsvHelper" Version="30.0.1" />
+    
+    <!-- SpecFlow (BDD) -->
+    <PackageReference Include="SpecFlow" Version="3.9.74" />
+    <PackageReference Include="SpecFlow.NUnit" Version="3.9.74" />
+  </ItemGroup>
+</Project>
+```
+
+### 3. Project Structure
+```
+PlaywrightFramework/
+├── Pages/
+│   ├── BasePage.cs
+│   ├── LoginPage.cs
+│   ├── InventoryPage.cs
+│   └── FormPage.cs
+├── Utils/
+│   ├── DataReader.cs
+│   ├── FormHelper.cs
+│   └── TestDataManager.cs
+├── Models/
+│   ├── User.cs
+│   ├── FormData.cs
+│   └── Config.cs
+├── Fixtures/
+│   └── TestFixtures.cs
+├── Tests/
+│   ├── SauceDemoTests.cs
+│   └── FormTests.cs
+├── StepDefinitions/
+│   ├── LoginSteps.cs
+│   └── ShoppingSteps.cs
+├── Features/
+│   ├── login.feature
+│   └── shopping.feature
+├── Data/
+│   ├── users.json
+│   ├── formData.csv
+│   └── config.yaml
+├── specflow.json
+└── PlaywrightFramework.csproj
+```
+
+### 4. Base Page (Pages/BasePage.cs)
+```csharp
+using Microsoft.Playwright;
+
+namespace PlaywrightFramework.Pages
+{
+    public class BasePage
+    {
+        protected IPage Page;
+        private const int Timeout = 5000;
+
+        public BasePage(IPage page)
+        {
+            Page = page;
+        }
+
+        public async Task NavigateToAsync(string url)
+        {
+            await Page.GotoAsync(url);
+        }
+
+        public async Task ClickAsync(string selector)
+        {
+            await Page.ClickAsync(selector);
+        }
+
+        public async Task FillAsync(string selector, string text)
+        {
+            await Page.FillAsync(selector, text);
+        }
+
+        public async Task<string?> GetTextAsync(string selector)
+        {
+            return await Page.TextContentAsync(selector);
+        }
+
+        public async Task WaitForElementAsync(string selector)
+        {
+            await Page.WaitForSelectorAsync(selector, new() { Timeout = Timeout });
+        }
+
+        public async Task<bool> IsVisibleAsync(string selector)
+        {
+            return await Page.Locator(selector).IsVisibleAsync();
+        }
+
+        public async Task SelectDropdownAsync(string selector, string optionText)
+        {
+            await Page.ClickAsync(selector);
+            await Page.ClickAsync($"text={optionText}");
+        }
+
+        public async Task SelectRadioButtonAsync(string labelText)
+        {
+            var label = Page.Locator($"label:has-text(\"{labelText}\")");
+            var radioId = await label.GetAttributeAsync("for");
+            await Page.ClickAsync($"#{radioId}");
+        }
+
+        public async Task CheckCheckboxAsync(string labelText)
+        {
+            var label = Page.Locator($"label:has-text(\"{labelText}\")");
+            var checkboxId = await label.GetAttributeAsync("for");
+            var checkbox = Page.Locator($"#{checkboxId}");
+            var isChecked = await checkbox.IsCheckedAsync();
+            
+            if (!isChecked)
+            {
+                await checkbox.ClickAsync();
+            }
+        }
+    }
+}
+```
+
+### 5. Login Page (Pages/LoginPage.cs)
+```csharp
+using Microsoft.Playwright;
+
+namespace PlaywrightFramework.Pages
+{
+    public class LoginPage : BasePage
+    {
+        private const string UsernameField = "[data-test=\"username\"]";
+        private const string PasswordField = "[data-test=\"password\"]";
+        private const string LoginButton = "[data-test=\"login-button\"]";
+        private const string AppUrl = "https://www.saucedemo.com/";
+
+        public LoginPage(IPage page) : base(page)
+        {
+        }
+
+        public async Task GoToAsync()
+        {
+            await Page.GotoAsync(AppUrl);
+        }
+
+        public async Task LoginAsync(string username, string password)
+        {
+            await Page.FillAsync(UsernameField, username);
+            await Page.FillAsync(PasswordField, password);
+            await Page.ClickAsync(LoginButton);
+            await Page.WaitForURLAsync("**/inventory.html");
+        }
+
+        public async Task<bool> IsLoadedAsync()
+        {
+            return await Page.Locator(UsernameField).IsVisibleAsync();
+        }
+    }
+}
+```
+
+### 6. Data Reader (Utils/DataReader.cs)
+```csharp
+using System.Text.Json;
+using YamlDotNet.Serialization;
+using CsvHelper;
+using System.Globalization;
+
+namespace PlaywrightFramework.Utils
+{
+    public class DataReader
+    {
+        private static readonly string DataDir = Path.Combine(
+            AppContext.BaseDirectory, 
+            "..", "..", "..", "Data"
+        );
+
+        public static async Task<Dictionary<string, object>> ReadJsonAsync(string filename)
+        {
+            var path = Path.Combine(DataDir, filename);
+            var content = await File.ReadAllTextAsync(path);
+            return JsonSerializer.Deserialize<Dictionary<string, object>>(content) 
+                ?? new Dictionary<string, object>();
+        }
+
+        public static async Task<Dictionary<string, object>> ReadYamlAsync(string filename)
+        {
+            var path = Path.Combine(DataDir, filename);
+            var content = await File.ReadAllTextAsync(path);
+            var deserializer = new Deserializer();
+            return deserializer.Deserialize<Dictionary<string, object>>(content) 
+                ?? new Dictionary<string, object>();
+        }
+
+        public static async Task<List<Dictionary<string, string>>> ReadCsvAsync(string filename)
+        {
+            var path = Path.Combine(DataDir, filename);
+            var records = new List<Dictionary<string, string>>();
+
+            using (var reader = new StreamReader(path))
+            using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+            {
+                csv.Read();
+                csv.ReadHeader();
+
+                while (csv.Read())
+                {
+                    var record = new Dictionary<string, string>();
+                    foreach (var header in csv.HeaderRecord!)
+                    {
+                        record[header] = csv.GetField(header) ?? string.Empty;
+                    }
+                    records.Add(record);
+                }
+            }
+
+            return records;
+        }
+
+        public static Dictionary<string, string>? GetRecordByKey(
+            List<Dictionary<string, string>> data, 
+            string key, 
+            string value)
+        {
+            return data.FirstOrDefault(record => 
+                record.ContainsKey(key) && record[key] == value);
+        }
+    }
+}
+```
+
+### 7. Form Helper (Utils/FormHelper.cs)
+```csharp
+using Microsoft.Playwright;
+
+namespace PlaywrightFramework.Utils
+{
+    public class FormHelper
+    {
+        private readonly IPage _page;
+
+        public FormHelper(IPage page)
+        {
+            _page = page;
+        }
+
+        public async Task FillInputAsync(string selector, string value)
+        {
+            await _page.FillAsync(selector, value);
+        }
+
+        public async Task FillTextAreaAsync(string selector, string value)
+        {
+            var locator = _page.Locator(selector);
+            await locator.ClearAsync();
+            await locator.TypeAsync(value, new() { Delay = 50 });
+        }
+
+        public async Task SelectDropdownAsync(string dropdownSelector, string optionText)
+        {
+            await _page.ClickAsync(dropdownSelector);
+            await _page.ClickAsync($"text={optionText}");
+        }
+
+        public async Task SelectRadioButtonAsync(string labelText)
+        {
+            var label = _page.Locator($"label:has-text(\"{labelText}\")");
+            var radioId = await label.GetAttributeAsync("for");
+            await _page.ClickAsync($"#{radioId}");
+        }
+
+        public async Task CheckCheckboxAsync(string labelText)
+        {
+            var label = _page.Locator($"label:has-text(\"{labelText}\")");
+            var checkboxId = await label.GetAttributeAsync("for");
+            var checkbox = _page.Locator($"#{checkboxId}");
+            
+            if (!await checkbox.IsCheckedAsync())
+            {
+                await checkbox.ClickAsync();
+            }
+        }
+
+        public async Task CheckMultipleAsync(List<string> labels)
+        {
+            foreach (var label in labels)
+            {
+                await CheckCheckboxAsync(label);
+            }
+        }
+
+        public async Task<string> GetInputValueAsync(string selector)
+        {
+            return await _page.InputValueAsync(selector);
+        }
+
+        public async Task<bool> IsCheckboxCheckedAsync(string labelText)
+        {
+            var label = _page.Locator($"label:has-text(\"{labelText}\")");
+            var checkboxId = await label.GetAttributeAsync("for");
+            return await _page.Locator($"#{checkboxId}").IsCheckedAsync();
+        }
+    }
+}
+```
+
+### 8. Test Base Fixture (Fixtures/TestFixtures.cs)
+```csharp
+using Microsoft.Playwright;
+
+namespace PlaywrightFramework.Fixtures
+{
+    public class TestFixtures
+    {
+        protected IPlaywright Playwright = null!;
+        protected IBrowser Browser = null!;
+        protected IBrowserContext Context = null!;
+        protected IPage Page = null!;
+
+        [SetUp]
+        public async Task SetupAsync()
+        {
+            Playwright = await Microsoft.Playwright.Playwright.CreateAsync();
+            Browser = await Playwright.Chromium.LaunchAsync();
+            Context = await Browser.NewContextAsync();
+            Page = await Context.NewPageAsync();
+        }
+
+        [TearDown]
+        public async Task TeardownAsync()
+        {
+            if (Page != null)
+                await Page.CloseAsync();
+            
+            if (Context != null)
+                await Context.CloseAsync();
+            
+            if (Browser != null)
+                await Browser.CloseAsync();
+            
+            if (Playwright != null)
+                Playwright.Dispose();
+        }
+    }
+}
+```
+
+### 9. Sample Test (Tests/SauceDemoTests.cs)
+```csharp
+using NUnit.Framework;
+using PlaywrightFramework.Pages;
+using PlaywrightFramework.Fixtures;
+
+namespace PlaywrightFramework.Tests
+{
+    [TestFixture]
+    public class SauceDemoTests : TestFixtures
+    {
+        [Test]
+        public async Task TestLoginWithValidCredentials()
+        {
+            var loginPage = new LoginPage(Page);
+            await loginPage.GoToAsync();
+            await loginPage.LoginAsync("standard_user", "secret_sauce");
+
+            Assert.That(Page.Url, Does.Contain("inventory.html"));
+        }
+
+        [Test]
+        public async Task TestLoginWithInvalidCredentials()
+        {
+            var loginPage = new LoginPage(Page);
+            await loginPage.GoToAsync();
+            
+            await loginPage.LoginAsync("invalid_user", "wrong_password");
+            
+            var errorMessage = await loginPage.GetTextAsync("[data-test=\"error\"]");
+            Assert.That(errorMessage, Does.Contain("Username and password do not match"));
+        }
+    }
+}
+```
+
+### 10. Run Tests
+
+```bash
+# Run all tests
+dotnet test
+
+# Run specific test class
+dotnet test --filter=SauceDemoTests
+
+# Run specific test method
+dotnet test --filter="Name~TestLoginWithValidCredentials"
+
+# Run with parallel execution (default)
+dotnet test --parallel
+
+# Run with NUnit console runner
+nunit3-console PlaywrightFramework.csproj
+
+# Run BDD scenarios
+dotnet test --filter=BDD
+```
+
+### 11. Test Data Files
+
+**Data/users.json**
+```json
+{
+  "users": [
+    {
+      "id": "1",
+      "username": "standard_user",
+      "password": "secret_sauce",
+      "email": "user@example.com",
+      "firstName": "John",
+      "lastName": "Doe"
+    }
+  ]
+}
+```
+
+**Data/config.yaml**
+```yaml
+app:
+  url: https://www.saucedemo.com/
+  timeout: 30000
+users:
+  standard:
+    username: standard_user
+    password: secret_sauce
+```
+
+**Data/formData.csv**
+```csv
+formType,firstName,lastName,email
+basic,John,Doe,john@example.com
+extended,Jane,Smith,jane@example.com
+```
+
+### 12. specflow.json (BDD Configuration)
+```json
+{
+  "language": {
+    "feature": "en"
+  },
+  "stepAssembly": "PlaywrightFramework",
+  "unitTestProvider": "nunit",
+  "bindingCulture": "en-US"
+}
+```
+
+## Best Practices
+✅ **Page Object Model** - All selectors in page classes
+✅ **Async/Await** - Modern C# patterns throughout
+✅ **Dependency Injection** - NUnit fixtures
+✅ **Test Data** - Externalize in JSON, CSV, YAML
+✅ **Form Helpers** - Handle all form interactions
+✅ **Parallel Execution** - Default test runner behavior
+✅ **Chromium Only** - Single browser for consistency
+✅ **C# 12** - Latest language features
+✅ **NUnit** - Modern testing framework
+✅ **.NET 8** - Latest framework version
+
+**Note:** This framework uses .NET 8, C# 12, Chromium only, and async/await patterns. Use `dotnet build` to compile and `dotnet test` to run tests with automatic parallel execution.