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) { }
      '''),
    );
  });
}