Converting Tests back to C# but still with Playwright

Tests/Pages/BasePage.cs

@@ -0,0 +1,28 @@
+using Tests.Helpers;
+
+namespace Tests.Pages;
+
+public abstract class BasePage
+{
+    protected Website Website { get; }
+
+    protected BasePage(Website website)
+    {
+        Website = website;
+    }
+
+    public abstract string Url { get; }
+
+    public virtual async Task GotoAsync()
+    {
+        await Website.GotoAsync(Url);
+    }
+
+    public async Task<List<string>> GetLinksAsync()
+    {
+        var content = Website.FindById("content");
+        var links = content.Locator("a");
+        var hrefs = await links.EvaluateAllAsync<string[]>("els => els.map(el => el.getAttribute('href')).filter(Boolean)");
+        return hrefs.ToList();
+    }
+}

Tests/Pages/BuildCalculator/ArmyComponent.cs

@@ -0,0 +1,48 @@
+namespace Tests.Pages.BuildCalculator;
+
+public class ArmyComponent
+{
+    private readonly Website _website;
+    public ArmyComponent(Website website) => _website = website;
+
+    public ILocator ArmyView => _website.Locator(".armyView");
+
+    public ILocator DisplayValue(string label) =>
+        _website.Locator(".displayContainer").Filter(new() { HasText = label }).Locator(".displayContent");
+
+    public ILocator ArmyCards => ArmyView.Locator(".armyCard");
+
+    public async Task<string> GetArmyCompletedAtAsync() =>
+        (await DisplayValue("Army Completed At").TextContentAsync())?.Trim() ?? "";
+
+    public async Task<string> GetArmyAttackingAtAsync() =>
+        (await DisplayValue("Army Attacking At").TextContentAsync())?.Trim() ?? "";
+
+    public async Task<IReadOnlyList<string>> GetArmyUnitNamesAsync()
+    {
+        var cards = await ArmyCards.AllAsync();
+        var names = new List<string>();
+        foreach (var card in cards)
+        {
+            var text = (await card.InnerTextAsync()).Trim();
+            var match = System.Text.RegularExpressions.Regex.Match(text, @"\d+x\s*(.+)");
+            names.Add(match.Success ? match.Groups[1].Value.Trim() : text);
+        }
+        return names;
+    }
+
+    public async Task<IReadOnlyList<(string Name, int Count)>> GetArmyUnitCountsAsync()
+    {
+        var cards = await ArmyCards.AllAsync();
+        var counts = new List<(string, int)>();
+        foreach (var card in cards)
+        {
+            var countEl = card.Locator(".armyCount");
+            var nameEl = card.Locator("div").Last;
+            var count = (await countEl.TextContentAsync())?.Replace("x", "").Trim() ?? "0";
+            var name = (await nameEl.TextContentAsync())?.Trim() ?? "";
+            counts.Add((name, int.Parse(count)));
+        }
+        return counts;
+    }
+}

Tests/Pages/BuildCalculator/BankComponent.cs

@@ -0,0 +1,27 @@
+namespace Tests.Pages.BuildCalculator;
+
+public class BankComponent
+{
+    private readonly Website _website;
+    public BankComponent(Website website) => _website = website;
+
+    public ILocator BankContainer => _website.Locator(".bankContainer");
+
+    public ILocator DisplayValue(string label) =>
+        BankContainer.Locator(".displayContainer").Filter(new() { HasText = label }).Locator(".displayContent");
+
+    public async Task<string> GetTimeAsync() => (await DisplayValue("Time").TextContentAsync())?.Trim() ?? "";
+    public async Task<string> GetAlloyAsync() => (await DisplayValue("Alloy").TextContentAsync())?.Trim() ?? "";
+    public async Task<string> GetEtherAsync() => (await DisplayValue("Ether").TextContentAsync())?.Trim() ?? "";
+    public async Task<string> GetPyreAsync() => (await DisplayValue("Pyre").TextContentAsync())?.Trim() ?? "";
+    public async Task<string> GetSupplyAsync() => (await DisplayValue("Supply").TextContentAsync())?.Trim() ?? "";
+
+    public async Task<string> GetWorkerCountAsync() =>
+        (await BankContainer.Locator(".workerText").Locator(".displayContent").Nth(0).TextContentAsync())?.Trim() ?? "";
+
+    public async Task<string> GetBusyWorkerCountAsync() =>
+        (await BankContainer.Locator(".workerText").Locator(".displayContent").Nth(1).TextContentAsync())?.Trim() ?? "";
+
+    public async Task<string> GetCreatingWorkerCountAsync() =>
+        (await BankContainer.Locator(".workerText").Locator(".displayContent").Nth(2).TextContentAsync())?.Trim() ?? "";
+}

