@voxgig/sdkgen-langpack 0.0.1

package/.sdk/tm/dart/test/harness.dart

@@ -0,0 +1,153 @@
+// Minimal dependency-free test harness for the generated ProjectName SDK.
+//
+// Mirrors the shape of the donor (ts) node:test usage: describe/test blocks
+// register cases which run sequentially (deterministic order), `t.skip()`
+// marks a case skipped, and the assertion helpers throw AssertionFailure.
+// The suite entry (test/main.dart) awaits runAll() and exits non-zero on
+// any failure.
+
+import 'dart:async';
+
+class AssertionFailure implements Exception {
+  final String message;
+  AssertionFailure(this.message);
+  @override
+  String toString() => 'AssertionFailure: ' + message;
+}
+
+class T {
+  bool skipped = false;
+  String? reason;
+  void skip([String? r]) {
+    skipped = true;
+    reason = r;
+  }
+}
+
+typedef TestBody = dynamic Function(T t);
+
+class _Case {
+  final String name;
+  final TestBody body;
+  _Case(this.name, this.body);
+}
+
+final List<_Case> _cases = [];
+final List<String> _prefix = [];
+
+void describe(String name, void Function() body) {
+  _prefix.add(name);
+  try {
+    body();
+  } finally {
+    _prefix.removeLast();
+  }
+}
+
+void test(String name, TestBody body) {
+  _cases.add(_Case(([..._prefix, name]).join(' > '), body));
+}
+
+void fail(String msg) => throw AssertionFailure(msg);
+
+void ok(dynamic cond, [String? msg]) {
+  if (true != cond) {
+    fail(msg ?? 'expected true, got ' + cond.toString());
+  }
+}
+
+void equal(dynamic a, dynamic b, [String? msg]) {
+  if (!_eq(a, b)) {
+    fail((null == msg ? 'equal' : msg) +
+        ': [' +
+        a.toString() +
+        '] != [' +
+        b.toString() +
+        ']');
+  }
+}
+
+void deepEqual(dynamic a, dynamic b, [String? msg]) {
+  if (!deq(a, b)) {
+    fail((null == msg ? 'deepEqual' : msg) +
+        ': [' +
+        a.toString() +
+        '] != [' +
+        b.toString() +
+        ']');
+  }
+}
+
+bool _eq(dynamic a, dynamic b) {
+  if (a is num && b is num) {
+    return a == b;
+  }
+  return a == b;
+}
+
+// Deep structural equality over JSON-like values.
+bool deq(dynamic a, dynamic b) {
+  if (null == a && null == b) {
+    return true;
+  }
+  if (a is List && b is List) {
+    if (a.length != b.length) {
+      return false;
+    }
+    for (var i = 0; i < a.length; i++) {
+      if (!deq(a[i], b[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (a is Map && b is Map) {
+    if (a.length != b.length) {
+      return false;
+    }
+    for (final k in a.keys) {
+      if (!b.containsKey(k) || !deq(a[k], b[k])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return _eq(a, b);
+}
+
+Future<int> runAll() async {
+  var pass = 0;
+  var failed = 0;
+  var skip = 0;
+  final failures = <String>[];
+
+  for (final c in _cases) {
+    final t = T();
+    try {
+      await Future.sync(() => c.body(t));
+      if (t.skipped) {
+        skip++;
+        print('skip: ' + c.name + (null == t.reason ? '' : ' (' + t.reason! + ')'));
+      } else {
+        pass++;
+      }
+    } catch (e, st) {
+      failed++;
+      failures.add('FAIL: ' + c.name + '\n  ' + e.toString() + '\n' + st.toString());
+    }
+  }
+
+  for (final f in failures) {
+    print(f);
+  }
+  print('tests: ' +
+      _cases.length.toString() +
+      '  pass: ' +
+      pass.toString() +
+      '  fail: ' +
+      failed.toString() +
+      '  skip: ' +
+      skip.toString());
+
+  return failed;
+}

package/.sdk/tm/dart/test/netsim_test.dart

@@ -0,0 +1,48 @@
+// Network-behaviour simulation over the offline mock transport. The `test`
+// feature accepts an optional `net` config so unit tests can exercise slow,
+// failing and offline conditions without a live server. These checks drive
+// the transport through `direct()`, which needs no entity, so they run for
+// every generated SDK regardless of its API shape. Port of ts test/netsim.test.ts.
+
+import 'harness.dart';
+
+import '../lib/ProjectNameSDK.dart';
+
+void tests() {
+  describe('netsim', () {
+    test('offline simulation fails the request', (t) async {
+      final sdk = ProjectNameSDK.test({
+        'net': {'offline': true}
+      });
+      final res = await sdk.direct({'path': '/ping'});
+      equal(false, res['ok'], 'offline network must fail the call');
+    });
+
+    test('failStatus simulation surfaces the error status', (t) async {
+      final sdk = ProjectNameSDK.test({
+        'net': {'failTimes': 1, 'failStatus': 503}
+      });
+      final res = await sdk.direct({'path': '/ping'});
+      equal(false, res['ok']);
+      equal(503, res['status'], 'simulated failure status is surfaced');
+    });
+
+    test('latency simulation delays the request', (t) async {
+      const delay = 60;
+      final sdk = ProjectNameSDK.test({
+        'net': {'latency': delay}
+      });
+      final start = DateTime.now().millisecondsSinceEpoch;
+      await sdk.direct({'path': '/ping'});
+      final elapsed = DateTime.now().millisecondsSinceEpoch - start;
+      // Generous lower bound to stay robust on slow CI.
+      ok(elapsed >= delay - 25,
+          'expected >= ' + (delay - 25).toString() + 'ms latency, got ' + elapsed.toString() + 'ms');
+    });
+
+    test('a plain test SDK still works with no net simulation', (t) async {
+      final sdk = ProjectNameSDK.test();
+      equal(true, null != sdk);
+    });
+  });
+}