@shaykec/app-agent 1.0.0

package/templates/ios/BookTemplate/BookTemplate.xcodeproj/xcshareddata/xcschemes/BookTemplate.xcscheme

@@ -0,0 +1,116 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "1500"
+   version = "1.7">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES"
+      runPostActionsOnFailure = "NO">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "9164277FD65DAA66B1090F7B"
+               BuildableName = "BookTemplate.app"
+               BlueprintName = "BookTemplate"
+               ReferencedContainer = "container:BookTemplate.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "NO"
+            buildForProfiling = "NO"
+            buildForArchiving = "NO"
+            buildForAnalyzing = "NO">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "3858FEDA604DE168B705AECB"
+               BuildableName = "BookTemplateTests.xctest"
+               BlueprintName = "BookTemplateTests"
+               ReferencedContainer = "container:BookTemplate.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      onlyGenerateCoverageForSpecifiedTargets = "NO">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "9164277FD65DAA66B1090F7B"
+            BuildableName = "BookTemplate.app"
+            BlueprintName = "BookTemplate"
+            ReferencedContainer = "container:BookTemplate.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+      <Testables>
+         <TestableReference
+            skipped = "NO"
+            parallelizable = "NO">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "3858FEDA604DE168B705AECB"
+               BuildableName = "BookTemplateTests.xctest"
+               BlueprintName = "BookTemplateTests"
+               ReferencedContainer = "container:BookTemplate.xcodeproj">
+            </BuildableReference>
+         </TestableReference>
+      </Testables>
+      <CommandLineArguments>
+      </CommandLineArguments>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "9164277FD65DAA66B1090F7B"
+            BuildableName = "BookTemplate.app"
+            BlueprintName = "BookTemplate"
+            ReferencedContainer = "container:BookTemplate.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "9164277FD65DAA66B1090F7B"
+            BuildableName = "BookTemplate.app"
+            BlueprintName = "BookTemplate"
+            ReferencedContainer = "container:BookTemplate.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>

package/templates/ios/BookTemplate/BookTemplateTests/MockDataProviderTests.swift

