sdd-full 4.6.2 → 4.8.0

package/skills/flutter-skills/tool/generator/test/services/resource_fetcher_service_test.dart

@@ -0,0 +1,188 @@
+// Copyright (c) 2026, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:io' as io;
+
+import 'package:http/http.dart' as http;
+import 'package:http/testing.dart';
+import 'package:logging/logging.dart';
+import 'package:path/path.dart' as p;
+
+import 'package:skills/src/services/resource_fetcher_service.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('ResourceFetcherService', () {
+    late Logger logger;
+
+    setUp(() {
+      logger = Logger('test');
+    });
+
+    test('fetches and converts content successfully on 200 OK', () async {
+      final client = MockClient((request) async {
+        if (request.url.toString() == 'https://example.com/doc1') {
+          return http.Response('<h1>Doc 1</h1>', 200);
+        } else if (request.url.toString() == 'https://example.com/doc2') {
+          return http.Response('<p>Doc 2 content</p>', 200);
+        }
+        return http.Response('Not found', 404);
+      });
+
+      final fetcher = ResourceFetcherService(
+        httpClient: client,
+        logger: logger,
+      );
+
+      final result = await fetcher.fetchAndConvertContent([
+        'https://example.com/doc1',
+        'https://example.com/doc2',
+      ]);
+
+      expect(result, contains('Doc 1'));
+      expect(result, contains('Doc 2 content'));
+    });
+
+    test('throws Exception on non-200 status code to save tokens', () async {
+      final client = MockClient((request) async {
+        return http.Response('Not found', 404);
+      });
+
+      final fetcher = ResourceFetcherService(
+        httpClient: client,
+        logger: logger,
+      );
+
+      expect(
+        () => fetcher.fetchAndConvertContent(['https://example.com/missing']),
+        throwsA(
+          isA<Exception>().having(
+            (e) => e.toString(),
+            'message',
+            contains('HTTP 404'),
+          ),
+        ),
+      );
+    });
+
+    test('throws exception on network error to save tokens', () async {
+      final client = MockClient((request) async {
+        throw http.ClientException('Connection failed');
+      });
+
+      final fetcher = ResourceFetcherService(
+        httpClient: client,
+        logger: logger,
+      );
+
+      expect(
+        () => fetcher.fetchAndConvertContent(['https://example.com/error']),
+        throwsA(isA<http.ClientException>()),
+      );
+    });
+
+    test('throws Exception for insecure http:// URL', () async {
+      final client = MockClient((request) async {
+        return http.Response('content', 200);
+      });
+
+      final fetcher = ResourceFetcherService(
+        httpClient: client,
+        logger: logger,
+      );
+
+      expect(
+        () => fetcher.fetchAndConvertContent(['http://example.com/doc1']),
+        throwsA(
+          isA<Exception>().having(
+            (e) => e.toString(),
+            'message',
+            contains('Insecure HTTP URL found'),
+          ),
+        ),
+      );
+    });
+
+    test('fetches local file correctly relative to configDir', () async {
+      final tempDir = io.Directory.systemTemp.createTempSync('gemini_test');
+      try {
+        io.File(
+          p.join(tempDir.path, 'local_doc.md'),
+        ).writeAsStringSync('# Local Doc\ncontent');
+
+        final client = MockClient((request) async {
+          return http.Response('Not found', 404);
+        });
+
+        final fetcher = ResourceFetcherService(
+          httpClient: client,
+          logger: logger,
+        );
+
+        final result = await fetcher.fetchAndConvertContent([
+          'local_doc.md',
+        ], configDir: tempDir);
+
+        expect(result, contains('Local Doc'));
+        expect(result, contains('content'));
+      } finally {
+        tempDir.deleteSync(recursive: true);
+      }
+    });
+
+    test('throws Exception for missing local file', () async {
+      final tempDir = io.Directory.systemTemp.createTempSync('gemini_test');
+      try {
+        final client = MockClient((request) async {
+          return http.Response('Not found', 404);
+        });
+
+        final fetcher = ResourceFetcherService(
+          httpClient: client,
+          logger: logger,
+        );
+
+        expect(
+          () => fetcher.fetchAndConvertContent([
+            'missing.md',
+          ], configDir: tempDir),
+          throwsA(
+            isA<Exception>().having(
+              (e) => e.toString(),
+              'message',
+              contains('Local resource file not found'),
+            ),
+          ),
+        );
+      } finally {
+        tempDir.deleteSync(recursive: true);
+      }
+    });
+
+    test(
+      'throws Exception for local file when no configDir is provided',
+      () async {
+        final client = MockClient((request) async {
+          return http.Response('Not found', 404);
+        });
+
+        final fetcher = ResourceFetcherService(
+          httpClient: client,
+          logger: logger,
+        );
+
+        expect(
+          () => fetcher.fetchAndConvertContent(['local_doc.md']),
+          throwsA(
+            isA<Exception>().having(
+              (e) => e.toString(),
+              'message',
+              contains('no configuration directory was provided to resolve it'),
+            ),
+          ),
+        );
+      },
+    );
+  });
+}

