dynamite, nextcloud: externalize, fix and test ContentString

Signed-off-by: Nikolas Rimikis <rimikis.nikolas@gmail.com>

packages/dynamite/lib/content_string.dart

@@ -0,0 +1 @@
+export 'src/helpers/content_string.dart';

packages/dynamite/lib/src/helpers/content_string.dart

@@ -0,0 +1,60 @@
+// ignore_for_file: avoid_equals_and_hash_code_on_mutable_classes
+
+import 'dart:convert';
+
+import 'package:built_value/built_value.dart';
+import 'package:built_value/serializer.dart';
+
+part 'content_string.g.dart';
+
+abstract class ContentString<T> implements Built<ContentString<T>, ContentStringBuilder<T>> {
+  factory ContentString([final void Function(ContentStringBuilder<T>)? b]) = _$ContentString<T>;
+  const ContentString._();
+
+  /// decoded contentString
+  T get content;
+
+  static Serializer<ContentString<Object?>> get serializer => _$contentStringSerializer;
+}
+
+class ContentStringPlugin implements SerializerPlugin {
+  const ContentStringPlugin();
+
+  @override
+  Object? afterDeserialize(final Object? object, final FullType specifiedType) => object;
+
+  @override
+  Object? afterSerialize(final Object? object, final FullType specifiedType) {
+    if (!specifiedType.root.toString().contains('ContentString')) {
+      return object;
+    }
+
+    if (object is! Map<String, dynamic>) {
+      throw ArgumentError('ContentStringPlugin can only be applied to Map<String, dynamic>. '
+          'Please ensure the StandardJsonPlugin is applied and run before.');
+    }
+
+    final content = object['content'];
+
+    return jsonEncode(content);
+  }
+
+  @override
+  Object? beforeDeserialize(final Object? object, final FullType specifiedType) {
+    if (!specifiedType.root.toString().contains('ContentString')) {
+      return object;
+    }
+
+    if (object is! String) {
+      throw ArgumentError('The serialized ContentString must be of type String. '
+          'Please ensure the StandardJsonPlugin is applied and run before.');
+    }
+
+    final content = jsonDecode(object);
+
+    return ['content', content];
+  }
+
+  @override
+  Object? beforeSerialize(final Object? object, final FullType specifiedType) => object;
+}

packages/dynamite/lib/src/helpers/content_string.g.dart