@@ -0,0 +1,304 @@
+import XCTest
+@testable import BookTemplate
+
+final class MockDataProviderTests: XCTestCase {
+    var sut: MockDataProvider!
+    
+    override func setUp() {
+        super.setUp()
+        sut = MockDataProvider.shared
+        // Initialize providers from seed data if empty
+        if sut.providers.isEmpty {
+            sut.providers = MockDataProvider.seedProviders
+        }
+        // Reset mutable state
+        sut.bookings = []
+        sut.reviews = []
+        sut.favoriteProviderIds = []
+    }
+    
+    override func tearDown() {
+        // Reset mutable state
+        sut.bookings = []
+        sut.reviews = []
+        sut.favoriteProviderIds = []
+        super.tearDown()
+    }
+    
+    // MARK: - Seed Data Tests
+    
+    func testSeedDataNotEmpty() {
+        XCTAssertFalse(MockDataProvider.seedProviders.isEmpty, "Seed providers should not be empty")
+        XCTAssertFalse(MockDataProvider.upcomingBookings.isEmpty, "Upcoming bookings should not be empty")
+        XCTAssertFalse(MockDataProvider.pastBookings.isEmpty, "Past bookings should not be empty")
+    }
+    
+    func testProvidersCanBeSetFromSeedData() {
+        sut.providers = MockDataProvider.seedProviders
+        XCTAssertEqual(sut.providers.count, MockDataProvider.seedProviders.count, "Providers should match seed data count")
+    }
+    
+    func testSeedProvidersHaveUniqueIDs() {
+        let providerIds = Set(MockDataProvider.seedProviders.map { $0.id })
+        XCTAssertEqual(providerIds.count, MockDataProvider.seedProviders.count, "All provider IDs should be unique")
+    }
+    
+    func testSeedProvidersHaveServices() {
+        for provider in MockDataProvider.seedProviders {
+            XCTAssertFalse(provider.services.isEmpty, "Provider \(provider.name) should have at least one service")
+        }
+    }
+    
+    func testSeedProvidersHaveHours() {
+        for provider in MockDataProvider.seedProviders {
+            XCTAssertFalse(provider.hours.isEmpty, "Provider \(provider.name) should have business hours")
+        }
+    }
+    
+    // MARK: - Provider Helper Tests
+    
+    func testProviderById() {
+        guard let firstProvider = MockDataProvider.seedProviders.first else {
+            XCTFail("Should have at least one provider")
+            return
+        }
+        
+        let foundProvider = MockDataProvider.provider(by: firstProvider.id)
+        XCTAssertNotNil(foundProvider, "Should find provider by ID")
+        XCTAssertEqual(foundProvider?.id, firstProvider.id, "Found provider ID should match")
+        
+        let notFound = MockDataProvider.provider(by: "non-existent")
+        XCTAssertNil(notFound, "Should return nil for non-existent ID")
+    }
+    
+    func testProvidersForCategory() {
+        guard let firstProvider = MockDataProvider.seedProviders.first else {
+            XCTFail("Should have at least one provider")
+            return
+        }
+        
+        let categoryProviders = MockDataProvider.providers(for: firstProvider.categoryId)
+        XCTAssertFalse(categoryProviders.isEmpty, "Should have providers for category")
+        XCTAssertTrue(categoryProviders.allSatisfy { $0.categoryId == firstProvider.categoryId }, "All providers should belong to the category")
+    }
+    
+    func testSearchProviders() {
+        guard let firstProvider = MockDataProvider.seedProviders.first else {
+            XCTFail("Should have at least one provider")
+            return
+        }
+        
+        let searchQuery = firstProvider.name.lowercased()
+        let results = MockDataProvider.searchProviders(query: searchQuery)
+        
+        XCTAssertFalse(results.isEmpty, "Search should return results")
+        XCTAssertTrue(results.contains { $0.id == firstProvider.id }, "Results should include the searched provider")
+    }
+    
+    func testSearchProvidersEmptyQuery() {
+        let results = MockDataProvider.searchProviders(query: "")
+        XCTAssertEqual(results.count, MockDataProvider.seedProviders.count, "Empty query should return all providers")
+    }
+    
+    func testSearchProvidersByService() {
+        guard let providerWithService = MockDataProvider.seedProviders.first(where: { !$0.services.isEmpty }) else {
+            XCTFail("Should have at least one provider with services")
+            return
+        }
+        
+        let serviceName = providerWithService.services[0].name.lowercased()
+        let results = MockDataProvider.searchProviders(query: serviceName)
+        
+        XCTAssertFalse(results.isEmpty, "Search by service name should return results")
+        XCTAssertTrue(results.contains { $0.id == providerWithService.id }, "Results should include provider with matching service")
+    }
+    
+    // MARK: - Time Slots Tests
+    
+    func testTimeSlotsForDate() {
+        let date = Date()
+        let timeSlots = MockDataProvider.timeSlots(for: date)
+        
+        XCTAssertFalse(timeSlots.isEmpty, "Should generate time slots for date")
+        XCTAssertTrue(timeSlots.allSatisfy { Calendar.current.isDate($0.date, inSameDayAs: date) }, "All time slots should be for the specified date")
+    }
+    
+    func testTimeSlotsHaveValidTimes() {
+        let date = Date()
+        let timeSlots = MockDataProvider.timeSlots(for: date)
+        
+        let validTimes = ["9:00 AM", "9:30 AM", "10:00 AM", "10:30 AM", "11:00 AM", "11:30 AM",
+                          "12:00 PM", "12:30 PM", "1:00 PM", "1:30 PM", "2:00 PM", "2:30 PM",
+                          "3:00 PM", "3:30 PM", "4:00 PM", "4:30 PM", "5:00 PM", "5:30 PM"]
+        
+        for slot in timeSlots {
+            XCTAssertTrue(validTimes.contains(slot.time), "Time slot should have valid time format")
+        }
+    }
+    
+    // MARK: - Reviews Tests
+    
+    func testReviewsForProvider() {
+        guard let firstProvider = MockDataProvider.seedProviders.first else {
+            XCTFail("Should have at least one provider")
+            return
+        }
+        
+        let reviews = MockDataProvider.reviews(for: firstProvider.id)
+        
+        XCTAssertEqual(reviews.count, 10, "Should return 10 reviews per provider")
+        XCTAssertTrue(reviews.allSatisfy { $0.providerId == firstProvider.id }, "All reviews should be for the specified provider")
+    }
+    
+    func testReviewsHaveValidRatings() {
+        guard let firstProvider = MockDataProvider.seedProviders.first else {
+            XCTFail("Should have at least one provider")
+            return
+        }
+        
+        let reviews = MockDataProvider.reviews(for: firstProvider.id)
+        
+        for review in reviews {
+            XCTAssertGreaterThanOrEqual(review.rating, 1, "Rating should be at least 1")
+            XCTAssertLessThanOrEqual(review.rating, 5, "Rating should be at most 5")
+        }
+    }
+    
+    // MARK: - Bookings Tests
+    
+    func testUpcomingBookings() {
+        let upcoming = MockDataProvider.upcomingBookings
+        
+        XCTAssertFalse(upcoming.isEmpty, "Should have upcoming bookings")
+        for booking in upcoming {
+            XCTAssertTrue(booking.date > Date(), "Upcoming booking date should be in the future")
+            XCTAssertTrue(booking.status == .confirmed || booking.status == .pending, "Upcoming bookings should be confirmed or pending")
+        }
+    }
+    
+    func testPastBookings() {
+        let past = MockDataProvider.pastBookings
+        
+        XCTAssertFalse(past.isEmpty, "Should have past bookings")
+        for booking in past {
+            XCTAssertTrue(booking.date < Date(), "Past booking date should be in the past")
+            XCTAssertEqual(booking.status, .completed, "Past bookings should be completed")
+        }
+    }
+    
+    // MARK: - CRUD Operations Tests
+    
+    func testCreateBooking() {
+        guard let provider = MockDataProvider.seedProviders.first,
+              let service = provider.services.first else {
+            XCTFail("Should have at least one provider and service")
+            return
+        }
+        
+        let initialCount = sut.bookings.count
+        let newBooking = Booking(
+            id: "new-booking",
+            provider: provider,
+            service: service,
+            date: Date().addingTimeInterval(86400),
+            time: "2:00 PM",
+            status: .pending,
+            totalPrice: service.price,
+            createdAt: Date()
+        )
+        
+        sut.bookings.append(newBooking)
+        
+        XCTAssertEqual(sut.bookings.count, initialCount + 1, "Booking count should increase by 1")
+        XCTAssertTrue(sut.bookings.contains { $0.id == "new-booking" }, "New booking should be added")
+    }
+    
+    func testCancelBooking() {
+        guard let provider = MockDataProvider.seedProviders.first,
+              let service = provider.services.first else {
+            XCTFail("Should have at least one provider and service")
+            return
+        }
+        
+        let booking = Booking(
+            id: "cancel-test",
+            provider: provider,
+            service: service,
+            date: Date().addingTimeInterval(86400 * 2),
+            time: "2:00 PM",
+            status: .confirmed,
+            totalPrice: service.price,
+            createdAt: Date()
+        )
+        
+        sut.bookings.append(booking)
+        
+        if let index = sut.bookings.firstIndex(where: { $0.id == "cancel-test" }) {
+            var updatedBooking = sut.bookings[index]
+            updatedBooking.status = .cancelled
+            updatedBooking.cancelledAt = Date()
+            sut.bookings[index] = updatedBooking
+            
+            XCTAssertEqual(sut.bookings[index].status, .cancelled, "Booking status should be cancelled")
+            XCTAssertNotNil(sut.bookings[index].cancelledAt, "Cancelled date should be set")
+        } else {
+            XCTFail("Should find booking to cancel")
+        }
+    }
+    
+    // MARK: - Favorite Tests
+    
+    func testToggleFavorite() {
+        guard let firstProvider = MockDataProvider.seedProviders.first else {
+            XCTFail("Should have at least one provider")
+            return
+        }
+        
+        let providerId = firstProvider.id
+        
+        XCTAssertFalse(sut.favoriteProviderIds.contains(providerId), "Provider should not be favorite initially")
+        
+        sut.favoriteProviderIds.insert(providerId)
+        XCTAssertTrue(sut.favoriteProviderIds.contains(providerId), "Provider should be favorite after adding")
+        
+        sut.favoriteProviderIds.remove(providerId)
+        XCTAssertFalse(sut.favoriteProviderIds.contains(providerId), "Provider should not be favorite after removing")
+    }
+    
+    // MARK: - State Management Tests
+    
+    func testMutableStateCanBeCleared() {
+        // Modify state
+        guard let firstProvider = MockDataProvider.seedProviders.first else {
+            XCTFail("Should have at least one provider")
+            return
+        }
+        
+        sut.favoriteProviderIds.insert(firstProvider.id)
+        sut.bookings.append(Booking(
+            id: "temp-booking",
+            provider: firstProvider,
+            service: firstProvider.services[0],
+            date: Date(),
+            time: "12:00 PM",
+            status: .pending,
+            totalPrice: 100,
+            createdAt: Date()
+        ))
+        
+        let favoriteCount = sut.favoriteProviderIds.count
+        let bookingCount = sut.bookings.count
+        
+        XCTAssertGreaterThan(favoriteCount, 0, "Should have favorites")
+        XCTAssertGreaterThan(bookingCount, 0, "Should have bookings")
+        
+        // Clear state
+        sut.favoriteProviderIds.removeAll()
+        sut.bookings.removeAll()
+        sut.reviews.removeAll()
+        
+        XCTAssertTrue(sut.favoriteProviderIds.isEmpty, "Favorites should be empty")
+        XCTAssertTrue(sut.bookings.isEmpty, "Bookings should be empty")
+        XCTAssertTrue(sut.reviews.isEmpty, "Reviews should be empty")
+    }
+}