Add POSSiteSettingService with a protocol for setting POS feature switch through API.

Author: jaclync

Modules/Sources/Networking/Remote/SiteSettingsRemote.swift

@@ -1,5 +1,10 @@
 import Foundation
 
+/// Protocol for SiteSettingsRemote to enable testing.
+public protocol SiteSettingsRemoteProtocol {
+    func setFeature(for siteID: Int64, feature: SiteSettingsFeature, enabled: Bool) async throws -> Bool
+}
+
 /// Features that can be enabled/disabled in core, under WC Settings > Advanced > Features.
 public enum SiteSettingsFeature {
     case pointOfSale

Modules/Sources/Yosemite/Tools/POS/POSSiteSettingService.swift

@@ -0,0 +1,34 @@
+import Foundation
+import Networking
+
+/// Protocol for POS site setting service that manages WooCommerce feature flags.
+public protocol POSSiteSettingServiceProtocol {
+    /// Enables or disables a specific feature in the site WC settings.
+    /// - Parameters:
+    ///   - siteID: The site ID for which to update the feature setting.
+    ///   - feature: The feature to enable or disable.
+    ///   - enabled: Whether the feature should be enabled (true) or disabled (false).
+    /// - Returns: A boolean indicating the updated feature status.
+    /// - Throws: Error if the request fails or the setting cannot be updated.
+    func setFeature(siteID: Int64, feature: SiteSettingsFeature, enabled: Bool) async throws -> Bool
+}
+
+/// Service for managing Point of Sale related site settings.
+public final class POSSiteSettingService: POSSiteSettingServiceProtocol {
+    private let remote: SiteSettingsRemoteProtocol
+
+    public init(credentials: Credentials?) {
+        let network = AlamofireNetwork(credentials: credentials)
+        self.remote = SiteSettingsRemote(network: network)
+    }
+
+    /// Test-friendly initializer that accepts a remote implementation.
+    /// - Parameter remote: The remote service implementation to use for network requests.
+    init(remote: SiteSettingsRemoteProtocol) {
+        self.remote = remote
+    }
+
+    public func setFeature(siteID: Int64, feature: SiteSettingsFeature, enabled: Bool) async throws -> Bool {
+        try await remote.setFeature(for: siteID, feature: feature, enabled: enabled)
+    }
+}

Modules/Tests/YosemiteTests/Mocks/MockSiteSettingsRemote.swift

@@ -0,0 +1,23 @@
+import Networking
+
+final class MockSiteSettingsRemote: SiteSettingsRemoteProtocol {
+    var setFeatureCalled: Bool = false
+    var spySetFeatureSiteID: Int64?
+    var spySetFeatureFeature: SiteSettingsFeature?
+    var spySetFeatureEnabled: Bool?
+    var setFeatureResult: Result<Bool, Error> = .success(true)
+
+    func setFeature(for siteID: Int64, feature: SiteSettingsFeature, enabled: Bool) async throws -> Bool {
+        setFeatureCalled = true
+        spySetFeatureSiteID = siteID
+        spySetFeatureFeature = feature
+        spySetFeatureEnabled = enabled
+
+        switch setFeatureResult {
+        case .success(let result):
+            return result
+        case .failure(let error):
+            throw error
+        }
+    }
+}

Modules/Tests/YosemiteTests/Tools/POS/POSSiteSettingServiceTests.swift

@@ -0,0 +1,60 @@
+import Foundation
+import Testing
+@testable import Yosemite
+@testable import Networking
+
+struct POSSiteSettingServiceTests {
+    private let sut: POSSiteSettingService
+    private let mockRemote: MockSiteSettingsRemote
+    private let sampleSiteID: Int64 = 123
+
+    init() {
+        let mockRemote = MockSiteSettingsRemote()
+        self.mockRemote = mockRemote
+        self.sut = POSSiteSettingService(remote: mockRemote)
+    }
+
+    @Test(arguments: [true, false])
+    func setFeature_calls_remote_with_correct_parameters(featureEnabled: Bool) async throws {
+        // Given
+        let feature = SiteSettingsFeature.pointOfSale
+        mockRemote.setFeatureResult = .success(true)
+
+        // When
+        let result = try await sut.setFeature(siteID: sampleSiteID, feature: feature, enabled: featureEnabled)
+
+        // Then
+        #expect(mockRemote.setFeatureCalled == true)
+        #expect(mockRemote.spySetFeatureSiteID == sampleSiteID)
+        #expect(mockRemote.spySetFeatureFeature == feature)
+        #expect(mockRemote.spySetFeatureEnabled == featureEnabled)
+        #expect(result == true)
+    }
+
+    @Test(arguments: [true, false])
+    func setFeature_returns_false_when_remote_returns_false(remoteFeatureEnabled: Bool) async throws {
+        // Given
+        let feature = SiteSettingsFeature.pointOfSale
+        mockRemote.setFeatureResult = .success(remoteFeatureEnabled)
+
+        // When
+        let result = try await sut.setFeature(siteID: sampleSiteID, feature: feature, enabled: true)
+
+        // Then
+        #expect(result == remoteFeatureEnabled)
+    }
+
+    @Test func setFeature_throws_error_when_remote_throws_error() async throws {
+        // Given
+        let feature = SiteSettingsFeature.pointOfSale
+        let expectedError = SiteSettingsRemoteError.invalidResponse
+        mockRemote.setFeatureResult = .failure(expectedError)
+
+        // When/Then
+        await #expect(performing: {
+            try await sut.setFeature(siteID: sampleSiteID, feature: feature, enabled: true)
+        }, throws: { error in
+            return error as? SiteSettingsRemoteError == expectedError
+        })
+    }
+}