बैजल के साथ कोड कवरेज

Bazel में coverage सब-कमांड हैं, ताकि वे रिपोज़िटरी (डेटा स्टोर करने की जगह) पर कोड कवरेज रिपोर्ट बना सकें. इनका इस्तेमाल bazel coverage के साथ किया जा सकता है. अलग-अलग भाषाओं के नेटवर्क के अलग-अलग पहलुओं की वजह से, किसी प्रोजेक्ट के लिए यह काम करना आम बात होती है.

इस पेज में कवरेज रिपोर्ट बनाने और देखने की सामान्य प्रक्रिया का दस्तावेज़ होता है. साथ ही, इसमें उन भाषाओं के लिए कुछ खास भाषा के नोट भी होते हैं जिनका कॉन्फ़िगरेशन मशहूर है. सबसे पहले इसे पढ़ने के लिए सामान्य सेक्शन पढ़ें और फिर किसी खास भाषा की ज़रूरतों के बारे में पढ़ें. रिमोट एक्ज़ीक्यूशन सेक्शन पर भी ध्यान दें, जिसके लिए कुछ और चीज़ों की ज़रूरत है.

हालांकि, बहुत ज़्यादा कस्टमाइज़ेशन हो सकता है, लेकिन इस दस्तावेज़ में lcov रिपोर्ट बनाने और इस्तेमाल करने पर फ़ोकस किया गया है, जो इस समय सबसे अच्छा रास्ता है.

कवरेज रिपोर्ट बनाना

तैयारी

कवरेज रिपोर्ट बनाने के बुनियादी वर्कफ़्लो के लिए नीचे दी गई चीज़ों की ज़रूरत होती है:

  • टेस्ट टारगेट के साथ एक बुनियादी डेटा स्टोर करने की जगह
  • भाषा-विशिष्ट कोड कवरेज टूल के साथ उपयोग किया जाने वाला टूलचेन
  • एक सही " इंस्ट्रूमेंटेशन" का कॉन्फ़िगरेशन

पहले दो नतीजे खास तौर पर भाषा के हिसाब से होते हैं और ज़्यादातर मामलों में आसान होते हैं. हालांकि, मुश्किल प्रोजेक्ट के लिए बाद वाली समस्याएं ज़्यादा मुश्किल होती हैं.

इस मामले में " इंस्ट्रूमेंटेशन" का मतलब उस कवरेज टूल से है जिसका इस्तेमाल किसी खास टारगेट के लिए किया जाता है. बैजल, --instrumentation_filter फ़्लैग का इस्तेमाल करके, फ़ाइलों के एक खास सबसेट के लिए इसे चालू करने की अनुमति देती हैं. यह फ़्लैग, टारगेट के साथ टेस्ट किए गए टारगेट के लिए फ़िल्टर तय करती है चालू है. टेस्ट के लिए इंस्ट्रूमेंटेशन की सुविधा चालू करने के लिए, --instrument_test_targets फ़्लैग की ज़रूरत है.

डिफ़ॉल्ट रूप से, बेज़ल लक्ष्य पैकेज के मिलान का प्रयास करता है और प्रासंगिक फ़िल्टर को INFO संदेश के रूप में प्रिंट करता है.

जारी कवरेज

कवरेज रिपोर्ट बनाने के लिए, bazel coverage --combined_report=lcov [target] का इस्तेमाल करें. यह टारगेट के लिए टेस्ट करता है, जिससे हर फ़ाइल के लिए कवरेज रिपोर्ट जनरेट की जाती है.

काम पूरा होने के बाद, बेज़ेल ऐसी कार्रवाई करता है जो बनाई गई सभी कवर फ़ाइलों को इकट्ठा करती है और उन्हें एक कर देती है, जो बाद में $(bazel info output_path)/_coverage/_coverage_report.dat के तहत बना दी जाती है.

अगर टेस्ट सफल नहीं होते, तो कवरेज रिपोर्ट भी तैयार की जाती हैं. हालांकि, ध्यान रखें कि यह जांच फ़ेल हो जाने पर भी लागू नहीं होती है.

कवरेज देखना

कवरेज रिपोर्ट सिर्फ़ गैर-मानवीय पढ़ने लायक lcov फ़ॉर्मैट में आउटपुट होती है. इससे, हम genhtml सुविधा (lcov प्रोजेक्ट का हिस्सा) का इस्तेमाल करके, ऐसी रिपोर्ट बना सकते हैं जिसे वेब ब्राउज़र में देखा जा सकता है:

genhtml --output genhtml "$(bazel info output_path)/_coverage/_coverage_report.dat"

ध्यान दें कि genhtml इन फ़ाइलों में छूटे हुए कवर के बारे में बताने के लिए, स्रोत कोड को भी पढ़ता है. इसके काम करने के लिए, उम्मीद की जाती है कि genhtml को बेज़ेल प्रोजेक्ट के रूट में लागू किया जाएगा.

