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

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है किसी समस्या की शिकायत करें सोर्स देखें रात · 7.3 · 7.2 · 7.1 · 7.0 · 6.5

Basel ने कोड कवरेज तैयार करने के लिए, coverage सब-कमांड दिया है डेटा स्टोर करने की जगहों के बारे में रिपोर्ट मौजूद हैं. इनका इस्तेमाल bazel coverage की मदद से किया जा सकता है. पूरा होने की तारीख की समस्याओं के बारे में जानने के लिए, किसी दिए गए प्रोजेक्ट के लिए यह काम करना हमेशा आसान नहीं होता.

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

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

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

वीडियो की रणनीति

कवरेज रिपोर्ट बनाने के लिए बेसिक वर्कफ़्लो के लिए ज़रूरी है फ़ॉलो किया जा रहा है:

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

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

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

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

कवरेज की संख्या

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

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

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

कवरेज देखना

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

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

ध्यान दें कि genhtml, सोर्स कोड को भी पढ़ता है, ताकि उस कॉन्टेंट के बारे में पता चल सके जो मौजूद नहीं है शामिल हैं. इसके काम करने के लिए, यह उम्मीद की जाती है कि genhtml को बेज़ल प्रोजेक्ट के रूट में एक्ज़ीक्यूट किया जाता है.

नतीजा देखने के लिए, यहां बनाई गई index.html फ़ाइल को खोलें किसी भी वेब ब्राउज़र में genhtml डायरेक्ट्री.

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

रिमोट तरीके से एक्ज़ीक्यूट करें

रिमोट तरीके से टेस्ट करने की प्रोसेस चलाने के दौरान, फ़िलहाल कुछ चेतावनियां दी गई हैं:

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

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

Java

Java को डिफ़ॉल्ट कॉन्फ़िगरेशन के साथ सबसे बेहतर काम करना चाहिए. कॉन्टेंट बनाने बेज़ल टूलचेन में वे सभी चीज़ें मौजूद होती हैं जो Google Tag Manager रिमोट एक्ज़ीक्यूशन के साथ-साथ JUnit को भी एक्ज़ीक्यूट किया जा सकता है.

Python

ज़रूरी शर्तें

Python के साथ कवरेज चलाना, इसके लिए कुछ ज़रूरी शर्तें पूरी करना होता है:

बेज़ल बाइनरी, जिसमें b01c859 शामिल है, जो कोई भी Basel >3.0 होना चाहिए.
कवरेज.py का संशोधित वर्शन.

बदले गए कवरेज.py का इस्तेमाल करना

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

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",
)

उसके बाद कवरेज.py की ज़रूरत का इस्तेमाल ऐसे टेस्ट टारगेट के लिए किया जा सकता है 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",
    ],
)

अगर कवरेज जोड़ने के बजाय, हर्मेटिक Python टूलचेन का इस्तेमाल किया जा रहा है, तो हर py_test टारगेट पर निर्भरता इसके बजाय कवरेज टूल को और टूलचेन कॉन्फ़िगरेशन की ज़रूरत है.

क्योंकि pip_install नियम, Python पर निर्भर करता है टूलचेन में, इसका इस्तेमाल coverage मॉड्यूल फ़ेच करने के लिए नहीं किया जा सकता. इसके बजाय, इसे अपने WORKSPACE में जोड़ें, जैसे कि

http_archive(
    name = "coverage_linux_x86_64"",
    build_file_content = """
py_library(
    name = "coverage",
    srcs = ["coverage/__main__.py"],
    data = glob(["coverage/*", "coverage/**/*.py"]),
    visibility = ["//visibility:public"],
)
""",
    sha256 = "84631e81dd053e8a0d4967cedab6db94345f1c36107c71698f746cb2636c63e3",
    type = "zip",
    urls = [
        "https://files.pythonhosted.org/packages/74/0d/0f3c522312fd27c32e1abe2fb5c323b583a5c108daf2c26d6e8dfdd5a105/coverage-6.4.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
    ],
)

इसके बाद, अपने Python टूलचेन को कॉन्फ़िगर करें, जैसे कि

py_runtime(
    name = "py3_runtime_linux_x86_64",
    coverage_tool = "@coverage_linux_x86_64//:coverage",
    files = ["@python3_9_x86_64-unknown-linux-gnu//:files"],
    interpreter = "@python3_9_x86_64-unknown-linux-gnu//:bin/python3",
    python_version = "PY3",
)

py_runtime_pair(
    name = "python_runtimes_linux_x86_64",
    py2_runtime = None,
    py3_runtime = ":py3_runtime_linux_x86_64",
)

toolchain(
    name = "python_toolchain_linux_x86_64",
    exec_compatible_with = [
        "@platforms//os:linux",
        "@platforms//cpu:x86_64",
    ],
    toolchain = ":python_runtimes_linux_x86_64",
    toolchain_type = "@bazel_tools//tools/python:toolchain_type",
)