feat(tests): Extend the compilation unit class matchers. (serverpod#3355)

Author: SandPod

tools/serverpod_cli/test/test_util/compilation_unit_matcher.dart

@@ -8,7 +8,9 @@ import 'compilation_unit_matcher/chainable_matcher.dart';
 part 'compilation_unit_matcher/argument_matcher/argument_matcher.dart';
 part 'compilation_unit_matcher/class_matcher/class_matcher.dart';
 part 'compilation_unit_matcher/constructor_matcher/constructor_matcher.dart';
+part 'compilation_unit_matcher/extends_matcher/extends_matcher.dart';
 part 'compilation_unit_matcher/field_matcher/field_matcher.dart';
+part 'compilation_unit_matcher/generic_matcher/generic_matcher.dart';
 part 'compilation_unit_matcher/method_matcher/method_matcher.dart';
 part 'compilation_unit_matcher/parameter_matcher/parameter_matcher.dart';
 part 'compilation_unit_matcher/super_initializer_matcher/super_initializer_matcher.dart';
@@ -28,8 +30,10 @@ part 'compilation_unit_matcher/super_initializer_matcher/super_initializer_match
 ///   │   ├── SuperInitializerMatcher
 ///   │   │   └── ArgumentMatcher
 ///   │   └── ParameterMatcher
-///   └── MethodMatcher
-///       └── ParameterMatcher
+///   ├── MethodMatcher
+///   │   └── ParameterMatcher
+///   └── ExtendsMatcher
+///
 ClassMatcher containsClass(String className) => _ClassMatcherImpl._(className);
 
 /// Parses a string of Dart code into a FormattedCompilationUnit.
@@ -42,6 +46,9 @@ abstract interface class ArgumentMatcher {}
 /// A matcher that checks if a CompilationUnit contains a class that matches
 /// certain criteria.
 abstract interface class ClassMatcher {
+  /// Chains a [ExtendsMatcher] that checks if the class extends a specific class.
+  ExtendsMatcher thatExtends(String className);
+
   /// Chains a [FieldMatcher] that checks if the class contains a field with a
   /// specific name.
   ///
@@ -56,7 +63,18 @@ abstract interface class ClassMatcher {
   ///
   /// Use [isNullable] to match field nullability. If the value is not set, the
   /// matcher will ignore the nullability of the field.
-  FieldMatcher withField(String fieldName, {bool? isNullable});
+  ///
+  /// Use [isFinal] to match final fields. If the value is not set, the matcher
+  /// will ignore the final status of the field
+  ///
+  /// Use [isLate] to match late fields. If the value is not set, the matcher
+  /// will ignore the late status of the field
+  FieldMatcher withField(
+    String fieldName, {
+    bool? isNullable,
+    bool? isFinal,
+    bool? isLate,
+  });
 
   /// Chains a [MethodMatcher] that checks if the class contains a method with a
   /// specific name.
@@ -139,6 +157,11 @@ abstract interface class ConstructorMatcher {
   });
 }
 
+/// A chainable matcher that matches the extension in a compilation unit.
+abstract interface class ExtendsMatcher {
+  GenericMatcher withGeneric(String genericType);
+}
+
 /// A chainable matcher that matches a field in a compilation unit.
 abstract interface class FieldMatcher {}
 
@@ -153,6 +176,9 @@ class FormattedCompilationUnit {
   }
 }
 
+/// A chainable matcher that matches a generic type in a compilation unit.
+abstract interface class GenericMatcher {}
+
 /// Initializer types for parameters.
 enum Initializer {
   /// The parameter is initialized with `this`.
@@ -196,7 +222,7 @@ abstract interface class ParameterMatcher {}
 /// A chainable matcher that matches a super initializer in a compilation unit.
 abstract interface class SuperInitializerMatcher {
   /// Chains an [ArgumentMatcher] that checks if the super initializer is called
-  /// with a specific argument.
+  /// with a specific literal argument.
   ArgumentMatcher withArgument(String value);
 
   /// Chains an [ArgumentMatcher] that checks if the super initializer is called

tools/serverpod_cli/test/test_util/compilation_unit_matcher/argument_matcher/argument_matcher.dart

@@ -47,7 +47,7 @@ class _ArgumentMatcherImpl extends Matcher implements ArgumentMatcher {
         'does not contain argument "$_value" in super initializer. Found arguments: [',
       );
       output.writeAll(
-        arguments.map((e) => e.toSource()),
+        arguments.value.map((e) => e.toSource()),
         ', ',
       );
       output.write(']');
@@ -89,10 +89,10 @@ class _ArgumentMatcherImpl extends Matcher implements ArgumentMatcher {
   }
 
   Iterable<Expression>? _featureValueOf(actual) {
-    var superInitializer = _parent.matchedFeatureValueOf(actual);
-    if (superInitializer == null) return null;
+    var match = _parent.matchedFeatureValueOf(actual);
+    if (match == null) return null;
 
-    return superInitializer.where((e) => e._hasMatchingValue(_value));
+    return match.value.where((e) => e._hasMatchingValue(_value));
   }
 }
 
@@ -134,8 +134,6 @@ extension on Expression {
       return resolvedThis.expression._hasMatchingValue(name);
     }
 
-    if (resolvedThis is! SimpleIdentifier) return false;
-
-    return resolvedThis.name == name;
+    return resolvedThis.toSource() == name;
   }
 }