Tests/Pages/BuildCalculator/BuildChartComponent.cs

@@ -0,0 +1,20 @@
+namespace Tests.Pages.BuildCalculator;
+
+public class BuildChartComponent
+{
+    private readonly Website _website;
+    public BuildChartComponent(Website website) => _website = website;
+
+    public ILocator ChartsContainer => _website.Locator(".chartsContainer");
+
+    public ILocator DisplayValue(string label) =>
+        _website.Locator(".displayContainer").Filter(new() { HasText = label }).Locator(".displayContent");
+
+    public async Task<string> GetHighestAlloyAsync() => (await DisplayValue("Highest Alloy").TextContentAsync())?.Trim() ?? "";
+    public async Task<string> GetHighestEtherAsync() => (await DisplayValue("Highest Ether").TextContentAsync())?.Trim() ?? "";
+    public async Task<string> GetHighestPyreAsync() => (await DisplayValue("Highest Pyre").TextContentAsync())?.Trim() ?? "";
+    public async Task<string> GetHighestArmyAsync() => (await DisplayValue("Highest Army").TextContentAsync())?.Trim() ?? "";
+
+    public async Task<int> GetChartCountAsync() =>
+        await ChartsContainer.Locator("> div").CountAsync();
+}

Tests/Pages/BuildCalculator/BuildOrderComponent.cs

@@ -0,0 +1,12 @@
+namespace Tests.Pages.BuildCalculator;
+
+public class BuildOrderComponent
+{
+    private readonly Website _website;
+    public BuildOrderComponent(Website website) => _website = website;
+
+    public ILocator JsonTextarea => _website.Locator("textarea");
+
+    public async Task<string> GetJsonDataAsync() =>
+        await JsonTextarea.InputValueAsync();
+}

Tests/Pages/BuildCalculator/EntityClickViewComponent.cs

@@ -0,0 +1,31 @@
+namespace Tests.Pages.BuildCalculator;
+
+public class EntityClickViewComponent
+{
+    private readonly Website _website;
+    public EntityClickViewComponent(Website website) => _website = website;
+
+    public ILocator EntityClickView => _website.Locator(".entityClickView");
+
+    public async Task<string?> GetEntityNameAsync()
+    {
+        var el = EntityClickView.Locator("#entityName");
+        if (await el.CountAsync() == 0) return null;
+        return (await el.TextContentAsync())?.Trim();
+    }
+
+    public async Task<string?> GetEntityHealthAsync()
+    {
+        var healthText = EntityClickView.Locator("div").Filter(new() { HasTextRegex = new System.Text.RegularExpressions.Regex("Health", System.Text.RegularExpressions.RegexOptions.IgnoreCase) }).First;
+        if (await healthText.CountAsync() == 0) return null;
+        var text = (await healthText.TextContentAsync()) ?? "";
+        var match = System.Text.RegularExpressions.Regex.Match(text, @"(\d+)");
+        return match.Success ? match.Groups[1].Value : null;
+    }
+
+    public async Task ClickDetailedViewAsync() =>
+        await EntityClickView.Locator("button").Filter(new() { HasText = "Detailed" }).ClickAsync();
+
+    public async Task ClickPlainViewAsync() =>
+        await EntityClickView.Locator("button").Filter(new() { HasText = "Plain" }).ClickAsync();
+}

