improve --include-tags and --exclude-tags

Author: jochen-testingbot

src/providers/maestro.ts

@@ -549,6 +549,14 @@ export default class Maestro extends BaseProvider<MaestroOptions> {
       }
     }
 
+    // Apply --include-tags / --exclude-tags filtering: drop flow files whose
+    // frontmatter tags don't match, and drop dependencies orphaned as a result.
+    const filtered = await this.filterFlowsByTags(allFlowFiles, baseDir);
+    if (filtered !== allFlowFiles) {
+      allFlowFiles.length = 0;
+      allFlowFiles.push(...filtered);
+    }
+
     if (!this.options.quiet) {
       this.logIncludedFiles(allFlowFiles, baseDir);
 
@@ -751,6 +759,85 @@ export default class Maestro extends BaseProvider<MaestroOptions> {
     return basename === 'config.yaml' || basename === 'config.yml';
   }
 
+  private async readFlowTags(flowFile: string): Promise<string[]> {
+    try {
+      const content = await fs.promises.readFile(flowFile, 'utf-8');
+      const documents: unknown[] = [];
+      yaml.loadAll(content, (doc) => documents.push(doc));
+      for (const doc of documents) {
+        if (doc !== null && typeof doc === 'object' && !Array.isArray(doc)) {
+          const tags = (doc as Record<string, unknown>).tags;
+          if (Array.isArray(tags)) {
+            return tags.filter((t): t is string => typeof t === 'string');
+          }
+          return [];
+        }
+      }
+    } catch {
+      // ignore
+    }
+    return [];
+  }
+
+  private async filterFlowsByTags(
+    allFlowFiles: string[],
+    baseDir: string | undefined,
+  ): Promise<string[]> {
+    const includeTags = this.options.includeTags ?? [];
+    const excludeTags = this.options.excludeTags ?? [];
+    const hasInclude = includeTags.length > 0;
+    const hasExclude = excludeTags.length > 0;
+    if (!hasInclude && !hasExclude) {
+      return allFlowFiles;
+    }
+
+    const yamlFlows: string[] = [];
+    const configFiles: string[] = [];
+    for (const f of allFlowFiles) {
+      const ext = path.extname(f).toLowerCase();
+      if (ext === '.yaml' || ext === '.yml') {
+        if (this.isConfigFile(f)) {
+          configFiles.push(f);
+        } else {
+          yamlFlows.push(f);
+        }
+      }
+    }
+
+    const keptYamlFlows: string[] = [];
+    for (const flowFile of yamlFlows) {
+      const tags = await this.readFlowTags(flowFile);
+      if (hasInclude && !tags.some((t) => includeTags.includes(t))) {
+        continue;
+      }
+      if (hasExclude && tags.some((t) => excludeTags.includes(t))) {
+        continue;
+      }
+      keptYamlFlows.push(flowFile);
+    }
+
+    if (keptYamlFlows.length === 0) {
+      throw new TestingBotError(
+        `No flow files match the provided tag filters (--include-tags / --exclude-tags)`,
+      );
+    }
+
+    const keptResolved = new Set<string>(
+      [...keptYamlFlows, ...configFiles].map((f) => path.resolve(f)),
+    );
+    for (const flowFile of keptYamlFlows) {
+      const deps = await this.discoverDependencies(
+        flowFile,
+        baseDir || path.dirname(flowFile),
+      );
+      for (const dep of deps) {
+        keptResolved.add(path.resolve(dep));
+      }
+    }
+
+    return allFlowFiles.filter((f) => keptResolved.has(path.resolve(f)));
+  }
+
   /**
    * Check if a string looks like a file path (relative path with extension)
    */

tests/providers/maestro.test.ts

@@ -3006,6 +3006,115 @@ flows:
     });
   });
 