tools/serverpod_cli/test/test_util/compilation_unit_matcher/argument_matcher/argument_matcher_test.dart

@@ -191,4 +191,51 @@ void main() {
       );
     });
   });
+
+  group(
+      'Given compilation unit with class with super initializer with literal argument',
+      () {
+    late final compilationUnit = parseCode(
+      '''
+      class User extends Super {
+        User() : super('name');
+      }
+    ''',
+    );
+
+    test(
+        'when matching class, constructor, super initializer and argument then test passes',
+        () {
+      expect(
+        compilationUnit,
+        containsClass('User')
+            .withUnnamedConstructor()
+            .withSuperInitializer()
+            .withArgument("'name'"),
+      );
+    });
+  });
+
+  group(
+      'Given compilation unit with class with super initializer with identifier argument',
+      () {
+    late final compilationUnit = parseCode(
+      '''
+      class User extends Super {
+        User() : super(name);
+      }
+    ''',
+    );
+    test(
+        'when matching class, constructor, super initializer and argument then test passes',
+        () {
+      expect(
+        compilationUnit,
+        containsClass('User')
+            .withUnnamedConstructor()
+            .withSuperInitializer()
+            .withArgument('name'),
+      );
+    });
+  });
 }

tools/serverpod_cli/test/test_util/compilation_unit_matcher/chainable_matcher.dart

@@ -1,13 +1,53 @@
 import 'package:test/test.dart';
 