@@ -0,0 +1,139 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'content_string.dart';
+
+// **************************************************************************
+// BuiltValueGenerator
+// **************************************************************************
+
+Serializer<ContentString<Object?>> _$contentStringSerializer = _$ContentStringSerializer();
+
+class _$ContentStringSerializer implements StructuredSerializer<ContentString<Object?>> {
+  @override
+  final Iterable<Type> types = const [ContentString, _$ContentString];
+  @override
+  final String wireName = 'ContentString';
+
+  @override
+  Iterable<Object?> serialize(Serializers serializers, ContentString<Object?> object,
+      {FullType specifiedType = FullType.unspecified}) {
+    final isUnderspecified = specifiedType.isUnspecified || specifiedType.parameters.isEmpty;
+    if (!isUnderspecified) serializers.expectBuilder(specifiedType);
+    final parameterT = isUnderspecified ? FullType.object : specifiedType.parameters[0];
+
+    final result = <Object?>[
+      'content',
+      serializers.serialize(object.content, specifiedType: parameterT),
+    ];
+
+    return result;
+  }
+
+  @override
+  ContentString<Object?> deserialize(Serializers serializers, Iterable<Object?> serialized,
+      {FullType specifiedType = FullType.unspecified}) {
+    final isUnderspecified = specifiedType.isUnspecified || specifiedType.parameters.isEmpty;
+    if (!isUnderspecified) serializers.expectBuilder(specifiedType);
+    final parameterT = isUnderspecified ? FullType.object : specifiedType.parameters[0];
+
+    final result = isUnderspecified
+        ? ContentStringBuilder<Object?>()
+        : serializers.newBuilder(specifiedType) as ContentStringBuilder<Object?>;
+
+    final iterator = serialized.iterator;
+    while (iterator.moveNext()) {
+      final key = iterator.current! as String;
+      iterator.moveNext();
+      final Object? value = iterator.current;
+      switch (key) {
+        case 'content':
+          result.content = serializers.deserialize(value, specifiedType: parameterT);
+          break;
+      }
+    }
+
+    return result.build();
+  }
+}
+
+class _$ContentString<T> extends ContentString<T> {
+  @override
+  final T content;
+
+  factory _$ContentString([void Function(ContentStringBuilder<T>)? updates]) =>
+      (ContentStringBuilder<T>()..update(updates))._build();
+
+  _$ContentString._({required this.content}) : super._() {
+    BuiltValueNullFieldError.checkNotNull(content, r'ContentString', 'content');
+    if (T == dynamic) {
+      throw BuiltValueMissingGenericsError(r'ContentString', 'T');
+    }
+  }
+
+  @override
+  ContentString<T> rebuild(void Function(ContentStringBuilder<T>) updates) => (toBuilder()..update(updates)).build();
+
+  @override
+  ContentStringBuilder<T> toBuilder() => ContentStringBuilder<T>()..replace(this);
+
+  @override
+  bool operator ==(Object other) {
+    if (identical(other, this)) return true;
+    return other is ContentString && content == other.content;
+  }
+
+  @override
+  int get hashCode {
+    var _$hash = 0;
+    _$hash = $jc(_$hash, content.hashCode);
+    _$hash = $jf(_$hash);
+    return _$hash;
+  }
+
+  @override
+  String toString() {
+    return (newBuiltValueToStringHelper(r'ContentString')..add('content', content)).toString();
+  }
+}
+
+class ContentStringBuilder<T> implements Builder<ContentString<T>, ContentStringBuilder<T>> {
+  _$ContentString<T>? _$v;
+
+  T? _content;
+  T? get content => _$this._content;
+  set content(T? content) => _$this._content = content;
+
+  ContentStringBuilder();
+
+  ContentStringBuilder<T> get _$this {
+    final $v = _$v;
+    if ($v != null) {
+      _content = $v.content;
+      _$v = null;
+    }
+    return this;
+  }
+
+  @override
+  void replace(ContentString<T> other) {
+    ArgumentError.checkNotNull(other, 'other');
+    _$v = other as _$ContentString<T>;
+  }
+
+  @override
+  void update(void Function(ContentStringBuilder<T>)? updates) {
+    if (updates != null) updates(this);
+  }
+
+  @override
+  ContentString<T> build() => _build();
+
+  _$ContentString<T> _build() {
+    final _$result = _$v ??
+        _$ContentString<T>._(content: BuiltValueNullFieldError.checkNotNull(content, r'ContentString', 'content'));
+    replace(_$result);
+    return _$result;
+  }
+}
+
+// ignore_for_file: deprecated_member_use_from_same_package,type=lint

packages/dynamite/lib/src/openapi_builder.dart

@@ -68,6 +68,7 @@ class OpenAPIBuilder implements Builder {
         "import 'package:built_value/serializer.dart';",
         "import 'package:built_value/standard_json_plugin.dart';",
         "import 'package:cookie_jar/cookie_jar.dart';",
+        "import 'package:dynamite/content_string.dart';",
         "import 'package:universal_io/io.dart';",
         '',
         "export 'package:cookie_jar/cookie_jar.dart';",
@@ -1015,11 +1016,11 @@ class OpenAPIBuilder implements Builder {
             '$name,',
           ],
           '])',
-          r'final Serializers serializers = (_$serializers.toBuilder()..addPlugin(StandardJsonPlugin())..addAll(const [',
+          r'final Serializers serializers = (_$serializers.toBuilder()..addPlugin(StandardJsonPlugin())',
           if (state.hasContentString) ...[
-            r'_$ContentStringSerializer()',
+            '..addPlugin(const ContentStringPlugin())',
           ],
-          '])).build();',
+          ').build();',
           '',
           '// coverage:ignore-start',
           'T deserialize$prefix<T>(final Object data) => serializers.deserialize(data, specifiedType: FullType(T))! as T;',
@@ -1029,199 +1030,6 @@ class OpenAPIBuilder implements Builder {
         ]);
       }
 