+  describe('filterFlowsByTags', () => {
+    const projectDir = path.resolve(path.sep, 'project');
+    const smokeFlow = path.join(projectDir, 'smoke.yaml');
+    const flakyFlow = path.join(projectDir, 'flaky.yaml');
+    const untaggedFlow = path.join(projectDir, 'untagged.yaml');
+    const configFile = path.join(projectDir, 'config.yaml');
+    const helperScript = path.join(projectDir, 'helper.js');
+    const orphanScript = path.join(projectDir, 'orphan.js');
+    const flowWithDep = path.join(projectDir, 'with-dep.yaml');
+    const flowWithOrphanDep = path.join(projectDir, 'with-orphan.yaml');
+
+    const fileContents: Record<string, string> = {
+      [smokeFlow]: `appId: com.example\ntags:\n  - smoke\n---\n- launchApp`,
+      [flakyFlow]: `appId: com.example\ntags:\n  - flaky\n---\n- launchApp`,
+      [untaggedFlow]: `appId: com.example\n---\n- launchApp`,
+      [configFile]: `flows:\n  - "*.yaml"`,
+      [flowWithDep]: `appId: com.example\ntags:\n  - smoke\n---\n- runScript: helper.js`,
+      [flowWithOrphanDep]: `appId: com.example\ntags:\n  - flaky\n---\n- runScript: orphan.js`,
+    };
+
+    const buildMaestro = (
+      includeTags?: string[],
+      excludeTags?: string[],
+    ): Maestro => {
+      const opts = new MaestroOptions(
+        'app.apk',
+        path.join(projectDir, 'smoke.yaml'),
+        'Pixel 6',
+        { includeTags, excludeTags, quiet: true },
+      );
+      return new Maestro(mockCredentials, opts);
+    };
+
+    beforeEach(() => {
+      fs.promises.readFile = jest
+        .fn()
+        .mockImplementation((p: string) =>
+          fileContents[p] !== undefined
+            ? Promise.resolve(fileContents[p])
+            : Promise.reject(new Error(`ENOENT: ${p}`)),
+        );
+      fs.promises.access = jest.fn().mockResolvedValue(undefined);
+    });
+
+    it('returns input unchanged when no tag filters are set', async () => {
+      const m = buildMaestro();
+      const input = [smokeFlow, flakyFlow, untaggedFlow];
+      const result = await m['filterFlowsByTags'](input, projectDir);
+      expect(result).toBe(input);
+    });
+
+    it('keeps only flows matching --include-tags', async () => {
+      const m = buildMaestro(['smoke']);
+      const result = await m['filterFlowsByTags'](
+        [smokeFlow, flakyFlow, untaggedFlow],
+        projectDir,
+      );
+      expect(result).toEqual([smokeFlow]);
+    });
+
+    it('drops flows matching --exclude-tags', async () => {
+      const m = buildMaestro(undefined, ['flaky']);
+      const result = await m['filterFlowsByTags'](
+        [smokeFlow, flakyFlow, untaggedFlow],
+        projectDir,
+      );
+      expect(result).toEqual([smokeFlow, untaggedFlow]);
+    });
+
+    it('combines --include-tags and --exclude-tags', async () => {
+      const m = buildMaestro(['smoke'], ['flaky']);
+      const result = await m['filterFlowsByTags'](
+        [smokeFlow, flakyFlow, untaggedFlow],
+        projectDir,
+      );
+      expect(result).toEqual([smokeFlow]);
+    });
+
+    it('always preserves config files', async () => {
+      const m = buildMaestro(['smoke']);
+      const result = await m['filterFlowsByTags'](
+        [smokeFlow, flakyFlow, configFile],
+        projectDir,
+      );
+      expect(result).toContain(configFile);
+      expect(result).toContain(smokeFlow);
+      expect(result).not.toContain(flakyFlow);
+    });
+
+    it('drops dependencies orphaned by filtered-out flows', async () => {
+      const m = buildMaestro(['smoke']);
+      const result = await m['filterFlowsByTags'](
+        [flowWithDep, flowWithOrphanDep, helperScript, orphanScript],
+        projectDir,
+      );
+      expect(result).toContain(flowWithDep);
+      expect(result).toContain(helperScript);
+      expect(result).not.toContain(flowWithOrphanDep);
+      expect(result).not.toContain(orphanScript);
+    });
+
+    it('throws TestingBotError when no flows match the filters', async () => {
+      const m = buildMaestro(['nonexistent']);
+      await expect(
+        m['filterFlowsByTags']([smokeFlow, flakyFlow], projectDir),
+      ).rejects.toThrow(TestingBotError);
+    });
+  });
+
   describe('Flow Status Display', () => {
     describe('getFlowStatusDisplay', () => {
       it('should return white WAITING for WAITING status', () => {