Tests/Pages/BuildCalculator/FilterComponent.cs

@@ -0,0 +1,28 @@
+namespace Tests.Pages.BuildCalculator;
+
+public class FilterComponent
+{
+    private readonly Website _website;
+    public FilterComponent(Website website) => _website = website;
+
+    private ILocator FactionSelect =>
+        _website.Locator("select").Filter(new() { Has = _website.Locator("option:has-text('Aru'), option:has-text(\"Q'Rath\")") });
+
+    private ILocator ImmortalSelect =>
+        _website.Locator("select").Filter(new() { Has = _website.Locator("option:has-text('Orzum'), option:has-text('Ajari'), option:has-text('Atzlan'), option:has-text('Mala'), option:has-text('Xol')") });
+
+    public async Task SelectFactionAsync(string faction) =>
+        await FactionSelect.SelectOptionAsync(faction);
+
+    public async Task SelectImmortalAsync(string immortal) =>
+        await ImmortalSelect.SelectOptionAsync(immortal);
+
+    public async Task<string> GetSelectedFactionAsync() =>
+        await FactionSelect.InputValueAsync();
+
+    public async Task<string> GetSelectedImmortalAsync() =>
+        await ImmortalSelect.InputValueAsync();
+
+    public async Task<IReadOnlyList<string>> GetAvailableImmortalsAsync() =>
+        await ImmortalSelect.Locator("option").AllTextContentsAsync();
+}

Tests/Pages/BuildCalculator/HighlightsComponent.cs

@@ -0,0 +1,29 @@
+namespace Tests.Pages.BuildCalculator;
+
+public class HighlightsComponent
+{
+    private readonly Website _website;
+    public HighlightsComponent(Website website) => _website = website;
+
+    public ILocator HighlightsContainer => _website.Locator(".highlightsContainer");
+    public ILocator RequestedColumn => HighlightsContainer.Locator("div").Filter(new() { HasText = "Requested" }).Locator("+ div");
+    public ILocator FinishedColumn => HighlightsContainer.Locator("div").Filter(new() { HasText = "Finished" }).Locator("+ div");
+
+    public async Task<IReadOnlyList<string>> GetRequestedItemsAsync() =>
+        await GetHighlightItemsAsync();
+
+    public async Task<IReadOnlyList<string>> GetFinishedItemsAsync() =>
+        await GetHighlightItemsAsync();
+
+    private async Task<IReadOnlyList<string>> GetHighlightItemsAsync()
+    {
+        var items = await _website.Locator(".highlightsContainer").Locator("div").Filter(new() { HasTextRegex = new System.Text.RegularExpressions.Regex(@"^\d+\s*\|") }).AllAsync();
+        var result = new List<string>();
+        foreach (var item in items)
+        {
+            var text = (await item.TextContentAsync())?.Trim();
+            if (text is not null) result.Add(text);
+        }
+        return result;
+    }
+}

Tests/Pages/BuildCalculator/HotkeyViewerComponent.cs

