mirror of
https://github.com/flutter/packages.git
synced 2025-05-22 11:16:44 +08:00
5513396a72
When running publish-check, any pre-publish hook must be run before the `publish --dry-run` step as the latter succeeding may depend on the former. Part of https://github.com/flutter/flutter/issues/150210
716 lines
23 KiB
Dart
716 lines
23 KiB
Dart
// Copyright 2013 The Flutter Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
import 'dart:convert';
|
|
|
|
import 'package:args/command_runner.dart';
|
|
import 'package:file/file.dart';
|
|
import 'package:file/memory.dart';
|
|
import 'package:flutter_plugin_tools/src/common/core.dart';
|
|
import 'package:flutter_plugin_tools/src/publish_check_command.dart';
|
|
import 'package:http/http.dart' as http;
|
|
import 'package:http/testing.dart';
|
|
import 'package:test/test.dart';
|
|
|
|
import 'mocks.dart';
|
|
import 'util.dart';
|
|
|
|
void main() {
|
|
group('PublishCheckCommand tests', () {
|
|
FileSystem fileSystem;
|
|
late MockPlatform mockPlatform;
|
|
late Directory packagesDir;
|
|
late RecordingProcessRunner processRunner;
|
|
late CommandRunner<void> runner;
|
|
|
|
setUp(() {
|
|
fileSystem = MemoryFileSystem();
|
|
mockPlatform = MockPlatform();
|
|
packagesDir = createPackagesDirectory(fileSystem: fileSystem);
|
|
processRunner = RecordingProcessRunner();
|
|
final PublishCheckCommand publishCheckCommand = PublishCheckCommand(
|
|
packagesDir,
|
|
processRunner: processRunner,
|
|
platform: mockPlatform,
|
|
);
|
|
|
|
runner = CommandRunner<void>(
|
|
'publish_check_command',
|
|
'Test for publish-check command.',
|
|
);
|
|
runner.addCommand(publishCheckCommand);
|
|
});
|
|
|
|
test('publish check all packages', () async {
|
|
final RepositoryPackage plugin1 = createFakePlugin(
|
|
'plugin_tools_test_package_a',
|
|
packagesDir,
|
|
examples: <String>[],
|
|
);
|
|
final RepositoryPackage plugin2 = createFakePlugin(
|
|
'plugin_tools_test_package_b',
|
|
packagesDir,
|
|
examples: <String>[],
|
|
);
|
|
|
|
await runCapturingPrint(runner, <String>['publish-check']);
|
|
|
|
expect(
|
|
processRunner.recordedCalls,
|
|
orderedEquals(<ProcessCall>[
|
|
ProcessCall(
|
|
'flutter',
|
|
const <String>['pub', 'publish', '--', '--dry-run'],
|
|
plugin1.path),
|
|
ProcessCall(
|
|
'flutter',
|
|
const <String>['pub', 'publish', '--', '--dry-run'],
|
|
plugin2.path),
|
|
]));
|
|
});
|
|
|
|
test('publish prepares dependencies of examples (when present)', () async {
|
|
final RepositoryPackage plugin1 = createFakePlugin(
|
|
'plugin_tools_test_package_a',
|
|
packagesDir,
|
|
examples: <String>['example1', 'example2'],
|
|
);
|
|
final RepositoryPackage plugin2 = createFakePlugin(
|
|
'plugin_tools_test_package_b',
|
|
packagesDir,
|
|
examples: <String>[],
|
|
);
|
|
|
|
await runCapturingPrint(runner, <String>['publish-check']);
|
|
|
|
// For plugin1, these are the expected pub get calls that will happen
|
|
final Iterable<ProcessCall> pubGetCalls =
|
|
plugin1.getExamples().map((RepositoryPackage example) {
|
|
return ProcessCall(
|
|
getFlutterCommand(mockPlatform),
|
|
const <String>['pub', 'get'],
|
|
example.path,
|
|
);
|
|
});
|
|
|
|
expect(pubGetCalls, hasLength(2));
|
|
expect(
|
|
processRunner.recordedCalls,
|
|
orderedEquals(<ProcessCall>[
|
|
// plugin1 has 2 examples, so there's some 'dart pub get' calls.
|
|
...pubGetCalls,
|
|
ProcessCall(
|
|
'flutter',
|
|
const <String>['pub', 'publish', '--', '--dry-run'],
|
|
plugin1.path),
|
|
// plugin2 has no examples, so there's no extra 'dart pub get' calls.
|
|
ProcessCall(
|
|
'flutter',
|
|
const <String>['pub', 'publish', '--', '--dry-run'],
|
|
plugin2.path),
|
|
]),
|
|
);
|
|
});
|
|
|
|
test('fail on negative test', () async {
|
|
createFakePlugin('plugin_tools_test_package_a', packagesDir);
|
|
|
|
processRunner.mockProcessesForExecutable['flutter'] = <FakeProcessInfo>[
|
|
FakeProcessInfo(MockProcess(), <String>['pub', 'get']),
|
|
FakeProcessInfo(MockProcess(exitCode: 1, stdout: 'Some error from pub'),
|
|
<String>['pub', 'publish'])
|
|
];
|
|
|
|
Error? commandError;
|
|
final List<String> output = await runCapturingPrint(
|
|
runner, <String>['publish-check'], errorHandler: (Error e) {
|
|
commandError = e;
|
|
});
|
|
|
|
expect(commandError, isA<ToolExit>());
|
|
expect(
|
|
output,
|
|
containsAllInOrder(<Matcher>[
|
|
contains('Some error from pub'),
|
|
contains('Unable to publish plugin_tools_test_package_a'),
|
|
]),
|
|
);
|
|
});
|
|
|
|
test('fail on bad pubspec', () async {
|
|
final RepositoryPackage package = createFakePlugin('c', packagesDir);
|
|
await package.pubspecFile.writeAsString('bad-yaml');
|
|
|
|
Error? commandError;
|
|
final List<String> output = await runCapturingPrint(
|
|
runner, <String>['publish-check'], errorHandler: (Error e) {
|
|
commandError = e;
|
|
});
|
|
|
|
expect(commandError, isA<ToolExit>());
|
|
expect(
|
|
output,
|
|
containsAllInOrder(<Matcher>[
|
|
contains('No valid pubspec found.'),
|
|
]),
|
|
);
|
|
});
|
|
|
|
test('fails if AUTHORS is missing', () async {
|
|
final RepositoryPackage package =
|
|
createFakePackage('a_package', packagesDir);
|
|
package.authorsFile.deleteSync();
|
|
|
|
Error? commandError;
|
|
final List<String> output = await runCapturingPrint(
|
|
runner, <String>['publish-check'], errorHandler: (Error e) {
|
|
commandError = e;
|
|
});
|
|
|
|
expect(commandError, isA<ToolExit>());
|
|
expect(
|
|
output,
|
|
containsAllInOrder(<Matcher>[
|
|
contains(
|
|
'No AUTHORS file found. Packages must include an AUTHORS file.'),
|
|
]),
|
|
);
|
|
});
|
|
|
|
test('does not require AUTHORS for third-party', () async {
|
|
final RepositoryPackage package = createFakePackage(
|
|
'a_package',
|
|
packagesDir.parent
|
|
.childDirectory('third_party')
|
|
.childDirectory('packages'));
|
|
package.authorsFile.deleteSync();
|
|
|
|
final List<String> output =
|
|
await runCapturingPrint(runner, <String>['publish-check']);
|
|
|
|
expect(
|
|
output,
|
|
containsAllInOrder(<Matcher>[
|
|
contains('Running for a_package'),
|
|
]),
|
|
);
|
|
});
|
|
|
|
test('pass on prerelease if --allow-pre-release flag is on', () async {
|
|
createFakePlugin('d', packagesDir);
|
|
|
|
final MockProcess process = MockProcess(
|
|
exitCode: 1,
|
|
stdout: 'Package has 1 warning.\n'
|
|
'Packages with an SDK constraint on a pre-release of the Dart '
|
|
'SDK should themselves be published as a pre-release version.');
|
|
processRunner.mockProcessesForExecutable['flutter'] = <FakeProcessInfo>[
|
|
FakeProcessInfo(MockProcess(), <String>['pub', 'get']),
|
|
FakeProcessInfo(process, <String>['pub', 'publish']),
|
|
];
|
|
|
|
expect(
|
|
runCapturingPrint(
|
|
runner, <String>['publish-check', '--allow-pre-release']),
|
|
completes);
|
|
});
|
|
|
|
test('fail on prerelease if --allow-pre-release flag is off', () async {
|
|
createFakePlugin('d', packagesDir);
|
|
|
|
final MockProcess process = MockProcess(
|
|
exitCode: 1,
|
|
stdout: 'Package has 1 warning.\n'
|
|
'Packages with an SDK constraint on a pre-release of the Dart '
|
|
'SDK should themselves be published as a pre-release version.');
|
|
processRunner.mockProcessesForExecutable['flutter'] = <FakeProcessInfo>[
|
|
FakeProcessInfo(MockProcess(), <String>['pub', 'get']),
|
|
FakeProcessInfo(process, <String>['pub', 'publish']),
|
|
];
|
|
|
|
Error? commandError;
|
|
final List<String> output = await runCapturingPrint(
|
|
runner, <String>['publish-check'], errorHandler: (Error e) {
|
|
commandError = e;
|
|
});
|
|
|
|
expect(commandError, isA<ToolExit>());
|
|
expect(
|
|
output,
|
|
containsAllInOrder(<Matcher>[
|
|
contains(
|
|
'Packages with an SDK constraint on a pre-release of the Dart SDK'),
|
|
contains('Unable to publish d'),
|
|
]),
|
|
);
|
|
});
|
|
|
|
test('Success message on stderr is not printed as an error', () async {
|
|
createFakePlugin('d', packagesDir);
|
|
|
|
processRunner.mockProcessesForExecutable['flutter'] = <FakeProcessInfo>[
|
|
FakeProcessInfo(MockProcess(), <String>['pub', 'get']),
|
|
FakeProcessInfo(MockProcess(stdout: 'Package has 0 warnings.'),
|
|
<String>['pub', 'publish']),
|
|
];
|
|
|
|
final List<String> output =
|
|
await runCapturingPrint(runner, <String>['publish-check']);
|
|
|
|
expect(output, isNot(contains(contains('ERROR:'))));
|
|
});
|
|
|
|
test(
|
|
'runs validation even for packages that are already published and reports failure',
|
|
() async {
|
|
final RepositoryPackage package =
|
|
createFakePackage('a_package', packagesDir, version: '0.1.0');
|
|
|
|
final MockClient mockClient = MockClient((http.Request request) async {
|
|
if (request.url.pathSegments.last == 'a_package.json') {
|
|
return http.Response(
|
|
json.encode(<String, dynamic>{
|
|
'name': 'a_package',
|
|
'versions': <String>[
|
|
'0.0.1',
|
|
'0.1.0',
|
|
],
|
|
}),
|
|
200);
|
|
}
|
|
return http.Response('', 500);
|
|
});
|
|
|
|
runner = CommandRunner<void>(
|
|
'publish_check_command',
|
|
'Test for publish-check command.',
|
|
);
|
|
runner.addCommand(PublishCheckCommand(packagesDir,
|
|
platform: mockPlatform,
|
|
processRunner: processRunner,
|
|
httpClient: mockClient));
|
|
|
|
processRunner.mockProcessesForExecutable['flutter'] = <FakeProcessInfo>[
|
|
FakeProcessInfo(MockProcess(exitCode: 1, stdout: 'Some error from pub'),
|
|
<String>['pub', 'publish'])
|
|
];
|
|
|
|
Error? commandError;
|
|
final List<String> output = await runCapturingPrint(
|
|
runner, <String>['publish-check'], errorHandler: (Error e) {
|
|
commandError = e;
|
|
});
|
|
|
|
expect(commandError, isA<ToolExit>());
|
|
expect(
|
|
output,
|
|
containsAllInOrder(<Matcher>[
|
|
contains('Unable to publish a_package'),
|
|
]),
|
|
);
|
|
expect(
|
|
processRunner.recordedCalls,
|
|
contains(
|
|
ProcessCall(
|
|
'flutter',
|
|
const <String>['pub', 'publish', '--', '--dry-run'],
|
|
package.path),
|
|
));
|
|
});
|
|
|
|
test('skips packages that are marked as not for publishing', () async {
|
|
createFakePackage('a_package', packagesDir,
|
|
version: '0.1.0', publishTo: 'none');
|
|
|
|
final List<String> output =
|
|
await runCapturingPrint(runner, <String>['publish-check']);
|
|
|
|
expect(
|
|
output,
|
|
containsAllInOrder(<Matcher>[
|
|
contains('SKIPPING: Package is marked as unpublishable.'),
|
|
]),
|
|
);
|
|
expect(processRunner.recordedCalls, isEmpty);
|
|
});
|
|
|
|
test(
|
|
'runs validation even for packages that are already published and reports success',
|
|
() async {
|
|
final RepositoryPackage package =
|
|
createFakePackage('a_package', packagesDir, version: '0.1.0');
|
|
|
|
final MockClient mockClient = MockClient((http.Request request) async {
|
|
if (request.url.pathSegments.last == 'a_package.json') {
|
|
return http.Response(
|
|
json.encode(<String, dynamic>{
|
|
'name': 'a_package',
|
|
'versions': <String>[
|
|
'0.0.1',
|
|
'0.1.0',
|
|
],
|
|
}),
|
|
200);
|
|
}
|
|
return http.Response('', 500);
|
|
});
|
|
|
|
runner = CommandRunner<void>(
|
|
'publish_check_command',
|
|
'Test for publish-check command.',
|
|
);
|
|
runner.addCommand(PublishCheckCommand(packagesDir,
|
|
platform: mockPlatform,
|
|
processRunner: processRunner,
|
|
httpClient: mockClient));
|
|
|
|
final List<String> output =
|
|
await runCapturingPrint(runner, <String>['publish-check']);
|
|
|
|
expect(
|
|
output,
|
|
containsAllInOrder(<Matcher>[
|
|
contains(
|
|
'Package a_package version: 0.1.0 has already been published on pub.'),
|
|
]),
|
|
);
|
|
expect(
|
|
processRunner.recordedCalls,
|
|
contains(
|
|
ProcessCall(
|
|
'flutter',
|
|
const <String>['pub', 'publish', '--', '--dry-run'],
|
|
package.path),
|
|
));
|
|
});
|
|
|
|
group('pre-publish script', () {
|
|
test('runs if present', () async {
|
|
final RepositoryPackage package =
|
|
createFakePackage('a_package', packagesDir, examples: <String>[]);
|
|
package.prePublishScript.createSync(recursive: true);
|
|
|
|
final List<String> output = await runCapturingPrint(runner, <String>[
|
|
'publish-check',
|
|
]);
|
|
|
|
expect(
|
|
output,
|
|
containsAllInOrder(<Matcher>[
|
|
contains('Running pre-publish hook tool/pre_publish.dart...'),
|
|
]),
|
|
);
|
|
expect(
|
|
processRunner.recordedCalls,
|
|
containsAllInOrder(<ProcessCall>[
|
|
ProcessCall(
|
|
'dart',
|
|
const <String>[
|
|
'pub',
|
|
'get',
|
|
],
|
|
package.directory.path),
|
|
ProcessCall(
|
|
'dart',
|
|
const <String>[
|
|
'run',
|
|
'tool/pre_publish.dart',
|
|
],
|
|
package.directory.path),
|
|
]));
|
|
});
|
|
|
|
test('runs before publish --dry-run', () async {
|
|
final RepositoryPackage package =
|
|
createFakePackage('a_package', packagesDir, examples: <String>[]);
|
|
package.prePublishScript.createSync(recursive: true);
|
|
|
|
final List<String> output = await runCapturingPrint(runner, <String>[
|
|
'publish-check',
|
|
]);
|
|
|
|
expect(
|
|
output,
|
|
containsAllInOrder(<Matcher>[
|
|
contains('Running pre-publish hook tool/pre_publish.dart...'),
|
|
]),
|
|
);
|
|
expect(
|
|
processRunner.recordedCalls,
|
|
containsAllInOrder(<ProcessCall>[
|
|
ProcessCall(
|
|
'dart',
|
|
const <String>[
|
|
'run',
|
|
'tool/pre_publish.dart',
|
|
],
|
|
package.directory.path),
|
|
ProcessCall(
|
|
'flutter',
|
|
const <String>[
|
|
'pub',
|
|
'publish',
|
|
'--',
|
|
'--dry-run',
|
|
],
|
|
package.directory.path),
|
|
]));
|
|
});
|
|
|
|
test('causes command failure if it fails', () async {
|
|
final RepositoryPackage package = createFakePackage(
|
|
'a_package', packagesDir,
|
|
isFlutter: true, examples: <String>[]);
|
|
package.prePublishScript.createSync(recursive: true);
|
|
|
|
processRunner.mockProcessesForExecutable['dart'] = <FakeProcessInfo>[
|
|
FakeProcessInfo(MockProcess(exitCode: 1),
|
|
<String>['run']), // run tool/pre_publish.dart
|
|
];
|
|
|
|
Error? commandError;
|
|
final List<String> output = await runCapturingPrint(runner, <String>[
|
|
'publish-check',
|
|
], errorHandler: (Error e) {
|
|
commandError = e;
|
|
});
|
|
|
|
expect(commandError, isA<ToolExit>());
|
|
expect(
|
|
output,
|
|
containsAllInOrder(<Matcher>[
|
|
contains('Pre-publish script failed.'),
|
|
]),
|
|
);
|
|
expect(
|
|
processRunner.recordedCalls,
|
|
containsAllInOrder(<ProcessCall>[
|
|
ProcessCall(
|
|
getFlutterCommand(mockPlatform),
|
|
const <String>[
|
|
'pub',
|
|
'get',
|
|
],
|
|
package.directory.path),
|
|
ProcessCall(
|
|
'dart',
|
|
const <String>[
|
|
'run',
|
|
'tool/pre_publish.dart',
|
|
],
|
|
package.directory.path),
|
|
]));
|
|
});
|
|
});
|
|
|
|
test(
|
|
'--machine: Log JSON with status:no-publish and correct human message, if there are no packages need to be published. ',
|
|
() async {
|
|
const Map<String, dynamic> httpResponseA = <String, dynamic>{
|
|
'name': 'a',
|
|
'versions': <String>[
|
|
'0.0.1',
|
|
'0.1.0',
|
|
],
|
|
};
|
|
|
|
const Map<String, dynamic> httpResponseB = <String, dynamic>{
|
|
'name': 'b',
|
|
'versions': <String>[
|
|
'0.0.1',
|
|
'0.1.0',
|
|
'0.2.0',
|
|
],
|
|
};
|
|
|
|
final MockClient mockClient = MockClient((http.Request request) async {
|
|
if (request.url.pathSegments.last == 'no_publish_a.json') {
|
|
return http.Response(json.encode(httpResponseA), 200);
|
|
} else if (request.url.pathSegments.last == 'no_publish_b.json') {
|
|
return http.Response(json.encode(httpResponseB), 200);
|
|
}
|
|
return http.Response('', 500);
|
|
});
|
|
final PublishCheckCommand command = PublishCheckCommand(packagesDir,
|
|
processRunner: processRunner, httpClient: mockClient);
|
|
|
|
runner = CommandRunner<void>(
|
|
'publish_check_command',
|
|
'Test for publish-check command.',
|
|
);
|
|
runner.addCommand(command);
|
|
|
|
createFakePlugin('no_publish_a', packagesDir, version: '0.1.0');
|
|
createFakePlugin('no_publish_b', packagesDir, version: '0.2.0');
|
|
|
|
final List<String> output = await runCapturingPrint(
|
|
runner, <String>['publish-check', '--machine']);
|
|
|
|
expect(output.first, r'''
|
|
{
|
|
"status": "no-publish",
|
|
"humanMessage": [
|
|
"\n============================================================\n|| Running for no_publish_a\n============================================================\n",
|
|
"Running pub publish --dry-run:",
|
|
"Package no_publish_a version: 0.1.0 has already been published on pub.",
|
|
"\n============================================================\n|| Running for no_publish_b\n============================================================\n",
|
|
"Running pub publish --dry-run:",
|
|
"Package no_publish_b version: 0.2.0 has already been published on pub.",
|
|
"\n",
|
|
"------------------------------------------------------------",
|
|
"Run overview:",
|
|
" no_publish_a - ran",
|
|
" no_publish_b - ran",
|
|
"",
|
|
"Ran for 2 package(s)",
|
|
"\n",
|
|
"No issues found!"
|
|
]
|
|
}''');
|
|
});
|
|
|
|
test(
|
|
'--machine: Log JSON with status:needs-publish and correct human message, if there is at least 1 plugin needs to be published.',
|
|
() async {
|
|
const Map<String, dynamic> httpResponseA = <String, dynamic>{
|
|
'name': 'a',
|
|
'versions': <String>[
|
|
'0.0.1',
|
|
'0.1.0',
|
|
],
|
|
};
|
|
|
|
const Map<String, dynamic> httpResponseB = <String, dynamic>{
|
|
'name': 'b',
|
|
'versions': <String>[
|
|
'0.0.1',
|
|
'0.1.0',
|
|
],
|
|
};
|
|
|
|
final MockClient mockClient = MockClient((http.Request request) async {
|
|
if (request.url.pathSegments.last == 'no_publish_a.json') {
|
|
return http.Response(json.encode(httpResponseA), 200);
|
|
} else if (request.url.pathSegments.last == 'no_publish_b.json') {
|
|
return http.Response(json.encode(httpResponseB), 200);
|
|
}
|
|
return http.Response('', 500);
|
|
});
|
|
final PublishCheckCommand command = PublishCheckCommand(packagesDir,
|
|
processRunner: processRunner, httpClient: mockClient);
|
|
|
|
runner = CommandRunner<void>(
|
|
'publish_check_command',
|
|
'Test for publish-check command.',
|
|
);
|
|
runner.addCommand(command);
|
|
|
|
createFakePlugin('no_publish_a', packagesDir, version: '0.1.0');
|
|
createFakePlugin('no_publish_b', packagesDir, version: '0.2.0');
|
|
|
|
final List<String> output = await runCapturingPrint(
|
|
runner, <String>['publish-check', '--machine']);
|
|
|
|
expect(output.first, r'''
|
|
{
|
|
"status": "needs-publish",
|
|
"humanMessage": [
|
|
"\n============================================================\n|| Running for no_publish_a\n============================================================\n",
|
|
"Running pub publish --dry-run:",
|
|
"Package no_publish_a version: 0.1.0 has already been published on pub.",
|
|
"\n============================================================\n|| Running for no_publish_b\n============================================================\n",
|
|
"Running pub publish --dry-run:",
|
|
"Package no_publish_b is able to be published.",
|
|
"\n",
|
|
"------------------------------------------------------------",
|
|
"Run overview:",
|
|
" no_publish_a - ran",
|
|
" no_publish_b - ran",
|
|
"",
|
|
"Ran for 2 package(s)",
|
|
"\n",
|
|
"No issues found!"
|
|
]
|
|
}''');
|
|
});
|
|
|
|
test(
|
|
'--machine: Log correct JSON, if there is at least 1 plugin contains error.',
|
|
() async {
|
|
const Map<String, dynamic> httpResponseA = <String, dynamic>{
|
|
'name': 'a',
|
|
'versions': <String>[
|
|
'0.0.1',
|
|
'0.1.0',
|
|
],
|
|
};
|
|
|
|
const Map<String, dynamic> httpResponseB = <String, dynamic>{
|
|
'name': 'b',
|
|
'versions': <String>[
|
|
'0.0.1',
|
|
'0.1.0',
|
|
],
|
|
};
|
|
|
|
final MockClient mockClient = MockClient((http.Request request) async {
|
|
print('url ${request.url}');
|
|
print(request.url.pathSegments.last);
|
|
if (request.url.pathSegments.last == 'no_publish_a.json') {
|
|
return http.Response(json.encode(httpResponseA), 200);
|
|
} else if (request.url.pathSegments.last == 'no_publish_b.json') {
|
|
return http.Response(json.encode(httpResponseB), 200);
|
|
}
|
|
return http.Response('', 500);
|
|
});
|
|
final PublishCheckCommand command = PublishCheckCommand(packagesDir,
|
|
processRunner: processRunner, httpClient: mockClient);
|
|
|
|
runner = CommandRunner<void>(
|
|
'publish_check_command',
|
|
'Test for publish-check command.',
|
|
);
|
|
runner.addCommand(command);
|
|
|
|
final RepositoryPackage plugin =
|
|
createFakePlugin('no_publish_a', packagesDir, version: '0.1.0');
|
|
createFakePlugin('no_publish_b', packagesDir, version: '0.2.0');
|
|
|
|
await plugin.pubspecFile.writeAsString('bad-yaml');
|
|
|
|
bool hasError = false;
|
|
final List<String> output = await runCapturingPrint(
|
|
runner, <String>['publish-check', '--machine'],
|
|
errorHandler: (Error error) {
|
|
expect(error, isA<ToolExit>());
|
|
hasError = true;
|
|
});
|
|
expect(hasError, isTrue);
|
|
|
|
expect(output.first, contains(r'''
|
|
{
|
|
"status": "error",
|
|
"humanMessage": [
|
|
"\n============================================================\n|| Running for no_publish_a\n============================================================\n",
|
|
"Failed to parse `pubspec.yaml` at /packages/no_publish_a/pubspec.yaml: ParsedYamlException:'''));
|
|
// This is split into two checks since the details of the YamlException
|
|
// aren't controlled by this package, so asserting its exact format would
|
|
// make the test fragile to irrelevant changes in those details.
|
|
expect(output.first, contains(r'''
|
|
"No valid pubspec found.",
|
|
"\n============================================================\n|| Running for no_publish_b\n============================================================\n",
|
|
"url https://pub.dev/packages/no_publish_b.json",
|
|
"no_publish_b.json",
|
|
"Running pub publish --dry-run:",
|
|
"Package no_publish_b is able to be published.",
|
|
"\n",
|
|
"The following packages had errors:",
|
|
" no_publish_a",
|
|
"See above for full details."
|
|
]
|
|
}'''));
|
|
});
|
|
});
|
|
}
|