package/skills/flutter-skills/tool/generator/test/update_skills_test.dart

@@ -0,0 +1,241 @@
+// Copyright (c) 2026, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:args/command_runner.dart';
+import 'package:http/http.dart' as http;
+import 'package:http/testing.dart';
+import 'package:logging/logging.dart';
+import 'package:path/path.dart' as p;
+import 'package:skills/src/commands/update_skill_command.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('UpdateSkillCommand', () {
+    late CommandRunner<void> runner;
+    late Directory tempDir;
+    late File inputYamlFile;
+
+    setUp(() async {
+      tempDir = await Directory.systemTemp.createTemp('skills_update_test');
+      inputYamlFile = File(p.join(tempDir.path, 'dart_dev.yaml'));
+      runner = CommandRunner<void>('skills', 'Test runner');
+    });
+
+    tearDown(() async {
+      await tempDir.delete(recursive: true);
+    });
+
+    test('updates skill from YAML input preserving existing content', () async {
+      final inputData = [
+        {
+          'name': 'foo',
+          'description': 'Foo description',
+          'resources': ['https://example.com/foo.html'],
+        },
+      ];
+      inputYamlFile.writeAsStringSync(jsonEncode(inputData));
+
+      // Create existing skill
+      final skillDirFoo = Directory(p.join(tempDir.path, 'foo'))..createSync();
+      final skillFile = File(p.join(skillDirFoo.path, 'SKILL.md'))
+        ..writeAsStringSync('# Existing Content\n');
+
+      final geminiRequests = <String>[];
+      // Mock HTTP Client
+      final mockClient = MockClient((request) async {
+        final url = request.url.toString();
+
+        // 1. Mock content fetch
+        if (url.startsWith('https://example.com')) {
+          return http.Response(
+            '<html><body><h1>New Content</h1></body></html>',
+            200,
+          );
+        }
+
+        // 2. Mock Gemini API
+        if (url.contains('generativelanguage.googleapis.com')) {
+          geminiRequests.add(request.body);
+          return http.Response(
+            jsonEncode({
+              'candidates': [
+                {
+                  'content': {
+                    'parts': [
+                      {'text': 'Updated Content with # Existing Content'},
+                    ],
+                  },
+                },
+              ],
+            }),
+            200,
+          );
+        }
+
+        return http.Response('Not Found', 404);
+      });
+
+      final command = UpdateSkillCommand(
+        environment: {'GEMINI_API_KEY': 'test-key'},
+        httpClient: mockClient,
+        outputDir: tempDir,
+      );
+      runner.addCommand(command);
+
+      // Run command
+      await runner.run(['update-skill', inputYamlFile.path]);
+
+      expect(skillFile.existsSync(), isTrue);
+
+      // Verify the updated content was written
+      final updatedText = skillFile.readAsStringSync();
+      expect(updatedText, contains('Updated Content with # Existing Content'));
+
+      // Verify source header was sent to Gemini
+      expect(geminiRequests, isNotEmpty);
+      expect(geminiRequests.first, contains('# Existing Content'));
+      expect(geminiRequests.first, contains('New Content'));
+    });
+
+    test('fails gracefully when SKILL.md does not exist', () async {
+      final inputData = [
+        {
+          'name': 'missing',
+          'description': 'Description',
+          'resources': ['https://example.com/source'],
+        },
+      ];
+      inputYamlFile.writeAsStringSync(jsonEncode(inputData));
+
+      final logs = <String>[];
+      final sub = Logger.root.onRecord.listen((record) {
+        logs.add(record.message);
+      });
+      addTearDown(sub.cancel);
+
+      final mockClient = MockClient((request) async {
+        return http.Response('Error', 500);
+      });
+
+      final command = UpdateSkillCommand(
+        environment: {'GEMINI_API_KEY': 'test-key'},
+        httpClient: mockClient,
+        outputDir: tempDir,
+      );
+      runner.addCommand(command);
+
+      await runner.run(['update-skill', inputYamlFile.path]);
+
+      expect(logs, contains(contains('Skill file not found at')));
+      expect(logs, contains(contains('Cannot update an non-existent skill.')));
+    });
+
+    test(
+      'logs warning when fetchAndConvertContent returns empty string',
+      () async {
+        final inputData = [
+          {
+            'name': 'empty-fetch',
+            'description': 'Description',
+            'resources': <String>[],
+          },
+        ];
+        inputYamlFile.writeAsStringSync(jsonEncode(inputData));
+
+        final skillDir = Directory(p.join(tempDir.path, 'empty-fetch'))
+          ..createSync();
+        File(p.join(skillDir.path, 'SKILL.md')).writeAsStringSync('Existing');
+
+        final logs = <String>[];
+        final sub = Logger.root.onRecord.listen(
+          (record) => logs.add(record.message),
+        );
+        addTearDown(sub.cancel);
+
+        final mockClient = MockClient((request) async {
+          return http.Response('', 200); // Empty HTML body
+        });
+
+        final command = UpdateSkillCommand(
+          environment: {'GEMINI_API_KEY': 'test-key'},
+          httpClient: mockClient,
+          outputDir: tempDir,
+        );
+        runner.addCommand(command);
+
+        await runner.run(['update-skill', inputYamlFile.path]);
+        expect(
+          logs,
+          contains('  No content fetched for empty-fetch. Skipping.'),
+        );
+      },
+    );
+
+    test('dry run fetches content but skips Gemini and file writes', () async {
+      final inputData = [
+        {
+          'name': 'dry-update',
+          'description': 'Description',
+          'resources': ['https://example.com/source'],
+        },
+      ];
+      inputYamlFile.writeAsStringSync(jsonEncode(inputData));
+
+      final skillDir = Directory(p.join(tempDir.path, 'dry-update'))
+        ..createSync();
+      final skillFile = File(p.join(skillDir.path, 'SKILL.md'))
+        ..writeAsStringSync('Existing content');
+
+      final logs = <String>[];
+      final sub = Logger.root.onRecord.listen((record) {
+        logs.add(record.message);
+      });
+      addTearDown(sub.cancel);
+
+      var geminiCalled = false;
+      final mockClient = MockClient((request) async {
+        if (request.url.toString() == 'https://example.com/source') {
+          return http.Response('<html>New Content</html>', 200);
+        }
+        if (request.url.toString().contains('generativelanguage')) {
+          geminiCalled = true;
+          return http.Response(
+            jsonEncode({
+              'candidates': [
+                {
+                  'content': {
+                    'parts': [
+                      {'text': 'Gen'},
+                    ],
+                  },
+                },
+              ],
+            }),
+            200,
+          );
+        }
+        return http.Response('Error', 500);
+      });
+
+      final command = UpdateSkillCommand(
+        environment: {'GEMINI_API_KEY': 'test-key'},
+        httpClient: mockClient,
+        outputDir: tempDir,
+      );
+      runner.addCommand(command);
+
+      await runner.run(['update-skill', '--dry-run', inputYamlFile.path]);
+
+      expect(geminiCalled, isFalse);
+      expect(
+        logs,
+        contains(contains('[DRY RUN] Would update skill: dry-update')),
+      );
+      expect(skillFile.readAsStringSync(), equals('Existing content'));
+    });
+  });
+}