✅ add regression coverage for encoder refactor

Add focused tests for filter-wrapped cycle detection, KeyPathNode caching/materialization edge cases, and EncodeConfig copyWith sentinel semantics.

Author: techouse

test/unit/encode_edge_cases_test.dart

@@ -86,6 +86,37 @@ void main() {
       expect(encoded.contains('b%5Bz%5D=1'), isTrue);
     });
 
+    test(
+        'cycle detection still throws when filter wraps maps with fresh containers',
+        () {
+      final cyclic = <String, dynamic>{};
+      cyclic['self'] = cyclic;
+
+      var wraps = 0;
+      final options = EncodeOptions(
+        encode: false,
+        filter: (prefix, value) {
+          if (value is Map) {
+            wraps++;
+            if (wraps > 8) {
+              // Keep this bounded so a regression fails quickly instead of
+              // risking unbounded expansion during traversal.
+              return 'stop';
+            }
+
+            return {'wrapped': value};
+          }
+
+          return value;
+        },
+      );
+
+      expect(
+        () => QS.encode({'root': cyclic}, options),
+        throwsA(isA<RangeError>()),
+      );
+    });
+
     test('strictNullHandling with custom encoder emits only encoded key', () {
       final encoded = QS.encode(
           {

test/unit/models/encode_config_test.dart

@@ -0,0 +1,109 @@
+import 'dart:convert' show Encoding, utf8;
+
+import 'package:qs_dart/src/enums/format.dart';
+import 'package:qs_dart/src/enums/list_format.dart';
+import 'package:qs_dart/src/models/encode_config.dart';
+import 'package:qs_dart/src/models/encode_options.dart';
+import 'package:test/test.dart';
+
+String _encoder(dynamic value, {Encoding? charset, Format? format}) =>
+    value.toString();
+String _serializeDate(DateTime date) => date.toIso8601String();
+int _sort(dynamic a, dynamic b) => 0;
+
+void main() {
+  group('EncodeConfig', () {
+    test('copyWith returns same instance when unchanged', () {
+      final config = _baseConfig();
+
+      expect(identical(config.copyWith(), config), isTrue);
+    });
+
+    test('withEncoder delegates to copyWith and can clear encoder', () {
+      final config = _baseConfig(encoder: _encoder);
+
+      final cleared = config.withEncoder(null);
+
+      expect(cleared, equals(config.copyWith(encoder: null)));
+      expect(cleared.encoder, isNull);
+      expect(identical(cleared, config), isFalse);
+    });
+
+    test('copyWith can clear nullable fields', () {
+      final config = _baseConfig(
+        encoder: _encoder,
+        serializeDate: _serializeDate,
+        sort: _sort,
+        filter: const ['a', 'b'],
+      );
+
+      final copy = config.copyWith(
+        encoder: null,
+        serializeDate: null,
+        sort: null,
+        filter: null,
+      );
+
+      expect(copy.encoder, isNull);
+      expect(copy.serializeDate, isNull);
+      expect(copy.sort, isNull);
+      expect(copy.filter, isNull);
+      expect(copy.generateArrayPrefix, same(config.generateArrayPrefix));
+      expect(copy.formatter, same(config.formatter));
+    });
+
+    test('copyWith treats const Object filter as explicit override', () {
+      const marker = Object();
+      final config = _baseConfig(filter: null);
+
+      final copy = config.copyWith(filter: marker);
+
+      expect(identical(copy.filter, marker), isTrue);
+    });
+
+    test('equatable props compare all fields', () {
+      final a = _baseConfig();
+      final b = _baseConfig();
+
+      expect(a, equals(b));
+      expect(a.copyWith(skipNulls: true), isNot(equals(b)));
+    });
+  });
+}
+
+EncodeConfig _baseConfig({
+  ListFormatGenerator? generateArrayPrefix,
+  bool commaRoundTrip = false,
+  bool commaCompactNulls = false,
+  bool allowEmptyLists = false,
+  bool strictNullHandling = false,
+  bool skipNulls = false,
+  bool encodeDotInKeys = false,
+  Encoder? encoder,
+  DateSerializer? serializeDate,
+  Sorter? sort,
+  dynamic filter,
+  bool allowDots = false,
+  Format format = Format.rfc3986,
+  Formatter? formatter,
+  bool encodeValuesOnly = false,
+}) {
+  return EncodeConfig(
+    generateArrayPrefix: generateArrayPrefix ?? ListFormat.indices.generator,
+    commaRoundTrip: commaRoundTrip,
+    commaCompactNulls: commaCompactNulls,
+    allowEmptyLists: allowEmptyLists,
+    strictNullHandling: strictNullHandling,
+    skipNulls: skipNulls,
+    encodeDotInKeys: encodeDotInKeys,
+    encoder: encoder,
+    serializeDate: serializeDate,
+    sort: sort,
+    filter: filter,
+    allowDots: allowDots,
+    format: format,
+    formatter: formatter ?? format.formatter,
+    encodeValuesOnly: encodeValuesOnly,
+    charset: utf8,
+  );
+}

test/unit/models/key_path_node_test.dart

@@ -0,0 +1,97 @@
+import 'package:qs_dart/src/models/key_path_node.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('KeyPathNode', () {
+    test('append returns same node for empty segment', () {
+      final root = KeyPathNode.fromMaterialized('a');
+
+      expect(identical(root.append(''), root), isTrue);
+    });
+
+    test('materialize composes full path once', () {
+      final node =
+          KeyPathNode.fromMaterialized('a').append('[b]').append('[c]');
+
+      final first = node.materialize();
+      final second = node.materialize();
+
+      expect(first, equals('a[b][c]'));
+      expect(identical(first, second), isTrue);
+    });
+
+    test('materialize composes from nearest cached ancestor', () {
+      final parent =
+          KeyPathNode.fromMaterialized('a').append('[b]').append('[c]');
+      final leaf = parent.append('[d]');
+
+      expect(parent.materialize(), equals('a[b][c]'));
+      final first = leaf.materialize();
+      final second = leaf.materialize();
+
+      expect(first, equals('a[b][c][d]'));
+      expect(identical(first, second), isTrue);
+    });
+
+    test('asDotEncoded returns same node when there are no dots', () {
+      final node = KeyPathNode.fromMaterialized('a').append('[b]');
+
+      final encoded = node.asDotEncoded();
+
+      expect(identical(encoded, node), isTrue);
+    });
+
+    test('asDotEncoded encodes dots in a root node', () {
+      final root = KeyPathNode.fromMaterialized('a.b.c');
+
+      expect(root.asDotEncoded().materialize(), equals('a%2Eb%2Ec'));
+    });
+
+    test('asDotEncoded caches encoded view across calls', () {
+      final node =
+          KeyPathNode.fromMaterialized('a.b').append('[c.d]').append('[e]');
+
+      final first = node.asDotEncoded();
+      final second = node.asDotEncoded();
+
+      expect(first.materialize(), equals('a%2Eb[c%2Ed][e]'));
+      expect(identical(first, second), isTrue);
+    });
+
+    test('asDotEncoded handles deep uncached chains without recursion', () {
+      KeyPathNode node = KeyPathNode.fromMaterialized('root.part');
+      for (int i = 0; i < 5000; i++) {
+        node = node.append('[k$i.v$i]');
+      }
+
+      final encodedFirst = node.asDotEncoded();
+      final encodedSecond = node.asDotEncoded();
+
+      expect(identical(encodedFirst, encodedSecond), isTrue);
+      expect(encodedFirst.materialize().startsWith('root%2Epart[k0%2Ev0]'),
+          isTrue);
+      expect(encodedFirst.materialize().contains('%2E'), isTrue);
+    });
+
+    test('deep chain materialize and asDotEncoded use cached results', () {
+      final node = KeyPathNode.fromMaterialized('a.b')
+          .append('[c.d]')
+          .append('[e.f]')
+          .append('[g.h]')
+          .append('[i]');
+
+      final materializedFirst = node.materialize();
+      final materializedSecond = node.materialize();
+
+      expect(materializedFirst, equals('a.b[c.d][e.f][g.h][i]'));
+      expect(identical(materializedFirst, materializedSecond), isTrue);
+
+      final encodedFirst = node.asDotEncoded();
+      final encodedSecond = node.asDotEncoded();
+
+      expect(
+          encodedFirst.materialize(), equals('a%2Eb[c%2Ed][e%2Ef][g%2Eh][i]'));
+      expect(identical(encodedFirst, encodedSecond), isTrue);
+    });
+  });
+}