@@ -0,0 +1,54 @@
+namespace Tests.Pages.BuildCalculator;
+
+public class HotkeyViewerComponent
+{
+    private readonly Website _website;
+    public HotkeyViewerComponent(Website website) => _website = website;
+
+    public ILocator KeyContainer => _website.Locator(".keyContainer");
+
+    public async Task<ILocator?> FindKeyButtonAsync(string keyLabel)
+    {
+        var upper = keyLabel.ToUpperInvariant();
+        var buttons = KeyContainer.Locator("> div > div");
+        var count = await buttons.CountAsync();
+        for (int i = 0; i < count; i++)
+        {
+            var btn = buttons.Nth(i);
+            var text = (await btn.TextContentAsync())?.Trim().ToUpperInvariant() ?? "";
+            if (text.StartsWith(upper)) return btn;
+        }
+        return null;
+    }
+
+    public async Task ClickKeyAsync(string keyText)
+    {
+        var btn = await FindKeyButtonAsync(keyText);
+        if (btn is null) throw new InvalidOperationException($"Key \"{keyText}\" not found");
+        await btn.ClickAsync(new() { Force = true });
+    }
+
+    public async Task<string?> GetFirstEntityNameAsync(string keyText)
+    {
+        var btn = await FindKeyButtonAsync(keyText);
+        if (btn is null) return null;
+        var entities = btn.Locator("> div");
+        if (await entities.CountAsync() == 0) return null;
+        return (await entities.First.TextContentAsync())?.Trim();
+    }
+
+    public async Task<IReadOnlyList<string>> GetEntityNamesOnKeyAsync(string keyText)
+    {
+        var btn = await FindKeyButtonAsync(keyText);
+        if (btn is null) return Array.Empty<string>();
+        var entities = btn.Locator("> div");
+        var count = await entities.CountAsync();
+        var names = new List<string>();
+        for (int i = 0; i < count; i++)
+        {
+            var text = (await entities.Nth(i).TextContentAsync())?.Trim();
+            if (!string.IsNullOrEmpty(text)) names.Add(text);
+        }
+        return names;
+    }
+}

Tests/Pages/BuildCalculator/OptionsComponent.cs

@@ -0,0 +1,38 @@
+namespace Tests.Pages.BuildCalculator;
+
+public class OptionsComponent
+{
+    private readonly Website _website;
+    public OptionsComponent(Website website) => _website = website;
+
+    private ILocator FormNumberInput(string label) =>
+        _website.Locator(".formNumberContainer").Filter(new() { HasText = label }).Locator("input[type='number']");
+
+    private ILocator ButtonWithLabel(string label) =>
+        _website.Locator("button").Filter(new() { HasText = label });
+
+    public ILocator BuildingInputDelayInput => FormNumberInput("Building Input Delay");
+    public ILocator WaitTimeInput => FormNumberInput("Wait Time");
+    public ILocator WaitToInput => FormNumberInput("Wait To");
+    public ILocator AddWaitButton => ButtonWithLabel("Add Wait").First;
+    public ILocator AddWaitToButton => ButtonWithLabel("Add Wait").Last;
+
+    public async Task SetBuildingInputDelayAsync(int value)
+    {
+        await BuildingInputDelayInput.FillAsync(value.ToString());
+        await BuildingInputDelayInput.PressAsync("Enter");
+    }
+
+    public async Task SetWaitTimeAsync(int value) =>
+        await WaitTimeInput.FillAsync(value.ToString());
+
+    public async Task SetWaitToAsync(int value) =>
+        await WaitToInput.FillAsync(value.ToString());
+
+    public async Task ClickAddWaitAsync() => await AddWaitButton.ClickAsync();
+    public async Task ClickAddWaitToAsync() => await AddWaitToButton.ClickAsync();
+
+    public async Task<string> GetBuildingInputDelayAsync() => await BuildingInputDelayInput.InputValueAsync();
+    public async Task<string> GetWaitTimeAsync() => await WaitTimeInput.InputValueAsync();
+    public async Task<string> GetWaitToAsync() => await WaitToInput.InputValueAsync();
+}

Tests/Pages/BuildCalculator/TimelineComponent.cs

@@ -0,0 +1,16 @@
+namespace Tests.Pages.BuildCalculator;
+
+public class TimelineComponent
+{
+    private readonly Website _website;
+    public TimelineComponent(Website website) => _website = website;
+
+    public ILocator Container =>
+        _website.Locator(".calculatorGrid > div").Filter(new() { HasText = "Timeline highlights" });
+
+    public async Task<bool> ContainsEntityAsync(string name)
+    {
+        var text = (await Container.TextContentAsync()) ?? "";
+        return text.Contains(name);
+    }
+}

