android-sdd 1.0.0

package/skills/Testing/Espresso/SKILL.md

@@ -0,0 +1,292 @@
+---
+name: espresso
+description: >
+  Espresso UI testing for Android View-based UI.
+  Load this skill when writing instrumented tests for Views, Fragments,
+  or Activities, using ViewMatchers and ViewActions, testing RecyclerView,
+  or interacting with dialogs and menus.
+---
+
+# Espresso
+
+## Overview
+Espresso is Android's UI testing framework for View-based UI. It synchronizes automatically with the UI thread and AsyncTasks, making tests deterministic. Espresso operates through three components: `onView()` to find views, `ViewActions` to interact, and `ViewAssertions` to verify.
+
+---
+
+## Core Principles
+
+- Espresso **auto-syncs** with the main thread — no `Thread.sleep()` needed
+- Find views with **`ViewMatcher`** — prefer `withId()` and `withContentDescription()`
+- **`IdlingResource`** for custom async operations that Espresso can't detect
+- **Hilt** replaces real dependencies for isolated UI tests
+- Espresso works alongside Compose tests in mixed View/Compose apps
+
+---
+
+## Dependencies
+
+```kotlin
+// build.gradle.kts
+dependencies {
+    androidTestImplementation(libs.espresso.core)
+    androidTestImplementation(libs.espresso.contrib)      // RecyclerView, DrawerLayout
+    androidTestImplementation(libs.espresso.intents)      // intent verification
+    androidTestImplementation(libs.androidx.test.rules)
+    androidTestImplementation(libs.androidx.test.runner)
+}
+```
+
+---
+
+## Basic Test Structure
+
+```kotlin
+// ✅ Standard Espresso test
+@RunWith(AndroidJUnit4::class)
+@HiltAndroidTest
+class UserListActivityTest {
+
+    @get:Rule(order = 0) val hiltRule = HiltAndroidRule(this)
+    @get:Rule(order = 1) val activityRule = ActivityScenarioRule(UserListActivity::class.java)
+
+    @Inject lateinit var fakeRepository: FakeUserRepository
+
+    @Before
+    fun setup() { hiltRule.inject() }
+
+    @Test
+    fun showsUserNameInList() {
+        fakeRepository.emit(listOf(
+            User(id = "1", name = "Ali Rezaei", email = Email("ali@test.com"))
+        ))
+
+        onView(withText("Ali Rezaei")).check(matches(isDisplayed()))
+    }
+
+    @Test
+    fun clickingUserOpensDetail() {
+        fakeRepository.emit(listOf(
+            User(id = "1", name = "Ali Rezaei", email = Email("ali@test.com"))
+        ))
+
+        onView(withText("Ali Rezaei")).perform(click())
+
+        onView(withId(R.id.user_detail_title)).check(matches(isDisplayed()))
+    }
+}
+```
+
+---
+
+## ViewMatchers Reference
+
+```kotlin
+// By ID
+onView(withId(R.id.submit_button))
+
+// By text
+onView(withText("Submit"))
+onView(withText(R.string.submit))
+onView(withText(containsString("ubmit")))   // Hamcrest matcher
+
+// By content description
+onView(withContentDescription("Back"))
+onView(withContentDescription(R.string.back))
+
+// By hint
+onView(withHint("Enter email"))
+
+// By tag
+onView(withTagKey(R.id.my_tag))
+onView(withTagValue(equalTo("my_tag_value")))
+
+// By type
+onView(isAssignableFrom(EditText::class.java))
+
+// Combining matchers
+onView(allOf(withId(R.id.name_field), isDisplayed()))
+onView(allOf(withText("Ali"), withParent(withId(R.id.user_card))))
+```
+
+---
+
+## ViewActions
+
+```kotlin
+val view = onView(withId(R.id.my_view))
+
+// Click
+view.perform(click())
+view.perform(longClick())
+view.perform(doubleClick())
+
+// Text input
+view.perform(typeText("Hello"))
+view.perform(clearText())
+view.perform(replaceText("New text"))
+
+// Keyboard
+view.perform(pressImeActionButton())
+view.perform(pressBack())
+view.perform(closeSoftKeyboard())
+
+// Scroll
+view.perform(scrollTo())
+
+// Swipe
+view.perform(swipeLeft())
+view.perform(swipeRight())
+view.perform(swipeUp())
+view.perform(swipeDown())
+```
+
+---
+
+## ViewAssertions
+
+```kotlin
+val view = onView(withId(R.id.result_text))
+
+// Visibility
+view.check(matches(isDisplayed()))
+view.check(matches(not(isDisplayed())))
+view.check(matches(withEffectiveVisibility(Visibility.VISIBLE)))
+
+// State
+view.check(matches(isEnabled()))
+view.check(matches(not(isEnabled())))
+view.check(matches(isChecked()))
+view.check(matches(isFocused()))
+
+// Content
+view.check(matches(withText("Expected")))
+view.check(matches(withText(containsString("partial"))))
+view.check(matches(withHint("placeholder")))
+
+// Existence
+view.check(matches(isDisplayed()))
+view.check(doesNotExist())
+```
+
+---
+
+## RecyclerView
+
+```kotlin
+// ✅ Scroll to position
+onView(withId(R.id.recycler_view))
+    .perform(RecyclerViewActions.scrollToPosition<RecyclerView.ViewHolder>(10))
+
+// ✅ Click item at position
+onView(withId(R.id.recycler_view))
+    .perform(RecyclerViewActions.actionOnItemAtPosition<RecyclerView.ViewHolder>(0, click()))
+
+// ✅ Click item matching a matcher
+onView(withId(R.id.recycler_view))
+    .perform(RecyclerViewActions.actionOnItem<RecyclerView.ViewHolder>(
+        hasDescendant(withText("Ali Rezaei")),
+        click()
+    ))
+
+// ✅ Assert on item at position
+onView(withId(R.id.recycler_view))
+    .check(RecyclerViewAssertions.withItemCount(5))
+```
+
+---
+
+## Intent Verification (Espresso Intents)
+
+```kotlin
+// ✅ Verify outgoing intents
+@get:Rule
+val intentsRule = IntentsRule()
+
+@Test
+fun clickShareOpensShareSheet() {
+    onView(withId(R.id.share_button)).perform(click())
+
+    intended(allOf(
+        hasAction(Intent.ACTION_SEND),
+        hasType("text/plain")
+    ))
+}
+
+// ✅ Stub incoming intents
+intending(hasComponent(CameraActivity::class.java.name))
+    .respondWith(ActivityResult(Activity.RESULT_OK, Intent().apply {
+        putExtra("photo_uri", "content://mock_uri")
+    }))
+```
+
+---
+
+## IdlingResource for Custom Async
+
+```kotlin
+// ✅ Register IdlingResource for operations Espresso can't detect
+class NetworkIdlingResource : IdlingResource {
+    private var callback: IdlingResource.ResourceCallback? = null
+    private var isIdle = true
+
+    override fun getName() = "NetworkIdlingResource"
+    override fun isIdleNow() = isIdle
+    override fun registerIdleTransitionCallback(callback: IdlingResource.ResourceCallback) {
+        this.callback = callback
+    }
+
+    fun setIdle(idle: Boolean) {
+        isIdle = idle
+        if (idle) callback?.onTransitionToIdle()
+    }
+}
+
+// Register in test
+val idlingResource = NetworkIdlingResource()
+IdlingRegistry.getInstance().register(idlingResource)
+
+// Unregister in @After
+IdlingRegistry.getInstance().unregister(idlingResource)
+```
+
+---
+
+## Mixed Compose + View Testing
+
+```kotlin
+// ✅ Espresso and Compose rules can coexist
+@RunWith(AndroidJUnit4::class)
+class MixedUiTest {
+
+    @get:Rule val activityRule = ActivityScenarioRule(MainActivity::class.java)
+    @get:Rule val composeRule = createAndroidComposeRule<MainActivity>()
+
+    @Test
+    fun testMixedUI() {
+        // Espresso for View
+        onView(withId(R.id.toolbar_title)).check(matches(withText("Home")))
+
+        // Compose for Compose content
+        composeRule.onNodeWithTag("compose_content").assertIsDisplayed()
+    }
+}
+```
+
+---
+
+## Anti-Patterns
+
+- `Thread.sleep()` for synchronization — use `IdlingResource` or rely on Espresso auto-sync
+- Testing with real network — fake the data layer via Hilt
+- `onView(withIndex(...))` for RecyclerView items — use `RecyclerViewActions` instead
+- Not calling `closeSoftKeyboard()` when keyboard may obscure views — causes view not found errors
+- Sharing mutable test state between test methods — each test must be independent
+
+---
+
+## Related Skills
+- `ui-testing` — broader UI test setup and Hilt configuration
+- `compose-testing` — Compose-specific test APIs
+- `integration-testing` — testing below the UI layer
+- `hilt` — replacing dependencies in tests

