revenuecat/ai-toolkit

rc-testing

Use this skill when testing a RevenueCat Android integration.

소스 보기

사용 방법

  1. 설치 명령을 복사하고 자신의 에이전트 환경에 설치하기 전에 소스 패키지를 확인하세요.
  2. 필요한 도구, 인증 정보, 지원 환경은 원본 문서에서 확인하세요.
  3. 입력과 원하는 산출물을 설명하고 출처와 결과를 대조하세요.
npx skills add https://github.com/revenuecat/ai-toolkit --skill rc-testing

시작 전 확인

  • 설치에는 모델 구독, API 한도, 파일 접근 권한이 포함되지 않습니다.
  • 별점 수와 설치 수는 활동 지표이며 독립적인 품질·보안 검증이 아닙니다.
원본 Skill 문서

원본 저장소의 제목, 예시, 코드, 표, 링크, 이미지를 유지해 표시합니다.

Testing RevenueCat on Android

Use this skill to stand up a fast test loop for a RevenueCat Android integration. The Test Store replaces the Google Play sandbox for most work, a BillingService interface makes Purchases mockable, and a small GitHub Actions job runs unit tests on every push.

Full source: see the full chapter on revenuecat.com.


Phase 1: Discovery

Before changing anything, learn what already exists. Answer each question with a file or a "no".