-      if (state.hasContentString) {
-        output.addAll([
-          Class(
-            (final b) => b
-              ..name = 'ContentString'
-              ..abstract = true
-              ..types.add(refer('T'))
-              ..implements.add(
-                refer(
-                  'Built<ContentString<T>, ContentStringBuilder<T>>',
-                ),
-              )
-              ..constructors.addAll([
-                Constructor(
-                  (final b) => b
-                    ..name = '_'
-                    ..constant = true,
-                ),
-                Constructor(
-                  (final b) => b
-                    ..factory = true
-                    ..lambda = true
-                    ..optionalParameters.add(
-                      Parameter(
-                        (final b) => b
-                          ..name = 'b'
-                          ..type = refer('void Function(ContentStringBuilder<T>)?'),
-                      ),
-                    )
-                    ..redirect = refer(r'_$ContentString<T>'),
-                ),
-              ])
-              ..methods.addAll([
-                Method(
-                  (final b) => b
-                    ..name = 'content'
-                    ..returns = refer('T')
-                    ..type = MethodType.getter
-                    ..docs.addAll(_descriptionToDocs('decoded contentString')),
-                ),
-                Method(
-                  (final b) => b
-                    ..static = true
-                    ..name = 'fromJson'
-                    ..lambda = true
-                    ..returns = refer('ContentString')
-                    ..requiredParameters.add(
-                      Parameter(
-                        (final b) => b
-                          ..name = 'json'
-                          ..type = refer('Object'),
-                      ),
-                    )
-                    ..body = const Code('serializers.deserializeWith(serializer, json)!'),
-                ),
-                Method(
-                  (final b) => b
-                    ..name = 'toJson'
-                    ..returns = refer('Map<String, dynamic>')
-                    ..lambda = true
-                    ..body = const Code('serializers.serializeWith(serializer, this)! as Map<String, dynamic>'),
-                ),
-                Method(
-                  (final b) => b
-                    ..name = 'serializer'
-                    ..returns = refer('Serializer<ContentString>')
-                    ..lambda = true
-                    ..static = true
-                    ..annotations.add(refer('BuiltValueSerializer').call([], {'custom': literalTrue}))
-                    ..body = const Code(r'_$ContentStringSerializer()')
-                    ..type = MethodType.getter,
-                ),
-              ]),
-          ).accept(emitter).toString(),
-          Class(
-            (final b) => b
-              ..name = r'_$ContentStringSerializer'
-              ..implements.add(refer('PrimitiveSerializer<ContentString<Object?>>'))
-              ..constructors.add(
-                Constructor(
-                  (final b) => b..constant = true,
-                ),
-              )
-              ..fields.addAll([
-                Field(
-                  (final b) => b
-                    ..name = 'types'
-                    ..modifier = FieldModifier.final$
-                    ..type = refer('Iterable<Type>')
-                    ..annotations.add(refer('override'))
-                    ..assignment = const Code(r'const [ContentString, _$ContentString]'),
-                ),
-                Field(
-                  (final b) => b
-                    ..name = 'wireName'
-                    ..modifier = FieldModifier.final$
-                    ..type = refer('String')
-                    ..annotations.add(refer('override'))
-                    ..assignment = literalString('ContentString').code,
-                ),
-              ])
-              ..methods.addAll([
-                Method((final b) {
-                  b
-                    ..name = 'serialize'
-                    ..returns = refer('Object')
-                    ..annotations.add(refer('override'))
-                    ..requiredParameters.addAll([
-                      Parameter(
-                        (final b) => b
-                          ..name = 'serializers'
-                          ..type = refer('Serializers'),
-                      ),
-                      Parameter(
-                        (final b) => b
-                          ..name = 'object'
-                          ..type = refer('ContentString<Object?>'),
-                      ),
-                    ])
-                    ..optionalParameters.add(
-                      Parameter(
-                        (final b) => b
-                          ..name = 'specifiedType'
-                          ..type = refer('FullType')
-                          ..named = true
-                          ..defaultTo = const Code('FullType.unspecified'),
-                      ),
-                    )
-                    ..body = Block.of([
-                      const Code(
-                        'final isUnderspecified = specifiedType.isUnspecified || specifiedType.parameters.isEmpty;',
-                      ),
-                      const Code('if (!isUnderspecified) serializers.expectBuilder(specifiedType);'),
-                      const Code(
-                        'final parameterT = isUnderspecified ? FullType.object : specifiedType.parameters[0];',
-                      ),
-                      const Code(''),
-                      const Code('final result = serializers.serialize(object.content, specifiedType: parameterT);'),
-                      const Code(''),
-                      const Code(r'return json.encode("$result");'),
-                    ]);
-                }),
-                Method((final b) {
-                  b
-                    ..name = 'deserialize'
-                    ..returns = refer('ContentString<Object?>')
-                    ..annotations.add(refer('override'))
-                    ..requiredParameters.addAll([
-                      Parameter(
-                        (final b) => b
-                          ..name = 'serializers'
-                          ..type = refer('Serializers'),
-                      ),
-                      Parameter(
-                        (final b) => b
-                          ..name = 'serialized'
-                          ..type = refer('Object?'),
-                      ),
-                    ])
-                    ..optionalParameters.add(
-                      Parameter(
-                        (final b) => b
-                          ..name = 'specifiedType'
-                          ..type = refer('FullType')
-                          ..named = true
-                          ..defaultTo = const Code('FullType.unspecified'),
-                      ),
-                    )
-                    ..body = Block.of([
-                      const Code(
-                        'final isUnderspecified = specifiedType.isUnspecified || specifiedType.parameters.isEmpty;',
-                      ),
-                      const Code('if (!isUnderspecified) serializers.expectBuilder(specifiedType);'),
-                      const Code(
-                        'final parameterT = isUnderspecified ? FullType.object : specifiedType.parameters[0];',
-                      ),
-                      const Code(''),
-                      const Code(
-                        'final result = isUnderspecified? ContentStringBuilder<Object?>(): serializers.newBuilder(specifiedType) as ContentStringBuilder<Object?>;',
-                      ),
-                      const Code(''),
-                      const Code(
-                        'result.content = serializers.deserialize(json.decode(serialized as String), specifiedType: parameterT);',
-                      ),
-                      const Code(''),
-                      const Code('return result.build();'),
-                    ]);
-                }),
-              ]),
-          ).accept(emitter).toString()
-        ]);
-      }
-
       final formatter = DartFormatter(
         pageWidth: 120,
       );