-typedef MatchedFeatureValueOf<T> = T? Function(dynamic actual);
+/// Helper method to construct a [Match] object.
+///
+/// In order to construct a [Match] object, the [matchedItem] must be non-null.
+/// If the [matchedItem] is null, this method will return null.
+///
+/// [extractValue] is used to extract the value from the [matchedItem]
+/// that is then stored in the constructed [Match] object.
+Match<T>? _createMatch<T, V>({
+  required V? Function() resolveMatch,
+  required T Function(V value) extractValue,
+}) {
+  var matchedItem = resolveMatch();
+  if (matchedItem == null) return null;
+
+  return Match(extractValue(matchedItem));
+}
+
+typedef MatchedFeatureValueOf<T> = Match<T>? Function(dynamic actual);
 
 /// A matcher that can be chained with other matchers.
 class ChainableMatcher<T> {
   final Matcher _matcher;
   final MatchedFeatureValueOf<T> _matchedFeatureValueOf;
 
-  ChainableMatcher(this._matcher, this._matchedFeatureValueOf);
+  ChainableMatcher._(this._matcher, this._matchedFeatureValueOf);
+
+  /// Creates a matcher that can be chained with other matchers.
+  /// The [matcher] is the matcher that is chained.
+  ///
+  /// The [resolveMatch] function is used to determine if the contained matcher
+  /// matches the [actual] value. If the matcher matches, this should return the
+  /// resolved match. If the matcher does not match, this should return null.
+  ///
+  /// The [extractValue] function is used to extract the value from the resolved
+  /// match. This value is then stored in the [Match] object.
+  static ChainableMatcher<T> createMatcher<T, V>(
+    Matcher matcher, {
+    required V? Function(dynamic item) resolveMatch,
+    required T Function(V value) extractValue,
+  }) {
+    return ChainableMatcher<T>._(
+      matcher,
+      (actual) => _createMatch<T, V>(
+        resolveMatch: () => resolveMatch(actual),
+        extractValue: extractValue,
+      ),
+    );
+  }
 
   /// Describes the contained matcher. This is used to describe the matcher in
   /// the context of the chain.
@@ -31,7 +71,15 @@ class ChainableMatcher<T> {
 
   /// Checks if the matcher matches the given [actual] value.
   ///
-  /// If null is returned, this means that the contained matcher did not match
-  /// and the call to describeMismatch should be delegated to the matcher.
-  T? matchedFeatureValueOf(dynamic actual) => _matchedFeatureValueOf(actual);
+  /// Returns a [Match] object if the matcher matches the [actual] value.
+  /// If the matcher does not match, this method should return null and the call
+  /// to describeMismatch should be delegated to the matcher.
+  Match<T>? matchedFeatureValueOf(dynamic actual) =>
+      _matchedFeatureValueOf(actual);
+}
+
+/// A match that contains the value requested by the matcher.
+class Match<T> {
+  final T value;
+  Match(this.value);
 }

tools/serverpod_cli/test/test_util/compilation_unit_matcher/class_matcher/class_matcher.dart

@@ -1,12 +1,13 @@
 part of '../../compilation_unit_matcher.dart';
 
 class _ClassMatcherImpl implements Matcher, ClassMatcher {
-  final String className;
-  _ClassMatcherImpl._(this.className);
+  final String _className;
+
+  _ClassMatcherImpl._(this._className);
 
   @override
   Description describe(Description description) {
-    return description.add('a CompilationUnit containing class "$className"');
+    return description.add('a CompilationUnit containing class "$_className"');
   }
 
   @override
@@ -32,7 +33,7 @@ class _ClassMatcherImpl implements Matcher, ClassMatcher {
         .join(', ');
 
     return mismatchDescription.add(
-        'does not contain class "$className". Found classes: [$classNames]');
+        'does not contain class "$_className". Found classes: [$classNames]');
   }
 
   @override
@@ -41,16 +42,35 @@ class _ClassMatcherImpl implements Matcher, ClassMatcher {
   }
 
   @override
-  FieldMatcher withField(String fieldName, {bool? isNullable}) {
+  ExtendsMatcher thatExtends(String className) {
+    return _ExtendsMatcherImpl._(
+      ChainableMatcher.createMatcher(
+        this,
+        resolveMatch: _matchedFeatureValueOf,
+        extractValue: (classDeclaration) => classDeclaration.extendsClause,
+      ),
+      name: className,
+    );
+  }
+
+  @override
+  FieldMatcher withField(
+    String fieldName, {
+    bool? isNullable,
+    bool? isFinal,
+    bool? isLate,
+  }) {
     return _FieldMatcherImpl._(
-      ChainableMatcher(
+      ChainableMatcher.createMatcher(
         this,
-        (actual) => _matchedFeatureValueOf(actual)
-            ?.members
-            .whereType<FieldDeclaration>(),
+        resolveMatch: _matchedFeatureValueOf,
+        extractValue: (classDeclaration) =>
+            classDeclaration.members.whereType<FieldDeclaration>(),
       ),
       fieldName,
       isNullable: isNullable,
+      isFinal: isFinal,
+      isLate: isLate,
     );
   }
 
@@ -61,11 +81,11 @@ class _ClassMatcherImpl implements Matcher, ClassMatcher {
     String? returnType,
   }) {
     return _MethodMatcherImpl._(
-      ChainableMatcher(
+      ChainableMatcher.createMatcher(
         this,
-        (actual) => _matchedFeatureValueOf(actual)
-            ?.members
-            .whereType<MethodDeclaration>(),
+        resolveMatch: _matchedFeatureValueOf,
+        extractValue: (classDeclaration) =>
+            classDeclaration.members.whereType<MethodDeclaration>(),
       ),
       methodName,
       isOverride: isOverride,
@@ -102,7 +122,7 @@ class _ClassMatcherImpl implements Matcher, ClassMatcher {
 
     return resolvedActual.declarations
         .whereType<ClassDeclaration>()
-        .where((d) => d._hasMatchingClass(className))
+        .where((d) => d._hasMatchingClass(_className))
         .firstOrNull;
   }
 
@@ -124,11 +144,11 @@ class _ClassMatcherImpl implements Matcher, ClassMatcher {
     bool? isFactory,
   }) {
     return _ConstructorMatcherImpl._(
-      ChainableMatcher(
+      ChainableMatcher.createMatcher(
         this,
-        (actual) => _matchedFeatureValueOf(actual)
-            ?.members
-            .whereType<ConstructorDeclaration>(),
+        resolveMatch: _matchedFeatureValueOf,
+        extractValue: (classDeclaration) =>
+            classDeclaration.members.whereType<ConstructorDeclaration>(),
       ),
       name: constructorName,
       isFactory: isFactory,