Adapter & Factory: Cero Lock-in de SDK y Tests 10× Más Rápidos

1
// Lógica de negocio acoplada directamente a Firebase
2
class EventTracker(private val firebase: FirebaseAnalytics) {
3

4
    fun trackPurchase(productId: String, price: Double) {
5
        val bundle = Bundle().apply {
6
            putString("product_id", productId)
7
            putDouble("price", price)
8
        }
9
        firebase.logEvent("purchase", bundle)
10
    }
11
}

1
// Paso 1: Define TU interfaz — el contrato del que depende tu código
2
interface AnalyticsTracker {
3
    fun track(event: String, params: Map<String, Any> = emptyMap())
4
    fun setUserId(id: String)
5
    fun reset()
6
}

1
// Paso 2: Firebase Adapter — envuelve el SDK
2
class FirebaseAnalyticsAdapter(
3
    private val firebase: FirebaseAnalytics
4
) : AnalyticsTracker {
5

6
    override fun track(event: String, params: Map<String, Any>) {
7
        val bundle = Bundle().apply {
8
            params.forEach { (k, v) -> putString(k, v.toString()) }
9
        }
10
        firebase.logEvent(event, bundle)
11
    }
12

13
    override fun setUserId(id: String) = firebase.setUserId(id)
14
    override fun reset() = firebase.setUserId(null)
15
}

1
// Paso 3: Amplitude Adapter — misma interfaz, SDK diferente
2
class AmplitudeAdapter(
3
    private val amplitude: Amplitude
4
) : AnalyticsTracker {
5

6
    override fun track(event: String, params: Map<String, Any>) {
7
        amplitude.track(event, params)
8
    }
9

10
    override fun setUserId(id: String) = amplitude.setUserId(id)
11
    override fun reset() = amplitude.reset()
12
}

1
// La lógica de negocio nunca cambia — solo inyecta el adapter correcto
2
class PurchaseUseCase(private val tracker: AnalyticsTracker) {
3

4
    suspend fun purchase(item: CartItem, userId: String): Result<Receipt> {
5
        // ... lógica de pago ...
6
        tracker.track("purchase", mapOf(
7
            "product_id" to item.id,
8
            "price" to item.price
9
        ))
10
        return Result.success(receipt)
11
    }
12
}

1
// Envía eventos a múltiples SDKs simultáneamente
2
class CompositeAnalyticsTracker(
3
    private val trackers: List<AnalyticsTracker>
4
) : AnalyticsTracker {
5

6
    override fun track(event: String, params: Map<String, Any>) {
7
        trackers.forEach { it.track(event, params) }
8
    }
9

10
    override fun setUserId(id: String) = trackers.forEach { it.setUserId(id) }
11
    override fun reset() = trackers.forEach { it.reset() }
12
}
13

14
// Uso
15
val tracker = CompositeAnalyticsTracker(listOf(
16
    FirebaseAnalyticsAdapter(firebase),
17
    AmplitudeAdapter(amplitude),
18
))

1
class FakeAnalyticsTracker : AnalyticsTracker {
2
    val events = mutableListOf<Pair<String, Map<String, Any>>>()
3

4
    override fun track(event: String, params: Map<String, Any>) {
5
        events += event to params
6
    }
7

8
    override fun setUserId(id: String) {}
9
    override fun reset() { events.clear() }
10
}
11

12
@Test
13
fun `purchase registra evento de analíticas`() = runTest {
14
    val fakeTracker = FakeAnalyticsTracker()
15
    val useCase = PurchaseUseCase(tracker = fakeTracker)
16

17
    useCase.purchase(CartItem(id = "item_1", price = 29.99), userId = "user_1")
18

19
    assertThat(fakeTracker.events).hasSize(1)
20
    assertThat(fakeTracker.events.first().first).isEqualTo("purchase")
21
}