CheckWhere to lookWhat you want
Test API key configured?app/build.gradle.kts, local.properties, envA test_... value bound to BuildConfig.RC_API_KEY in debug
Release key separate?build.gradle.kts release blockA goog_... key, never test_...
Purchases wrapped?app/src/main/java/**/*Billing*.ktAn interface that hides Purchases.sharedInstance
CI present?.github/workflows/*.ymlA job running ./gradlew testDebugUnitTest
Secret wired?GitHub repo settings, workflow env:RC_TEST_STORE_KEY referenced from secrets
Test library?app/build.gradle.kts dependenciesio.mockk:mockk and kotlinx-coroutines-test

If the project has none of these, start from scratch in Phase 3. If some exist, only fill the gaps.


Phase 2: Plan

Pick the test path per scenario. The Test Store is the default; fall back to Google Play sandbox only when you need store behavior the Test Store does not simulate.

ScenarioUse
Success, failure, cancel pathsTest Store
Unit tests of ViewModelsmockk against BillingService
CI on every pushTest Store + unit tests
Subscription renewal cyclesGoogle Play Sandbox
Pending purchase (parental approval)Google Play Sandbox
Full end-to-end paymentGoogle Play Sandbox

Write the plan as a short checklist in tasks/todo.md before coding. If the app ships subscriptions, keep one Sandbox pass in the pre-ship checklist even if the Test Store covers daily iteration.


Phase 3: Execute

Step 1: Generate the test API key

In the RevenueCat dashboard, open your app, go to Apps & providers, then Create Test Store. Copy the test_... key. Do not commit it. Put it in local.properties or a CI secret.

Step 2: Wire the key into debug builds

kotlin
// build.gradle.kts
android {
    buildTypes {
        debug {
            buildConfigField("String", "RC_API_KEY", "\"test_YOUR_KEY\"")
        }
        release {
            buildConfigField("String", "RC_API_KEY", "\"goog_YOUR_KEY\"")
        }
    }
}

For CI, read from env so the key never lands in git:

kotlin
// build.gradle.kts
val testKey = System.getenv("RC_TEST_STORE_KEY") ?: "test_placeholder"
buildConfigField("String", "RC_API_KEY", "\"$testKey\"")

Step 3: Configure Purchases with the build config key

kotlin
class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        if (BuildConfig.DEBUG) Purchases.logLevel = LogLevel.DEBUG
        Purchases.configure(
            PurchasesConfiguration.Builder(this, BuildConfig.RC_API_KEY).build()
        )
    }
}

Step 4: Trigger the Test Store dialog

Run the app in debug and call awaitPurchase() from your paywall. A dialog appears with Success, Fail, and Cancel options. Each choice resolves the same way production would: Success returns a PurchaseResult with active entitlements, Fail throws PurchasesTransactionException with a payment error, Cancel throws with userCancelled = true. Walk every branch of your error handling to verify UI states.

Step 5: Wrap Purchases in a BillingService

The Purchases singleton is not mockable. A thin interface lets you inject a fake in tests and keeps ViewModels free of SDK types.

kotlin
interface BillingService {
    suspend fun getOfferings(): Offerings
    suspend fun purchase(activity: Activity, pkg: Package): CustomerInfo
    suspend fun getCustomerInfo(): CustomerInfo
}
kotlin
class RevenueCatBillingService : BillingService {
    override suspend fun getOfferings() =
        Purchases.sharedInstance.awaitOfferings()

    override suspend fun purchase(activity: Activity, pkg: Package): CustomerInfo =
        Purchases.sharedInstance.awaitPurchase(
            PurchaseParams.Builder(activity, pkg).build()
        ).customerInfo

    override suspend fun getCustomerInfo() =
        Purchases.sharedInstance.awaitCustomerInfo()
}

Step 6: Write mockk unit tests

kotlin
class PaywallViewModelTest {
    private val billing = mockk<BillingService>()
    private val viewModel = PaywallViewModel(billing)

    @Test
    fun `purchase success grants access`() = runTest {
        val info = mockk<CustomerInfo> {
            every { entitlements["pro_access"]?.isActive } returns true
        }
        coEvery { billing.purchase(any(), any()) } returns info
        viewModel.purchase(mockActivity, mockPackage)
        assertTrue(viewModel.state.value is PaywallState.Success)
    }
}

Add one test per branch: success grants access, failure shows error, cancel stays idle.

Step 7: Add a minimal GitHub Actions job

yaml
# .github/workflows/test.yml
name: test
on: [push, pull_request]
jobs:
  unit:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with:
          distribution: temurin
          java-version: 17
      - name: Run tests
        env:
          RC_TEST_STORE_KEY: ${{ secrets.RC_TEST_STORE_KEY }}
        run: ./gradlew testDebugUnitTest

Store the test_... key as the RC_TEST_STORE_KEY repository secret. The job runs without a device or a Google account.


Verification

After each purchase, open the RevenueCat dashboard, go to Customers, pick the user, and confirm the purchase, the entitlement, and the CustomerInfo JSON. The Events tab shows webhooks fired for the test purchase.

Pre-Ship Checklist

  • [ ] Purchases.logLevel = LogLevel.DEBUG gated on BuildConfig.DEBUG
  • [ ] Release build uses the goog_ key, not the test_ key
  • [ ] test_ key is not committed (env var or local.properties)
  • [ ] Success, failure, and cancel paths exercised through the Test Store dialog
  • [ ] At least one end-to-end flow verified in Google Play Sandbox
  • [ ] Webhook endpoint receives events for sandbox purchases

References

관련 작업

같은 저장소의 Skills

더 많은 Skills

모든 Skills
revenuecat
커뮤니티

create-revenuecat-project

Set up a complete RevenueCat project from scratch — creates apps, products, entitlements, offerings, and packages in the correct order. Use when the user wants to create a new RevenueCat project, configure in-app purchases, set up subscriptions or monetization, or bootstrap IAP infrastructure for iOS, Android, or Web.

1시간 설치 수
2
GitHub Stars
79
업데이트
11월 17일
revenuecat
커뮤니티

rc-cancellations-pauses-winback

Use this skill when surfacing cancellation, pause, and winback state on Android with RevenueCat. Covers reading unsubscribeDetectedAt, billingIssueDetectedAt, pause state and resume date via SubscriptionInfo.autoResumeDate, showManageSubscriptions for the deep link, and the SUBSCRIPTIONPAUSED webhook.

1시간 설치 수
2
GitHub Stars
79
업데이트
11월 17일
revenuecat
커뮤니티

rc-configuring-the-sdk

Use this skill when adding and configuring the RevenueCat Android SDK (purchases-android, artifact com.revenuecat.purchases:purchases) in an app. Covers the Gradle dependency, Purchases.configure with PurchasesConfiguration, initial app user id strategy, and log level.

1시간 설치 수
2
GitHub Stars
79
업데이트
11월 17일
revenuecat
커뮤니티

rc-plan-changes

Use this skill when implementing subscription upgrades, downgrades, and plan switches via RevenueCat on Android. Covers StoreReplacementMode, picking a replacement mode, and letting the SDK manage linkedPurchaseToken chaining.

1시간 설치 수
2
GitHub Stars
79
업데이트
11월 17일