परिणाम देखने के लिए, बस किसी भी वेब ब्राउज़र में genhtml निर्देशिका में बनाई गई index.html फ़ाइल खोलें.

genhtml टूल या lcov कवरेज फ़ॉर्मैट से जुड़ी ज़्यादा सहायता और जानकारी के लिए, lcov प्रोजेक्ट देखें.

रिमोट एक्ज़ीक्यूशन

रिमोट टेस्ट चलाने में फ़िलहाल कुछ चेतावनियां हैं:

  • रिपोर्ट संयोजन कार्रवाई अभी तक दूरस्थ रूप से नहीं चल सकती. ऐसा इसलिए होता है, क्योंकि बैजल, कवरेज आउटपुट फ़ाइलों को इसके ग्राफ़ के हिस्से के तौर पर नहीं देखता (यह समस्या देखें). इसलिए, इसे सही तरीके से कॉम्बिनेशन के इनपुट के तौर पर नहीं माना जा सकता कार्रवाई. इससे बचने के लिए, --strategy=CoverageReport=local का इस्तेमाल करें.
    • ध्यान दें: बज़ेल के लिए local,remote का इस्तेमाल करने की सुविधा सेट अप करने के बजाय, --strategy=CoverageReport=local,remote जैसी कुछ जानकारी देना ज़रूरी हो सकता है. ऐसा इसलिए होता है, क्योंकि बेज़ेल अपनी रणनीतियां ठीक करता है.
  • --remote_download_minimal और इससे मिलते-जुलते फ़्लैग का इस्तेमाल, पहले वाले फ़्लैग के तौर पर भी नहीं किया जा सकता.
  • अगर अभी कैश मेमोरी में कैश मेमोरी में सेव हो जाने की वजह से, इससे बचने के लिए, --nocache_test_results को खास तौर पर कवरेज के लिए सेट किया जा सकता है. हालांकि, टेस्ट के समय बहुत ज़्यादा पैसे चुकाने होते हैं.
  • --experimental_split_coverage_postprocessing और --experimental_fetch_all_coverage_outputs
    • आम तौर पर कवरेज, टेस्ट कार्रवाई के हिस्से के तौर पर चलाया जाता है. इसलिए, डिफ़ॉल्ट रूप से, हमें डिफ़ॉल्ट तौर पर सभी कवरेज को आउटपुट के तौर पर रिमोट नहीं मिलता है. ये फ़्लैग डिफ़ॉल्ट को ओवरराइड कर देते हैं और कवरेज डेटा हासिल करते हैं. ज़्यादा जानकारी के लिए यह समस्या देखें.

भाषा के हिसाब से कॉन्फ़िगरेशन

Java

Java को डिफ़ॉल्ट कॉन्फ़िगरेशन के साथ बॉक्स के बाहर काम करना चाहिए. बज़ेल टूल चेन में, रिमोट यूनिटेशन के लिए ज़रूरी सभी चीज़ें होती हैं. इनमें JUnit भी शामिल है.

Python

ज़रूरी बातें

Python के साथ चल रहे कवरेज से जुड़ी कुछ ज़रूरी शर्तें हैं:

conversions.py का इस्तेमाल करना

ऐसा करने के लिए यह तरीका हैrules_python है, तो इससे आपकोrequirements.txt है, तो फ़ाइल में सूचीबद्ध आवश्यकताएं अपने-आप इसेपीआईपी_इंस्टॉल डेटा स्टोर करने की जगह का नियम.

requirements.txt में नीचे दी गई जानकारी होनी चाहिए:

git+https://github.com/ulfjack/coveragepy.git@lcov-support

इसके बाद, rules_python, pip_install, और requirements.txt फ़ाइल का इस्तेमाल WORKSPACE फ़ाइल के तौर पर किया जाना चाहिए:

load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

http_archive(
    name = "rules_python",
    url = "https://github.com/bazelbuild/rules_python/releases/download/0.5.0/rules_python-0.5.0.tar.gz",
    sha256 = "cd6730ed53a002c56ce4e2f396ba3b3be262fd7cb68339f0377a45e8227fe332",
)

load("@rules_python//python:pip.bzl", "pip_install")

pip_install(
   name = "python_deps",
   requirements = "//:requirements.txt",
)

फिर कवरेज फ़ाइलों को BUILD टारगेट में सेट करके टेस्ट टारगेट से इस्तेमाल किया जा सकता है:

load("@python_deps//:requirements.bzl", "entry_point")

alias(
    name = "python_coverage_tools",
    actual = entry_point("coverage"),
)

py_test(
    name = "test",
    srcs = ["test.py"],
    env = {
        "PYTHON_COVERAGE": "$(location :python_coverage_tools)",
    },
    deps = [
        ":main",
        ":python_coverage_tools",
    ],
)