> ## Documentation Index
> Fetch the complete documentation index at: https://e2e.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# कंटीन्यूअस इंटीग्रेशन

> e2e को GitHub Actions, Vercel डिप्लॉयमेंट, GitLab CI/CD, Expo Workflows, Bitrise, Codemagic, Norrix या Node चलाने वाली किसी भी CI सेवा पर चलाएँ।

e2e हर उस CI सेवा पर चलता है जो Node 24.8 या उसके बाद का वर्ज़न (Node 22 पर
22.22.3 या बाद का) चला सके, या वेब टेस्ट के लिए [Bun](https://e2e.com/docs/hi/reference/cli#bun) 1.4.3
या बाद का वर्ज़न। हर जॉब डिपेंडेंसी इंस्टॉल करता है, ऐप या कोई डिवाइस शुरू करता है,
टेस्ट चलाता है, और `.e2e/` अपलोड करता है।

## अपनी CI सेवा चुनें

<CardGroup cols={2}>
  <Card title="GitHub Actions" icon="/images/integrations/github-actions.svg" href="/ci/github-actions">
    वेब और मोबाइल वर्कफ़्लो। नतीजों को पुल रिक्वेस्ट कमेंट के रूप में पोस्ट करें।
  </Card>
  <Card title="Vercel Previews" icon="/images/integrations/vercel.svg" href="/ci/vercel-previews">
    हर डिप्लॉयमेंट को टेस्ट करें और टेस्ट पास होने तक प्रोडक्शन रिलीज़ रोककर रखें।
  </Card>
  <Card title="GitLab CI/CD" icon="/images/integrations/gitlab.svg" href="/ci/gitlab">
    वेब और मोबाइल जॉब। नतीजों को मर्ज रिक्वेस्ट में दिखाएँ।
  </Card>
  <Card title="Expo Workflows" icon="/images/integrations/expo.svg" href="/ci/eas-workflows">
    Expo Build से Expo ऐप बिल्ड करें, फिर उस पर iOS और Android टेस्ट चलाएँ।
  </Card>
  <Card title="Bitrise" icon="/images/integrations/bitrise.svg" href="/ci/bitrise">
    सिम्युलेटर और एम्युलेटर के लिए Bitrise के चरणों वाले iOS और Android वर्कफ़्लो।
  </Card>
  <Card title="Codemagic" icon="/images/integrations/codemagic.svg" href="/ci/codemagic">
    Mac mini और Linux इंस्टेंस पर iOS और Android वर्कफ़्लो।
  </Card>
  <Card title="Norrix" icon="/images/integrations/norrix.png" href="/ci/norrix">
    Norrix से NativeScript ऐप बिल्ड करें, फिर उसका सूट Norrix सिम्युलेटर या एम्युलेटर पर चलाएँ।
  </Card>
</CardGroup>

किसी दूसरी CI सेवा के लिए [GitHub Actions](https://e2e.com/docs/hi/ci/github-actions) वाला वर्कफ़्लो
कॉपी करें। किसी होस्टेड सेवा से ब्राउज़र या डिवाइस लीज़ पर लेने के लिए
[होस्टेड ब्राउज़र और डिवाइस](https://e2e.com/docs/hi/integrations) देखें।

## रिपोर्ट अपलोड करें

हर जॉब के अंत में `.e2e/` अपलोड करें, तब भी जब कोई टेस्ट विफल हो। इसमें ये होते हैं:

| पाथ | इसमें क्या होता है |
| --- | --- |
| `report.json` | रन रिपोर्ट, हर उस रन से जो अपने टेस्ट तक पहुँचता है |
| `junit.xml` | `junit` रिपोर्टर (`--reporter list,junit`) के साथ: नतीजे, वे टेस्ट जिन्हें किसी [टेस्ट फ़िल्टर](https://e2e.com/docs/hi/filters) ने छोड़ दिया (skipped के रूप में), और `run` सूट में `APP_UNREACHABLE` जैसी स्टार्टअप विफलताएँ |
| `results/` | हर टेस्ट के ट्रेस पेज, स्क्रीनशॉट और स्क्रीन डंप। `--video` के साथ, हर उस टारगेट का वीडियो भी जिसका इंजन रिकॉर्ड कर सकता है |

अपनी CI सेवा के टेस्ट-रिपोर्ट इंटीग्रेशन को `.e2e/junit.xml` पर पॉइंट करें।
GitLab पर `junit.xml` हर विफलता के स्क्रीनशॉट का लिंक भी रखता है, इसलिए वह स्क्रीनशॉट टेस्ट रिपोर्ट में दिखता है।
[`output`](https://e2e.com/docs/hi/reference/config#output) विकल्प से `.e2e/` की जगह बदली जा सकती है।

## मॉडल क्रेडेंशियल

जॉब को वह क्रेडेंशियल दें जो आपके प्रोवाइडर को चाहिए, जैसे
`AI_GATEWAY_API_KEY` ([मॉडल](https://e2e.com/docs/hi/models) देखें)। जो टेस्ट कभी `agent` इस्तेमाल
नहीं करते, उन्हें किसी क्रेडेंशियल की ज़रूरत नहीं होती।

<Warning>
जिस भी जॉब के पास कुंजी होती है, वह उसे अपने चलाए हर कोड को दे देता है: टेस्ट,
कॉन्फ़िग और डिपेंडेंसी। कुंजी सिर्फ़ उन ब्रांच के बिल्ड को दें जिन पर आप भरोसा
करते हैं। जिन पुल रिक्वेस्ट पर आप भरोसा नहीं करते, उनका कोड चलाते समय जॉब को
कोई सीक्रेट या लिखने की इजाज़त वाला टोकन न दें। [सुरक्षा](https://e2e.com/docs/hi/security) देखें।
</Warning>

कुंजियाँ CI सीक्रेट में रखें, और जहाँ हो सके, खर्च की सीमा तय करें। GitHub फ़ोर्क
से आने वाले पुल रिक्वेस्ट को सीक्रेट नहीं देता।

## CI क्या बदलता है

CI मोड तब चालू होता है जब `CI` का मान खाली स्ट्रिंग, `0` या `false` के अलावा कुछ
और हो। ये डिफ़ॉल्ट अपनी मशीन पर पाने के लिए `CI=1 npx e2e run` चलाएँ:

| सेटिंग | लोकल | CI |
| --- | --- | --- |
| `retries` | `0` | `1` |
| `workers` | आपके CPU कोर की आधी संख्या | `1` |
| सेट न होने पर `cache` | `read-write` | `read-only` |
| `.only` | इजाज़त है | `ONLY_IN_CI` के साथ अस्वीकार |
| `command.reuseExisting` | लागू होता है | अनदेखा, एक सूचना के साथ |

वर्कर और रीट्राई के डिफ़ॉल्ट बदलने के लिए फ़्लैग इस्तेमाल करें:

<CodeGroup>
```bash npm
npx e2e run --workers 4 --retries 0
```

```bash pnpm
pnpm exec e2e run --workers 4 --retries 0
```

```bash bun
bunx e2e run --workers 4 --retries 0
```
</CodeGroup>

CI से कोई [टेलीमेट्री](https://e2e.com/docs/hi/telemetry#in-ci) न भेजने के लिए, जॉब के `env` में
`E2E_TELEMETRY_DISABLED: '1'` जोड़ें।

## मोबाइल जॉब

[होस्टेड डिवाइस सेवा](https://e2e.com/docs/hi/mobile#hosted-devices) के बिना हर प्लेटफ़ॉर्म को अपनी अलग
मशीन, बिल्ड और डिवाइस चाहिए:

| | iOS | Android |
| --- | --- | --- |
| मशीन | Xcode और सिम्युलेटर रनटाइम वाला macOS | KVM (नेस्टेड वर्चुअलाइज़ेशन) वाला Linux |
| बिल्ड | Release सिम्युलेटर `.app`, बिना साइनिंग | Release `.apk` |
| डिवाइस | बूट किया हुआ सिम्युलेटर | बूट किया हुआ एम्युलेटर |

दोनों प्लेटफ़ॉर्म पर Release बिल्ड बनाएँ। React Native या Expo का debug बिल्ड
अपना JavaScript Metro से लोड करता है, जिसे ये जॉब शुरू नहीं करते, इसलिए ऐप एक
एरर स्क्रीन पर खुलता है। उदाहरण ऐसे React Native प्रोजेक्ट का इस्तेमाल करते हैं
जिसकी रिपॉज़िटरी में `ios/` और `android/` मौजूद हैं। जिस Expo प्रोजेक्ट में ये
नहीं हैं, उसमें पहले `npx expo prebuild` चलाएँ।

बिल्ड इंस्टॉल करें, फिर सूट चलाएँ:

<CodeGroup>
```bash npm
# iOS
xcrun simctl install booted path/to/MyApp.app
npx e2e run --target ios --reporter list,junit

# Android
adb install -r path/to/app.apk
npx e2e run --target android --reporter list,junit
```

```bash pnpm
# iOS
xcrun simctl install booted path/to/MyApp.app
pnpm exec e2e run --target ios --reporter list,junit

# Android
adb install -r path/to/app.apk
pnpm exec e2e run --target android --reporter list,junit
```

```bash bun
# iOS
xcrun simctl install booted path/to/MyApp.app
bunx e2e run --target ios --reporter list,junit

# Android
adb install -r path/to/app.apk
bunx e2e run --target android --reporter list,junit
```
</CodeGroup>

ये कमांड मानकर चलती हैं कि `ios` और `android` नाम के दो टारगेट हैं, और हर एक
ऐप के `bundleId` के साथ `mobile()` इंजन है।
[अपने ऐप की ओर पॉइंट करें](https://e2e.com/docs/hi/mobile#point-at-your-app) देखें। सूट से बिल्ड
इंस्टॉल करवाने के लिए `app.appPath` सेट करें और `device.installApp()` कॉल करें।

ये नियम हर सेवा पर लागू होते हैं:

- **हर प्लेटफ़ॉर्म के लिए एक जॉब।** `--target ios` को Mac पर और
  `--target android` को KVM वाले Linux पर चलाएँ। होस्टेड Mac में Apple Silicon
  होता है, जो नेस्टेड वर्चुअलाइज़ेशन नहीं कर सकता, इसलिए उन पर Android
  एम्युलेटर शुरू नहीं होता।
- **डिवाइस को उसके अपने चरण में बूट करें।** अगर कोई डिवाइस बूट नहीं है, तो इंजन
  agent-device से एक डिवाइस बूट करने को कहता है, लेकिन नए Linux रनर पर कोई
  एम्युलेटर इमेज नहीं होती। अलग चरण से यह भी साफ़ होता है कि बूट विफल हुआ या टेस्ट।
- **iOS रनटाइम पिन करें।** नाम से चुना गया सिम्युलेटर (`iPhone 17`) इमेज का
  डिफ़ॉल्ट iOS चलाता है, और ऐक्सेसिबिलिटी ट्री iOS रिलीज़ के बीच बदल जाता है।
  ऐसे में रनर इमेज का कोई अपडेट आपके कोड में बिना किसी बदलाव के किसी लोकेटर
  असर्शन को विफल कर सकता है। उदाहरण किसी नामित रनटाइम पर सिम्युलेटर बनाते हैं
  और उसे UDID से बूट करते हैं। `iOS-26-5` की जगह वह रनटाइम लिखें जो इमेज में
  मौजूद है (`xcrun simctl list runtimes`)।
- **`~/.agent-device/apple-runner/derived` को कैश करें।** agent-device जब पहली बार
  किसी सिम्युलेटर को चलाता है, तब वहीं अपना XCUITest रनर बिल्ड करता है। पूरा
  `~/.agent-device` कैश न करें। बाकी हिस्सा पिछले डेमन की स्थिति है, और उसकी
  रिस्टोर की गई कॉपी अगले रन को `Failed to communicate with daemon` के साथ रोक
  सकती है।
- **लोकल रिकॉर्डिंग रीप्ले करें।** रीप्ले कैश की कुंजी में ऐप होता है, डिवाइस नहीं,
  इसलिए आपके सिम्युलेटर पर रिकॉर्ड किया गया चरण CI वाले सिम्युलेटर पर भी रीप्ले
  होता है। [रीप्ले कैश कमिट करें](https://e2e.com/docs/hi/cache#commit-the-replay-cache)।

## पुल रिक्वेस्ट पर गेट लगाएँ

शून्य के अलावा हर एग्ज़िट कोड जॉब को विफल कर देता है। एजेंट का कोई चरण विफल
होने पर भी यही होता है। विफल रन पर मर्ज रोकने के लिए e2e जॉब को ज़रूरी (required) चेक बनाएँ।
[रन को डीबग करना](https://e2e.com/docs/hi/debugging#read-the-failure) हर एग्ज़िट कोड की सूची देता है और
बताता है कि जॉब दोबारा चलाने से मदद मिल सकती है या नहीं।

चेक के नतीजे अनुमान के मुताबिक रखने के लिए:

- हर `agent.act` को एक [एटॉमिक लक्ष्य](https://e2e.com/docs/hi/core-concepts#goals) दें। फिर उसके
  नतीजे को लोकेटर असर्शन या `agent.assert` से जाँचें।
- [रीप्ले कैश कमिट करें](https://e2e.com/docs/hi/cache#commit-the-replay-cache)। रीप्ले किया गया
  `agent.act` कोई मॉडल कॉल नहीं करता। बिल्ट-इन एजेंट के साथ कैश मिस, हैंड-ऑफ़
  और एजेंट का हर आकलन (`agent.assert`, `agent.waitFor`, `agent.extract`) मॉडल
  को कॉल करता है।
- फ़्लेकी टेस्ट पर नज़र रखें। जो टेस्ट सिर्फ़ CI रीट्राई पर पास होता है, रिपोर्ट
  उसे फ़्लेकी के रूप में मार्क करती है।
- `--max-failures <n>` जोड़ें, ताकि इतने टेस्ट विफल होने के बाद रन रुक जाए और
  टूटा हुआ डिप्लॉय बाकी हर चरण पर मॉडल कॉल खर्च न करे। जॉब का एग्ज़िट कोड 1
  होता है।
- टेस्ट चलने के समय की सीमा तय करने के लिए `--max-duration <ms>` जोड़ें। घड़ी तब
  शुरू होती है जब टेस्ट शुरू होते हैं, ऐप स्टार्टअप के दौरान नहीं। जॉब का
  एग्ज़िट कोड 1 होता है।

## सिर्फ़ प्रभावित टेस्ट चलाएँ

पुल रिक्वेस्ट पर `--changed-since` पास करें, ताकि कोई [टेस्ट फ़िल्टर](https://e2e.com/docs/hi/filters)
उन टेस्ट को छोड़ सके जिन पर बदलाव का असर पड़ने की संभावना कम है। जब फ़िल्टर
टेस्ट को स्कोर देता है, जैसा डिसीज़न फ़िल्टर करता है, तो हर टारगेट सबसे पहले उन
टेस्ट की फ़ाइलें शुरू करता है जिनके विफल होने की संभावना सबसे ज़्यादा है। फ़्लैग
के बिना, जैसे `main` पर, पूरा सूट चलता है।
[डिसीज़न फ़िल्टर जोड़ें](https://e2e.com/docs/hi/filters#add-the-decision-filter) देखें।

CI के डिफ़ॉल्ट एक वर्कर के साथ फ़ाइलों का क्रम सिर्फ़ रेलेवेंस बैंड तय करते हैं,
और बराबरी होने पर टेस्ट इकट्ठा होने का क्रम फ़ैसला करता है: e2e
[टाइमिंग हिस्ट्री](#cache-the-timings-history) सिर्फ़ एक से ज़्यादा वर्कर होने पर पढ़ता है।
[सबसे संभावित को पहले शुरू करें](https://e2e.com/docs/hi/filters#start-the-likeliest-first) देखें।

## टाइमिंग हिस्ट्री को कैश करें

एक से ज़्यादा वर्कर होने पर `e2e run` सबसे लंबी फ़ाइलें पहले शुरू करता है, उन
फ़ाइलों के बाद जिनका कोई समय उसके पास दर्ज नहीं है। यह क्रम `<output>/timings.json` (डिफ़ॉल्ट रूप से `.e2e/timings.json`) से तय होता है: कुछ KB की
एक फ़ाइल, जिसे कोई रन तब अपडेट करता है जब उसने कम से कम एक फ़ाइल पूरी चलाई हो।
नए CI चेकआउट में यह फ़ाइल नहीं होती, इसलिए रन से पहले इसे अपने CI कैश से
रिस्टोर करें और रन के बाद सेव करें।
[GitHub Actions](https://e2e.com/docs/hi/ci/github-actions#cache-the-timings-history) पेज पर इसका चरण दिया गया है।

- यह फ़ाइल सिर्फ़ सलाह देती है। गायब, खराब या अमान्य फ़ाइल को हिस्ट्री नहीं माना
  जाता, और रन पिछली `report.json` का सहारा लेता है। रिस्टोर की गई फ़ाइल फ़ाइलों
  का क्रम बदल सकती है, नतीजा कभी नहीं।
- कोई रन किसी फ़ाइल का समय तभी दर्ज करता है जब उसने वह पूरी फ़ाइल चलाई हो।
  `--grep` या `--last-failed` रन जिस फ़ाइल को आंशिक रूप से चलाता है, उसकी एंट्री
  जैसी थी वैसी ही छोड़ देता है।
- CI डिफ़ॉल्ट रूप से एक वर्कर इस्तेमाल करता है। टाइमिंग हिस्ट्री का फ़ायदा उठाने के लिए
  [`workers`](https://e2e.com/docs/hi/reference/config#workers) सेट करें या `--workers` पास करें।
- कैश की कुंजी ब्रांच के हिसाब से रखें, और फ़ॉलबैक के तौर पर `main` रखें, ताकि
  नया पुल रिक्वेस्ट `main` की हिस्ट्री से शुरू हो। [शार्डिंग](#sharding) के साथ
  कुंजी में शार्ड इंडेक्स भी जोड़ें।
- `--timings <file>` किसी दूसरे पाथ को पढ़ता और लिखता है।

## शार्डिंग

`--shard <index/total>` सूट का एक हिस्सा चलाता है। हर जॉब अपने इंडेक्स के साथ
एक ही कमांड चलाता है, और हर मशीन सूट को एक ही तरह से बाँटती है। जिस शार्ड में
कोई टेस्ट नहीं होता, वह `NO_TESTS` के साथ विफल होता है। अगर किसी मैट्रिक्स में
टेस्ट से ज़्यादा शार्ड हो सकते हैं, तो `--pass-with-no-tests` जोड़ें।
[CLI रेफ़रेंस](https://e2e.com/docs/hi/reference/cli#flags) में बाँटने के नियम दिए गए हैं।

GitHub Actions पर एक मैट्रिक्स हर शार्ड के लिए एक जॉब चलाता है:

```yaml
jobs:
  e2e:
    strategy:
      fail-fast: false
      matrix:
        shard: [1, 2, 3]
    steps:
      # ...
      - run: npx e2e run --shard ${{ matrix.shard }}/3 --reporter list,junit
```

हर शार्ड की `report.json` और `junit.xml` ऐसे नाम से अपलोड करें जिसमें शार्ड
इंडेक्स हो। e2e अभी शार्ड रिपोर्ट को मर्ज नहीं कर सकता।

## विफल टेस्ट दोबारा चलाना

`--last-failed` सिर्फ़ वे टेस्ट चलाता है जो पिछले रन में पास नहीं हुए। यह उन्हें
आउटपुट डायरेक्टरी की `report.json` से पढ़ता है। इसे पहले रन वाले चरण में ही
चलाएँ:

```yaml
      - run: npx e2e run || npx e2e run --last-failed
```

दोबारा चलाया गया रन पहले रन के आर्टिफ़ैक्ट रखता है और अपने आर्टिफ़ैक्ट हर टेस्ट
की डायरेक्टरी में `rerun-<n>/` के अंदर लिखता है, इसलिए एक ही अपलोड में दोनों आ
जाते हैं। [CLI रेफ़रेंस](https://e2e.com/docs/hi/reference/cli#flags) बताता है कि किसे पास नहीं हुआ
माना जाता है।

अलग जॉब के रनर पर कोई रिपोर्ट नहीं होती। पहले उसे आउटपुट डायरेक्टरी में डाउनलोड
करें, या विफल जॉब को दोबारा चलाएँ।

## आगे

<CardGroup cols={2}>
  <Card title="पुल रिक्वेस्ट कमेंट" icon="code-pull-request" href="/github">
    हर रन के लिए एक कमेंट, जिसे दोबारा चलाने पर उसी जगह एडिट किया जाता है।
  </Card>
  <Card title="CLI रेफ़रेंस" icon="terminal" href="/reference/cli">
    फ़्लैग, रिपोर्टर और हर एग्ज़िट कोड।
  </Card>
</CardGroup>
