Merge V2.15-develop into main

.gitignore

@@ -4,6 +4,7 @@ htmlcov
 __pycache__
 app.egg-info
 logs
+admin_storage.json
 /docker-stack.yml
 .DS_Store
 app/chip-tool/chip-tool
@@ -13,4 +14,7 @@ SerialTests.lock
 test_db_creation.lock
 .sha_information
 test_collections/matter/sdk_tests/sdk_checkout
-performance-logs
+performance-logs
+output_logs/
+test_collections/matter/sdk_tests/custom_python_tests_info.json
+test_collections/matter/sdk_tests/python_tests_info.json

.version_information

@@ -1 +1 @@
-v2.11+fall2024
+v2.15+spring2026

Dockerfile

@@ -62,7 +62,7 @@ RUN curl -sSL https://install.python-poetry.org | python3 - && \
 RUN curl -sSL https://get.docker.com/ | sh
 
 # Install nodejs, npm and spell checker
-RUN curl -sL https://deb.nodesource.com/setup_18.x | bash -
+RUN curl -sL https://deb.nodesource.com/setup_20.x | bash -
 RUN apt-get install -y nodejs
 RUN npm install -g npm@latest
 RUN npm install -g cspell@latest

alembic/versions/a16c8c20cd36_add_execution_pics_to_test_run_execution.py

@@ -0,0 +1,32 @@
+"""add execution_pics to test_run_execution
+
+Revision ID: a16c8c20cd36
+Revises: e6153267b741
+Create Date: 2026-04-08 17:41:21.198510
+
+"""
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "a16c8c20cd36"
+down_revision = "e6153267b741"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # Add execution_pics column to testrunexecution table (optional JSON)
+    op.add_column(
+        "testrunexecution",
+        sa.Column(
+            "execution_pics", postgresql.JSON(astext_type=sa.Text()), nullable=True
+        ),
+    )
+
+
+def downgrade():
+    # Remove execution_pics column
+    op.drop_column("testrunexecution", "execution_pics")

alembic/versions/e6153267b741_add_execution_config_to_test_run_execution.py

@@ -0,0 +1,32 @@
+"""add execution_config to test_run_execution
+
+Revision ID: e6153267b741
+Revises: 0a251edfd975
+Create Date: 2026-01-15 17:36:00.000000
+
+"""
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "e6153267b741"
+down_revision = "0a251edfd975"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # Add execution_config column to testrunexecution table (optional JSON)
+    op.add_column(
+        "testrunexecution",
+        sa.Column(
+            "execution_config", postgresql.JSON(astext_type=sa.Text()), nullable=True
+        ),
+    )
+
+
+def downgrade():
+    # Remove execution_config column
+    op.drop_column("testrunexecution", "execution_config")

app/api/api_v1/endpoints/projects.py

@@ -13,10 +13,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+import json
+import traceback
 from http import HTTPStatus
 from typing import List, Sequence, Union
 
 from fastapi import APIRouter, Depends, File, HTTPException, Request, UploadFile
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import JSONResponse
+from loguru import logger
+from pydantic import ValidationError, parse_obj_as
 from sqlalchemy.orm import Session
 from sqlalchemy.orm.attributes import flag_modified
 
@@ -25,11 +31,16 @@
 from app.default_environment_config import default_environment_config
 from app.models.project import Project
 from app.pics.pics_parser import PICSParser
-from app.pics_applicable_test_cases import applicable_test_cases_list
+from app.pics_applicable_test_cases import applicable_test_cases_set
 from app.schemas.pics import PICSError
 from app.schemas.project import Project as Proj
 from app.schemas.test_environment_config import TestEnvironmentConfigError
-from app.utils import TEST_ENVIRONMENT_CONFIG_NAME
+from app.utils import (
+    DMP_TEST_SKIP_CONFIG_NODE,
+    DMP_TEST_SKIP_FILENAME,
+    TEST_ENVIRONMENT_CONFIG_NAME,
+    parse_dmp_file,
+)
 
 router = APIRouter()
 