1
// Imposible de testear — red real, base de datos real
2
class UserViewModel : ViewModel() {
3
    // La construcción ocurre dentro de la clase — no hay forma de inyectar fakes
4
    private val api = RetrofitFactory.create(UserApi::class.java)
5
    private val dao = AppDatabase.getInstance(context).userDao()
6
    private val repo = UserRepositoryImpl(api, dao)
7
}

1
// La interfaz — de lo que dependen quienes llaman
2
interface UserRepository {
3
    suspend fun getUser(id: String): Result<User>
4
    suspend fun saveUser(user: User): Result<Unit>
5
    fun observeUser(id: String): Flow<User?>
6
}

1
// Implementación de producción
2
class UserRepositoryImpl(
3
    private val api: UserApi,
4
    private val dao: UserDao,
5
    private val dispatcher: CoroutineDispatcher = Dispatchers.IO
6
) : UserRepository {
7
    override suspend fun getUser(id: String) = withContext(dispatcher) {
8
        runCatching { dao.getUser(id) ?: api.getUser(id).also { dao.upsert(it) } }
9
    }
10
    override suspend fun saveUser(user: User) = withContext(dispatcher) {
11
        runCatching { dao.upsert(user) }
12
    }
13
    override fun observeUser(id: String): Flow<User?> = dao.observeUser(id)
14
}

1
// Fake para tests — en memoria, instantáneo, determinístico
2
class FakeUserRepository : UserRepository {
3
    private val store = mutableMapOf<String, User>()
4
    private val updates = MutableStateFlow<User?>(null)
5

6
    fun seed(user: User) {
7
        store[user.id] = user
8
        updates.value = user
9
    }
10

11
    override suspend fun getUser(id: String) =
12
        store[id]?.let { Result.success(it) } ?: Result.failure(NoSuchElementException(id))
13

14
    override suspend fun saveUser(user: User): Result<Unit> {
15
        store[user.id] = user
16
        updates.value = user
17
        return Result.success(Unit)
18
    }
19

20
    override fun observeUser(id: String): Flow<User?> =
21
        updates.filterNotNull().filter { it.id == id }
22
}

1
// Módulo Hilt conecta la implementación correcta por entorno
2
@Module
3
@InstallIn(SingletonComponent::class)
4
abstract class RepositoryModule {
5

6
    @Binds
7
    @Singleton
8
    abstract fun bindUserRepository(impl: UserRepositoryImpl): UserRepository
9
}
10

11
// Módulo de test lo sobreescribe
12
@TestInstallIn(
13
    components = [SingletonComponent::class],
14
    replaces = [RepositoryModule::class]
15
)
16
@Module
17
abstract class FakeRepositoryModule {
18

19
    @Binds
20
    @Singleton
21
    abstract fun bindUserRepository(fake: FakeUserRepository): UserRepository
22
}

1
// Factory simple cuando Hilt es exagerado
2
object RepositoryFactory {
3

4
    fun createUserRepository(context: Context): UserRepository =
5
        if (BuildConfig.DEBUG && isRunningTests()) {
6
            FakeUserRepository()
7
        } else {
8
            UserRepositoryImpl(
9
                api = RetrofitFactory.create(UserApi::class.java),
10
                dao = AppDatabase.getInstance(context).userDao()
11
            )
12
        }
13
}

1
// Factory crea el Adapter correcto para el entorno
2
object AnalyticsFactory {
3

4
    fun create(context: Context): AnalyticsTracker =
5
        when {
6
            BuildConfig.DEBUG -> NoOpAnalyticsTracker()     // Sin eventos en debug
7
            isQABuild()       -> LoggingAnalyticsTracker()  // Loguea en consola
8
            else -> CompositeAnalyticsTracker(listOf(
9
                FirebaseAnalyticsAdapter(FirebaseAnalytics.getInstance(context)),
10
                AmplitudeAdapter(Amplitude.getInstance().also {
11
                    it.initialize(context, BuildConfig.AMPLITUDE_KEY)
12
                })
13
            ))
14
        }
15
}