pkgs/code_builder/test/specs/enum_test.dart

// Copyright (c) 2020, 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 an enum', () {
    expect(
      Enum(
        (b) =>
            b
              ..name = 'E'
              ..values.addAll([
                EnumValue((b) => b..name = 'a'),
                EnumValue((b) => b..name = 'b'),
              ]),
      ),
      equalsDart(r'''
      enum E {
        a,
        b
      }
    '''),
    );
  });

  test('should create an enum with annotations', () {
    expect(
      Enum(
        (b) =>
            b
              ..annotations.addAll([
                refer('deprecated'),
                refer(
                  'Deprecated',
                ).call([literalString('This is an old enum')]),
              ])
              ..name = 'V'
              ..values.addAll([EnumValue((b) => b..name = 'x')]),
      ),
      equalsDart(r'''
      @deprecated
      @Deprecated('This is an old enum')
      enum V {
        x
      }
    '''),
    );
  });

  test('should create an enum with annotated values', () {
    expect(
      Enum(
        (b) =>
            b
              ..name = 'Status'
              ..values.addAll([
                EnumValue(
                  (b) =>
                      b
                        ..name = 'okay'
                        ..annotations.addAll([
                          refer('deprecated'),
                          refer(
                            'Deprecated',
                          ).call([literalString('use Good instead')]),
                        ]),
                ),
                EnumValue(
                  (b) =>
                      b
                        ..name = 'good'
                        ..annotations.addAll([
                          refer('JsonKey').call([literalString('good')]),
                        ]),
                ),
              ]),
      ),
      equalsDart(r'''
      enum Status {
        @deprecated
        @Deprecated('use Good instead')
        okay,
        @JsonKey('good')
        good
      }
    '''),
    );
  });

  test('should create an enum which mixes in and implements specs', () {
    final myEnum = Enum(
      (b) =>
          b
            ..name = 'MyEnum'
            ..implements.addAll(const [
              Reference('InterfaceA'),
              Reference('InterfaceB'),
            ])
            ..mixins.addAll(const [Reference('Mixin1'), Reference('Mixin2')])
            ..values.addAll([
              EnumValue((v) => v..name = 'a'),
              EnumValue((v) => v..name = 'b'),
              EnumValue((v) => v..name = 'c'),
            ]),
    );
    expect(
      myEnum,
      equalsDart('''
    enum MyEnum with Mixin1, Mixin2 implements InterfaceA, InterfaceB {
      a,
      b,
      c
    }
    '''),
    );
  });

  test('should create an enum which targets a named constructor', () {
    final myEnum = Enum(
      (b) =>
          b
            ..name = 'MyEnum'
            ..constructors.addAll([
              Constructor((c) => c..constant = true),
              Constructor(
                (c) =>
                    c
                      ..constant = true
                      ..name = 'named',
              ),
            ])
            ..values.addAll([
              EnumValue((v) => v..name = 'a'),
              EnumValue(
                (v) =>
                    v
                      ..name = 'b'
                      ..constructorName = 'named',
              ),
              EnumValue((v) => v..name = 'c'),
            ]),
    );
    expect(
      myEnum,
      equalsDart('''
    enum MyEnum {
      a,
      b.named(),
      c;

      const MyEnum();

      const MyEnum.named();
    }
    '''),
    );
  });

  test('should create an enum which targets a redirecting constructor', () {
    final myEnum = Enum(
      (b) =>
          b
            ..name = 'MyEnum'
            ..constructors.addAll([
              Constructor((c) => c..constant = true),
              Constructor(
                (c) =>
                    c
                      ..constant = true
                      ..name = 'redirect'
                      ..initializers.add(refer('this').call([]).code),
              ),
            ])
            ..values.addAll([
              EnumValue((v) => v..name = 'a'),
              EnumValue(
                (v) =>
                    v
                      ..name = 'b'
                      ..constructorName = 'redirect',
              ),
              EnumValue((v) => v..name = 'c'),
            ]),
    );
    expect(
      myEnum,
      equalsDart('''
    enum MyEnum {
      a,
      b.redirect(),
      c;

      const MyEnum();

      const MyEnum.redirect() : this();
    }
    '''),
    );
  });

  test(
    'should create an enum which targets a redirecting factory constructor',
    () {
      final myEnum = Enum(
        (b) =>
            b
              ..name = 'MyEnum'
              ..constructors.addAll([
                Constructor((c) => c..constant = true),
                Constructor(
                  (c) =>
                      c
                        ..constant = true
                        ..factory = true
                        ..name = 'redirect'
                        ..redirect = refer('MyOtherEnum.named')
                        ..optionalParameters.addAll([
                          Parameter(
                            (p) =>
                                p
                                  ..type = refer('int?')
                                  ..name = 'myInt',
                          ),
                          Parameter(
                            (p) =>
                                p
                                  ..type = refer('String?')
                                  ..name = 'myString',
                          ),
                        ]),
                ),
              ])
              ..values.addAll([
                EnumValue((v) => v..name = 'a'),
                EnumValue(
                  (v) =>
                      v
                        ..name = 'b'
                        ..constructorName = 'redirect'
                        ..arguments.addAll([
                          literalNum(1),
                          literalString('abc'),
                        ]),
                ),
                EnumValue(
                  (v) =>
                      v
                        ..name = 'c'
                        ..constructorName = 'redirect',
                ),
              ]),
      );
      expect(
        myEnum,
        equalsDart('''
    enum MyEnum {
      a,
      b.redirect(1, 'abc'),
      c.redirect();

      const MyEnum();

      const factory MyEnum.redirect([
          int? myInt,
          String? myString,
      ]) = MyOtherEnum.named;
    }
    '''),
      );
    },
  );

  test('should create an enum which targets an unnamed constructor', () {
    final myEnum = Enum(
      (b) =>
          b
            ..name = 'MyEnum'
            ..constructors.add(
              Constructor(
                (c) =>
                    c
                      ..constant = true
                      ..optionalParameters.addAll([
                        Parameter(
                          (p) =>
                              p
                                ..toThis = true
                                ..name = 'myInt',
                        ),
                        Parameter(
                          (p) =>
                              p
                                ..toThis = true
                                ..name = 'myString',
                        ),
                      ]),
              ),
            )
            ..fields.addAll([
              Field(
                (f) =>
                    f
                      ..modifier = FieldModifier.final$
                      ..type = refer('int?')
                      ..name = 'myInt',
              ),
              Field(
                (f) =>
                    f
                      ..modifier = FieldModifier.final$
                      ..type = refer('String?')
                      ..name = 'myString',
              ),
            ])
            ..values.addAll([
              EnumValue((v) => v..name = 'a'),
              EnumValue(
                (v) =>
                    v
                      ..name = 'b'
                      ..arguments.addAll([literalNum(1), literalString('abc')]),
              ),
              EnumValue((v) => v..name = 'c'),
            ]),
    );
    expect(
      myEnum,
      equalsDart('''
    enum MyEnum {
      a,
      b(1, 'abc'),
      c;

      const MyEnum([
          this.myInt,
          this.myString,
      ]);

      final int? myInt;

      final String? myString;
    }
    '''),
    );
  });

  test('should create an enum with generics', () {
    final myEnum = Enum(
      (b) =>
          b
            ..name = 'MyEnum'
            ..types.add(const Reference('T'))
            ..constructors.add(
              Constructor(
                (c) =>
                    c
                      ..constant = true
                      ..requiredParameters.add(
                        Parameter(
                          (p) =>
                              p
                                ..toThis = true
                                ..name = 'value',
                        ),
                      ),
              ),
            )
            ..fields.add(
              Field(
                (f) =>
                    f
                      ..modifier = FieldModifier.final$
                      ..type = refer('T')
                      ..name = 'value',
              ),
            )
            ..values.addAll([
              EnumValue(
                (v) =>
                    v
                      ..name = 'a'
                      ..types.add(const Reference('int'))
                      ..arguments.add(literalNum(123)),
              ),
              EnumValue(
                (v) =>
                    v
                      ..name = 'b'
                      ..types.add(const Reference('String'))
                      ..arguments.add(literalString('abc')),
              ),
              EnumValue(
                (v) =>
                    v
                      ..name = 'c'
                      ..types.add(const Reference('MyEnum'))
                      ..arguments.add(refer('MyEnum').property('a')),
              ),
            ]),
    );
    expect(
      myEnum,
      equalsDart('''
    enum MyEnum<T> {
      a<int>(123),
      b<String>('abc'),
      c<MyEnum>(MyEnum.a);

      const MyEnum(this.value);

      final T value;
    }
    '''),
    );
  });

  test('should create an enum with fields', () {
    final myEnum = Enum(
      (b) =>
          b
            ..name = 'MyEnum'
            ..constructors.add(
              Constructor(
                (c) =>
                    c
                      ..constant = true
                      ..optionalParameters.add(
                        Parameter(
                          (p) =>
                              p
                                ..toThis = true
                                ..name = 'myInt',
                        ),
                      ),
              ),
            )
            ..fields.addAll([
              Field(
                (f) =>
                    f
                      ..modifier = FieldModifier.final$
                      ..type = refer('int?')
                      ..name = 'myInt',
              ),
              Field(
                (f) =>
                    f
                      ..static = true
                      ..modifier = FieldModifier.constant
                      ..type = refer('String')
                      ..name = 'myString'
                      ..assignment = literalString('abc').code,
              ),
            ])
            ..values.addAll([
              EnumValue((v) => v..name = 'a'),
              EnumValue((v) => v..name = 'b'),
              EnumValue((v) => v..name = 'c'),
            ]),
    );
    expect(
      myEnum,
      equalsDart('''
    enum MyEnum {
      a,
      b,
      c;

      const MyEnum([this.myInt]);

      final int? myInt;

      static const String myString = 'abc';
    }
    '''),
    );
  });

  test('should create an enum with methods', () {
    final myEnum = Enum(
      (b) =>
          b
            ..name = 'MyEnum'
            ..methods.addAll([
              Method(
                (m) =>
                    m
                      ..returns = refer('int')
                      ..type = MethodType.getter
                      ..name = 'myInt'
                      ..body = literalNum(123).code,
              ),
              Method(
                (m) =>
                    m
                      ..returns = refer('Iterable<String>')
                      ..name = 'myStrings'
                      ..modifier = MethodModifier.syncStar
                      ..body = Block.of(const [
                        Code("yield 'a';"),
                        Code("yield 'b';"),
                        Code("yield 'c';"),
                      ]),
              ),
            ])
            ..values.addAll([
              EnumValue((v) => v..name = 'a'),
              EnumValue((v) => v..name = 'b'),
              EnumValue((v) => v..name = 'c'),
            ]),
    );
    expect(
      myEnum,
      equalsDart('''
    enum MyEnum {
      a,
      b,
      c;

      int get myInt => 123;

      Iterable<String> myStrings() sync* {
        yield 'a';
        yield 'b';
        yield 'c';
      }
    }
    '''),
    );
  });

  test(
    'should create an enum which named and unnamed constructor parameters',
    () {
      final myEnum = Enum(
        (b) =>
            b
              ..name = 'MyEnum'
              ..constructors.add(
                Constructor(
                  (c) =>
                      c
                        ..constant = true
                        ..requiredParameters.addAll([
                          Parameter(
                            (p) =>
                                p
                                  ..toThis = true
                                  ..name = 'myInt',
                          ),
                        ])
                        ..optionalParameters.addAll([
                          Parameter(
                            (p) =>
                                p
                                  ..toThis = true
                                  ..named = true
                                  ..required = true
                                  ..name = 'myString',
                          ),
                        ]),
                ),
              )
              ..fields.addAll([
                Field(
                  (f) =>
                      f
                        ..modifier = FieldModifier.final$
                        ..type = refer('int?')
                        ..name = 'myInt',
                ),
                Field(
                  (f) =>
                      f
                        ..modifier = FieldModifier.final$
                        ..type = refer('String?')
                        ..name = 'myString',
                ),
              ])
              ..values.addAll([
                EnumValue((v) => v..name = 'a'),
                EnumValue(
                  (v) =>
                      v
                        ..name = 'b'
                        ..arguments.addAll([literalNum(1)])
                        ..namedArguments.addAll({
                          'myString': literalString('abc'),
                        }),
                ),
                EnumValue((v) => v..name = 'c'),
              ]),
      );
      expect(
        myEnum,
        equalsDart('''
    enum MyEnum {
      a,
      b(1, myString: 'abc'),
      c;

      const MyEnum(
          this.myInt,
          {required this.myString, }
      );

      final int? myInt;

      final String? myString;
    }
    '''),
      );
    },
  );
}