Support composable template without top-level template

esrally/track/params.py

@@ -441,12 +441,15 @@ def __init__(self, track, params, templates, **kwargs):
         elif templates:
             filter_template = params.get("template")
             settings = params.get("settings")
+            template_definitions = []
             for template in templates:
                 if not filter_template or template.name == filter_template:
-                    body = template.content
-                    if body and "template" in body:
-                        body = CreateComposableTemplateParamSource._create_or_merge(template.content, ["template", "settings"], settings)
-                        self.template_definitions.append((template.name, body))
+                    body = self._create_or_merge(template.content, ["template", "settings"], settings)
+                    template_definitions.append((template.name, body))
+            if filter_template and not template_definitions:
+                template_names = ", ".join([template.name for template in templates])
+                raise exceptions.InvalidSyntax(f"Unknown template: {filter_template}. Available templates: {template_names}.")
+            self.template_definitions.extend(template_definitions)
         else:
             raise exceptions.InvalidSyntax(
                 "Please set the properties 'template' and 'body' for the "

tests/track/params_test.py

@@ -2138,6 +2138,56 @@ def test_create_composable_index_template_from_track(self):
             "composed_of": ["ct1", "ct2"],
         }
 
+    def test_create_composable_index_template_from_track_wrong_filter(self):
+        t1 = track.IndexTemplate(
+            name="t1",
+            content={},
+            pattern="",
+        )
+        t2 = track.IndexTemplate(
+            name="t2",
+            content={},
+            pattern="",
+        )
+
+        with pytest.raises(exceptions.InvalidSyntax) as exc:
+            params.CreateComposableTemplateParamSource(
+                track=track.Track(name="unit-test", composable_templates=[t1, t2]),
+                params={
+                    "template": "t3",
+                },
+            )
+        assert exc.value.args[0] == ("Unknown template: t3. Available templates: t1, t2.")
+
+    def test_create_composable_index_template_from_track_no_template(self):
+        tpl = track.IndexTemplate(
+            name="default",
+            pattern="*",
+            content={
+                "index_patterns": ["my*"],
+                "composed_of": ["ct1", "ct2"],
+            },
+        )
+
+        source = params.CreateComposableTemplateParamSource(
+            track=track.Track(name="unit-test", composable_templates=[tpl]),
+            params={
+                "settings": {"index.number_of_replicas": 1},
+            },
+        )
+
+        p = source.params()
+
+        assert len(p["templates"]) == 1
+        assert p["request-params"] == {}
+        template, body = p["templates"][0]
+        assert template == "default"
+        assert body == {
+            "index_patterns": ["my*"],
+            "template": {"settings": {"index.number_of_replicas": 1}},
+            "composed_of": ["ct1", "ct2"],
+        }
+
     def test_create_or_merge(self):
         content = params.CreateComposableTemplateParamSource._create_or_merge(
             {"parent": {}},
@@ -2270,6 +2320,25 @@ def test_create_component_index_template_from_track(self):
             }
         }
 
+    def test_create_component_index_template_from_track_wrong_filter(self):
+        t1 = track.ComponentTemplate(
+            name="t1",
+            content={},
+        )
+        t2 = track.ComponentTemplate(
+            name="t2",
+            content={},
+        )
+
+        with pytest.raises(exceptions.InvalidSyntax) as exc:
+            params.CreateComponentTemplateParamSource(
+                track=track.Track(name="unit-test", component_templates=[t1, t2]),
+                params={
+                    "template": "t3",
+                },
+            )
+        assert exc.value.args[0] == ("Unknown template: t3. Available templates: t1, t2.")
+
 
 class TestDeleteComponentTemplateParamSource:
     def test_delete_component_template_by_name(self):