@@ -1869,11 +1677,9 @@ TypeResult resolveType(
       identifier,
       schema.contentSchema!,
     );
-    //state.hasContentString = true;
+    state.hasContentString = true;
 
-    //result = TypeResultObject('ContentString<${result.name}>');
-    print("Current ContentString support is limited and won't be decoded automatically. "
-        'See https://github.com/provokateurin/nextcloud-neon/issues/281 for further information.');
+    result = TypeResultObject('ContentString<${result.name}>');
   } else {
     switch (schema.type) {
       case 'boolean':

packages/dynamite/pubspec.yaml

@@ -6,6 +6,7 @@ environment:
 
 dependencies:
   build: ^2.4.0
+  built_value: ^8.5.0
   code_builder: ^4.4.0
   dart_style: ^2.3.1
   json_annotation: ^4.8.1
@@ -13,8 +14,11 @@ dependencies:
 
 dev_dependencies:
   build_runner: ^2.4.2
+  built_collection: ^5.1.1
+  built_value_generator: ^8.5.0
   json_serializable: ^6.6.2
   nit_picking:
     git:
       url: https://github.com/stack11/dart_nit_picking
       ref: 0b2ee0d
+  test: ^1.24.2

packages/dynamite/test/content_string_test.dart

@@ -0,0 +1,341 @@
+// ignore_for_file: avoid_redundant_argument_values
+
+import 'dart:convert';
+
+import 'package:built_collection/built_collection.dart';
+import 'package:built_value/serializer.dart';
+import 'package:built_value/standard_json_plugin.dart';
+import 'package:dynamite/content_string.dart';
+import 'package:test/test.dart';
+
+part 'content_string_test.g.dart';
+
+@SerializersFor([
+  ContentString,
+])
+final Serializers serializers = (_$serializers.toBuilder()
+      ..addPlugin(StandardJsonPlugin())
+      ..addPlugin(const ContentStringPlugin())
+      ..addBuilderFactory(const FullType(ContentString, [FullType(bool)]), ContentStringBuilder<bool>.new)
+      ..addBuilderFactory(const FullType(ContentString, [FullType(double)]), ContentStringBuilder<double>.new)
+      ..addBuilderFactory(
+        const FullType(ContentString, [
+          FullType(BuiltList, [FullType(int)])
+        ]),
+        ContentStringBuilder<BuiltList<int>>.new,
+      )
+      ..addBuilderFactory(const FullType(BuiltList, [FullType(int)]), ListBuilder<int>.new)
+      ..addBuilderFactory(
+        const FullType(ContentString, [
+          FullType(BuiltMap, [FullType(String), FullType(int)])
+        ]),
+        ContentStringBuilder<BuiltMap<String, int>>.new,
+      )
+      ..addBuilderFactory(const FullType(BuiltMap, [FullType(String), FullType(int)]), MapBuilder<String, int>.new)
+      ..addBuilderFactory(const FullType(ContentString, [FullType(int)]), ContentStringBuilder<int>.new)
+      ..addBuilderFactory(const FullType(ContentString, [FullType(String)]), ContentStringBuilder<String>.new)
+      ..addBuilderFactory(
+        const FullType(ContentString, [
+          FullType(ContentString, [FullType(String)])
+        ]),
+        ContentStringBuilder<ContentString<String>>.new,
+      ))
+    .build();
+
+void main() {
+  group('ContentString with known specifiedType holding bool', () {
+    final data = ContentString<bool>((final b) => b..content = true);
+    final serialized = json.encode(true);
+    const specifiedType = FullType(ContentString, [FullType(bool)]);
+
+    test('can be serialized', () {
+      expect(serializers.serialize(data, specifiedType: specifiedType), serialized);
+    });
+
+    test('can be deserialized', () {
+      expect(serializers.deserialize(serialized, specifiedType: specifiedType), data);
+    });
+  });
+
+  group(
+    'ContentString with unknown specifiedType holding bool',
+    () {
+      final data = ContentString((final b) => b..content = true);
+      final serialized = json.decode(
+        json.encode({
+          r'$': 'ContentString',
+          'content': {r'$': 'bool', '': true}
+        }),
+      ) as Object;
+      const specifiedType = FullType.unspecified;
+
+      test('can be serialized', () {
+        expect(serializers.serialize(data, specifiedType: specifiedType), serialized);
+      });
+
+      test('can be deserialized', () {
+        expect(serializers.deserialize(serialized, specifiedType: specifiedType), data);
+      });
+    },
+    skip: true,
+  );
+
+  group('ContentString with known specifiedType holding double', () {
+    final data = ContentString<double>((final b) => b..content = 42.5);
+    final serialized = json.encode(42.5);
+    const specifiedType = FullType(ContentString, [FullType(double)]);
+
+    test('can be serialized', () {
+      expect(serializers.serialize(data, specifiedType: specifiedType), serialized);
+    });
+
+    test('can be deserialized', () {
+      expect(serializers.deserialize(serialized, specifiedType: specifiedType), data);
+    });
+  });
+
+  group(
+    'ContentString with unknown specifiedType holding double',
+    () {
+      final data = ContentString((final b) => b..content = 42.5);
+      final serialized = json.decode(
+        json.encode({
+          r'$': 'ContentString',
+          'content': {r'$': 'double', '': 42.5}
+        }),
+      ) as Object;
+      const specifiedType = FullType.unspecified;
+
+      test('can be serialized', () {
+        expect(serializers.serialize(data, specifiedType: specifiedType), serialized);
+      });
+
+      test('can be deserialized', () {
+        expect(serializers.deserialize(serialized, specifiedType: specifiedType), data);
+      });
+    },
+    skip: true,
+  );
+
+  group('ContentString with known specifiedType holding list', () {
+    final data = ContentString<BuiltList<int>>((final b) => b..content = BuiltList([1, 2, 3]));
+    final serialized = json.encode([1, 2, 3]);
+    const specifiedType = FullType(ContentString, [
+      FullType(BuiltList, [FullType(int)])
+    ]);
+
+    test('can be serialized', () {
+      expect(serializers.serialize(data, specifiedType: specifiedType), serialized);
+    });
+
+    test('can be deserialized', () {
+      expect(serializers.deserialize(serialized, specifiedType: specifiedType), equals(data));
+    });
+  });
+
+  group(
+    'ContentString with unknown specifiedType holding list',
+    () {
+      final data = ContentString((final b) => b..content = BuiltList([1, 2, 3]));
+      final serialized = json.decode(
+        json.encode({
+          r'$': 'ContentString',
+          'content': {
+            r'$': 'list',
+            '': [
+              {r'$': 'int', '': 1},
+              {r'$': 'int', '': 2},
+              {r'$': 'int', '': 3}
+            ]
+          }
+        }),
+      ) as Object;
+      const specifiedType = FullType.unspecified;
+
+      test('can be serialized', () {
+        expect(serializers.serialize(data, specifiedType: specifiedType), serialized);
+      });
+
+      test('can be deserialized', () {
+        expect(serializers.deserialize(serialized, specifiedType: specifiedType), data);
+      });
+    },
+    skip: true,
+  );
+
+  group('ContentString with known specifiedType holding map', () {
+    final data =
+        ContentString<BuiltMap<String, int>>((final b) => b..content = BuiltMap({'one': 1, 'two': 2, 'three': 3}));
+    // while not being valid json it's what built_value expects.
+    // using the StandardJsonPlugin will encode it to a valid Map<String, int>.
+    final serialized = json.encode({'one': 1, 'two': 2, 'three': 3});
+    const specifiedType = FullType(ContentString, [
+      FullType(BuiltMap, [FullType(String), FullType(int)])
+    ]);
+
+    test('can be serialized', () {
+      expect(serializers.serialize(data, specifiedType: specifiedType), serialized);
+    });
+
+    test('can be deserialized', () {
+      expect(serializers.deserialize(serialized, specifiedType: specifiedType), data);
+    });
+  });
+
+  group(
+    'ContentString with unknown specifiedType holding map',
+    () {
+      final data = ContentString((final b) => b..content = BuiltMap({'one': 1, 'two': 2, 'three': 3}));
+      final serialized = json.decode(
+        json.encode({
+          r'$': 'ContentString',
+          'content': {
+            r'$': 'encoded_map',
+            r'{"$":"String","":"one"}': {r'$': 'int', '': 1},
+            r'{"$":"String","":"two"}': {r'$': 'int', '': 2},
+            r'{"$":"String","":"three"}': {r'$': 'int', '': 3}
+          }
+        }),
+      ) as Object;
+      const specifiedType = FullType.unspecified;
+
+      test('can be serialized', () {
+        expect(serializers.serialize(data, specifiedType: specifiedType), serialized);
+      });
+
+      test('can be deserialized', () {
+        expect(serializers.deserialize(serialized, specifiedType: specifiedType), data);
+      });
+    },
+    skip: true,
+  );
+
+  group(
+    'ContentString with known specifiedType holding int',
+    () {
+      final data = ContentString<int>((final b) => b..content = 42);
+      final serialized = json.encode(42);
+      const specifiedType = FullType(ContentString, [FullType(int)]);
+
+      test('can be serialized', () {
+        expect(serializers.serialize(data, specifiedType: specifiedType), serialized);
+      });
+
+      test('can be deserialized', () {
+        expect(serializers.deserialize(serialized, specifiedType: specifiedType), data);
+      });
+    },
+  );
+
+  group(
+    'ContentString with unknown specifiedType holding int',
+    () {
+      final data = ContentString((final b) => b..content = 42);
+      final serialized = json.decode(
+        json.encode({
+          r'$': 'ContentString',
+          'content': {r'$': 'int', '': 42}
+        }),
+      ) as Object;
+      const specifiedType = FullType.unspecified;
+
+      test('can be serialized', () {
+        expect(serializers.serialize(data, specifiedType: specifiedType), serialized);
+      });
+
+      test('can be deserialized', () {
+        expect(serializers.deserialize(serialized, specifiedType: specifiedType), data);
+      });
+    },
+    skip: true,
+  );
+
+  group('ContentString with known specifiedType holding String', () {
+    final data = ContentString<String>((final b) => b..content = 'test');
+    final serialized = json.encode('test');
+    const specifiedType = FullType(ContentString, [FullType(String)]);
+
+    test('can be serialized', () {
+      expect(serializers.serialize(data, specifiedType: specifiedType), serialized);
+    });
+
+    test('can be deserialized', () {
+      expect(serializers.deserialize(serialized, specifiedType: specifiedType), data);
+    });
+  });
+
+  group(
+    'ContentString with unknown specifiedType holding String',
+    () {
+      final data = ContentString((final b) => b..content = 'test');
+      final serialized = json.decode(
+        json.encode({
+          r'$': 'ContentString',
+          'content': {r'$': 'String', '': 'test'}
+        }),
+      ) as Object;
+      const specifiedType = FullType.unspecified;
+
+      test('can be serialized', () {
+        expect(serializers.serialize(data, specifiedType: specifiedType), serialized);
+      });
+
+      test('can be deserialized', () {
+        expect(serializers.deserialize(serialized, specifiedType: specifiedType), data);
+      });
+    },
+    skip: true,
+  );
+
+  group('ContentString with known specifiedType holding ContentString', () {
+    final data = ContentString<ContentString<String>>(
+      (final b) => b
+        ..content = ContentString<String>(
+          (final b) => b..content = 'test',
+        ),
+    );
+    final serialized = json.encode(json.encode('test'));
+    const specifiedType = FullType(ContentString, [
+      FullType(ContentString, [FullType(String)])
+    ]);
+
+    test('can be serialized', () {
+      expect(serializers.serialize(data, specifiedType: specifiedType), serialized);
+    });
+
+    test('can be deserialized', () {
+      expect(serializers.deserialize(serialized, specifiedType: specifiedType), data);
+    });
+  });
+
+  group(
+    'ContentString with unknown specifiedType holding ContentString',
+    () {
+      final data = ContentString<ContentString<String>>(
+        (final b) => b
+          ..content = ContentString<String>(
+            (final b) => b..content = 'test',
+          ),
+      );
+      final serialized = json.decode(
+        json.encode({
+          r'$': 'ContentString',
+          'content': {
+            r'$': 'ContentString',
+            'content': {r'$': 'String', '': 'test'}
+          }
+        }),
+      ) as Object;
+      const specifiedType = FullType.unspecified;
+
+      test('can be serialized', () {
+        expect(serializers.serialize(data, specifiedType: specifiedType), serialized);
+      });
+
+      test('can be deserialized', () {
+        expect(serializers.deserialize(serialized, specifiedType: specifiedType), data);
+      });
+    },
+    skip: false,
+  );
+}

packages/dynamite/test/content_string_test.g.dart

@@ -0,0 +1,11 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'content_string_test.dart';
+
+// **************************************************************************
+// BuiltValueGenerator
+// **************************************************************************
+
+Serializers _$serializers = (Serializers().toBuilder()..add(ContentString.serializer)).build();
+
+// ignore_for_file: deprecated_member_use_from_same_package,type=lint

packages/nextcloud/pubspec.yaml

@@ -10,6 +10,8 @@ dependencies:
   cookie_jar: ^4.0.2
   crypto: ^3.0.3
   crypton: ^2.0.5
+  dynamite:
+    path: ../dynamite
   intl: ^0.18.0
   universal_io: ^2.2.0
   version: ^3.0.2
@@ -18,9 +20,8 @@ dependencies:
 
 dev_dependencies:
   build_runner: ^2.4.2
+  built_value_generator: ^8.5.0
   coverage: ^1.6.3
-  dynamite:
-    path: ../dynamite
   nit_picking:
     git:
       url: https://github.com/stack11/dart_nit_picking