refactor(configmanager): rename UI project and split test projects

Rename ConfigManager to ConfigManager.Ui to match the Core/CLI/UI project
structure, and split the monolithic test project into Core.Tests,
Cli.Tests, and Ui.Tests to align with the source project organization.

NEW/tests/Utils/JdeScoping.ConfigManager.Ui.Tests/ViewModels/Forms/AuthFormViewModelTests.cs

@@ -0,0 +1,91 @@
+using JdeScoping.ConfigManager.Core.Models;
+using JdeScoping.ConfigManager.Ui.ViewModels.Forms;
+
+namespace JdeScoping.ConfigManager.Ui.Tests.ViewModels.Forms;
+
+public class AuthFormViewModelTests
+{
+    [Fact]
+    public void Constructor_InitializesFromModel()
+    {
+        // Arrange
+        var model = new AuthSection
+        {
+            CookieName = ".TestApp.Auth",
+            CookieExpirationMinutes = 120
+        };
+
+        // Act
+        var sut = new AuthFormViewModel(model, () => { });
+
+        // Assert
+        sut.CookieName.ShouldBe(".TestApp.Auth");
+        sut.CookieExpirationMinutes.ShouldBe(120);
+    }
+
+    [Fact]
+    public void PropertyChange_UpdatesModelAndInvokesOnChanged()
+    {
+        // Arrange
+        var model = new AuthSection();
+        var changedInvoked = false;
+        var sut = new AuthFormViewModel(model, () => changedInvoked = true);
+
+        // Act
+        sut.CookieName = ".Custom.Cookie";
+
+        // Assert
+        model.CookieName.ShouldBe(".Custom.Cookie");
+        changedInvoked.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void CookieExpirationMinutes_UpdatesModelAndInvokesOnChanged()
+    {
+        // Arrange
+        var model = new AuthSection { CookieExpirationMinutes = 480 };
+        var changedInvoked = false;
+        var sut = new AuthFormViewModel(model, () => changedInvoked = true);
+
+        // Act
+        sut.CookieExpirationMinutes = 60;
+
+        // Assert
+        model.CookieExpirationMinutes.ShouldBe(60);
+        changedInvoked.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void PropertyChange_RaisesPropertyChanged()
+    {
+        // Arrange
+        var model = new AuthSection();
+        var sut = new AuthFormViewModel(model, () => { });
+        var propertyChangedRaised = false;
+        sut.PropertyChanged += (s, e) =>
+        {
+            if (e.PropertyName == nameof(AuthFormViewModel.CookieName))
+                propertyChangedRaised = true;
+        };
+
+        // Act
+        sut.CookieName = ".New.Cookie";
+
+        // Assert
+        propertyChangedRaised.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void Constructor_ThrowsOnNullModel()
+    {
+        // Act & Assert
+        Should.Throw<ArgumentNullException>(() => new AuthFormViewModel(null!, () => { }));
+    }
+
+    [Fact]
+    public void Constructor_ThrowsOnNullCallback()
+    {
+        // Act & Assert
+        Should.Throw<ArgumentNullException>(() => new AuthFormViewModel(new AuthSection(), null!));
+    }
+}

NEW/tests/Utils/JdeScoping.ConfigManager.Ui.Tests/ViewModels/Forms/ConnectionStringEntryViewModelTests.cs

@@ -0,0 +1,219 @@
+using JdeScoping.ConfigManager.Core.Models;
+using JdeScoping.ConfigManager.Ui.ViewModels.Forms;
+
+namespace JdeScoping.ConfigManager.Ui.Tests.ViewModels.Forms;
+
+public class ConnectionStringEntryViewModelTests
+{
+    [Fact]
+    public void Constructor_InitializesFromModel()
+    {
+        // Arrange
+        var model = new ConnectionStringEntry
+        {
+            Name = "TestConnection",
+            Provider = ConnectionProvider.SqlServer,
+            Server = "localhost",
+            SqlServerPort = 1434,
+            Database = "TestDb",
+            UserId = "testuser",
+            Password = "testpass",
+            Encrypt = "Strict",
+            TrustServerCertificate = true,
+            ConnectionTimeout = 45,
+            ApplicationName = "TestApp"
+        };
+
+        // Act
+        var sut = new ConnectionStringEntryViewModel(model, () => { });
+
+        // Assert
+        sut.Name.ShouldBe("TestConnection");
+        sut.Provider.ShouldBe(ConnectionProvider.SqlServer);
+        sut.Server.ShouldBe("localhost");
+        sut.SqlServerPort.ShouldBe(1434);
+        sut.Database.ShouldBe("TestDb");
+        sut.UserId.ShouldBe("testuser");
+        sut.Password.ShouldBe("testpass");
+        sut.Encrypt.ShouldBe("Strict");
+        sut.TrustServerCertificate.ShouldBeTrue();
+        sut.ConnectionTimeout.ShouldBe(45);
+        sut.ApplicationName.ShouldBe("TestApp");
+    }
+
+    [Fact]
+    public void Constructor_ThrowsOnNullModel()
+    {
+        // Act & Assert
+        Should.Throw<ArgumentNullException>(() => new ConnectionStringEntryViewModel(null!, () => { }));
+    }
+
+    [Fact]
+    public void Constructor_ThrowsOnNullOnChanged()
+    {
+        // Arrange
+        var model = new ConnectionStringEntry();
+
+        // Act & Assert
+        Should.Throw<ArgumentNullException>(() => new ConnectionStringEntryViewModel(model, null!));
+    }
+
+    [Fact]
+    public void PropertyChange_UpdatesModel()
+    {
+        // Arrange
+        var model = new ConnectionStringEntry();
+        var sut = new ConnectionStringEntryViewModel(model, () => { });
+
+        // Act
+        sut.Name = "UpdatedName";
+        sut.Server = "newserver";
+        sut.Database = "newdb";
+
+        // Assert
+        model.Name.ShouldBe("UpdatedName");
+        model.Server.ShouldBe("newserver");
+        model.Database.ShouldBe("newdb");
+    }
+
+    [Fact]
+    public void PropertyChange_InvokesOnChanged()
+    {
+        // Arrange
+        var model = new ConnectionStringEntry();
+        var changedInvoked = false;
+        var sut = new ConnectionStringEntryViewModel(model, () => changedInvoked = true);
+
+        // Act
+        sut.Name = "NewName";
+
+        // Assert
+        changedInvoked.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void TogglePasswordVisibility_TogglesIsPasswordVisible()
+    {
+        // Arrange
+        var model = new ConnectionStringEntry();
+        var sut = new ConnectionStringEntryViewModel(model, () => { });
+
+        // Assert initial state
+        sut.IsPasswordVisible.ShouldBeFalse();
+
+        // Act - first toggle
+        sut.TogglePasswordVisibilityCommand.Execute(null);
+
+        // Assert
+        sut.IsPasswordVisible.ShouldBeTrue();
+
+        // Act - second toggle
+        sut.TogglePasswordVisibilityCommand.Execute(null);
+
+        // Assert
+        sut.IsPasswordVisible.ShouldBeFalse();
+    }
+
+    [Fact]
+    public void ProviderDisplay_ReturnsCorrectString()
+    {
+        // Arrange
+        var model = new ConnectionStringEntry { Provider = ConnectionProvider.SqlServer };
+        var sut = new ConnectionStringEntryViewModel(model, () => { });
+
+        // Assert
+        sut.ProviderDisplay.ShouldBe("SqlServer");
+
+        // Act
+        sut.Provider = ConnectionProvider.Oracle;
+
+        // Assert
+        sut.ProviderDisplay.ShouldBe("Oracle");
+
+        // Act
+        sut.Provider = ConnectionProvider.Generic;
+
+        // Assert
+        sut.ProviderDisplay.ShouldBe("Generic");
+    }
+
+    [Fact]
+    public void ServerDisplay_ReturnsServerForSqlServer()
+    {
+        // Arrange
+        var model = new ConnectionStringEntry
+        {
+            Provider = ConnectionProvider.SqlServer,
+            Server = "sql-server-host"
+        };
+        var sut = new ConnectionStringEntryViewModel(model, () => { });
+
+        // Assert
+        sut.ServerDisplay.ShouldBe("sql-server-host");
+    }
+
+    [Fact]
+    public void ServerDisplay_ReturnsHostForOracle()
+    {
+        // Arrange
+        var model = new ConnectionStringEntry
+        {
+            Provider = ConnectionProvider.Oracle,
+            Host = "oracle-host"
+        };
+        var sut = new ConnectionStringEntryViewModel(model, () => { });
+
+        // Assert
+        sut.ServerDisplay.ShouldBe("oracle-host");
+    }
+
+    [Fact]
+    public void ServerDisplay_ReturnsDashForGeneric()
+    {
+        // Arrange
+        var model = new ConnectionStringEntry
+        {
+            Provider = ConnectionProvider.Generic,
+            RawConnectionString = "some connection string"
+        };
+        var sut = new ConnectionStringEntryViewModel(model, () => { });
+
+        // Assert
+        sut.ServerDisplay.ShouldBe("-");
+    }
+
+    [Fact]
+    public void SqlServerPort_PropertyChange_UpdatesModel()
+    {
+        // Arrange
+        var model = new ConnectionStringEntry();
+        var changedInvoked = false;
+        var sut = new ConnectionStringEntryViewModel(model, () => changedInvoked = true);
+
+        // Act
+        sut.SqlServerPort = 1434;
+
+        // Assert
+        model.SqlServerPort.ShouldBe(1434);
+        changedInvoked.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void SqlServerPort_PropertyChange_UpdatesGeneratedConnectionString()
+    {
+        // Arrange
+        var model = new ConnectionStringEntry
+        {
+            Provider = ConnectionProvider.SqlServer,
+            Server = "localhost",
+            Database = "TestDb"
+        };
+        var sut = new ConnectionStringEntryViewModel(model, () => { });
+
+        // Act
+        sut.SqlServerPort = 1434;
+
+        // Assert
+        sut.GeneratedConnectionString.ShouldContain("Server=localhost,1434");
+    }
+}

NEW/tests/Utils/JdeScoping.ConfigManager.Ui.Tests/ViewModels/Forms/ConnectionStringsFormViewModelTests.cs

@@ -0,0 +1,664 @@
+using JdeScoping.ConfigManager.Core.Models;
+using JdeScoping.ConfigManager.Core.Services;
+using JdeScoping.ConfigManager.Core.Services.SecureStore;
+using JdeScoping.ConfigManager.Ui.Services;
+using JdeScoping.ConfigManager.Ui.ViewModels.Forms;
+
+namespace JdeScoping.ConfigManager.Ui.Tests.ViewModels.Forms;
+
+public class ConnectionStringsFormViewModelTests
+{
+    private readonly ISecureStoreManager _secureStoreManager;
+    private readonly IDialogService _dialogService;
+    private readonly IConnectionTestService _connectionTestService;
+
+    public ConnectionStringsFormViewModelTests()
+    {
+        _secureStoreManager = Substitute.For<ISecureStoreManager>();
+        _dialogService = Substitute.For<IDialogService>();
+        _connectionTestService = Substitute.For<IConnectionTestService>();
+
+        // Setup default behavior - SecureStore is not open by default in tests
+        _secureStoreManager.IsStoreOpen.Returns(false);
+    }
+
+    [Fact]
+    public void Constructor_InitializesFromModel()
+    {
+        // Arrange
+        var model = new ConnectionStringsSection
+        {
+            Entries = new List<ConnectionStringEntry>
+            {
+                new ConnectionStringEntry
+                {
+                    Name = "Connection1",
+                    Provider = ConnectionProvider.SqlServer,
+                    Server = "server1"
+                },
+                new ConnectionStringEntry
+                {
+                    Name = "Connection2",
+                    Provider = ConnectionProvider.Oracle,
+                    Host = "oracle-host"
+                }
+            }
+        };
+
+        // Act
+        var sut = new ConnectionStringsFormViewModel(model, _secureStoreManager, () => { }, _dialogService, _connectionTestService);
+
+        // Assert
+        sut.Connections.Count.ShouldBe(2);
+        sut.Connections[0].Name.ShouldBe("Connection1");
+        sut.Connections[0].Provider.ShouldBe(ConnectionProvider.SqlServer);
+        sut.Connections[0].Server.ShouldBe("server1");
+        sut.Connections[1].Name.ShouldBe("Connection2");
+        sut.Connections[1].Provider.ShouldBe(ConnectionProvider.Oracle);
+        sut.Connections[1].Host.ShouldBe("oracle-host");
+    }
+
+    [Fact]
+    public void Constructor_LoadsAndParsesSqlServerConnectionStringFromSecureStore()
+    {
+        // Arrange
+        var model = new ConnectionStringsSection
+        {
+            Entries = new List<ConnectionStringEntry>
+            {
+                new ConnectionStringEntry { Name = "LotFinder" }
+            }
+        };
+        _secureStoreManager.IsStoreOpen.Returns(true);
+        _secureStoreManager.GetSecret("LotFinder")
+            .Returns("Server=localhost,1434;Database=ScopingTool;User Id=scopingapp;Password=pass;TrustServerCertificate=true");
+
+        // Act
+        var sut = new ConnectionStringsFormViewModel(model, _secureStoreManager, () => { }, _dialogService, _connectionTestService);
+
+        // Assert - port stays embedded in server name, not parsed into SqlServerPort
+        sut.Connections.Count.ShouldBe(1);
+        sut.Connections[0].Provider.ShouldBe(ConnectionProvider.SqlServer);
+        sut.Connections[0].Server.ShouldBe("localhost,1434");
+        sut.Connections[0].SqlServerPort.ShouldBeNull();
+        sut.Connections[0].Database.ShouldBe("ScopingTool");
+        sut.Connections[0].UserId.ShouldBe("scopingapp");
+        sut.Connections[0].Password.ShouldBe("pass");
+        sut.Connections[0].TrustServerCertificate.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void Constructor_LoadsAndParsesOracleConnectionStringFromSecureStore()
+    {
+        // Arrange
+        var model = new ConnectionStringsSection
+        {
+            Entries = new List<ConnectionStringEntry>
+            {
+                new ConnectionStringEntry { Name = "CMS" }
+            }
+        };
+        _secureStoreManager.IsStoreOpen.Returns(true);
+        _secureStoreManager.GetSecret("CMS")
+            .Returns("HOST=ha-iman;Service Name=imanprd;Fetch Array Size=1280000;Port=1522;User ID=app_teamcenter;Password=pass;");
+
+        // Act
+        var sut = new ConnectionStringsFormViewModel(model, _secureStoreManager, () => { }, _dialogService, _connectionTestService);
+
+        // Assert
+        sut.Connections.Count.ShouldBe(1);
+        sut.Connections[0].Provider.ShouldBe(ConnectionProvider.Oracle);
+        sut.Connections[0].Host.ShouldBe("ha-iman");
+        sut.Connections[0].ServiceName.ShouldBe("imanprd");
+        sut.Connections[0].Port.ShouldBe(1522);
+        sut.Connections[0].UserId.ShouldBe("app_teamcenter");
+        sut.Connections[0].Password.ShouldBe("pass");
+    }
+
+    [Fact]
+    public void Constructor_ThrowsOnNullModel()
+    {
+        // Act & Assert
+        Should.Throw<ArgumentNullException>(() =>
+            new ConnectionStringsFormViewModel(null!, _secureStoreManager, () => { }, _dialogService, _connectionTestService));
+    }
+
+    [Fact]
+    public void Constructor_ThrowsOnNullSecureStoreManager()
+    {
+        // Arrange
+        var model = new ConnectionStringsSection();
+
+        // Act & Assert
+        Should.Throw<ArgumentNullException>(() =>
+            new ConnectionStringsFormViewModel(model, null!, () => { }, _dialogService, _connectionTestService));
+    }
+
+    [Fact]
+    public void Constructor_ThrowsOnNullOnChanged()
+    {
+        // Arrange
+        var model = new ConnectionStringsSection();
+
+        // Act & Assert
+        Should.Throw<ArgumentNullException>(() =>
+            new ConnectionStringsFormViewModel(model, _secureStoreManager, null!, _dialogService, _connectionTestService));
+    }
+
+    [Fact]
+    public void Constructor_ThrowsOnNullConnectionTestService()
+    {
+        // Arrange
+        var model = new ConnectionStringsSection();
+
+        // Act & Assert
+        Should.Throw<ArgumentNullException>(() =>
+            new ConnectionStringsFormViewModel(model, _secureStoreManager, () => { }, _dialogService, null!));
+    }
+
+    [Fact]
+    public void AddConnection_CreatesNewEntryAndSelectsIt()
+    {
+        // Arrange
+        var model = new ConnectionStringsSection();
+        var changedInvoked = false;
+        var sut = new ConnectionStringsFormViewModel(model, _secureStoreManager, () => changedInvoked = true, _dialogService, _connectionTestService);
+
+        // Act
+        sut.AddConnectionCommand.Execute(null);
+
+        // Assert
+        sut.Connections.Count.ShouldBe(1);
+        sut.Connections[0].Name.ShouldBe("NewConnection");
+        sut.SelectedConnection.ShouldBe(sut.Connections[0]);
+        model.Entries.Count.ShouldBe(1);
+        changedInvoked.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void HasSelection_IsFalseWhenNothingSelected()
+    {
+        // Arrange
+        var model = new ConnectionStringsSection
+        {
+            Entries = new List<ConnectionStringEntry>
+            {
+                new ConnectionStringEntry { Name = "Conn1" }
+            }
+        };
+        var sut = new ConnectionStringsFormViewModel(model, _secureStoreManager, () => { }, _dialogService, _connectionTestService);
+
+        // Assert - no selection by default
+        sut.SelectedConnection.ShouldBeNull();
+        sut.HasSelection.ShouldBeFalse();
+    }
+
+    [Fact]
+    public void HasSelection_IsTrueWhenConnectionSelected()
+    {
+        // Arrange
+        var model = new ConnectionStringsSection
+        {
+            Entries = new List<ConnectionStringEntry>
+            {
+                new ConnectionStringEntry { Name = "Conn1" }
+            }
+        };
+        var sut = new ConnectionStringsFormViewModel(model, _secureStoreManager, () => { }, _dialogService, _connectionTestService);
+
+        // Act
+        sut.SelectedConnection = sut.Connections[0];
+
+        // Assert
+        sut.HasSelection.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void ConnectionCount_ReflectsCollectionSize()
+    {
+        // Arrange
+        var model = new ConnectionStringsSection
+        {
+            Entries = new List<ConnectionStringEntry>
+            {
+                new ConnectionStringEntry { Name = "Conn1" },
+                new ConnectionStringEntry { Name = "Conn2" },
+                new ConnectionStringEntry { Name = "Conn3" }
+            }
+        };
+
+        // Act
+        var sut = new ConnectionStringsFormViewModel(model, _secureStoreManager, () => { }, _dialogService, _connectionTestService);
+
+        // Assert
+        sut.ConnectionCount.ShouldBe(3);
+
+        // Act - add another
+        sut.AddConnectionCommand.Execute(null);
+
+        // Assert
+        sut.ConnectionCount.ShouldBe(4);
+    }
+
+    [Fact]
+    public void Constructor_InitializesConnectionsFromModel()
+    {
+        // Arrange
+        var model = new ConnectionStringsSection
+        {
+            Entries = new List<ConnectionStringEntry>
+            {
+                new ConnectionStringEntry
+                {
+                    Name = "TestConnection",
+                    Provider = ConnectionProvider.SqlServer,
+                    Server = "localhost",
+                    Database = "TestDb",
+                    UserId = "sa",
+                    Password = "secret"
+                }
+            }
+        };
+
+        // Act
+        var sut = new ConnectionStringsFormViewModel(model, _secureStoreManager, () => { }, _dialogService, _connectionTestService);
+
+        // Assert
+        sut.Connections.Count.ShouldBe(1);
+        sut.Connections[0].Name.ShouldBe("TestConnection");
+        sut.Connections[0].Provider.ShouldBe(ConnectionProvider.SqlServer);
+        sut.Connections[0].Server.ShouldBe("localhost");
+        sut.Connections[0].Database.ShouldBe("TestDb");
+    }
+
+    [Fact]
+    public void AddConnectionCommand_AddsNewConnection()
+    {
+        // Arrange
+        var model = new ConnectionStringsSection();
+        var sut = new ConnectionStringsFormViewModel(model, _secureStoreManager, () => { }, _dialogService, _connectionTestService);
+        var initialCount = sut.Connections.Count;
+
+        // Act
+        sut.AddConnectionCommand.Execute(null);
+
+        // Assert
+        sut.Connections.Count.ShouldBe(initialCount + 1);
+        sut.Connections.Last().Name.ShouldBe("NewConnection");
+        sut.Connections.Last().Provider.ShouldBe(ConnectionProvider.Generic);
+    }
+
+    [Fact]
+    public async Task DeleteConnectionCommand_WhenConfirmed_RemovesConnection()
+    {
+        // Arrange
+        var model = new ConnectionStringsSection
+        {
+            Entries = new List<ConnectionStringEntry>
+            {
+                new ConnectionStringEntry { Name = "ToDelete" }
+            }
+        };
+        _dialogService.ShowConfirmationAsync(Arg.Any<string>(), Arg.Any<string>())
+            .Returns(true);
+
+        var sut = new ConnectionStringsFormViewModel(model, _secureStoreManager, () => { }, _dialogService, _connectionTestService);
+        sut.SelectedConnection = sut.Connections[0];
+
+        // Act
+        sut.DeleteConnectionCommand.Execute(null);
+        await Task.Delay(100);
+
+        // Assert
+        sut.Connections.Count.ShouldBe(0);
+        model.Entries.Count.ShouldBe(0);
+    }
+
+    [Fact]
+    public async Task DeleteConnectionCommand_WhenCancelled_KeepsConnection()
+    {
+        // Arrange
+        var model = new ConnectionStringsSection
+        {
+            Entries = new List<ConnectionStringEntry>
+            {
+                new ConnectionStringEntry { Name = "ToKeep" }
+            }
+        };
+        _dialogService.ShowConfirmationAsync(Arg.Any<string>(), Arg.Any<string>())
+            .Returns(false);
+
+        var sut = new ConnectionStringsFormViewModel(model, _secureStoreManager, () => { }, _dialogService, _connectionTestService);
+        sut.SelectedConnection = sut.Connections[0];
+
+        // Act
+        sut.DeleteConnectionCommand.Execute(null);
+        await Task.Delay(100);
+
+        // Assert
+        sut.Connections.Count.ShouldBe(1);
+        sut.Connections[0].Name.ShouldBe("ToKeep");
+    }
+
+    [Fact]
+    public async Task ValidateConnectionCommand_WithEmptyConnectionString_ShowsError()
+    {
+        // Arrange
+        var model = new ConnectionStringsSection
+        {
+            Entries = new List<ConnectionStringEntry>
+            {
+                new ConnectionStringEntry
+                {
+                    Name = "EmptyConnection",
+                    Provider = ConnectionProvider.Generic,
+                    RawConnectionString = ""
+                }
+            }
+        };
+
+        var sut = new ConnectionStringsFormViewModel(model, _secureStoreManager, () => { }, _dialogService, _connectionTestService);
+        sut.SelectedConnection = sut.Connections[0];
+
+        // Act
+        sut.ValidateConnectionCommand.Execute(null);
+        await Task.Delay(100);
+
+        // Assert
+        await _dialogService.Received().ShowMessageAsync(
+            "Validation Failed",
+            Arg.Is<string>(s => s.Contains("empty connection string")));
+    }
+
+    [Fact]
+    public async Task ValidateConnectionCommand_WithValidConnectionString_ShowsSuccess()
+    {
+        // Arrange
+        var model = new ConnectionStringsSection
+        {
+            Entries = new List<ConnectionStringEntry>
+            {
+                new ConnectionStringEntry
+                {
+                    Name = "ValidConnection",
+                    Provider = ConnectionProvider.SqlServer,
+                    Server = "localhost",
+                    Database = "TestDb"
+                }
+            }
+        };
+
+        var sut = new ConnectionStringsFormViewModel(model, _secureStoreManager, () => { }, _dialogService, _connectionTestService);
+        sut.SelectedConnection = sut.Connections[0];
+
+        // Act
+        sut.ValidateConnectionCommand.Execute(null);
+        await Task.Delay(100);
+
+        // Assert
+        await _dialogService.Received().ShowMessageAsync(
+            "Validation Passed",
+            Arg.Is<string>(s => s.Contains("valid connection string")));
+    }
+
+    [Fact]
+    public async Task TestConnectionCommand_WhenSuccessful_ShowsSuccessMessage()
+    {
+        // Arrange
+        var model = new ConnectionStringsSection
+        {
+            Entries = new List<ConnectionStringEntry>
+            {
+                new ConnectionStringEntry
+                {
+                    Name = "TestConn",
+                    Provider = ConnectionProvider.SqlServer,
+                    Server = "localhost",
+                    Database = "TestDb"
+                }
+            }
+        };
+        _connectionTestService.TestConnectionAsync(Arg.Any<string>(), Arg.Any<ConnectionProvider>(), Arg.Any<CancellationToken>())
+            .Returns(new ConnectionTestResult { Success = true, Duration = TimeSpan.FromMilliseconds(50) });
+
+        var sut = new ConnectionStringsFormViewModel(model, _secureStoreManager, () => { }, _dialogService, _connectionTestService);
+        sut.SelectedConnection = sut.Connections[0];
+
+        // Act
+        sut.TestConnectionCommand.Execute(null);
+        await Task.Delay(150);
+
+        // Assert
+        await _dialogService.Received().ShowMessageAsync(
+            "Connection Successful",
+            Arg.Is<string>(s => s.Contains("Successfully connected")));
+    }
+
+    [Fact]
+    public async Task TestConnectionCommand_WhenFailed_ShowsErrorMessage()
+    {
+        // Arrange
+        var model = new ConnectionStringsSection
+        {
+            Entries = new List<ConnectionStringEntry>
+            {
+                new ConnectionStringEntry
+                {
+                    Name = "FailConn",
+                    Provider = ConnectionProvider.SqlServer,
+                    Server = "badserver",
+                    Database = "TestDb"
+                }
+            }
+        };
+        _connectionTestService.TestConnectionAsync(Arg.Any<string>(), Arg.Any<ConnectionProvider>(), Arg.Any<CancellationToken>())
+            .Returns(new ConnectionTestResult { Success = false, Message = "Connection refused" });
+
+        var sut = new ConnectionStringsFormViewModel(model, _secureStoreManager, () => { }, _dialogService, _connectionTestService);
+        sut.SelectedConnection = sut.Connections[0];
+
+        // Act
+        sut.TestConnectionCommand.Execute(null);
+        await Task.Delay(150);
+
+        // Assert
+        await _dialogService.Received().ShowMessageAsync(
+            "Connection Failed",
+            Arg.Is<string>(s => s.Contains("Failed to connect") && s.Contains("Connection refused")));
+    }
+
+    [Fact]
+    public async Task TestConnectionCommand_SetsIsTesting_DuringExecution()
+    {
+        // Arrange
+        var model = new ConnectionStringsSection
+        {
+            Entries = new List<ConnectionStringEntry>
+            {
+                new ConnectionStringEntry
+                {
+                    Name = "TestConn",
+                    Provider = ConnectionProvider.SqlServer,
+                    Server = "localhost",
+                    Database = "TestDb"
+                }
+            }
+        };
+
+        var taskCompletionSource = new TaskCompletionSource<ConnectionTestResult>();
+        _connectionTestService.TestConnectionAsync(Arg.Any<string>(), Arg.Any<ConnectionProvider>(), Arg.Any<CancellationToken>())
+            .Returns(taskCompletionSource.Task);
+
+        var sut = new ConnectionStringsFormViewModel(model, _secureStoreManager, () => { }, _dialogService, _connectionTestService);
+        sut.SelectedConnection = sut.Connections[0];
+
+        // Act - Start the command
+        sut.TestConnectionCommand.Execute(null);
+        await Task.Delay(50);
+
+        // Assert - IsTesting should be true during execution
+        sut.IsTesting.ShouldBeTrue();
+
+        // Complete the task
+        taskCompletionSource.SetResult(new ConnectionTestResult { Success = true });
+        await Task.Delay(100);
+
+        // Assert - IsTesting should be false after completion
+        sut.IsTesting.ShouldBeFalse();
+    }
+
+    [Fact]
+    public void SelectedConnection_WhenChanged_RaisesHasSelectionPropertyChanged()
+    {
+        // Arrange
+        var model = new ConnectionStringsSection
+        {
+            Entries = new List<ConnectionStringEntry>
+            {
+                new ConnectionStringEntry { Name = "Conn1" }
+            }
+        };
+        var sut = new ConnectionStringsFormViewModel(model, _secureStoreManager, () => { }, _dialogService, _connectionTestService);
+
+        var hasSelectionChangedRaised = false;
+        sut.PropertyChanged += (s, e) =>
+        {
+            if (e.PropertyName == nameof(ConnectionStringsFormViewModel.HasSelection))
+                hasSelectionChangedRaised = true;
+        };
+
+        // Act
+        sut.SelectedConnection = sut.Connections[0];
+
+        // Assert
+        hasSelectionChangedRaised.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void OnEntryChanged_SavesValueToSecureStore()
+    {
+        // Arrange
+        var model = new ConnectionStringsSection
+        {
+            Entries = new List<ConnectionStringEntry>
+            {
+                new ConnectionStringEntry
+                {
+                    Name = "TestConn",
+                    Provider = ConnectionProvider.SqlServer,
+                    Server = "localhost",
+                    Database = "TestDb"
+                }
+            }
+        };
+        _secureStoreManager.IsStoreOpen.Returns(true);
+
+        var onChangedCalled = false;
+        var sut = new ConnectionStringsFormViewModel(model, _secureStoreManager, () => onChangedCalled = true, _dialogService, _connectionTestService);
+        sut.SelectedConnection = sut.Connections[0];
+
+        // Act - Change a property on the selected connection
+        sut.SelectedConnection.Database = "NewDatabase";
+
+        // Assert
+        onChangedCalled.ShouldBeTrue();
+        _secureStoreManager.Received().SetSecret("TestConn", Arg.Any<string>());
+    }
+
+    [Fact]
+    public async Task DeleteConnectionCommand_RemovesFromSecureStore()
+    {
+        // Arrange
+        var model = new ConnectionStringsSection
+        {
+            Entries = new List<ConnectionStringEntry>
+            {
+                new ConnectionStringEntry { Name = "ToDelete" }
+            }
+        };
+        _secureStoreManager.IsStoreOpen.Returns(true);
+        _dialogService.ShowConfirmationAsync(Arg.Any<string>(), Arg.Any<string>())
+            .Returns(true);
+
+        var sut = new ConnectionStringsFormViewModel(model, _secureStoreManager, () => { }, _dialogService, _connectionTestService);
+        sut.SelectedConnection = sut.Connections[0];
+
+        // Act
+        sut.DeleteConnectionCommand.Execute(null);
+        await Task.Delay(100);
+
+        // Assert
+        _secureStoreManager.Received().RemoveSecret("ToDelete");
+    }
+
+    [Fact]
+    public void AddConnectionCommand_CreatesSecureStoreEntry()
+    {
+        // Arrange
+        var model = new ConnectionStringsSection();
+        _secureStoreManager.IsStoreOpen.Returns(true);
+
+        var sut = new ConnectionStringsFormViewModel(model, _secureStoreManager, () => { }, _dialogService, _connectionTestService);
+
+        // Act
+        sut.AddConnectionCommand.Execute(null);
+
+        // Assert
+        _secureStoreManager.Received().SetSecret("NewConnection", string.Empty);
+    }
+
+    [Fact]
+    public async Task TestConnectionCommand_WithEmptyConnectionString_ShowsMessage()
+    {
+        // Arrange
+        var model = new ConnectionStringsSection
+        {
+            Entries = new List<ConnectionStringEntry>
+            {
+                new ConnectionStringEntry
+                {
+                    Name = "EmptyConn",
+                    Provider = ConnectionProvider.Generic,
+                    RawConnectionString = ""
+                }
+            }
+        };
+
+        var sut = new ConnectionStringsFormViewModel(model, _secureStoreManager, () => { }, _dialogService, _connectionTestService);
+        sut.SelectedConnection = sut.Connections[0];
+
+        // Act
+        sut.TestConnectionCommand.Execute(null);
+        await Task.Delay(100);
+
+        // Assert
+        await _dialogService.Received().ShowMessageAsync(
+            "Test Connection",
+            Arg.Is<string>(s => s.Contains("connection string is empty")));
+        await _connectionTestService.DidNotReceive().TestConnectionAsync(
+            Arg.Any<string>(),
+            Arg.Any<ConnectionProvider>(),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public void AvailableProviders_ContainsAllProviders()
+    {
+        // Assert
+        ConnectionStringsFormViewModel.AvailableProviders.Count.ShouldBe(
+            Enum.GetValues<ConnectionProvider>().Length);
+        ConnectionStringsFormViewModel.AvailableProviders.ShouldContain(ConnectionProvider.SqlServer);
+        ConnectionStringsFormViewModel.AvailableProviders.ShouldContain(ConnectionProvider.Oracle);
+        ConnectionStringsFormViewModel.AvailableProviders.ShouldContain(ConnectionProvider.Generic);
+    }
+
+    [Fact]
+    public void EncryptOptions_ContainsExpectedValues()
+    {
+        // Assert
+        ConnectionStringsFormViewModel.EncryptOptions.Count.ShouldBe(3);
+        ConnectionStringsFormViewModel.EncryptOptions.ShouldContain("True");
+        ConnectionStringsFormViewModel.EncryptOptions.ShouldContain("False");
+        ConnectionStringsFormViewModel.EncryptOptions.ShouldContain("Strict");
+    }
+}

NEW/tests/Utils/JdeScoping.ConfigManager.Ui.Tests/ViewModels/Forms/DataAccessFormViewModelTests.cs

@@ -0,0 +1,43 @@
+using JdeScoping.ConfigManager.Core.Models;
+using JdeScoping.ConfigManager.Ui.ViewModels.Forms;
+
+namespace JdeScoping.ConfigManager.Ui.Tests.ViewModels.Forms;
+
+public class DataAccessFormViewModelTests
+{
+    [Fact]
+    public void Constructor_InitializesFromModel()
+    {
+        // Arrange
+        var model = new DataAccessSection
+        {
+            DefaultTimeoutSeconds = 60,
+            ProductionSchema = "dbo",
+            EnableDetailedLogging = true
+        };
+
+        // Act
+        var sut = new DataAccessFormViewModel(model, () => { });
+
+        // Assert
+        sut.DefaultTimeoutSeconds.ShouldBe(60);
+        sut.ProductionSchema.ShouldBe("dbo");
+        sut.EnableDetailedLogging.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void PropertyChange_UpdatesModelAndInvokesOnChanged()
+    {
+        // Arrange
+        var model = new DataAccessSection();
+        var changedInvoked = false;
+        var sut = new DataAccessFormViewModel(model, () => changedInvoked = true);
+
+        // Act
+        sut.ArchiveSchema = "hist";
+
+        // Assert
+        model.ArchiveSchema.ShouldBe("hist");
+        changedInvoked.ShouldBeTrue();
+    }
+}

NEW/tests/Utils/JdeScoping.ConfigManager.Ui.Tests/ViewModels/Forms/DataSyncFormViewModelTests.cs

@@ -0,0 +1,76 @@
+using JdeScoping.ConfigManager.Core.Models;
+using JdeScoping.ConfigManager.Ui.ViewModels.Forms;
+
+namespace JdeScoping.ConfigManager.Ui.Tests.ViewModels.Forms;
+
+public class DataSyncFormViewModelTests
+{
+    [Fact]
+    public void Constructor_InitializesFromModel()
+    {
+        // Arrange
+        var model = new DataSyncSection
+        {
+            Enabled = true,
+            MaxDegreeOfParallelism = 8,
+            BatchSize = 25000
+        };
+
+        // Act
+        var sut = new DataSyncFormViewModel(model, () => { });
+
+        // Assert
+        sut.Enabled.ShouldBeTrue();
+        sut.MaxDegreeOfParallelism.ShouldBe(8);
+        sut.BatchSize.ShouldBe(25000);
+    }
+
+    [Fact]
+    public void PropertyChange_UpdatesModel()
+    {
+        // Arrange
+        var model = new DataSyncSection { MaxDegreeOfParallelism = 4 };
+        var sut = new DataSyncFormViewModel(model, () => { });
+
+        // Act
+        sut.MaxDegreeOfParallelism = 16;
+
+        // Assert
+        model.MaxDegreeOfParallelism.ShouldBe(16);
+    }
+
+    [Fact]
+    public void PropertyChange_InvokesOnChanged()
+    {
+        // Arrange
+        var model = new DataSyncSection();
+        var changedInvoked = false;
+        var sut = new DataSyncFormViewModel(model, () => changedInvoked = true);
+
+        // Act
+        sut.BatchSize = 10000;
+
+        // Assert
+        changedInvoked.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void PropertyChange_RaisesPropertyChanged()
+    {
+        // Arrange
+        var model = new DataSyncSection();
+        var sut = new DataSyncFormViewModel(model, () => { });
+        var propertyChangedRaised = false;
+        sut.PropertyChanged += (s, e) =>
+        {
+            if (e.PropertyName == nameof(DataSyncFormViewModel.LookbackMultiplier))
+                propertyChangedRaised = true;
+        };
+
+        // Act
+        sut.LookbackMultiplier = 2.5;
+
+        // Assert
+        propertyChangedRaised.ShouldBeTrue();
+    }
+}

NEW/tests/Utils/JdeScoping.ConfigManager.Ui.Tests/ViewModels/Forms/ExcelExportFormViewModelTests.cs

@@ -0,0 +1,149 @@
+using JdeScoping.ConfigManager.Core.Models;
+using JdeScoping.ConfigManager.Ui.ViewModels.Forms;
+
+namespace JdeScoping.ConfigManager.Ui.Tests.ViewModels.Forms;
+
+public class ExcelExportFormViewModelTests
+{
+    [Fact]
+    public void Constructor_InitializesFromModel()
+    {
+        // Arrange
+        var model = new ExcelExportSection
+        {
+            MaxRowsPerSheet = 500000,
+            DefaultDateFormat = "MM/dd/yyyy",
+            DebugWriteToFile = true,
+            DebugOutputDirectory = "/tmp/debug",
+            TimezoneId = "America/Los_Angeles"
+        };
+
+        // Act
+        var sut = new ExcelExportFormViewModel(model, () => { });
+
+        // Assert
+        sut.MaxRowsPerSheet.ShouldBe(500000);
+        sut.DefaultDateFormat.ShouldBe("MM/dd/yyyy");
+        sut.DebugWriteToFile.ShouldBeTrue();
+        sut.DebugOutputDirectory.ShouldBe("/tmp/debug");
+        sut.SelectedTimezone.ShouldBe("America/Los_Angeles");
+    }
+
+    [Fact]
+    public void Constructor_UsesModelTimezone()
+    {
+        // Arrange - model defaults to "America/Chicago"
+        var model = new ExcelExportSection();
+
+        // Act
+        var sut = new ExcelExportFormViewModel(model, () => { });
+
+        // Assert
+        sut.SelectedTimezone.ShouldBe("America/Chicago");
+    }
+
+    [Fact]
+    public void AvailableTimezones_ContainsSystemTimezones()
+    {
+        // Act & Assert
+        ExcelExportFormViewModel.AvailableTimezones.ShouldNotBeEmpty();
+        // Check for common IANA timezones
+        ExcelExportFormViewModel.AvailableTimezones.ShouldContain("America/Chicago");
+        ExcelExportFormViewModel.AvailableTimezones.ShouldContain("UTC");
+    }
+
+    [Fact]
+    public void PropertyChange_UpdatesModel()
+    {
+        // Arrange
+        var model = new ExcelExportSection { MaxRowsPerSheet = 1000000 };
+        var sut = new ExcelExportFormViewModel(model, () => { });
+
+        // Act
+        sut.MaxRowsPerSheet = 750000;
+
+        // Assert
+        model.MaxRowsPerSheet.ShouldBe(750000);
+    }
+
+    [Fact]
+    public void SelectedTimezone_UpdatesModelTimezoneId()
+    {
+        // Arrange - model defaults to "America/Chicago"
+        var model = new ExcelExportSection();
+        var sut = new ExcelExportFormViewModel(model, () => { });
+
+        // Act - change to a different timezone
+        sut.SelectedTimezone = "America/New_York";
+
+        // Assert
+        model.TimezoneId.ShouldBe("America/New_York");
+    }
+
+    [Fact]
+    public void PropertyChange_InvokesOnChanged()
+    {
+        // Arrange
+        var model = new ExcelExportSection(); // Default TimezoneId is "America/Chicago"
+        var changedInvoked = false;
+        var sut = new ExcelExportFormViewModel(model, () => changedInvoked = true);
+
+        // Act - change to a different timezone than the default
+        sut.SelectedTimezone = "America/Denver";
+
+        // Assert
+        changedInvoked.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void PropertyChange_RaisesPropertyChanged()
+    {
+        // Arrange
+        var model = new ExcelExportSection();
+        var sut = new ExcelExportFormViewModel(model, () => { });
+        var propertyChangedRaised = false;
+        sut.PropertyChanged += (s, e) =>
+        {
+            if (e.PropertyName == nameof(ExcelExportFormViewModel.DefaultDateFormat))
+                propertyChangedRaised = true;
+        };
+
+        // Act
+        sut.DefaultDateFormat = "dd-MMM-yyyy";
+
+        // Assert
+        propertyChangedRaised.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void SameValueAssignment_DoesNotInvokeOnChanged()
+    {
+        // Arrange
+        var model = new ExcelExportSection { DebugWriteToFile = true };
+        var changedInvoked = false;
+        var sut = new ExcelExportFormViewModel(model, () => changedInvoked = true);
+
+        // Act
+        sut.DebugWriteToFile = true; // Same value
+
+        // Assert
+        changedInvoked.ShouldBeFalse();
+    }
+
+    [Fact]
+    public void Constructor_ThrowsOnNullModel()
+    {
+        // Act & Assert
+        Should.Throw<ArgumentNullException>(() => new ExcelExportFormViewModel(null!, () => { }));
+    }
+
+    [Fact]
+    public void Constructor_ThrowsOnNullOnChanged()
+    {
+        // Arrange
+        var model = new ExcelExportSection();
+
+        // Act & Assert
+        Should.Throw<ArgumentNullException>(() => new ExcelExportFormViewModel(model, null!));
+    }
+}

NEW/tests/Utils/JdeScoping.ConfigManager.Ui.Tests/ViewModels/Forms/LdapFormViewModelTests.cs

@@ -0,0 +1,60 @@
+using JdeScoping.ConfigManager.Core.Models;
+using JdeScoping.ConfigManager.Ui.ViewModels.Forms;
+
+namespace JdeScoping.ConfigManager.Ui.Tests.ViewModels.Forms;
+
+public class LdapFormViewModelTests
+{
+    [Fact]
+    public void Constructor_InitializesFromModel()
+    {
+        // Arrange
+        var model = new LdapSection
+        {
+            ServerUrls = ["ldap://server1.local", "ldap://server2.local"],
+            GroupDn = "CN=Admins,DC=corp",
+            SearchBase = "DC=corp,DC=local",
+            UseFakeAuth = true
+        };
+
+        // Act
+        var sut = new LdapFormViewModel(model, () => { });
+
+        // Assert
+        sut.ServerUrlsText.ShouldBe("ldap://server1.local\nldap://server2.local");
+        sut.GroupDn.ShouldBe("CN=Admins,DC=corp");
+        sut.SearchBase.ShouldBe("DC=corp,DC=local");
+        sut.UseFakeAuth.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void ServerUrlsText_SplitsIntoArray()
+    {
+        // Arrange
+        var model = new LdapSection();
+        var sut = new LdapFormViewModel(model, () => { });
+
+        // Act
+        sut.ServerUrlsText = "ldap://a.local\nldap://b.local\nldap://c.local";
+
+        // Assert
+        model.ServerUrls.Length.ShouldBe(3);
+        model.ServerUrls[0].ShouldBe("ldap://a.local");
+        model.ServerUrls[2].ShouldBe("ldap://c.local");
+    }
+
+    [Fact]
+    public void AdminBypassUsersText_SplitsIntoArray()
+    {
+        // Arrange
+        var model = new LdapSection();
+        var sut = new LdapFormViewModel(model, () => { });
+
+        // Act
+        sut.AdminBypassUsersText = "admin\nservice_account";
+
+        // Assert
+        model.AdminBypassUsers.Length.ShouldBe(2);
+        model.AdminBypassUsers[0].ShouldBe("admin");
+    }
+}

NEW/tests/Utils/JdeScoping.ConfigManager.Ui.Tests/ViewModels/Forms/PipelineEditorViewModelTests.cs

@@ -0,0 +1,630 @@
+using JdeScoping.ConfigManager.Ui.Services;
+using JdeScoping.ConfigManager.Ui.ViewModels.Forms;
+using JdeScoping.ConfigManager.Ui.ViewModels.PipelineSteps;
+using JdeScoping.DataSync.Configuration;
+
+namespace JdeScoping.ConfigManager.Ui.Tests.ViewModels.Forms;
+
+public class PipelineEditorViewModelTests
+{
+    private readonly IDialogService _dialogService;
+
+    public PipelineEditorViewModelTests()
+    {
+        _dialogService = Substitute.For<IDialogService>();
+    }
+
+    [Fact]
+    public void Constructor_InitializesPropertiesCorrectly()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        var connections = new List<string> { "jde", "cms", "lotfinder" };
+
+        // Act
+        var sut = new PipelineEditorViewModel("TestPipeline", model, connections, _dialogService, () => { });
+
+        // Assert
+        sut.Name.ShouldBe("TestPipeline");
+        sut.AvailableConnections.ShouldBe(connections);
+        sut.PreScripts.ShouldNotBeNull();
+        sut.Transformers.ShouldNotBeNull();
+        sut.PostScripts.ShouldNotBeNull();
+        sut.Source.ShouldNotBeNull();
+        sut.Destination.ShouldNotBeNull();
+    }
+
+    [Fact]
+    public void Constructor_BuildsSourceAndDestinationFromModel()
+    {
+        // Arrange
+        var model = new EtlPipelineConfig
+        {
+            Source = new SourceElement { Connection = "jde", Query = "SELECT * FROM WO" },
+            Destination = new DestinationElement { Table = "WorkOrder_Curr" }
+        };
+        var connections = new List<string> { "jde" };
+
+        // Act
+        var sut = new PipelineEditorViewModel("TestPipeline", model, connections, _dialogService, () => { });
+
+        // Assert
+        sut.Source.Connection.ShouldBe("jde");
+        sut.Source.Query.ShouldBe("SELECT * FROM WO");
+        sut.Destination.Table.ShouldBe("WorkOrder_Curr");
+    }
+
+    [Fact]
+    public void IsEnabled_Setter_UpdatesModelAndInvokesOnChanged()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        model.IsEnabled = false;
+        var changedInvoked = false;
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => changedInvoked = true);
+
+        // Act
+        sut.IsEnabled = true;
+
+        // Assert
+        sut.IsEnabled.ShouldBeTrue();
+        model.IsEnabled.ShouldBeTrue();
+        changedInvoked.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void IsManualOnly_Setter_UpdatesModelAndInvokesOnChanged()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        model.IsManualOnly = false;
+        var changedInvoked = false;
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => changedInvoked = true);
+
+        // Act
+        sut.IsManualOnly = true;
+
+        // Assert
+        sut.IsManualOnly.ShouldBeTrue();
+        model.IsManualOnly.ShouldBeTrue();
+        changedInvoked.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void MassSyncEnabled_ToggleOn_SetsDefaultInterval()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        model.MassSyncIntervalMinutes = null;
+        var changedInvoked = false;
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => changedInvoked = true);
+
+        // Act
+        sut.MassSyncEnabled = true;
+
+        // Assert
+        sut.MassSyncEnabled.ShouldBeTrue();
+        sut.MassSyncIntervalMinutes.ShouldBe(10080); // 1 week default
+        model.MassSyncIntervalMinutes.ShouldBe(10080);
+        changedInvoked.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void MassSyncEnabled_ToggleOff_ClearsInterval()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        model.MassSyncIntervalMinutes = 10080;
+        var changedInvoked = false;
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => changedInvoked = true);
+
+        // Act
+        sut.MassSyncEnabled = false;
+
+        // Assert
+        sut.MassSyncEnabled.ShouldBeFalse();
+        model.MassSyncIntervalMinutes.ShouldBeNull();
+        changedInvoked.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void DailySyncEnabled_ToggleOn_SetsDefaultInterval()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        model.DailySyncIntervalMinutes = null;
+        var changedInvoked = false;
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => changedInvoked = true);
+
+        // Act
+        sut.DailySyncEnabled = true;
+
+        // Assert
+        sut.DailySyncEnabled.ShouldBeTrue();
+        sut.DailySyncIntervalMinutes.ShouldBe(1440); // 1 day default
+        model.DailySyncIntervalMinutes.ShouldBe(1440);
+        changedInvoked.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void HourlySyncEnabled_ToggleOn_SetsDefaultInterval()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        model.HourlySyncIntervalMinutes = null;
+        var changedInvoked = false;
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => changedInvoked = true);
+
+        // Act
+        sut.HourlySyncEnabled = true;
+
+        // Assert
+        sut.HourlySyncEnabled.ShouldBeTrue();
+        sut.HourlySyncIntervalMinutes.ShouldBe(60); // 1 hour default
+        model.HourlySyncIntervalMinutes.ShouldBe(60);
+        changedInvoked.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void SelectedStep_Setter_DeselectsPreviousAndSelectsNew()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => { });
+        var source = sut.Source;
+        var destination = sut.Destination;
+
+        // Act - Select source
+        sut.SelectedStep = source;
+
+        // Assert
+        source.IsSelected.ShouldBeTrue();
+        sut.SelectedStep.ShouldBe(source);
+
+        // Act - Select destination (should deselect source)
+        sut.SelectedStep = destination;
+
+        // Assert
+        source.IsSelected.ShouldBeFalse();
+        destination.IsSelected.ShouldBeTrue();
+        sut.SelectedStep.ShouldBe(destination);
+    }
+
+    [Fact]
+    public void CanDeleteSelectedStep_ReturnsFalse_ForSourceStep()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => { });
+
+        // Act
+        sut.SelectedStep = sut.Source;
+
+        // Assert
+        sut.CanDeleteSelectedStep.ShouldBeFalse();
+    }
+
+    [Fact]
+    public void CanDeleteSelectedStep_ReturnsFalse_ForDestinationStep()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => { });
+
+        // Act
+        sut.SelectedStep = sut.Destination;
+
+        // Assert
+        sut.CanDeleteSelectedStep.ShouldBeFalse();
+    }
+
+    [Fact]
+    public void CanDeleteSelectedStep_ReturnsTrue_ForTransformerStep()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => { });
+
+        // Add a transformer
+        sut.AddTransformerCommand.Execute(null);
+        var transformer = sut.Transformers[0];
+
+        // Act
+        sut.SelectedStep = transformer;
+
+        // Assert
+        sut.CanDeleteSelectedStep.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void CanDeleteSelectedStep_ReturnsTrue_ForPreScriptStep()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => { });
+
+        // Add a pre-script
+        sut.AddPreScriptCommand.Execute(null);
+        var preScript = sut.PreScripts[0];
+
+        // Act
+        sut.SelectedStep = preScript;
+
+        // Assert
+        sut.CanDeleteSelectedStep.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void CanDeleteSelectedStep_ReturnsTrue_ForPostScriptStep()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => { });
+
+        // Add a post-script
+        sut.AddPostScriptCommand.Execute(null);
+        var postScript = sut.PostScripts[0];
+
+        // Act
+        sut.SelectedStep = postScript;
+
+        // Assert
+        sut.CanDeleteSelectedStep.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void AddPreScriptCommand_AddsPreScriptAndSelectsIt()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        var changedInvoked = false;
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => changedInvoked = true);
+
+        // Act
+        sut.AddPreScriptCommand.Execute(null);
+
+        // Assert
+        sut.PreScripts.Count.ShouldBe(1);
+        sut.SelectedStep.ShouldBe(sut.PreScripts[0]);
+        sut.PreScripts[0].IsSelected.ShouldBeTrue();
+        changedInvoked.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void AddTransformerCommand_AddsTransformerAndSelectsIt()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        var changedInvoked = false;
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => changedInvoked = true);
+
+        // Act
+        sut.AddTransformerCommand.Execute(null);
+
+        // Assert
+        sut.Transformers.Count.ShouldBe(1);
+        sut.SelectedStep.ShouldBe(sut.Transformers[0]);
+        sut.Transformers[0].IsSelected.ShouldBeTrue();
+        changedInvoked.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void AddPostScriptCommand_AddsPostScriptAndSelectsIt()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        var changedInvoked = false;
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => changedInvoked = true);
+
+        // Act
+        sut.AddPostScriptCommand.Execute(null);
+
+        // Assert
+        sut.PostScripts.Count.ShouldBe(1);
+        sut.SelectedStep.ShouldBe(sut.PostScripts[0]);
+        sut.PostScripts[0].IsSelected.ShouldBeTrue();
+        changedInvoked.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void RemoveStepCommand_RemovesSelectedStep()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        var changedInvoked = false;
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => changedInvoked = true);
+
+        // Add a transformer first
+        sut.AddTransformerCommand.Execute(null);
+        var transformer = sut.Transformers[0];
+        changedInvoked = false;
+
+        // Act
+        sut.RemoveStepCommand.Execute(transformer);
+
+        // Assert
+        sut.Transformers.Count.ShouldBe(0);
+        sut.SelectedStep.ShouldBeNull();
+        changedInvoked.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void MoveStepUpCommand_MovesStepUpInCollection()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => { });
+
+        // Add two transformers
+        sut.AddTransformerCommand.Execute(null);
+        sut.AddTransformerCommand.Execute(null);
+        var firstTransformer = sut.Transformers[0];
+        var secondTransformer = sut.Transformers[1];
+
+        // Act - Move second up
+        sut.MoveStepUpCommand.Execute(secondTransformer);
+
+        // Assert
+        sut.Transformers[0].ShouldBe(secondTransformer);
+        sut.Transformers[1].ShouldBe(firstTransformer);
+    }
+
+    [Fact]
+    public void MoveStepDownCommand_MovesStepDownInCollection()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => { });
+
+        // Add two transformers
+        sut.AddTransformerCommand.Execute(null);
+        sut.AddTransformerCommand.Execute(null);
+        var firstTransformer = sut.Transformers[0];
+        var secondTransformer = sut.Transformers[1];
+
+        // Act - Move first down
+        sut.MoveStepDownCommand.Execute(firstTransformer);
+
+        // Assert
+        sut.Transformers[0].ShouldBe(secondTransformer);
+        sut.Transformers[1].ShouldBe(firstTransformer);
+    }
+
+    [Fact]
+    public void MoveStepUpCommand_DoesNotMove_WhenAtTop()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => { });
+
+        // Add two transformers
+        sut.AddTransformerCommand.Execute(null);
+        sut.AddTransformerCommand.Execute(null);
+        var firstTransformer = sut.Transformers[0];
+        var secondTransformer = sut.Transformers[1];
+
+        // Act - Try to move first up (should do nothing)
+        sut.MoveStepUpCommand.Execute(firstTransformer);
+
+        // Assert
+        sut.Transformers[0].ShouldBe(firstTransformer);
+        sut.Transformers[1].ShouldBe(secondTransformer);
+    }
+
+    [Fact]
+    public void MoveStepDownCommand_DoesNotMove_WhenAtBottom()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => { });
+
+        // Add two transformers
+        sut.AddTransformerCommand.Execute(null);
+        sut.AddTransformerCommand.Execute(null);
+        var firstTransformer = sut.Transformers[0];
+        var secondTransformer = sut.Transformers[1];
+
+        // Act - Try to move second down (should do nothing)
+        sut.MoveStepDownCommand.Execute(secondTransformer);
+
+        // Assert
+        sut.Transformers[0].ShouldBe(firstTransformer);
+        sut.Transformers[1].ShouldBe(secondTransformer);
+    }
+
+    [Fact]
+    public void Constructor_ThrowsOnNullName()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+
+        // Act & Assert
+        Should.Throw<ArgumentNullException>(() =>
+            new PipelineEditorViewModel(null!, model, [], _dialogService, () => { }));
+    }
+
+    [Fact]
+    public void Constructor_ThrowsOnNullModel()
+    {
+        // Act & Assert
+        Should.Throw<ArgumentNullException>(() =>
+            new PipelineEditorViewModel("Test", null!, [], _dialogService, () => { }));
+    }
+
+    [Fact]
+    public void Constructor_ThrowsOnNullDialogService()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+
+        // Act & Assert
+        Should.Throw<ArgumentNullException>(() =>
+            new PipelineEditorViewModel("Test", model, [], null!, () => { }));
+    }
+
+    [Fact]
+    public void Constructor_ThrowsOnNullOnChanged()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+
+        // Act & Assert
+        Should.Throw<ArgumentNullException>(() =>
+            new PipelineEditorViewModel("Test", model, [], _dialogService, null!));
+    }
+
+    [Fact]
+    public void Constructor_LoadsExistingTransformers()
+    {
+        // Arrange
+        var model = new EtlPipelineConfig
+        {
+            Source = new SourceElement { Connection = "jde", Query = "SELECT * FROM WO" },
+            Destination = new DestinationElement { Table = "WorkOrder" },
+            Transforms =
+            [
+                new TransformElement { TransformType = "ColumnDrop" },
+                new TransformElement { TransformType = "ColumnRename" }
+            ]
+        };
+
+        // Act
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => { });
+
+        // Assert
+        sut.Transformers.Count.ShouldBe(2);
+        sut.Transformers[0].ShouldBeOfType<ColumnDropTransformerViewModel>();
+        sut.Transformers[1].ShouldBeOfType<ColumnRenameTransformerViewModel>();
+    }
+
+    [Fact]
+    public void Constructor_LoadsExistingPreScripts()
+    {
+        // Arrange
+        var model = new EtlPipelineConfig
+        {
+            Source = new SourceElement { Connection = "jde", Query = "SELECT * FROM WO" },
+            Destination = new DestinationElement { Table = "WorkOrder" },
+            PreScripts = [new ScriptElement { Connection = "lotfinder", Script = "TRUNCATE TABLE Test" }]
+        };
+
+        // Act
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => { });
+
+        // Assert
+        sut.PreScripts.Count.ShouldBe(1);
+        sut.PreScripts[0].Script.ShouldBe("TRUNCATE TABLE Test");
+    }
+
+    [Fact]
+    public void Constructor_LoadsExistingPostScripts()
+    {
+        // Arrange
+        var model = new EtlPipelineConfig
+        {
+            Source = new SourceElement { Connection = "jde", Query = "SELECT * FROM WO" },
+            Destination = new DestinationElement { Table = "WorkOrder" },
+            PostScripts = [new ScriptElement { Connection = "lotfinder", Script = "UPDATE Stats SET LastRun = GETDATE()" }]
+        };
+
+        // Act
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => { });
+
+        // Assert
+        sut.PostScripts.Count.ShouldBe(1);
+        sut.PostScripts[0].Script.ShouldBe("UPDATE Stats SET LastRun = GETDATE()");
+    }
+
+    [Fact]
+    public void AllSteps_ReturnsAllStepsInOrder()
+    {
+        // Arrange
+        var model = new EtlPipelineConfig
+        {
+            Source = new SourceElement { Connection = "jde", Query = "SELECT * FROM WO" },
+            Destination = new DestinationElement { Table = "WorkOrder" },
+            PreScripts = [new ScriptElement { Script = "pre" }],
+            Transforms = [new TransformElement { TransformType = "ColumnDrop" }],
+            PostScripts = [new ScriptElement { Script = "post" }]
+        };
+
+        // Act
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => { });
+        var allSteps = sut.AllSteps.ToList();
+
+        // Assert
+        allSteps.Count.ShouldBe(5);
+        allSteps[0].ShouldBeOfType<PreScriptStepViewModel>();
+        allSteps[1].ShouldBeOfType<SourceStepViewModel>();
+        allSteps[2].ShouldBeOfType<ColumnDropTransformerViewModel>();
+        allSteps[3].ShouldBeOfType<DestinationStepViewModel>();
+        allSteps[4].ShouldBeOfType<PostScriptStepViewModel>();
+    }
+
+    [Fact]
+    public void SelectedStepEditor_UpdatesWhenSelectedStepChanges()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => { });
+
+        // Act
+        sut.SelectedStep = sut.Source;
+
+        // Assert
+        sut.SelectedStepEditor.ShouldBe(sut.Source);
+    }
+
+    [Fact]
+    public void AddTransformerOfType_AddsSpecificTransformerType()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => { });
+
+        // Act
+        sut.AddTransformerOfType("JdeDate");
+
+        // Assert
+        sut.Transformers.Count.ShouldBe(1);
+        sut.Transformers[0].ShouldBeOfType<JdeDateTransformerViewModel>();
+        sut.SelectedStep.ShouldBe(sut.Transformers[0]);
+    }
+
+    [Fact]
+    public void SelectedTransformerType_SetterAndGetter_Work()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => { });
+
+        // Act
+        sut.SelectedTransformerType = "ColumnRename";
+
+        // Assert
+        sut.SelectedTransformerType.ShouldBe("ColumnRename");
+    }
+
+    [Fact]
+    public void AvailableTransformerTypes_ReturnsExpectedTypes()
+    {
+        // Arrange
+        var model = CreateDefaultModel();
+        var sut = new PipelineEditorViewModel("Test", model, [], _dialogService, () => { });
+
+        // Assert
+        sut.AvailableTransformerTypes.ShouldContain("ColumnDrop");
+        sut.AvailableTransformerTypes.ShouldContain("ColumnRename");
+        sut.AvailableTransformerTypes.ShouldContain("JdeDate");
+        sut.AvailableTransformerTypes.ShouldContain("Regex");
+    }
+
+    private static EtlPipelineConfig CreateDefaultModel()
+    {
+        return new EtlPipelineConfig
+        {
+            Source = new SourceElement { Connection = string.Empty, Query = string.Empty },
+            Destination = new DestinationElement { Table = string.Empty }
+        };
+    }
+}