package/skills/Testing/Fake Data/SKILL.md

@@ -0,0 +1,245 @@
+---
+name: fake-data
+description: >
+  Fake data and test factory patterns for Android tests.
+  Load this skill when building fake repositories, creating test data
+  with factory functions, designing object mothers, or maintaining
+  consistent test data across a test suite.
+---
+
+# Fake Data
+
+## Overview
+Fake data refers to two related concerns: fake implementations of interfaces (replacing real dependencies in tests) and test data factories (creating domain/entity objects with sensible defaults). Together they make tests readable, maintainable, and independent of production data.
+
+---
+
+## Core Principles
+
+- **Fakes are real implementations** — they implement the same interface, just in memory
+- **Test data factories** provide defaults — only specify what's relevant to the test
+- **Centralize test data** — one place to update when models change
+- **Named factory variants** for common test scenarios (e.g., `adminUser()`, `suspendedUser()`)
+- **Deterministic** — fake data never uses random values unless explicitly testing randomness
+
+---
+
+## Fake Repository
+
+```kotlin
+// ✅ Fake repository — in-memory implementation of the real interface
+class FakeUserRepository @Inject constructor() : UserRepository {
+
+    private val _users = MutableStateFlow<List<User>>(emptyList())
+    var shouldFail = false
+    var failureMessage = "Fake failure"
+
+    // ── Reactive ───────────────────────────────────────────────
+    override fun observeUsers(): Flow<List<User>> = _users.asStateFlow()
+
+    override fun observeUser(id: String): Flow<User?> =
+        _users.map { users -> users.find { it.id == id } }
+
+    // ── Suspend ────────────────────────────────────────────────
+    override suspend fun getUser(id: String): Result<User> {
+        if (shouldFail) return Result.failure(Exception(failureMessage))
+        return _users.value.find { it.id == id }
+            ?.let { Result.success(it) }
+            ?: Result.failure(Exception("User not found: $id"))
+    }
+
+    override suspend fun getUsers(): Result<List<User>> {
+        if (shouldFail) return Result.failure(Exception(failureMessage))
+        return Result.success(_users.value)
+    }
+
+    override suspend fun createUser(user: User): Result<User> {
+        if (shouldFail) return Result.failure(Exception(failureMessage))
+        _users.update { it + user }
+        return Result.success(user)
+    }
+
+    override suspend fun updateUser(user: User): Result<Unit> {
+        if (shouldFail) return Result.failure(Exception(failureMessage))
+        _users.update { users -> users.map { if (it.id == user.id) user else it } }
+        return Result.success(Unit)
+    }
+
+    override suspend fun deleteUser(id: String): Result<Unit> {
+        if (shouldFail) return Result.failure(Exception(failureMessage))
+        _users.update { users -> users.filter { it.id != id } }
+        return Result.success(Unit)
+    }
+
+    // ── Test helpers ───────────────────────────────────────────
+    fun emit(users: List<User>) { _users.value = users }
+    fun emitOne(user: User) { _users.value = listOf(user) }
+    fun clear() { _users.value = emptyList() }
+    fun addUser(user: User) { _users.update { it + user } }
+}
+```
+
+---
+
+## Domain Model Factory
+
+```kotlin
+// ✅ Factory object with defaults — only override what matters
+object UserFactory {
+
+    fun create(
+        id: String = "user-1",
+        name: String = "Ali Rezaei",
+        email: String = "ali@test.com",
+        role: UserRole = UserRole.MEMBER,
+        status: UserStatus = UserStatus.ACTIVE,
+        createdAt: Instant = Instant.parse("2024-01-01T00:00:00Z")
+    ): User = User(
+        id = id,
+        name = name,
+        email = Email(email),
+        role = role,
+        status = status,
+        createdAt = createdAt
+    )
+
+    // ✅ Named variants for common scenarios
+    fun admin() = create(id = "admin-1", name = "Admin User", role = UserRole.ADMIN)
+    fun guest() = create(id = "guest-1", name = "Guest User", role = UserRole.GUEST)
+    fun suspended() = create(id = "suspended-1", status = UserStatus.SUSPENDED)
+
+    // ✅ List factory
+    fun list(count: Int = 3): List<User> = (1..count).map {
+        create(id = "user-$it", name = "User $it", email = "user$it@test.com")
+    }
+}
+
+// ✅ Usage in tests — only specify what matters
+val user = UserFactory.create(name = "Custom Name")
+val admin = UserFactory.admin()
+val users = UserFactory.list(5)
+```
+
+---
+
+## Entity Factory (for Room Tests)
+
+```kotlin
+// ✅ Separate factory for DB entities
+object UserEntityFactory {
+
+    fun create(
+        id: String = "user-1",
+        name: String = "Ali Rezaei",
+        email: String = "ali@test.com",
+        role: String = "member",
+        isActive: Boolean = true,
+        createdAt: Long = 1704067200000L,
+        updatedAt: Long = 1704067200000L
+    ): UserEntity = UserEntity(
+        id = id, name = name, email = email,
+        role = role, isActive = isActive,
+        createdAt = createdAt, updatedAt = updatedAt
+    )
+
+    fun list(count: Int = 3): List<UserEntity> = (1..count).map {
+        create(id = "user-$it", name = "User $it", email = "user$it@test.com")
+    }
+}
+```
+
+---
+
+## DTO Factory (for API Tests)
+
+```kotlin
+// ✅ Factory for API response DTOs
+object UserDtoFactory {
+
+    fun create(
+        id: String = "user-1",
+        name: String = "Ali Rezaei",
+        email: String = "ali@test.com",
+        role: String = "member"
+    ): UserDto = UserDto(id = id, name = name, email = email, role = role)
+
+    fun list(count: Int = 3): List<UserDto> = (1..count).map {
+        create(id = "user-$it", name = "User $it", email = "user$it@test.com")
+    }
+}
+```
+
+---
+
+## UiState Factory
+
+```kotlin
+// ✅ Factories for UI state — useful for Compose Preview and tests
+object UserListUiStateFactory {
+
+    fun loading() = UserListUiState.Loading
+
+    fun success(
+        users: List<User> = UserFactory.list()
+    ) = UserListUiState.Success(users)
+
+    fun error(
+        message: String = "Something went wrong"
+    ) = UserListUiState.Error(message)
+
+    fun empty() = UserListUiState.Success(emptyList())
+}
+```
+
+---
+
+## Fake Dispatcher
+
+```kotlin
+// ✅ Fake dispatcher for controlling coroutine execution in tests
+class FakeDispatcherProvider : DispatcherProvider {
+    override val main: CoroutineDispatcher = UnconfinedTestDispatcher()
+    override val io: CoroutineDispatcher = UnconfinedTestDispatcher()
+    override val default: CoroutineDispatcher = UnconfinedTestDispatcher()
+}
+```
+
+---
+
+## Test Fixtures in androidTest
+
+```kotlin
+// ✅ Shared test fixtures in :core:testing module
+// core/testing/src/main/kotlin/com/example/testing/
+
+// Factories
+UserFactory.kt
+OrderFactory.kt
+ProductFactory.kt
+
+// Fakes
+FakeUserRepository.kt
+FakeOrderRepository.kt
+FakeNetworkMonitor.kt
+
+// Rules
+MainDispatcherRule.kt
+```
+
+---
+
+## Anti-Patterns
+
+- Hardcoding IDs like `"1"` scattered across all tests — use factory defaults
+- Creating full objects in every test — use factories with defaults, override only what matters
+- Mutable shared state in fakes — each test should reset; use `@BeforeEach` or `clear()`
+- Fake that diverges from real implementation — a fake that ignores method contracts is useless
+- Using `Random.nextInt()` in factories — non-deterministic; use fixed values
+
+---
+
+## Related Skills
+- `unit-testing` — factories used in unit tests
+- `integration-testing` — fakes used in integration tests
+- `mocking` — when to use fakes vs MockK mocks
+- `domain-modeling` — domain models the factories create