Google Git
Sign in
dart / mockito / 78c650b29255e4ad62b4c3108e06aeb1d47f2910 / . / test / builder / auto_mocks_test.dart
blob: 31a62447b186574abc3f6a080815e13982151afb [file] [log] [blame]
// Copyright 2019 Dart Mockito authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
@TestOn('vm')
import 'dart:convert' show utf8;
import 'package:build/build.dart';
import 'package:build/experiments.dart';
import 'package:build_test/build_test.dart';
import 'package:mockito/src/builder.dart';
import 'package:package_config/package_config.dart';
import 'package:test/test.dart';
const annotationsAsset = {
'mockito|lib/annotations.dart': '''
class GenerateMocks {
final List<Type> classes;
final List<MockSpec> customMocks;
const GenerateMocks(this.classes, {this.customMocks = const []});
}
class MockSpec<T> {
final Symbol? mockName;
final bool returnNullOnMissingStub;
final Set<Symbol> unsupportedMembers;
final Map<Symbol, Function> fallbackGenerators;
const MockSpec({
Symbol? as,
this.returnNullOnMissingStub = false,
this.unsupportedMembers = const {},
this.fallbackGenerators = const {},
})
: mockName = as;
}
'''
};
const mockitoAssets = {
'mockito|lib/mockito.dart': '''
export 'src/mock.dart';
''',
'mockito|lib/src/mock.dart': '''
class Mock {}
'''
};
const metaAssets = {
'meta|lib/meta.dart': '''
library meta;
class _Immutable {
const _Immutable();
}
const immutable = _Immutable();
'''
};
const simpleTestAsset = {
'foo|test/foo_test.dart': '''
import 'package:foo/foo.dart';
import 'package:mockito/annotations.dart';
@GenerateMocks([Foo])
void main() {}
'''
};
void main() {
late InMemoryAssetWriter writer;
/// Test [MockBuilder] in a package which has not opted into null safety.
Future<void> testPreNonNullable(Map<String, String> sourceAssets,
{Map<String, /*String|Matcher<String>*/ Object>? outputs,
Map<String, dynamic> config = const <String, dynamic>{}}) async {
final packageConfig = PackageConfig([
Package('foo', Uri.file('/foo/'),
packageUriRoot: Uri.file('/foo/lib/'),
languageVersion: LanguageVersion(2, 7))
]);
await testBuilder(buildMocks(BuilderOptions(config)), sourceAssets,
writer: writer, outputs: outputs, packageConfig: packageConfig);
}
/// Test [MockBuilder] in a package which has opted into null safety.
Future<void> testWithNonNullable(Map<String, String> sourceAssets,
{Map<String, /*String|Matcher<List<int>>*/ Object>? outputs,
Map<String, dynamic> config = const <String, dynamic>{}}) async {
final packageConfig = PackageConfig([
Package('foo', Uri.file('/foo/'),
packageUriRoot: Uri.file('/foo/lib/'),
languageVersion: LanguageVersion(3, 0))
]);
await testBuilder(buildMocks(BuilderOptions(config)), sourceAssets,
writer: writer, outputs: outputs, packageConfig: packageConfig);
}
/// Builds with [MockBuilder] in a package which has opted into null safety,
/// returning the content of the generated mocks library.
Future<String> buildWithNonNullable(Map<String, String> sourceAssets) async {
final packageConfig = PackageConfig([
Package('foo', Uri.file('/foo/'),
packageUriRoot: Uri.file('/foo/lib/'),
languageVersion: LanguageVersion(3, 0))
]);
await testBuilder(buildMocks(BuilderOptions({})), sourceAssets,
writer: writer, packageConfig: packageConfig);
final mocksAsset = AssetId('foo', 'test/foo_test.mocks.dart');
return utf8.decode(writer.assets[mocksAsset]!);
}
/// Test [MockBuilder] on a single source file, in a package which has opted
/// into null safety, and with the non-nullable experiment enabled.
Future<void> expectSingleNonNullableOutput(String sourceAssetText,
/*String|Matcher<List<int>>*/ Object output) async {
await testWithNonNullable({
...metaAssets,
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': sourceAssetText,
}, outputs: {
'foo|test/foo_test.mocks.dart': output
});
}
/// Builds with [MockBuilder] in a package which has opted into the
/// non-nullable type system, returning the content of the generated mocks
/// library.
Future<String> buildWithSingleNonNullableSource(
String sourceAssetText) async {
await testWithNonNullable({
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': sourceAssetText,
});
final mocksAsset = AssetId('foo', 'test/foo_test.mocks.dart');
return utf8.decode(writer.assets[mocksAsset]!);
}
setUp(() {
writer = InMemoryAssetWriter();
});
test(
'generates a mock class but does not override methods w/ zero parameters',
() async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
class Foo {
dynamic method1() => 7;
}
'''));
expect(mocksContent,
contains('class MockFoo extends _i1.Mock implements _i2.Foo'));
expect(mocksContent, isNot(contains('method1')));
});
test('generates a mock class but does not override private methods',
() async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
class Foo {
int _method1(int x) => 8;
}
'''));
expect(mocksContent,
contains('class MockFoo extends _i1.Mock implements _i2.Foo'));
expect(mocksContent, isNot(contains('method1')));
});
test('generates a mock class but does not override static methods', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
class Foo {
static int method1(int y) => 9;
}
'''));
expect(mocksContent, isNot(contains('method1')));
});
test('generates a mock class but does not override any extension methods',
() async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
extension X on Foo {
dynamic x(int m, String n) => n + 1;
}
class Foo {}
'''));
expect(mocksContent,
contains('class MockFoo extends _i1.Mock implements _i2.Foo'));
});
test('overrides methods, matching required positional parameters', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
void m(int a) {}
}
'''),
_containsAllOf('void m(int? a) => super.noSuchMethod('),
);
});
test('overrides methods, matching optional positional parameters', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
void m(int a, [int b, int c = 0]) {}
}
'''),
_containsAllOf(dedent2('''
void m(
int? a, [
int? b,
int? c = 0,
]) =>
''')),
);
});
test('overrides methods, matching named parameters', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
void m(int a, {int b, int c = 0}) {}
}
'''),
_containsAllOf(dedent2('''
void m(
int? a, {
int? b,
int? c = 0,
}) =>
''')),
);
});
test('matches parameter default values', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
void m([int a, int b = 0]) {}
}
'''),
_containsAllOf(dedent2('''
void m([
int? a,
int? b = 0,
]) =>''')),
);
});
test('matches boolean literal parameter default values', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
void m([bool a = true, bool b = false]) {}
}
'''),
_containsAllOf(dedent2('''
void m([
bool? a = true,
bool? b = false,
]) =>
''')),
);
});
test('matches number literal parameter default values', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
void m([int a = 0, double b = 0.5]) {}
}
'''),
_containsAllOf(dedent2('''
void m([
int? a = 0,
double? b = 0.5,
]) =>
''')),
);
});
test('matches string literal parameter default values', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
void m([String a = 'Hello', String b = 'Hello ' r"World"]) {}
}
'''),
_containsAllOf(dedent2('''
void m([
String? a = r'Hello',
String? b = r'Hello World',
]) =>
''')),
);
});
test('matches empty collection literal parameter default values', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
void m([List<int> a = const [], Map<int, int> b = const {}]) {}
}
'''),
_containsAllOf(dedent2('''
void m([
List<int>? a = const [],
Map<int, int>? b = const {},
]) =>
''')),
);
});
test('matches non-empty list literal parameter default values', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
void m([List<int> a = const [1, 2, 3]]) {}
}
'''),
_containsAllOf(dedent2('''
void m(
[List<int>? a = const [
1,
2,
3,
]]) =>
''')),
);
});
test('matches non-empty map literal parameter default values', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
void m([Map<int, String> a = const {1: 'a', 2: 'b'}]) {}
}
'''),
_containsAllOf(dedent2('''
void m(
[Map<int, String>? a = const {
1: r'a',
2: r'b',
}]) =>
''')),
);
});
test('matches non-empty map literal parameter default values', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
void m([Map<int, String> a = const {1: 'a', 2: 'b'}]) {}
}
'''),
_containsAllOf(dedent2('''
void m(
[Map<int, String>? a = const {
1: r'a',
2: r'b',
}]) =>
''')),
);
});
test('matches parameter default values constructed from a local class',
() async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
void m([Bar a = const Bar()]) {}
}
class Bar {
const Bar();
}
'''),
_containsAllOf(
'void m([_i2.Bar? a = const _i2.Bar()]) => super.noSuchMethod('),
);
});
test('matches parameter default values constructed from a Dart SDK class',
() async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
void m([Duration a = const Duration(days: 1)]) {}
}
'''),
_containsAllOf(
'void m([Duration? a = const Duration(days: 1)]) => super.noSuchMethod('),
);
});
test('matches parameter default values constructed from a named constructor',
() async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
void m([Bar a = const Bar.named()]) {}
}
class Bar {
const Bar.named();
}
'''),
_containsAllOf(
'void m([_i2.Bar? a = const _i2.Bar.named()]) => super.noSuchMethod('),
);
});
test('matches parameter default values constructed with positional arguments',
() async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
void m([Bar a = const Bar(7)]) {}
}
class Bar {
final int i;
const Bar(this.i);
}
'''),
_containsAllOf(
'void m([_i2.Bar? a = const _i2.Bar(7)]) => super.noSuchMethod('),
);
});
test('matches parameter default values constructed with named arguments',
() async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
void m([Bar a = const Bar(i: 7)]) {}
}
class Bar {
final int i;
const Bar({this.i});
}
'''),
_containsAllOf(
'void m([_i2.Bar? a = const _i2.Bar(i: 7)]) => super.noSuchMethod('),
);
});
test('matches parameter default values constructed with top-level variable',
() async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
void m([int a = x]) {}
}
const x = 1;
'''),
_containsAllOf('void m([int? a = 1]) => super.noSuchMethod('),
);
});
test('matches parameter default values constructed with top-level function',
() async {
await expectSingleNonNullableOutput(
dedent(r'''
typedef Callback = void Function();
void defaultCallback() {}
class Foo {
void m([Callback a = defaultCallback]) {}
}
'''),
_containsAllOf(
'void m([_i2.Callback? a = _i2.defaultCallback]) => super.noSuchMethod('),
);
});
test('matches parameter default values constructed with static field',
() async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
static const x = 1;
void m([int a = x]) {}
}
'''),
_containsAllOf('void m([int? a = 1]) => super.noSuchMethod('),
);
});
test('throws when given a parameter default value using a private type', () {
_expectBuilderThrows(
assets: {
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo {
void m([Bar a = const _Bar()]) {}
}
class Bar {}
class _Bar implements Bar {
const _Bar();
}
'''),
},
message: contains(
"Mockito cannot generate a valid override for method 'Foo.m'; "
"parameter 'a' causes a problem: default value has a private type: "
'asset:foo/lib/foo.dart#_Bar'),
);
});
test(
'throws when given a parameter default value using a private type, and '
'refers to the class-to-mock', () {
_expectBuilderThrows(
assets: {
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent(r'''
class FooBase {
void m([Bar a = const _Bar()]) {}
}
class Foo extends FooBase {}
class Bar {}
class _Bar implements Bar {
const _Bar();
}
'''),
},
message: contains(
"Mockito cannot generate a valid override for method 'Foo.m'; "
"parameter 'a' causes a problem: default value has a private type: "
'asset:foo/lib/foo.dart#_Bar'),
);
});
test(
'throws when given a parameter default value using a private constructor',
() {
_expectBuilderThrows(
assets: {
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo {
void m([Bar a = const Bar._named()]) {}
}
class Bar {
const Bar._named();
}
'''),
},
message: contains(
"Mockito cannot generate a valid override for method 'Foo.m'; "
"parameter 'a' causes a problem: default value has a private type: "
'asset:foo/lib/foo.dart#Bar::_named'),
);
});
test('throws when given a parameter default value which is a type', () {
_expectBuilderThrows(
assets: {
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo {
void m([Type a = int]) {}
}
'''),
},
message: contains('Mockito cannot generate a valid override for method '
"'Foo.m'; parameter 'a' causes a problem: default value is a Type: "
'int'),
);
});
test('overrides async methods legally', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
Future<void> m() async => print(s);
}
'''),
_containsAllOf('_i3.Future<void> m() => (super.noSuchMethod('),
);
});
test('overrides async* methods legally', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
Stream<int> m() async* { yield 7; }
}
'''),
_containsAllOf('_i3.Stream<int> m() => (super.noSuchMethod('),
);
});
test('overrides sync* methods legally', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
Iterable<int> m() sync* { yield 7; }
}
'''),
_containsAllOf('Iterable<int> m() => (super.noSuchMethod('),
);
});
test('overrides methods of super classes', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class FooBase {
void m(int a) {}
}
class Foo extends FooBase {}
'''),
_containsAllOf('void m(int? a) => super.noSuchMethod('),
);
});
test('overrides methods of generic super classes, substituting types',
() async {
await expectSingleNonNullableOutput(
dedent(r'''
class FooBase<T> {
void m(T a) {}
}
class Foo extends FooBase<int> {}
'''),
_containsAllOf('void m(int? a) => super.noSuchMethod('),
);
});
test('overrides methods of mixed in classes, substituting types', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Mixin<T> {
void m(T a) {}
}
class Foo with Mixin<int> {}
'''),
_containsAllOf('void m(int? a) => super.noSuchMethod('),
);
});
test('overrides methods of mixed in classes, from hierarchy', () async {
await expectSingleNonNullableOutput(
dedent(r'''
mixin Mixin {
void m(int a) {}
}
class FooBase with Mixin {}
class Foo extends FooBase {}
'''),
_containsAllOf('void m(int? a) => super.noSuchMethod('),
);
});
test('overrides mixed in methods, using correct overriding signature',
() async {
await expectSingleNonNullableOutput(
dedent(r'''
class Base {
void m(int a) {}
}
mixin MixinConstraint implements Base {}
mixin Mixin on MixinConstraint {
@override
void m(num a) {}
}
class Foo with MixinConstraint, Mixin {}
'''),
_containsAllOf('void m(num? a) => super.noSuchMethod('),
);
});
test('overrides methods of implemented classes', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Interface<T> {
void m(T a) {}
}
class Foo implements Interface<int> {}
'''),
_containsAllOf('void m(int? a) => super.noSuchMethod('),
);
});
test('overrides fields of implemented classes', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Interface<T> {
int m;
}
class Foo implements Interface<int> {}
'''),
_containsAllOf(
'int get m => (super.noSuchMethod(',
'set m(int? _m) => super.noSuchMethod(',
),
);
});
test(
'overrides methods of indirect generic super classes, substituting types',
() async {
await expectSingleNonNullableOutput(
dedent(r'''
class FooBase2<T> {
void m(T a) {}
}
class FooBase1<T> extends FooBase2<T> {}
class Foo extends FooBase2<int> {}
'''),
_containsAllOf('void m(int? a) => super.noSuchMethod('),
);
});
test('overrides methods of generic super classes using void', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class FooBase<T> {
T m() {}
}
class Foo extends FooBase<void> {}
'''),
_containsAllOf('void m() => super.noSuchMethod('),
);
});
test('overrides methods of generic super classes (type variable)', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class FooBase<T> {
void m(T a) {}
}
class Foo<T> extends FooBase<T> {}
'''),
_containsAllOf('void m(T? a) => super.noSuchMethod('),
);
});
test('overrides methods, adjusting imports for names that conflict with core',
() async {
await expectSingleNonNullableOutput(
dedent('''
import 'dart:core' as core;
class Foo {
void List(core.int a) {}
core.List<core.String> m() => [];
}
'''),
_containsAllOf(
' void List(int? a) => super.noSuchMethod(\n',
' _i3.List<String> m() => (super.noSuchMethod(\n',
));
});
test(
'overrides `toString` with a correct signature if the class overrides '
'it', () async {
await expectSingleNonNullableOutput(
dedent('''
abstract class Foo {
String toString({bool a = false});
}
'''),
_containsAllOf('String toString({bool? a = false}) => super.toString()'),
);
});
test(
'does not override `toString` if the class does not override `toString` '
'with additional parameters', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent('''
abstract class Foo {
String toString() => 'Foo';
}
'''));
expect(mocksContent, isNot(contains('toString')));
});
test(
'overrides `toString` with a correct signature if a mixed in class '
'overrides it, in a Fake', () async {
await expectSingleNonNullableOutput(
dedent('''
abstract class Foo {
Bar m();
}
abstract class BarBase {
String toString({bool a = false});
}
abstract class Bar extends BarBase {}
'''),
_containsAllOf('String toString({bool? a = false}) => super.toString()'),
);
});
test('does not override `operator==`, even if the class overrides it',
() async {
final mocksContent = await buildWithSingleNonNullableSource(dedent('''
class Foo {
bool operator==(Object? other);
}
'''));
expect(mocksContent, isNot(contains('==')));
});
test('does not override `hashCode`, even if the class overrides it',
() async {
final mocksContent = await buildWithSingleNonNullableSource(dedent('''
class Foo {
final int hashCode = 7;
}
'''));
expect(mocksContent, isNot(contains('hashCode')));
});
test('generates mock classes from part files', () async {
final mocksOutput = await buildWithNonNullable({
...annotationsAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo {}
'''),
'foo|test/foo_test.dart': '''
import 'package:foo/foo.dart';
import 'package:mockito/annotations.dart';
part 'part.dart';
''',
'foo|test/part.dart': '''
part of 'foo_test.dart';
@GenerateMocks([Foo])
void fooTests() {}
'''
});
expect(mocksOutput,
contains('class MockFoo extends _i1.Mock implements _i2.Foo'));
});
test('does not crash upon finding non-library files', () async {
await testWithNonNullable(
{
...annotationsAsset,
'foo|lib/foo.dart': dedent('class Foo {}'),
'foo|test/foo_test.dart': "part 'part.dart';",
'foo|test/part.dart': "part of 'foo_test.dart';",
},
outputs: {},
);
});
test('generates mock classes from an annotation on an import directive',
() async {
final mocksOutput = await buildWithNonNullable({
...annotationsAsset,
'foo|lib/foo.dart': dedent(r'class Foo {} class Bar {}'),
'foo|test/foo_test.dart': '''
@GenerateMocks([Foo])
import 'package:foo/foo.dart';
import 'package:mockito/annotations.dart';
'''
});
expect(mocksOutput,
contains('class MockFoo extends _i1.Mock implements _i2.Foo'));
});
test('generates mock classes from an annotation on an export directive',
() async {
final mocksOutput = await buildWithNonNullable({
...annotationsAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo {}
class Bar {}
'''),
'foo|test/foo_test.dart': '''
@GenerateMocks([Foo])
export 'dart:core';
import 'package:foo/foo.dart';
import 'package:mockito/annotations.dart';
'''
});
expect(mocksOutput,
contains('class MockFoo extends _i1.Mock implements _i2.Foo'));
});
test('generates multiple mock classes', () async {
final mocksOutput = await buildWithNonNullable({
...annotationsAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo {}
class Bar {}
'''),
'foo|test/foo_test.dart': '''
import 'package:foo/foo.dart';
import 'package:mockito/annotations.dart';
@GenerateMocks([Foo, Bar])
void main() {}
'''
});
expect(mocksOutput,
contains('class MockFoo extends _i1.Mock implements _i2.Foo'));
expect(mocksOutput,
contains('class MockBar extends _i1.Mock implements _i2.Bar'));
});
test('generates mock classes from multiple annotations', () async {
final mocksOutput = await buildWithNonNullable({
...annotationsAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo {}
class Bar {}
'''),
'foo|test/foo_test.dart': '''
import 'package:foo/foo.dart';
import 'package:mockito/annotations.dart';
@GenerateMocks([Foo])
void fooTests() {}
@GenerateMocks([Bar])
void barTests() {}
'''
});
expect(mocksOutput,
contains('class MockFoo extends _i1.Mock implements _i2.Foo'));
expect(mocksOutput,
contains('class MockBar extends _i1.Mock implements _i2.Bar'));
});
test('generates mock classes from multiple annotations on a single element',
() async {
final mocksOutput = await buildWithNonNullable({
...annotationsAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo {}
class Bar {}
'''),
'foo|test/foo_test.dart': '''
import 'package:foo/foo.dart';
import 'package:mockito/annotations.dart';
@GenerateMocks([Foo])
@GenerateMocks([Bar])
void barTests() {}
'''
});
expect(mocksOutput,
contains('class MockFoo extends _i1.Mock implements _i2.Foo'));
expect(mocksOutput,
contains('class MockBar extends _i1.Mock implements _i2.Bar'));
});
test('generates generic mock classes', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
class Foo<T, U> {}
'''));
expect(
mocksContent,
contains(
'class MockFoo<T, U> extends _i1.Mock implements _i2.Foo<T, U>'));
});
test('generates generic mock classes with type bounds', () async {
final mocksOutput = await buildWithNonNullable({
...annotationsAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo {}
class Bar<T extends Foo> {}
'''),
'foo|test/foo_test.dart': '''
import 'package:foo/foo.dart';
import 'package:mockito/annotations.dart';
@GenerateMocks([Foo, Bar])
void main() {}
'''
});
expect(mocksOutput,
contains('class MockFoo extends _i1.Mock implements _i2.Foo'));
expect(
mocksOutput,
contains('class MockBar<T extends _i2.Foo> extends _i1.Mock '
'implements _i2.Bar<T>'));
});
test('writes dynamic, void w/o import prefix', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
void m(dynamic a, int b) {}
}
'''),
_containsAllOf(dedent2('''
void m(
dynamic a,
int? b,
) =>
''')),
);
});
test('matches function parameters with scoped return types', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
void m<T>(T Function() a) {}
}
'''),
_containsAllOf('void m<T>(T Function()? a) => super.noSuchMethod('),
);
});
test('writes type variables types w/o import prefixes', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
void m<T>(T a) {}
}
'''),
_containsAllOf('void m<T>(T? a) => super.noSuchMethod('),
);
});
test('imports libraries for external class types', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
import 'dart:async';
class Foo {
dynamic f(List<Foo> list) {}
}
'''));
expect(mocksContent, contains("import 'package:foo/foo.dart' as _i2;"));
expect(mocksContent, contains('implements _i2.Foo'));
expect(mocksContent, contains('List<_i2.Foo>? list'));
});
test('imports libraries for external class types declared in parts',
() async {
final mocksContent = await buildWithNonNullable({
...annotationsAsset,
'foo|lib/foo.dart': dedent(r'''
part 'foo_part.dart';
'''),
'foo|lib/foo_part.dart': dedent(r'''
part of 'foo.dart';
class Foo {}
'''),
'foo|test/foo_test.dart': '''
import 'package:foo/foo.dart';
import 'package:mockito/annotations.dart';
@GenerateMocks([Foo])
void fooTests() {}
'''
});
expect(mocksContent, contains("import 'package:foo/foo.dart' as _i2;"));
expect(mocksContent,
contains('class MockFoo extends _i1.Mock implements _i2.Foo'));
});
test(
'imports libraries for external class types found in a method return '
'type', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
import 'dart:async';
class Foo {
Future<void> f() async {}
}
'''));
expect(mocksContent, contains("import 'dart:async' as _i3;"));
expect(mocksContent, contains('_i3.Future<void> f()'));
});
test('imports libraries for external class types found in a type argument',
() async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
import 'dart:async';
class Foo {
List<Future> f() => [];
}
'''));
expect(mocksContent, contains("import 'dart:async' as _i3;"));
expect(mocksContent, contains('List<_i3.Future<dynamic>> f()'));
});
test(
'imports libraries for external class types found in the return type of '
'a function-typed parameter', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
import 'dart:async';
class Foo {
void f(Future<void> a()) {}
}
'''));
expect(mocksContent, contains("import 'dart:async' as _i3;"));
expect(mocksContent, contains('f(_i3.Future<void> Function()? a)'));
});
test(
'imports libraries for external class types found in a parameter type of '
'a function-typed parameter', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
import 'dart:async';
class Foo {
void f(void a(Future<int> b)) {}
}
'''));
expect(mocksContent, contains("import 'dart:async' as _i3;"));
expect(mocksContent, contains('f(void Function(_i3.Future<int>)? a)'));
});
test(
'imports libraries for external class types found in a function-typed '
'parameter', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
import 'dart:async';
class Foo {
void f(Future<void> a()) {}
}
'''));
expect(mocksContent, contains("import 'dart:async' as _i3;"));
expect(mocksContent, contains('f(_i3.Future<void> Function()? a)'));
});
test(
'imports libraries for external class types found in a FunctionType '
'parameter', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
import 'dart:async';
class Foo {
void f(Future<void> Function() a) {}
}
'''));
expect(mocksContent, contains("import 'dart:async' as _i3;"));
expect(mocksContent, contains('f(_i3.Future<void> Function()? a)'));
});
test(
'imports libraries for external class types found nested in a '
'function-typed parameter', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
import 'dart:async';
class Foo {
void f(void a(Future<void> b)) {}
}
'''));
expect(mocksContent, contains("import 'dart:async' as _i3;"));
expect(mocksContent, contains('f(void Function(_i3.Future<void>)? a)'));
});
test(
'imports libraries for external class types found in the bound of a '
'type parameter of a method', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
import 'dart:async';
class Foo {
void f<T extends Future>(T a) {}
}
'''));
expect(mocksContent, contains("import 'dart:async' as _i3;"));
expect(mocksContent, contains('f<T extends _i3.Future<dynamic>>(T? a)'));
});
test(
'imports libraries for external class types found in the default value '
'of a parameter', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
import 'dart:convert';
class Foo {
void f([Object a = utf8]) {}
}
'''));
expect(mocksContent, contains("import 'dart:convert' as _i3;"));
expect(mocksContent, contains('f([Object? a = const _i3.Utf8Codec()])'));
});
test(
'imports libraries for external class types found in an inherited method',
() async {
await testWithNonNullable({
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': '''
import 'bar.dart';
class Foo extends Bar {}
''',
'foo|lib/bar.dart': '''
import 'dart:async';
class Bar {
m(Future<void> a) {}
}
''',
});
final mocksAsset = AssetId('foo', 'test/foo_test.mocks.dart');
final mocksContent = utf8.decode(writer.assets[mocksAsset]!);
expect(mocksContent, contains("import 'dart:async' as _i3;"));
expect(mocksContent, contains('m(_i3.Future<void>? a)'));
});
test(
'imports libraries for external class types found in an inherited method '
'via a generic instantiation', () async {
await testWithNonNullable({
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': '''
import 'dart:async';
import 'bar.dart';
class Foo extends Bar<Future<void>> {}
''',
'foo|lib/bar.dart': '''
class Bar<T> {
m(T a) {}
}
''',
});
final mocksAsset = AssetId('foo', 'test/foo_test.mocks.dart');
final mocksContent = utf8.decode(writer.assets[mocksAsset]!);
expect(mocksContent, contains("import 'dart:async' as _i3;"));
expect(mocksContent, contains('m(_i3.Future<void>? a)'));
});
test('imports libraries for type aliases with external types', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
import 'dart:async';
typedef Callback = void Function();
typedef void Callback2();
typedef Future<T> Callback3<T>();
class Foo {
dynamic f(Callback c) {}
dynamic g(Callback2 c) {}
dynamic h(Callback3<Foo> c) {}
}
'''));
expect(mocksContent, contains("import 'package:foo/foo.dart' as _i2;"));
expect(mocksContent, contains('implements _i2.Foo'));
expect(mocksContent, contains('_i2.Callback? c'));
expect(mocksContent, contains('_i2.Callback2? c'));
expect(mocksContent, contains('_i2.Callback3<_i2.Foo>? c'));
});
test('imports libraries for type aliases with external types 2', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
import 'dart:async';
typedef Ignore<T> = String Function(int);
class Foo {
dynamic f(Ignore<Future<int>> c) {}
dynamic g(Ignore<Future> c) {}
}
'''));
expect(mocksContent, contains("import 'package:foo/foo.dart' as _i2;"));
expect(mocksContent, contains("import 'dart:async' as _i3;"));
expect(mocksContent, contains('implements _i2.Foo'));
expect(mocksContent, contains('_i2.Ignore<_i3.Future<int>>? c'));
expect(mocksContent, contains('_i2.Ignore<_i3.Future<dynamic>>? c'));
});
test('imports libraries for types declared in private SDK libraries',
() async {
final mocksContent = await buildWithSingleNonNullableSource(dedent('''
import 'dart:io';
abstract class Foo {
HttpClient f() {}
}
'''));
expect(mocksContent, contains("import 'dart:io' as _i2;"));
expect(mocksContent, contains('_i2.HttpClient f() =>'));
});
test(
'imports libraries for types declared in private SDK libraries exported '
'in dart:io', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent('''
import 'dart:io';
abstract class Foo {
HttpStatus f() {}
}
'''));
expect(mocksContent, contains("import 'dart:io' as _i2;"));
expect(mocksContent, contains('_i2.HttpStatus f() =>'));
});
test(
'imports libraries for types declared in private SDK libraries exported '
'in dart:html', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent('''
import 'dart:html';
abstract class Foo {
HttpStatus f() {}
}
'''));
expect(mocksContent, contains("import 'dart:html' as _i2;"));
expect(mocksContent, contains('_i2.HttpStatus f() =>'));
});
test('imports libraries which export external class types', () async {
await testWithNonNullable({
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': '''
import 'types.dart';
abstract class Foo {
void m(Bar a);
}
''',
'foo|lib/types.dart': '''
export 'base.dart' if (dart.library.html) 'html.dart';
''',
'foo|lib/base.dart': '''
class Bar {}
''',
'foo|lib/html.dart': '''
class Bar {}
''',
});
final mocksAsset = AssetId('foo', 'test/foo_test.mocks.dart');
final mocksContent = utf8.decode(writer.assets[mocksAsset]!);
expect(mocksContent, contains("import 'package:foo/types.dart' as _i3;"));
expect(mocksContent, contains('m(_i3.Bar? a)'));
});
test('imports dart:core with a prefix when members conflict with dart:core',
() async {
await expectSingleNonNullableOutput(
dedent('''
import 'dart:core' as core;
class Foo {
void List(int a) {}
core.List<String> m() => [];
}
'''),
_containsAllOf(
"import 'dart:core' hide List;",
"import 'dart:core' as _i3;",
),
);
});
test('prefixes parameter type on generic function-typed parameter', () async {
await expectSingleNonNullableOutput(
dedent(r'''
import 'dart:async';
class Foo {
dynamic m(void Function(Foo f) a) {}
}
'''),
_containsAllOf(
'dynamic m(void Function(_i2.Foo)? a) => super.noSuchMethod(Invocation.method('),
);
});
test('prefixes return type on generic function-typed parameter', () async {
await expectSingleNonNullableOutput(
dedent(r'''
import 'dart:async';
class Foo {
void m(Foo Function() a) {}
}
'''),
_containsAllOf('void m(_i2.Foo Function()? a) => super.noSuchMethod('),
);
});
test('prefixes parameter type on function-typed parameter', () async {
await expectSingleNonNullableOutput(
dedent(r'''
import 'dart:async';
class Foo {
void m(void a(Foo f)) {}
}
'''),
_containsAllOf(
'void m(void Function(_i2.Foo)? a) => super.noSuchMethod('),
);
});
test('prefixes return type on function-typed parameter', () async {
await expectSingleNonNullableOutput(
dedent(r'''
import 'dart:async';
class Foo {
void m(Foo a()) {}
}
'''),
_containsAllOf('void m(_i2.Foo Function()? a) => super.noSuchMethod('),
);
});
test('widens the type of parameters to be nullable', () async {
await expectSingleNonNullableOutput(
dedent(r'''
abstract class Foo {
void m(int? a, int b);
}
'''),
_containsAllOf(dedent2('''
void m(
int? a,
int? b,
) =>
''')),
);
});
test(
'widens the type of potentially non-nullable type variables to be '
'nullable', () async {
await expectSingleNonNullableOutput(
dedent(r'''
abstract class Foo<T> {
void m(int? a, T b);
}
'''),
_containsAllOf(dedent2('''
void m(
int? a,
T? b,
) =>
''')),
);
});
test('widens the type of covariant parameters to be nullable', () async {
await expectSingleNonNullableOutput(
dedent('''
abstract class FooBase {
void m(num a);
}
abstract class Foo extends FooBase {
void m(covariant int a);
}
'''),
_containsAllOf('void m(num? a) => super.noSuchMethod('),
);
});
test(
'widens the type of covariant parameters with default values to be nullable',
() async {
await expectSingleNonNullableOutput(
dedent('''
abstract class FooBase {
void m([num a = 0]);
}
abstract class Foo extends FooBase {
void m([covariant int a = 0]);
}
'''),
_containsAllOf('void m([num? a = 0]) => super.noSuchMethod('),
);
});
test(
'widens the type of covariant parameters (declared covariant in a '
'superclass) to be nullable', () async {
await expectSingleNonNullableOutput(
dedent('''
abstract class FooBase {
void m(covariant num a);
}
abstract class Foo extends FooBase {
void m(int a);
}
'''),
_containsAllOf('void m(num? a) => super.noSuchMethod('),
);
});
test('widens the type of successively covariant parameters to be nullable',
() async {
await expectSingleNonNullableOutput(
dedent('''
abstract class FooBaseBase {
void m(Object a);
}
abstract class FooBase extends FooBaseBase {
void m(covariant num a);
}
abstract class Foo extends FooBase {
void m(covariant int a);
}
'''),
_containsAllOf('void m(Object? a) => super.noSuchMethod('),
);
});
test(
'widens the type of covariant parameters, overriding a mixin, to be nullable',
() async {
await expectSingleNonNullableOutput(
dedent('''
mixin FooMixin {
void m(num a);
}
abstract class Foo with FooMixin {
void m(covariant int a);
}
'''),
_containsAllOf('void m(num? a) => super.noSuchMethod('),
);
});
test(
"widens the type of covariant parameters, which don't have corresponding "
'parameters in all overridden methods, to be nullable', () async {
await expectSingleNonNullableOutput(
dedent('''
abstract class FooBaseBase {
void m();
}
abstract class FooBase extends FooBaseBase {
void m([num a]);
}
abstract class Foo extends FooBase {
void m([covariant int a]);
}
'''),
_containsAllOf('void m([num? a]) => super.noSuchMethod('),
);
});
test('widens the type of covariant named parameters to be nullable',
() async {
await expectSingleNonNullableOutput(
dedent('''
abstract class FooBase extends FooBaseBase {
void m({required num a});
}
abstract class Foo extends FooBase {
void m({required covariant int a});
}
'''),
_containsAllOf('void m({required num? a}) => super.noSuchMethod('),
);
});
test('widens the type of covariant generic parameters to be nullable',
() async {
await expectSingleNonNullableOutput(
dedent('''
abstract class FooBase<T extends Object> {
void m(Object a);
}
abstract class Foo<T extends Object> extends FooBase<T> {
void m(covariant T a);
}
'''),
_containsAllOf('void m(Object? a) => super.noSuchMethod('),
);
});
test('matches nullability of type arguments of a parameter', () async {
await expectSingleNonNullableOutput(
dedent(r'''
abstract class Foo {
void m(List<int?> a, List<int> b);
}
'''),
_containsAllOf(dedent2('''
void m(
List<int?>? a,
List<int>? b,
) =>
''')),
);
});
test(
'matches nullability of return type of a generic function-typed '
'parameter', () async {
await expectSingleNonNullableOutput(
dedent(r'''
abstract class Foo {
void m(int? Function() a, int Function() b);
}
'''),
_containsAllOf(dedent2('''
void m(
int? Function()? a,
int Function()? b,
) =>
''')),
);
});
test(
'matches nullability of return type of FutureOr<T> for potentially nullable T',
() async {
await expectSingleNonNullableOutput(
dedent(r'''
import 'dart:async';
abstract class Foo {
FutureOr<R> m<R>();
}
'''),
_containsAllOf('_i2.FutureOr<R> m<R>() => (super.noSuchMethod('),
);
});
test(
'matches nullability of parameter types within a generic function-typed '
'parameter', () async {
await expectSingleNonNullableOutput(
dedent(r'''
abstract class Foo {
void m(void Function(int?) a, void Function(int) b);
}
'''),
_containsAllOf(dedent2('''
void m(
void Function(int?)? a,
void Function(int)? b,
) =>
''')),
);
});
test('matches nullability of return type of a function-typed parameter',
() async {
await expectSingleNonNullableOutput(
dedent(r'''
abstract class Foo {
void m(int? a(), int b());
}
'''),
_containsAllOf(dedent2('''
void m(
int? Function()? a,
int Function()? b,
) =>
''')),
);
});
test(
'matches nullability of parameter types within a function-typed '
'parameter', () async {
await expectSingleNonNullableOutput(
dedent(r'''
abstract class Foo {
void m(void a(int? x), void b(int x));
}
'''),
_containsAllOf(dedent2('''
void m(
void Function(int?)? a,
void Function(int)? b,
) =>
''')),
);
});
test(
'matches requiredness of parameter types within a function-typed '
'parameter', () async {
await expectSingleNonNullableOutput(
dedent('''
class Foo {
void m(void Function({required int p}) cb) {}
}
'''),
_containsAllOf(
'void m(void Function({required int p})? cb) => super.noSuchMethod('));
});
test('matches nullability of a generic parameter', () async {
await expectSingleNonNullableOutput(
dedent(r'''
abstract class Foo {
void m<T>(T? a, T b);
}
'''),
_containsAllOf(dedent2('''
void m<T>(
T? a,
T? b,
) =>
''')),
);
});
test('matches nullability of a dynamic parameter', () async {
await expectSingleNonNullableOutput(
dedent(r'''
abstract class Foo {
void m(dynamic a, int b);
}
'''),
_containsAllOf(dedent2('''
void m(
dynamic a,
int? b,
) =>
''')),
);
});
test('matches nullability of non-nullable return type', () async {
await expectSingleNonNullableOutput(
dedent(r'''
abstract class Foo {
int m(int a);
}
'''),
_containsAllOf('int m(int? a) =>'),
);
});
test('matches nullability of nullable return type', () async {
await expectSingleNonNullableOutput(
dedent(r'''
abstract class Foo {
int? m(int a);
}
'''),
_containsAllOf('int? m(int? a) =>'),
);
});
test('matches nullability of return type type arguments', () async {
await expectSingleNonNullableOutput(
dedent(r'''
abstract class Foo {
List<int?> m(int a);
}
'''),
_containsAllOf('List<int?> m(int? a) =>'),
);
});
test('matches nullability of nullable type variable return type', () async {
await expectSingleNonNullableOutput(
dedent(r'''
abstract class Foo {
T? m<T>(int a);
}
'''),
_containsAllOf('T? m<T>(int? a) =>'),
);
});
test('overrides implicit return type with dynamic', () async {
await expectSingleNonNullableOutput(
dedent(r'''
abstract class Foo {
m(int a);
}
'''),
_containsAllOf(
'dynamic m(int? a) => super.noSuchMethod(Invocation.method('),
);
});
test('overrides abstract methods', () async {
await expectSingleNonNullableOutput(
dedent(r'''
abstract class Foo {
dynamic f(int a);
}
'''),
_containsAllOf(
'dynamic f(int? a) => super.noSuchMethod(Invocation.method('),
);
});
test('does not override methods with all nullable parameters', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
class Foo {
int? method1(int? p) => null;
}
'''));
expect(mocksContent, isNot(contains('method1')));
});
test('does not override methods with all nullable parameters (dynamic)',
() async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
class Foo {
int? method1(dynamic p) => null;
}
'''));
expect(mocksContent, isNot(contains('method1')));
});
test('does not override methods with all nullable parameters (var untyped)',
() async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
class Foo {
int? method1(var p) => null;
}
'''));
expect(mocksContent, isNot(contains('method1')));
});
test('does not override methods with all nullable parameters (final untyped)',
() async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
class Foo {
int? method1(final p) => null;
}
'''));
expect(mocksContent, isNot(contains('method1')));
});
test('does not override methods with all nullable parameters (type variable)',
() async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
class Foo<T> {
int? method1(T? p) => null;
}
'''));
expect(mocksContent, isNot(contains('method1')));
});
test(
'does not override methods with all nullable parameters (function-typed)',
() async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
class Foo {
int? method1(int Function()? p) => null;
}
'''));
expect(mocksContent, isNot(contains('method1')));
});
test('does not override methods with an implicit dynamic return type',
() async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
abstract class Foo {
method1();
}
'''));
expect(mocksContent, isNot(contains('method1')));
});
test('does not override methods with an explicit dynamic return type',
() async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
abstract class Foo {
dynamic method1();
}
'''));
expect(mocksContent, isNot(contains('method1')));
});
test('does not override methods with a nullable return type', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
abstract class Foo {
int? method1();
}
'''));
expect(mocksContent, isNot(contains('method1')));
});
test('does not override methods with a nullable return type (type variable)',
() async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
abstract class Foo<T> {
T? method1();
}
'''));
expect(mocksContent, isNot(contains('method1')));
});
test('overrides methods with a non-nullable return type', () async {
await expectSingleNonNullableOutput(
dedent(r'''
abstract class Foo {
int m();
}
'''),
_containsAllOf(dedent2('''
int m() => (super.noSuchMethod(
Invocation.method(
#m,
[],
),
returnValue: 0,
) as int);
''')),
);
});
test('overrides inherited methods with a non-nullable return type', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
class FooBase {
num m() => 7;
}
class Foo extends FooBase {
int m() => 7;
}
'''));
expect(mocksContent, contains('int m()'));
expect(mocksContent, isNot(contains('num m()')));
});
test('overrides methods with a potentially non-nullable parameter', () async {
await testWithNonNullable(
{
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo<T> {
void m(T a) {}
}
'''),
},
outputs: {
'foo|test/foo_test.mocks.dart': _containsAllOf(dedent2('''
void m(T? a) => super.noSuchMethod(
Invocation.method(
#m,
[a],
),
''')),
},
);
});
test('overrides generic methods', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
class Foo {
dynamic f<T>(int a) {}
dynamic g<T extends Foo>(int a) {}
}
'''));
expect(mocksContent, contains('dynamic f<T>(int? a) =>'));
expect(mocksContent, contains('dynamic g<T extends _i2.Foo>(int? a) =>'));
});
test('overrides non-nullable instance getters', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
int get m => 7;
}
'''),
_containsAllOf(dedent2('''
int get m => (super.noSuchMethod(
Invocation.getter(#m),
returnValue: 0,
) as int);
''')),
);
});
test('does not override nullable instance getters', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
class Foo {
int? get getter1 => 7;
}
'''));
expect(mocksContent, isNot(contains('getter1')));
});
test('overrides inherited non-nullable instance getters', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class FooBase {
int get m => 7;
}
class Foo extends FooBase {}
'''),
_containsAllOf(dedent2('''
int get m => (super.noSuchMethod(
Invocation.getter(#m),
returnValue: 0,
) as int);
''')),
);
});
test('overrides inherited instance getters only once', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent('''
class FooBase {
num get m => 7;
}
class Foo extends FooBase {
int get m => 7;
}
'''));
expect(mocksContent, contains('int get m'));
expect(mocksContent, isNot(contains('num get m')));
});
test('overrides non-nullable instance setters', () async {
await expectSingleNonNullableOutput(
dedent('''
class Foo {
void set m(int a) {}
}
'''),
_containsAllOf(dedent2('''
set m(int? a) => super.noSuchMethod(
Invocation.setter(
#m,
a,
),
returnValueForMissingStub: null,
);
''')),
);
});
test('overrides nullable instance setters', () async {
await expectSingleNonNullableOutput(
dedent('''
class Foo {
void set m(int? a) {}
}
'''),
_containsAllOf(dedent2('''
set m(int? a) => super.noSuchMethod(
Invocation.setter(
#m,
a,
),
returnValueForMissingStub: null,
);
''')),
);
});
test('overrides inherited non-nullable instance setters', () async {
await expectSingleNonNullableOutput(
dedent('''
class FooBase {
void set m(int a) {}
}
class Foo extends FooBase {}
'''),
_containsAllOf(dedent2('''
set m(int? a) => super.noSuchMethod(
Invocation.setter(
#m,
a,
),
returnValueForMissingStub: null,
);
''')),
);
});
test('overrides inherited non-nullable instance setters only once', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent('''
class FooBase {
set m(int a) {}
}
class Foo extends FooBase {
set m(num a) {}
}
'''));
expect(mocksContent, contains('set m(num? a)'));
expect(mocksContent, isNot(contains('set m(int? a)')));
});
test('overrides non-nullable fields', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
int m;
}
'''),
_containsAllOf(dedent2('''
int get m => (super.noSuchMethod(
Invocation.getter(#m),
returnValue: 0,
) as int);
'''), dedent2('''
set m(int? _m) => super.noSuchMethod(
Invocation.setter(
#m,
_m,
),
returnValueForMissingStub: null,
);
''')),
);
});
test('overrides inherited non-nullable fields', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class FooBase {
int m;
}
class Foo extends FooBase {}
'''),
_containsAllOf(dedent2('''
int get m => (super.noSuchMethod(
Invocation.getter(#m),
returnValue: 0,
) as int);
'''), dedent2('''
set m(int? _m) => super.noSuchMethod(
Invocation.setter(
#m,
_m,
),
returnValueForMissingStub: null,
);
''')),
);
});
test('overrides inherited non-nullable fields only once', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent('''
class FooBase {
num m;
}
class Foo extends FooBase<int> {
int get m => 7;
void set m(covariant int value) {}
}
'''));
expect(mocksContent, contains('int get m'));
expect(mocksContent, contains('set m(int? value)'));
expect(mocksContent, isNot(contains('num get m')));
expect(mocksContent, isNot(contains('set m(num? value)')));
});
test('overrides final non-nullable fields', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
final int m;
Foo(this.m);
}
'''),
_containsAllOf(dedent2('''
int get m => (super.noSuchMethod(
Invocation.getter(#m),
returnValue: 0,
) as int);
''')),
);
});
test('does not override getters for nullable fields', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
class Foo {
int? field1;
}
'''));
expect(mocksContent, isNot(contains('get field1')));
});
test('does not override private fields', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
class Foo {
int _field1;
}
'''));
expect(mocksContent, isNot(contains('int _field1')));
});
test('does not override static fields', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
class Foo {
static int field1;
}
'''));
expect(mocksContent, isNot(contains('int field1')));
});
test('overrides binary operators', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
int operator +(Foo other) => 7;
}
'''),
_containsAllOf(dedent2('''
int operator +(_i2.Foo? other) => (super.noSuchMethod(
Invocation.method(
#+,
[other],
),
returnValue: 0,
) as int);
''')),
);
});
test('overrides index operators', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
int operator [](int x) => 7;
}
'''),
_containsAllOf(dedent2('''
int operator [](int? x) => (super.noSuchMethod(
Invocation.method(
#[],
[x],
),
returnValue: 0,
) as int);
''')),
);
});
test('overrides unary operators', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
int operator ~() => 7;
}
'''),
_containsAllOf(dedent2('''
int operator ~() => (super.noSuchMethod(
Invocation.method(
#~,
[],
),
returnValue: 0,
) as int);
''')),
);
});
test('creates dummy non-null bool return value', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
bool m() => false;
}
'''),
_containsAllOf('returnValue: false,'),
);
});
test('creates dummy non-null double return value', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
double m() => 3.14;
}
'''),
_containsAllOf('returnValue: 0.0,'),
);
});
test('creates dummy non-null int return value', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
int m() => 7;
}
'''),
_containsAllOf('returnValue: 0,'),
);
});
test('creates dummy non-null String return value', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
String m() => "Hello";
}
'''),
_containsAllOf("returnValue: '',"),
);
});
test('creates dummy non-null List return value', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
List<Foo> m() => [Foo()];
}
'''),
_containsAllOf('returnValue: <_i2.Foo>[],'),
);
});
test('creates dummy non-null Set return value', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
Set<Foo> m() => {Foo()};
}
'''),
_containsAllOf('returnValue: <_i2.Foo>{},'),
);
});
test('creates dummy non-null Map return value', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
Map<int, Foo> m() => {7: Foo()};
}
'''),
_containsAllOf('returnValue: <int, _i2.Foo>{},'),
);
});
test('creates dummy non-null raw-typed return value', () async {
await expectSingleNonNullableOutput(
dedent(r'''
abstract class Foo {
Map m();
}
'''),
_containsAllOf('returnValue: <dynamic, dynamic>{},'),
);
});
test('creates dummy non-null return values for Futures', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
Future<bool> m() async => false;
}
'''),
_containsAllOf('returnValue: _i3.Future<bool>.value(false),'),
);
});
test('creates dummy non-null return values for Futures of unknown types',
() async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
Future<T> m<T>() async => false;
}
'''),
_containsAllOf('dummyValueOrNull<T>(', '_FakeFuture_0<T>('),
);
});
test('creates dummy non-null Stream return value', () async {
await expectSingleNonNullableOutput(
dedent(r'''
abstract class Foo {
Stream<int> m();
}
'''),
_containsAllOf('returnValue: _i3.Stream<int>.empty(),'),
);
});
test('creates dummy non-null return values for unknown classes', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
Bar m() => Bar('name');
}
class Bar {
final String name;
Bar(this.name);
}
'''),
_containsAllOf('''
returnValue: _FakeBar_0(
this,
Invocation.method(
#m,
[],
),
),'''),
);
});
test('creates dummy non-null return values for generic type', () async {
await expectSingleNonNullableOutput(
dedent(r'''
abstract class Foo {
Bar<int> m();
}
class Bar<T> {}
'''),
_containsAllOf('''
returnValue: _FakeBar_0<int>(
this,
Invocation.method(
#m,
[],
),
),'''),
);
});
test('creates dummy non-null return values for enums', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
Bar m1() => Bar('name');
}
enum Bar {
one,
two,
}
'''),
_containsAllOf('returnValue: _i2.Bar.one,'),
);
});
test(
'creates a dummy non-null function-typed return value, with optional '
'parameters', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
void Function(int, [String]) m() => (int i, [String s]) {};
}
'''),
_containsAllOf('''
returnValue: (
int __p0, [
String __p1,
]) {},'''),
);
});
test(
'creates a dummy non-null function-typed return value, with named '
'parameters', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
void Function(Foo, {bool b}) m() => (Foo f, {bool b}) {};
}
'''),
_containsAllOf('''
returnValue: (
_i2.Foo __p0, {
bool b,
}) {},'''),
);
});
test(
'creates a dummy non-null function-typed return value, with required '
'named parameters', () async {
await expectSingleNonNullableOutput(
dedent(r'''
abstract class Foo {
void Function(Foo, {required bool b}) m();
}
'''),
_containsAllOf('''
returnValue: (
_i2.Foo __p0, {
required bool b,
}) {},'''),
);
});
test(
'creates a dummy non-null function-typed return value, with non-core '
'return type', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
Foo Function() m() => () => Foo();
}
'''),
_containsAllOf('''
returnValue: () => _FakeFoo_0(
this,
Invocation.method(
#m,
[],
),
),'''),
);
});
test(
'creates a dummy non-null function-typed return value, with private type '
'alias', () async {
await expectSingleNonNullableOutput(
dedent(r'''
typedef _Callback = Foo Function();
class Foo {
_Callback m() => () => Foo();
}
'''),
_containsAllOf('''
returnValue: () => _FakeFoo_0(
this,
Invocation.method(
#m,
[],
),
),
'''),
);
});
test('creates a dummy non-null generic function-typed return value',
() async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
T? Function<T>(T) m() => (int i, [String s]) {};
}
'''),
_containsAllOf('returnValue: <T>(T __p0) => null,'),
);
});
test('creates a dummy non-null generic bounded function-typed return value',
() async {
await expectSingleNonNullableOutput(
dedent(r'''
import 'dart:io';
class Foo {
T? Function<T extends File>(T) m() => (int i, [String s]) {};
}
'''),
_containsAllOf(dedent2('''
T? Function<T extends _i3.File>(T) m() => (super.noSuchMethod(
Invocation.method(
#m,
[],
),
returnValue: <T extends _i3.File>(T __p0) => null,
) as T? Function<T extends _i3.File>(T));
''')),
);
});
test(
'creates a dummy non-null function-typed (with an imported parameter '
'type) return value', () async {
await expectSingleNonNullableOutput(
dedent(r'''
import 'dart:io';
class Foo {
void Function(File) m() => (int i, [String s]) {};
}
'''),
_containsAllOf(dedent2('''
void Function(_i3.File) m() => (super.noSuchMethod(
Invocation.method(
#m,
[],
),
returnValue: (_i3.File __p0) {},
) as void Function(_i3.File));
''')),
);
});
test(
'creates a dummy non-null function-typed (with an imported return type) '
'return value', () async {
await expectSingleNonNullableOutput(
dedent(r'''
import 'dart:io';
class Foo {
File Function() m() => (int i, [String s]) {};
}
'''),
_containsAllOf(dedent2('''
_i2.File Function() m() => (super.noSuchMethod(
Invocation.method(
#m,
[],
),
returnValue: () => _FakeFile_0(
this,
Invocation.method(
#m,
[],
),
),
) as _i2.File Function());
''')),
);
});
test('generates a fake class used in return values', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
Bar m1() => Bar('name1');
}
class Bar {}
'''),
_containsAllOf(dedent('''
class _FakeBar_0 extends _i1.SmartFake implements _i2.Bar {
_FakeBar_0(
Object parent,
Invocation parentInvocation,
) : super(
parent,
parentInvocation,
);
}''')),
);
});
test('generates fake classes with unique names', () async {
final mocksOutput = await buildWithNonNullable({
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': '''
import 'bar1.dart' as one;
import 'bar2.dart' as two;
abstract class Foo {
one.Bar m1();
two.Bar m2();
}
''',
'foo|lib/bar1.dart': '''
class Bar {}
''',
'foo|lib/bar2.dart': '''
class Bar {}
''',
});
expect(
mocksOutput,
contains(
'class _FakeBar_0 extends _i1.SmartFake implements _i2.Bar {'));
expect(
mocksOutput,
contains(
'class _FakeBar_1 extends _i1.SmartFake implements _i3.Bar {'));
});
test('generates a fake generic class used in return values', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Foo {
Bar m1() => Bar();
}
class Bar<T, U> {}
'''),
_containsAllOf(
'class _FakeBar_0<T, U> extends _i1.SmartFake implements _i2.Bar<T, U> {'),
);
});
test('generates a fake, bounded generic class used in return values',
() async {
await expectSingleNonNullableOutput(
dedent(r'''
class Baz {}
class Bar<T extends Baz> {}
class Foo {
Bar<Baz> m1() => Bar();
}
'''),
_containsAllOf(dedent('''
class _FakeBar_0<T extends _i1.Baz> extends _i2.SmartFake
implements _i1.Bar<T> {
''')),
);
});
test('generates a fake, aliased class used in return values', () async {
await expectSingleNonNullableOutput(
dedent(r'''
class Baz {}
class Bar<T extends Baz> {}
typedef BarOfBaz = Bar<Baz>;
class Foo {
BarOfBaz m1() => Bar();
}
'''),
_containsAllOf(dedent('''
class _FakeBar_0<T extends _i1.Baz> extends _i2.SmartFake
implements _i1.Bar<T> {
''')),
);
});
test(
'generates a fake, recursively bounded generic class used in return values',
() async {
await expectSingleNonNullableOutput(
dedent(r'''
class Baz<T extends Baz<T>> {}
class Bar<T> {}
class Foo {
Bar<Baz> m1() => Bar();
}
'''),
_containsAllOf(
'class _FakeBar_0<T> extends _i1.SmartFake implements _i2.Bar<T> {'),
);
});
test('generates a fake class with an overridden `toString` implementation',
() async {
await expectSingleNonNullableOutput(
dedent('''
class Foo {
Bar m1() => Bar('name1');
}
class Bar {
String toString({bool a = true}) => '';
}
'''),
_containsAllOf(dedent('''
class _FakeBar_0 extends _i1.SmartFake implements _i2.Bar {
_FakeBar_0(
Object parent,
Invocation parentInvocation,
) : super(
parent,
parentInvocation,
);
@override
String toString({bool? a = true}) => super.toString();
}
''')),
);
});
test('imports libraries for types used in generated fake classes', () async {
await expectSingleNonNullableOutput(
dedent('''
class Foo {
Bar m1() => Bar('name1');
}
class Bar {
String toString({Baz? baz}) => '';
}
class Baz {}
'''),
_containsAllOf('String toString({_i2.Baz? baz}) => super.toString();'),
);
});
test('deduplicates fake classes', () async {
final mocksContent = await buildWithSingleNonNullableSource(dedent(r'''
class Foo {
Bar m1() => Bar('name1');
Bar m2() => Bar('name2');
}
class Bar {
final String name;
Bar(this.name);
}
'''));
final mocksContentLines = mocksContent.split('\n');
// The _FakeBar_0 class should be generated exactly once.
expect(mocksContentLines.where((line) => line.contains('class _FakeBar_0')),
hasLength(1));
});
test('does not try to generate a fake for a final class', () async {
await expectSingleNonNullableOutput(dedent(r'''
class Foo {
Bar m1() => Bar();
}
final class Bar {}
'''), _containsAllOf('dummyValue<_i2.Bar>('));
});
test('does not try to generate a fake for a base class', () async {
await expectSingleNonNullableOutput(dedent(r'''
class Foo {
Bar m1() => Bar();
}
base class Bar {}
'''), _containsAllOf('dummyValue<_i2.Bar>('));
});
test('does not try to generate a fake for a sealed class', () async {
await expectSingleNonNullableOutput(dedent(r'''
class Foo {
Bar m1() => Bar();
}
sealed class Bar {}
'''), _containsAllOf('dummyValue<_i2.Bar>('));
});
test('throws when GenerateMocks is given a class multiple times', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo {}
'''),
'foo|test/foo_test.dart': '''
import 'package:foo/foo.dart';
import 'package:mockito/annotations.dart';
@GenerateMocks([Foo, Foo])
void main() {}
'''
},
message: contains(
'Mockito cannot generate two mocks with the same name: MockFoo (for '
'Foo declared in /foo/lib/foo.dart, and for Foo declared in '
'/foo/lib/foo.dart)'),
);
});
test(
'throws when GenerateMocks is given a class with a getter with a private '
'return type', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent('''
abstract class Foo with FooMixin {}
mixin FooMixin {
_Bar get f => _Bar();
}
class _Bar {}
'''),
},
message: contains(
"The property accessor 'FooMixin.f' features a private return type, "
'and cannot be stubbed.'),
);
});
test(
'throws when GenerateMocks is given a class with a setter with a private '
'return type', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent('''
abstract class Foo with FooMixin {}
mixin FooMixin {
void set f(_Bar value) {}
}
class _Bar {}
'''),
},
message: contains(
"The property accessor 'FooMixin.f=' features a private parameter "
"type, '_Bar', and cannot be stubbed."),
);
});
test(
'throws when GenerateMocks is given a class with a method with a '
'private return type', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent('''
abstract class Foo {
_Bar m(int a);
}
class _Bar {}
'''),
},
message: contains(
"The method 'Foo.m' features a private return type, and cannot be "
'stubbed.'),
);
});
test(
'throws when GenerateMocks is given a class with an inherited method '
'with a private return type', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent('''
abstract class Foo with FooMixin {}
mixin FooMixin {
_Bar m(int a);
}
class _Bar {}
'''),
},
message: contains(
"The method 'FooMixin.m' features a private return type, and cannot "
'be stubbed.'),
);
});
test(
'throws when GenerateMocks is given a class with a method with a '
'type alias return type which refers to private types', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent('''
abstract class Foo {
Callback m(int a);
}
class _Bar {}
typedef Callback = Function(_Bar?);
'''),
},
message: contains(
"The method 'Foo.m' features a private parameter type, '_Bar', and "
'cannot be stubbed.'),
);
});
test(
'throws when GenerateMocks is given a class with a method with a '
'private type alias parameter type which refers to private types',
() async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent('''
abstract class Foo {
void m(_Callback c);
}
class _Bar {}
typedef _Callback = Function(_Bar?);
'''),
},
message: contains(
"The method 'Foo.m' features a private parameter type, '_Bar', and "
'cannot be stubbed.'),
);
});
test(
'throws when GenerateMocks is given a class with a method with a return '
'type with private type arguments', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent('''
abstract class Foo {
List<_Bar> m(int a);
}
class _Bar {}
'''),
},
message: contains(
"The method 'Foo.m' features a private type argument, and cannot be "
'stubbed.'),
);
});
test(
'throws when GenerateMocks is given a class with a method with a return '
'function type, with a private return type', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent('''
abstract class Foo {
_Bar Function() m();
}
class _Bar {}
'''),
},
message: contains("The method 'Foo.m' features a private return type, "
'and cannot be stubbed.'),
);
});
test(
'throws when GenerateMocks is given a class with a method with a '
'private parameter type', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo {
void m(_Bar a) {}
}
class _Bar {}
'''),
},
message: contains(
"The method 'Foo.m' features a private parameter type, '_Bar', and "
'cannot be stubbed.'),
);
});
test(
'throws when GenerateMocks is given a class with a method with a '
'parameter with private type arguments', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo {
void m(List<_Bar> a) {}
}
class _Bar {}
'''),
},
message: contains(
"The method 'Foo.m' features a private type argument, and cannot be "
'stubbed.'),
);
});
test(
'throws when GenerateMocks is given a class with a method with a '
'function parameter type, with a private return type', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo {
void m(_Bar Function() a) {}
}
class _Bar {}
'''),
},
message: contains(
"The method 'Foo.m' features a private return type, and cannot be "
'stubbed.'),
);
});
test(
'throws when GenerateMocks is given a class with a method with a return '
'function type, with a private parameter type', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent('''
abstract class Foo {
Function(_Bar) m();
}
class _Bar {}
'''),
},
message: contains(
"The method 'Foo.m' features a private parameter type, '_Bar', and "
'cannot be stubbed.'),
);
});
test(
'throws when GenerateMocks is given a class with a type parameter with a '
'private bound', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo<T extends _Bar> {
void m(int a) {}
}
class _Bar {}
'''),
},
message: contains(
"The class 'Foo' features a private type parameter bound, and cannot "
'be stubbed.'),
);
});
test(
'throws when GenerateMocks is given a class with a method with a '
'type parameter with a private bound', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo {
void m<T extends _Bar>(int a) {}
}
class _Bar {}
'''),
},
message: contains(
"The method 'Foo.m' features a private type parameter bound, and "
'cannot be stubbed.'),
);
});
test(
"calls 'dummyValue' for a getter with a "
'non-nullable class-declared type variable type', () async {
await expectSingleNonNullableOutput(dedent('''
abstract class Foo<T> {
T get f;
}
'''), _containsAllOf('dummyValue<T>('));
});
test(
"calls 'dummyValue' for a method with a "
'non-nullable class-declared type variable return type', () async {
await expectSingleNonNullableOutput(dedent('''
abstract class Foo<T> {
T m(int a);
}
'''), _containsAllOf('dummyValue<T>('));
});
test(
"calls 'dummyValue' for a method with a "
'non-nullable method-declared type variable return type', () async {
await expectSingleNonNullableOutput(dedent('''
abstract class Foo {
T m<T>(int a);
}
'''), _containsAllOf('dummyValue<T>('));
});
test(
"calls 'dummyValue' for a method with a "
'non-nullable method-declared bounded type variable return type',
() async {
await expectSingleNonNullableOutput(dedent('''
abstract class Foo {
T m<T extends num>(int a);
}
'''), _containsAllOf('dummyValue<T>('));
});
test('throws when GenerateMocks is missing an argument', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
'foo|test/foo_test.dart': dedent('''
import 'package:mockito/annotations.dart';
// Missing required argument to GenerateMocks.
@GenerateMocks()
void main() {}
'''),
},
message: contains('The GenerateMocks "classes" argument is missing'),
);
});
test('throws when GenerateMocks is given a private class', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
'foo|test/foo_test.dart': dedent('''
import 'package:mockito/annotations.dart';
@GenerateMocks([_Foo])
void main() {}
class _Foo {}
'''),
},
message: contains("Mockito cannot mock a private type: '_Foo'."),
);
});
test('throws when GenerateMocks references an unresolved type', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo {}
'''),
'foo|test/foo_test.dart': dedent('''
// missing foo.dart import.
import 'package:mockito/annotations.dart';
@GenerateMocks([List, Foo])
void main() {}
'''),
},
message: contains('includes an unknown type'),
);
});
test('throws when two distinct classes with the same name are mocked',
() async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
'foo|lib/a.dart': dedent(r'''
class Foo {}
'''),
'foo|lib/b.dart': dedent(r'''
class Foo {}
'''),
'foo|test/foo_test.dart': dedent('''
import 'package:foo/a.dart' as a;
import 'package:foo/b.dart' as b;
import 'package:mockito/annotations.dart';
@GenerateMocks([a.Foo, b.Foo])
void main() {}
'''),
},
message: contains(
'Mockito cannot generate two mocks with the same name: MockFoo (for '
'Foo declared in /foo/lib/a.dart, and for Foo declared in '
'/foo/lib/b.dart)'),
);
});
test('throws when a mock class of the same name already exists', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo {}
'''),
'foo|test/foo_test.dart': dedent('''
import 'package:foo/foo.dart';
import 'package:mockito/annotations.dart';
@GenerateMocks([Foo])
void main() {}
class MockFoo {}
'''),
},
message: contains(
'Mockito cannot generate a mock with a name which conflicts with '
'another class declared in this library: MockFoo'),
);
});
test('throws when a mock class of class-to-mock already exists', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
...mockitoAssets,
'foo|lib/foo.dart': dedent(r'''
class Foo {}
'''),
'foo|test/foo_test.dart': dedent('''
import 'package:foo/foo.dart';
import 'package:mockito/annotations.dart';
import 'package:mockito/mockito.dart';
@GenerateMocks([Foo])
void main() {}
class FakeFoo extends Mock implements Foo {}
'''),
},
message: contains(
'contains a class which appears to already be mocked inline: FakeFoo'),
);
});
test('throws when GenerateMocks references a non-type', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
'foo|test/foo_test.dart': dedent('''
import 'package:mockito/annotations.dart';
@GenerateMocks([7])
void main() {}
'''),
},
message: 'The "classes" argument includes a non-type: int (7)',
);
});
test('throws when GenerateMocks references a function typedef', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent(r'''
typedef Foo = void Function();
'''),
},
message: 'Mockito cannot mock a non-class: Foo',
);
});
test('throws when GenerateMocks references an enum', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent(r'''
enum Foo {}
'''),
},
message: "Mockito cannot mock an enum: 'Foo'",
);
});
test('throws when GenerateMocks references an extension', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent(r'''
extension Foo on String {}
'''),
},
message: contains('includes an extension'),
);
});
test('throws when GenerateMocks references a non-subtypeable type', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
'foo|test/foo_test.dart': dedent('''
import 'package:mockito/annotations.dart';
@GenerateMocks([int])
void main() {}
'''),
},
message: contains("Mockito cannot mock a non-subtypable type: 'int'"),
);
});
test('throws when GenerateMocks references a sealed class', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
'foo|test/foo_test.dart': dedent('''
// @dart=3.0
import 'package:mockito/annotations.dart';
sealed class Foo {}
@GenerateMocks([Foo])
void main() {}
'''),
},
message: contains("Mockito cannot mock a sealed class 'Foo'"),
);
});
test('throws when GenerateMocks references sealed a class via typedef',
() async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
'foo|test/foo_test.dart': dedent('''
// @dart=3.0
import 'package:mockito/annotations.dart';
sealed class Foo {}
typedef Bar = Foo;
@GenerateMocks([Bar])
void main() {}
'''),
},
message: contains("Mockito cannot mock a sealed class 'Foo'"),
);
});
test('throws when GenerateMocks references a base class', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
'foo|test/foo_test.dart': dedent('''
// @dart=3.0
import 'package:mockito/annotations.dart';
base class Foo {}
@GenerateMocks([Foo])
void main() {}
'''),
},
message: contains("Mockito cannot mock a base class 'Foo'"),
);
});
test('throws when GenerateMocks references a final class', () async {
_expectBuilderThrows(
assets: {
...annotationsAsset,
'foo|test/foo_test.dart': dedent('''
// @dart=3.0
import 'package:mockito/annotations.dart';
final class Foo {}
@GenerateMocks([Foo])
void main() {}
'''),
},
message: contains("Mockito cannot mock a final class 'Foo'"),
);
});
test('given a pre-non-nullable library, includes an opt-out comment',
() async {
await testPreNonNullable(
{
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent(r'''
abstract class Foo {
int f(int a);
}
'''),
},
outputs: {'foo|test/foo_test.mocks.dart': _containsAllOf('// @dart=2.9')},
);
});
test('given a pre-non-nullable library, does not override any members',
() async {
await testPreNonNullable(
{
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent(r'''
abstract class Foo {
int f(int a);
}
'''),
},
outputs: {
'foo|test/foo_test.mocks.dart': _containsAllOf(dedent('''
class MockFoo extends _i1.Mock implements _i2.Foo {
MockFoo() {
_i1.throwOnMissingStub(this);
}
}
'''))
},
);
});
test('given a pre-non-nullable library, overrides toString if necessary',
() async {
await testPreNonNullable(
{
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': dedent(r'''
abstract class Foo {
String toString({bool a = false});
}
'''),
},
outputs: {
'foo|test/foo_test.mocks.dart': _containsAllOf(
'String toString({bool a = false}) => super.toString();')
},
);
});
test(
'adds ignore: must_be_immutable analyzer comment if mocked class is '
'immutable', () async {
await expectSingleNonNullableOutput(
dedent(r'''
import 'package:meta/meta.dart';
@immutable
class Foo {
void foo();
}
'''),
_containsAllOf('// ignore: must_be_immutable\nclass MockFoo'),
);
});
group('typedef mocks', () {
group('are generated properly', () {
test('when aliased type parameters are instantiated', () async {
final mocksContent = await buildWithNonNullable({
...annotationsAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo<T> {}
typedef Bar = Foo<int>;
'''),
'foo|test/foo_test.dart': '''
import 'package:foo/foo.dart';
import 'package:mockito/annotations.dart';
@GenerateMocks([Bar])
void main() {}
'''
});
expect(mocksContent, contains('class MockBar extends _i1.Mock'));
expect(mocksContent, contains('implements _i2.Bar'));
});
test('when no aliased type parameters are instantiated', () async {
final mocksContent = await buildWithNonNullable({
...annotationsAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo<T> {}
typedef Bar = Foo;
'''),
'foo|test/foo_test.dart': '''
import 'package:foo/foo.dart';
import 'package:mockito/annotations.dart';
@GenerateMocks([Bar])
void main() {}
'''
});
expect(mocksContent, contains('class MockBar extends _i1.Mock'));
expect(mocksContent, contains('implements _i2.Bar'));
});
test('when the aliased type has no type parameters', () async {
final mocksContent = await buildWithNonNullable({
...annotationsAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo {}
typedef Bar = Foo;
'''),
'foo|test/foo_test.dart': '''
import 'package:foo/foo.dart';
import 'package:mockito/annotations.dart';
@GenerateMocks([Bar])
void main() {}
'''
});
expect(mocksContent, contains('class MockBar extends _i1.Mock'));
expect(mocksContent, contains('implements _i2.Bar'));
});
test('when the typedef defines a type', () async {
final mocksContent = await buildWithNonNullable({
...annotationsAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo<A, B> {}
typedef Bar<X> = Foo<int, X>;
'''),
'foo|test/foo_test.dart': '''
import 'package:foo/foo.dart';
import 'package:mockito/annotations.dart';
@GenerateMocks([Bar])
void main() {}
'''
});
expect(mocksContent, contains('class MockBar<X> extends _i1.Mock'));
expect(mocksContent, contains('implements _i2.Bar<X>'));
});
test('when the typedef defines a bounded type', () async {
final mocksContent = await buildWithNonNullable({
...annotationsAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo<A> {}
typedef Bar<X extends num> = Foo<X>;
'''),
'foo|test/foo_test.dart': '''
import 'package:foo/foo.dart';
import 'package:mockito/annotations.dart';
@GenerateMocks([Bar])
void main() {}
'''
});
expect(mocksContent,
contains('class MockBar<X extends num> extends _i1.Mock'));
expect(mocksContent, contains('implements _i2.Bar<X>'));
});
test('when the aliased type is a mixin', () async {
final mocksContent = await buildWithNonNullable({
...annotationsAsset,
'foo|lib/foo.dart': dedent(r'''
mixin Foo {
String get value;
}
typedef Bar = Foo;
'''),
'foo|test/foo_test.dart': '''
import 'package:foo/foo.dart';
import 'package:mockito/annotations.dart';
@GenerateMocks([Bar])
void main() {}
'''
});
expect(mocksContent, contains('class MockBar extends _i1.Mock'));
expect(mocksContent, contains('implements _i2.Bar'));
expect(mocksContent, contains('String get value'));
});
test('when the aliased type is another typedef', () async {
final mocksContent = await buildWithNonNullable({
...annotationsAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo {}
typedef Bar = Foo;
typedef Baz = Bar;
'''),
'foo|test/foo_test.dart': '''
import 'package:foo/foo.dart';
import 'package:mockito/annotations.dart';
@GenerateMocks([Baz])
void main() {}
'''
});
expect(mocksContent, contains('class MockBaz extends _i1.Mock'));
expect(mocksContent, contains('implements _i2.Baz'));
});
});
test('generation throws when the aliased type is nullable', () {
_expectBuilderThrows(
assets: {
...annotationsAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo {
T get value;
}
typedef Bar = Foo?;
'''),
'foo|test/foo_test.dart': '''
import 'package:foo/foo.dart';
import 'package:mockito/annotations.dart';
@GenerateMocks([Bar])
void main() {}
'''
},
message:
contains('Mockito cannot mock a type-aliased nullable type: Bar'),
enabledExperiments: ['nonfunction-type-aliases'],
languageVersion: LanguageVersion(2, 13),
);
});
});
test('Void in argument type gets overriden to dynamic', () async {
final mocksContent = await buildWithNonNullable({
...annotationsAsset,
'foo|lib/foo.dart': dedent(r'''
class Foo {
void m(void x) {}
}
'''),
'foo|test/foo_test.dart': dedent(r'''
import 'package:foo/foo.dart';
import 'package:mockito/annotations.dart';
@GenerateMocks([Foo])
void main() {}
'''),
});
expect(mocksContent, contains('void m(dynamic x)'));
});
group('Record types', () {
test('are supported as arguments', () async {
await expectSingleNonNullableOutput(dedent('''
abstract class Foo {
int m((int, {Foo foo}) a);
}
'''), _containsAllOf('int m((int, {_i2.Foo foo})? a)'));
});
test('are supported as return types', () async {
await expectSingleNonNullableOutput(
dedent('''
class Bar {}
abstract class Foo {
Future<(int, {Bar bar})> get v;
}
'''),
decodedMatches(allOf(
contains('Future<(int, {_i2.Bar bar})> get v'),
contains('returnValue: _i3.Future<(int, {_i2.Bar bar})>.value('),
contains('bar: _FakeBar_0('))));
});
});
group('build_extensions support', () {
test('should export mocks to different directory', () async {
await testWithNonNullable({
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': '''
import 'bar.dart';
class Foo extends Bar {}
''',
'foo|lib/bar.dart': '''
import 'dart:async';
class Bar {
m(Future<void> a) {}
}
''',
}, config: {
'build_extensions': {'^test/{{}}.dart': 'test/mocks/{{}}.mocks.dart'}
});
final mocksAsset = AssetId('foo', 'test/mocks/foo_test.mocks.dart');
final mocksContent = utf8.decode(writer.assets[mocksAsset]!);
expect(mocksContent, contains("import 'dart:async' as _i3;"));
expect(mocksContent, contains('m(_i3.Future<void>? a)'));
});
test('should throw if it has confilicting outputs', () async {
await expectLater(
testWithNonNullable({
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': '''
import 'bar.dart';
class Foo extends Bar {}
''',
'foo|lib/bar.dart': '''
import 'dart:async';
class Bar {
m(Future<void> a) {}
}
''',
}, config: {
'build_extensions': {
'^test/{{}}.dart': 'test/mocks/{{}}.mocks.dart',
'test/{{}}.dart': 'test/{{}}.something.mocks.dart'
}
}),
throwsArgumentError);
final mocksAsset = AssetId('foo', 'test/mocks/foo_test.mocks.dart');
final otherMocksAsset = AssetId('foo', 'test/mocks/foo_test.mocks.dart');
final somethingMocksAsset =
AssetId('foo', 'test/mocks/foo_test.something.mocks.dart');
expect(writer.assets.containsKey(mocksAsset), false);
expect(writer.assets.containsKey(otherMocksAsset), false);
expect(writer.assets.containsKey(somethingMocksAsset), false);
});
test('should throw if input is in incorrect format', () async {
await expectLater(
testWithNonNullable({
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': '''
import 'bar.dart';
class Foo extends Bar {}
''',
'foo|lib/bar.dart': '''
import 'dart:async';
class Bar {
m(Future<void> a) {}
}
''',
}, config: {
'build_extensions': {'^test/{{}}': 'test/mocks/{{}}.mocks.dart'}
}),
throwsArgumentError);
final mocksAsset = AssetId('foo', 'test/mocks/foo_test.mocks.dart');
final mocksAssetOriginal = AssetId('foo', 'test/foo_test.mocks.dart');
expect(writer.assets.containsKey(mocksAsset), false);
expect(writer.assets.containsKey(mocksAssetOriginal), false);
});
test('should throw if output is in incorrect format', () async {
await expectLater(
testWithNonNullable({
...annotationsAsset,
...simpleTestAsset,
'foo|lib/foo.dart': '''
import 'bar.dart';
class Foo extends Bar {}
''',
'foo|lib/bar.dart': '''
import 'dart:async';
class Bar {
m(Future<void> a) {}
}
''',
}, config: {
'build_extensions': {'^test/{{}}.dart': 'test/mocks/{{}}.g.dart'}
}),
throwsArgumentError);
final mocksAsset = AssetId('foo', 'test/mocks/foo_test.mocks.dart');
final mocksAssetOriginal = AssetId('foo', 'test/foo_test.mocks.dart');
expect(writer.assets.containsKey(mocksAsset), false);
expect(writer.assets.containsKey(mocksAssetOriginal), false);
});
});
}
TypeMatcher<List<int>> _containsAllOf(a, [b]) => decodedMatches(
b == null ? allOf(contains(a)) : allOf(contains(a), contains(b)));
/// Expect that [testBuilder], given [assets], in a package which has opted into
/// null safety, throws an [InvalidMockitoAnnotationException] with a message
/// containing [message].
void _expectBuilderThrows({
required Map<String, String> assets,
required dynamic /*String|Matcher<List<int>>*/ message,
List<String> enabledExperiments = const [],
LanguageVersion? languageVersion,
}) {
final packageConfig = PackageConfig([
Package('foo', Uri.file('/foo/'),
packageUriRoot: Uri.file('/foo/lib/'),
languageVersion: languageVersion ?? LanguageVersion(2, 12))
]);
expect(
() => withEnabledExperiments(
() => testBuilder(
buildMocks(BuilderOptions({})),
assets,
packageConfig: packageConfig,
),
enabledExperiments,
),
throwsA(TypeMatcher<InvalidMockitoAnnotationException>()
.having((e) => e.message, 'message', message)));
}
/// Dedent [input], so that each line is shifted to the left, so that the first
/// line is at the 0 column.
String dedent(String input) {
final indentMatch = RegExp(r'^(\s*)').firstMatch(input)!;
final indent = ''.padRight(indentMatch.group(1)!.length);
return input.splitMapJoin('\n',
onNonMatch: (s) => s.replaceFirst(RegExp('^$indent'), ''));
}
/// Dedent [input], so that each line is shifted to the left, so that the first
/// line is at column 2 (starting position for a class member).
String dedent2(String input) {
final indentMatch = RegExp(r'^ (\s*)').firstMatch(input)!;
final indent = ''.padRight(indentMatch.group(1)!.length);
return input.replaceFirst(RegExp(r'\s*$'), '').splitMapJoin('\n',
onNonMatch: (s) => s.replaceFirst(RegExp('^$indent'), ''));
}