NEW/tests/Utils/JdeScoping.ConfigManager.Ui.Tests/ViewModels/Forms/SearchFormViewModelTests.cs

@@ -0,0 +1,108 @@
+using JdeScoping.ConfigManager.Core.Models;
+using JdeScoping.ConfigManager.Ui.ViewModels.Forms;
+
+namespace JdeScoping.ConfigManager.Ui.Tests.ViewModels.Forms;
+
+public class SearchFormViewModelTests
+{
+    [Fact]
+    public void Constructor_InitializesFromModel()
+    {
+        // Arrange
+        var model = new SearchSection
+        {
+            MaxResultRows = 50000,
+            TimeoutSeconds = 600,
+            MaxConcurrentSearches = 10
+        };
+
+        // Act
+        var sut = new SearchFormViewModel(model, () => { });
+
+        // Assert
+        sut.MaxResultRows.ShouldBe(50000);
+        sut.TimeoutSeconds.ShouldBe(600);
+        sut.MaxConcurrentSearches.ShouldBe(10);
+    }
+
+    [Fact]
+    public void PropertyChange_UpdatesModel()
+    {
+        // Arrange
+        var model = new SearchSection { MaxResultRows = 100000 };
+        var sut = new SearchFormViewModel(model, () => { });
+
+        // Act
+        sut.MaxResultRows = 25000;
+
+        // Assert
+        model.MaxResultRows.ShouldBe(25000);
+    }
+
+    [Fact]
+    public void PropertyChange_InvokesOnChanged()
+    {
+        // Arrange
+        var model = new SearchSection();
+        var changedInvoked = false;
+        var sut = new SearchFormViewModel(model, () => changedInvoked = true);
+
+        // Act
+        sut.TimeoutSeconds = 120;
+
+        // Assert
+        changedInvoked.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void PropertyChange_RaisesPropertyChanged()
+    {
+        // Arrange
+        var model = new SearchSection();
+        var sut = new SearchFormViewModel(model, () => { });
+        var propertyChangedRaised = false;
+        sut.PropertyChanged += (s, e) =>
+        {
+            if (e.PropertyName == nameof(SearchFormViewModel.MaxConcurrentSearches))
+                propertyChangedRaised = true;
+        };
+
+        // Act
+        sut.MaxConcurrentSearches = 8;
+
+        // Assert
+        propertyChangedRaised.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void Constructor_ThrowsOnNullModel()
+    {
+        // Act & Assert
+        Should.Throw<ArgumentNullException>(() => new SearchFormViewModel(null!, () => { }));
+    }
+
+    [Fact]
+    public void Constructor_ThrowsOnNullCallback()
+    {
+        // Arrange
+        var model = new SearchSection();
+
+        // Act & Assert
+        Should.Throw<ArgumentNullException>(() => new SearchFormViewModel(model, null!));
+    }
+
+    [Fact]
+    public void PropertyChange_DoesNotInvokeOnChangedWhenValueUnchanged()
+    {
+        // Arrange
+        var model = new SearchSection { MaxResultRows = 50000 };
+        var changedCount = 0;
+        var sut = new SearchFormViewModel(model, () => changedCount++);
+
+        // Act - set to same value
+        sut.MaxResultRows = 50000;
+
+        // Assert
+        changedCount.ShouldBe(0);
+    }
+}

NEW/tests/Utils/JdeScoping.ConfigManager.Ui.Tests/ViewModels/Forms/SecretFormViewModelTests.cs

@@ -0,0 +1,412 @@
+using JdeScoping.ConfigManager.Ui.Services;
+using JdeScoping.ConfigManager.Ui.ViewModels.Forms;
+
+namespace JdeScoping.ConfigManager.Ui.Tests.ViewModels.Forms;
+
+public class SecretFormViewModelTests
+{
+    private readonly IClipboardService _clipboardService;
+
+    public SecretFormViewModelTests()
+    {
+        _clipboardService = Substitute.For<IClipboardService>();
+    }
+
+    [Fact]
+    public void Constructor_SetsPropertiesCorrectly()
+    {
+        // Arrange & Act
+        var sut = new SecretFormViewModel(
+            "API_KEY",
+            "secret-value-123",
+            _clipboardService,
+            _ => { },
+            () => { });
+
+        // Assert
+        sut.Key.ShouldBe("API_KEY");
+        sut.Value.ShouldBe("secret-value-123");
+        sut.IsValueVisible.ShouldBeFalse();
+    }
+
+    [Fact]
+    public void Constructor_WithNullValue_SetsEmptyString()
+    {
+        // Arrange & Act
+        var sut = new SecretFormViewModel(
+            "API_KEY",
+            null!,
+            _clipboardService,
+            _ => { },
+            () => { });
+
+        // Assert
+        sut.Value.ShouldBe(string.Empty);
+    }
+
+    [Fact]
+    public void Value_Setter_InvokesCallback()
+    {
+        // Arrange
+        string? changedValue = null;
+        var sut = new SecretFormViewModel(
+            "API_KEY",
+            "initial",
+            _clipboardService,
+            v => changedValue = v,
+            () => { });
+
+        // Act
+        sut.Value = "new-value";
+
+        // Assert
+        changedValue.ShouldBe("new-value");
+    }
+
+    [Fact]
+    public void Value_Setter_RaisesPropertyChanged()
+    {
+        // Arrange
+        var sut = new SecretFormViewModel(
+            "API_KEY",
+            "initial",
+            _clipboardService,
+            _ => { },
+            () => { });
+
+        var propertyChangedRaised = false;
+        sut.PropertyChanged += (s, e) =>
+        {
+            if (e.PropertyName == nameof(SecretFormViewModel.Value))
+                propertyChangedRaised = true;
+        };
+
+        // Act
+        sut.Value = "new-value";
+
+        // Assert
+        propertyChangedRaised.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void Value_Setter_RaisesDisplayValuePropertyChanged()
+    {
+        // Arrange
+        var sut = new SecretFormViewModel(
+            "API_KEY",
+            "initial",
+            _clipboardService,
+            _ => { },
+            () => { });
+
+        var displayValueChangedRaised = false;
+        sut.PropertyChanged += (s, e) =>
+        {
+            if (e.PropertyName == nameof(SecretFormViewModel.DisplayValue))
+                displayValueChangedRaised = true;
+        };
+
+        // Act
+        sut.Value = "new-value";
+
+        // Assert
+        displayValueChangedRaised.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void IsValueVisible_Toggle_Works()
+    {
+        // Arrange
+        var sut = new SecretFormViewModel(
+            "API_KEY",
+            "secret",
+            _clipboardService,
+            _ => { },
+            () => { });
+
+        // Act & Assert - Initial state
+        sut.IsValueVisible.ShouldBeFalse();
+
+        // Act - Toggle on
+        sut.IsValueVisible = true;
+        sut.IsValueVisible.ShouldBeTrue();
+
+        // Act - Toggle off
+        sut.IsValueVisible = false;
+        sut.IsValueVisible.ShouldBeFalse();
+    }
+
+    [Fact]
+    public void IsValueVisible_RaisesPropertyChanged()
+    {
+        // Arrange
+        var sut = new SecretFormViewModel(
+            "API_KEY",
+            "secret",
+            _clipboardService,
+            _ => { },
+            () => { });
+
+        var propertyChangedRaised = false;
+        sut.PropertyChanged += (s, e) =>
+        {
+            if (e.PropertyName == nameof(SecretFormViewModel.IsValueVisible))
+                propertyChangedRaised = true;
+        };
+
+        // Act
+        sut.IsValueVisible = true;
+
+        // Assert
+        propertyChangedRaised.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void IsValueVisible_RaisesDisplayValueAndVisibilityButtonTextPropertyChanged()
+    {
+        // Arrange
+        var sut = new SecretFormViewModel(
+            "API_KEY",
+            "secret",
+            _clipboardService,
+            _ => { },
+            () => { });
+
+        var displayValueChangedRaised = false;
+        var visibilityButtonTextChangedRaised = false;
+        sut.PropertyChanged += (s, e) =>
+        {
+            if (e.PropertyName == nameof(SecretFormViewModel.DisplayValue))
+                displayValueChangedRaised = true;
+            if (e.PropertyName == nameof(SecretFormViewModel.VisibilityButtonText))
+                visibilityButtonTextChangedRaised = true;
+        };
+
+        // Act
+        sut.IsValueVisible = true;
+
+        // Assert
+        displayValueChangedRaised.ShouldBeTrue();
+        visibilityButtonTextChangedRaised.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void DisplayValue_ShowsMaskedValue_WhenNotVisible()
+    {
+        // Arrange
+        var sut = new SecretFormViewModel(
+            "API_KEY",
+            "secret123",
+            _clipboardService,
+            _ => { },
+            () => { });
+
+        // Act & Assert
+        sut.IsValueVisible.ShouldBeFalse();
+        sut.DisplayValue.ShouldBe("\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022"); // 9 bullet points
+    }
+
+    [Fact]
+    public void DisplayValue_ShowsActualValue_WhenVisible()
+    {
+        // Arrange
+        var sut = new SecretFormViewModel(
+            "API_KEY",
+            "secret123",
+            _clipboardService,
+            _ => { },
+            () => { });
+
+        // Act
+        sut.IsValueVisible = true;
+
+        // Assert
+        sut.DisplayValue.ShouldBe("secret123");
+    }
+
+    [Fact]
+    public void DisplayValue_LimitsMaskedLength_ToTwentyCharacters()
+    {
+        // Arrange
+        var longValue = new string('x', 50);
+        var sut = new SecretFormViewModel(
+            "API_KEY",
+            longValue,
+            _clipboardService,
+            _ => { },
+            () => { });
+
+        // Act & Assert
+        sut.DisplayValue.Length.ShouldBe(20);
+        sut.DisplayValue.ShouldBe(new string('\u2022', 20));
+    }
+
+    [Fact]
+    public void DisplayValue_HandlesEmptyValue()
+    {
+        // Arrange
+        var sut = new SecretFormViewModel(
+            "API_KEY",
+            "",
+            _clipboardService,
+            _ => { },
+            () => { });
+
+        // Act & Assert
+        sut.DisplayValue.ShouldBe("");
+    }
+
+    [Fact]
+    public void VisibilityButtonText_ShowsShow_WhenHidden()
+    {
+        // Arrange
+        var sut = new SecretFormViewModel(
+            "API_KEY",
+            "secret",
+            _clipboardService,
+            _ => { },
+            () => { });
+
+        // Act & Assert
+        sut.VisibilityButtonText.ShouldBe("Show");
+    }
+
+    [Fact]
+    public void VisibilityButtonText_ShowsHide_WhenVisible()
+    {
+        // Arrange
+        var sut = new SecretFormViewModel(
+            "API_KEY",
+            "secret",
+            _clipboardService,
+            _ => { },
+            () => { });
+
+        // Act
+        sut.IsValueVisible = true;
+
+        // Assert
+        sut.VisibilityButtonText.ShouldBe("Hide");
+    }
+
+    [Fact]
+    public void ToggleVisibilityCommand_TogglesVisibility()
+    {
+        // Arrange
+        var sut = new SecretFormViewModel(
+            "API_KEY",
+            "secret",
+            _clipboardService,
+            _ => { },
+            () => { });
+
+        // Act & Assert - Toggle on
+        sut.ToggleVisibilityCommand.Execute(null);
+        sut.IsValueVisible.ShouldBeTrue();
+
+        // Act & Assert - Toggle off
+        sut.ToggleVisibilityCommand.Execute(null);
+        sut.IsValueVisible.ShouldBeFalse();
+    }
+
+    [Fact]
+    public async Task CopyToClipboardCommand_CopiesValueToClipboard()
+    {
+        // Arrange
+        _clipboardService.SetTextAsync(Arg.Any<string>()).Returns(Task.CompletedTask);
+
+        var sut = new SecretFormViewModel(
+            "API_KEY",
+            "secret-to-copy",
+            _clipboardService,
+            _ => { },
+            () => { });
+
+        // Act
+        sut.CopyToClipboardCommand.Execute(null);
+
+        // Small delay to allow async command to complete
+        await Task.Delay(50);
+
+        // Assert
+        await _clipboardService.Received(1).SetTextAsync("secret-to-copy");
+    }
+
+    [Fact]
+    public void DeleteCommand_InvokesCallback()
+    {
+        // Arrange
+        var deleteCalled = false;
+        var sut = new SecretFormViewModel(
+            "API_KEY",
+            "secret",
+            _clipboardService,
+            _ => { },
+            () => deleteCalled = true);
+
+        // Act
+        sut.DeleteCommand.Execute(null);
+
+        // Assert
+        deleteCalled.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void Constructor_ThrowsOnNullKey()
+    {
+        // Act & Assert
+        Should.Throw<ArgumentNullException>(() =>
+            new SecretFormViewModel(null!, "value", _clipboardService, _ => { }, () => { }));
+    }
+
+    [Fact]
+    public void Constructor_ThrowsOnNullClipboardService()
+    {
+        // Act & Assert
+        Should.Throw<ArgumentNullException>(() =>
+            new SecretFormViewModel("key", "value", null!, _ => { }, () => { }));
+    }
+
+    [Fact]
+    public void Constructor_ThrowsOnNullValueChangedCallback()
+    {
+        // Act & Assert
+        Should.Throw<ArgumentNullException>(() =>
+            new SecretFormViewModel("key", "value", _clipboardService, null!, () => { }));
+    }
+
+    [Fact]
+    public void Constructor_ThrowsOnNullDeleteCallback()
+    {
+        // Act & Assert
+        Should.Throw<ArgumentNullException>(() =>
+            new SecretFormViewModel("key", "value", _clipboardService, _ => { }, null!));
+    }
+
+    [Fact]
+    public void Key_IsReadOnly()
+    {
+        // Assert - Verify Key property is get-only
+        var keyProperty = typeof(SecretFormViewModel).GetProperty(nameof(SecretFormViewModel.Key));
+        keyProperty!.CanWrite.ShouldBeFalse();
+    }
+
+    [Fact]
+    public void Value_DoesNotInvokeCallback_WhenValueUnchanged()
+    {
+        // Arrange
+        var callbackCount = 0;
+        var sut = new SecretFormViewModel(
+            "API_KEY",
+            "same-value",
+            _clipboardService,
+            _ => callbackCount++,
+            () => { });
+
+        // Act
+        sut.Value = "same-value"; // Same as initial value
+
+        // Assert
+        callbackCount.ShouldBe(0);
+    }
+}