@@ -222,32 +233,66 @@ def unarchive_project(
     return crud.project.unarchive(db=db, db_obj=__project(db=db, id=id))
 
 
+def __upload_pics(file: UploadFile, db: Session, project: Project) -> Project:
+    cluster = PICSParser.parse(file=file.file)
+
+    project.pics.clusters[cluster.name] = cluster
+
+    return __persist_update_not_mutable(db=db, project=project, field="pics")
+
+
+def __persist_dmp_test_skip(file: UploadFile, db: Session, project: Project) -> Project:
+    try:
+        skip_test_list = parse_dmp_file(xml_file=file.file)
+        project.config[DMP_TEST_SKIP_CONFIG_NODE] = skip_test_list
+
+        return __persist_update_not_mutable(db=db, project=project, field="config")
+    except Exception:
+        logger.error(traceback.format_exc())
+        raise HTTPException(
+            status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
+            detail=f"Not able to parse {file.filename} file",
+        )
+
+
 @router.put("/{id}/upload_pics", response_model=schemas.Project)
-def upload_pics(
+async def upload_pics(
     *,
     db: Session = Depends(get_db),
     file: UploadFile = File(...),
     id: int,
 ) -> models.Project:
-    """Upload PICS file of a project based on project identifier.
+    """Upload PICS or dmp-test-skip.xml file of a project based on project identifier.
 
     Args:
         id (int): project id
-        file : the PICS file to upload
+        file : the PICS or dmp-test-skip.xml file to upload
 
     Raises:
         HTTPException: if no project exists for provided project id (or)
                        if the PICS file is invalid
 
     Returns:
-        Project: project record that was updated with the PICS information
+        Project: project record that was updated with the PICS and dmp_test_skip
+        information.
     """
-    cluster = PICSParser.parse(file=file.file)
-
     project = __project(db=db, id=id)
-    project.pics.clusters[cluster.name] = cluster
 
-    return __persist_pics_update(db=db, project=project)
+    try:
+        if file and file.filename and file.filename.startswith(DMP_TEST_SKIP_FILENAME):
+            return __persist_dmp_test_skip(file=file, db=db, project=project)
+        else:
+            return __upload_pics(file=file, db=db, project=project)
+    except PICSError as e:
+        raise HTTPException(
+            status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
+            detail=str(e),
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
+            detail=f"Not able to parse {file.filename} file: {str(e)}",
+        )
 
 
 @router.delete("/{id}/pics_cluster_type", response_model=schemas.Project)
@@ -277,7 +322,7 @@ def remove_pics_cluster_type(
     # delete the PICS cluster.
     del project.pics.clusters[cluster_name]
 
-    return __persist_pics_update(db=db, project=project)
+    return __persist_update_not_mutable(db=db, project=project, field="pics")
 
 
 @router.get(
@@ -303,7 +348,19 @@ def applicable_test_cases(
 
     project_data = Proj.from_orm(project)
 
-    return applicable_test_cases_list(pics=project_data.pics)
+    try:
+        return applicable_test_cases_set(
+            pics=project_data.pics,
+            dmp_test_skip=project_data.config.get(  # type: ignore
+                DMP_TEST_SKIP_CONFIG_NODE, []
+            ),
+        )
+    except Exception as e:
+        logger.error(f"Error getting applicable test cases: {str(e)}")
+        raise HTTPException(
+            status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
+            detail=f"Error getting applicable test cases: {str(e)}",
+        )
 
 
 def __project(db: Session, id: int) -> Project:
@@ -315,16 +372,91 @@ def __project(db: Session, id: int) -> Project:
     return project
 
 
-def __persist_pics_update(db: Session, project: Project) -> Project:
-    """Update Project PICS in DB.
+def __persist_update_not_mutable(db: Session, project: Project, field: str) -> Project:
+    """Update Project JSON fields in DB.
 
-    project.pics is stored in a JSON column mapped to PICS schema, this column is
-    not Mutable, so SQLAlchemy doesn't know when PICS changed.
+    Project contains JSON columns (like 'pics' and 'config') mapped to their respective
+    schemas.
+    These columns are not Mutable by default, so SQLAlchemy doesn't track changes
+    to their content.
 
-    Using `flag_modified` marks the property, so SQLAlchemy will update the field on
-    commit.
+    Using `flag_modified` explicitly marks the JSON property as changed, ensuring
+    SQLAlchemy will update the field on commit. This is necessary for any nested
+    modifications to JSON column data.
     """
-    flag_modified(project, "pics")
+
+    flag_modified(project, field)
     db.commit()
     db.refresh(project)
     return project
+
+
+@router.get("/{id}/export", response_model=schemas.ProjectCreate)
+def export_project_config(
+    *,
+    db: Session = Depends(get_db),
+    id: int,
+) -> JSONResponse:
+    """
+    Exports the project config by id.
+
+    Args:
+        id (int): project id
+
+    Raises:
+        HTTPException: if no project exists for provided project id
+
+    Returns:
+        JSONResponse: json representation of the project with the informed project id
+    """
+    # Retrieve project by project_id using schemas.ProjectCreate schema
+    project = schemas.ProjectCreate(**__project(db=db, id=id).__dict__)
+
+    options: dict = {"media_type": "application/json"}
+    filename = f"{project.name}-project-config.json"
+    options["headers"] = {"Content-Disposition": f'attachment; filename="{filename}"'}
+
+    return JSONResponse(
+        jsonable_encoder(project),
+        **options,
+    )
+
+
+@router.post("/import", response_model=schemas.Project)
+def importproject_config(
+    *,
+    db: Session = Depends(get_db),
+    import_file: UploadFile = File(...),
+) -> models.Project:
+    """
+    Imports the project config
+
+    Args:
+        import_file : The project config file to be imported
+
+    Raises:
+        ValidationError: if the imported project config contains invalid information
+
+    Returns:
+        Project: newly created project record
+    """
+
+    file_content = import_file.file.read().decode("utf-8")
+    file_dict = json.loads(file_content)
+
+    try:
+        imported_project: schemas.ProjectCreate = parse_obj_as(
+            schemas.ProjectCreate, file_dict
+        )
+    except ValidationError as error:
+        raise HTTPException(
+            status_code=HTTPStatus.UNPROCESSABLE_ENTITY, detail=str(error)
+        )
+
+    try:
+        return crud.project.create(db=db, obj_in=imported_project)
+    except TestEnvironmentConfigError as e:
+        raise HTTPException(
+            status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
+            detail=str(e),
+        )