Tests/Pages/BuildCalculator/TimingComponent.cs

@@ -0,0 +1,28 @@
+namespace Tests.Pages.BuildCalculator;
+
+public class TimingComponent
+{
+    private readonly Website _website;
+    public TimingComponent(Website website) => _website = website;
+
+    private ILocator FormNumberInput(string label) =>
+        _website.Locator(".formNumberContainer").Filter(new() { HasText = label }).Locator("input[type='number']");
+
+    public ILocator AttackTimeInput => FormNumberInput("Attack Time");
+    public ILocator TravelTimeInput => FormNumberInput("Travel Time");
+
+    public async Task SetAttackTimeAsync(int value)
+    {
+        await AttackTimeInput.FillAsync(value.ToString());
+        await AttackTimeInput.PressAsync("Enter");
+    }
+
+    public async Task SetTravelTimeAsync(int value)
+    {
+        await TravelTimeInput.FillAsync(value.ToString());
+        await TravelTimeInput.PressAsync("Enter");
+    }
+
+    public async Task<string> GetAttackTimeAsync() => await AttackTimeInput.InputValueAsync();
+    public async Task<string> GetTravelTimeAsync() => await TravelTimeInput.InputValueAsync();
+}

Tests/Pages/BuildCalculatorPage.cs

@@ -0,0 +1,43 @@
+using Tests.Pages.BuildCalculator;
+using Tests.Shared;
+
+namespace Tests.Pages;
+
+public class BuildCalculatorPage : BasePage
+{
+    public BuildCalculatorPage(Website website) : base(website)
+    {
+        Timing = new TimingComponent(website);
+        Filter = new FilterComponent(website);
+        Options = new OptionsComponent(website);
+        Bank = new BankComponent(website);
+        Army = new ArmyComponent(website);
+        Highlights = new HighlightsComponent(website);
+        BuildOrder = new BuildOrderComponent(website);
+        Timeline = new TimelineComponent(website);
+        Hotkeys = new HotkeyViewerComponent(website);
+        EntityView = new EntityClickViewComponent(website);
+        Chart = new BuildChartComponent(website);
+        Toast = new ToastComponent(website);
+    }
+
+    public override string Url => "build-calculator";
+
+    public TimingComponent Timing { get; }
+    public FilterComponent Filter { get; }
+    public OptionsComponent Options { get; }
+    public BankComponent Bank { get; }
+    public ArmyComponent Army { get; }
+    public HighlightsComponent Highlights { get; }
+    public BuildOrderComponent BuildOrder { get; }
+    public TimelineComponent Timeline { get; }
+    public HotkeyViewerComponent Hotkeys { get; }
+    public EntityClickViewComponent EntityView { get; }
+    public BuildChartComponent Chart { get; }
+    public ToastComponent Toast { get; }
+
+    public ILocator CalculatorGrid => Website.Locator(".calculatorGrid");
+    public ILocator ClearBuildOrderButton => Website.Locator("button").Filter(new() { HasText = "Clear Build Order" });
+
+    public async Task ClickClearBuildOrderAsync() => await ClearBuildOrderButton.ClickAsync();
+}

Tests/Pages/DatabasePage.cs

@@ -0,0 +1,26 @@
+namespace Tests.Pages;
+
+public class DatabasePage : BasePage
+{
+    public DatabasePage(Website website) : base(website) { }
+
+    public override string Url => "database";
+
+    public async Task FilterNameAsync(string name)
+    {
+        var input = Website.FindById("filterName").First;
+        await Website.EnterInputAsync(input, name);
+    }
+
+    public async Task<string> GetEntityNameAsync(string entityType, string entityName)
+    {
+        var el = Website.Locator($"#{entityType.ToLower()}-{entityName.ToLower()}").Locator("#entityName");
+        return (await el.InnerTextAsync()).Trim();
+    }
+
+    public async Task<string> GetEntityNameByIndexAsync(int index)
+    {
+        var el = Website.FindById("entityName").Nth(index);
+        return (await el.InnerTextAsync()).Trim();
+    }
+}

