606 lines
25 KiB
C#
606 lines
25 KiB
C#
using Microsoft.Playwright;
|
||
|
||
namespace Enciphered.Blazor.UIComponents.Tests;
|
||
|
||
[TestFixture]
|
||
public class FormsTests : PlaywrightTestBase
|
||
{
|
||
// ── Helpers ──────────────────────────────────────────────────────────────
|
||
|
||
private async Task GoToFormsAsync()
|
||
{
|
||
await Page.GotoAsync($"{BaseUrl}/forms", new PageGotoOptions { WaitUntil = WaitUntilState.NetworkIdle });
|
||
// Wait for Blazor interactive mode to be ready
|
||
await Page.WaitForSelectorAsync("[data-testid='btn-submit']", new PageWaitForSelectorOptions { Timeout = 10_000 });
|
||
}
|
||
|
||
private ILocator Input(string testId) => Page.Locator($"[data-testid='{testId}']");
|
||
private ILocator Trigger(string testId) => Page.Locator($"[data-testid='{testId}']");
|
||
private ILocator Btn(string testId) => Page.Locator($"[data-testid='{testId}']");
|
||
|
||
/// <summary>
|
||
/// Select a date via the calendar popover.
|
||
/// Opens the trigger, uses month/year pickers to navigate, then clicks the day.
|
||
/// </summary>
|
||
private async Task SelectDateAsync(string triggerId, DateOnly target)
|
||
{
|
||
// Open the popover
|
||
await Trigger(triggerId).ClickAsync();
|
||
await Page.WaitForTimeoutAsync(200);
|
||
|
||
await NavigateCalendarToDate(target);
|
||
|
||
// Click the target day (only enabled buttons in the calendar day grid)
|
||
// The day grid is the last grid-cols-7 div; find the button with matching day text
|
||
var dayGrid = Page.Locator(".grid.grid-cols-7").Last;
|
||
var dayButton = dayGrid.Locator($"button:not([disabled])").Filter(new LocatorFilterOptions { HasTextString = target.Day.ToString() }).First;
|
||
await dayButton.ClickAsync();
|
||
await Page.WaitForTimeoutAsync(200);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Navigate the open calendar to a specific month/year using the month and year pickers.
|
||
/// </summary>
|
||
private async Task NavigateCalendarToDate(DateOnly target)
|
||
{
|
||
// Click year header to open year picker, then select the year
|
||
var yearButton = Page.Locator("[data-calendar-year]");
|
||
await yearButton.ClickAsync();
|
||
await Page.WaitForTimeoutAsync(100);
|
||
|
||
// The year picker is a scrollable grid; find and click the target year
|
||
var yearGrid = Page.Locator(".grid.grid-cols-4");
|
||
var targetYearBtn = yearGrid.Locator($"button:has-text('{target.Year}')");
|
||
|
||
// If the year isn't visible, use prev/next to shift the year range (±20 per click)
|
||
var attempts = 0;
|
||
while (await targetYearBtn.CountAsync() == 0 && attempts < 10)
|
||
{
|
||
// Read the first year button text to determine which direction to go
|
||
var firstYearText = await yearGrid.Locator("button").First.InnerTextAsync();
|
||
var firstYear = int.Parse(firstYearText.Trim());
|
||
|
||
if (target.Year < firstYear)
|
||
await Page.Locator("button[aria-label='Previous month']").ClickAsync();
|
||
else
|
||
await Page.Locator("button[aria-label='Next month']").ClickAsync();
|
||
await Page.WaitForTimeoutAsync(50);
|
||
yearGrid = Page.Locator(".grid.grid-cols-4");
|
||
targetYearBtn = yearGrid.Locator($"button:has-text('{target.Year}')");
|
||
attempts++;
|
||
}
|
||
|
||
await targetYearBtn.First.ClickAsync();
|
||
await Page.WaitForTimeoutAsync(100);
|
||
|
||
// Now click month header to open month picker, then select the month
|
||
var monthButton = Page.Locator("[data-calendar-month]");
|
||
await monthButton.ClickAsync();
|
||
await Page.WaitForTimeoutAsync(100);
|
||
|
||
var monthGrid = Page.Locator(".grid.grid-cols-3");
|
||
var targetMonthText = new DateOnly(2000, target.Month, 1).ToString("MMM");
|
||
await monthGrid.Locator($"button:has-text('{targetMonthText}')").First.ClickAsync();
|
||
await Page.WaitForTimeoutAsync(100);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Select a time via the time picker popover.
|
||
/// Opens the trigger, clicks the hour, minute, and AM/PM.
|
||
/// </summary>
|
||
private async Task SelectTimeAsync(string triggerId, int hour, int minute)
|
||
{
|
||
// Open the popover
|
||
await Trigger(triggerId).ClickAsync();
|
||
await Page.WaitForTimeoutAsync(200);
|
||
|
||
await PickTimeInOpenPopover(hour, minute);
|
||
|
||
// Close popover by clicking the backdrop overlay
|
||
await Page.Locator(".fixed.inset-0.z-40").ClickAsync(new LocatorClickOptions { Force = true });
|
||
await Page.WaitForTimeoutAsync(100);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Pick hour, minute, and AM/PM in an already-open time picker.
|
||
/// Scopes all locators to the visible popover content to avoid backdrop interception.
|
||
/// </summary>
|
||
private async Task PickTimeInOpenPopover(int hour, int minute)
|
||
{
|
||
// The popover content sits in a z-50 absolutely positioned container
|
||
var popoverContent = Page.Locator(".absolute.z-50");
|
||
|
||
// Convert to 12-hour format
|
||
var isPm = hour >= 12;
|
||
var hour12 = hour % 12;
|
||
if (hour12 == 0) hour12 = 12;
|
||
|
||
// Click the hour in the first scrollable column (within the popover)
|
||
var hourText = hour12.ToString("D2");
|
||
var hourColumn = popoverContent.Locator(".scrollbar-thin").First;
|
||
await hourColumn.Locator($"button:has-text('{hourText}')").First.ClickAsync();
|
||
await Page.WaitForTimeoutAsync(50);
|
||
|
||
// Click the minute in the second scrollable column (within the popover)
|
||
var minuteText = minute.ToString("D2");
|
||
var minuteColumn = popoverContent.Locator(".scrollbar-thin").Nth(1);
|
||
await minuteColumn.Locator($"button:has-text('{minuteText}')").First.ClickAsync();
|
||
await Page.WaitForTimeoutAsync(50);
|
||
|
||
// Click AM/PM (within the popover)
|
||
var periodText = isPm ? "PM" : "AM";
|
||
await popoverContent.Locator($"button:has-text('{periodText}')").First.ClickAsync();
|
||
await Page.WaitForTimeoutAsync(50);
|
||
}
|
||
|
||
// ════════════════════════════════════════════════════════════════════════
|
||
// Rendering
|
||
// ════════════════════════════════════════════════════════════════════════
|
||
|
||
[Test]
|
||
public async Task FormsPage_Loads_Successfully()
|
||
{
|
||
var response = await Page.GotoAsync($"{BaseUrl}/forms");
|
||
Assert.That(response!.Status, Is.EqualTo(200));
|
||
}
|
||
|
||
[Test]
|
||
public async Task FormsPage_Has_Title()
|
||
{
|
||
await GoToFormsAsync();
|
||
var heading = Page.Locator("[data-sidebar-inset] h1.text-3xl");
|
||
await Expect(heading).ToHaveTextAsync("Forms Demo");
|
||
}
|
||
|
||
[Test]
|
||
public async Task All_Inputs_Are_Rendered()
|
||
{
|
||
await GoToFormsAsync();
|
||
|
||
await Expect(Input("input-name")).ToBeVisibleAsync();
|
||
await Expect(Input("input-email")).ToBeVisibleAsync();
|
||
await Expect(Input("input-password")).ToBeVisibleAsync();
|
||
await Expect(Input("input-age")).ToBeVisibleAsync();
|
||
// Date/Time/DateTime use popover triggers instead of visible native inputs
|
||
await Expect(Trigger("trigger-birthdate")).ToBeVisibleAsync();
|
||
await Expect(Trigger("trigger-preferredtime")).ToBeVisibleAsync();
|
||
await Expect(Trigger("trigger-appointment-date")).ToBeVisibleAsync();
|
||
await Expect(Trigger("trigger-appointment-time")).ToBeVisibleAsync();
|
||
}
|
||
|
||
[Test]
|
||
public async Task All_Buttons_Are_Rendered()
|
||
{
|
||
await GoToFormsAsync();
|
||
|
||
await Expect(Btn("btn-submit")).ToBeVisibleAsync();
|
||
await Expect(Btn("btn-reset")).ToBeVisibleAsync();
|
||
await Expect(Btn("btn-disabled")).ToBeVisibleAsync();
|
||
}
|
||
|
||
// ════════════════════════════════════════════════════════════════════════
|
||
// Input types
|
||
// ════════════════════════════════════════════════════════════════════════
|
||
|
||
[Test]
|
||
public async Task TextInput_Has_Correct_Type()
|
||
{
|
||
await GoToFormsAsync();
|
||
await Expect(Input("input-name")).ToHaveAttributeAsync("type", "text");
|
||
}
|
||
|
||
[Test]
|
||
public async Task EmailInput_Has_Correct_Type()
|
||
{
|
||
await GoToFormsAsync();
|
||
await Expect(Input("input-email")).ToHaveAttributeAsync("type", "email");
|
||
}
|
||
|
||
[Test]
|
||
public async Task PasswordInput_Has_Correct_Type()
|
||
{
|
||
await GoToFormsAsync();
|
||
await Expect(Input("input-password")).ToHaveAttributeAsync("type", "password");
|
||
}
|
||
|
||
[Test]
|
||
public async Task NumberInput_Has_Correct_Type()
|
||
{
|
||
await GoToFormsAsync();
|
||
await Expect(Input("input-age")).ToHaveAttributeAsync("type", "number");
|
||
}
|
||
|
||
[Test]
|
||
public async Task DateInput_Has_Correct_Type()
|
||
{
|
||
await GoToFormsAsync();
|
||
await Expect(Input("input-birthdate")).ToHaveAttributeAsync("type", "date");
|
||
}
|
||
|
||
[Test]
|
||
public async Task TimeInput_Has_Correct_Type()
|
||
{
|
||
await GoToFormsAsync();
|
||
await Expect(Input("input-time")).ToHaveAttributeAsync("type", "time");
|
||
}
|
||
|
||
[Test]
|
||
public async Task DateTimeInput_Has_Correct_Type()
|
||
{
|
||
await GoToFormsAsync();
|
||
await Expect(Input("input-appointment")).ToHaveAttributeAsync("type", "datetime-local");
|
||
}
|
||
|
||
// ════════════════════════════════════════════════════════════════════════
|
||
// Placeholders
|
||
// ════════════════════════════════════════════════════════════════════════
|
||
|
||
[Test]
|
||
public async Task TextInput_Shows_Placeholder()
|
||
{
|
||
await GoToFormsAsync();
|
||
await Expect(Input("input-name")).ToHaveAttributeAsync("placeholder", "Jane Doe");
|
||
}
|
||
|
||
[Test]
|
||
public async Task EmailInput_Shows_Placeholder()
|
||
{
|
||
await GoToFormsAsync();
|
||
await Expect(Input("input-email")).ToHaveAttributeAsync("placeholder", "jane@example.com");
|
||
}
|
||
|
||
// ════════════════════════════════════════════════════════════════════════
|
||
// Labels
|
||
// ════════════════════════════════════════════════════════════════════════
|
||
|
||
[Test]
|
||
public async Task FormFields_Have_Labels()
|
||
{
|
||
await GoToFormsAsync();
|
||
|
||
var labels = Page.Locator("label");
|
||
var count = await labels.CountAsync();
|
||
Assert.That(count, Is.EqualTo(7), "Expected 7 labels (one per form field)");
|
||
}
|
||
|
||
[Test]
|
||
public async Task Label_For_Attribute_Matches_Input_Id()
|
||
{
|
||
await GoToFormsAsync();
|
||
|
||
var label = Page.Locator("label[for='name']");
|
||
await Expect(label).ToHaveTextAsync("Full Name");
|
||
|
||
var input = Input("input-name");
|
||
await Expect(input).ToHaveAttributeAsync("id", "name");
|
||
}
|
||
|
||
// ════════════════════════════════════════════════════════════════════════
|
||
// Two-way binding
|
||
// ════════════════════════════════════════════════════════════════════════
|
||
|
||
[Test]
|
||
public async Task TextInput_Binds_Value()
|
||
{
|
||
await GoToFormsAsync();
|
||
|
||
var input = Input("input-name");
|
||
await input.FillAsync("Alice");
|
||
await Expect(input).ToHaveValueAsync("Alice");
|
||
}
|
||
|
||
[Test]
|
||
public async Task NumberInput_Binds_Value()
|
||
{
|
||
await GoToFormsAsync();
|
||
|
||
var input = Input("input-age");
|
||
await input.FillAsync("30");
|
||
await Expect(input).ToHaveValueAsync("30");
|
||
}
|
||
|
||
[Test]
|
||
public async Task DateInput_Binds_Value()
|
||
{
|
||
await GoToFormsAsync();
|
||
|
||
// Use the calendar popover to select June 15, 2000
|
||
await SelectDateAsync("trigger-birthdate", new DateOnly(2000, 6, 15));
|
||
|
||
// The hidden input should reflect the selected date
|
||
await Expect(Input("input-birthdate")).ToHaveValueAsync("2000-06-15");
|
||
}
|
||
|
||
[Test]
|
||
public async Task TimeInput_Binds_Value()
|
||
{
|
||
await GoToFormsAsync();
|
||
|
||
// Use the time picker popover to select 14:30 (2:30 PM)
|
||
await SelectTimeAsync("trigger-preferredtime", 14, 30);
|
||
|
||
// The hidden input should reflect the selected time
|
||
await Expect(Input("input-time")).ToHaveValueAsync("14:30");
|
||
}
|
||
|
||
[Test]
|
||
public async Task DateTimeInput_Binds_Value()
|
||
{
|
||
await GoToFormsAsync();
|
||
|
||
// Pick the date part via the date trigger
|
||
await SelectDateAsync("trigger-appointment-date", new DateOnly(2025, 12, 25));
|
||
|
||
// Pick the time part via the time trigger
|
||
await SelectTimeAsync("trigger-appointment-time", 10, 0);
|
||
|
||
// The hidden input should have the combined datetime value
|
||
var value = await Input("input-appointment").InputValueAsync();
|
||
Assert.That(value, Does.StartWith("2025-12-25T10:00"));
|
||
}
|
||
|
||
// ════════════════════════════════════════════════════════════════════════
|
||
// Validation — empty submit shows errors
|
||
// ════════════════════════════════════════════════════════════════════════
|
||
|
||
[Test]
|
||
public async Task Empty_Submit_Shows_Validation_Errors()
|
||
{
|
||
await GoToFormsAsync();
|
||
|
||
await Btn("btn-submit").ClickAsync();
|
||
|
||
// Wait for at least one error message to appear
|
||
await Page.WaitForSelectorAsync("p.text-destructive", new PageWaitForSelectorOptions { Timeout = 5_000 });
|
||
|
||
var errors = Page.Locator("p.text-destructive");
|
||
var count = await errors.CountAsync();
|
||
Assert.That(count, Is.GreaterThanOrEqualTo(7), "Expected at least 7 validation errors (one per required field)");
|
||
}
|
||
|
||
[Test]
|
||
public async Task Validation_Error_Shows_Name_Required()
|
||
{
|
||
await GoToFormsAsync();
|
||
|
||
await Btn("btn-submit").ClickAsync();
|
||
await Page.WaitForSelectorAsync("p.text-destructive", new PageWaitForSelectorOptions { Timeout = 5_000 });
|
||
|
||
var nameError = Page.Locator("p.text-destructive", new PageLocatorOptions { HasTextString = "Name is required" });
|
||
await Expect(nameError).ToBeVisibleAsync();
|
||
}
|
||
|
||
[Test]
|
||
public async Task Validation_Error_Shows_Email_Required()
|
||
{
|
||
await GoToFormsAsync();
|
||
|
||
await Btn("btn-submit").ClickAsync();
|
||
await Page.WaitForSelectorAsync("p.text-destructive", new PageWaitForSelectorOptions { Timeout = 5_000 });
|
||
|
||
var emailError = Page.Locator("p.text-destructive", new PageLocatorOptions { HasTextString = "Email is required" });
|
||
await Expect(emailError).ToBeVisibleAsync();
|
||
}
|
||
|
||
// ════════════════════════════════════════════════════════════════════════
|
||
// Validation — specific error messages
|
||
// ════════════════════════════════════════════════════════════════════════
|
||
|
||
[Test]
|
||
public async Task Short_Name_Shows_Length_Error()
|
||
{
|
||
await GoToFormsAsync();
|
||
|
||
var input = Input("input-name");
|
||
await input.FillAsync("A");
|
||
await Btn("btn-submit").ClickAsync();
|
||
await Page.WaitForSelectorAsync("p.text-destructive", new PageWaitForSelectorOptions { Timeout = 5_000 });
|
||
|
||
var error = Page.Locator("p.text-destructive", new PageLocatorOptions { HasTextString = "2–100 characters" });
|
||
await Expect(error).ToBeVisibleAsync();
|
||
}
|
||
|
||
[Test]
|
||
public async Task Invalid_Email_Shows_Error()
|
||
{
|
||
await GoToFormsAsync();
|
||
|
||
var input = Input("input-email");
|
||
await input.FillAsync("not-an-email");
|
||
await Btn("btn-submit").ClickAsync();
|
||
await Page.WaitForSelectorAsync("p.text-destructive", new PageWaitForSelectorOptions { Timeout = 5_000 });
|
||
|
||
var error = Page.Locator("p.text-destructive", new PageLocatorOptions { HasTextString = "Invalid email" });
|
||
await Expect(error).ToBeVisibleAsync();
|
||
}
|
||
|
||
[Test]
|
||
public async Task Short_Password_Shows_Error()
|
||
{
|
||
await GoToFormsAsync();
|
||
|
||
var input = Input("input-password");
|
||
await input.FillAsync("123");
|
||
await Btn("btn-submit").ClickAsync();
|
||
await Page.WaitForSelectorAsync("p.text-destructive", new PageWaitForSelectorOptions { Timeout = 5_000 });
|
||
|
||
var error = Page.Locator("p.text-destructive", new PageLocatorOptions { HasTextString = "8–64 characters" });
|
||
await Expect(error).ToBeVisibleAsync();
|
||
}
|
||
|
||
// ════════════════════════════════════════════════════════════════════════
|
||
// Valid submission
|
||
// ════════════════════════════════════════════════════════════════════════
|
||
|
||
[Test]
|
||
public async Task Valid_Form_Shows_Success_Message()
|
||
{
|
||
await GoToFormsAsync();
|
||
|
||
await Input("input-name").FillAsync("Jane Doe");
|
||
await Input("input-email").FillAsync("jane@example.com");
|
||
await Input("input-password").FillAsync("securepassword123");
|
||
await Input("input-age").FillAsync("30");
|
||
|
||
// Use popover pickers for date/time fields
|
||
await SelectDateAsync("trigger-birthdate", new DateOnly(1995, 3, 15));
|
||
await SelectTimeAsync("trigger-preferredtime", 9, 30);
|
||
|
||
// DateTime: pick date and time via separate triggers
|
||
await SelectDateAsync("trigger-appointment-date", new DateOnly(2025, 12, 25));
|
||
await SelectTimeAsync("trigger-appointment-time", 10, 0);
|
||
|
||
await Btn("btn-submit").ClickAsync();
|
||
|
||
var success = Page.Locator("[data-testid='success-message']");
|
||
await Expect(success).ToBeVisibleAsync(new LocatorAssertionsToBeVisibleOptions { Timeout = 5_000 });
|
||
await Expect(success).ToContainTextAsync("Form submitted successfully");
|
||
await Expect(success).ToContainTextAsync("Jane Doe");
|
||
}
|
||
|
||
[Test]
|
||
public async Task No_Success_Message_Before_Submit()
|
||
{
|
||
await GoToFormsAsync();
|
||
|
||
var success = Page.Locator("[data-testid='success-message']");
|
||
await Expect(success).ToBeHiddenAsync();
|
||
}
|
||
|
||
// ════════════════════════════════════════════════════════════════════════
|
||
// Button variants
|
||
// ════════════════════════════════════════════════════════════════════════
|
||
|
||
[Test]
|
||
public async Task Submit_Button_Has_Default_Variant_Classes()
|
||
{
|
||
await GoToFormsAsync();
|
||
|
||
var btn = Btn("btn-submit");
|
||
var cls = await btn.GetAttributeAsync("class");
|
||
Assert.That(cls, Does.Contain("bg-primary"), "Submit should use default variant");
|
||
}
|
||
|
||
[Test]
|
||
public async Task Reset_Button_Has_Outline_Variant_Classes()
|
||
{
|
||
await GoToFormsAsync();
|
||
|
||
var btn = Btn("btn-reset");
|
||
var cls = await btn.GetAttributeAsync("class");
|
||
Assert.That(cls, Does.Contain("border"), "Reset should use outline variant");
|
||
Assert.That(cls, Does.Contain("bg-background"), "Reset should use outline variant");
|
||
}
|
||
|
||
[Test]
|
||
public async Task Disabled_Button_Is_Actually_Disabled()
|
||
{
|
||
await GoToFormsAsync();
|
||
|
||
var btn = Btn("btn-disabled");
|
||
await Expect(btn).ToBeDisabledAsync();
|
||
}
|
||
|
||
[Test]
|
||
public async Task Disabled_Button_Has_Destructive_Variant()
|
||
{
|
||
await GoToFormsAsync();
|
||
|
||
var btn = Btn("btn-disabled");
|
||
var cls = await btn.GetAttributeAsync("class");
|
||
Assert.That(cls, Does.Contain("bg-destructive"), "Disabled button should have destructive variant");
|
||
}
|
||
|
||
// ════════════════════════════════════════════════════════════════════════
|
||
// Reset
|
||
// ════════════════════════════════════════════════════════════════════════
|
||
|
||
[Test]
|
||
public async Task Reset_Button_Clears_Form()
|
||
{
|
||
await GoToFormsAsync();
|
||
|
||
// Fill some fields
|
||
await Input("input-name").FillAsync("Alice");
|
||
await Input("input-email").FillAsync("alice@test.com");
|
||
|
||
// Reset
|
||
await Btn("btn-reset").ClickAsync();
|
||
|
||
// Fields should be empty
|
||
await Expect(Input("input-name")).ToHaveValueAsync("");
|
||
await Expect(Input("input-email")).ToHaveValueAsync("");
|
||
}
|
||
|
||
[Test]
|
||
public async Task Reset_Button_Clears_Success_Message()
|
||
{
|
||
await GoToFormsAsync();
|
||
|
||
// Submit valid form
|
||
await Input("input-name").FillAsync("Jane Doe");
|
||
await Input("input-email").FillAsync("jane@example.com");
|
||
await Input("input-password").FillAsync("securepassword123");
|
||
await Input("input-age").FillAsync("30");
|
||
|
||
await SelectDateAsync("trigger-birthdate", new DateOnly(1995, 3, 15));
|
||
await SelectTimeAsync("trigger-preferredtime", 9, 30);
|
||
|
||
// DateTime picker — date and time via separate triggers
|
||
await SelectDateAsync("trigger-appointment-date", new DateOnly(2025, 12, 25));
|
||
await SelectTimeAsync("trigger-appointment-time", 10, 0);
|
||
|
||
await Btn("btn-submit").ClickAsync();
|
||
|
||
var success = Page.Locator("[data-testid='success-message']");
|
||
await Expect(success).ToBeVisibleAsync(new LocatorAssertionsToBeVisibleOptions { Timeout = 5_000 });
|
||
|
||
// Reset
|
||
await Btn("btn-reset").ClickAsync();
|
||
|
||
await Expect(success).ToBeHiddenAsync();
|
||
}
|
||
|
||
// ════════════════════════════════════════════════════════════════════════
|
||
// Input styling (base CSS classes present)
|
||
// ════════════════════════════════════════════════════════════════════════
|
||
|
||
[Test]
|
||
public async Task Inputs_Have_Base_Styling_Classes()
|
||
{
|
||
await GoToFormsAsync();
|
||
|
||
var input = Input("input-name");
|
||
var cls = await input.GetAttributeAsync("class");
|
||
Assert.That(cls, Does.Contain("rounded-md"), "Input should have rounded-md class");
|
||
Assert.That(cls, Does.Contain("border"), "Input should have border class");
|
||
}
|
||
|
||
// ════════════════════════════════════════════════════════════════════════
|
||
// Navigation to forms page
|
||
// ════════════════════════════════════════════════════════════════════════
|
||
|
||
[Test]
|
||
public async Task Sidebar_Has_Forms_Link()
|
||
{
|
||
await Page.GotoAsync(BaseUrl, new PageGotoOptions { WaitUntil = WaitUntilState.NetworkIdle });
|
||
await Page.WaitForSelectorAsync("[data-sidebar-wrapper][data-state]", new PageWaitForSelectorOptions { Timeout = 10_000 });
|
||
|
||
var formsLink = Page.Locator("a[href='/forms']");
|
||
await Expect(formsLink).ToBeVisibleAsync();
|
||
}
|
||
|
||
[Test]
|
||
public async Task Navigate_To_Forms_Via_Sidebar()
|
||
{
|
||
await Page.GotoAsync(BaseUrl, new PageGotoOptions { WaitUntil = WaitUntilState.NetworkIdle });
|
||
await Page.WaitForSelectorAsync("[data-sidebar-wrapper][data-state]", new PageWaitForSelectorOptions { Timeout = 10_000 });
|
||
|
||
await Page.Locator("a[href='/forms']").ClickAsync();
|
||
await Page.WaitForURLAsync($"{BaseUrl}/forms");
|
||
|
||
var heading = Page.Locator("[data-sidebar-inset] h1.text-3xl");
|
||
await Expect(heading).ToHaveTextAsync("Forms Demo");
|
||
}
|
||
}
|