pkgs/code_builder/test/specs/method_test.dart

// Copyright (c) 2017, 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 'package:code_builder/code_builder.dart';
import 'package:test/test.dart';

import '../common.dart';

void main() {
  useDartfmt();

  test('should create a method', () {
    expect(
      Method((b) => b..name = 'foo'),
      equalsDart(r'''
        foo();
      '''),
    );
  });

  test('should create an async method', () {
    expect(
      Method(
        (b) => b
          ..name = 'foo'
          ..modifier = MethodModifier.async
          ..body = literalNull.code,
      ),
      equalsDart(r'''
        foo() async => null
      '''),
    );
  });

  test('should create an async* method', () {
    expect(
      Method(
        (b) => b
          ..name = 'foo'
          ..modifier = MethodModifier.asyncStar
          ..body = literalNull.code,
      ),
      equalsDart(r'''
        foo() async* => null
      '''),
    );
  });

  test('should create an sync* method', () {
    expect(
      Method(
        (b) => b
          ..name = 'foo'
          ..modifier = MethodModifier.syncStar
          ..body = literalNull.code,
      ),
      equalsDart(r'''
        foo() sync* => null
      '''),
    );
  });

  test('should create a lambda method implicitly', () {
    expect(
      Method(
        (b) => b
          ..name = 'returnsTrue'
          ..returns = refer('bool')
          ..body = literalTrue.code,
      ),
      equalsDart(r'''
        bool returnsTrue() => true
      '''),
    );
  });

  test('should create a lambda method if the value is cast', () {
    expect(
      Method(
        (b) => b
          ..name = 'returnsCastedValue'
          ..returns = refer('Foo')
          ..body = refer('bar').asA(refer('Foo')).code,
      ),
      equalsDart(r'''
        Foo returnsCastedValue() => (bar as Foo)
      '''),
    );
  });

  test('should create a normal method implicitly', () {
    expect(
      Method.returnsVoid(
        (b) => b
          ..name = 'assignTrue'
          ..body = refer('topLevelFoo').assign(literalTrue).statement,
      ),
      equalsDart(r'''
        void assignTrue() {
          topLevelFoo = true;
        }
      '''),
    );
  });

  test('should create a getter', () {
    expect(
      Method(
        (b) => b
          ..name = 'foo'
          ..external = true
          ..type = MethodType.getter,
      ),
      equalsDart(r'''
        external get foo;
      '''),
    );
  });

  test('should create a setter', () {
    expect(
      Method(
        (b) => b
          ..name = 'foo'
          ..external = true
          ..requiredParameters.add(Parameter((b) => b..name = 'foo'))
          ..type = MethodType.setter,
      ),
      equalsDart(r'''
        external set foo(foo);
      '''),
    );
  });

  test('should create a method with a return type', () {
    expect(
      Method(
        (b) => b
          ..name = 'foo'
          ..returns = refer('String'),
      ),
      equalsDart(r'''
        String foo();
      '''),
    );
  });

  test('should create a method with a void return type', () {
    expect(
      Method.returnsVoid((b) => b..name = 'foo'),
      equalsDart(r'''
        void foo();
      '''),
    );
  });

  test('should create a method with a function type return type', () {
    expect(
      Method(
        (b) => b
          ..name = 'foo'
          ..returns = FunctionType(
            (b) => b
              ..returnType = refer('String')
              ..requiredParameters.addAll([refer('int')]),
          ),
      ),
      equalsDart(r'''
        String Function(int) foo();
      '''),
    );
  });

  test(
    'should create a function type with an optional positional parameter',
    () {
      expect(
        FunctionType(
          (b) => b
            ..returnType = refer('String')
            ..optionalParameters.add(refer('int')),
        ),
        equalsDart(r'''
        String Function([int])
      '''),
      );
    },
  );

  test('should create a function type with a required '
      'and an optional positional parameter', () {
    expect(
      FunctionType(
        (b) => b
          ..returnType = refer('String')
          ..requiredParameters.add(refer('int'))
          ..optionalParameters.add(refer('int')),
      ),
      equalsDart(r'''
        String Function(int, [int, ])
      '''),
    );
  });

  test('should create a function type without parameters', () {
    expect(
      FunctionType((b) => b..returnType = refer('String')),
      equalsDart(r'''
        String Function()
      '''),
    );
  });

  test('should create a function type with an optional named parameter', () {
    expect(
      FunctionType(
        (b) => b
          ..returnType = refer('String')
          ..namedParameters['named'] = refer('int'),
      ),
      equalsDart(r'''
        String Function({int named})
      '''),
    );
  });

  test('should create a function type with a required '
      'and an optional named parameter', () {
    expect(
      FunctionType(
        (b) => b
          ..returnType = refer('String')
          ..requiredParameters.add(refer('int'))
          ..namedParameters['named'] = refer('int'),
      ),
      equalsDart(r'''
        String Function(int, {int named, })
      '''),
    );
  });

  test('should create a function type with a required named parameter', () {
    expect(
      FunctionType(
        (b) => b
          ..returnType = refer('String')
          ..namedRequiredParameters['named'] = refer('int'),
      ),
      equalsDart(r'''
        String Function({required int named})
      '''),
    );
  });

  test('should create a function type with a required named and an optional '
      'named parameter', () {
    expect(
      FunctionType(
        (b) => b
          ..returnType = refer('String')
          ..namedRequiredParameters['named'] = refer('int')
          ..namedParameters['optional'] = refer('int'),
      ),
      equalsDart(r'''
        String Function({required int named, int optional, })
      '''),
    );
  });

  test('should create a typedef to a reference', () {
    expect(
      TypeDef(
        (b) => b
          ..name = 'i32'
          ..definition = const Reference('int'),
      ),
      equalsDart(r'''
        typedef i32 = int;
      '''),
    );
  });

  test('should create a typedef to a function type', () {
    expect(
      TypeDef(
        (b) => b
          ..name = 'MyMapper'
          ..definition = FunctionType(
            (b) => b
              ..returnType = refer('String')
              ..optionalParameters.add(refer('int')),
          ),
      ),
      equalsDart(r'''
        typedef MyMapper = String Function([int]);
      '''),
    );
  });

  test('should create a method with a nested function type return type', () {
    expect(
      Method(
        (b) => b
          ..name = 'foo'
          ..returns = FunctionType(
            (b) => b
              ..returnType = FunctionType(
                (b) => b
                  ..returnType = refer('String')
                  ..requiredParameters.add(refer('String')),
              )
              ..requiredParameters.addAll([refer('int')]),
          ),
      ),
      equalsDart(r'''
        String Function(String) Function(int) foo();
      '''),
    );
  });

  test('should create a method with a function type argument', () {
    expect(
      Method(
        (b) => b
          ..name = 'foo'
          ..requiredParameters.add(
            Parameter(
              (b) => b
                ..type = FunctionType(
                  (b) => b
                    ..returnType = refer('String')
                    ..requiredParameters.add(refer('int')),
                )
                ..name = 'argument',
            ),
          ),
      ),
      equalsDart(r'''
          foo(String Function(int) argument);
        '''),
    );
  });

  test('should create a method with a nested function type argument', () {
    expect(
      Method(
        (b) => b
          ..name = 'foo'
          ..requiredParameters.add(
            Parameter(
              (b) => b
                ..type = FunctionType(
                  (b) => b
                    ..returnType = FunctionType(
                      (b) => b
                        ..returnType = refer('String')
                        ..requiredParameters.add(refer('String')),
                    )
                    ..requiredParameters.add(refer('int')),
                )
                ..name = 'argument',
            ),
          ),
      ),
      equalsDart(r'''
          foo(String Function(String) Function(int) argument);
        '''),
    );
  });

  test('should create a method with generic types', () {
    expect(
      Method(
        (b) => b
          ..name = 'foo'
          ..types.add(refer('T')),
      ),
      equalsDart(r'''
        foo<T>();
      '''),
    );
  });

  test('should create an external method', () {
    expect(
      Method(
        (b) => b
          ..name = 'foo'
          ..external = true,
      ),
      equalsDart(r'''
        external foo();
      '''),
    );
  });

  test('should create a method with a body', () {
    expect(
      Method(
        (b) => b
          ..name = 'foo'
          ..body = const Code('return 1+ 2;'),
      ),
      equalsDart(r'''
        foo() {
          return 1 + 2;
        }
      '''),
    );
  });

  test('should create a lambda method (explicitly)', () {
    expect(
      Method(
        (b) => b
          ..name = 'foo'
          ..lambda = true
          ..body = const Code('1 + 2'),
      ),
      equalsDart(r'''
        foo() => 1 + 2
      '''),
    );
  });

  test('should create a method with a body with references', () {
    final $LinkedHashMap = refer('LinkedHashMap', 'dart:collection');
    expect(
      Method(
        (b) => b
          ..name = 'foo'
          ..body = Code.scope((a) => 'return ${a($LinkedHashMap)}();'),
      ),
      equalsDart(r'''
        foo() {
          return LinkedHashMap();
        }
      '''),
    );
  });

  test('should create a method with a parameter', () {
    expect(
      Method(
        (b) => b
          ..name = 'fib'
          ..requiredParameters.add(Parameter((b) => b.name = 'i')),
      ),
      equalsDart(r'''
        fib(i);
      '''),
    );
  });

  test('should create a method with an annotated parameter', () {
    expect(
      Method(
        (b) => b
          ..name = 'fib'
          ..requiredParameters.add(
            Parameter(
              (b) => b
                ..name = 'i'
                ..annotations.add(refer('deprecated')),
            ),
          ),
      ),
      equalsDart(r'''
        fib(@deprecated i);
      '''),
    );
  });

  test('should create a method with a parameter with a type', () {
    expect(
      Method(
        (b) => b
          ..name = 'fib'
          ..requiredParameters.add(
            Parameter(
              (b) => b
                ..name = 'i'
                ..type = refer('int').type,
            ),
          ),
      ),
      equalsDart(r'''
        fib(int i);
      '''),
    );
  });

  test('should create a method with a covariant parameter with a type', () {
    expect(
      Method(
        (b) => b
          ..name = 'fib'
          ..requiredParameters.add(
            Parameter(
              (b) => b
                ..name = 'i'
                ..covariant = true
                ..type = refer('int').type,
            ),
          ),
      ),
      equalsDart(r'''
        fib(covariant int i);
      '''),
    );
  });

  test('should create a method with a parameter with a generic type', () {
    expect(
      Method(
        (b) => b
          ..name = 'foo'
          ..types.add(
            TypeReference(
              (b) => b
                ..symbol = 'T'
                ..bound = refer('Iterable'),
            ),
          )
          ..requiredParameters.addAll([
            Parameter(
              (b) => b
                ..name = 't'
                ..type = refer('T'),
            ),
            Parameter(
              (b) => b
                ..name = 'x'
                ..type = TypeReference(
                  (b) => b
                    ..symbol = 'X'
                    ..types.add(refer('T')),
                ),
            ),
          ]),
      ),
      equalsDart(r'''
        foo<T extends Iterable>(T t, X<T> x, );
      '''),
    );
  });

  test('should create a method with an optional parameter', () {
    expect(
      Method(
        (b) => b
          ..name = 'fib'
          ..optionalParameters.add(Parameter((b) => b.name = 'i')),
      ),
      equalsDart(r'''
        fib([i]);
      '''),
    );
  });

  test('should create a method with multiple optional parameters', () {
    expect(
      Method(
        (b) => b
          ..name = 'foo'
          ..optionalParameters.addAll([
            Parameter((b) => b.name = 'a'),
            Parameter((b) => b.name = 'b'),
          ]),
      ),
      equalsDart(r'''
        foo([a, b, ]);
      '''),
    );
  });

  test('should create a method with an optional parameter with a value', () {
    expect(
      Method(
        (b) => b
          ..name = 'fib'
          ..optionalParameters.add(
            Parameter(
              (b) => b
                ..name = 'i'
                ..defaultTo = const Code('0'),
            ),
          ),
      ),
      equalsDart(r'''
        fib([i = 0]);
      '''),
    );
  });

  test('should create a method with a named required parameter', () {
    expect(
      Method(
        (b) => b
          ..name = 'fib'
          ..optionalParameters.add(
            Parameter(
              (b) => b
                ..name = 'i'
                ..named = true
                ..required = true
                ..type = refer('int').type,
            ),
          ),
      ),
      equalsDart(r'''
        fib({required int i});
      '''),
    );
  });

  test('should create a method with a named required covariant parameter', () {
    expect(
      Method(
        (b) => b
          ..name = 'fib'
          ..optionalParameters.add(
            Parameter(
              (b) => b
                ..name = 'i'
                ..named = true
                ..required = true
                ..covariant = true
                ..type = refer('int').type,
            ),
          ),
      ),
      equalsDart(r'''
        fib({required covariant int i});
      '''),
    );
  });

  test('should create a method with a named optional parameter', () {
    expect(
      Method(
        (b) => b
          ..name = 'fib'
          ..optionalParameters.add(
            Parameter(
              (b) => b
                ..named = true
                ..name = 'i',
            ),
          ),
      ),
      equalsDart(r'''
        fib({i});
      '''),
    );
  });

  test('should create a method with a named optional parameter with value', () {
    expect(
      Method(
        (b) => b
          ..name = 'fib'
          ..optionalParameters.add(
            Parameter(
              (b) => b
                ..named = true
                ..name = 'i'
                ..defaultTo = const Code('0'),
            ),
          ),
      ),
      equalsDart(r'''
        fib({i = 0});
      '''),
    );
  });

  test('should create a method with a mix of parameters', () {
    expect(
      Method(
        (b) => b
          ..name = 'foo'
          ..requiredParameters.add(Parameter((b) => b..name = 'a'))
          ..optionalParameters.add(
            Parameter(
              (b) => b
                ..named = true
                ..name = 'b',
            ),
          ),
      ),
      equalsDart(r'''
        foo(a, {b, });
      '''),
    );
  });

  test('should create a method as a closure', () {
    expect(
      Method(
        (b) => b
          ..requiredParameters.add(Parameter((b) => b..name = 'a'))
          ..body = const Code(''),
      ).closure,
      equalsDart(r'''
        (a) {}
      '''),
    );
  });
}