Tests/Pages/DatabaseSinglePage.cs

@@ -0,0 +1,25 @@
+namespace Tests.Pages;
+
+public class DatabaseSinglePage : BasePage
+{
+    public DatabaseSinglePage(Website website) : base(website) { }
+
+    public override string Url => "database";
+
+    public async Task GotoWithSearchAsync(string searchText)
+    {
+        await Website.GotoAsync($"{Url}/{searchText}");
+    }
+
+    public async Task<string> GetEntityNameAsync() =>
+        (await Website.FindById("entityName").InnerTextAsync()).Trim();
+
+    public async Task<string> GetEntityHealthAsync() =>
+        (await Website.FindById("entityHealth").InnerTextAsync()).Trim();
+
+    public async Task<string> GetInvalidSearchAsync() =>
+        (await Website.FindById("invalidSearch").InnerTextAsync()).Trim();
+
+    public async Task<string> GetValidSearchAsync() =>
+        (await Website.FindById("validSearch").InnerTextAsync()).Trim();
+}

Tests/Pages/HarassCalculatorPage.cs

@@ -0,0 +1,48 @@
+namespace Tests.Pages;
+
+public class HarassCalculatorPage : BasePage
+{
+    public HarassCalculatorPage(Website website) : base(website) { }
+
+    public override string Url => "harass-calculator";
+
+    public async Task SetWorkersLostToHarassAsync(int number) =>
+        await EnterAndPressAsync("numberOfWorkersLostToHarass", number);
+
+    public async Task SetNumberOfTownHallsExistingAsync(int number) =>
+        await EnterAndPressAsync("numberOfTownHallsExisting", number);
+
+    public async Task SetTownHallTravelTimeAsync(int index, int seconds) =>
+        await EnterInputAtIndexAsync("numberOfTownHallTravelTimes", index, seconds);
+
+    public async Task<int> GetTotalAlloyHarassmentAsync() => await ReadIntAsync("totalAlloyHarassment");
+    public async Task<int> GetWorkerReplacementCostAsync() => await ReadIntAsync("workerReplacementCost");
+    public async Task<int> GetDelayedMiningCostAsync() => await ReadIntAsync("delayedMiningCost");
+    public async Task<int> GetAverageTravelTimeAsync() => await ReadIntAsync("getAverageTravelTime");
+    public async Task<int> GetExampleTotalAlloyLossAsync() => await ReadIntAsync("exampleTotalAlloyLoss");
+    public async Task<int> GetExampleWorkerCostAsync() => await ReadIntAsync("exampleWorkerCost");
+    public async Task<int> GetExampleMiningTimeCostAsync() => await ReadIntAsync("exampleMiningTimeCost");
+    public async Task<int> GetExampleTotalAlloyLossAccurateAsync() => await ReadIntAsync("exampleTotalAlloyLossAccurate");
+    public async Task<int> GetExampleTotalAlloyLossDifferenceAsync() => await ReadIntAsync("exampleTotalAlloyLossDifference");
+    public async Task<int> GetExampleTotalAlloyLossAccurateDifferenceAsync() => await ReadIntAsync("exampleTotalAlloyLossAccurateDifference");
+
+    private async Task EnterAndPressAsync(string id, int value)
+    {
+        var locator = Website.FindById(id);
+        await Website.EnterInputAsync(locator, value.ToString());
+    }
+
+    private async Task EnterInputAtIndexAsync(string parentId, int index, int value)
+    {
+        var inputs = Website.FindById(parentId).Locator("input");
+        var input = inputs.Nth(index);
+        await input.FillAsync(value.ToString());
+        await input.PressAsync("Enter");
+    }
+
+    private async Task<int> ReadIntAsync(string id)
+    {
+        var text = await Website.FindById(id).TextContentAsync() ?? "";
+        return int.Parse(text.Trim());
+    }
+}