From 43cddac03ea0db64111b55832b7c1af5370c2710 Mon Sep 17 00:00:00 2001 From: Markus Bechter Date: Wed, 17 Dec 2025 11:42:58 +0100 Subject: [PATCH] Cleanup of unused parts - Removed feature_requirements from component - Fixed integration tests --- .github/workflows/tests.yml | 3 + MODULE.bazel | 2 +- bazel/rules/rules_score/docs/index.rst | 186 ++++++++++++++++++ bazel/rules/rules_score/private/component.bzl | 21 +- .../private/component_requirements.bzl | 13 +- .../private/dependable_element.bzl | 143 ++------------ bazel/rules/rules_score/providers.bzl | 16 +- bazel/rules/rules_score/rules_score.bzl | 2 - .../templates/seooc_index.template.rst | 13 +- bazel/rules/rules_score/test/BUILD | 16 +- .../rules_score/test/unit_component_test.bzl | 93 +-------- 11 files changed, 225 insertions(+), 283 deletions(-) diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 7354275..b43c3ec 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -23,3 +23,6 @@ jobs: - name: Run coverage module tests run: | bazel test //coverage/tests:all + - name: Run rules_score tests + run: | + bazel test //bazel/rules/rules_score/... diff --git a/MODULE.bazel b/MODULE.bazel index 0b792f4..66678f7 100644 --- a/MODULE.bazel +++ b/MODULE.bazel @@ -101,5 +101,5 @@ git_override( remote = "https://github.com/eclipse-score/docs-as-code.git", ) -bazel_dep(name = "score_platform", version = "0.5.0") +# bazel_dep(name = "score_platform", version = "0.5.0") bazel_dep(name = "score_process", version = "1.3.2") diff --git a/bazel/rules/rules_score/docs/index.rst b/bazel/rules/rules_score/docs/index.rst index c6ea28a..79769a4 100644 --- a/bazel/rules/rules_score/docs/index.rst +++ b/bazel/rules/rules_score/docs/index.rst @@ -59,6 +59,141 @@ Builds Sphinx-based HTML documentation from RST source files with support for de **Output:** ``/html/`` with merged dependency documentation +Artifact Rules +-------------- + +Artifact rules define S-CORE process work products. All provide ``SphinxSourcesInfo`` for documentation generation. + +**feature_requirements** + +.. code-block:: python + + feature_requirements( + name = "features", + srcs = ["docs/features.rst"], + ) + +**component_requirements** + +.. code-block:: python + + component_requirements( + name = "requirements", + srcs = ["docs/requirements.rst"], + ) + +**assumptions_of_use** + +.. code-block:: python + + assumptions_of_use( + name = "aous", + srcs = ["docs/assumptions.rst"], + ) + +**architectural_design** + +.. code-block:: python + + architectural_design( + name = "architecture", + static = ["docs/static_arch.rst"], + dynamic = ["docs/dynamic_arch.rst"], + ) + +**safety_analysis** + +.. code-block:: python + + safety_analysis( + name = "safety", + controlmeasures = ["docs/controls.rst"], + failuremodes = ["docs/failures.rst"], + fta = ["docs/fta.rst"], + arch_design = ":architecture", + ) + +**dependability_analysis** + +.. code-block:: python + + dependability_analysis( + name = "analysis", + arch_design = ":architecture", + dfa = ["docs/dfa.rst"], + safety_analysis = [":safety"], + ) + + +Structural Rules +---------------- + +**unit** + +Define the smallest testable software element. + +.. code-block:: python + + unit( + name = "my_unit", + unit_design = [":architecture"], + implementation = ["//src:lib"], + tests = ["//tests:unit_test"], + ) + +**component** + +Define a collection of units. + +.. code-block:: python + + component( + name = "my_component", + component_requirements = [":requirements"], + units = [":my_unit"], + implementation = ["//src:binary"], + tests = ["//tests:integration_test"], + ) + +**dependable_element** + +Define a complete SEooC with automatic documentation generation. + +.. code-block:: python + + dependable_element( + name = "my_seooc", + description = "My safety-critical component", + assumptions_of_use = [":aous"], + requirements = [":requirements"], + architectural_design = [":architecture"], + dependability_analysis = [":analysis"], + components = [":my_component"], + tests = ["//tests:system_test"], + deps = ["@platform//:platform_module"], + ) + +**Generated Targets:** + +- ````: Sphinx module with HTML documentation +- ``_needs``: Sphinx-needs JSON for cross-referencing +- ``_index``: Generated index.rst with artifact structure + + srcs = glob(["docs/**/*.rst"]), + index = "docs/index.rst", + deps = ["@external_module//:docs"], + ) + +**Key Parameters:** + +- ``srcs``: RST/MD source files +- ``index``: Main index.rst file +- ``deps``: Other sphinx_module or dependable_element targets for cross-referencing +- ``sphinx``: Sphinx build binary (default: ``//bazel/rules/rules_score:score_build``) + +**Output:** ``/html/`` with merged dependency documentation + + Artifact Rules -------------- @@ -180,6 +315,14 @@ Define a complete SEooC with automatic documentation generation. - ``_needs``: Sphinx-needs JSON for cross-referencing - ``_index``: Generated index.rst with artifact structure +**Implementation Details:** + +The macro automatically: + +- Generates an index.rst file with a toctree referencing all provided artifacts +- Creates symlinks to artifact files (assumptions of use, requirements, architecture, safety analysis) for co-location with the generated index +- Delegates to ``sphinx_module`` for actual Sphinx build and HTML generation +- Integrates dependencies for cross-module referencing and HTML merging Dependency Management --------------------- @@ -248,6 +391,49 @@ Build: bazel build //:persistency_kvs # Output: bazel-bin/persistency_kvs/html/ + # Implementation + cc_library(name = "kvs_lib", srcs = ["kvs.cpp"], hdrs = ["kvs.h"]) + cc_test(name = "kvs_test", srcs = ["kvs_test.cpp"], deps = [":kvs_lib"]) + + # Structure + unit(name = "kvs_unit", unit_design = [":arch"], + implementation = [":kvs_lib"], tests = [":kvs_test"]) + component(name = "kvs_component", component_requirements = [":reqs"], + units = [":kvs_unit"], implementation = [":kvs_lib"], tests = []) + + # SEooC + dependable_element( + name = "persistency_kvs", + description = "Key-Value Store for persistent data storage", + assumptions_of_use = [":aous"], + requirements = [":reqs"], + architectural_design = [":arch"], + dependability_analysis = [":analysis"], + components = [":kvs_component"], + tests = [], + deps = ["@score_process//:score_process_module"], + ) + +Build: + +.. code-block:: bash + + bazel build //:kvs_seooc + # Output: bazel-bin/kvs_seooc/html/ + # Includes merged HTML from score_platform and score_process modules + +Design Rationale +---------------- + +These rules provide a structured approach to documentation by: + +1. **Two-Tier Architecture**: Generic ``sphinx_module`` for flexibility, specialized ``score_component`` for safety-critical work +2. **Dependency Management**: Automatic cross-referencing and HTML merging across modules +3. **Standardization**: SEooC enforces consistent structure for safety documentation +4. **Traceability**: Sphinx-needs integration enables bidirectional traceability +5. **Automation**: Index generation, symlinking, and configuration management are automatic +6. **Build System Integration**: Bazel ensures reproducible, cacheable documentation builds + Reference Implementation ------------------------ diff --git a/bazel/rules/rules_score/private/component.bzl b/bazel/rules/rules_score/private/component.bzl index 8a8c29a..0966a03 100644 --- a/bazel/rules/rules_score/private/component.bzl +++ b/bazel/rules/rules_score/private/component.bzl @@ -49,8 +49,8 @@ def _component_impl(ctx): # Collect implementation targets implementation_depset = depset(ctx.attr.implementation) - # Collect units and tests - units_depset = depset(ctx.attr.units) + # Collect components and tests + components_depset = depset(ctx.attr.components) tests_depset = depset(ctx.attr.tests) # Combine all files for DefaultInfo @@ -64,7 +64,7 @@ def _component_impl(ctx): name = ctx.label.name, requirements = requirements_depset, implementation = implementation_depset, - units = units_depset, + components = components_depset, tests = tests_depset, ), SphinxSourcesInfo( @@ -89,7 +89,7 @@ _component = rule( doc = "Implementation targets (libraries, binaries) that realize this component", default = [], ), - "units": attr.label_list( + "components": attr.label_list( mandatory = True, doc = "Unit targets that comprise this component", ), @@ -149,20 +149,11 @@ def component( ``` """ - # Support both old parameter names and new aliases - final_requirements = requirements - final_units = units if units != None else components - - if final_requirements == None: - fail("component() requires 'requirements' parameter") - if final_units == None: - fail("component() requires either 'units' or 'components' parameter") - _component( name = name, - requirements = final_requirements, + requirements = requirements, implementation = implementation, - units = final_units, + components = components, tests = tests, testonly = testonly, visibility = visibility, diff --git a/bazel/rules/rules_score/private/component_requirements.bzl b/bazel/rules/rules_score/private/component_requirements.bzl index eda94d6..8735354 100644 --- a/bazel/rules/rules_score/private/component_requirements.bzl +++ b/bazel/rules/rules_score/private/component_requirements.bzl @@ -30,6 +30,7 @@ ComponentRequirementsInfo = provider( doc = "Provider for component requirements artifacts", fields = { "srcs": "Depset of source files containing component requirements", + "requirements": "List of FeatureRequirementsInfo providers this component traces to", "name": "Name of the component requirements target", }, ) @@ -54,15 +55,9 @@ def _component_requirements_impl(ctx): # Collect feature requirements providers feature_reqs = [] - for feat_req in ctx.attr.feature_requirement: - if FeatureRequirementsInfo in feat_req: - feature_reqs.append(feat_req[FeatureRequirementsInfo]) # Collect transitive sphinx sources from feature requirements transitive = [srcs] - for feat_req in ctx.attr.feature_requirement: - if SphinxSourcesInfo in feat_req: - transitive.append(feat_req[SphinxSourcesInfo].transitive_srcs) return [ DefaultInfo(files = srcs), @@ -99,7 +94,6 @@ _component_requirements = rule( def component_requirements( name, srcs, - feature_requirement = [], visibility = None): """Define component requirements following S-CORE process guidelines. @@ -114,9 +108,6 @@ def component_requirements( srcs: List of labels to .rst, .md, or .trlc files containing the component requirements specifications as defined in the S-CORE process. - feature_requirement: Optional list of labels to feature_requirements - targets that these component requirements trace to. Establishes - bidirectional traceability as defined in the S-CORE process. visibility: Bazel visibility specification for the generated targets. Generated Targets: @@ -127,13 +118,11 @@ def component_requirements( component_requirements( name = "my_component_requirements", srcs = ["component_requirements.rst"], - feature_requirement = [":my_feature_requirements"], ) ``` """ _component_requirements( name = name, srcs = srcs, - feature_requirement = feature_requirement, visibility = visibility, ) diff --git a/bazel/rules/rules_score/private/dependable_element.bzl b/bazel/rules/rules_score/private/dependable_element.bzl index a5dd097..f193cc4 100644 --- a/bazel/rules/rules_score/private/dependable_element.bzl +++ b/bazel/rules/rules_score/private/dependable_element.bzl @@ -22,7 +22,6 @@ assumptions of use, requirements, design, and safety analysis. load( "//bazel/rules/rules_score:providers.bzl", - "DependableElementInfo", "SphinxSourcesInfo", ) load("//bazel/rules/rules_score/private:sphinx_module.bzl", "sphinx_module") @@ -250,6 +249,9 @@ def _process_deps(ctx): return "\n".join(links) +def _get_component_names(components): + return [c.label.name for c in components] + # ============================================================================ # Index Generation Rule Implementation # ============================================================================ @@ -271,9 +273,10 @@ def _dependable_element_index_impl(ctx): index_rst = ctx.actions.declare_file(ctx.label.name + "/index.rst") output_files = [index_rst] - # Define artifact types to process + # Define artifacts # Note: "requirements" can contain both component_requirements and feature_requirements artifact_types = [ + "components", "assumptions_of_use", "requirements", "architectural_design", @@ -294,6 +297,7 @@ def _dependable_element_index_impl(ctx): # Generate index file from template title = ctx.attr.module_name underline = "=" * len(title) + component_names = _get_component_names(ctx.attr.components) # Collect list of components ctx.actions.expand_template( template = ctx.file.template, @@ -302,6 +306,7 @@ def _dependable_element_index_impl(ctx): "{title}": title, "{underline}": underline, "{description}": ctx.attr.description, + "{components}": "\n- ".join(component_names), "{assumptions_of_use}": "\n ".join(artifacts_by_type["assumptions_of_use"]), "{component_requirements}": "\n ".join(artifacts_by_type["requirements"]), "{architectural_design}": "\n ".join(artifacts_by_type["architectural_design"]), @@ -343,6 +348,10 @@ _dependable_element_index = rule( mandatory = True, doc = "Dependability analysis targets or files.", ), + "components": attr.label_list( + default = [], + doc = "Safety checklists targets or files.", + ), "checklists": attr.label_list( default = [], doc = "Safety checklists targets or files.", @@ -359,91 +368,6 @@ _dependable_element_index = rule( }, ) -# ============================================================================ -# Provider Rule Implementation -# ============================================================================ - -def _dependable_element_provider_impl(ctx): - """Provide DependableElementInfo for a dependable element. - - This rule collects metadata about the dependable element and provides - it through the DependableElementInfo provider. - - Args: - ctx: Rule context - - Returns: - List of providers including DependableElementInfo and SphinxSourcesInfo - """ - - # Collect depsets for each artifact type - assumptions_depset = depset(ctx.files.assumptions_of_use) - requirements_depset = depset(ctx.files.requirements) - arch_design_depset = depset(ctx.files.architectural_design) - dep_analysis_depset = depset(ctx.files.dependability_analysis) - components_depset = depset(ctx.attr.components) - tests_depset = depset(ctx.attr.tests) - - # Collect all source files for Sphinx - all_files = depset( - direct = ctx.files.assumptions_of_use + - ctx.files.requirements + - ctx.files.architectural_design + - ctx.files.dependability_analysis, - ) - - return [ - DependableElementInfo( - name = ctx.label.name, - description = ctx.attr.description, - assumptions_of_use = assumptions_depset, - requirements = requirements_depset, - architectural_design = arch_design_depset, - dependability_analysis = dep_analysis_depset, - consists_of = components_depset, - tests = tests_depset, - ), - SphinxSourcesInfo( - srcs = all_files, - transitive_srcs = all_files, - ), - ] - -_dependable_element_provider = rule( - implementation = _dependable_element_provider_impl, - doc = "Provider rule for dependable element metadata", - attrs = { - "description": attr.string( - mandatory = True, - doc = "Description of the dependable element", - ), - "assumptions_of_use": attr.label_list( - mandatory = True, - doc = "Assumptions of Use targets or files", - ), - "requirements": attr.label_list( - mandatory = True, - doc = "Requirements targets", - ), - "architectural_design": attr.label_list( - mandatory = True, - doc = "Architectural design targets or files", - ), - "dependability_analysis": attr.label_list( - mandatory = True, - doc = "Dependability analysis targets or files", - ), - "components": attr.label_list( - default = [], - doc = "Component and/or unit targets that comprise this element", - ), - "tests": attr.label_list( - default = [], - doc = "Test targets", - ), - }, -) - # ============================================================================ # Public Macro # ============================================================================ @@ -499,49 +423,13 @@ def dependable_element( visibility: Bazel visibility specification for the dependable element target. Generated Targets: - _provider: Internal metadata provider with DependableElementInfo _index: Internal rule that generates index.rst and copies artifacts : Main dependable element target (sphinx_module) with HTML documentation - _needs: Internal target for sphinx-needs JSON generation - - Example: - ```python - dependable_element( - name = "persistency_kvs", - description = ''' - The Key-Value Store (KVS) component provides persistent storage capabilities - for safety-critical applications. - ''', - assumptions_of_use = [":kvs_assumptions_of_use"], - requirements = [":kvs_component_requirements"], - architectural_design = [":kvs_architectural_design"], - dependability_analysis = [":kvs_dependability_analysis"], - components = [":kvs_component", ":kvs_unit"], - tests = ["//persistency/kvs/tests:score_kvs_integration_tests"], - deps = [ - "@score_process//:score_process_module", - "@score_platform//:score_platform_module", - ], - visibility = ["//visibility:public"], - ) - ``` - """ + _needs: Sphinx-needs JSON target (created by sphinx_module for cross-referencing) - # Step 1: Create provider target with DependableElementInfo - _dependable_element_provider( - name = name + "_provider", - description = description, - assumptions_of_use = assumptions_of_use, - requirements = requirements, - architectural_design = architectural_design, - dependability_analysis = dependability_analysis, - components = components, - tests = tests, - testonly = testonly, - visibility = ["//visibility:private"], - ) + """ - # Step 2: Generate index.rst and collect all artifacts + # Step 1: Generate index.rst and collect all artifacts _dependable_element_index( name = name + "_index", module_name = name, @@ -549,6 +437,7 @@ def dependable_element( template = Label("//bazel/rules/rules_score:templates/seooc_index.template.rst"), assumptions_of_use = assumptions_of_use, requirements = requirements, + components = components, architectural_design = architectural_design, dependability_analysis = dependability_analysis, checklists = checklists, @@ -557,7 +446,7 @@ def dependable_element( visibility = ["//visibility:private"], ) - # Step 3: Create sphinx_module using generated index and artifacts + # Step 2: Create sphinx_module using generated index and artifacts sphinx_module( name = name, srcs = [":" + name + "_index"], diff --git a/bazel/rules/rules_score/providers.bzl b/bazel/rules/rules_score/providers.bzl index d4d8746..1331f6e 100644 --- a/bazel/rules/rules_score/providers.bzl +++ b/bazel/rules/rules_score/providers.bzl @@ -52,21 +52,7 @@ ComponentInfo = provider( "name": "Name of the component target", "requirements": "Depset of component requirements artifacts", "implementation": "Depset of implementation targets (libraries, binaries)", - "units": "Depset of unit targets that comprise this component", + "components": "Depset of unit targets that comprise this component", "tests": "Depset of component-level integration test targets", }, ) - -DependableElementInfo = provider( - doc = "Provider for dependable element (SEooC) artifacts", - fields = { - "name": "Name of the dependable element target", - "description": "Description of the dependable element", - "assumptions_of_use": "Depset of assumptions of use artifacts", - "requirements": "Depset of requirements artifacts (safety and feature requirements)", - "architectural_design": "Depset of architectural design artifacts", - "dependability_analysis": "Depset of dependability analysis artifacts", - "consists_of": "Depset of component/unit targets that comprise this element", - "tests": "Depset of system-level integration test targets", - }, -) diff --git a/bazel/rules/rules_score/rules_score.bzl b/bazel/rules/rules_score/rules_score.bzl index 907b4fa..7084744 100644 --- a/bazel/rules/rules_score/rules_score.bzl +++ b/bazel/rules/rules_score/rules_score.bzl @@ -3,7 +3,6 @@ load("@rules_python//sphinxdocs:sphinx_docs_library.bzl", "sphinx_docs_library") load( "//bazel/rules/rules_score:providers.bzl", _ComponentInfo = "ComponentInfo", - _DependableElementInfo = "DependableElementInfo", _SphinxSourcesInfo = "SphinxSourcesInfo", _UnitInfo = "UnitInfo", ) @@ -61,4 +60,3 @@ dependable_element = _dependable_element SphinxSourcesInfo = _SphinxSourcesInfo UnitInfo = _UnitInfo ComponentInfo = _ComponentInfo -DependableElementInfo = _DependableElementInfo diff --git a/bazel/rules/rules_score/templates/seooc_index.template.rst b/bazel/rules/rules_score/templates/seooc_index.template.rst index c545f32..c833b7b 100644 --- a/bazel/rules/rules_score/templates/seooc_index.template.rst +++ b/bazel/rules/rules_score/templates/seooc_index.template.rst @@ -11,8 +11,8 @@ .. SPDX-License-Identifier: Apache-2.0 .. ******************************************************************************* -{title} -{underline} +Dependable element: {title} +===================={underline} {description} @@ -24,13 +24,10 @@ Assumptions of Use {assumptions_of_use} -Component Requirements ----------------------- - -.. toctree:: - :maxdepth: 2 +Components +---------- - {component_requirements} +{components} Architectural Design -------------------- diff --git a/bazel/rules/rules_score/test/BUILD b/bazel/rules/rules_score/test/BUILD index 9317b62..f81b2cf 100644 --- a/bazel/rules/rules_score/test/BUILD +++ b/bazel/rules/rules_score/test/BUILD @@ -40,8 +40,6 @@ load( ":unit_component_test.bzl", "component_provider_test", "component_sphinx_sources_test", - "dependable_element_provider_test", - "dependable_element_sphinx_sources_test", "unit_component_test_suite", "unit_provider_test", "unit_sphinx_sources_test", @@ -97,7 +95,6 @@ feature_requirements( component_requirements( name = "comp_req", srcs = ["fixtures/seooc_test/component_requirements.rst"], - feature_requirement = [":feat_req"], ) # - Assumptions of Use: wp__requirements_comp_aou @@ -197,9 +194,9 @@ unit( component( name = "test_component", testonly = True, + components = [":test_unit"], requirements = [":comp_req"], tests = [], # Empty for testing - units = [":test_unit"], implementation = [":test_component_binary"], ) @@ -302,17 +299,6 @@ component_sphinx_sources_test( target_under_test = ":test_component", ) -# Dependable Element tests -dependable_element_provider_test( - name = "dependable_element_provider_test", - target_under_test = ":test_dependable_element_provider", -) - -dependable_element_sphinx_sources_test( - name = "dependable_element_sphinx_sources_test", - target_under_test = ":test_dependable_element_provider", -) - # Unit, Component, and Dependable Element test suite unit_component_test_suite(name = "unit_component_tests") diff --git a/bazel/rules/rules_score/test/unit_component_test.bzl b/bazel/rules/rules_score/test/unit_component_test.bzl index b756856..f62f4b8 100644 --- a/bazel/rules/rules_score/test/unit_component_test.bzl +++ b/bazel/rules/rules_score/test/unit_component_test.bzl @@ -20,7 +20,7 @@ Tests the new hierarchical structure for S-CORE process compliance: """ load("@bazel_skylib//lib:unittest.bzl", "analysistest", "asserts") -load("//bazel/rules/rules_score:providers.bzl", "ComponentInfo", "DependableElementInfo", "SphinxSourcesInfo", "UnitInfo") +load("//bazel/rules/rules_score:providers.bzl", "ComponentInfo", "SphinxSourcesInfo", "UnitInfo") # ============================================================================ # Unit Tests @@ -118,8 +118,8 @@ def _component_provider_test_impl(ctx): asserts.true( env, - comp_info.units != None, - "ComponentInfo should have units field", + comp_info.components != None, + "ComponentInfo should have components field", ) asserts.true( @@ -151,89 +151,8 @@ component_sphinx_sources_test = analysistest.make(_component_sphinx_sources_test # ============================================================================ # Dependable Element Tests # ============================================================================ - -def _dependable_element_provider_test_impl(ctx): - """Test that dependable_element rule provides DependableElementInfo.""" - env = analysistest.begin(ctx) - target_under_test = analysistest.target_under_test(env) - - # Check DependableElementInfo provider exists - asserts.true( - env, - DependableElementInfo in target_under_test, - "Dependable element should provide DependableElementInfo", - ) - - de_info = target_under_test[DependableElementInfo] - - # Verify fields are populated - asserts.true( - env, - de_info.name != None, - "DependableElementInfo should have name field", - ) - - asserts.true( - env, - de_info.description != None, - "DependableElementInfo should have description field", - ) - - asserts.true( - env, - de_info.assumptions_of_use != None, - "DependableElementInfo should have assumptions_of_use field", - ) - - asserts.true( - env, - de_info.requirements != None, - "DependableElementInfo should have requirements field", - ) - - asserts.true( - env, - de_info.architectural_design != None, - "DependableElementInfo should have architectural_design field", - ) - - asserts.true( - env, - de_info.dependability_analysis != None, - "DependableElementInfo should have dependability_analysis field", - ) - - asserts.true( - env, - de_info.consists_of != None, - "DependableElementInfo should have consists_of field", - ) - - asserts.true( - env, - de_info.tests != None, - "DependableElementInfo should have tests field", - ) - - return analysistest.end(env) - -dependable_element_provider_test = analysistest.make(_dependable_element_provider_test_impl) - -def _dependable_element_sphinx_sources_test_impl(ctx): - """Test that dependable_element rule provides SphinxSourcesInfo.""" - env = analysistest.begin(ctx) - target_under_test = analysistest.target_under_test(env) - - # Check SphinxSourcesInfo provider exists - asserts.true( - env, - SphinxSourcesInfo in target_under_test, - "Dependable element should provide SphinxSourcesInfo", - ) - - return analysistest.end(env) - -dependable_element_sphinx_sources_test = analysistest.make(_dependable_element_sphinx_sources_test_impl) +# Note: Provider tests removed as dependable_element no longer creates a +# separate provider target. The main target is now a sphinx_module. # ============================================================================ # Test Suite Definition @@ -252,7 +171,5 @@ def unit_component_test_suite(name): ":unit_sphinx_sources_test", ":component_provider_test", ":component_sphinx_sources_test", - ":dependable_element_provider_test", - ":dependable_element_sphinx_sources_test", ], )