From 973bc555b6d50ac2e14342a0b00dc89fc34bd2f3 Mon Sep 17 00:00:00 2001 From: Nexushunter Date: Fri, 1 Sep 2023 19:45:47 -0400 Subject: [PATCH 01/13] Begin mocking and migration --- openapi-generator/Makefile | 4 + .../lib/src/openapi_generator_runner.dart | 171 +- openapi-generator/pubspec.yaml | 1 + openapi-generator/test/generator_test.dart | 111 + openapi-generator/test/mocks.dart | 17 + openapi-generator/test/mocks.mocks.dart | 2226 +++++++++++++++++ .../test/specs/localstack/cache/machine.json | 1 + .../specs/localstack/cache/server.test.pem | 125 + .../localstack/cache/server.test.pem.crt | 97 + .../localstack/cache/server.test.pem.key | 28 + .../service-catalog-2_2_1_dev-1_31_28.pickle | Bin 0 -> 352716 bytes 11 files changed, 2681 insertions(+), 100 deletions(-) create mode 100644 openapi-generator/Makefile create mode 100644 openapi-generator/test/generator_test.dart create mode 100644 openapi-generator/test/mocks.dart create mode 100644 openapi-generator/test/mocks.mocks.dart create mode 100644 openapi-generator/test/specs/localstack/cache/machine.json create mode 100644 openapi-generator/test/specs/localstack/cache/server.test.pem create mode 100644 openapi-generator/test/specs/localstack/cache/server.test.pem.crt create mode 100644 openapi-generator/test/specs/localstack/cache/server.test.pem.key create mode 100644 openapi-generator/test/specs/localstack/cache/service-catalog-2_2_1_dev-1_31_28.pickle diff --git a/openapi-generator/Makefile b/openapi-generator/Makefile new file mode 100644 index 0000000..92e92a1 --- /dev/null +++ b/openapi-generator/Makefile @@ -0,0 +1,4 @@ +.PHONY: gen + +gen: + dart run build_runner build --delete-conflicting-outputs \ No newline at end of file diff --git a/openapi-generator/lib/src/openapi_generator_runner.dart b/openapi-generator/lib/src/openapi_generator_runner.dart index 97b6664..1849750 100755 --- a/openapi-generator/lib/src/openapi_generator_runner.dart +++ b/openapi-generator/lib/src/openapi_generator_runner.dart @@ -37,51 +37,28 @@ class OpenapiGenerator extends GeneratorForAnnotation { ), ); - try { - if (element is! ClassElement) { - final friendlyName = element.displayName; - - throw InvalidGenerationSourceError( - 'Generator cannot target `$friendlyName`.', - todo: 'Remove the [Openapi] annotation from `$friendlyName`.', - ); - } else { - if (!(annotations.read('useNextGen').literalValue as bool)) { - if (annotations.read('cachePath').literalValue != null) { - throw InvalidGenerationSourceError( - 'useNextGen must be set when using cachePath', - todo: - 'Either set useNextGen: true on the annotation or remove the custom cachePath', - ); - } - } + if (element is! ClassElement) { + final friendlyName = element.displayName; + throw InvalidGenerationSourceError( + 'Generator cannot target `$friendlyName`.', + todo: 'Remove the [Openapi] annotation from `$friendlyName`.', + ); + } else { + if (!(annotations.read('useNextGen').literalValue as bool) && + annotations.read('cachePath').literalValue != null) { + throw AssertionError('useNextGen must be set when using cachePath'); + } + try { // Transform the annotations. final args = GeneratorArguments(annotations: annotations); - // Determine if the project has a dependency on the flutter sdk or not. final baseCommand = await checkPubspecAndWrapperForFlutterSupport( wrapper: args.wrapper, providedPubspecPath: args.pubspecPath) ? 'flutter' : 'dart'; - if (!args.useNextGen) { - final path = - '${args.outputDirectory}${Platform.pathSeparator}lib${Platform.pathSeparator}api.dart'; - if (await File(path).exists()) { - if (!args.alwaysRun) { - logOutputMessage( - log: log, - communication: OutputMessage( - message: - 'Generated client already exists at [$path] and configuration is annotated with alwaysRun: [${args.alwaysRun}]. Therefore, skipping this build. Note that the "alwaysRun" config will be removed in future versions.', - level: Level.INFO, - ), - ); - return ''; - } - } - } else { + if (args.useNextGen) { // If the flag to use the next generation of the generator is applied // use the new functionality. return generatorV2( @@ -90,26 +67,42 @@ class OpenapiGenerator extends GeneratorForAnnotation { annotatedPath: buildStep.inputId.path); } + final path = + '${args.outputDirectory}${Platform.pathSeparator}lib${Platform.pathSeparator}api.dart'; + if (await File(path).exists()) { + if (!args.alwaysRun) { + logOutputMessage( + log: log, + communication: OutputMessage( + message: + 'Generated client already exists at [$path] and configuration is annotated with alwaysRun: [${args.alwaysRun}]. Therefore, skipping this build. Note that the "alwaysRun" config will be removed in future versions.', + level: Level.INFO, + ), + ); + return ''; + } + } + await runOpenApiJar(arguments: args); await fetchDependencies(baseCommand: baseCommand, args: args); await generateSources(baseCommand: baseCommand, args: args); - } - } catch (e, st) { - late OutputMessage communication; - if (e is! OutputMessage) { - communication = OutputMessage( - message: '- There was an error generating the spec.', - level: Level.SEVERE, - additionalContext: e, - stackTrace: st, - ); - } else { - communication = e; - } + } catch (e, st) { + late OutputMessage communication; + if (e is! OutputMessage) { + communication = OutputMessage( + message: '- There was an error generating the spec.', + level: Level.SEVERE, + additionalContext: e, + stackTrace: st, + ); + } else { + communication = e; + } - logOutputMessage(log: log, communication: communication); + logOutputMessage(log: log, communication: communication); + } + return ''; } - return ''; } /// Runs the OpenAPI compiler with the given [args]. @@ -130,23 +123,18 @@ class OpenapiGenerator extends GeneratorForAnnotation { // Include java environment variables in openApiCliCommand var javaOpts = Platform.environment['JAVA_OPTS'] ?? ''; - ProcessResult result; - if (!testMode) { - result = await Process.run( - 'java', - [ + final result = await runExternalProcess( + command: Command( + executable: 'java', + arguments: [ if (javaOpts.isNotEmpty) javaOpts, '-jar', binPath, ...args, ], - workingDirectory: Directory.current.path, - runInShell: Platform.isWindows, - ); - } else { - result = ProcessResult(999999, 0, null, null); - } - + ), + workingDirectory: Directory.current.path, + ); if (result.exitCode != 0) { return Future.error( OutputMessage( @@ -359,17 +347,8 @@ class OpenapiGenerator extends GeneratorForAnnotation { ), ); - ProcessResult results; - if (!testMode) { - results = await Process.run( - command.executable, - command.arguments, - runInShell: Platform.isWindows, - workingDirectory: args.outputDirectory, - ); - } else { - results = ProcessResult(99999, 0, null, null); - } + final results = await runExternalProcess( + command: command, workingDirectory: args.outputDirectory); if (results.exitCode != 0) { return Future.error( @@ -415,18 +394,8 @@ class OpenapiGenerator extends GeneratorForAnnotation { ), ); - ProcessResult results; - if (!testMode) { - results = await Process.run( - command.executable, - command.arguments, - runInShell: Platform.isWindows, - workingDirectory: args.outputDirectory, - ); - } else { - results = ProcessResult(999999, 0, null, null); - } - + final results = await runExternalProcess( + command: command, workingDirectory: args.outputDirectory); if (results.exitCode != 0) { return Future.error( OutputMessage( @@ -499,17 +468,8 @@ class OpenapiGenerator extends GeneratorForAnnotation { /// Format the generated code in the output directory. Future formatCode({required GeneratorArguments args}) async { final command = Command(executable: 'dart', arguments: ['format', './']); - ProcessResult result; - if (!testMode) { - result = await Process.run( - command.executable, - command.arguments, - workingDirectory: args.outputDirectory, - runInShell: Platform.isWindows, - ); - } else { - result = ProcessResult(99999, 0, null, null); - } + final result = await runExternalProcess( + command: command, workingDirectory: args.outputDirectory); if (result.exitCode != 0) { return Future.error( @@ -522,9 +482,20 @@ class OpenapiGenerator extends GeneratorForAnnotation { ); } else { logOutputMessage( - log: log, - communication: - OutputMessage(message: 'Successfully formatted code.')); + log: log, + communication: OutputMessage( + message: 'Successfully formatted code.', + ), + ); } } + + Future runExternalProcess( + {required Command command, required String workingDirectory}) => + Process.run( + command.executable, + command.arguments, + workingDirectory: workingDirectory, + runInShell: Platform.isWindows, + ); } diff --git a/openapi-generator/pubspec.yaml b/openapi-generator/pubspec.yaml index a20cafc..fa8fe7a 100755 --- a/openapi-generator/pubspec.yaml +++ b/openapi-generator/pubspec.yaml @@ -24,3 +24,4 @@ dev_dependencies: source_gen_test: pedantic: coverage: ^1.6.3 + mockito: diff --git a/openapi-generator/test/generator_test.dart b/openapi-generator/test/generator_test.dart new file mode 100644 index 0000000..ce78987 --- /dev/null +++ b/openapi-generator/test/generator_test.dart @@ -0,0 +1,111 @@ +import 'dart:io'; + +import 'package:analyzer/dart/analysis/session.dart'; +import 'package:analyzer/dart/element/element.dart'; +import 'package:analyzer/dart/element/type.dart'; +import 'package:analyzer/src/generated/engine.dart'; +import 'package:analyzer/src/generated/source.dart'; +import 'package:build_test/build_test.dart'; +import 'package:logging/logging.dart'; +import 'package:mockito/mockito.dart'; +import 'package:openapi_generator/src/models/generator_arguments.dart'; +import 'package:openapi_generator/src/models/output_message.dart'; +import 'package:openapi_generator/src/openapi_generator_runner.dart'; +import 'package:pub_semver/src/version.dart'; +import 'package:source_gen/source_gen.dart'; +import 'package:test/test.dart'; + +import 'mocks.mocks.dart'; +import 'utils.dart'; + +void main() { + group('OpenApiGenerator', () { + group('NextGen', () { + late MockConstantReader mockedAnnotations; + late ConstantReader defaultAnnotations; + late MockOpenapiGenerator generator; + late GeneratorArguments realArguments; + setUpAll(() async { + mockedAnnotations = MockConstantReader(); + defaultAnnotations = (await resolveSource( + File('$testSpecPath/next_gen_builder_test_config.dart') + .readAsStringSync(), + (resolver) async => + (await resolver.findLibraryByName('test_lib'))!)) + .getClass('TestClassConfig')! + .metadata + .map((e) => ConstantReader(e.computeConstantValue()!)) + .first; + realArguments = GeneratorArguments(annotations: defaultAnnotations); + generator = MockOpenapiGenerator(); + }); + + test('throws InvalidGenerationSourceError when not a class', () async { + try { + await OpenapiGenerator().generateForAnnotatedElement( + MockMethodElement(), defaultAnnotations, MockBuildStep()); + fail('Should throw when not ClassElement'); + } catch (e, _) { + expect(e, isA()); + e as InvalidGenerationSourceError; + expect(e.message, 'Generator cannot target ``.'); + expect(e.todo, 'Remove the [Openapi] annotation from ``.'); + } + }); + + test('throws AssertionError when useCache is set but useNextGen is not', + () async { + final mockedUseNextGen = MockConstantReader(); + when(mockedUseNextGen.literalValue).thenReturn(false); + + final mockedUseCachePath = MockConstantReader(); + when(mockedUseCachePath.literalValue).thenReturn('something'); + + when(mockedAnnotations.read('useNextGen')).thenReturn(mockedUseNextGen); + when(mockedAnnotations.read('cachePath')) + .thenReturn(mockedUseCachePath); + + try { + await OpenapiGenerator().generateForAnnotatedElement( + MockClassElement(), mockedAnnotations, MockBuildStep()); + fail('Should throw when useNextGen is false and cache path is set.'); + } catch (e, _) { + expect(e, isA()); + e as AssertionError; + expect(e.message, 'useNextGen must be set when using cachePath'); + } + }); + + group('runOpenApiJar', () { + test('returns an error when the jar command fails', () async { + when( + generator.runExternalProcess( + command: anyNamed('command'), + workingDirectory: anyNamed( + 'workingDirectory', + ), + ), + ).thenAnswer( + (realInvocation) => Future.value( + ProcessResult(999, 1, '', 'something went wrong'), + ), + ); + + try { + await generator.runOpenApiJar(arguments: realArguments); + fail( + 'should have returned an error log.', + ); + } catch (e, _) { + expect(e, isA()); + e as OutputMessage; + expect(e.level, Level.SEVERE); + expect(e.message, 'Codegen Failed. Generator output:'); + expect(e.additionalContext, 'something went wrong'); + expect(e.stackTrace, isNotNull); + } + }); + }); + }); + }); +} diff --git a/openapi-generator/test/mocks.dart b/openapi-generator/test/mocks.dart new file mode 100644 index 0000000..bd0f40b --- /dev/null +++ b/openapi-generator/test/mocks.dart @@ -0,0 +1,17 @@ +import 'dart:io'; + +import 'package:analyzer/dart/element/element.dart'; +import 'package:build/build.dart'; +import 'package:mockito/annotations.dart'; +import 'package:openapi_generator/src/openapi_generator_runner.dart'; +import 'package:source_gen/source_gen.dart'; + +@GenerateNiceMocks([ + MockSpec(), + MockSpec(), + MockSpec(), + MockSpec(), + MockSpec(), + MockSpec(), +]) +void main() {} diff --git a/openapi-generator/test/mocks.mocks.dart b/openapi-generator/test/mocks.mocks.dart new file mode 100644 index 0000000..8c6e7ca --- /dev/null +++ b/openapi-generator/test/mocks.mocks.dart @@ -0,0 +1,2226 @@ +// Mocks generated by Mockito 5.4.2 from annotations +// in openapi_generator/test/mocks.dart. +// Do not manually edit this file. + +// ignore_for_file: no_leading_underscores_for_library_prefixes +import 'dart:async' as _i8; +import 'dart:convert' as _i17; +import 'dart:io' as _i12; + +import 'package:analyzer/dart/constant/value.dart' as _i3; +import 'package:analyzer/dart/element/element.dart' as _i6; +import 'package:analyzer/dart/element/nullability_suffix.dart' as _i19; +import 'package:analyzer/dart/element/type.dart' as _i4; +import 'package:analyzer/src/generated/engine.dart' as _i10; +import 'package:analyzer/src/generated/source.dart' as _i11; +import 'package:build/build.dart' as _i5; +import 'package:crypto/crypto.dart' as _i9; +import 'package:glob/glob.dart' as _i18; +import 'package:mockito/mockito.dart' as _i1; +import 'package:mockito/src/dummies.dart' as _i16; +import 'package:openapi_generator/src/models/command.dart' as _i15; +import 'package:openapi_generator/src/models/generator_arguments.dart' as _i14; +import 'package:openapi_generator/src/openapi_generator_runner.dart' as _i13; +import 'package:package_config/package_config_types.dart' as _i7; +import 'package:source_gen/source_gen.dart' as _i2; + +// ignore_for_file: type=lint +// ignore_for_file: avoid_redundant_argument_values +// ignore_for_file: avoid_setters_without_getters +// ignore_for_file: comment_references +// ignore_for_file: implementation_imports +// ignore_for_file: invalid_use_of_visible_for_testing_member +// ignore_for_file: prefer_const_constructors +// ignore_for_file: unnecessary_parenthesis +// ignore_for_file: camel_case_types +// ignore_for_file: subtype_of_sealed_class + +class _FakeTypeChecker_0 extends _i1.SmartFake implements _i2.TypeChecker { + _FakeTypeChecker_0( + Object parent, + Invocation parentInvocation, + ) : super( + parent, + parentInvocation, + ); +} + +class _FakeDartObject_1 extends _i1.SmartFake implements _i3.DartObject { + _FakeDartObject_1( + Object parent, + Invocation parentInvocation, + ) : super( + parent, + parentInvocation, + ); +} + +class _FakeSymbol_2 extends _i1.SmartFake implements Symbol { + _FakeSymbol_2( + Object parent, + Invocation parentInvocation, + ) : super( + parent, + parentInvocation, + ); +} + +class _FakeDartType_3 extends _i1.SmartFake implements _i4.DartType { + _FakeDartType_3( + Object parent, + Invocation parentInvocation, + ) : super( + parent, + parentInvocation, + ); +} + +class _FakeConstantReader_4 extends _i1.SmartFake + implements _i2.ConstantReader { + _FakeConstantReader_4( + Object parent, + Invocation parentInvocation, + ) : super( + parent, + parentInvocation, + ); +} + +class _FakeRevivable_5 extends _i1.SmartFake implements _i2.Revivable { + _FakeRevivable_5( + Object parent, + Invocation parentInvocation, + ) : super( + parent, + parentInvocation, + ); +} + +class _FakeAssetId_6 extends _i1.SmartFake implements _i5.AssetId { + _FakeAssetId_6( + Object parent, + Invocation parentInvocation, + ) : super( + parent, + parentInvocation, + ); +} + +class _FakeLibraryElement_7 extends _i1.SmartFake + implements _i6.LibraryElement { + _FakeLibraryElement_7( + Object parent, + Invocation parentInvocation, + ) : super( + parent, + parentInvocation, + ); +} + +class _FakeResolver_8 extends _i1.SmartFake implements _i5.Resolver { + _FakeResolver_8( + Object parent, + Invocation parentInvocation, + ) : super( + parent, + parentInvocation, + ); +} + +class _FakePackageConfig_9 extends _i1.SmartFake implements _i7.PackageConfig { + _FakePackageConfig_9( + Object parent, + Invocation parentInvocation, + ) : super( + parent, + parentInvocation, + ); +} + +class _FakeFuture_10 extends _i1.SmartFake implements _i8.Future { + _FakeFuture_10( + Object parent, + Invocation parentInvocation, + ) : super( + parent, + parentInvocation, + ); +} + +class _FakeDigest_11 extends _i1.SmartFake implements _i9.Digest { + _FakeDigest_11( + Object parent, + Invocation parentInvocation, + ) : super( + parent, + parentInvocation, + ); +} + +class _FakeMethodElement_12 extends _i1.SmartFake implements _i6.MethodElement { + _FakeMethodElement_12( + Object parent, + Invocation parentInvocation, + ) : super( + parent, + parentInvocation, + ); +} + +class _FakeElement_13 extends _i1.SmartFake implements _i6.Element { + _FakeElement_13( + Object parent, + Invocation parentInvocation, + ) : super( + parent, + parentInvocation, + ); +} + +class _FakeAnalysisContext_14 extends _i1.SmartFake + implements _i10.AnalysisContext { + _FakeAnalysisContext_14( + Object parent, + Invocation parentInvocation, + ) : super( + parent, + parentInvocation, + ); +} + +class _FakeElementKind_15 extends _i1.SmartFake implements _i6.ElementKind { + _FakeElementKind_15( + Object parent, + Invocation parentInvocation, + ) : super( + parent, + parentInvocation, + ); +} + +class _FakeSource_16 extends _i1.SmartFake implements _i11.Source { + _FakeSource_16( + Object parent, + Invocation parentInvocation, + ) : super( + parent, + parentInvocation, + ); +} + +class _FakeFunctionType_17 extends _i1.SmartFake implements _i4.FunctionType { + _FakeFunctionType_17( + Object parent, + Invocation parentInvocation, + ) : super( + parent, + parentInvocation, + ); +} + +class _FakeAugmentedClassElement_18 extends _i1.SmartFake + implements _i6.AugmentedClassElement { + _FakeAugmentedClassElement_18( + Object parent, + Invocation parentInvocation, + ) : super( + parent, + parentInvocation, + ); +} + +class _FakeCompilationUnitElement_19 extends _i1.SmartFake + implements _i6.CompilationUnitElement { + _FakeCompilationUnitElement_19( + Object parent, + Invocation parentInvocation, + ) : super( + parent, + parentInvocation, + ); +} + +class _FakeInterfaceType_20 extends _i1.SmartFake implements _i4.InterfaceType { + _FakeInterfaceType_20( + Object parent, + Invocation parentInvocation, + ) : super( + parent, + parentInvocation, + ); +} + +class _FakeIOSink_21 extends _i1.SmartFake implements _i12.IOSink { + _FakeIOSink_21( + Object parent, + Invocation parentInvocation, + ) : super( + parent, + parentInvocation, + ); +} + +/// A class which mocks [OpenapiGenerator]. +/// +/// See the documentation for Mockito's code generation for more information. +class MockOpenapiGenerator extends _i1.Mock implements _i13.OpenapiGenerator { + @override + bool get testMode => (super.noSuchMethod( + Invocation.getter(#testMode), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + _i2.TypeChecker get typeChecker => (super.noSuchMethod( + Invocation.getter(#typeChecker), + returnValue: _FakeTypeChecker_0( + this, + Invocation.getter(#typeChecker), + ), + returnValueForMissingStub: _FakeTypeChecker_0( + this, + Invocation.getter(#typeChecker), + ), + ) as _i2.TypeChecker); + @override + _i8.FutureOr generateForAnnotatedElement( + _i6.Element? element, + _i2.ConstantReader? annotations, + _i5.BuildStep? buildStep, + ) => + (super.noSuchMethod( + Invocation.method( + #generateForAnnotatedElement, + [ + element, + annotations, + buildStep, + ], + ), + returnValue: _i8.Future.value(''), + returnValueForMissingStub: _i8.Future.value(''), + ) as _i8.FutureOr); + @override + _i8.Future runOpenApiJar( + {required _i14.GeneratorArguments? arguments}) => + (super.noSuchMethod( + Invocation.method( + #runOpenApiJar, + [], + {#arguments: arguments}, + ), + returnValue: _i8.Future.value(), + returnValueForMissingStub: _i8.Future.value(), + ) as _i8.Future); + @override + _i8.FutureOr generatorV2({ + required _i14.GeneratorArguments? args, + required String? baseCommand, + required String? annotatedPath, + }) => + (super.noSuchMethod( + Invocation.method( + #generatorV2, + [], + { + #args: args, + #baseCommand: baseCommand, + #annotatedPath: annotatedPath, + }, + ), + returnValue: _i8.Future.value(''), + returnValueForMissingStub: _i8.Future.value(''), + ) as _i8.FutureOr); + @override + _i8.FutureOr hasDiff({required _i14.GeneratorArguments? args}) => + (super.noSuchMethod( + Invocation.method( + #hasDiff, + [], + {#args: args}, + ), + returnValue: _i8.Future.value(false), + returnValueForMissingStub: _i8.Future.value(false), + ) as _i8.FutureOr); + @override + _i8.FutureOr generateSources({ + required String? baseCommand, + required _i14.GeneratorArguments? args, + }) => + (super.noSuchMethod( + Invocation.method( + #generateSources, + [], + { + #baseCommand: baseCommand, + #args: args, + }, + ), + returnValueForMissingStub: null, + ) as _i8.FutureOr); + @override + _i8.Future runSourceGen({ + required String? baseCommand, + required _i14.GeneratorArguments? args, + }) => + (super.noSuchMethod( + Invocation.method( + #runSourceGen, + [], + { + #baseCommand: baseCommand, + #args: args, + }, + ), + returnValue: _i8.Future.value(), + returnValueForMissingStub: _i8.Future.value(), + ) as _i8.Future); + @override + _i8.FutureOr fetchDependencies({ + required String? baseCommand, + required _i14.GeneratorArguments? args, + }) => + (super.noSuchMethod( + Invocation.method( + #fetchDependencies, + [], + { + #baseCommand: baseCommand, + #args: args, + }, + ), + returnValueForMissingStub: null, + ) as _i8.FutureOr); + @override + _i8.Future updateCachedSpec({ + required Map? updatedSpec, + required String? cachedPath, + }) => + (super.noSuchMethod( + Invocation.method( + #updateCachedSpec, + [], + { + #updatedSpec: updatedSpec, + #cachedPath: cachedPath, + }, + ), + returnValue: _i8.Future.value(), + returnValueForMissingStub: _i8.Future.value(), + ) as _i8.Future); + @override + _i8.Future updateAnnotatedFile({required dynamic annotatedPath}) => + (super.noSuchMethod( + Invocation.method( + #updateAnnotatedFile, + [], + {#annotatedPath: annotatedPath}, + ), + returnValue: _i8.Future.value(), + returnValueForMissingStub: _i8.Future.value(), + ) as _i8.Future); + @override + _i8.Future formatCode({required _i14.GeneratorArguments? args}) => + (super.noSuchMethod( + Invocation.method( + #formatCode, + [], + {#args: args}, + ), + returnValue: _i8.Future.value(), + returnValueForMissingStub: _i8.Future.value(), + ) as _i8.Future); + @override + _i8.Future<_i12.ProcessResult> runExternalProcess({ + required _i15.Command? command, + required String? workingDirectory, + }) => + (super.noSuchMethod( + Invocation.method( + #runExternalProcess, + [], + { + #command: command, + #workingDirectory: workingDirectory, + }, + ), + returnValue: _i8.Future<_i12.ProcessResult>.value( + _i16.dummyValue<_i12.ProcessResult>( + this, + Invocation.method( + #runExternalProcess, + [], + { + #command: command, + #workingDirectory: workingDirectory, + }, + ), + )), + returnValueForMissingStub: _i8.Future<_i12.ProcessResult>.value( + _i16.dummyValue<_i12.ProcessResult>( + this, + Invocation.method( + #runExternalProcess, + [], + { + #command: command, + #workingDirectory: workingDirectory, + }, + ), + )), + ) as _i8.Future<_i12.ProcessResult>); + @override + _i8.FutureOr generate( + _i2.LibraryReader? library, + _i5.BuildStep? buildStep, + ) => + (super.noSuchMethod( + Invocation.method( + #generate, + [ + library, + buildStep, + ], + ), + returnValue: _i8.Future.value(''), + returnValueForMissingStub: _i8.Future.value(''), + ) as _i8.FutureOr); +} + +/// A class which mocks [ConstantReader]. +/// +/// See the documentation for Mockito's code generation for more information. +class MockConstantReader extends _i1.Mock implements _i2.ConstantReader { + @override + bool get isLiteral => (super.noSuchMethod( + Invocation.getter(#isLiteral), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + _i3.DartObject get objectValue => (super.noSuchMethod( + Invocation.getter(#objectValue), + returnValue: _FakeDartObject_1( + this, + Invocation.getter(#objectValue), + ), + returnValueForMissingStub: _FakeDartObject_1( + this, + Invocation.getter(#objectValue), + ), + ) as _i3.DartObject); + @override + bool get isNull => (super.noSuchMethod( + Invocation.getter(#isNull), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get isBool => (super.noSuchMethod( + Invocation.getter(#isBool), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get boolValue => (super.noSuchMethod( + Invocation.getter(#boolValue), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get isInt => (super.noSuchMethod( + Invocation.getter(#isInt), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + int get intValue => (super.noSuchMethod( + Invocation.getter(#intValue), + returnValue: 0, + returnValueForMissingStub: 0, + ) as int); + @override + bool get isDouble => (super.noSuchMethod( + Invocation.getter(#isDouble), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + double get doubleValue => (super.noSuchMethod( + Invocation.getter(#doubleValue), + returnValue: 0.0, + returnValueForMissingStub: 0.0, + ) as double); + @override + bool get isString => (super.noSuchMethod( + Invocation.getter(#isString), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + String get stringValue => (super.noSuchMethod( + Invocation.getter(#stringValue), + returnValue: '', + returnValueForMissingStub: '', + ) as String); + @override + bool get isSymbol => (super.noSuchMethod( + Invocation.getter(#isSymbol), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + Symbol get symbolValue => (super.noSuchMethod( + Invocation.getter(#symbolValue), + returnValue: _FakeSymbol_2( + this, + Invocation.getter(#symbolValue), + ), + returnValueForMissingStub: _FakeSymbol_2( + this, + Invocation.getter(#symbolValue), + ), + ) as Symbol); + @override + bool get isType => (super.noSuchMethod( + Invocation.getter(#isType), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + _i4.DartType get typeValue => (super.noSuchMethod( + Invocation.getter(#typeValue), + returnValue: _FakeDartType_3( + this, + Invocation.getter(#typeValue), + ), + returnValueForMissingStub: _FakeDartType_3( + this, + Invocation.getter(#typeValue), + ), + ) as _i4.DartType); + @override + bool get isMap => (super.noSuchMethod( + Invocation.getter(#isMap), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + Map<_i3.DartObject?, _i3.DartObject?> get mapValue => (super.noSuchMethod( + Invocation.getter(#mapValue), + returnValue: <_i3.DartObject?, _i3.DartObject?>{}, + returnValueForMissingStub: <_i3.DartObject?, _i3.DartObject?>{}, + ) as Map<_i3.DartObject?, _i3.DartObject?>); + @override + bool get isList => (super.noSuchMethod( + Invocation.getter(#isList), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + List<_i3.DartObject> get listValue => (super.noSuchMethod( + Invocation.getter(#listValue), + returnValue: <_i3.DartObject>[], + returnValueForMissingStub: <_i3.DartObject>[], + ) as List<_i3.DartObject>); + @override + bool get isSet => (super.noSuchMethod( + Invocation.getter(#isSet), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + Set<_i3.DartObject> get setValue => (super.noSuchMethod( + Invocation.getter(#setValue), + returnValue: <_i3.DartObject>{}, + returnValueForMissingStub: <_i3.DartObject>{}, + ) as Set<_i3.DartObject>); + @override + bool instanceOf(_i2.TypeChecker? checker) => (super.noSuchMethod( + Invocation.method( + #instanceOf, + [checker], + ), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + _i2.ConstantReader read(String? field) => (super.noSuchMethod( + Invocation.method( + #read, + [field], + ), + returnValue: _FakeConstantReader_4( + this, + Invocation.method( + #read, + [field], + ), + ), + returnValueForMissingStub: _FakeConstantReader_4( + this, + Invocation.method( + #read, + [field], + ), + ), + ) as _i2.ConstantReader); + @override + _i2.ConstantReader? peek(String? field) => (super.noSuchMethod( + Invocation.method( + #peek, + [field], + ), + returnValueForMissingStub: null, + ) as _i2.ConstantReader?); + @override + _i2.Revivable revive() => (super.noSuchMethod( + Invocation.method( + #revive, + [], + ), + returnValue: _FakeRevivable_5( + this, + Invocation.method( + #revive, + [], + ), + ), + returnValueForMissingStub: _FakeRevivable_5( + this, + Invocation.method( + #revive, + [], + ), + ), + ) as _i2.Revivable); +} + +/// A class which mocks [BuildStep]. +/// +/// See the documentation for Mockito's code generation for more information. +class MockBuildStep extends _i1.Mock implements _i5.BuildStep { + @override + _i5.AssetId get inputId => (super.noSuchMethod( + Invocation.getter(#inputId), + returnValue: _FakeAssetId_6( + this, + Invocation.getter(#inputId), + ), + returnValueForMissingStub: _FakeAssetId_6( + this, + Invocation.getter(#inputId), + ), + ) as _i5.AssetId); + @override + _i8.Future<_i6.LibraryElement> get inputLibrary => (super.noSuchMethod( + Invocation.getter(#inputLibrary), + returnValue: _i8.Future<_i6.LibraryElement>.value(_FakeLibraryElement_7( + this, + Invocation.getter(#inputLibrary), + )), + returnValueForMissingStub: + _i8.Future<_i6.LibraryElement>.value(_FakeLibraryElement_7( + this, + Invocation.getter(#inputLibrary), + )), + ) as _i8.Future<_i6.LibraryElement>); + @override + _i5.Resolver get resolver => (super.noSuchMethod( + Invocation.getter(#resolver), + returnValue: _FakeResolver_8( + this, + Invocation.getter(#resolver), + ), + returnValueForMissingStub: _FakeResolver_8( + this, + Invocation.getter(#resolver), + ), + ) as _i5.Resolver); + @override + Iterable<_i5.AssetId> get allowedOutputs => (super.noSuchMethod( + Invocation.getter(#allowedOutputs), + returnValue: <_i5.AssetId>[], + returnValueForMissingStub: <_i5.AssetId>[], + ) as Iterable<_i5.AssetId>); + @override + _i8.Future<_i7.PackageConfig> get packageConfig => (super.noSuchMethod( + Invocation.getter(#packageConfig), + returnValue: _i8.Future<_i7.PackageConfig>.value(_FakePackageConfig_9( + this, + Invocation.getter(#packageConfig), + )), + returnValueForMissingStub: + _i8.Future<_i7.PackageConfig>.value(_FakePackageConfig_9( + this, + Invocation.getter(#packageConfig), + )), + ) as _i8.Future<_i7.PackageConfig>); + @override + _i8.Future fetchResource(_i5.Resource? resource) => + (super.noSuchMethod( + Invocation.method( + #fetchResource, + [resource], + ), + returnValue: _i16.ifNotNull( + _i16.dummyValueOrNull( + this, + Invocation.method( + #fetchResource, + [resource], + ), + ), + (T v) => _i8.Future.value(v), + ) ?? + _FakeFuture_10( + this, + Invocation.method( + #fetchResource, + [resource], + ), + ), + returnValueForMissingStub: _i16.ifNotNull( + _i16.dummyValueOrNull( + this, + Invocation.method( + #fetchResource, + [resource], + ), + ), + (T v) => _i8.Future.value(v), + ) ?? + _FakeFuture_10( + this, + Invocation.method( + #fetchResource, + [resource], + ), + ), + ) as _i8.Future); + @override + _i8.Future writeAsBytes( + _i5.AssetId? id, + _i8.FutureOr>? bytes, + ) => + (super.noSuchMethod( + Invocation.method( + #writeAsBytes, + [ + id, + bytes, + ], + ), + returnValue: _i8.Future.value(), + returnValueForMissingStub: _i8.Future.value(), + ) as _i8.Future); + @override + _i8.Future writeAsString( + _i5.AssetId? id, + _i8.FutureOr? contents, { + _i17.Encoding? encoding = const _i17.Utf8Codec(), + }) => + (super.noSuchMethod( + Invocation.method( + #writeAsString, + [ + id, + contents, + ], + {#encoding: encoding}, + ), + returnValue: _i8.Future.value(), + returnValueForMissingStub: _i8.Future.value(), + ) as _i8.Future); + @override + T trackStage( + String? label, + T Function()? action, { + bool? isExternal = false, + }) => + (super.noSuchMethod( + Invocation.method( + #trackStage, + [ + label, + action, + ], + {#isExternal: isExternal}, + ), + returnValue: _i16.dummyValue( + this, + Invocation.method( + #trackStage, + [ + label, + action, + ], + {#isExternal: isExternal}, + ), + ), + returnValueForMissingStub: _i16.dummyValue( + this, + Invocation.method( + #trackStage, + [ + label, + action, + ], + {#isExternal: isExternal}, + ), + ), + ) as T); + @override + void reportUnusedAssets(Iterable<_i5.AssetId>? ids) => super.noSuchMethod( + Invocation.method( + #reportUnusedAssets, + [ids], + ), + returnValueForMissingStub: null, + ); + @override + _i8.Future> readAsBytes(_i5.AssetId? id) => (super.noSuchMethod( + Invocation.method( + #readAsBytes, + [id], + ), + returnValue: _i8.Future>.value([]), + returnValueForMissingStub: _i8.Future>.value([]), + ) as _i8.Future>); + @override + _i8.Future readAsString( + _i5.AssetId? id, { + _i17.Encoding? encoding = const _i17.Utf8Codec(), + }) => + (super.noSuchMethod( + Invocation.method( + #readAsString, + [id], + {#encoding: encoding}, + ), + returnValue: _i8.Future.value(''), + returnValueForMissingStub: _i8.Future.value(''), + ) as _i8.Future); + @override + _i8.Future canRead(_i5.AssetId? id) => (super.noSuchMethod( + Invocation.method( + #canRead, + [id], + ), + returnValue: _i8.Future.value(false), + returnValueForMissingStub: _i8.Future.value(false), + ) as _i8.Future); + @override + _i8.Stream<_i5.AssetId> findAssets(_i18.Glob? glob) => (super.noSuchMethod( + Invocation.method( + #findAssets, + [glob], + ), + returnValue: _i8.Stream<_i5.AssetId>.empty(), + returnValueForMissingStub: _i8.Stream<_i5.AssetId>.empty(), + ) as _i8.Stream<_i5.AssetId>); + @override + _i8.Future<_i9.Digest> digest(_i5.AssetId? id) => (super.noSuchMethod( + Invocation.method( + #digest, + [id], + ), + returnValue: _i8.Future<_i9.Digest>.value(_FakeDigest_11( + this, + Invocation.method( + #digest, + [id], + ), + )), + returnValueForMissingStub: _i8.Future<_i9.Digest>.value(_FakeDigest_11( + this, + Invocation.method( + #digest, + [id], + ), + )), + ) as _i8.Future<_i9.Digest>); +} + +/// A class which mocks [MethodElement]. +/// +/// See the documentation for Mockito's code generation for more information. +class MockMethodElement extends _i1.Mock implements _i6.MethodElement { + @override + _i6.MethodElement get declaration => (super.noSuchMethod( + Invocation.getter(#declaration), + returnValue: _FakeMethodElement_12( + this, + Invocation.getter(#declaration), + ), + returnValueForMissingStub: _FakeMethodElement_12( + this, + Invocation.getter(#declaration), + ), + ) as _i6.MethodElement); + @override + _i6.Element get enclosingElement => (super.noSuchMethod( + Invocation.getter(#enclosingElement), + returnValue: _FakeElement_13( + this, + Invocation.getter(#enclosingElement), + ), + returnValueForMissingStub: _FakeElement_13( + this, + Invocation.getter(#enclosingElement), + ), + ) as _i6.Element); + @override + _i6.Element get enclosingElement3 => (super.noSuchMethod( + Invocation.getter(#enclosingElement3), + returnValue: _FakeElement_13( + this, + Invocation.getter(#enclosingElement3), + ), + returnValueForMissingStub: _FakeElement_13( + this, + Invocation.getter(#enclosingElement3), + ), + ) as _i6.Element); + @override + bool get isStatic => (super.noSuchMethod( + Invocation.getter(#isStatic), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + List<_i6.Element> get children => (super.noSuchMethod( + Invocation.getter(#children), + returnValue: <_i6.Element>[], + returnValueForMissingStub: <_i6.Element>[], + ) as List<_i6.Element>); + @override + _i10.AnalysisContext get context => (super.noSuchMethod( + Invocation.getter(#context), + returnValue: _FakeAnalysisContext_14( + this, + Invocation.getter(#context), + ), + returnValueForMissingStub: _FakeAnalysisContext_14( + this, + Invocation.getter(#context), + ), + ) as _i10.AnalysisContext); + @override + String get displayName => (super.noSuchMethod( + Invocation.getter(#displayName), + returnValue: '', + returnValueForMissingStub: '', + ) as String); + @override + bool get hasAlwaysThrows => (super.noSuchMethod( + Invocation.getter(#hasAlwaysThrows), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasDeprecated => (super.noSuchMethod( + Invocation.getter(#hasDeprecated), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasDoNotStore => (super.noSuchMethod( + Invocation.getter(#hasDoNotStore), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasFactory => (super.noSuchMethod( + Invocation.getter(#hasFactory), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasInternal => (super.noSuchMethod( + Invocation.getter(#hasInternal), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasIsTest => (super.noSuchMethod( + Invocation.getter(#hasIsTest), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasIsTestGroup => (super.noSuchMethod( + Invocation.getter(#hasIsTestGroup), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasJS => (super.noSuchMethod( + Invocation.getter(#hasJS), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasLiteral => (super.noSuchMethod( + Invocation.getter(#hasLiteral), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasMustBeOverridden => (super.noSuchMethod( + Invocation.getter(#hasMustBeOverridden), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasMustCallSuper => (super.noSuchMethod( + Invocation.getter(#hasMustCallSuper), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasNonVirtual => (super.noSuchMethod( + Invocation.getter(#hasNonVirtual), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasOptionalTypeArgs => (super.noSuchMethod( + Invocation.getter(#hasOptionalTypeArgs), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasOverride => (super.noSuchMethod( + Invocation.getter(#hasOverride), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasProtected => (super.noSuchMethod( + Invocation.getter(#hasProtected), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasReopen => (super.noSuchMethod( + Invocation.getter(#hasReopen), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasRequired => (super.noSuchMethod( + Invocation.getter(#hasRequired), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasSealed => (super.noSuchMethod( + Invocation.getter(#hasSealed), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasUseResult => (super.noSuchMethod( + Invocation.getter(#hasUseResult), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasVisibleForOverriding => (super.noSuchMethod( + Invocation.getter(#hasVisibleForOverriding), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasVisibleForTemplate => (super.noSuchMethod( + Invocation.getter(#hasVisibleForTemplate), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasVisibleForTesting => (super.noSuchMethod( + Invocation.getter(#hasVisibleForTesting), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + int get id => (super.noSuchMethod( + Invocation.getter(#id), + returnValue: 0, + returnValueForMissingStub: 0, + ) as int); + @override + bool get isPrivate => (super.noSuchMethod( + Invocation.getter(#isPrivate), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get isPublic => (super.noSuchMethod( + Invocation.getter(#isPublic), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get isSynthetic => (super.noSuchMethod( + Invocation.getter(#isSynthetic), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + _i6.ElementKind get kind => (super.noSuchMethod( + Invocation.getter(#kind), + returnValue: _FakeElementKind_15( + this, + Invocation.getter(#kind), + ), + returnValueForMissingStub: _FakeElementKind_15( + this, + Invocation.getter(#kind), + ), + ) as _i6.ElementKind); + @override + _i6.LibraryElement get library => (super.noSuchMethod( + Invocation.getter(#library), + returnValue: _FakeLibraryElement_7( + this, + Invocation.getter(#library), + ), + returnValueForMissingStub: _FakeLibraryElement_7( + this, + Invocation.getter(#library), + ), + ) as _i6.LibraryElement); + @override + List<_i6.ElementAnnotation> get metadata => (super.noSuchMethod( + Invocation.getter(#metadata), + returnValue: <_i6.ElementAnnotation>[], + returnValueForMissingStub: <_i6.ElementAnnotation>[], + ) as List<_i6.ElementAnnotation>); + @override + String get name => (super.noSuchMethod( + Invocation.getter(#name), + returnValue: '', + returnValueForMissingStub: '', + ) as String); + @override + int get nameLength => (super.noSuchMethod( + Invocation.getter(#nameLength), + returnValue: 0, + returnValueForMissingStub: 0, + ) as int); + @override + int get nameOffset => (super.noSuchMethod( + Invocation.getter(#nameOffset), + returnValue: 0, + returnValueForMissingStub: 0, + ) as int); + @override + _i6.Element get nonSynthetic => (super.noSuchMethod( + Invocation.getter(#nonSynthetic), + returnValue: _FakeElement_13( + this, + Invocation.getter(#nonSynthetic), + ), + returnValueForMissingStub: _FakeElement_13( + this, + Invocation.getter(#nonSynthetic), + ), + ) as _i6.Element); + @override + _i11.Source get source => (super.noSuchMethod( + Invocation.getter(#source), + returnValue: _FakeSource_16( + this, + Invocation.getter(#source), + ), + returnValueForMissingStub: _FakeSource_16( + this, + Invocation.getter(#source), + ), + ) as _i11.Source); + @override + _i11.Source get librarySource => (super.noSuchMethod( + Invocation.getter(#librarySource), + returnValue: _FakeSource_16( + this, + Invocation.getter(#librarySource), + ), + returnValueForMissingStub: _FakeSource_16( + this, + Invocation.getter(#librarySource), + ), + ) as _i11.Source); + @override + bool get hasImplicitReturnType => (super.noSuchMethod( + Invocation.getter(#hasImplicitReturnType), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get isAbstract => (super.noSuchMethod( + Invocation.getter(#isAbstract), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get isAsynchronous => (super.noSuchMethod( + Invocation.getter(#isAsynchronous), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get isExternal => (super.noSuchMethod( + Invocation.getter(#isExternal), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get isGenerator => (super.noSuchMethod( + Invocation.getter(#isGenerator), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get isOperator => (super.noSuchMethod( + Invocation.getter(#isOperator), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get isSynchronous => (super.noSuchMethod( + Invocation.getter(#isSynchronous), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + List<_i6.ParameterElement> get parameters => (super.noSuchMethod( + Invocation.getter(#parameters), + returnValue: <_i6.ParameterElement>[], + returnValueForMissingStub: <_i6.ParameterElement>[], + ) as List<_i6.ParameterElement>); + @override + _i4.DartType get returnType => (super.noSuchMethod( + Invocation.getter(#returnType), + returnValue: _FakeDartType_3( + this, + Invocation.getter(#returnType), + ), + returnValueForMissingStub: _FakeDartType_3( + this, + Invocation.getter(#returnType), + ), + ) as _i4.DartType); + @override + _i4.FunctionType get type => (super.noSuchMethod( + Invocation.getter(#type), + returnValue: _FakeFunctionType_17( + this, + Invocation.getter(#type), + ), + returnValueForMissingStub: _FakeFunctionType_17( + this, + Invocation.getter(#type), + ), + ) as _i4.FunctionType); + @override + bool get isSimplyBounded => (super.noSuchMethod( + Invocation.getter(#isSimplyBounded), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + List<_i6.TypeParameterElement> get typeParameters => (super.noSuchMethod( + Invocation.getter(#typeParameters), + returnValue: <_i6.TypeParameterElement>[], + returnValueForMissingStub: <_i6.TypeParameterElement>[], + ) as List<_i6.TypeParameterElement>); + @override + T? accept(_i6.ElementVisitor? visitor) => (super.noSuchMethod( + Invocation.method( + #accept, + [visitor], + ), + returnValueForMissingStub: null, + ) as T?); + @override + String getDisplayString({ + required bool? withNullability, + bool? multiline = false, + }) => + (super.noSuchMethod( + Invocation.method( + #getDisplayString, + [], + { + #withNullability: withNullability, + #multiline: multiline, + }, + ), + returnValue: '', + returnValueForMissingStub: '', + ) as String); + @override + String getExtendedDisplayName(String? shortName) => (super.noSuchMethod( + Invocation.method( + #getExtendedDisplayName, + [shortName], + ), + returnValue: '', + returnValueForMissingStub: '', + ) as String); + @override + bool isAccessibleIn(_i6.LibraryElement? library) => (super.noSuchMethod( + Invocation.method( + #isAccessibleIn, + [library], + ), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool isAccessibleIn2(_i6.LibraryElement? library) => (super.noSuchMethod( + Invocation.method( + #isAccessibleIn2, + [library], + ), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + E? thisOrAncestorMatching( + bool Function(_i6.Element)? predicate) => + (super.noSuchMethod( + Invocation.method( + #thisOrAncestorMatching, + [predicate], + ), + returnValueForMissingStub: null, + ) as E?); + @override + void visitChildren(_i6.ElementVisitor? visitor) => + super.noSuchMethod( + Invocation.method( + #visitChildren, + [visitor], + ), + returnValueForMissingStub: null, + ); +} + +/// A class which mocks [ClassElement]. +/// +/// See the documentation for Mockito's code generation for more information. +class MockClassElement extends _i1.Mock implements _i6.ClassElement { + @override + _i6.AugmentedClassElement get augmented => (super.noSuchMethod( + Invocation.getter(#augmented), + returnValue: _FakeAugmentedClassElement_18( + this, + Invocation.getter(#augmented), + ), + returnValueForMissingStub: _FakeAugmentedClassElement_18( + this, + Invocation.getter(#augmented), + ), + ) as _i6.AugmentedClassElement); + @override + bool get hasNonFinalField => (super.noSuchMethod( + Invocation.getter(#hasNonFinalField), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get isAbstract => (super.noSuchMethod( + Invocation.getter(#isAbstract), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get isBase => (super.noSuchMethod( + Invocation.getter(#isBase), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get isConstructable => (super.noSuchMethod( + Invocation.getter(#isConstructable), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get isDartCoreEnum => (super.noSuchMethod( + Invocation.getter(#isDartCoreEnum), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get isDartCoreObject => (super.noSuchMethod( + Invocation.getter(#isDartCoreObject), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get isExhaustive => (super.noSuchMethod( + Invocation.getter(#isExhaustive), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get isFinal => (super.noSuchMethod( + Invocation.getter(#isFinal), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get isInterface => (super.noSuchMethod( + Invocation.getter(#isInterface), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get isMixinApplication => (super.noSuchMethod( + Invocation.getter(#isMixinApplication), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get isMixinClass => (super.noSuchMethod( + Invocation.getter(#isMixinClass), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get isSealed => (super.noSuchMethod( + Invocation.getter(#isSealed), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get isValidMixin => (super.noSuchMethod( + Invocation.getter(#isValidMixin), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + List<_i4.InterfaceType> get superclassConstraints => (super.noSuchMethod( + Invocation.getter(#superclassConstraints), + returnValue: <_i4.InterfaceType>[], + returnValueForMissingStub: <_i4.InterfaceType>[], + ) as List<_i4.InterfaceType>); + @override + List<_i6.PropertyAccessorElement> get accessors => (super.noSuchMethod( + Invocation.getter(#accessors), + returnValue: <_i6.PropertyAccessorElement>[], + returnValueForMissingStub: <_i6.PropertyAccessorElement>[], + ) as List<_i6.PropertyAccessorElement>); + @override + List<_i6.ConstructorElement> get constructors => (super.noSuchMethod( + Invocation.getter(#constructors), + returnValue: <_i6.ConstructorElement>[], + returnValueForMissingStub: <_i6.ConstructorElement>[], + ) as List<_i6.ConstructorElement>); + @override + _i6.CompilationUnitElement get enclosingElement => (super.noSuchMethod( + Invocation.getter(#enclosingElement), + returnValue: _FakeCompilationUnitElement_19( + this, + Invocation.getter(#enclosingElement), + ), + returnValueForMissingStub: _FakeCompilationUnitElement_19( + this, + Invocation.getter(#enclosingElement), + ), + ) as _i6.CompilationUnitElement); + @override + _i6.CompilationUnitElement get enclosingElement3 => (super.noSuchMethod( + Invocation.getter(#enclosingElement3), + returnValue: _FakeCompilationUnitElement_19( + this, + Invocation.getter(#enclosingElement3), + ), + returnValueForMissingStub: _FakeCompilationUnitElement_19( + this, + Invocation.getter(#enclosingElement3), + ), + ) as _i6.CompilationUnitElement); + @override + List<_i6.FieldElement> get fields => (super.noSuchMethod( + Invocation.getter(#fields), + returnValue: <_i6.FieldElement>[], + returnValueForMissingStub: <_i6.FieldElement>[], + ) as List<_i6.FieldElement>); + @override + List<_i4.InterfaceType> get interfaces => (super.noSuchMethod( + Invocation.getter(#interfaces), + returnValue: <_i4.InterfaceType>[], + returnValueForMissingStub: <_i4.InterfaceType>[], + ) as List<_i4.InterfaceType>); + @override + List<_i6.MethodElement> get methods => (super.noSuchMethod( + Invocation.getter(#methods), + returnValue: <_i6.MethodElement>[], + returnValueForMissingStub: <_i6.MethodElement>[], + ) as List<_i6.MethodElement>); + @override + List<_i4.InterfaceType> get mixins => (super.noSuchMethod( + Invocation.getter(#mixins), + returnValue: <_i4.InterfaceType>[], + returnValueForMissingStub: <_i4.InterfaceType>[], + ) as List<_i4.InterfaceType>); + @override + String get name => (super.noSuchMethod( + Invocation.getter(#name), + returnValue: '', + returnValueForMissingStub: '', + ) as String); + @override + bool get isSimplyBounded => (super.noSuchMethod( + Invocation.getter(#isSimplyBounded), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + List<_i6.TypeParameterElement> get typeParameters => (super.noSuchMethod( + Invocation.getter(#typeParameters), + returnValue: <_i6.TypeParameterElement>[], + returnValueForMissingStub: <_i6.TypeParameterElement>[], + ) as List<_i6.TypeParameterElement>); + @override + _i6.Element get declaration => (super.noSuchMethod( + Invocation.getter(#declaration), + returnValue: _FakeElement_13( + this, + Invocation.getter(#declaration), + ), + returnValueForMissingStub: _FakeElement_13( + this, + Invocation.getter(#declaration), + ), + ) as _i6.Element); + @override + _i6.LibraryElement get library => (super.noSuchMethod( + Invocation.getter(#library), + returnValue: _FakeLibraryElement_7( + this, + Invocation.getter(#library), + ), + returnValueForMissingStub: _FakeLibraryElement_7( + this, + Invocation.getter(#library), + ), + ) as _i6.LibraryElement); + @override + _i11.Source get librarySource => (super.noSuchMethod( + Invocation.getter(#librarySource), + returnValue: _FakeSource_16( + this, + Invocation.getter(#librarySource), + ), + returnValueForMissingStub: _FakeSource_16( + this, + Invocation.getter(#librarySource), + ), + ) as _i11.Source); + @override + _i11.Source get source => (super.noSuchMethod( + Invocation.getter(#source), + returnValue: _FakeSource_16( + this, + Invocation.getter(#source), + ), + returnValueForMissingStub: _FakeSource_16( + this, + Invocation.getter(#source), + ), + ) as _i11.Source); + @override + List<_i6.Element> get children => (super.noSuchMethod( + Invocation.getter(#children), + returnValue: <_i6.Element>[], + returnValueForMissingStub: <_i6.Element>[], + ) as List<_i6.Element>); + @override + _i10.AnalysisContext get context => (super.noSuchMethod( + Invocation.getter(#context), + returnValue: _FakeAnalysisContext_14( + this, + Invocation.getter(#context), + ), + returnValueForMissingStub: _FakeAnalysisContext_14( + this, + Invocation.getter(#context), + ), + ) as _i10.AnalysisContext); + @override + String get displayName => (super.noSuchMethod( + Invocation.getter(#displayName), + returnValue: '', + returnValueForMissingStub: '', + ) as String); + @override + bool get hasAlwaysThrows => (super.noSuchMethod( + Invocation.getter(#hasAlwaysThrows), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasDeprecated => (super.noSuchMethod( + Invocation.getter(#hasDeprecated), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasDoNotStore => (super.noSuchMethod( + Invocation.getter(#hasDoNotStore), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasFactory => (super.noSuchMethod( + Invocation.getter(#hasFactory), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasInternal => (super.noSuchMethod( + Invocation.getter(#hasInternal), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasIsTest => (super.noSuchMethod( + Invocation.getter(#hasIsTest), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasIsTestGroup => (super.noSuchMethod( + Invocation.getter(#hasIsTestGroup), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasJS => (super.noSuchMethod( + Invocation.getter(#hasJS), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasLiteral => (super.noSuchMethod( + Invocation.getter(#hasLiteral), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasMustBeOverridden => (super.noSuchMethod( + Invocation.getter(#hasMustBeOverridden), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasMustCallSuper => (super.noSuchMethod( + Invocation.getter(#hasMustCallSuper), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasNonVirtual => (super.noSuchMethod( + Invocation.getter(#hasNonVirtual), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasOptionalTypeArgs => (super.noSuchMethod( + Invocation.getter(#hasOptionalTypeArgs), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasOverride => (super.noSuchMethod( + Invocation.getter(#hasOverride), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasProtected => (super.noSuchMethod( + Invocation.getter(#hasProtected), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasReopen => (super.noSuchMethod( + Invocation.getter(#hasReopen), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasRequired => (super.noSuchMethod( + Invocation.getter(#hasRequired), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasSealed => (super.noSuchMethod( + Invocation.getter(#hasSealed), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasUseResult => (super.noSuchMethod( + Invocation.getter(#hasUseResult), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasVisibleForOverriding => (super.noSuchMethod( + Invocation.getter(#hasVisibleForOverriding), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasVisibleForTemplate => (super.noSuchMethod( + Invocation.getter(#hasVisibleForTemplate), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get hasVisibleForTesting => (super.noSuchMethod( + Invocation.getter(#hasVisibleForTesting), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + int get id => (super.noSuchMethod( + Invocation.getter(#id), + returnValue: 0, + returnValueForMissingStub: 0, + ) as int); + @override + bool get isPrivate => (super.noSuchMethod( + Invocation.getter(#isPrivate), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get isPublic => (super.noSuchMethod( + Invocation.getter(#isPublic), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool get isSynthetic => (super.noSuchMethod( + Invocation.getter(#isSynthetic), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + _i6.ElementKind get kind => (super.noSuchMethod( + Invocation.getter(#kind), + returnValue: _FakeElementKind_15( + this, + Invocation.getter(#kind), + ), + returnValueForMissingStub: _FakeElementKind_15( + this, + Invocation.getter(#kind), + ), + ) as _i6.ElementKind); + @override + List<_i6.ElementAnnotation> get metadata => (super.noSuchMethod( + Invocation.getter(#metadata), + returnValue: <_i6.ElementAnnotation>[], + returnValueForMissingStub: <_i6.ElementAnnotation>[], + ) as List<_i6.ElementAnnotation>); + @override + int get nameLength => (super.noSuchMethod( + Invocation.getter(#nameLength), + returnValue: 0, + returnValueForMissingStub: 0, + ) as int); + @override + int get nameOffset => (super.noSuchMethod( + Invocation.getter(#nameOffset), + returnValue: 0, + returnValueForMissingStub: 0, + ) as int); + @override + _i6.Element get nonSynthetic => (super.noSuchMethod( + Invocation.getter(#nonSynthetic), + returnValue: _FakeElement_13( + this, + Invocation.getter(#nonSynthetic), + ), + returnValueForMissingStub: _FakeElement_13( + this, + Invocation.getter(#nonSynthetic), + ), + ) as _i6.Element); + @override + List<_i4.InterfaceType> get allSupertypes => (super.noSuchMethod( + Invocation.getter(#allSupertypes), + returnValue: <_i4.InterfaceType>[], + returnValueForMissingStub: <_i4.InterfaceType>[], + ) as List<_i4.InterfaceType>); + @override + _i4.InterfaceType get thisType => (super.noSuchMethod( + Invocation.getter(#thisType), + returnValue: _FakeInterfaceType_20( + this, + Invocation.getter(#thisType), + ), + returnValueForMissingStub: _FakeInterfaceType_20( + this, + Invocation.getter(#thisType), + ), + ) as _i4.InterfaceType); + @override + bool isExtendableIn(_i6.LibraryElement? library) => (super.noSuchMethod( + Invocation.method( + #isExtendableIn, + [library], + ), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool isImplementableIn(_i6.LibraryElement? library) => (super.noSuchMethod( + Invocation.method( + #isImplementableIn, + [library], + ), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool isMixableIn(_i6.LibraryElement? library) => (super.noSuchMethod( + Invocation.method( + #isMixableIn, + [library], + ), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + T? accept(_i6.ElementVisitor? visitor) => (super.noSuchMethod( + Invocation.method( + #accept, + [visitor], + ), + returnValueForMissingStub: null, + ) as T?); + @override + String getDisplayString({ + required bool? withNullability, + bool? multiline = false, + }) => + (super.noSuchMethod( + Invocation.method( + #getDisplayString, + [], + { + #withNullability: withNullability, + #multiline: multiline, + }, + ), + returnValue: '', + returnValueForMissingStub: '', + ) as String); + @override + String getExtendedDisplayName(String? shortName) => (super.noSuchMethod( + Invocation.method( + #getExtendedDisplayName, + [shortName], + ), + returnValue: '', + returnValueForMissingStub: '', + ) as String); + @override + bool isAccessibleIn(_i6.LibraryElement? library) => (super.noSuchMethod( + Invocation.method( + #isAccessibleIn, + [library], + ), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + bool isAccessibleIn2(_i6.LibraryElement? library) => (super.noSuchMethod( + Invocation.method( + #isAccessibleIn2, + [library], + ), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); + @override + E? thisOrAncestorMatching( + bool Function(_i6.Element)? predicate) => + (super.noSuchMethod( + Invocation.method( + #thisOrAncestorMatching, + [predicate], + ), + returnValueForMissingStub: null, + ) as E?); + @override + void visitChildren(_i6.ElementVisitor? visitor) => + super.noSuchMethod( + Invocation.method( + #visitChildren, + [visitor], + ), + returnValueForMissingStub: null, + ); + @override + _i6.FieldElement? getField(String? name) => (super.noSuchMethod( + Invocation.method( + #getField, + [name], + ), + returnValueForMissingStub: null, + ) as _i6.FieldElement?); + @override + _i6.PropertyAccessorElement? getGetter(String? name) => (super.noSuchMethod( + Invocation.method( + #getGetter, + [name], + ), + returnValueForMissingStub: null, + ) as _i6.PropertyAccessorElement?); + @override + _i6.MethodElement? getMethod(String? name) => (super.noSuchMethod( + Invocation.method( + #getMethod, + [name], + ), + returnValueForMissingStub: null, + ) as _i6.MethodElement?); + @override + _i6.ConstructorElement? getNamedConstructor(String? name) => + (super.noSuchMethod( + Invocation.method( + #getNamedConstructor, + [name], + ), + returnValueForMissingStub: null, + ) as _i6.ConstructorElement?); + @override + _i6.PropertyAccessorElement? getSetter(String? name) => (super.noSuchMethod( + Invocation.method( + #getSetter, + [name], + ), + returnValueForMissingStub: null, + ) as _i6.PropertyAccessorElement?); + @override + _i4.InterfaceType instantiate({ + required List<_i4.DartType>? typeArguments, + required _i19.NullabilitySuffix? nullabilitySuffix, + }) => + (super.noSuchMethod( + Invocation.method( + #instantiate, + [], + { + #typeArguments: typeArguments, + #nullabilitySuffix: nullabilitySuffix, + }, + ), + returnValue: _FakeInterfaceType_20( + this, + Invocation.method( + #instantiate, + [], + { + #typeArguments: typeArguments, + #nullabilitySuffix: nullabilitySuffix, + }, + ), + ), + returnValueForMissingStub: _FakeInterfaceType_20( + this, + Invocation.method( + #instantiate, + [], + { + #typeArguments: typeArguments, + #nullabilitySuffix: nullabilitySuffix, + }, + ), + ), + ) as _i4.InterfaceType); + @override + _i6.MethodElement? lookUpConcreteMethod( + String? methodName, + _i6.LibraryElement? library, + ) => + (super.noSuchMethod( + Invocation.method( + #lookUpConcreteMethod, + [ + methodName, + library, + ], + ), + returnValueForMissingStub: null, + ) as _i6.MethodElement?); + @override + _i6.PropertyAccessorElement? lookUpGetter( + String? getterName, + _i6.LibraryElement? library, + ) => + (super.noSuchMethod( + Invocation.method( + #lookUpGetter, + [ + getterName, + library, + ], + ), + returnValueForMissingStub: null, + ) as _i6.PropertyAccessorElement?); + @override + _i6.PropertyAccessorElement? lookUpInheritedConcreteGetter( + String? getterName, + _i6.LibraryElement? library, + ) => + (super.noSuchMethod( + Invocation.method( + #lookUpInheritedConcreteGetter, + [ + getterName, + library, + ], + ), + returnValueForMissingStub: null, + ) as _i6.PropertyAccessorElement?); + @override + _i6.MethodElement? lookUpInheritedConcreteMethod( + String? methodName, + _i6.LibraryElement? library, + ) => + (super.noSuchMethod( + Invocation.method( + #lookUpInheritedConcreteMethod, + [ + methodName, + library, + ], + ), + returnValueForMissingStub: null, + ) as _i6.MethodElement?); + @override + _i6.PropertyAccessorElement? lookUpInheritedConcreteSetter( + String? setterName, + _i6.LibraryElement? library, + ) => + (super.noSuchMethod( + Invocation.method( + #lookUpInheritedConcreteSetter, + [ + setterName, + library, + ], + ), + returnValueForMissingStub: null, + ) as _i6.PropertyAccessorElement?); + @override + _i6.MethodElement? lookUpInheritedMethod( + String? methodName, + _i6.LibraryElement? library, + ) => + (super.noSuchMethod( + Invocation.method( + #lookUpInheritedMethod, + [ + methodName, + library, + ], + ), + returnValueForMissingStub: null, + ) as _i6.MethodElement?); + @override + _i6.MethodElement? lookUpMethod( + String? methodName, + _i6.LibraryElement? library, + ) => + (super.noSuchMethod( + Invocation.method( + #lookUpMethod, + [ + methodName, + library, + ], + ), + returnValueForMissingStub: null, + ) as _i6.MethodElement?); + @override + _i6.PropertyAccessorElement? lookUpSetter( + String? setterName, + _i6.LibraryElement? library, + ) => + (super.noSuchMethod( + Invocation.method( + #lookUpSetter, + [ + setterName, + library, + ], + ), + returnValueForMissingStub: null, + ) as _i6.PropertyAccessorElement?); +} + +/// A class which mocks [Process]. +/// +/// See the documentation for Mockito's code generation for more information. +class MockProcess extends _i1.Mock implements _i12.Process { + @override + _i8.Future get exitCode => (super.noSuchMethod( + Invocation.getter(#exitCode), + returnValue: _i8.Future.value(0), + returnValueForMissingStub: _i8.Future.value(0), + ) as _i8.Future); + @override + _i8.Stream> get stdout => (super.noSuchMethod( + Invocation.getter(#stdout), + returnValue: _i8.Stream>.empty(), + returnValueForMissingStub: _i8.Stream>.empty(), + ) as _i8.Stream>); + @override + _i8.Stream> get stderr => (super.noSuchMethod( + Invocation.getter(#stderr), + returnValue: _i8.Stream>.empty(), + returnValueForMissingStub: _i8.Stream>.empty(), + ) as _i8.Stream>); + @override + _i12.IOSink get stdin => (super.noSuchMethod( + Invocation.getter(#stdin), + returnValue: _FakeIOSink_21( + this, + Invocation.getter(#stdin), + ), + returnValueForMissingStub: _FakeIOSink_21( + this, + Invocation.getter(#stdin), + ), + ) as _i12.IOSink); + @override + int get pid => (super.noSuchMethod( + Invocation.getter(#pid), + returnValue: 0, + returnValueForMissingStub: 0, + ) as int); + @override + bool kill([_i12.ProcessSignal? signal = _i12.ProcessSignal.sigterm]) => + (super.noSuchMethod( + Invocation.method( + #kill, + [signal], + ), + returnValue: false, + returnValueForMissingStub: false, + ) as bool); +} diff --git a/openapi-generator/test/specs/localstack/cache/machine.json b/openapi-generator/test/specs/localstack/cache/machine.json new file mode 100644 index 0000000..ad66b14 --- /dev/null +++ b/openapi-generator/test/specs/localstack/cache/machine.json @@ -0,0 +1 @@ +{"machine_id": "gen_e5a2b64d-fee"} \ No newline at end of file diff --git a/openapi-generator/test/specs/localstack/cache/server.test.pem b/openapi-generator/test/specs/localstack/cache/server.test.pem new file mode 100644 index 0000000..13cc7f6 --- /dev/null +++ b/openapi-generator/test/specs/localstack/cache/server.test.pem @@ -0,0 +1,125 @@ +-----BEGIN PRIVATE KEY----- +MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC265jVO5QVVLr3 +rrAcmEvitwLMzEu88nyejp8Z48A8HhL5HdXCnvVStOwzvO38J9hFieRFrqi1jaTg +04QXRCSvBG4Y4lRkXNFGwnmI+K+/U7Ol8ZZGxX3OokHmqUeiseDk/4WrWotCEuow +x0+ZMaGx//xXq2W5DhQweBqPq5/jbxl1/Q92tHnp8hYCrBZKlmclgEmSiXf8Y/hT +Ft3tA/7M3YaWMBG2jPN6U3FAFaCgiFWjhDzFpw08TuE8th47Inlbs6M8OdHlje13 +29CDj19KACT9VaD5ehCWXWQU4zcIvG/c2PLWaGirdkPPGDFh1RvU6oN5fti499Oa +uvLu3f5RAgMBAAECggEABKQ/0ZFcdZob0HMnVuJqcotQT+ATP+0rSl62HNMRqrTc +qGOga/raoMmkgL+XjmF4dHNGTppa/5hjiaz0Wh7Ji4NiQ9FicNWGHfSLXvVoiENY +eKqDtLIIOjkV0QOUpMU8vrLZMnrus7OFK82y8GE5CCpFvffEcgiwbHZvvhuNyBib +lvTziO3Vv5fJ99rD4/7wz/1d0Jcwb/7xozYfSStWeC6/RZMNMHOjCX4zHL0z1ry/ +Sgk5YZ1kkl9PCZGaiA7aQ/eH5rpxVpuM6aIsvNwdaFr4E12onMiog2ldOEtFbZVG +WQTWsILjVj8MK9fI1aHZMMGcfXaCuy8+3p+KhMhRzQKBgQDsvzwfeBUgjQ77M37A +lRdTZHspeaxjKQMr1vOKXOawxzr7JIQ01X0bgHC/wsS5lX259/9giBnadU+/HjuY +vxZXrrvtmdOFwShe3QypXgaft3wCLan4Df/9N7wRvYyCSJSBhvc0tSdX46u63rdx +k9VgYE73SAkjpq1riijxFvjwmwKBgQDFy8KOG6jxY2x8Tq3prkmJOEuBZJnOSxVs +3XbWrH9D75afGULCUwDWG96ZBc+otQ2uyrCDwCBVwe9eU/NZDGH6wcfa2P6vu5Tj +28ICz9Aie4V0gEdy+SK/J4n6zXzs9e0jF1qhIrRjlCma0A6/5PwQpPmQ9DEsuoyX +f380cHkNgwKBgQCj5EtB2cZ+b0hUvDReK5gnQeNFNhcR2l14puiX+3I0JOf+3iur +y7M9K7Bh//piI0wTRsyCzhVft2CKhOpq9rYH403z0U6uRKam7U4LnazmOoZdl7EX +qNFzQXcvrNGti4NLG9zcnx/qZxEGX5IMzXOksWdZJoQ1KvjY/p8TL30MSwKBgAdO +iKhhQzNvndFVwrzwME0+ZCOqiLgDNA5qe/pgMu9aiXDlKP8uu8gtDWMPwOUVkyTS +3gRv84HXgTU12rZ+a5wszmo6O+ZYAp8MPjWGYcT0VTDBkGIh6/OtzT4TmzrRtunl +8fYj5xAKqCLM7s6N8fXXclS1gJ+LYKg0EInqYb5rAoGANrkOuxR9EuQJSyxPqYxI +ZujvPlBFZP0YdNkEBsgBRczee0w8W8HE9Ry4bm/r7A0ZGXEffqAEN9fqbtTpCgoN +PUGUMeyF3b9AMysrMf5gV+8VMvTcdxGrcwGile335p8dUJv7HzkCKWwZ8DBdQNvJ +fwFn4LJthOKDPZ7G9OTYAwc= +-----END PRIVATE KEY----- +-----BEGIN CERTIFICATE----- +MIIGWTCCBUGgAwIBAgISA8x1EBwVQKws8CsVwKOtHxMTMA0GCSqGSIb3DQEBCwUA +MDIxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1MZXQncyBFbmNyeXB0MQswCQYDVQQD +EwJSMzAeFw0yMzA2MjQyMDA2MjBaFw0yMzA5MjIyMDA2MTlaMCUxIzAhBgNVBAMT +GmxvY2FsaG9zdC5sb2NhbHN0YWNrLmNsb3VkMIIBIjANBgkqhkiG9w0BAQEFAAOC +AQ8AMIIBCgKCAQEAtuuY1TuUFVS6966wHJhL4rcCzMxLvPJ8no6fGePAPB4S+R3V +wp71UrTsM7zt/CfYRYnkRa6otY2k4NOEF0QkrwRuGOJUZFzRRsJ5iPivv1OzpfGW +RsV9zqJB5qlHorHg5P+Fq1qLQhLqMMdPmTGhsf/8V6tluQ4UMHgaj6uf428Zdf0P +drR56fIWAqwWSpZnJYBJkol3/GP4Uxbd7QP+zN2GljARtozzelNxQBWgoIhVo4Q8 +xacNPE7hPLYeOyJ5W7OjPDnR5Y3td9vQg49fSgAk/VWg+XoQll1kFOM3CLxv3Njy +1mhoq3ZDzxgxYdUb1OqDeX7YuPfTmrry7t3+UQIDAQABo4IDdDCCA3AwDgYDVR0P +AQH/BAQDAgWgMB0GA1UdJQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjAMBgNVHRMB +Af8EAjAAMB0GA1UdDgQWBBQjA13j9gxM4TMdtc2Y9vFynWsE+zAfBgNVHSMEGDAW +gBQULrMXt1hWy65QCUDmH6+dixTCxjBVBggrBgEFBQcBAQRJMEcwIQYIKwYBBQUH +MAGGFWh0dHA6Ly9yMy5vLmxlbmNyLm9yZzAiBggrBgEFBQcwAoYWaHR0cDovL3Iz +LmkubGVuY3Iub3JnLzCCAXoGA1UdEQSCAXEwggFtgicqLmFtcGxpZnlhcHAubG9j +YWxob3N0LmxvY2Fsc3RhY2suY2xvdWSCJyouY2xvdWRmcm9udC5sb2NhbGhvc3Qu +bG9jYWxzdGFjay5jbG91ZIIgKi5lbGIubG9jYWxob3N0LmxvY2Fsc3RhY2suY2xv +dWSCKCouZXhlY3V0ZS1hcGkubG9jYWxob3N0LmxvY2Fsc3RhY2suY2xvdWSCHCou +bG9jYWxob3N0LmxvY2Fsc3RhY2suY2xvdWSCJyoub3BlbnNlYXJjaC5sb2NhbGhv +c3QubG9jYWxzdGFjay5jbG91ZIInKi5zMy13ZWJzaXRlLmxvY2FsaG9zdC5sb2Nh +bHN0YWNrLmNsb3Vkgh8qLnMzLmxvY2FsaG9zdC5sb2NhbHN0YWNrLmNsb3VkgiAq +LnNjbS5sb2NhbGhvc3QubG9jYWxzdGFjay5jbG91ZIIabG9jYWxob3N0LmxvY2Fs +c3RhY2suY2xvdWQwEwYDVR0gBAwwCjAIBgZngQwBAgEwggEFBgorBgEEAdZ5AgQC +BIH2BIHzAPEAdgB6MoxU2LcttiDqOOBSHumEFnAyE4VNO9IrwTpXo1LrUgAAAYjv +Oq1ZAAAEAwBHMEUCIQDeLLchWTLThBy15PH72K1CeUPDHLuGCFO8CCJFVh392AIg +Ryz+nmoNYlQcy6MBUQBCgYVciCnrFPnbL8qNWc3J2okAdwDoPtDaPvUGNTLnVyi8 +iWvJA9PL0RFr7Otp4Xd9bQa9bgAAAYjvOq1PAAAEAwBIMEYCIQCJS5m5Dz6gGGPP +o9Zvbw6sGrT0K/umxPCnrPfpU3MBMgIhAIohiRpxIv2SRyLzUXQr1ani1dCklTpl +C6IU2wE0YQpUMA0GCSqGSIb3DQEBCwUAA4IBAQC429PPt82YPxbChUViGeAtOPdS +vol/VrRChQwWs+nai+puPXuuPIefvSRqo8eO6kOmSgwn3KkQtfbz3cLILk7WGCC9 +YsoE2tRPWmJtGqxUIY4YN3ESb+zx81Y+1Bst497Yw2H0J5FFFjdc0tmUFqWbaiNx +Gx1v/lZVt/92wzBp9EscokIMoOxFdTT0IPF8yF6UM7Ed4u0B4XZCFnaWbcKmWLPy +QHrZq8OBkdXJgWEYgOkwtxlq3WUbhxqz8gCWC4JuSfzSoj5w4etzrNBmkGJ5TtHi +0PzSe5L3kKsqu86UmDUDfQ0ugzumbusFpC2Ev62ETFKyW70pnj0IW/OZEdYM +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFFjCCAv6gAwIBAgIRAJErCErPDBinU/bWLiWnX1owDQYJKoZIhvcNAQELBQAw +TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh +cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMjAwOTA0MDAwMDAw +WhcNMjUwOTE1MTYwMDAwWjAyMQswCQYDVQQGEwJVUzEWMBQGA1UEChMNTGV0J3Mg +RW5jcnlwdDELMAkGA1UEAxMCUjMwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK +AoIBAQC7AhUozPaglNMPEuyNVZLD+ILxmaZ6QoinXSaqtSu5xUyxr45r+XXIo9cP +R5QUVTVXjJ6oojkZ9YI8QqlObvU7wy7bjcCwXPNZOOftz2nwWgsbvsCUJCWH+jdx +sxPnHKzhm+/b5DtFUkWWqcFTzjTIUu61ru2P3mBw4qVUq7ZtDpelQDRrK9O8Zutm +NHz6a4uPVymZ+DAXXbpyb/uBxa3Shlg9F8fnCbvxK/eG3MHacV3URuPMrSXBiLxg +Z3Vms/EY96Jc5lP/Ooi2R6X/ExjqmAl3P51T+c8B5fWmcBcUr2Ok/5mzk53cU6cG +/kiFHaFpriV1uxPMUgP17VGhi9sVAgMBAAGjggEIMIIBBDAOBgNVHQ8BAf8EBAMC +AYYwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMBIGA1UdEwEB/wQIMAYB +Af8CAQAwHQYDVR0OBBYEFBQusxe3WFbLrlAJQOYfr52LFMLGMB8GA1UdIwQYMBaA +FHm0WeZ7tuXkAXOACIjIGlj26ZtuMDIGCCsGAQUFBwEBBCYwJDAiBggrBgEFBQcw +AoYWaHR0cDovL3gxLmkubGVuY3Iub3JnLzAnBgNVHR8EIDAeMBygGqAYhhZodHRw +Oi8veDEuYy5sZW5jci5vcmcvMCIGA1UdIAQbMBkwCAYGZ4EMAQIBMA0GCysGAQQB +gt8TAQEBMA0GCSqGSIb3DQEBCwUAA4ICAQCFyk5HPqP3hUSFvNVneLKYY611TR6W +PTNlclQtgaDqw+34IL9fzLdwALduO/ZelN7kIJ+m74uyA+eitRY8kc607TkC53wl +ikfmZW4/RvTZ8M6UK+5UzhK8jCdLuMGYL6KvzXGRSgi3yLgjewQtCPkIVz6D2QQz +CkcheAmCJ8MqyJu5zlzyZMjAvnnAT45tRAxekrsu94sQ4egdRCnbWSDtY7kh+BIm +lJNXoB1lBMEKIq4QDUOXoRgffuDghje1WrG9ML+Hbisq/yFOGwXD9RiX8F6sw6W4 +avAuvDszue5L3sz85K+EC4Y/wFVDNvZo4TYXao6Z0f+lQKc0t8DQYzk1OXVu8rp2 +yJMC6alLbBfODALZvYH7n7do1AZls4I9d1P4jnkDrQoxB3UqQ9hVl3LEKQ73xF1O +yK5GhDDX8oVfGKF5u+decIsH4YaTw7mP3GFxJSqv3+0lUFJoi5Lc5da149p90Ids +hCExroL1+7mryIkXPeFM5TgO9r0rvZaBFOvV2z0gp35Z0+L4WPlbuEjN/lxPFin+ +HlUjr8gRsI3qfJOQFy/9rKIJR0Y/8Omwt/8oTWgy1mdeHmmjk7j1nYsvC9JSQ6Zv +MldlTTKB3zhThV1+XWYp6rjd5JW1zbVWEkLNxE7GJThEUG3szgBVGP7pSWTUTsqX +nLRbwHOoq7hHwg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFYDCCBEigAwIBAgIQQAF3ITfU6UK47naqPGQKtzANBgkqhkiG9w0BAQsFADA/ +MSQwIgYDVQQKExtEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdCBDby4xFzAVBgNVBAMT +DkRTVCBSb290IENBIFgzMB4XDTIxMDEyMDE5MTQwM1oXDTI0MDkzMDE4MTQwM1ow +TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh +cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwggIiMA0GCSqGSIb3DQEB +AQUAA4ICDwAwggIKAoICAQCt6CRz9BQ385ueK1coHIe+3LffOJCMbjzmV6B493XC +ov71am72AE8o295ohmxEk7axY/0UEmu/H9LqMZshftEzPLpI9d1537O4/xLxIZpL +wYqGcWlKZmZsj348cL+tKSIG8+TA5oCu4kuPt5l+lAOf00eXfJlII1PoOK5PCm+D +LtFJV4yAdLbaL9A4jXsDcCEbdfIwPPqPrt3aY6vrFk/CjhFLfs8L6P+1dy70sntK +4EwSJQxwjQMpoOFTJOwT2e4ZvxCzSow/iaNhUd6shweU9GNx7C7ib1uYgeGJXDR5 +bHbvO5BieebbpJovJsXQEOEO3tkQjhb7t/eo98flAgeYjzYIlefiN5YNNnWe+w5y +sR2bvAP5SQXYgd0FtCrWQemsAXaVCg/Y39W9Eh81LygXbNKYwagJZHduRze6zqxZ +Xmidf3LWicUGQSk+WT7dJvUkyRGnWqNMQB9GoZm1pzpRboY7nn1ypxIFeFntPlF4 +FQsDj43QLwWyPntKHEtzBRL8xurgUBN8Q5N0s8p0544fAQjQMNRbcTa0B7rBMDBc +SLeCO5imfWCKoqMpgsy6vYMEG6KDA0Gh1gXxG8K28Kh8hjtGqEgqiNx2mna/H2ql +PRmP6zjzZN7IKw0KKP/32+IVQtQi0Cdd4Xn+GOdwiK1O5tmLOsbdJ1Fu/7xk9TND +TwIDAQABo4IBRjCCAUIwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYw +SwYIKwYBBQUHAQEEPzA9MDsGCCsGAQUFBzAChi9odHRwOi8vYXBwcy5pZGVudHJ1 +c3QuY29tL3Jvb3RzL2RzdHJvb3RjYXgzLnA3YzAfBgNVHSMEGDAWgBTEp7Gkeyxx ++tvhS5B1/8QVYIWJEDBUBgNVHSAETTBLMAgGBmeBDAECATA/BgsrBgEEAYLfEwEB +ATAwMC4GCCsGAQUFBwIBFiJodHRwOi8vY3BzLnJvb3QteDEubGV0c2VuY3J5cHQu +b3JnMDwGA1UdHwQ1MDMwMaAvoC2GK2h0dHA6Ly9jcmwuaWRlbnRydXN0LmNvbS9E +U1RST09UQ0FYM0NSTC5jcmwwHQYDVR0OBBYEFHm0WeZ7tuXkAXOACIjIGlj26Ztu +MA0GCSqGSIb3DQEBCwUAA4IBAQAKcwBslm7/DlLQrt2M51oGrS+o44+/yQoDFVDC +5WxCu2+b9LRPwkSICHXM6webFGJueN7sJ7o5XPWioW5WlHAQU7G75K/QosMrAdSW +9MUgNTP52GE24HGNtLi1qoJFlcDyqSMo59ahy2cI2qBDLKobkx/J3vWraV0T9VuG +WCLKTVXkcGdtwlfFRjlBz4pYg1htmf5X6DYO8A4jqv2Il9DjXA6USbW1FzXSLr9O +he8Y4IWS6wY7bCkjCWDcRQJMEhg76fsO3txE+FiYruq9RUWhiF1myv4Q6W+CyBFC +Dfvp7OOGAN6dEOM4+qR9sdjoSYKEBpsr6GtPAQw4dy753ec5 +-----END CERTIFICATE----- diff --git a/openapi-generator/test/specs/localstack/cache/server.test.pem.crt b/openapi-generator/test/specs/localstack/cache/server.test.pem.crt new file mode 100644 index 0000000..0b95895 --- /dev/null +++ b/openapi-generator/test/specs/localstack/cache/server.test.pem.crt @@ -0,0 +1,97 @@ +-----BEGIN CERTIFICATE----- +MIIGWTCCBUGgAwIBAgISA8x1EBwVQKws8CsVwKOtHxMTMA0GCSqGSIb3DQEBCwUA +MDIxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1MZXQncyBFbmNyeXB0MQswCQYDVQQD +EwJSMzAeFw0yMzA2MjQyMDA2MjBaFw0yMzA5MjIyMDA2MTlaMCUxIzAhBgNVBAMT +GmxvY2FsaG9zdC5sb2NhbHN0YWNrLmNsb3VkMIIBIjANBgkqhkiG9w0BAQEFAAOC +AQ8AMIIBCgKCAQEAtuuY1TuUFVS6966wHJhL4rcCzMxLvPJ8no6fGePAPB4S+R3V +wp71UrTsM7zt/CfYRYnkRa6otY2k4NOEF0QkrwRuGOJUZFzRRsJ5iPivv1OzpfGW +RsV9zqJB5qlHorHg5P+Fq1qLQhLqMMdPmTGhsf/8V6tluQ4UMHgaj6uf428Zdf0P +drR56fIWAqwWSpZnJYBJkol3/GP4Uxbd7QP+zN2GljARtozzelNxQBWgoIhVo4Q8 +xacNPE7hPLYeOyJ5W7OjPDnR5Y3td9vQg49fSgAk/VWg+XoQll1kFOM3CLxv3Njy +1mhoq3ZDzxgxYdUb1OqDeX7YuPfTmrry7t3+UQIDAQABo4IDdDCCA3AwDgYDVR0P +AQH/BAQDAgWgMB0GA1UdJQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjAMBgNVHRMB +Af8EAjAAMB0GA1UdDgQWBBQjA13j9gxM4TMdtc2Y9vFynWsE+zAfBgNVHSMEGDAW +gBQULrMXt1hWy65QCUDmH6+dixTCxjBVBggrBgEFBQcBAQRJMEcwIQYIKwYBBQUH +MAGGFWh0dHA6Ly9yMy5vLmxlbmNyLm9yZzAiBggrBgEFBQcwAoYWaHR0cDovL3Iz +LmkubGVuY3Iub3JnLzCCAXoGA1UdEQSCAXEwggFtgicqLmFtcGxpZnlhcHAubG9j +YWxob3N0LmxvY2Fsc3RhY2suY2xvdWSCJyouY2xvdWRmcm9udC5sb2NhbGhvc3Qu +bG9jYWxzdGFjay5jbG91ZIIgKi5lbGIubG9jYWxob3N0LmxvY2Fsc3RhY2suY2xv +dWSCKCouZXhlY3V0ZS1hcGkubG9jYWxob3N0LmxvY2Fsc3RhY2suY2xvdWSCHCou +bG9jYWxob3N0LmxvY2Fsc3RhY2suY2xvdWSCJyoub3BlbnNlYXJjaC5sb2NhbGhv +c3QubG9jYWxzdGFjay5jbG91ZIInKi5zMy13ZWJzaXRlLmxvY2FsaG9zdC5sb2Nh +bHN0YWNrLmNsb3Vkgh8qLnMzLmxvY2FsaG9zdC5sb2NhbHN0YWNrLmNsb3VkgiAq +LnNjbS5sb2NhbGhvc3QubG9jYWxzdGFjay5jbG91ZIIabG9jYWxob3N0LmxvY2Fs +c3RhY2suY2xvdWQwEwYDVR0gBAwwCjAIBgZngQwBAgEwggEFBgorBgEEAdZ5AgQC +BIH2BIHzAPEAdgB6MoxU2LcttiDqOOBSHumEFnAyE4VNO9IrwTpXo1LrUgAAAYjv +Oq1ZAAAEAwBHMEUCIQDeLLchWTLThBy15PH72K1CeUPDHLuGCFO8CCJFVh392AIg +Ryz+nmoNYlQcy6MBUQBCgYVciCnrFPnbL8qNWc3J2okAdwDoPtDaPvUGNTLnVyi8 +iWvJA9PL0RFr7Otp4Xd9bQa9bgAAAYjvOq1PAAAEAwBIMEYCIQCJS5m5Dz6gGGPP +o9Zvbw6sGrT0K/umxPCnrPfpU3MBMgIhAIohiRpxIv2SRyLzUXQr1ani1dCklTpl +C6IU2wE0YQpUMA0GCSqGSIb3DQEBCwUAA4IBAQC429PPt82YPxbChUViGeAtOPdS +vol/VrRChQwWs+nai+puPXuuPIefvSRqo8eO6kOmSgwn3KkQtfbz3cLILk7WGCC9 +YsoE2tRPWmJtGqxUIY4YN3ESb+zx81Y+1Bst497Yw2H0J5FFFjdc0tmUFqWbaiNx +Gx1v/lZVt/92wzBp9EscokIMoOxFdTT0IPF8yF6UM7Ed4u0B4XZCFnaWbcKmWLPy +QHrZq8OBkdXJgWEYgOkwtxlq3WUbhxqz8gCWC4JuSfzSoj5w4etzrNBmkGJ5TtHi +0PzSe5L3kKsqu86UmDUDfQ0ugzumbusFpC2Ev62ETFKyW70pnj0IW/OZEdYM +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFFjCCAv6gAwIBAgIRAJErCErPDBinU/bWLiWnX1owDQYJKoZIhvcNAQELBQAw +TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh +cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMjAwOTA0MDAwMDAw +WhcNMjUwOTE1MTYwMDAwWjAyMQswCQYDVQQGEwJVUzEWMBQGA1UEChMNTGV0J3Mg +RW5jcnlwdDELMAkGA1UEAxMCUjMwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK +AoIBAQC7AhUozPaglNMPEuyNVZLD+ILxmaZ6QoinXSaqtSu5xUyxr45r+XXIo9cP +R5QUVTVXjJ6oojkZ9YI8QqlObvU7wy7bjcCwXPNZOOftz2nwWgsbvsCUJCWH+jdx +sxPnHKzhm+/b5DtFUkWWqcFTzjTIUu61ru2P3mBw4qVUq7ZtDpelQDRrK9O8Zutm +NHz6a4uPVymZ+DAXXbpyb/uBxa3Shlg9F8fnCbvxK/eG3MHacV3URuPMrSXBiLxg +Z3Vms/EY96Jc5lP/Ooi2R6X/ExjqmAl3P51T+c8B5fWmcBcUr2Ok/5mzk53cU6cG +/kiFHaFpriV1uxPMUgP17VGhi9sVAgMBAAGjggEIMIIBBDAOBgNVHQ8BAf8EBAMC +AYYwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMBIGA1UdEwEB/wQIMAYB +Af8CAQAwHQYDVR0OBBYEFBQusxe3WFbLrlAJQOYfr52LFMLGMB8GA1UdIwQYMBaA +FHm0WeZ7tuXkAXOACIjIGlj26ZtuMDIGCCsGAQUFBwEBBCYwJDAiBggrBgEFBQcw +AoYWaHR0cDovL3gxLmkubGVuY3Iub3JnLzAnBgNVHR8EIDAeMBygGqAYhhZodHRw +Oi8veDEuYy5sZW5jci5vcmcvMCIGA1UdIAQbMBkwCAYGZ4EMAQIBMA0GCysGAQQB +gt8TAQEBMA0GCSqGSIb3DQEBCwUAA4ICAQCFyk5HPqP3hUSFvNVneLKYY611TR6W +PTNlclQtgaDqw+34IL9fzLdwALduO/ZelN7kIJ+m74uyA+eitRY8kc607TkC53wl +ikfmZW4/RvTZ8M6UK+5UzhK8jCdLuMGYL6KvzXGRSgi3yLgjewQtCPkIVz6D2QQz +CkcheAmCJ8MqyJu5zlzyZMjAvnnAT45tRAxekrsu94sQ4egdRCnbWSDtY7kh+BIm +lJNXoB1lBMEKIq4QDUOXoRgffuDghje1WrG9ML+Hbisq/yFOGwXD9RiX8F6sw6W4 +avAuvDszue5L3sz85K+EC4Y/wFVDNvZo4TYXao6Z0f+lQKc0t8DQYzk1OXVu8rp2 +yJMC6alLbBfODALZvYH7n7do1AZls4I9d1P4jnkDrQoxB3UqQ9hVl3LEKQ73xF1O +yK5GhDDX8oVfGKF5u+decIsH4YaTw7mP3GFxJSqv3+0lUFJoi5Lc5da149p90Ids +hCExroL1+7mryIkXPeFM5TgO9r0rvZaBFOvV2z0gp35Z0+L4WPlbuEjN/lxPFin+ +HlUjr8gRsI3qfJOQFy/9rKIJR0Y/8Omwt/8oTWgy1mdeHmmjk7j1nYsvC9JSQ6Zv +MldlTTKB3zhThV1+XWYp6rjd5JW1zbVWEkLNxE7GJThEUG3szgBVGP7pSWTUTsqX +nLRbwHOoq7hHwg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFYDCCBEigAwIBAgIQQAF3ITfU6UK47naqPGQKtzANBgkqhkiG9w0BAQsFADA/ +MSQwIgYDVQQKExtEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdCBDby4xFzAVBgNVBAMT +DkRTVCBSb290IENBIFgzMB4XDTIxMDEyMDE5MTQwM1oXDTI0MDkzMDE4MTQwM1ow +TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh +cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwggIiMA0GCSqGSIb3DQEB +AQUAA4ICDwAwggIKAoICAQCt6CRz9BQ385ueK1coHIe+3LffOJCMbjzmV6B493XC +ov71am72AE8o295ohmxEk7axY/0UEmu/H9LqMZshftEzPLpI9d1537O4/xLxIZpL +wYqGcWlKZmZsj348cL+tKSIG8+TA5oCu4kuPt5l+lAOf00eXfJlII1PoOK5PCm+D +LtFJV4yAdLbaL9A4jXsDcCEbdfIwPPqPrt3aY6vrFk/CjhFLfs8L6P+1dy70sntK +4EwSJQxwjQMpoOFTJOwT2e4ZvxCzSow/iaNhUd6shweU9GNx7C7ib1uYgeGJXDR5 +bHbvO5BieebbpJovJsXQEOEO3tkQjhb7t/eo98flAgeYjzYIlefiN5YNNnWe+w5y +sR2bvAP5SQXYgd0FtCrWQemsAXaVCg/Y39W9Eh81LygXbNKYwagJZHduRze6zqxZ +Xmidf3LWicUGQSk+WT7dJvUkyRGnWqNMQB9GoZm1pzpRboY7nn1ypxIFeFntPlF4 +FQsDj43QLwWyPntKHEtzBRL8xurgUBN8Q5N0s8p0544fAQjQMNRbcTa0B7rBMDBc +SLeCO5imfWCKoqMpgsy6vYMEG6KDA0Gh1gXxG8K28Kh8hjtGqEgqiNx2mna/H2ql +PRmP6zjzZN7IKw0KKP/32+IVQtQi0Cdd4Xn+GOdwiK1O5tmLOsbdJ1Fu/7xk9TND +TwIDAQABo4IBRjCCAUIwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYw +SwYIKwYBBQUHAQEEPzA9MDsGCCsGAQUFBzAChi9odHRwOi8vYXBwcy5pZGVudHJ1 +c3QuY29tL3Jvb3RzL2RzdHJvb3RjYXgzLnA3YzAfBgNVHSMEGDAWgBTEp7Gkeyxx ++tvhS5B1/8QVYIWJEDBUBgNVHSAETTBLMAgGBmeBDAECATA/BgsrBgEEAYLfEwEB +ATAwMC4GCCsGAQUFBwIBFiJodHRwOi8vY3BzLnJvb3QteDEubGV0c2VuY3J5cHQu +b3JnMDwGA1UdHwQ1MDMwMaAvoC2GK2h0dHA6Ly9jcmwuaWRlbnRydXN0LmNvbS9E +U1RST09UQ0FYM0NSTC5jcmwwHQYDVR0OBBYEFHm0WeZ7tuXkAXOACIjIGlj26Ztu +MA0GCSqGSIb3DQEBCwUAA4IBAQAKcwBslm7/DlLQrt2M51oGrS+o44+/yQoDFVDC +5WxCu2+b9LRPwkSICHXM6webFGJueN7sJ7o5XPWioW5WlHAQU7G75K/QosMrAdSW +9MUgNTP52GE24HGNtLi1qoJFlcDyqSMo59ahy2cI2qBDLKobkx/J3vWraV0T9VuG +WCLKTVXkcGdtwlfFRjlBz4pYg1htmf5X6DYO8A4jqv2Il9DjXA6USbW1FzXSLr9O +he8Y4IWS6wY7bCkjCWDcRQJMEhg76fsO3txE+FiYruq9RUWhiF1myv4Q6W+CyBFC +Dfvp7OOGAN6dEOM4+qR9sdjoSYKEBpsr6GtPAQw4dy753ec5 +-----END CERTIFICATE----- \ No newline at end of file diff --git a/openapi-generator/test/specs/localstack/cache/server.test.pem.key b/openapi-generator/test/specs/localstack/cache/server.test.pem.key new file mode 100644 index 0000000..4ee21ea --- /dev/null +++ b/openapi-generator/test/specs/localstack/cache/server.test.pem.key @@ -0,0 +1,28 @@ +-----BEGIN PRIVATE KEY----- +MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC265jVO5QVVLr3 +rrAcmEvitwLMzEu88nyejp8Z48A8HhL5HdXCnvVStOwzvO38J9hFieRFrqi1jaTg +04QXRCSvBG4Y4lRkXNFGwnmI+K+/U7Ol8ZZGxX3OokHmqUeiseDk/4WrWotCEuow +x0+ZMaGx//xXq2W5DhQweBqPq5/jbxl1/Q92tHnp8hYCrBZKlmclgEmSiXf8Y/hT +Ft3tA/7M3YaWMBG2jPN6U3FAFaCgiFWjhDzFpw08TuE8th47Inlbs6M8OdHlje13 +29CDj19KACT9VaD5ehCWXWQU4zcIvG/c2PLWaGirdkPPGDFh1RvU6oN5fti499Oa +uvLu3f5RAgMBAAECggEABKQ/0ZFcdZob0HMnVuJqcotQT+ATP+0rSl62HNMRqrTc +qGOga/raoMmkgL+XjmF4dHNGTppa/5hjiaz0Wh7Ji4NiQ9FicNWGHfSLXvVoiENY +eKqDtLIIOjkV0QOUpMU8vrLZMnrus7OFK82y8GE5CCpFvffEcgiwbHZvvhuNyBib +lvTziO3Vv5fJ99rD4/7wz/1d0Jcwb/7xozYfSStWeC6/RZMNMHOjCX4zHL0z1ry/ +Sgk5YZ1kkl9PCZGaiA7aQ/eH5rpxVpuM6aIsvNwdaFr4E12onMiog2ldOEtFbZVG +WQTWsILjVj8MK9fI1aHZMMGcfXaCuy8+3p+KhMhRzQKBgQDsvzwfeBUgjQ77M37A +lRdTZHspeaxjKQMr1vOKXOawxzr7JIQ01X0bgHC/wsS5lX259/9giBnadU+/HjuY +vxZXrrvtmdOFwShe3QypXgaft3wCLan4Df/9N7wRvYyCSJSBhvc0tSdX46u63rdx +k9VgYE73SAkjpq1riijxFvjwmwKBgQDFy8KOG6jxY2x8Tq3prkmJOEuBZJnOSxVs +3XbWrH9D75afGULCUwDWG96ZBc+otQ2uyrCDwCBVwe9eU/NZDGH6wcfa2P6vu5Tj +28ICz9Aie4V0gEdy+SK/J4n6zXzs9e0jF1qhIrRjlCma0A6/5PwQpPmQ9DEsuoyX +f380cHkNgwKBgQCj5EtB2cZ+b0hUvDReK5gnQeNFNhcR2l14puiX+3I0JOf+3iur +y7M9K7Bh//piI0wTRsyCzhVft2CKhOpq9rYH403z0U6uRKam7U4LnazmOoZdl7EX +qNFzQXcvrNGti4NLG9zcnx/qZxEGX5IMzXOksWdZJoQ1KvjY/p8TL30MSwKBgAdO +iKhhQzNvndFVwrzwME0+ZCOqiLgDNA5qe/pgMu9aiXDlKP8uu8gtDWMPwOUVkyTS +3gRv84HXgTU12rZ+a5wszmo6O+ZYAp8MPjWGYcT0VTDBkGIh6/OtzT4TmzrRtunl +8fYj5xAKqCLM7s6N8fXXclS1gJ+LYKg0EInqYb5rAoGANrkOuxR9EuQJSyxPqYxI +ZujvPlBFZP0YdNkEBsgBRczee0w8W8HE9Ry4bm/r7A0ZGXEffqAEN9fqbtTpCgoN +PUGUMeyF3b9AMysrMf5gV+8VMvTcdxGrcwGile335p8dUJv7HzkCKWwZ8DBdQNvJ +fwFn4LJthOKDPZ7G9OTYAwc= +-----END PRIVATE KEY----- \ No newline at end of file diff --git a/openapi-generator/test/specs/localstack/cache/service-catalog-2_2_1_dev-1_31_28.pickle b/openapi-generator/test/specs/localstack/cache/service-catalog-2_2_1_dev-1_31_28.pickle new file mode 100644 index 0000000000000000000000000000000000000000..01177496a713b5c5bb2870c95892df74e47275eb GIT binary patch literal 352716 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%0D+1-7F81HP^S?TKd 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%0APHoZ> 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 literal 0 HcmV?d00001 From 5822666aad384444827ca6a5aa3028ac3317c443 Mon Sep 17 00:00:00 2001 From: Nexushunter Date: Sun, 3 Sep 2023 12:55:53 -0400 Subject: [PATCH 02/13] fix: add tests and ensure that the sub processes can be mocked out. --- .github/workflows/code_quality.yml | 3 + openapi-generator/lib/src/models/command.dart | 53 + .../lib/src/openapi_generator_runner.dart | 163 +-- openapi-generator/lib/src/utils.dart | 2 +- openapi-generator/test/builder_test.dart | 481 --------- openapi-generator/test/generator_test.dart | 937 +++++++++++++++++- openapi-generator/test/mocks.dart | 6 + ...next_gen_builder_flutterw_test_config.dart | 17 + .../next_gen_builder_fvm_test_config.dart | 19 + 9 files changed, 1112 insertions(+), 569 deletions(-) create mode 100644 openapi-generator/test/specs/next_gen_builder_flutterw_test_config.dart create mode 100644 openapi-generator/test/specs/next_gen_builder_fvm_test_config.dart diff --git a/.github/workflows/code_quality.yml b/.github/workflows/code_quality.yml index 7f165a3..686cc55 100644 --- a/.github/workflows/code_quality.yml +++ b/.github/workflows/code_quality.yml @@ -36,6 +36,9 @@ jobs: run: dart pub get - name: Validate formatting run: dart format ./ --set-exit-if-changed + - name: Generate Mocks + if: ${{ matrix.work_dir == 'openapi-generator' }} + run: dart run build_runner build --delete-conflicting-outputs - name: Run analyzer run: dart analyze --fatal-warnings - name: Run tests diff --git a/openapi-generator/lib/src/models/command.dart b/openapi-generator/lib/src/models/command.dart index 6e3e112..2f847e0 100644 --- a/openapi-generator/lib/src/models/command.dart +++ b/openapi-generator/lib/src/models/command.dart @@ -1,3 +1,7 @@ +import 'dart:io'; + +import 'package:openapi_generator/src/determine_flutter_project_status.dart'; +import 'package:openapi_generator/src/gen_on_spec_changes.dart'; import 'package:openapi_generator_annotations/openapi_generator_annotations.dart'; /// Creates a representation of a cli request for Flutter or Dart. @@ -29,3 +33,52 @@ class Command { arguments, ); } + +/// CommandRunner provides an abstraction layer to external functions / processes. +class CommandRunner { + const CommandRunner(); + + Future runCommand({ + required Command command, + required String workingDirectory, + }) async => + Process.run( + command.executable, + command.arguments, + workingDirectory: workingDirectory, + runInShell: Platform.isWindows, + ); + + Future> loadAnnotatedFile({required String path}) async { + final f = File(path); + return f.readAsLines(); + } + + Future writeAnnotatedFile( + {required String path, required List content}) async { + final f = File(path); + return f.writeAsStringSync(content.join('\n'), flush: true); + } + + Future cacheSpecFile({ + required Map updatedSpec, + required String cachedPath, + }) async => + cacheSpec(outputLocation: cachedPath, spec: updatedSpec); + + Future> loadSpecFile( + {required InputSpec specConfig, bool isCached = false}) async => + loadSpec(specConfig: specConfig); + + Future isSpecFileDirty({ + required Map cachedSpec, + required Map loadedSpec, + }) async => + isSpecDirty(cachedSpec: cachedSpec, loadedSpec: loadedSpec); + + Future checkForFlutterEnvironemt( + {Wrapper? wrapper = Wrapper.none, + String? providedPubspecPath}) async => + checkPubspecAndWrapperForFlutterSupport( + wrapper: wrapper, providedPubspecPath: providedPubspecPath); +} diff --git a/openapi-generator/lib/src/openapi_generator_runner.dart b/openapi-generator/lib/src/openapi_generator_runner.dart index 0db8126..5022740 100755 --- a/openapi-generator/lib/src/openapi_generator_runner.dart +++ b/openapi-generator/lib/src/openapi_generator_runner.dart @@ -7,7 +7,6 @@ import 'package:analyzer/dart/element/element.dart'; import 'package:build/build.dart'; import 'package:logging/logging.dart'; import 'package:openapi_generator/src/determine_flutter_project_status.dart'; -import 'package:openapi_generator/src/gen_on_spec_changes.dart'; import 'package:openapi_generator/src/models/output_message.dart'; import 'package:openapi_generator/src/utils.dart'; import 'package:openapi_generator_annotations/openapi_generator_annotations.dart' @@ -20,14 +19,24 @@ import 'models/generator_arguments.dart'; class OpenapiGenerator extends GeneratorForAnnotation { @Deprecated('To be removed in next major version') final bool testMode; - - OpenapiGenerator({this.testMode = false}); + final CommandRunner runner; + final Logger _log; + + OpenapiGenerator({ + this.testMode = false, + this.runner = const CommandRunner(), + Logger? log, + }) : _log = log ?? Logger('OpenApiGenerator') { + _log.onRecord.listen((event) { + print(event.toString()); + }); + } @override FutureOr generateForAnnotatedElement( Element element, ConstantReader annotations, BuildStep buildStep) async { logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: [ ':::::::::::::::::::::::::::::::::::::::::::', @@ -53,10 +62,16 @@ class OpenapiGenerator extends GeneratorForAnnotation { // Transform the annotations. final args = GeneratorArguments(annotations: annotations); // Determine if the project has a dependency on the flutter sdk or not. - final baseCommand = await checkPubspecAndWrapperForFlutterSupport( + final baseCommand = await runner.checkForFlutterEnvironemt( wrapper: args.wrapper, providedPubspecPath: args.pubspecPath) ? 'flutter' : 'dart'; + logOutputMessage( + log: _log, + communication: OutputMessage( + message: 'Using $baseCommand environemnt', + ), + ); if (args.useNextGen) { // If the flag to use the next generation of the generator is applied @@ -72,7 +87,7 @@ class OpenapiGenerator extends GeneratorForAnnotation { if (await File(path).exists()) { if (!args.alwaysRun) { logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: 'Generated client already exists at [$path] and configuration is annotated with alwaysRun: [${args.alwaysRun}]. Therefore, skipping this build. Note that the "alwaysRun" config will be removed in future versions.', @@ -99,7 +114,7 @@ class OpenapiGenerator extends GeneratorForAnnotation { communication = e; } - logOutputMessage(log: log, communication: communication); + logOutputMessage(log: _log, communication: communication); } return ''; } @@ -109,7 +124,7 @@ class OpenapiGenerator extends GeneratorForAnnotation { Future runOpenApiJar({required GeneratorArguments arguments}) async { final args = await arguments.jarArgs; logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: 'Running following command to generate openapi client - [ ${args.join(' ')} ]', @@ -123,7 +138,7 @@ class OpenapiGenerator extends GeneratorForAnnotation { // Include java environment variables in openApiCliCommand var javaOpts = Platform.environment['JAVA_OPTS'] ?? ''; - final result = await runExternalProcess( + final result = await runner.runCommand( command: Command( executable: 'java', arguments: [ @@ -146,7 +161,7 @@ class OpenapiGenerator extends GeneratorForAnnotation { ); } else { logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: [ if (arguments.isDebug) result.stdout, @@ -169,7 +184,7 @@ class OpenapiGenerator extends GeneratorForAnnotation { required String annotatedPath}) async { if (args.isRemote) { logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: 'Using a remote specification, a cache will still be create but may be outdated.', @@ -180,14 +195,14 @@ class OpenapiGenerator extends GeneratorForAnnotation { try { if (!await hasDiff(args: args)) { logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: 'No diff between versions, not running generator.', ), ); } else { logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: 'Dirty Spec found. Running generation.', ), @@ -197,26 +212,26 @@ class OpenapiGenerator extends GeneratorForAnnotation { await generateSources(baseCommand: baseCommand, args: args); if (!args.hasLocalCache) { logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: 'No local cache found. Creating one.', - level: Level.CONFIG, + level: Level.INFO, ), ); } else { logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: 'Local cache found. Overwriting existing one.', - level: Level.CONFIG, + level: Level.INFO, ), ); } - await cacheSpec( - outputLocation: args.cachePath, - spec: await loadSpec(specConfig: args.inputSpec)); + await runner.cacheSpecFile( + cachedPath: args.cachePath, + updatedSpec: await runner.loadSpecFile(specConfig: args.inputSpec)); logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: 'Successfully cached spec changes.', ), @@ -224,7 +239,7 @@ class OpenapiGenerator extends GeneratorForAnnotation { } } catch (e, st) { logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: 'Failed to generate content.', additionalContext: e, @@ -236,7 +251,7 @@ class OpenapiGenerator extends GeneratorForAnnotation { await formatCode(args: args).then( (_) {}, onError: (e, st) => logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: 'Failed to format generated code.', additionalContext: e, @@ -247,14 +262,14 @@ class OpenapiGenerator extends GeneratorForAnnotation { ); await updateAnnotatedFile(annotatedPath: annotatedPath).then( (_) => logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: 'Successfully updated annotated file.', - level: Level.CONFIG, + level: Level.INFO, ), ), onError: (e, st) => logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: 'Failed to update annotated class file.', level: Level.WARNING, @@ -270,12 +285,12 @@ class OpenapiGenerator extends GeneratorForAnnotation { /// Load both specs into memory and verify if there is a diff between them. FutureOr hasDiff({required GeneratorArguments args}) async { try { - final cachedSpec = await loadSpec( + final cachedSpec = await runner.loadSpecFile( specConfig: annots.InputSpec(path: args.cachePath), isCached: true); - final loadedSpec = await loadSpec(specConfig: args.inputSpec); + final loadedSpec = await runner.loadSpecFile(specConfig: args.inputSpec); logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: [ 'Loaded cached and current spec files.', @@ -287,7 +302,8 @@ class OpenapiGenerator extends GeneratorForAnnotation { ), ); - return isSpecDirty(cachedSpec: cachedSpec, loadedSpec: loadedSpec); + return await runner.isSpecFileDirty( + cachedSpec: cachedSpec, loadedSpec: loadedSpec); } catch (e, st) { return Future.error( OutputMessage( @@ -306,7 +322,7 @@ class OpenapiGenerator extends GeneratorForAnnotation { {required String baseCommand, required GeneratorArguments args}) async { if (!args.runSourceGen) { logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: 'Skipping source gen step due to flag being set.', level: Level.WARNING, @@ -314,7 +330,7 @@ class OpenapiGenerator extends GeneratorForAnnotation { ); } else if (!args.shouldGenerateSources) { logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: 'Skipping source gen because generator does not need it.', ), @@ -322,7 +338,7 @@ class OpenapiGenerator extends GeneratorForAnnotation { } else { return await runSourceGen(baseCommand: baseCommand, args: args).then( (_) => logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: 'Sources generated successfully.', ), @@ -343,7 +359,7 @@ class OpenapiGenerator extends GeneratorForAnnotation { Future runSourceGen( {required String baseCommand, required GeneratorArguments args}) async { logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: 'Running source code generation.', ), @@ -356,13 +372,13 @@ class OpenapiGenerator extends GeneratorForAnnotation { wrapper: args.wrapper); logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: '${command.executable} ${command.arguments.join(' ')}', ), ); - final results = await runExternalProcess( + final results = await runner.runCommand( command: command, workingDirectory: args.outputDirectory); if (results.exitCode != 0) { @@ -376,7 +392,7 @@ class OpenapiGenerator extends GeneratorForAnnotation { ); } else { logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: 'Codegen completed successfully.', ), @@ -389,7 +405,7 @@ class OpenapiGenerator extends GeneratorForAnnotation { {required String baseCommand, required GeneratorArguments args}) async { if (!args.shouldFetchDependencies) { logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: 'Skipping install step because flag was set.', level: Level.WARNING, @@ -402,14 +418,14 @@ class OpenapiGenerator extends GeneratorForAnnotation { wrapper: args.wrapper); logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: 'Installing dependencies with generated source. ${command.executable} ${command.arguments.join(' ')}', ), ); - final results = await runExternalProcess( + final results = await runner.runCommand( command: command, workingDirectory: args.outputDirectory); if (results.exitCode != 0) { return Future.error( @@ -422,7 +438,7 @@ class OpenapiGenerator extends GeneratorForAnnotation { ); } else { logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: [ if (args.isDebug) results.stdout, @@ -439,35 +455,35 @@ class OpenapiGenerator extends GeneratorForAnnotation { required Map updatedSpec, required String cachedPath, }) async => - cacheSpec(spec: updatedSpec, outputLocation: cachedPath); + runner.cacheSpecFile(updatedSpec: updatedSpec, cachedPath: cachedPath); Future updateAnnotatedFile({required annotatedPath}) async { - // The should exist since that is what triggered the build to begin with so - // there is no point in verifying it exists. It is also a relative file since - // it exists within the project. - final f = File(annotatedPath); - var content = f.readAsLinesSync(); - final now = DateTime.now().toIso8601String(); - final generated = '$lastRunPlaceHolder: $now'; - if (content.first.contains(lastRunPlaceHolder)) { - content = content.sublist(1); - logOutputMessage( - log: log, - communication: OutputMessage( - message: 'Found generated timestamp. Updating with $now', - ), - ); - } else { - logOutputMessage( - log: log, - communication: OutputMessage( - message: 'Creating generated timestamp with $now', - ), - ); - } try { - content.insert(0, generated); - f.writeAsStringSync(content.join('\n'), flush: true); + // The should exist since that is what triggered the build to begin with so + // there is no point in verifying it exists. It is also a relative file since + // it exists within the project. + var content = await runner.loadAnnotatedFile(path: annotatedPath); + final now = DateTime.now().toIso8601String(); + final generated = '$lastRunPlaceHolder: $now'; + if (content.first.contains(lastRunPlaceHolder)) { + content = content.sublist(1); + logOutputMessage( + log: _log, + communication: OutputMessage( + message: 'Found generated timestamp. Updating with $now', + ), + ); + } else { + logOutputMessage( + log: _log, + communication: OutputMessage( + message: 'Creating generated timestamp with $now', + ), + ); + } + + await runner.writeAnnotatedFile( + path: annotatedPath, content: content..insert(0, generated)); } catch (e, st) { return Future.error( OutputMessage( @@ -483,7 +499,7 @@ class OpenapiGenerator extends GeneratorForAnnotation { /// Format the generated code in the output directory. Future formatCode({required GeneratorArguments args}) async { final command = Command(executable: 'dart', arguments: ['format', './']); - final result = await runExternalProcess( + final result = await runner.runCommand( command: command, workingDirectory: args.outputDirectory); if (result.exitCode != 0) { @@ -497,20 +513,11 @@ class OpenapiGenerator extends GeneratorForAnnotation { ); } else { logOutputMessage( - log: log, + log: _log, communication: OutputMessage( message: 'Successfully formatted code.', ), ); } } - - Future runExternalProcess( - {required Command command, required String workingDirectory}) => - Process.run( - command.executable, - command.arguments, - workingDirectory: workingDirectory, - runInShell: Platform.isWindows, - ); } diff --git a/openapi-generator/lib/src/utils.dart b/openapi-generator/lib/src/utils.dart index 3307026..717b73c 100644 --- a/openapi-generator/lib/src/utils.dart +++ b/openapi-generator/lib/src/utils.dart @@ -6,7 +6,7 @@ import 'models/output_message.dart'; /// A utility function that prints out a log meant for the end user. void logOutputMessage( {required Logger log, required OutputMessage communication}) => - log.log(communication.level, communication.message + '\n', + log.log(communication.level, communication.message, communication.additionalContext, communication.stackTrace); /// Transforms a [Map] into a string. diff --git a/openapi-generator/test/builder_test.dart b/openapi-generator/test/builder_test.dart index c97b621..edf49f9 100644 --- a/openapi-generator/test/builder_test.dart +++ b/openapi-generator/test/builder_test.dart @@ -1,12 +1,3 @@ -import 'dart:convert'; -import 'dart:io'; - -import 'package:build_test/build_test.dart'; -import 'package:openapi_generator/src/gen_on_spec_changes.dart'; -import 'package:openapi_generator/src/models/generator_arguments.dart'; -import 'package:openapi_generator/src/utils.dart'; -import 'package:openapi_generator_annotations/openapi_generator_annotations.dart'; -import 'package:source_gen/source_gen.dart'; import 'package:test/expect.dart'; import 'package:test/scaffolding.dart'; @@ -113,476 +104,4 @@ void main() { 'generate -o=${testSpecPath}output -i=../openapi-spec.yaml -g=dart2-api --import-mappings=IntOrString=./int_or_string.dart --type-mappings=int-or-string=IntOrString')); }); }); - - group('NextGen', () { - late String generatedOutput; - final specPath = - 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml'; - final basePath = '${testSpecPath}output-nextgen/'; - final f = File('${basePath}cache.json'); - tearDown(() { - final b = File(basePath); - if (b.existsSync()) b.deleteSync(recursive: true); - }); - - group('runs', () { - setUpAll(() { - if (!f.existsSync()) { - f.createSync(recursive: true); - } - f.writeAsStringSync('{}'); - }); - tearDown(() { - if (f.existsSync()) { - f.deleteSync(); - } - }); - test('fails with invalid configuration', () async { - generatedOutput = await generate(''' - @Openapi( - inputSpecFile: '$specPath', - typeMappings: {'int-or-string':'IntOrString'}, - importMappings: {'IntOrString':'./int_or_string.dart'}, - generatorName: Generator.dioAlt, - useNextGen: false, - cachePath: '${f.path}', - outputDirectory: '${f.parent.path}/invalid_config/' - ) - '''); - expect(generatedOutput, - contains('useNextGen must be set when using cachePath')); - }); - test('Logs warning when using remote spec', () async { - generatedOutput = await generate(''' - @Openapi( - inputSpecFile: '$specPath', - inputSpec: RemoteSpec(path: '$specPath'), - typeMappings: {'int-or-string':'IntOrString'}, - importMappings: {'IntOrString':'./int_or_string.dart'}, - generatorName: Generator.dioAlt, - useNextGen: true, - outputDirectory: '${f.parent.path}/logs-when-remote' - ) - '''); - expect( - generatedOutput, - contains( - 'Using a remote specification, a cache will still be create but may be outdated.')); - }); - test('when the spec is dirty', () async { - final src = ''' - @Openapi( - inputSpecFile: '$specPath', - inputSpec: RemoteSpec(path: '$specPath'), - useNextGen: true, - cachePath: '${f.path}', - outputDirectory: '${f.parent.path}/when-spec-is-dirty' - ) - '''; - generatedOutput = await generate(src); - expect( - generatedOutput, contains('Dirty Spec found. Running generation.')); - }); - test('and terminates early when there is no diff', () async { - f.writeAsStringSync( - jsonEncode(await loadSpec(specConfig: RemoteSpec(path: specPath)))); - final src = ''' - @Openapi( - inputSpecFile: '$specPath', - inputSpec: RemoteSpec(path: '$specPath'), - useNextGen: true, - cachePath: '${f.path}', - outputDirectory: '${f.parent.path}/early-term' - ) - '''; - generatedOutput = await generate(src); - expect(generatedOutput, - contains('No diff between versions, not running generator.')); - }); - test('openApiJar with expected args', () async { - f.writeAsStringSync(jsonEncode({'someKey': 'someValue'})); - final annotations = (await resolveSource( - File('$testSpecPath/next_gen_builder_test_config.dart') - .readAsStringSync(), - (resolver) async => - (await resolver.findLibraryByName('test_lib'))!)) - .getClass('TestClassConfig')! - .metadata - .map((e) => ConstantReader(e.computeConstantValue()!)) - .first; - final args = GeneratorArguments(annotations: annotations); - generatedOutput = await generate(''' - @Openapi( - inputSpecFile: - 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', - inputSpec: RemoteSpec(path: '$specPath'), - generatorName: Generator.dio, - useNextGen: true, - cachePath: '${f.path}', - outputDirectory: './test/specs/output-nextgen/expected-args' -) - '''); - expect( - generatedOutput, contains('[ ${(await args.jarArgs).join(' ')} ]')); - }); - test('adds generated comment', () async { - f.writeAsStringSync(jsonEncode({'someKey': 'someValue'})); - final contents = File('$testSpecPath/next_gen_builder_test_config.dart') - .readAsStringSync(); - final copy = - File('./test/specs/next_gen_builder_test_config_copy.dart'); - copy.writeAsStringSync(contents, flush: true); - generatedOutput = await generate(''' - @Openapi( - inputSpecFile: - 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', - inputSpec: RemoteSpec(path: '$specPath'), - generatorName: Generator.dio, - useNextGen: true, - cachePath: '${f.path}', - outputDirectory: './test/specs/output-nextgen/add-generated-comment' -) - ''', path: copy.path); - - var hasOutput = copy.readAsStringSync().contains(lastRunPlaceHolder); - expect(generatedOutput, contains('Creating generated timestamp with ')); - - generatedOutput = await generate(''' - @Openapi( - inputSpecFile: - 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', - inputSpec: RemoteSpec(path: '$specPath'), - generatorName: Generator.dio, - useNextGen: true, - cachePath: '${f.path}', - outputDirectory: './test/specs/output-nextgen/add-generated-comment' -) - ''', path: copy.path); - - hasOutput = copy.readAsStringSync().contains(lastRunPlaceHolder); - expect(generatedOutput, - contains('Found generated timestamp. Updating with')); - - copy.deleteSync(); - expect(hasOutput, isTrue); - }); - group('source gen', () { - group('uses Flutter', () { - group('with wrapper', () { - test('fvm', () async { - generatedOutput = await generate(''' -@Openapi( - inputSpecFile: - 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', - inputSpec: RemoteSpec(path: '$specPath'), - generatorName: Generator.dio, - useNextGen: true, - cachePath: '${f.path}', - outputDirectory: '${f.parent.path}/fvm', - additionalProperties: AdditionalProperties( - wrapper: Wrapper.fvm, - ), -) - '''); - expect( - generatedOutput, contains('Running source code generation.')); - expect( - generatedOutput, - contains( - 'fvm pub run build_runner build --delete-conflicting-outputs')); - }); - test('flutterw', () async { - generatedOutput = await generate(''' -@Openapi( - inputSpecFile: - 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', - inputSpec: RemoteSpec(path: '$specPath'), - generatorName: Generator.dio, - useNextGen: true, - cachePath: '${f.path}', - outputDirectory: '${f.parent.path}/flutterw', - additionalProperties: AdditionalProperties( - wrapper: Wrapper.flutterw, - ), -) - '''); - expect( - generatedOutput, contains('Running source code generation.')); - expect( - generatedOutput, - contains( - './flutterw pub run build_runner build --delete-conflicting-outputs')); - }); - }); - test('without wrapper', () async { - final annotations = (await resolveSource( - File('$testSpecPath/next_gen_builder_flutter_test_config.dart') - .readAsStringSync(), - (resolver) async => - (await resolver.findLibraryByName('test_lib'))!)) - .getClass('TestClassConfig')! - .metadata - .map((e) => ConstantReader(e.computeConstantValue()!)) - .first; - final args = GeneratorArguments(annotations: annotations); - generatedOutput = await generate(''' -@Openapi( - inputSpecFile: - 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', - inputSpec: RemoteSpec(path: '$specPath'), - generatorName: Generator.dio, - useNextGen: true, - cachePath: '${f.path}', - outputDirectory: '${f.parent.path}/flutter', - projectPubspecPath: './test/specs/flutter_pubspec.test.yaml', -) - '''); - - expect(args.wrapper, Wrapper.none); - expect( - generatedOutput, contains('Running source code generation.')); - expect( - generatedOutput, - contains( - 'flutter pub run build_runner build --delete-conflicting-outputs')); - }); - }); - test('uses dart', () async { - final annotations = (await resolveSource( - File('$testSpecPath/next_gen_builder_test_config.dart') - .readAsStringSync(), - (resolver) async => - (await resolver.findLibraryByName('test_lib'))!)) - .getClass('TestClassConfig')! - .metadata - .map((e) => ConstantReader(e.computeConstantValue()!)) - .first; - final args = GeneratorArguments(annotations: annotations); - generatedOutput = await generate(''' -@Openapi( - inputSpecFile: - 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', - inputSpec: RemoteSpec(path: '$specPath'), - generatorName: Generator.dio, - useNextGen: true, - cachePath: '${f.path}', - outputDirectory: '${f.parent.path}/dart', - projectPubspecPath: './test/specs/dart_pubspec.test.yaml', -) - '''); - - expect(args.wrapper, Wrapper.none); - expect(generatedOutput, contains('Running source code generation.')); - expect( - generatedOutput, - contains( - 'dart pub run build_runner build --delete-conflicting-outputs')); - }); - group('except when', () { - test('flag is set', () async { - final annotations = (await resolveSource( - ''' -library test_lib; - -import 'package:openapi_generator_annotations/openapi_generator_annotations.dart'; - -@Openapi( - inputSpecFile: - 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', - inputSpec: RemoteSpec(path: '$specPath'), - generatorName: Generator.dio, - useNextGen: true, - cachePath: '${f.path}', - outputDirectory: '${f.parent.path}/no-src', - runSourceGenOnOutput: false, -) -class TestClassConfig extends OpenapiGeneratorConfig {} - ''', - (resolver) async => - (await resolver.findLibraryByName('test_lib'))!)) - .getClass('TestClassConfig')! - .metadata - .map((e) => ConstantReader(e.computeConstantValue()!)) - .first; - final args = GeneratorArguments(annotations: annotations); - - expect(args.runSourceGen, isFalse); - generatedOutput = await generate(''' -@Openapi( - inputSpecFile: - 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', - inputSpec: RemoteSpec(path: '$specPath'), - generatorName: Generator.dio, - useNextGen: true, - cachePath: '${f.path}', - outputDirectory: '${f.parent.path}/no-src', - runSourceGenOnOutput: false, -) - '''); - expect(generatedOutput, - contains('Skipping source gen step due to flag being set.')); - }); - test('generator is dart', () async { - final annotations = (await resolveSource( - ''' -library test_lib; - -import 'package:openapi_generator_annotations/openapi_generator_annotations.dart'; - -@Openapi( - inputSpecFile: - 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', - inputSpec: RemoteSpec(path: '$specPath'), - generatorName: Generator.dart, - useNextGen: true, - cachePath: '${f.path}', - outputDirectory: '${f.parent.path}/dart-gen' -) -class TestClassConfig extends OpenapiGeneratorConfig {} - ''', - (resolver) async => - (await resolver.findLibraryByName('test_lib'))!)) - .getClass('TestClassConfig')! - .metadata - .map((e) => ConstantReader(e.computeConstantValue()!)) - .first; - final args = GeneratorArguments(annotations: annotations); - expect(args.runSourceGen, isTrue); - generatedOutput = await generate(''' -@Openapi( - inputSpecFile: - 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', - inputSpec: RemoteSpec(path: '$specPath'), - generatorName: Generator.dart, - useNextGen: true, - cachePath: '${f.path}', - outputDirectory: '${f.parent.path}/dart-gen' -) - '''); - expect( - generatedOutput, - contains( - 'Skipping source gen because generator does not need it.')); - }); - }); - test('logs when successful', () async { - generatedOutput = await generate(''' -@Openapi( - inputSpecFile: - 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', - inputSpec: RemoteSpec(path: '$specPath'), - generatorName: Generator.dio, - useNextGen: true, - cachePath: '${f.path}', - outputDirectory: '${f.parent.path}/success', - projectPubspecPath: './test/specs/dart_pubspec.test.yaml', -) - '''); - expect(generatedOutput, contains('Codegen completed successfully.')); - expect(generatedOutput, contains('Sources generated successfully.')); - }); - }); - group('fetch dependencies', () { - test('except when flag is present', () async { - generatedOutput = await generate(''' -@Openapi( - inputSpecFile: - 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', - inputSpec: RemoteSpec(path: '$specPath'), - generatorName: Generator.dio, - useNextGen: true, - cachePath: '${f.path}', - outputDirectory: '${f.parent.path}/no-fetch', - projectPubspecPath: './test/specs/dart_pubspec.test.yaml', - fetchDependencies: false, -) - '''); - expect(generatedOutput, - contains('Skipping install step because flag was set.')); - }); - test('succeeds', () async { - generatedOutput = await generate(''' -@Openapi( - inputSpecFile: - 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', - inputSpec: RemoteSpec(path: '$specPath'), - generatorName: Generator.dio, - useNextGen: true, - cachePath: '${f.path}', - outputDirectory: '${f.parent.path}/no-fetch', - projectPubspecPath: './test/specs/dart_pubspec.test.yaml', -) - '''); - expect(generatedOutput, - contains('Installing dependencies with generated source.')); - expect(generatedOutput, contains('Install completed successfully.')); - }); - }); - group('update cache', () { - final src = ''' - @Openapi( - inputSpecFile: '$specPath', - inputSpec: RemoteSpec(path: '$specPath'), - useNextGen: true, - cachePath: '${f.path}', - outputDirectory: '${f.parent.path}/update-cache', - ) - '''; - - test('creating a cache file when not found', () async { - // Ensure that other tests don't make this available; - if (f.existsSync()) { - f.deleteSync(); - } - expect(f.existsSync(), isFalse); - generatedOutput = await generate(src); - expect(f.existsSync(), isTrue); - expect(jsonDecode(f.readAsStringSync()), - await loadSpec(specConfig: RemoteSpec(path: specPath))); - }); - test('updates the cache file when found', () async { - f.writeAsStringSync(jsonEncode({'someKey': 'someValue'})); - expect(f.existsSync(), isTrue); - generatedOutput = await generate(src); - final expectedSpec = - await loadSpec(specConfig: RemoteSpec(path: specPath)); - final actualSpec = jsonDecode(f.readAsStringSync()); - expect(actualSpec, expectedSpec); - }); - test('logs when successful', () async { - f.writeAsStringSync(jsonEncode({'someKey': 'someValue'})); - generatedOutput = await generate(src); - expect( - generatedOutput, contains('Successfully cached spec changes.')); - }); - }); - test('uses AWS', () async { - generatedOutput = await generate(''' -@Openapi( - inputSpecFile: '', - inputSpec: RemoteSpec( - path: - 'http://bucket.s3.us-east-1.localhost.localstack.cloud:4566/openapi.yaml', - headerDelegate: AWSRemoteSpecHeaderDelegate( - bucket: 'bucket', - accessKeyId: 'test', - secretAccessKey: 'test', - ), - ), - generatorName: Generator.dio, - useNextGen: true, - cachePath: '${f.path}', - outputDirectory: '${f.parent.path}/uses-aws-spec', - projectPubspecPath: './test/specs/dart_pubspec.test.yaml', -) - '''); - - expect(generatedOutput, contains('Running source code generation.')); - expect( - generatedOutput, - contains( - 'dart pub run build_runner build --delete-conflicting-outputs')); - }); - }); - }); } diff --git a/openapi-generator/test/generator_test.dart b/openapi-generator/test/generator_test.dart index ce78987..48f3748 100644 --- a/openapi-generator/test/generator_test.dart +++ b/openapi-generator/test/generator_test.dart @@ -1,17 +1,15 @@ import 'dart:io'; -import 'package:analyzer/dart/analysis/session.dart'; -import 'package:analyzer/dart/element/element.dart'; import 'package:analyzer/dart/element/type.dart'; -import 'package:analyzer/src/generated/engine.dart'; -import 'package:analyzer/src/generated/source.dart'; import 'package:build_test/build_test.dart'; import 'package:logging/logging.dart'; import 'package:mockito/mockito.dart'; +import 'package:openapi_generator/src/models/command.dart'; import 'package:openapi_generator/src/models/generator_arguments.dart'; import 'package:openapi_generator/src/models/output_message.dart'; import 'package:openapi_generator/src/openapi_generator_runner.dart'; -import 'package:pub_semver/src/version.dart'; +import 'package:openapi_generator/src/utils.dart'; +import 'package:openapi_generator_annotations/openapi_generator_annotations.dart'; import 'package:source_gen/source_gen.dart'; import 'package:test/test.dart'; @@ -23,9 +21,14 @@ void main() { group('NextGen', () { late MockConstantReader mockedAnnotations; late ConstantReader defaultAnnotations; - late MockOpenapiGenerator generator; late GeneratorArguments realArguments; + late MockGeneratorArguments mockedArgs; + late MockCommandRunner mockRunner; + final logger = Logger('TestOpenApiGenerator'); setUpAll(() async { + resetMockitoState(); + mockedArgs = MockGeneratorArguments(); + mockRunner = MockCommandRunner(); mockedAnnotations = MockConstantReader(); defaultAnnotations = (await resolveSource( File('$testSpecPath/next_gen_builder_test_config.dart') @@ -37,7 +40,26 @@ void main() { .map((e) => ConstantReader(e.computeConstantValue()!)) .first; realArguments = GeneratorArguments(annotations: defaultAnnotations); - generator = MockOpenapiGenerator(); + }); + + test('should have banner logger', () async { + final logs = []; + logger.onRecord.listen(logs.add); + try { + await OpenapiGenerator(log: logger).generateForAnnotatedElement( + MockMethodElement(), defaultAnnotations, MockBuildStep()); + fail('Should throw when not ClassElement'); + } catch (_, __) { + expect(logs.length, 1); + expect( + logs[0].message, + [ + ':::::::::::::::::::::::::::::::::::::::::::', + ':: Openapi generator for dart ::', + ':::::::::::::::::::::::::::::::::::::::::::', + ].join('\n')); + expect(logs[0].level, Level.INFO); + } }); test('throws InvalidGenerationSourceError when not a class', () async { @@ -76,10 +98,906 @@ void main() { } }); + group('logs which enviroment being used', () { + setUpAll(() => resetMockitoState()); + test('dart when wrapper is none', () async { + final logs = []; + logger.onRecord.listen(logs.add); + when(mockRunner.checkForFlutterEnvironemt( + wrapper: anyNamed('wrapper'), + providedPubspecPath: anyNamed('providedPubspecPath'))) + .thenAnswer((_) async => false); + + await OpenapiGenerator(log: logger, runner: mockRunner) + .generateForAnnotatedElement( + MockClassElement(), defaultAnnotations, MockBuildStep()); + + expect(logs[1].message, 'Using dart environemnt'); + }); + test('flutter when wrapper is fvm', () async { + final logs = []; + logger.onRecord.listen(logs.add); + final annotations = (await resolveSource( + File('$testSpecPath/next_gen_builder_fvm_test_config.dart') + .readAsStringSync(), + (resolver) async => + (await resolver.findLibraryByName('test_lib'))!)) + .getClass('TestClassConfig')! + .metadata + .map((e) => ConstantReader(e.computeConstantValue()!)) + .first; + + when(mockRunner.checkForFlutterEnvironemt( + wrapper: argThat( + TypeMatcher() + .having((e) => e, 'name', Wrapper.fvm), + named: 'wrapper', + ), + providedPubspecPath: anyNamed('providedPubspecPath'))) + .thenAnswer((_) async => true); + + await OpenapiGenerator(log: logger, runner: mockRunner) + .generateForAnnotatedElement( + MockClassElement(), annotations, MockBuildStep()); + + expect(logs[1].message, 'Using flutter environemnt'); + }); + test('flutter when wrapper is ./flutter', () async { + final logs = []; + logger.onRecord.listen(logs.add); + final annotations = (await resolveSource( + File('$testSpecPath/next_gen_builder_flutterw_test_config.dart') + .readAsStringSync(), + (resolver) async => + (await resolver.findLibraryByName('test_lib'))!)) + .getClass('TestClassConfig')! + .metadata + .map((e) => ConstantReader(e.computeConstantValue()!)) + .first; + + when(mockRunner.checkForFlutterEnvironemt( + wrapper: argThat( + TypeMatcher() + .having((e) => e, 'name', Wrapper.flutterw), + named: 'wrapper', + ), + providedPubspecPath: anyNamed('providedPubspecPath'))) + .thenAnswer((_) async => true); + + await OpenapiGenerator(log: logger, runner: mockRunner) + .generateForAnnotatedElement( + MockClassElement(), annotations, MockBuildStep()); + + expect(logs[1].message, 'Using flutter environemnt'); + }); + test('when defined in pubspec', () async { + final logs = []; + logger.onRecord.listen(logs.add); + final annotations = (await resolveSource( + File('$testSpecPath/next_gen_builder_flutter_test_config.dart') + .readAsStringSync(), + (resolver) async => + (await resolver.findLibraryByName('test_lib'))!)) + .getClass('TestClassConfig')! + .metadata + .map((e) => ConstantReader(e.computeConstantValue()!)) + .first; + + when( + mockRunner.checkForFlutterEnvironemt( + wrapper: anyNamed('wrapper'), + providedPubspecPath: argThat( + contains('./test/specs/flutter_pubspec.test.yaml'), + named: 'providedPubspecPath', + ), + ), + ).thenAnswer((_) async => true); + + await OpenapiGenerator(log: logger, runner: mockRunner) + .generateForAnnotatedElement( + MockClassElement(), annotations, MockBuildStep()); + + expect(logs[1].message, 'Using flutter environemnt'); + }); + }); + + group('generatorV2', () { + group('completes successfully', () { + late OpenapiGenerator generator; + setUpAll(() { + resetMockitoState(); + generator = OpenapiGenerator(log: logger, runner: mockRunner); + when(mockRunner.runCommand( + command: anyNamed('command'), + workingDirectory: anyNamed('workingDirectory'))) + .thenAnswer((realInvocation) => + Future.value(ProcessResult(999, 0, 'success', ''))); + when(mockRunner.writeAnnotatedFile( + path: anyNamed('path'), content: anyNamed('content'))) + .thenAnswer((realInvocation) => Future.value()); + }); + + test('no diff', () async { + final logs = []; + logger.onRecord.listen(logs.add); + when(mockRunner.loadSpecFile( + specConfig: anyNamed('specConfig'), isCached: true)) + .thenAnswer((realInvocation) => Future.value({})); + when(mockRunner.loadSpecFile(specConfig: anyNamed('specConfig'))) + .thenAnswer((realInvocation) => Future.value({})); + when(mockRunner.isSpecFileDirty( + cachedSpec: anyNamed('cachedSpec'), + loadedSpec: anyNamed('loadedSpec'))) + .thenAnswer((realInvocation) => Future.value(false)); + when(mockedArgs.isRemote).thenReturn(false); + try { + await generator.generatorV2( + args: mockedArgs, + baseCommand: 'dart', + annotatedPath: 'annotatedPath'); + expect(logs.length, 4); + expect(logs[1].message, + 'No diff between versions, not running generator.'); + expect(logs[1].level, Level.INFO); + } catch (e, _) { + fail('should not have thrown.'); + } + }); + test('has diff', () async { + // setup + final logs = []; + logger.onRecord.listen(logs.add); + when(mockRunner.loadSpecFile( + specConfig: anyNamed('specConfig'), isCached: true)) + .thenAnswer((realInvocation) => Future.value({})); + when(mockRunner.loadSpecFile(specConfig: anyNamed('specConfig'))) + .thenAnswer((realInvocation) => Future.value({})); + when(mockRunner.isSpecFileDirty( + cachedSpec: anyNamed('cachedSpec'), + loadedSpec: anyNamed('loadedSpec'))) + .thenAnswer((realInvocation) => Future.value(true)); + when(mockedArgs.isRemote).thenReturn(false); + when(mockedArgs.runSourceGen).thenReturn(true); + when(mockedArgs.shouldGenerateSources).thenReturn(true); + when(mockedArgs.shouldFetchDependencies).thenReturn(true); + when(mockRunner.cacheSpecFile( + updatedSpec: anyNamed('updatedSpec'), + cachedPath: anyNamed('cachedPath'))) + .thenAnswer((_) => Future.value(VoidType)); + when(mockRunner.runCommand( + command: anyNamed('command'), + workingDirectory: anyNamed('workingDirectory'))) + .thenAnswer((realInvocation) => + Future.value(ProcessResult(999, 0, 'success', ''))); + + when(mockRunner.loadAnnotatedFile(path: anyNamed('path'))) + .thenAnswer((realInvocation) => + Future.value(['cant be empty or throws'])); + when(mockRunner.writeAnnotatedFile( + path: anyNamed('path'), content: anyNamed('content'))) + .thenAnswer((realInvocation) => Future.value(VoidType)); + + // execution + await generator.generatorV2( + args: mockedArgs, + baseCommand: 'dart', + annotatedPath: 'annotatedPath'); + expect(logs.length, 15); + }); + }); + group('logs', () { + late OpenapiGenerator generator; + setUpAll(() { + resetMockitoState(); + generator = OpenapiGenerator(log: logger, runner: mockRunner); + }); + test('warning when using remote spec', () async { + final logs = []; + logger.onRecord.listen(logs.add); + when(mockRunner.loadSpecFile( + specConfig: anyNamed('specConfig'), isCached: true)) + .thenAnswer((realInvocation) => Future.value({})); + when(mockRunner.loadSpecFile(specConfig: anyNamed('specConfig'))) + .thenAnswer((realInvocation) => Future.value({})); + when(mockRunner.isSpecFileDirty( + cachedSpec: anyNamed('cachedSpec'), + loadedSpec: anyNamed('loadedSpec'))) + .thenAnswer((realInvocation) => Future.value(false)); + when(mockedArgs.isRemote).thenReturn(true); + when(mockRunner.runCommand( + command: anyNamed('command'), + workingDirectory: anyNamed('workingDirectory'))) + .thenAnswer((realInvocation) => + Future.value(ProcessResult(999, 0, 'success', ''))); + when(mockRunner.writeAnnotatedFile( + path: anyNamed('path'), content: anyNamed('content'))) + .thenAnswer((realInvocation) => Future.value()); + try { + await generator.generatorV2( + args: mockedArgs, + baseCommand: 'dart', + annotatedPath: 'annotatedPath'); + expect(logs.length, 6); + expect(logs[0].message, + 'Using a remote specification, a cache will still be create but may be outdated.'); + expect(logs[0].level, Level.WARNING); + } catch (e, _) { + print(e); + fail('should not have thrown.'); + } + }); + test('when no cache is found', () async { + // setup + final logs = []; + logger.onRecord.listen(logs.add); + when(mockRunner.loadSpecFile( + specConfig: anyNamed('specConfig'), isCached: true)) + .thenAnswer((realInvocation) => Future.value({})); + when(mockRunner.loadSpecFile(specConfig: anyNamed('specConfig'))) + .thenAnswer((realInvocation) => Future.value({})); + when(mockRunner.isSpecFileDirty( + cachedSpec: anyNamed('cachedSpec'), + loadedSpec: anyNamed('loadedSpec'))) + .thenAnswer((realInvocation) => Future.value(true)); + when(mockedArgs.isRemote).thenReturn(false); + when(mockedArgs.hasLocalCache).thenReturn(false); + when(mockRunner.runCommand( + command: anyNamed('command'), + workingDirectory: anyNamed('workingDirectory'))) + .thenAnswer((realInvocation) => + Future.value(ProcessResult(999, 0, 'success', ''))); + + when(mockRunner.loadAnnotatedFile(path: anyNamed('path'))) + .thenAnswer((realInvocation) => + Future.value(['cant be empty or throws'])); + when(mockRunner.writeAnnotatedFile( + path: anyNamed('path'), content: anyNamed('content'))) + .thenAnswer((realInvocation) => Future.value(VoidType)); + + // execution + await generator.generatorV2( + args: mockedArgs, + baseCommand: 'dart', + annotatedPath: 'annotatedPath'); + expect(logs.length, 15); + + final recordIndex = logs.indexWhere((element) => + element.message == 'No local cache found. Creating one.'); + expect(recordIndex, greaterThan(-1)); + expect(logs[recordIndex].level, Level.INFO); + }); + test('when cache is found', () async { + // setup + final logs = []; + logger.onRecord.listen(logs.add); + when(mockRunner.loadSpecFile( + specConfig: anyNamed('specConfig'), isCached: true)) + .thenAnswer((realInvocation) => Future.value({})); + when(mockRunner.loadSpecFile(specConfig: anyNamed('specConfig'))) + .thenAnswer((realInvocation) => Future.value({})); + when(mockRunner.isSpecFileDirty( + cachedSpec: anyNamed('cachedSpec'), + loadedSpec: anyNamed('loadedSpec'))) + .thenAnswer((realInvocation) => Future.value(true)); + when(mockedArgs.isRemote).thenReturn(false); + when(mockedArgs.hasLocalCache).thenReturn(true); + when(mockRunner.runCommand( + command: anyNamed('command'), + workingDirectory: anyNamed('workingDirectory'))) + .thenAnswer((realInvocation) => + Future.value(ProcessResult(999, 0, 'success', ''))); + + when(mockRunner.loadAnnotatedFile(path: anyNamed('path'))) + .thenAnswer((realInvocation) => + Future.value(['cant be empty or throws'])); + when(mockRunner.writeAnnotatedFile( + path: anyNamed('path'), content: anyNamed('content'))) + .thenAnswer((realInvocation) => Future.value(VoidType)); + + // execution + await generator.generatorV2( + args: mockedArgs, + baseCommand: 'dart', + annotatedPath: 'annotatedPath'); + expect(logs.length, 15); + + final recordIndex = logs.indexWhere((element) => + element.message == + 'Local cache found. Overwriting existing one.'); + expect(recordIndex, greaterThan(-1)); + expect(logs[recordIndex].level, Level.INFO); + }); + group('on failure', () { + test('has diff', () async { + // setup + final logs = []; + logger.onRecord.listen(logs.add); + when(mockRunner.loadSpecFile( + specConfig: anyNamed('specConfig'), isCached: true)) + .thenAnswer((realInvocation) => Future.value({})); + when(mockRunner.loadSpecFile(specConfig: anyNamed('specConfig'))) + .thenAnswer((realInvocation) => Future.value({})); + when(mockRunner.isSpecFileDirty( + cachedSpec: anyNamed('cachedSpec'), + loadedSpec: anyNamed('loadedSpec'))) + .thenThrow('uh oh'); + when(mockedArgs.isRemote).thenReturn(false); + when(mockedArgs.runSourceGen).thenReturn(true); + when(mockedArgs.shouldGenerateSources).thenReturn(true); + when(mockedArgs.shouldFetchDependencies).thenReturn(true); + when(mockRunner.cacheSpecFile( + updatedSpec: anyNamed('updatedSpec'), + cachedPath: anyNamed('cachedPath'))) + .thenAnswer((_) => Future.value(VoidType)); + when(mockRunner.runCommand( + command: anyNamed('command'), + workingDirectory: anyNamed('workingDirectory'))) + .thenAnswer((realInvocation) => + Future.value(ProcessResult(999, 0, 'success', ''))); + + when(mockRunner.loadAnnotatedFile(path: anyNamed('path'))) + .thenAnswer((realInvocation) => + Future.value(['cant be empty or throws'])); + when(mockRunner.writeAnnotatedFile( + path: anyNamed('path'), content: anyNamed('content'))) + .thenAnswer((realInvocation) => Future.value(VoidType)); + + // execution + await generator.generatorV2( + args: mockedArgs, + baseCommand: 'dart', + annotatedPath: 'annotatedPath'); + expect(logs.length, 5); + expect(logs[1].message, 'Failed to generate content.'); + expect(logs[1].level, Level.SEVERE); + }); + test('fails to format', () async { + // setup + final logs = []; + logger.onRecord.listen(logs.add); + when(mockRunner.loadSpecFile( + specConfig: anyNamed('specConfig'), isCached: true)) + .thenAnswer((realInvocation) => Future.value({})); + when(mockRunner.loadSpecFile(specConfig: anyNamed('specConfig'))) + .thenAnswer((realInvocation) => Future.value({})); + when(mockRunner.isSpecFileDirty( + cachedSpec: anyNamed('cachedSpec'), + loadedSpec: anyNamed('loadedSpec'))) + .thenAnswer((realInvocation) => Future.value(true)); + when(mockedArgs.isRemote).thenReturn(false); + when(mockedArgs.runSourceGen).thenReturn(true); + when(mockedArgs.shouldGenerateSources).thenReturn(true); + when(mockedArgs.shouldFetchDependencies).thenReturn(true); + when(mockRunner.cacheSpecFile( + updatedSpec: anyNamed('updatedSpec'), + cachedPath: anyNamed('cachedPath'))) + .thenAnswer((_) => Future.value(VoidType)); + when(mockedArgs.outputDirectory).thenReturn('pwd'); + when(mockRunner.runCommand( + command: anyNamed('command'), + workingDirectory: anyNamed('workingDirectory'))) + .thenAnswer((_) => + Future.value(ProcessResult(999, 0, 'success', ''))); + when(mockRunner.runCommand( + command: argThat( + TypeMatcher() + .having((c) => c.executable, 'executable', 'dart') + .having( + (c) => c.arguments, 'arguments', ['format', './']), + named: 'command', + ), + workingDirectory: + argThat(contains('pwd'), named: 'workingDirectory'), + )).thenAnswer((realInvocation) => + Future.value(ProcessResult(999, 1, '', 'err'))); + + when(mockRunner.loadAnnotatedFile(path: anyNamed('path'))) + .thenAnswer((realInvocation) => + Future.value(['cant be empty or throws'])); + when(mockRunner.writeAnnotatedFile( + path: anyNamed('path'), content: anyNamed('content'))) + .thenAnswer((realInvocation) => Future.value(VoidType)); + + // execution + await generator.generatorV2( + args: mockedArgs, + baseCommand: 'dart', + annotatedPath: 'annotatedPath'); + expect(logs.length, 15); + expect(logs[12].message, 'Failed to format generated code.'); + expect(logs[12].level, Level.SEVERE); + }); + }); + }); + }); + + group('hasDiff', () { + test('succeeds', () async { + final logs = []; + logger.onRecord.listen(logs.add); + when(mockRunner.loadSpecFile( + specConfig: anyNamed('specConfig'), isCached: true)) + .thenAnswer( + (realInvocation) => Future.value({})); + when(mockRunner.loadSpecFile(specConfig: anyNamed('specConfig'))) + .thenAnswer( + (realInvocation) => Future.value({})); + when(mockRunner.isSpecFileDirty( + cachedSpec: anyNamed('cachedSpec'), + loadedSpec: anyNamed('loadedSpec'))) + .thenAnswer((realInvocation) => Future.value(true)); + try { + expect( + await OpenapiGenerator(runner: mockRunner) + .hasDiff(args: realArguments), + isTrue); + expect(logs.length, 1); + expect(logs[0].message, 'Loaded cached and current spec files.'); + } catch (_, __) { + fail('should have completed successfully'); + } + }); + test('debug logs', () async { + final logs = []; + logger.onRecord.listen(logs.add); + when(mockedArgs.isDebug).thenReturn(true); + when(mockRunner.loadSpecFile( + specConfig: anyNamed('specConfig'), isCached: true)) + .thenAnswer( + (realInvocation) => Future.value({})); + when(mockRunner.loadSpecFile(specConfig: anyNamed('specConfig'))) + .thenAnswer( + (realInvocation) => Future.value({})); + when(mockRunner.isSpecFileDirty( + cachedSpec: anyNamed('cachedSpec'), + loadedSpec: anyNamed('loadedSpec'))) + .thenAnswer((realInvocation) => Future.value(true)); + try { + expect( + await OpenapiGenerator(runner: mockRunner) + .hasDiff(args: mockedArgs), + isTrue); + expect(logs.length, 1); + expect(logs[0].message, + 'Loaded cached and current spec files.\n{}\n{}'); + } catch (_, __) { + fail('should have completed successfully'); + } + }); + test('fails', () async { + when(mockRunner.loadSpecFile( + specConfig: anyNamed('specConfig'), isCached: true)) + .thenAnswer( + (realInvocation) => Future.value({})); + when(mockRunner.loadSpecFile(specConfig: anyNamed('specConfig'))) + .thenAnswer( + (realInvocation) => Future.value({})); + when(mockRunner.isSpecFileDirty( + cachedSpec: anyNamed('cachedSpec'), + loadedSpec: anyNamed('loadedSpec'))) + .thenThrow('uh oh'); + try { + await OpenapiGenerator(runner: mockRunner) + .hasDiff(args: realArguments); + fail('should have thrown'); + } catch (e, _) { + expect(e, isA()); + e as OutputMessage; + expect(e.message, 'Failed to check diff status.'); + expect(e.additionalContext, 'uh oh'); + expect(e.level, Level.SEVERE); + expect(e.stackTrace, isNotNull); + } + }); + }); + group('fetchDependencies', () { + test('returns successfully', () async { + when(mockedArgs.shouldFetchDependencies).thenReturn(true); + when(mockRunner.runCommand( + command: anyNamed('command'), + workingDirectory: anyNamed('workingDirectory'))) + .thenAnswer( + (_) => Future.value(ProcessResult(999, 0, 'yes', ''))); + try { + await OpenapiGenerator(runner: mockRunner) + .fetchDependencies(baseCommand: 'cmd', args: mockedArgs); + } catch (e, _) { + fail('should have completed successfully'); + } + }); + test('fails and returns an OutputMessage', () async { + when(mockedArgs.shouldFetchDependencies).thenReturn(true); + when(mockRunner.runCommand( + command: anyNamed('command'), + workingDirectory: anyNamed('workingDirectory'))) + .thenAnswer( + (_) => Future.value(ProcessResult(999, 1, '', 'uh oh'))); + try { + await OpenapiGenerator(runner: mockRunner) + .fetchDependencies(baseCommand: 'cmd', args: mockedArgs); + fail('should returned an error'); + } catch (e, _) { + expect(e, isA()); + e as OutputMessage; + expect(e.level, Level.SEVERE); + expect(e.message, 'Install within generated sources failed.'); + expect(e.additionalContext, 'uh oh'); + expect(e.stackTrace, isNotNull); + } + }); + group('logs', () { + tearDownAll(() => resetMockitoState()); + test('skips dependency fetch when flag is set', () async { + final logs = []; + logger.onRecord.listen(logs.add); + when(mockedArgs.shouldFetchDependencies).thenReturn(false); + + await OpenapiGenerator(log: logger) + .fetchDependencies(baseCommand: 'cmd', args: mockedArgs); + + expect(logs.length, 1); + expect(logs[0].toString(), + contains('Skipping install step because flag was set.')); + expect(logs[0].level, Level.WARNING); + }); + test('debug', () async { + final logs = []; + logger.onRecord.listen(logs.add); + when(mockedArgs.shouldFetchDependencies).thenReturn(true); + when(mockedArgs.isDebug).thenReturn(true); + when(mockRunner.runCommand( + command: anyNamed('command'), + workingDirectory: anyNamed('workingDirectory'))) + .thenAnswer( + (_) => Future.value(ProcessResult(999, 0, 'yes', ''))); + + await OpenapiGenerator(log: logger, runner: mockRunner) + .fetchDependencies(baseCommand: 'dart', args: mockedArgs); + + expect(logs.length, 2); + expect( + logs[0].message, + contains( + 'Installing dependencies with generated source. dart pub get')); + expect(logs[1].message, contains('yes')); + expect( + logs[1].message, contains('Install completed successfully.')); + expect(logs[0].level, Level.INFO); + expect(logs[1].level, Level.INFO); + }); + test('normal', () async { + final logs = []; + logger.onRecord.listen(logs.add); + when(mockedArgs.shouldFetchDependencies).thenReturn(true); + when(mockedArgs.isDebug).thenReturn(false); + when(mockRunner.runCommand( + command: anyNamed('command'), + workingDirectory: anyNamed('workingDirectory'))) + .thenAnswer( + (_) => Future.value(ProcessResult(999, 0, 'yes', ''))); + + await OpenapiGenerator(log: logger, runner: mockRunner) + .fetchDependencies(baseCommand: 'dart', args: mockedArgs); + + expect(logs.length, 2); + expect( + logs[0].message, + contains( + 'Installing dependencies with generated source. dart pub get')); + expect(logs[1].message.contains('yes'), isFalse); + expect( + logs[1].message, contains('Install completed successfully.')); + expect(logs[0].level, Level.INFO); + expect(logs[1].level, Level.INFO); + }); + }); + }); + group('runSourceGen', () { + test('fails and returns an OutputMessage', () async { + when(mockRunner.runCommand( + command: anyNamed('command'), + workingDirectory: anyNamed('workingDirectory'))) + .thenAnswer( + (_) => Future.value(ProcessResult(999, 1, '', 'uh oh'))); + try { + await OpenapiGenerator(runner: mockRunner) + .runSourceGen(baseCommand: 'dart', args: mockedArgs); + fail('should returned an error'); + } catch (e, _) { + expect(e, isA()); + e as OutputMessage; + expect(e.level, Level.SEVERE); + expect(e.message, + 'Failed to generate source code. Build Command output:'); + expect(e.additionalContext, 'uh oh'); + expect(e.stackTrace, isNotNull); + } + }); + test('runs successfully', () async { + final logs = []; + logger.onRecord.listen(logs.add); + when(mockRunner.runCommand( + command: anyNamed('command'), + workingDirectory: anyNamed('workingDirectory'))) + .thenAnswer((_) => Future.value(ProcessResult(999, 0, '', ''))); + try { + await OpenapiGenerator(runner: mockRunner) + .runSourceGen(baseCommand: 'dart', args: mockedArgs); + expect(logs.length, 3); + expect(logs[0].message, 'Running source code generation.'); + expect(logs[1].message, + 'dart pub run build_runner build --delete-conflicting-outputs'); + expect(logs[2].message, 'Codegen completed successfully.'); + for (final log in logs) { + expect(log.level, Level.INFO); + } + } catch (e, _) { + fail('should have completed normally'); + } + }); + }); + group('generateSources', () { + test('skips when flag is set', () async { + final logs = []; + logger.onRecord.listen(logs.add); + when(mockedArgs.runSourceGen).thenReturn(false); + try { + await OpenapiGenerator(runner: mockRunner) + .generateSources(baseCommand: 'dart', args: mockedArgs); + expect(logs.length, 1); + expect(logs[0].message, + 'Skipping source gen step due to flag being set.'); + expect(logs[0].level, Level.WARNING); + } catch (e, _) { + fail('should have completed normally'); + } + }); + test('skips when not needed', () async { + final logs = []; + logger.onRecord.listen(logs.add); + when(mockedArgs.runSourceGen).thenReturn(true); + when(mockedArgs.shouldGenerateSources).thenReturn(false); + try { + await OpenapiGenerator(runner: mockRunner) + .generateSources(baseCommand: 'dart', args: mockedArgs); + expect(logs.length, 1); + expect(logs[0].message, + 'Skipping source gen because generator does not need it.'); + expect(logs[0].level, Level.INFO); + } catch (e, _) { + fail('should have completed normally'); + } + }); + test('completes successfully', () async { + final logs = []; + logger.onRecord.listen(logs.add); + when(mockedArgs.runSourceGen).thenReturn(true); + when(mockedArgs.shouldGenerateSources).thenReturn(true); + when(mockRunner.runCommand( + command: anyNamed('command'), + workingDirectory: anyNamed('workingDirectory'))) + .thenAnswer((_) => Future.value(ProcessResult(999, 0, '', ''))); + try { + await OpenapiGenerator(runner: mockRunner) + .generateSources(baseCommand: 'dart', args: mockedArgs); + expect(logs.length, 4); + expect(logs[3].message, 'Sources generated successfully.'); + expect(logs[3].level, Level.INFO); + } catch (e, _) { + fail('should have completed normally'); + } + }); + test('fails', () async { + final logs = []; + logger.onRecord.listen(logs.add); + when(mockedArgs.runSourceGen).thenReturn(true); + when(mockedArgs.shouldGenerateSources).thenReturn(true); + when(mockRunner.runCommand( + command: anyNamed('command'), + workingDirectory: anyNamed('workingDirectory'))) + .thenAnswer( + (_) => Future.value(ProcessResult(999, 1, '', 'uh oh'))); + try { + await OpenapiGenerator(runner: mockRunner) + .generateSources(baseCommand: 'dart', args: mockedArgs); + fail('should have failed'); + } catch (e, _) { + expect(e, isA()); + e as OutputMessage; + expect(e.message, 'Could not complete source generation'); + expect(e.level, Level.SEVERE); + expect(e.additionalContext, isA()); + expect(e.stackTrace, isNotNull); + } + }); + }); + group('updateAnnotatedFile', () { + test('fails', () async { + when(mockRunner.loadAnnotatedFile(path: 'annotatedPath')) + .thenAnswer((realInvocation) => Future.error('uh')); + try { + await OpenapiGenerator(runner: mockRunner) + .updateAnnotatedFile(annotatedPath: 'annotatedPath'); + fail('should have thrown an error'); + } catch (e, _) { + expect(e, isA()); + e as OutputMessage; + expect(e.message, 'Failed to update the annotated class file.'); + expect(e.level, Level.SEVERE); + expect(e.additionalContext, 'uh'); + expect(e.stackTrace, isNotNull); + } + }); + test('finds timestamp', () async { + final logs = []; + logger.onRecord.listen(logs.add); + when(mockRunner.loadAnnotatedFile(path: 'annotatedPath')).thenAnswer( + (realInvocation) => + Future.value(['$lastRunPlaceHolder: something', 'more'])); + when(mockRunner.writeAnnotatedFile( + path: 'annotatedPath', content: anyNamed('content'))) + .thenAnswer((realInvocation) => Future.value()); + try { + await OpenapiGenerator(runner: mockRunner) + .updateAnnotatedFile(annotatedPath: 'annotatedPath'); + expect(logs.length, 1); + expect(logs[0].message, + contains('Found generated timestamp. Updating with ')); + } catch (_, __) { + fail('should have completed successfully'); + } + }); + test('does not find timestamp', () async { + final logs = []; + logger.onRecord.listen(logs.add); + when(mockRunner.loadAnnotatedFile(path: 'annotatedPath')) + .thenAnswer((realInvocation) => Future.value(['more'])); + when(mockRunner.writeAnnotatedFile( + path: 'annotatedPath', content: anyNamed('content'))) + .thenAnswer((realInvocation) => Future.value()); + try { + await OpenapiGenerator(runner: mockRunner) + .updateAnnotatedFile(annotatedPath: 'annotatedPath'); + expect(logs.length, 1); + expect(logs[0].message, + contains('Creating generated timestamp with ')); + } catch (_, __) { + fail('should have completed successfully'); + } + }); + }); + group('formatCode', () { + test('logs on success', () async { + final logs = []; + logger.onRecord.listen(logs.add); + when(mockRunner.runCommand( + command: anyNamed('command'), + workingDirectory: anyNamed('workingDirectory'))) + .thenAnswer((_) => Future.value(ProcessResult(999, 0, '', ''))); + try { + await OpenapiGenerator(runner: mockRunner, log: logger) + .formatCode(args: mockedArgs); + expect(logs.length, 1); + expect(logs[0].message, 'Successfully formatted code.'); + expect(logs[0].level, Level.INFO); + } catch (e, _) { + fail('should complete successfully'); + } + }); + test('fails and returns an OutputMessage', () async { + when(mockRunner.runCommand( + command: anyNamed('command'), + workingDirectory: anyNamed('workingDirectory'))) + .thenAnswer( + (_) => Future.value(ProcessResult(999, 1, '', 'uh oh'))); + try { + await OpenapiGenerator(runner: mockRunner) + .formatCode(args: mockedArgs); + fail('should returned an error'); + } catch (e, _) { + expect(e, isA()); + e as OutputMessage; + expect(e.level, Level.SEVERE); + expect(e.message, 'Failed to format generated code.'); + expect(e.additionalContext, 'uh oh'); + expect(e.stackTrace, isNotNull); + } + }); + }); group('runOpenApiJar', () { + group('logs', () { + tearDownAll(() => resetMockitoState()); + test('normal', () async { + final logs = []; + logger.onRecord.listen(logs.add); + when( + mockRunner.runCommand( + command: anyNamed('command'), + workingDirectory: anyNamed( + 'workingDirectory', + ), + ), + ).thenAnswer( + (realInvocation) => Future.value( + ProcessResult(999, 0, 'jar successful', ''), + ), + ); + + when(mockedArgs.jarArgs) + .thenAnswer((realInvocation) => realArguments.jarArgs); + when(mockedArgs.isDebug).thenReturn(false); + await OpenapiGenerator(runner: mockRunner, log: logger) + .runOpenApiJar(arguments: mockedArgs); + expect(logs.length, 2); + expect( + logs[0].message, + contains( + 'Running following command to generate openapi client - [ ${(await realArguments.jarArgs).join(' ')} ]')); + expect(logs[1].message.contains('jar successful'), isFalse); + expect(logs[1].message, + contains('Openapi generator completed successfully.')); + for (final log in logs) { + expect(log.level, Level.INFO); + } + }); + + test('debug', () async { + final logs = []; + logger.onRecord.listen(logs.add); + when( + mockRunner.runCommand( + command: anyNamed('command'), + workingDirectory: anyNamed( + 'workingDirectory', + ), + ), + ).thenAnswer( + (realInvocation) => Future.value( + ProcessResult(999, 0, 'jar successful', ''), + ), + ); + + when(mockedArgs.jarArgs) + .thenAnswer((realInvocation) => realArguments.jarArgs); + when(mockedArgs.isDebug).thenReturn(true); + await OpenapiGenerator(runner: mockRunner, log: logger) + .runOpenApiJar(arguments: mockedArgs); + expect(logs.length, 2); + expect( + logs[0].message, + contains( + 'Running following command to generate openapi client - [ ${(await realArguments.jarArgs).join(' ')} ]')); + expect(logs[1].message, contains('jar successful')); + expect(logs[1].message, + contains('Openapi generator completed successfully.')); + for (final log in logs) { + expect(log.level, Level.INFO); + } + }); + }); + test('returns successfully', () async { + when( + mockRunner.runCommand( + command: anyNamed('command'), + workingDirectory: anyNamed( + 'workingDirectory', + ), + ), + ).thenAnswer( + (realInvocation) => Future.value( + ProcessResult(999, 0, 'completed successfully', ''), + ), + ); + try { + await OpenapiGenerator(runner: mockRunner) + .runOpenApiJar(arguments: realArguments); + } catch (e, _) { + fail('should have completed successfully.'); + } + }); test('returns an error when the jar command fails', () async { when( - generator.runExternalProcess( + mockRunner.runCommand( command: anyNamed('command'), workingDirectory: anyNamed( 'workingDirectory', @@ -92,7 +1010,8 @@ void main() { ); try { - await generator.runOpenApiJar(arguments: realArguments); + await OpenapiGenerator(runner: mockRunner) + .runOpenApiJar(arguments: realArguments); fail( 'should have returned an error log.', ); diff --git a/openapi-generator/test/mocks.dart b/openapi-generator/test/mocks.dart index bd0f40b..301fd6f 100644 --- a/openapi-generator/test/mocks.dart +++ b/openapi-generator/test/mocks.dart @@ -3,7 +3,10 @@ import 'dart:io'; import 'package:analyzer/dart/element/element.dart'; import 'package:build/build.dart'; import 'package:mockito/annotations.dart'; +import 'package:openapi_generator/src/models/command.dart'; +import 'package:openapi_generator/src/models/generator_arguments.dart'; import 'package:openapi_generator/src/openapi_generator_runner.dart'; +import 'package:openapi_generator_annotations/openapi_generator_annotations.dart'; import 'package:source_gen/source_gen.dart'; @GenerateNiceMocks([ @@ -13,5 +16,8 @@ import 'package:source_gen/source_gen.dart'; MockSpec(), MockSpec(), MockSpec(), + MockSpec(), + MockSpec(), + MockSpec() ]) void main() {} diff --git a/openapi-generator/test/specs/next_gen_builder_flutterw_test_config.dart b/openapi-generator/test/specs/next_gen_builder_flutterw_test_config.dart new file mode 100644 index 0000000..8198482 --- /dev/null +++ b/openapi-generator/test/specs/next_gen_builder_flutterw_test_config.dart @@ -0,0 +1,17 @@ +library test_lib; + +import 'package:openapi_generator_annotations/openapi_generator_annotations.dart'; + +@Openapi( + inputSpecFile: + 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', + inputSpec: RemoteSpec( + path: + 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', + ), + generatorName: Generator.dio, + useNextGen: true, + additionalProperties: AdditionalProperties(wrapper: Wrapper.flutterw), + cachePath: './test/specs/output-nextgen/expected-args/cache.json', + outputDirectory: './test/specs/output-nextgen/expected-args') +class TestClassConfig extends OpenapiGeneratorConfig {} diff --git a/openapi-generator/test/specs/next_gen_builder_fvm_test_config.dart b/openapi-generator/test/specs/next_gen_builder_fvm_test_config.dart new file mode 100644 index 0000000..2a316b5 --- /dev/null +++ b/openapi-generator/test/specs/next_gen_builder_fvm_test_config.dart @@ -0,0 +1,19 @@ +library test_lib; + +import 'package:openapi_generator_annotations/openapi_generator_annotations.dart'; + +@Openapi( + inputSpecFile: + 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', + inputSpec: RemoteSpec( + path: + 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', + ), + generatorName: Generator.dio, + additionalProperties: AdditionalProperties( + wrapper: Wrapper.fvm, + ), + useNextGen: true, + cachePath: './test/specs/output-nextgen/expected-args/cache.json', + outputDirectory: './test/specs/output-nextgen/expected-args') +class TestClassConfig extends OpenapiGeneratorConfig {} From f1122d007ef47f0849656e5180a78052b9542ec9 Mon Sep 17 00:00:00 2001 From: Nexushunter Date: Sun, 3 Sep 2023 13:02:33 -0400 Subject: [PATCH 03/13] fix: tweak gitignore --- openapi-generator/.gitignore | 3 +- openapi-generator/test/mocks.mocks.dart | 2226 ----------------- .../test/specs/localstack/cache/machine.json | 1 - .../specs/localstack/cache/server.test.pem | 125 - .../localstack/cache/server.test.pem.crt | 97 - .../localstack/cache/server.test.pem.key | 28 - .../service-catalog-2_2_1_dev-1_31_28.pickle | Bin 352716 -> 0 bytes 7 files changed, 2 insertions(+), 2478 deletions(-) delete mode 100644 openapi-generator/test/mocks.mocks.dart delete mode 100644 openapi-generator/test/specs/localstack/cache/machine.json delete mode 100644 openapi-generator/test/specs/localstack/cache/server.test.pem delete mode 100644 openapi-generator/test/specs/localstack/cache/server.test.pem.crt delete mode 100644 openapi-generator/test/specs/localstack/cache/server.test.pem.key delete mode 100644 openapi-generator/test/specs/localstack/cache/service-catalog-2_2_1_dev-1_31_28.pickle diff --git a/openapi-generator/.gitignore b/openapi-generator/.gitignore index a1cc285..125d434 100755 --- a/openapi-generator/.gitignore +++ b/openapi-generator/.gitignore @@ -169,4 +169,5 @@ example/.dart_tool # Generated test output test/specs/test-cached.json -test/specs/localstack/** \ No newline at end of file +test/specs/localstack +test/mocks.mocks.dart \ No newline at end of file diff --git a/openapi-generator/test/mocks.mocks.dart b/openapi-generator/test/mocks.mocks.dart deleted file mode 100644 index 8c6e7ca..0000000 --- a/openapi-generator/test/mocks.mocks.dart +++ /dev/null @@ -1,2226 +0,0 @@ -// Mocks generated by Mockito 5.4.2 from annotations -// in openapi_generator/test/mocks.dart. -// Do not manually edit this file. - -// ignore_for_file: no_leading_underscores_for_library_prefixes -import 'dart:async' as _i8; -import 'dart:convert' as _i17; -import 'dart:io' as _i12; - -import 'package:analyzer/dart/constant/value.dart' as _i3; -import 'package:analyzer/dart/element/element.dart' as _i6; -import 'package:analyzer/dart/element/nullability_suffix.dart' as _i19; -import 'package:analyzer/dart/element/type.dart' as _i4; -import 'package:analyzer/src/generated/engine.dart' as _i10; -import 'package:analyzer/src/generated/source.dart' as _i11; -import 'package:build/build.dart' as _i5; -import 'package:crypto/crypto.dart' as _i9; -import 'package:glob/glob.dart' as _i18; -import 'package:mockito/mockito.dart' as _i1; -import 'package:mockito/src/dummies.dart' as _i16; -import 'package:openapi_generator/src/models/command.dart' as _i15; -import 'package:openapi_generator/src/models/generator_arguments.dart' as _i14; -import 'package:openapi_generator/src/openapi_generator_runner.dart' as _i13; -import 'package:package_config/package_config_types.dart' as _i7; -import 'package:source_gen/source_gen.dart' as _i2; - -// ignore_for_file: type=lint -// ignore_for_file: avoid_redundant_argument_values -// ignore_for_file: avoid_setters_without_getters -// ignore_for_file: comment_references -// ignore_for_file: implementation_imports -// ignore_for_file: invalid_use_of_visible_for_testing_member -// ignore_for_file: prefer_const_constructors -// ignore_for_file: unnecessary_parenthesis -// ignore_for_file: camel_case_types -// ignore_for_file: subtype_of_sealed_class - -class _FakeTypeChecker_0 extends _i1.SmartFake implements _i2.TypeChecker { - _FakeTypeChecker_0( - Object parent, - Invocation parentInvocation, - ) : super( - parent, - parentInvocation, - ); -} - -class _FakeDartObject_1 extends _i1.SmartFake implements _i3.DartObject { - _FakeDartObject_1( - Object parent, - Invocation parentInvocation, - ) : super( - parent, - parentInvocation, - ); -} - -class _FakeSymbol_2 extends _i1.SmartFake implements Symbol { - _FakeSymbol_2( - Object parent, - Invocation parentInvocation, - ) : super( - parent, - parentInvocation, - ); -} - -class _FakeDartType_3 extends _i1.SmartFake implements _i4.DartType { - _FakeDartType_3( - Object parent, - Invocation parentInvocation, - ) : super( - parent, - parentInvocation, - ); -} - -class _FakeConstantReader_4 extends _i1.SmartFake - implements _i2.ConstantReader { - _FakeConstantReader_4( - Object parent, - Invocation parentInvocation, - ) : super( - parent, - parentInvocation, - ); -} - -class _FakeRevivable_5 extends _i1.SmartFake implements _i2.Revivable { - _FakeRevivable_5( - Object parent, - Invocation parentInvocation, - ) : super( - parent, - parentInvocation, - ); -} - -class _FakeAssetId_6 extends _i1.SmartFake implements _i5.AssetId { - _FakeAssetId_6( - Object parent, - Invocation parentInvocation, - ) : super( - parent, - parentInvocation, - ); -} - -class _FakeLibraryElement_7 extends _i1.SmartFake - implements _i6.LibraryElement { - _FakeLibraryElement_7( - Object parent, - Invocation parentInvocation, - ) : super( - parent, - parentInvocation, - ); -} - -class _FakeResolver_8 extends _i1.SmartFake implements _i5.Resolver { - _FakeResolver_8( - Object parent, - Invocation parentInvocation, - ) : super( - parent, - parentInvocation, - ); -} - -class _FakePackageConfig_9 extends _i1.SmartFake implements _i7.PackageConfig { - _FakePackageConfig_9( - Object parent, - Invocation parentInvocation, - ) : super( - parent, - parentInvocation, - ); -} - -class _FakeFuture_10 extends _i1.SmartFake implements _i8.Future { - _FakeFuture_10( - Object parent, - Invocation parentInvocation, - ) : super( - parent, - parentInvocation, - ); -} - -class _FakeDigest_11 extends _i1.SmartFake implements _i9.Digest { - _FakeDigest_11( - Object parent, - Invocation parentInvocation, - ) : super( - parent, - parentInvocation, - ); -} - -class _FakeMethodElement_12 extends _i1.SmartFake implements _i6.MethodElement { - _FakeMethodElement_12( - Object parent, - Invocation parentInvocation, - ) : super( - parent, - parentInvocation, - ); -} - -class _FakeElement_13 extends _i1.SmartFake implements _i6.Element { - _FakeElement_13( - Object parent, - Invocation parentInvocation, - ) : super( - parent, - parentInvocation, - ); -} - -class _FakeAnalysisContext_14 extends _i1.SmartFake - implements _i10.AnalysisContext { - _FakeAnalysisContext_14( - Object parent, - Invocation parentInvocation, - ) : super( - parent, - parentInvocation, - ); -} - -class _FakeElementKind_15 extends _i1.SmartFake implements _i6.ElementKind { - _FakeElementKind_15( - Object parent, - Invocation parentInvocation, - ) : super( - parent, - parentInvocation, - ); -} - -class _FakeSource_16 extends _i1.SmartFake implements _i11.Source { - _FakeSource_16( - Object parent, - Invocation parentInvocation, - ) : super( - parent, - parentInvocation, - ); -} - -class _FakeFunctionType_17 extends _i1.SmartFake implements _i4.FunctionType { - _FakeFunctionType_17( - Object parent, - Invocation parentInvocation, - ) : super( - parent, - parentInvocation, - ); -} - -class _FakeAugmentedClassElement_18 extends _i1.SmartFake - implements _i6.AugmentedClassElement { - _FakeAugmentedClassElement_18( - Object parent, - Invocation parentInvocation, - ) : super( - parent, - parentInvocation, - ); -} - -class _FakeCompilationUnitElement_19 extends _i1.SmartFake - implements _i6.CompilationUnitElement { - _FakeCompilationUnitElement_19( - Object parent, - Invocation parentInvocation, - ) : super( - parent, - parentInvocation, - ); -} - -class _FakeInterfaceType_20 extends _i1.SmartFake implements _i4.InterfaceType { - _FakeInterfaceType_20( - Object parent, - Invocation parentInvocation, - ) : super( - parent, - parentInvocation, - ); -} - -class _FakeIOSink_21 extends _i1.SmartFake implements _i12.IOSink { - _FakeIOSink_21( - Object parent, - Invocation parentInvocation, - ) : super( - parent, - parentInvocation, - ); -} - -/// A class which mocks [OpenapiGenerator]. -/// -/// See the documentation for Mockito's code generation for more information. -class MockOpenapiGenerator extends _i1.Mock implements _i13.OpenapiGenerator { - @override - bool get testMode => (super.noSuchMethod( - Invocation.getter(#testMode), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - _i2.TypeChecker get typeChecker => (super.noSuchMethod( - Invocation.getter(#typeChecker), - returnValue: _FakeTypeChecker_0( - this, - Invocation.getter(#typeChecker), - ), - returnValueForMissingStub: _FakeTypeChecker_0( - this, - Invocation.getter(#typeChecker), - ), - ) as _i2.TypeChecker); - @override - _i8.FutureOr generateForAnnotatedElement( - _i6.Element? element, - _i2.ConstantReader? annotations, - _i5.BuildStep? buildStep, - ) => - (super.noSuchMethod( - Invocation.method( - #generateForAnnotatedElement, - [ - element, - annotations, - buildStep, - ], - ), - returnValue: _i8.Future.value(''), - returnValueForMissingStub: _i8.Future.value(''), - ) as _i8.FutureOr); - @override - _i8.Future runOpenApiJar( - {required _i14.GeneratorArguments? arguments}) => - (super.noSuchMethod( - Invocation.method( - #runOpenApiJar, - [], - {#arguments: arguments}, - ), - returnValue: _i8.Future.value(), - returnValueForMissingStub: _i8.Future.value(), - ) as _i8.Future); - @override - _i8.FutureOr generatorV2({ - required _i14.GeneratorArguments? args, - required String? baseCommand, - required String? annotatedPath, - }) => - (super.noSuchMethod( - Invocation.method( - #generatorV2, - [], - { - #args: args, - #baseCommand: baseCommand, - #annotatedPath: annotatedPath, - }, - ), - returnValue: _i8.Future.value(''), - returnValueForMissingStub: _i8.Future.value(''), - ) as _i8.FutureOr); - @override - _i8.FutureOr hasDiff({required _i14.GeneratorArguments? args}) => - (super.noSuchMethod( - Invocation.method( - #hasDiff, - [], - {#args: args}, - ), - returnValue: _i8.Future.value(false), - returnValueForMissingStub: _i8.Future.value(false), - ) as _i8.FutureOr); - @override - _i8.FutureOr generateSources({ - required String? baseCommand, - required _i14.GeneratorArguments? args, - }) => - (super.noSuchMethod( - Invocation.method( - #generateSources, - [], - { - #baseCommand: baseCommand, - #args: args, - }, - ), - returnValueForMissingStub: null, - ) as _i8.FutureOr); - @override - _i8.Future runSourceGen({ - required String? baseCommand, - required _i14.GeneratorArguments? args, - }) => - (super.noSuchMethod( - Invocation.method( - #runSourceGen, - [], - { - #baseCommand: baseCommand, - #args: args, - }, - ), - returnValue: _i8.Future.value(), - returnValueForMissingStub: _i8.Future.value(), - ) as _i8.Future); - @override - _i8.FutureOr fetchDependencies({ - required String? baseCommand, - required _i14.GeneratorArguments? args, - }) => - (super.noSuchMethod( - Invocation.method( - #fetchDependencies, - [], - { - #baseCommand: baseCommand, - #args: args, - }, - ), - returnValueForMissingStub: null, - ) as _i8.FutureOr); - @override - _i8.Future updateCachedSpec({ - required Map? updatedSpec, - required String? cachedPath, - }) => - (super.noSuchMethod( - Invocation.method( - #updateCachedSpec, - [], - { - #updatedSpec: updatedSpec, - #cachedPath: cachedPath, - }, - ), - returnValue: _i8.Future.value(), - returnValueForMissingStub: _i8.Future.value(), - ) as _i8.Future); - @override - _i8.Future updateAnnotatedFile({required dynamic annotatedPath}) => - (super.noSuchMethod( - Invocation.method( - #updateAnnotatedFile, - [], - {#annotatedPath: annotatedPath}, - ), - returnValue: _i8.Future.value(), - returnValueForMissingStub: _i8.Future.value(), - ) as _i8.Future); - @override - _i8.Future formatCode({required _i14.GeneratorArguments? args}) => - (super.noSuchMethod( - Invocation.method( - #formatCode, - [], - {#args: args}, - ), - returnValue: _i8.Future.value(), - returnValueForMissingStub: _i8.Future.value(), - ) as _i8.Future); - @override - _i8.Future<_i12.ProcessResult> runExternalProcess({ - required _i15.Command? command, - required String? workingDirectory, - }) => - (super.noSuchMethod( - Invocation.method( - #runExternalProcess, - [], - { - #command: command, - #workingDirectory: workingDirectory, - }, - ), - returnValue: _i8.Future<_i12.ProcessResult>.value( - _i16.dummyValue<_i12.ProcessResult>( - this, - Invocation.method( - #runExternalProcess, - [], - { - #command: command, - #workingDirectory: workingDirectory, - }, - ), - )), - returnValueForMissingStub: _i8.Future<_i12.ProcessResult>.value( - _i16.dummyValue<_i12.ProcessResult>( - this, - Invocation.method( - #runExternalProcess, - [], - { - #command: command, - #workingDirectory: workingDirectory, - }, - ), - )), - ) as _i8.Future<_i12.ProcessResult>); - @override - _i8.FutureOr generate( - _i2.LibraryReader? library, - _i5.BuildStep? buildStep, - ) => - (super.noSuchMethod( - Invocation.method( - #generate, - [ - library, - buildStep, - ], - ), - returnValue: _i8.Future.value(''), - returnValueForMissingStub: _i8.Future.value(''), - ) as _i8.FutureOr); -} - -/// A class which mocks [ConstantReader]. -/// -/// See the documentation for Mockito's code generation for more information. -class MockConstantReader extends _i1.Mock implements _i2.ConstantReader { - @override - bool get isLiteral => (super.noSuchMethod( - Invocation.getter(#isLiteral), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - _i3.DartObject get objectValue => (super.noSuchMethod( - Invocation.getter(#objectValue), - returnValue: _FakeDartObject_1( - this, - Invocation.getter(#objectValue), - ), - returnValueForMissingStub: _FakeDartObject_1( - this, - Invocation.getter(#objectValue), - ), - ) as _i3.DartObject); - @override - bool get isNull => (super.noSuchMethod( - Invocation.getter(#isNull), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get isBool => (super.noSuchMethod( - Invocation.getter(#isBool), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get boolValue => (super.noSuchMethod( - Invocation.getter(#boolValue), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get isInt => (super.noSuchMethod( - Invocation.getter(#isInt), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - int get intValue => (super.noSuchMethod( - Invocation.getter(#intValue), - returnValue: 0, - returnValueForMissingStub: 0, - ) as int); - @override - bool get isDouble => (super.noSuchMethod( - Invocation.getter(#isDouble), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - double get doubleValue => (super.noSuchMethod( - Invocation.getter(#doubleValue), - returnValue: 0.0, - returnValueForMissingStub: 0.0, - ) as double); - @override - bool get isString => (super.noSuchMethod( - Invocation.getter(#isString), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - String get stringValue => (super.noSuchMethod( - Invocation.getter(#stringValue), - returnValue: '', - returnValueForMissingStub: '', - ) as String); - @override - bool get isSymbol => (super.noSuchMethod( - Invocation.getter(#isSymbol), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - Symbol get symbolValue => (super.noSuchMethod( - Invocation.getter(#symbolValue), - returnValue: _FakeSymbol_2( - this, - Invocation.getter(#symbolValue), - ), - returnValueForMissingStub: _FakeSymbol_2( - this, - Invocation.getter(#symbolValue), - ), - ) as Symbol); - @override - bool get isType => (super.noSuchMethod( - Invocation.getter(#isType), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - _i4.DartType get typeValue => (super.noSuchMethod( - Invocation.getter(#typeValue), - returnValue: _FakeDartType_3( - this, - Invocation.getter(#typeValue), - ), - returnValueForMissingStub: _FakeDartType_3( - this, - Invocation.getter(#typeValue), - ), - ) as _i4.DartType); - @override - bool get isMap => (super.noSuchMethod( - Invocation.getter(#isMap), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - Map<_i3.DartObject?, _i3.DartObject?> get mapValue => (super.noSuchMethod( - Invocation.getter(#mapValue), - returnValue: <_i3.DartObject?, _i3.DartObject?>{}, - returnValueForMissingStub: <_i3.DartObject?, _i3.DartObject?>{}, - ) as Map<_i3.DartObject?, _i3.DartObject?>); - @override - bool get isList => (super.noSuchMethod( - Invocation.getter(#isList), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - List<_i3.DartObject> get listValue => (super.noSuchMethod( - Invocation.getter(#listValue), - returnValue: <_i3.DartObject>[], - returnValueForMissingStub: <_i3.DartObject>[], - ) as List<_i3.DartObject>); - @override - bool get isSet => (super.noSuchMethod( - Invocation.getter(#isSet), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - Set<_i3.DartObject> get setValue => (super.noSuchMethod( - Invocation.getter(#setValue), - returnValue: <_i3.DartObject>{}, - returnValueForMissingStub: <_i3.DartObject>{}, - ) as Set<_i3.DartObject>); - @override - bool instanceOf(_i2.TypeChecker? checker) => (super.noSuchMethod( - Invocation.method( - #instanceOf, - [checker], - ), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - _i2.ConstantReader read(String? field) => (super.noSuchMethod( - Invocation.method( - #read, - [field], - ), - returnValue: _FakeConstantReader_4( - this, - Invocation.method( - #read, - [field], - ), - ), - returnValueForMissingStub: _FakeConstantReader_4( - this, - Invocation.method( - #read, - [field], - ), - ), - ) as _i2.ConstantReader); - @override - _i2.ConstantReader? peek(String? field) => (super.noSuchMethod( - Invocation.method( - #peek, - [field], - ), - returnValueForMissingStub: null, - ) as _i2.ConstantReader?); - @override - _i2.Revivable revive() => (super.noSuchMethod( - Invocation.method( - #revive, - [], - ), - returnValue: _FakeRevivable_5( - this, - Invocation.method( - #revive, - [], - ), - ), - returnValueForMissingStub: _FakeRevivable_5( - this, - Invocation.method( - #revive, - [], - ), - ), - ) as _i2.Revivable); -} - -/// A class which mocks [BuildStep]. -/// -/// See the documentation for Mockito's code generation for more information. -class MockBuildStep extends _i1.Mock implements _i5.BuildStep { - @override - _i5.AssetId get inputId => (super.noSuchMethod( - Invocation.getter(#inputId), - returnValue: _FakeAssetId_6( - this, - Invocation.getter(#inputId), - ), - returnValueForMissingStub: _FakeAssetId_6( - this, - Invocation.getter(#inputId), - ), - ) as _i5.AssetId); - @override - _i8.Future<_i6.LibraryElement> get inputLibrary => (super.noSuchMethod( - Invocation.getter(#inputLibrary), - returnValue: _i8.Future<_i6.LibraryElement>.value(_FakeLibraryElement_7( - this, - Invocation.getter(#inputLibrary), - )), - returnValueForMissingStub: - _i8.Future<_i6.LibraryElement>.value(_FakeLibraryElement_7( - this, - Invocation.getter(#inputLibrary), - )), - ) as _i8.Future<_i6.LibraryElement>); - @override - _i5.Resolver get resolver => (super.noSuchMethod( - Invocation.getter(#resolver), - returnValue: _FakeResolver_8( - this, - Invocation.getter(#resolver), - ), - returnValueForMissingStub: _FakeResolver_8( - this, - Invocation.getter(#resolver), - ), - ) as _i5.Resolver); - @override - Iterable<_i5.AssetId> get allowedOutputs => (super.noSuchMethod( - Invocation.getter(#allowedOutputs), - returnValue: <_i5.AssetId>[], - returnValueForMissingStub: <_i5.AssetId>[], - ) as Iterable<_i5.AssetId>); - @override - _i8.Future<_i7.PackageConfig> get packageConfig => (super.noSuchMethod( - Invocation.getter(#packageConfig), - returnValue: _i8.Future<_i7.PackageConfig>.value(_FakePackageConfig_9( - this, - Invocation.getter(#packageConfig), - )), - returnValueForMissingStub: - _i8.Future<_i7.PackageConfig>.value(_FakePackageConfig_9( - this, - Invocation.getter(#packageConfig), - )), - ) as _i8.Future<_i7.PackageConfig>); - @override - _i8.Future fetchResource(_i5.Resource? resource) => - (super.noSuchMethod( - Invocation.method( - #fetchResource, - [resource], - ), - returnValue: _i16.ifNotNull( - _i16.dummyValueOrNull( - this, - Invocation.method( - #fetchResource, - [resource], - ), - ), - (T v) => _i8.Future.value(v), - ) ?? - _FakeFuture_10( - this, - Invocation.method( - #fetchResource, - [resource], - ), - ), - returnValueForMissingStub: _i16.ifNotNull( - _i16.dummyValueOrNull( - this, - Invocation.method( - #fetchResource, - [resource], - ), - ), - (T v) => _i8.Future.value(v), - ) ?? - _FakeFuture_10( - this, - Invocation.method( - #fetchResource, - [resource], - ), - ), - ) as _i8.Future); - @override - _i8.Future writeAsBytes( - _i5.AssetId? id, - _i8.FutureOr>? bytes, - ) => - (super.noSuchMethod( - Invocation.method( - #writeAsBytes, - [ - id, - bytes, - ], - ), - returnValue: _i8.Future.value(), - returnValueForMissingStub: _i8.Future.value(), - ) as _i8.Future); - @override - _i8.Future writeAsString( - _i5.AssetId? id, - _i8.FutureOr? contents, { - _i17.Encoding? encoding = const _i17.Utf8Codec(), - }) => - (super.noSuchMethod( - Invocation.method( - #writeAsString, - [ - id, - contents, - ], - {#encoding: encoding}, - ), - returnValue: _i8.Future.value(), - returnValueForMissingStub: _i8.Future.value(), - ) as _i8.Future); - @override - T trackStage( - String? label, - T Function()? action, { - bool? isExternal = false, - }) => - (super.noSuchMethod( - Invocation.method( - #trackStage, - [ - label, - action, - ], - {#isExternal: isExternal}, - ), - returnValue: _i16.dummyValue( - this, - Invocation.method( - #trackStage, - [ - label, - action, - ], - {#isExternal: isExternal}, - ), - ), - returnValueForMissingStub: _i16.dummyValue( - this, - Invocation.method( - #trackStage, - [ - label, - action, - ], - {#isExternal: isExternal}, - ), - ), - ) as T); - @override - void reportUnusedAssets(Iterable<_i5.AssetId>? ids) => super.noSuchMethod( - Invocation.method( - #reportUnusedAssets, - [ids], - ), - returnValueForMissingStub: null, - ); - @override - _i8.Future> readAsBytes(_i5.AssetId? id) => (super.noSuchMethod( - Invocation.method( - #readAsBytes, - [id], - ), - returnValue: _i8.Future>.value([]), - returnValueForMissingStub: _i8.Future>.value([]), - ) as _i8.Future>); - @override - _i8.Future readAsString( - _i5.AssetId? id, { - _i17.Encoding? encoding = const _i17.Utf8Codec(), - }) => - (super.noSuchMethod( - Invocation.method( - #readAsString, - [id], - {#encoding: encoding}, - ), - returnValue: _i8.Future.value(''), - returnValueForMissingStub: _i8.Future.value(''), - ) as _i8.Future); - @override - _i8.Future canRead(_i5.AssetId? id) => (super.noSuchMethod( - Invocation.method( - #canRead, - [id], - ), - returnValue: _i8.Future.value(false), - returnValueForMissingStub: _i8.Future.value(false), - ) as _i8.Future); - @override - _i8.Stream<_i5.AssetId> findAssets(_i18.Glob? glob) => (super.noSuchMethod( - Invocation.method( - #findAssets, - [glob], - ), - returnValue: _i8.Stream<_i5.AssetId>.empty(), - returnValueForMissingStub: _i8.Stream<_i5.AssetId>.empty(), - ) as _i8.Stream<_i5.AssetId>); - @override - _i8.Future<_i9.Digest> digest(_i5.AssetId? id) => (super.noSuchMethod( - Invocation.method( - #digest, - [id], - ), - returnValue: _i8.Future<_i9.Digest>.value(_FakeDigest_11( - this, - Invocation.method( - #digest, - [id], - ), - )), - returnValueForMissingStub: _i8.Future<_i9.Digest>.value(_FakeDigest_11( - this, - Invocation.method( - #digest, - [id], - ), - )), - ) as _i8.Future<_i9.Digest>); -} - -/// A class which mocks [MethodElement]. -/// -/// See the documentation for Mockito's code generation for more information. -class MockMethodElement extends _i1.Mock implements _i6.MethodElement { - @override - _i6.MethodElement get declaration => (super.noSuchMethod( - Invocation.getter(#declaration), - returnValue: _FakeMethodElement_12( - this, - Invocation.getter(#declaration), - ), - returnValueForMissingStub: _FakeMethodElement_12( - this, - Invocation.getter(#declaration), - ), - ) as _i6.MethodElement); - @override - _i6.Element get enclosingElement => (super.noSuchMethod( - Invocation.getter(#enclosingElement), - returnValue: _FakeElement_13( - this, - Invocation.getter(#enclosingElement), - ), - returnValueForMissingStub: _FakeElement_13( - this, - Invocation.getter(#enclosingElement), - ), - ) as _i6.Element); - @override - _i6.Element get enclosingElement3 => (super.noSuchMethod( - Invocation.getter(#enclosingElement3), - returnValue: _FakeElement_13( - this, - Invocation.getter(#enclosingElement3), - ), - returnValueForMissingStub: _FakeElement_13( - this, - Invocation.getter(#enclosingElement3), - ), - ) as _i6.Element); - @override - bool get isStatic => (super.noSuchMethod( - Invocation.getter(#isStatic), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - List<_i6.Element> get children => (super.noSuchMethod( - Invocation.getter(#children), - returnValue: <_i6.Element>[], - returnValueForMissingStub: <_i6.Element>[], - ) as List<_i6.Element>); - @override - _i10.AnalysisContext get context => (super.noSuchMethod( - Invocation.getter(#context), - returnValue: _FakeAnalysisContext_14( - this, - Invocation.getter(#context), - ), - returnValueForMissingStub: _FakeAnalysisContext_14( - this, - Invocation.getter(#context), - ), - ) as _i10.AnalysisContext); - @override - String get displayName => (super.noSuchMethod( - Invocation.getter(#displayName), - returnValue: '', - returnValueForMissingStub: '', - ) as String); - @override - bool get hasAlwaysThrows => (super.noSuchMethod( - Invocation.getter(#hasAlwaysThrows), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasDeprecated => (super.noSuchMethod( - Invocation.getter(#hasDeprecated), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasDoNotStore => (super.noSuchMethod( - Invocation.getter(#hasDoNotStore), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasFactory => (super.noSuchMethod( - Invocation.getter(#hasFactory), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasInternal => (super.noSuchMethod( - Invocation.getter(#hasInternal), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasIsTest => (super.noSuchMethod( - Invocation.getter(#hasIsTest), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasIsTestGroup => (super.noSuchMethod( - Invocation.getter(#hasIsTestGroup), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasJS => (super.noSuchMethod( - Invocation.getter(#hasJS), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasLiteral => (super.noSuchMethod( - Invocation.getter(#hasLiteral), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasMustBeOverridden => (super.noSuchMethod( - Invocation.getter(#hasMustBeOverridden), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasMustCallSuper => (super.noSuchMethod( - Invocation.getter(#hasMustCallSuper), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasNonVirtual => (super.noSuchMethod( - Invocation.getter(#hasNonVirtual), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasOptionalTypeArgs => (super.noSuchMethod( - Invocation.getter(#hasOptionalTypeArgs), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasOverride => (super.noSuchMethod( - Invocation.getter(#hasOverride), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasProtected => (super.noSuchMethod( - Invocation.getter(#hasProtected), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasReopen => (super.noSuchMethod( - Invocation.getter(#hasReopen), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasRequired => (super.noSuchMethod( - Invocation.getter(#hasRequired), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasSealed => (super.noSuchMethod( - Invocation.getter(#hasSealed), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasUseResult => (super.noSuchMethod( - Invocation.getter(#hasUseResult), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasVisibleForOverriding => (super.noSuchMethod( - Invocation.getter(#hasVisibleForOverriding), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasVisibleForTemplate => (super.noSuchMethod( - Invocation.getter(#hasVisibleForTemplate), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasVisibleForTesting => (super.noSuchMethod( - Invocation.getter(#hasVisibleForTesting), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - int get id => (super.noSuchMethod( - Invocation.getter(#id), - returnValue: 0, - returnValueForMissingStub: 0, - ) as int); - @override - bool get isPrivate => (super.noSuchMethod( - Invocation.getter(#isPrivate), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get isPublic => (super.noSuchMethod( - Invocation.getter(#isPublic), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get isSynthetic => (super.noSuchMethod( - Invocation.getter(#isSynthetic), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - _i6.ElementKind get kind => (super.noSuchMethod( - Invocation.getter(#kind), - returnValue: _FakeElementKind_15( - this, - Invocation.getter(#kind), - ), - returnValueForMissingStub: _FakeElementKind_15( - this, - Invocation.getter(#kind), - ), - ) as _i6.ElementKind); - @override - _i6.LibraryElement get library => (super.noSuchMethod( - Invocation.getter(#library), - returnValue: _FakeLibraryElement_7( - this, - Invocation.getter(#library), - ), - returnValueForMissingStub: _FakeLibraryElement_7( - this, - Invocation.getter(#library), - ), - ) as _i6.LibraryElement); - @override - List<_i6.ElementAnnotation> get metadata => (super.noSuchMethod( - Invocation.getter(#metadata), - returnValue: <_i6.ElementAnnotation>[], - returnValueForMissingStub: <_i6.ElementAnnotation>[], - ) as List<_i6.ElementAnnotation>); - @override - String get name => (super.noSuchMethod( - Invocation.getter(#name), - returnValue: '', - returnValueForMissingStub: '', - ) as String); - @override - int get nameLength => (super.noSuchMethod( - Invocation.getter(#nameLength), - returnValue: 0, - returnValueForMissingStub: 0, - ) as int); - @override - int get nameOffset => (super.noSuchMethod( - Invocation.getter(#nameOffset), - returnValue: 0, - returnValueForMissingStub: 0, - ) as int); - @override - _i6.Element get nonSynthetic => (super.noSuchMethod( - Invocation.getter(#nonSynthetic), - returnValue: _FakeElement_13( - this, - Invocation.getter(#nonSynthetic), - ), - returnValueForMissingStub: _FakeElement_13( - this, - Invocation.getter(#nonSynthetic), - ), - ) as _i6.Element); - @override - _i11.Source get source => (super.noSuchMethod( - Invocation.getter(#source), - returnValue: _FakeSource_16( - this, - Invocation.getter(#source), - ), - returnValueForMissingStub: _FakeSource_16( - this, - Invocation.getter(#source), - ), - ) as _i11.Source); - @override - _i11.Source get librarySource => (super.noSuchMethod( - Invocation.getter(#librarySource), - returnValue: _FakeSource_16( - this, - Invocation.getter(#librarySource), - ), - returnValueForMissingStub: _FakeSource_16( - this, - Invocation.getter(#librarySource), - ), - ) as _i11.Source); - @override - bool get hasImplicitReturnType => (super.noSuchMethod( - Invocation.getter(#hasImplicitReturnType), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get isAbstract => (super.noSuchMethod( - Invocation.getter(#isAbstract), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get isAsynchronous => (super.noSuchMethod( - Invocation.getter(#isAsynchronous), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get isExternal => (super.noSuchMethod( - Invocation.getter(#isExternal), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get isGenerator => (super.noSuchMethod( - Invocation.getter(#isGenerator), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get isOperator => (super.noSuchMethod( - Invocation.getter(#isOperator), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get isSynchronous => (super.noSuchMethod( - Invocation.getter(#isSynchronous), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - List<_i6.ParameterElement> get parameters => (super.noSuchMethod( - Invocation.getter(#parameters), - returnValue: <_i6.ParameterElement>[], - returnValueForMissingStub: <_i6.ParameterElement>[], - ) as List<_i6.ParameterElement>); - @override - _i4.DartType get returnType => (super.noSuchMethod( - Invocation.getter(#returnType), - returnValue: _FakeDartType_3( - this, - Invocation.getter(#returnType), - ), - returnValueForMissingStub: _FakeDartType_3( - this, - Invocation.getter(#returnType), - ), - ) as _i4.DartType); - @override - _i4.FunctionType get type => (super.noSuchMethod( - Invocation.getter(#type), - returnValue: _FakeFunctionType_17( - this, - Invocation.getter(#type), - ), - returnValueForMissingStub: _FakeFunctionType_17( - this, - Invocation.getter(#type), - ), - ) as _i4.FunctionType); - @override - bool get isSimplyBounded => (super.noSuchMethod( - Invocation.getter(#isSimplyBounded), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - List<_i6.TypeParameterElement> get typeParameters => (super.noSuchMethod( - Invocation.getter(#typeParameters), - returnValue: <_i6.TypeParameterElement>[], - returnValueForMissingStub: <_i6.TypeParameterElement>[], - ) as List<_i6.TypeParameterElement>); - @override - T? accept(_i6.ElementVisitor? visitor) => (super.noSuchMethod( - Invocation.method( - #accept, - [visitor], - ), - returnValueForMissingStub: null, - ) as T?); - @override - String getDisplayString({ - required bool? withNullability, - bool? multiline = false, - }) => - (super.noSuchMethod( - Invocation.method( - #getDisplayString, - [], - { - #withNullability: withNullability, - #multiline: multiline, - }, - ), - returnValue: '', - returnValueForMissingStub: '', - ) as String); - @override - String getExtendedDisplayName(String? shortName) => (super.noSuchMethod( - Invocation.method( - #getExtendedDisplayName, - [shortName], - ), - returnValue: '', - returnValueForMissingStub: '', - ) as String); - @override - bool isAccessibleIn(_i6.LibraryElement? library) => (super.noSuchMethod( - Invocation.method( - #isAccessibleIn, - [library], - ), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool isAccessibleIn2(_i6.LibraryElement? library) => (super.noSuchMethod( - Invocation.method( - #isAccessibleIn2, - [library], - ), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - E? thisOrAncestorMatching( - bool Function(_i6.Element)? predicate) => - (super.noSuchMethod( - Invocation.method( - #thisOrAncestorMatching, - [predicate], - ), - returnValueForMissingStub: null, - ) as E?); - @override - void visitChildren(_i6.ElementVisitor? visitor) => - super.noSuchMethod( - Invocation.method( - #visitChildren, - [visitor], - ), - returnValueForMissingStub: null, - ); -} - -/// A class which mocks [ClassElement]. -/// -/// See the documentation for Mockito's code generation for more information. -class MockClassElement extends _i1.Mock implements _i6.ClassElement { - @override - _i6.AugmentedClassElement get augmented => (super.noSuchMethod( - Invocation.getter(#augmented), - returnValue: _FakeAugmentedClassElement_18( - this, - Invocation.getter(#augmented), - ), - returnValueForMissingStub: _FakeAugmentedClassElement_18( - this, - Invocation.getter(#augmented), - ), - ) as _i6.AugmentedClassElement); - @override - bool get hasNonFinalField => (super.noSuchMethod( - Invocation.getter(#hasNonFinalField), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get isAbstract => (super.noSuchMethod( - Invocation.getter(#isAbstract), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get isBase => (super.noSuchMethod( - Invocation.getter(#isBase), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get isConstructable => (super.noSuchMethod( - Invocation.getter(#isConstructable), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get isDartCoreEnum => (super.noSuchMethod( - Invocation.getter(#isDartCoreEnum), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get isDartCoreObject => (super.noSuchMethod( - Invocation.getter(#isDartCoreObject), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get isExhaustive => (super.noSuchMethod( - Invocation.getter(#isExhaustive), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get isFinal => (super.noSuchMethod( - Invocation.getter(#isFinal), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get isInterface => (super.noSuchMethod( - Invocation.getter(#isInterface), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get isMixinApplication => (super.noSuchMethod( - Invocation.getter(#isMixinApplication), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get isMixinClass => (super.noSuchMethod( - Invocation.getter(#isMixinClass), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get isSealed => (super.noSuchMethod( - Invocation.getter(#isSealed), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get isValidMixin => (super.noSuchMethod( - Invocation.getter(#isValidMixin), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - List<_i4.InterfaceType> get superclassConstraints => (super.noSuchMethod( - Invocation.getter(#superclassConstraints), - returnValue: <_i4.InterfaceType>[], - returnValueForMissingStub: <_i4.InterfaceType>[], - ) as List<_i4.InterfaceType>); - @override - List<_i6.PropertyAccessorElement> get accessors => (super.noSuchMethod( - Invocation.getter(#accessors), - returnValue: <_i6.PropertyAccessorElement>[], - returnValueForMissingStub: <_i6.PropertyAccessorElement>[], - ) as List<_i6.PropertyAccessorElement>); - @override - List<_i6.ConstructorElement> get constructors => (super.noSuchMethod( - Invocation.getter(#constructors), - returnValue: <_i6.ConstructorElement>[], - returnValueForMissingStub: <_i6.ConstructorElement>[], - ) as List<_i6.ConstructorElement>); - @override - _i6.CompilationUnitElement get enclosingElement => (super.noSuchMethod( - Invocation.getter(#enclosingElement), - returnValue: _FakeCompilationUnitElement_19( - this, - Invocation.getter(#enclosingElement), - ), - returnValueForMissingStub: _FakeCompilationUnitElement_19( - this, - Invocation.getter(#enclosingElement), - ), - ) as _i6.CompilationUnitElement); - @override - _i6.CompilationUnitElement get enclosingElement3 => (super.noSuchMethod( - Invocation.getter(#enclosingElement3), - returnValue: _FakeCompilationUnitElement_19( - this, - Invocation.getter(#enclosingElement3), - ), - returnValueForMissingStub: _FakeCompilationUnitElement_19( - this, - Invocation.getter(#enclosingElement3), - ), - ) as _i6.CompilationUnitElement); - @override - List<_i6.FieldElement> get fields => (super.noSuchMethod( - Invocation.getter(#fields), - returnValue: <_i6.FieldElement>[], - returnValueForMissingStub: <_i6.FieldElement>[], - ) as List<_i6.FieldElement>); - @override - List<_i4.InterfaceType> get interfaces => (super.noSuchMethod( - Invocation.getter(#interfaces), - returnValue: <_i4.InterfaceType>[], - returnValueForMissingStub: <_i4.InterfaceType>[], - ) as List<_i4.InterfaceType>); - @override - List<_i6.MethodElement> get methods => (super.noSuchMethod( - Invocation.getter(#methods), - returnValue: <_i6.MethodElement>[], - returnValueForMissingStub: <_i6.MethodElement>[], - ) as List<_i6.MethodElement>); - @override - List<_i4.InterfaceType> get mixins => (super.noSuchMethod( - Invocation.getter(#mixins), - returnValue: <_i4.InterfaceType>[], - returnValueForMissingStub: <_i4.InterfaceType>[], - ) as List<_i4.InterfaceType>); - @override - String get name => (super.noSuchMethod( - Invocation.getter(#name), - returnValue: '', - returnValueForMissingStub: '', - ) as String); - @override - bool get isSimplyBounded => (super.noSuchMethod( - Invocation.getter(#isSimplyBounded), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - List<_i6.TypeParameterElement> get typeParameters => (super.noSuchMethod( - Invocation.getter(#typeParameters), - returnValue: <_i6.TypeParameterElement>[], - returnValueForMissingStub: <_i6.TypeParameterElement>[], - ) as List<_i6.TypeParameterElement>); - @override - _i6.Element get declaration => (super.noSuchMethod( - Invocation.getter(#declaration), - returnValue: _FakeElement_13( - this, - Invocation.getter(#declaration), - ), - returnValueForMissingStub: _FakeElement_13( - this, - Invocation.getter(#declaration), - ), - ) as _i6.Element); - @override - _i6.LibraryElement get library => (super.noSuchMethod( - Invocation.getter(#library), - returnValue: _FakeLibraryElement_7( - this, - Invocation.getter(#library), - ), - returnValueForMissingStub: _FakeLibraryElement_7( - this, - Invocation.getter(#library), - ), - ) as _i6.LibraryElement); - @override - _i11.Source get librarySource => (super.noSuchMethod( - Invocation.getter(#librarySource), - returnValue: _FakeSource_16( - this, - Invocation.getter(#librarySource), - ), - returnValueForMissingStub: _FakeSource_16( - this, - Invocation.getter(#librarySource), - ), - ) as _i11.Source); - @override - _i11.Source get source => (super.noSuchMethod( - Invocation.getter(#source), - returnValue: _FakeSource_16( - this, - Invocation.getter(#source), - ), - returnValueForMissingStub: _FakeSource_16( - this, - Invocation.getter(#source), - ), - ) as _i11.Source); - @override - List<_i6.Element> get children => (super.noSuchMethod( - Invocation.getter(#children), - returnValue: <_i6.Element>[], - returnValueForMissingStub: <_i6.Element>[], - ) as List<_i6.Element>); - @override - _i10.AnalysisContext get context => (super.noSuchMethod( - Invocation.getter(#context), - returnValue: _FakeAnalysisContext_14( - this, - Invocation.getter(#context), - ), - returnValueForMissingStub: _FakeAnalysisContext_14( - this, - Invocation.getter(#context), - ), - ) as _i10.AnalysisContext); - @override - String get displayName => (super.noSuchMethod( - Invocation.getter(#displayName), - returnValue: '', - returnValueForMissingStub: '', - ) as String); - @override - bool get hasAlwaysThrows => (super.noSuchMethod( - Invocation.getter(#hasAlwaysThrows), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasDeprecated => (super.noSuchMethod( - Invocation.getter(#hasDeprecated), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasDoNotStore => (super.noSuchMethod( - Invocation.getter(#hasDoNotStore), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasFactory => (super.noSuchMethod( - Invocation.getter(#hasFactory), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasInternal => (super.noSuchMethod( - Invocation.getter(#hasInternal), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasIsTest => (super.noSuchMethod( - Invocation.getter(#hasIsTest), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasIsTestGroup => (super.noSuchMethod( - Invocation.getter(#hasIsTestGroup), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasJS => (super.noSuchMethod( - Invocation.getter(#hasJS), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasLiteral => (super.noSuchMethod( - Invocation.getter(#hasLiteral), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasMustBeOverridden => (super.noSuchMethod( - Invocation.getter(#hasMustBeOverridden), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasMustCallSuper => (super.noSuchMethod( - Invocation.getter(#hasMustCallSuper), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasNonVirtual => (super.noSuchMethod( - Invocation.getter(#hasNonVirtual), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasOptionalTypeArgs => (super.noSuchMethod( - Invocation.getter(#hasOptionalTypeArgs), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasOverride => (super.noSuchMethod( - Invocation.getter(#hasOverride), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasProtected => (super.noSuchMethod( - Invocation.getter(#hasProtected), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasReopen => (super.noSuchMethod( - Invocation.getter(#hasReopen), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasRequired => (super.noSuchMethod( - Invocation.getter(#hasRequired), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasSealed => (super.noSuchMethod( - Invocation.getter(#hasSealed), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasUseResult => (super.noSuchMethod( - Invocation.getter(#hasUseResult), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasVisibleForOverriding => (super.noSuchMethod( - Invocation.getter(#hasVisibleForOverriding), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasVisibleForTemplate => (super.noSuchMethod( - Invocation.getter(#hasVisibleForTemplate), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get hasVisibleForTesting => (super.noSuchMethod( - Invocation.getter(#hasVisibleForTesting), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - int get id => (super.noSuchMethod( - Invocation.getter(#id), - returnValue: 0, - returnValueForMissingStub: 0, - ) as int); - @override - bool get isPrivate => (super.noSuchMethod( - Invocation.getter(#isPrivate), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get isPublic => (super.noSuchMethod( - Invocation.getter(#isPublic), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool get isSynthetic => (super.noSuchMethod( - Invocation.getter(#isSynthetic), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - _i6.ElementKind get kind => (super.noSuchMethod( - Invocation.getter(#kind), - returnValue: _FakeElementKind_15( - this, - Invocation.getter(#kind), - ), - returnValueForMissingStub: _FakeElementKind_15( - this, - Invocation.getter(#kind), - ), - ) as _i6.ElementKind); - @override - List<_i6.ElementAnnotation> get metadata => (super.noSuchMethod( - Invocation.getter(#metadata), - returnValue: <_i6.ElementAnnotation>[], - returnValueForMissingStub: <_i6.ElementAnnotation>[], - ) as List<_i6.ElementAnnotation>); - @override - int get nameLength => (super.noSuchMethod( - Invocation.getter(#nameLength), - returnValue: 0, - returnValueForMissingStub: 0, - ) as int); - @override - int get nameOffset => (super.noSuchMethod( - Invocation.getter(#nameOffset), - returnValue: 0, - returnValueForMissingStub: 0, - ) as int); - @override - _i6.Element get nonSynthetic => (super.noSuchMethod( - Invocation.getter(#nonSynthetic), - returnValue: _FakeElement_13( - this, - Invocation.getter(#nonSynthetic), - ), - returnValueForMissingStub: _FakeElement_13( - this, - Invocation.getter(#nonSynthetic), - ), - ) as _i6.Element); - @override - List<_i4.InterfaceType> get allSupertypes => (super.noSuchMethod( - Invocation.getter(#allSupertypes), - returnValue: <_i4.InterfaceType>[], - returnValueForMissingStub: <_i4.InterfaceType>[], - ) as List<_i4.InterfaceType>); - @override - _i4.InterfaceType get thisType => (super.noSuchMethod( - Invocation.getter(#thisType), - returnValue: _FakeInterfaceType_20( - this, - Invocation.getter(#thisType), - ), - returnValueForMissingStub: _FakeInterfaceType_20( - this, - Invocation.getter(#thisType), - ), - ) as _i4.InterfaceType); - @override - bool isExtendableIn(_i6.LibraryElement? library) => (super.noSuchMethod( - Invocation.method( - #isExtendableIn, - [library], - ), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool isImplementableIn(_i6.LibraryElement? library) => (super.noSuchMethod( - Invocation.method( - #isImplementableIn, - [library], - ), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool isMixableIn(_i6.LibraryElement? library) => (super.noSuchMethod( - Invocation.method( - #isMixableIn, - [library], - ), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - T? accept(_i6.ElementVisitor? visitor) => (super.noSuchMethod( - Invocation.method( - #accept, - [visitor], - ), - returnValueForMissingStub: null, - ) as T?); - @override - String getDisplayString({ - required bool? withNullability, - bool? multiline = false, - }) => - (super.noSuchMethod( - Invocation.method( - #getDisplayString, - [], - { - #withNullability: withNullability, - #multiline: multiline, - }, - ), - returnValue: '', - returnValueForMissingStub: '', - ) as String); - @override - String getExtendedDisplayName(String? shortName) => (super.noSuchMethod( - Invocation.method( - #getExtendedDisplayName, - [shortName], - ), - returnValue: '', - returnValueForMissingStub: '', - ) as String); - @override - bool isAccessibleIn(_i6.LibraryElement? library) => (super.noSuchMethod( - Invocation.method( - #isAccessibleIn, - [library], - ), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - bool isAccessibleIn2(_i6.LibraryElement? library) => (super.noSuchMethod( - Invocation.method( - #isAccessibleIn2, - [library], - ), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); - @override - E? thisOrAncestorMatching( - bool Function(_i6.Element)? predicate) => - (super.noSuchMethod( - Invocation.method( - #thisOrAncestorMatching, - [predicate], - ), - returnValueForMissingStub: null, - ) as E?); - @override - void visitChildren(_i6.ElementVisitor? visitor) => - super.noSuchMethod( - Invocation.method( - #visitChildren, - [visitor], - ), - returnValueForMissingStub: null, - ); - @override - _i6.FieldElement? getField(String? name) => (super.noSuchMethod( - Invocation.method( - #getField, - [name], - ), - returnValueForMissingStub: null, - ) as _i6.FieldElement?); - @override - _i6.PropertyAccessorElement? getGetter(String? name) => (super.noSuchMethod( - Invocation.method( - #getGetter, - [name], - ), - returnValueForMissingStub: null, - ) as _i6.PropertyAccessorElement?); - @override - _i6.MethodElement? getMethod(String? name) => (super.noSuchMethod( - Invocation.method( - #getMethod, - [name], - ), - returnValueForMissingStub: null, - ) as _i6.MethodElement?); - @override - _i6.ConstructorElement? getNamedConstructor(String? name) => - (super.noSuchMethod( - Invocation.method( - #getNamedConstructor, - [name], - ), - returnValueForMissingStub: null, - ) as _i6.ConstructorElement?); - @override - _i6.PropertyAccessorElement? getSetter(String? name) => (super.noSuchMethod( - Invocation.method( - #getSetter, - [name], - ), - returnValueForMissingStub: null, - ) as _i6.PropertyAccessorElement?); - @override - _i4.InterfaceType instantiate({ - required List<_i4.DartType>? typeArguments, - required _i19.NullabilitySuffix? nullabilitySuffix, - }) => - (super.noSuchMethod( - Invocation.method( - #instantiate, - [], - { - #typeArguments: typeArguments, - #nullabilitySuffix: nullabilitySuffix, - }, - ), - returnValue: _FakeInterfaceType_20( - this, - Invocation.method( - #instantiate, - [], - { - #typeArguments: typeArguments, - #nullabilitySuffix: nullabilitySuffix, - }, - ), - ), - returnValueForMissingStub: _FakeInterfaceType_20( - this, - Invocation.method( - #instantiate, - [], - { - #typeArguments: typeArguments, - #nullabilitySuffix: nullabilitySuffix, - }, - ), - ), - ) as _i4.InterfaceType); - @override - _i6.MethodElement? lookUpConcreteMethod( - String? methodName, - _i6.LibraryElement? library, - ) => - (super.noSuchMethod( - Invocation.method( - #lookUpConcreteMethod, - [ - methodName, - library, - ], - ), - returnValueForMissingStub: null, - ) as _i6.MethodElement?); - @override - _i6.PropertyAccessorElement? lookUpGetter( - String? getterName, - _i6.LibraryElement? library, - ) => - (super.noSuchMethod( - Invocation.method( - #lookUpGetter, - [ - getterName, - library, - ], - ), - returnValueForMissingStub: null, - ) as _i6.PropertyAccessorElement?); - @override - _i6.PropertyAccessorElement? lookUpInheritedConcreteGetter( - String? getterName, - _i6.LibraryElement? library, - ) => - (super.noSuchMethod( - Invocation.method( - #lookUpInheritedConcreteGetter, - [ - getterName, - library, - ], - ), - returnValueForMissingStub: null, - ) as _i6.PropertyAccessorElement?); - @override - _i6.MethodElement? lookUpInheritedConcreteMethod( - String? methodName, - _i6.LibraryElement? library, - ) => - (super.noSuchMethod( - Invocation.method( - #lookUpInheritedConcreteMethod, - [ - methodName, - library, - ], - ), - returnValueForMissingStub: null, - ) as _i6.MethodElement?); - @override - _i6.PropertyAccessorElement? lookUpInheritedConcreteSetter( - String? setterName, - _i6.LibraryElement? library, - ) => - (super.noSuchMethod( - Invocation.method( - #lookUpInheritedConcreteSetter, - [ - setterName, - library, - ], - ), - returnValueForMissingStub: null, - ) as _i6.PropertyAccessorElement?); - @override - _i6.MethodElement? lookUpInheritedMethod( - String? methodName, - _i6.LibraryElement? library, - ) => - (super.noSuchMethod( - Invocation.method( - #lookUpInheritedMethod, - [ - methodName, - library, - ], - ), - returnValueForMissingStub: null, - ) as _i6.MethodElement?); - @override - _i6.MethodElement? lookUpMethod( - String? methodName, - _i6.LibraryElement? library, - ) => - (super.noSuchMethod( - Invocation.method( - #lookUpMethod, - [ - methodName, - library, - ], - ), - returnValueForMissingStub: null, - ) as _i6.MethodElement?); - @override - _i6.PropertyAccessorElement? lookUpSetter( - String? setterName, - _i6.LibraryElement? library, - ) => - (super.noSuchMethod( - Invocation.method( - #lookUpSetter, - [ - setterName, - library, - ], - ), - returnValueForMissingStub: null, - ) as _i6.PropertyAccessorElement?); -} - -/// A class which mocks [Process]. -/// -/// See the documentation for Mockito's code generation for more information. -class MockProcess extends _i1.Mock implements _i12.Process { - @override - _i8.Future get exitCode => (super.noSuchMethod( - Invocation.getter(#exitCode), - returnValue: _i8.Future.value(0), - returnValueForMissingStub: _i8.Future.value(0), - ) as _i8.Future); - @override - _i8.Stream> get stdout => (super.noSuchMethod( - Invocation.getter(#stdout), - returnValue: _i8.Stream>.empty(), - returnValueForMissingStub: _i8.Stream>.empty(), - ) as _i8.Stream>); - @override - _i8.Stream> get stderr => (super.noSuchMethod( - Invocation.getter(#stderr), - returnValue: _i8.Stream>.empty(), - returnValueForMissingStub: _i8.Stream>.empty(), - ) as _i8.Stream>); - @override - _i12.IOSink get stdin => (super.noSuchMethod( - Invocation.getter(#stdin), - returnValue: _FakeIOSink_21( - this, - Invocation.getter(#stdin), - ), - returnValueForMissingStub: _FakeIOSink_21( - this, - Invocation.getter(#stdin), - ), - ) as _i12.IOSink); - @override - int get pid => (super.noSuchMethod( - Invocation.getter(#pid), - returnValue: 0, - returnValueForMissingStub: 0, - ) as int); - @override - bool kill([_i12.ProcessSignal? signal = _i12.ProcessSignal.sigterm]) => - (super.noSuchMethod( - Invocation.method( - #kill, - [signal], - ), - returnValue: false, - returnValueForMissingStub: false, - ) as bool); -} diff --git a/openapi-generator/test/specs/localstack/cache/machine.json b/openapi-generator/test/specs/localstack/cache/machine.json deleted file mode 100644 index ad66b14..0000000 --- a/openapi-generator/test/specs/localstack/cache/machine.json +++ /dev/null @@ -1 +0,0 @@ -{"machine_id": "gen_e5a2b64d-fee"} \ No newline at end of file diff --git a/openapi-generator/test/specs/localstack/cache/server.test.pem b/openapi-generator/test/specs/localstack/cache/server.test.pem deleted file mode 100644 index 13cc7f6..0000000 --- a/openapi-generator/test/specs/localstack/cache/server.test.pem +++ /dev/null @@ -1,125 +0,0 @@ ------BEGIN PRIVATE KEY----- -MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC265jVO5QVVLr3 -rrAcmEvitwLMzEu88nyejp8Z48A8HhL5HdXCnvVStOwzvO38J9hFieRFrqi1jaTg -04QXRCSvBG4Y4lRkXNFGwnmI+K+/U7Ol8ZZGxX3OokHmqUeiseDk/4WrWotCEuow -x0+ZMaGx//xXq2W5DhQweBqPq5/jbxl1/Q92tHnp8hYCrBZKlmclgEmSiXf8Y/hT -Ft3tA/7M3YaWMBG2jPN6U3FAFaCgiFWjhDzFpw08TuE8th47Inlbs6M8OdHlje13 -29CDj19KACT9VaD5ehCWXWQU4zcIvG/c2PLWaGirdkPPGDFh1RvU6oN5fti499Oa -uvLu3f5RAgMBAAECggEABKQ/0ZFcdZob0HMnVuJqcotQT+ATP+0rSl62HNMRqrTc -qGOga/raoMmkgL+XjmF4dHNGTppa/5hjiaz0Wh7Ji4NiQ9FicNWGHfSLXvVoiENY -eKqDtLIIOjkV0QOUpMU8vrLZMnrus7OFK82y8GE5CCpFvffEcgiwbHZvvhuNyBib -lvTziO3Vv5fJ99rD4/7wz/1d0Jcwb/7xozYfSStWeC6/RZMNMHOjCX4zHL0z1ry/ -Sgk5YZ1kkl9PCZGaiA7aQ/eH5rpxVpuM6aIsvNwdaFr4E12onMiog2ldOEtFbZVG -WQTWsILjVj8MK9fI1aHZMMGcfXaCuy8+3p+KhMhRzQKBgQDsvzwfeBUgjQ77M37A -lRdTZHspeaxjKQMr1vOKXOawxzr7JIQ01X0bgHC/wsS5lX259/9giBnadU+/HjuY -vxZXrrvtmdOFwShe3QypXgaft3wCLan4Df/9N7wRvYyCSJSBhvc0tSdX46u63rdx -k9VgYE73SAkjpq1riijxFvjwmwKBgQDFy8KOG6jxY2x8Tq3prkmJOEuBZJnOSxVs -3XbWrH9D75afGULCUwDWG96ZBc+otQ2uyrCDwCBVwe9eU/NZDGH6wcfa2P6vu5Tj -28ICz9Aie4V0gEdy+SK/J4n6zXzs9e0jF1qhIrRjlCma0A6/5PwQpPmQ9DEsuoyX -f380cHkNgwKBgQCj5EtB2cZ+b0hUvDReK5gnQeNFNhcR2l14puiX+3I0JOf+3iur -y7M9K7Bh//piI0wTRsyCzhVft2CKhOpq9rYH403z0U6uRKam7U4LnazmOoZdl7EX -qNFzQXcvrNGti4NLG9zcnx/qZxEGX5IMzXOksWdZJoQ1KvjY/p8TL30MSwKBgAdO -iKhhQzNvndFVwrzwME0+ZCOqiLgDNA5qe/pgMu9aiXDlKP8uu8gtDWMPwOUVkyTS -3gRv84HXgTU12rZ+a5wszmo6O+ZYAp8MPjWGYcT0VTDBkGIh6/OtzT4TmzrRtunl -8fYj5xAKqCLM7s6N8fXXclS1gJ+LYKg0EInqYb5rAoGANrkOuxR9EuQJSyxPqYxI -ZujvPlBFZP0YdNkEBsgBRczee0w8W8HE9Ry4bm/r7A0ZGXEffqAEN9fqbtTpCgoN -PUGUMeyF3b9AMysrMf5gV+8VMvTcdxGrcwGile335p8dUJv7HzkCKWwZ8DBdQNvJ -fwFn4LJthOKDPZ7G9OTYAwc= ------END PRIVATE KEY----- ------BEGIN CERTIFICATE----- -MIIGWTCCBUGgAwIBAgISA8x1EBwVQKws8CsVwKOtHxMTMA0GCSqGSIb3DQEBCwUA -MDIxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1MZXQncyBFbmNyeXB0MQswCQYDVQQD -EwJSMzAeFw0yMzA2MjQyMDA2MjBaFw0yMzA5MjIyMDA2MTlaMCUxIzAhBgNVBAMT -GmxvY2FsaG9zdC5sb2NhbHN0YWNrLmNsb3VkMIIBIjANBgkqhkiG9w0BAQEFAAOC -AQ8AMIIBCgKCAQEAtuuY1TuUFVS6966wHJhL4rcCzMxLvPJ8no6fGePAPB4S+R3V -wp71UrTsM7zt/CfYRYnkRa6otY2k4NOEF0QkrwRuGOJUZFzRRsJ5iPivv1OzpfGW -RsV9zqJB5qlHorHg5P+Fq1qLQhLqMMdPmTGhsf/8V6tluQ4UMHgaj6uf428Zdf0P -drR56fIWAqwWSpZnJYBJkol3/GP4Uxbd7QP+zN2GljARtozzelNxQBWgoIhVo4Q8 -xacNPE7hPLYeOyJ5W7OjPDnR5Y3td9vQg49fSgAk/VWg+XoQll1kFOM3CLxv3Njy -1mhoq3ZDzxgxYdUb1OqDeX7YuPfTmrry7t3+UQIDAQABo4IDdDCCA3AwDgYDVR0P -AQH/BAQDAgWgMB0GA1UdJQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjAMBgNVHRMB -Af8EAjAAMB0GA1UdDgQWBBQjA13j9gxM4TMdtc2Y9vFynWsE+zAfBgNVHSMEGDAW -gBQULrMXt1hWy65QCUDmH6+dixTCxjBVBggrBgEFBQcBAQRJMEcwIQYIKwYBBQUH -MAGGFWh0dHA6Ly9yMy5vLmxlbmNyLm9yZzAiBggrBgEFBQcwAoYWaHR0cDovL3Iz -LmkubGVuY3Iub3JnLzCCAXoGA1UdEQSCAXEwggFtgicqLmFtcGxpZnlhcHAubG9j -YWxob3N0LmxvY2Fsc3RhY2suY2xvdWSCJyouY2xvdWRmcm9udC5sb2NhbGhvc3Qu -bG9jYWxzdGFjay5jbG91ZIIgKi5lbGIubG9jYWxob3N0LmxvY2Fsc3RhY2suY2xv -dWSCKCouZXhlY3V0ZS1hcGkubG9jYWxob3N0LmxvY2Fsc3RhY2suY2xvdWSCHCou -bG9jYWxob3N0LmxvY2Fsc3RhY2suY2xvdWSCJyoub3BlbnNlYXJjaC5sb2NhbGhv -c3QubG9jYWxzdGFjay5jbG91ZIInKi5zMy13ZWJzaXRlLmxvY2FsaG9zdC5sb2Nh -bHN0YWNrLmNsb3Vkgh8qLnMzLmxvY2FsaG9zdC5sb2NhbHN0YWNrLmNsb3VkgiAq -LnNjbS5sb2NhbGhvc3QubG9jYWxzdGFjay5jbG91ZIIabG9jYWxob3N0LmxvY2Fs -c3RhY2suY2xvdWQwEwYDVR0gBAwwCjAIBgZngQwBAgEwggEFBgorBgEEAdZ5AgQC -BIH2BIHzAPEAdgB6MoxU2LcttiDqOOBSHumEFnAyE4VNO9IrwTpXo1LrUgAAAYjv -Oq1ZAAAEAwBHMEUCIQDeLLchWTLThBy15PH72K1CeUPDHLuGCFO8CCJFVh392AIg -Ryz+nmoNYlQcy6MBUQBCgYVciCnrFPnbL8qNWc3J2okAdwDoPtDaPvUGNTLnVyi8 -iWvJA9PL0RFr7Otp4Xd9bQa9bgAAAYjvOq1PAAAEAwBIMEYCIQCJS5m5Dz6gGGPP -o9Zvbw6sGrT0K/umxPCnrPfpU3MBMgIhAIohiRpxIv2SRyLzUXQr1ani1dCklTpl -C6IU2wE0YQpUMA0GCSqGSIb3DQEBCwUAA4IBAQC429PPt82YPxbChUViGeAtOPdS -vol/VrRChQwWs+nai+puPXuuPIefvSRqo8eO6kOmSgwn3KkQtfbz3cLILk7WGCC9 -YsoE2tRPWmJtGqxUIY4YN3ESb+zx81Y+1Bst497Yw2H0J5FFFjdc0tmUFqWbaiNx -Gx1v/lZVt/92wzBp9EscokIMoOxFdTT0IPF8yF6UM7Ed4u0B4XZCFnaWbcKmWLPy -QHrZq8OBkdXJgWEYgOkwtxlq3WUbhxqz8gCWC4JuSfzSoj5w4etzrNBmkGJ5TtHi -0PzSe5L3kKsqu86UmDUDfQ0ugzumbusFpC2Ev62ETFKyW70pnj0IW/OZEdYM ------END CERTIFICATE----- ------BEGIN CERTIFICATE----- -MIIFFjCCAv6gAwIBAgIRAJErCErPDBinU/bWLiWnX1owDQYJKoZIhvcNAQELBQAw -TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh -cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMjAwOTA0MDAwMDAw -WhcNMjUwOTE1MTYwMDAwWjAyMQswCQYDVQQGEwJVUzEWMBQGA1UEChMNTGV0J3Mg -RW5jcnlwdDELMAkGA1UEAxMCUjMwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK -AoIBAQC7AhUozPaglNMPEuyNVZLD+ILxmaZ6QoinXSaqtSu5xUyxr45r+XXIo9cP -R5QUVTVXjJ6oojkZ9YI8QqlObvU7wy7bjcCwXPNZOOftz2nwWgsbvsCUJCWH+jdx -sxPnHKzhm+/b5DtFUkWWqcFTzjTIUu61ru2P3mBw4qVUq7ZtDpelQDRrK9O8Zutm -NHz6a4uPVymZ+DAXXbpyb/uBxa3Shlg9F8fnCbvxK/eG3MHacV3URuPMrSXBiLxg -Z3Vms/EY96Jc5lP/Ooi2R6X/ExjqmAl3P51T+c8B5fWmcBcUr2Ok/5mzk53cU6cG -/kiFHaFpriV1uxPMUgP17VGhi9sVAgMBAAGjggEIMIIBBDAOBgNVHQ8BAf8EBAMC -AYYwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMBIGA1UdEwEB/wQIMAYB -Af8CAQAwHQYDVR0OBBYEFBQusxe3WFbLrlAJQOYfr52LFMLGMB8GA1UdIwQYMBaA -FHm0WeZ7tuXkAXOACIjIGlj26ZtuMDIGCCsGAQUFBwEBBCYwJDAiBggrBgEFBQcw -AoYWaHR0cDovL3gxLmkubGVuY3Iub3JnLzAnBgNVHR8EIDAeMBygGqAYhhZodHRw -Oi8veDEuYy5sZW5jci5vcmcvMCIGA1UdIAQbMBkwCAYGZ4EMAQIBMA0GCysGAQQB -gt8TAQEBMA0GCSqGSIb3DQEBCwUAA4ICAQCFyk5HPqP3hUSFvNVneLKYY611TR6W -PTNlclQtgaDqw+34IL9fzLdwALduO/ZelN7kIJ+m74uyA+eitRY8kc607TkC53wl -ikfmZW4/RvTZ8M6UK+5UzhK8jCdLuMGYL6KvzXGRSgi3yLgjewQtCPkIVz6D2QQz -CkcheAmCJ8MqyJu5zlzyZMjAvnnAT45tRAxekrsu94sQ4egdRCnbWSDtY7kh+BIm -lJNXoB1lBMEKIq4QDUOXoRgffuDghje1WrG9ML+Hbisq/yFOGwXD9RiX8F6sw6W4 -avAuvDszue5L3sz85K+EC4Y/wFVDNvZo4TYXao6Z0f+lQKc0t8DQYzk1OXVu8rp2 -yJMC6alLbBfODALZvYH7n7do1AZls4I9d1P4jnkDrQoxB3UqQ9hVl3LEKQ73xF1O -yK5GhDDX8oVfGKF5u+decIsH4YaTw7mP3GFxJSqv3+0lUFJoi5Lc5da149p90Ids -hCExroL1+7mryIkXPeFM5TgO9r0rvZaBFOvV2z0gp35Z0+L4WPlbuEjN/lxPFin+ -HlUjr8gRsI3qfJOQFy/9rKIJR0Y/8Omwt/8oTWgy1mdeHmmjk7j1nYsvC9JSQ6Zv -MldlTTKB3zhThV1+XWYp6rjd5JW1zbVWEkLNxE7GJThEUG3szgBVGP7pSWTUTsqX -nLRbwHOoq7hHwg== ------END CERTIFICATE----- ------BEGIN CERTIFICATE----- -MIIFYDCCBEigAwIBAgIQQAF3ITfU6UK47naqPGQKtzANBgkqhkiG9w0BAQsFADA/ -MSQwIgYDVQQKExtEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdCBDby4xFzAVBgNVBAMT -DkRTVCBSb290IENBIFgzMB4XDTIxMDEyMDE5MTQwM1oXDTI0MDkzMDE4MTQwM1ow -TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh -cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwggIiMA0GCSqGSIb3DQEB -AQUAA4ICDwAwggIKAoICAQCt6CRz9BQ385ueK1coHIe+3LffOJCMbjzmV6B493XC -ov71am72AE8o295ohmxEk7axY/0UEmu/H9LqMZshftEzPLpI9d1537O4/xLxIZpL -wYqGcWlKZmZsj348cL+tKSIG8+TA5oCu4kuPt5l+lAOf00eXfJlII1PoOK5PCm+D -LtFJV4yAdLbaL9A4jXsDcCEbdfIwPPqPrt3aY6vrFk/CjhFLfs8L6P+1dy70sntK -4EwSJQxwjQMpoOFTJOwT2e4ZvxCzSow/iaNhUd6shweU9GNx7C7ib1uYgeGJXDR5 -bHbvO5BieebbpJovJsXQEOEO3tkQjhb7t/eo98flAgeYjzYIlefiN5YNNnWe+w5y -sR2bvAP5SQXYgd0FtCrWQemsAXaVCg/Y39W9Eh81LygXbNKYwagJZHduRze6zqxZ -Xmidf3LWicUGQSk+WT7dJvUkyRGnWqNMQB9GoZm1pzpRboY7nn1ypxIFeFntPlF4 -FQsDj43QLwWyPntKHEtzBRL8xurgUBN8Q5N0s8p0544fAQjQMNRbcTa0B7rBMDBc -SLeCO5imfWCKoqMpgsy6vYMEG6KDA0Gh1gXxG8K28Kh8hjtGqEgqiNx2mna/H2ql -PRmP6zjzZN7IKw0KKP/32+IVQtQi0Cdd4Xn+GOdwiK1O5tmLOsbdJ1Fu/7xk9TND -TwIDAQABo4IBRjCCAUIwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYw -SwYIKwYBBQUHAQEEPzA9MDsGCCsGAQUFBzAChi9odHRwOi8vYXBwcy5pZGVudHJ1 -c3QuY29tL3Jvb3RzL2RzdHJvb3RjYXgzLnA3YzAfBgNVHSMEGDAWgBTEp7Gkeyxx -+tvhS5B1/8QVYIWJEDBUBgNVHSAETTBLMAgGBmeBDAECATA/BgsrBgEEAYLfEwEB -ATAwMC4GCCsGAQUFBwIBFiJodHRwOi8vY3BzLnJvb3QteDEubGV0c2VuY3J5cHQu -b3JnMDwGA1UdHwQ1MDMwMaAvoC2GK2h0dHA6Ly9jcmwuaWRlbnRydXN0LmNvbS9E -U1RST09UQ0FYM0NSTC5jcmwwHQYDVR0OBBYEFHm0WeZ7tuXkAXOACIjIGlj26Ztu -MA0GCSqGSIb3DQEBCwUAA4IBAQAKcwBslm7/DlLQrt2M51oGrS+o44+/yQoDFVDC -5WxCu2+b9LRPwkSICHXM6webFGJueN7sJ7o5XPWioW5WlHAQU7G75K/QosMrAdSW -9MUgNTP52GE24HGNtLi1qoJFlcDyqSMo59ahy2cI2qBDLKobkx/J3vWraV0T9VuG -WCLKTVXkcGdtwlfFRjlBz4pYg1htmf5X6DYO8A4jqv2Il9DjXA6USbW1FzXSLr9O -he8Y4IWS6wY7bCkjCWDcRQJMEhg76fsO3txE+FiYruq9RUWhiF1myv4Q6W+CyBFC -Dfvp7OOGAN6dEOM4+qR9sdjoSYKEBpsr6GtPAQw4dy753ec5 ------END CERTIFICATE----- diff --git a/openapi-generator/test/specs/localstack/cache/server.test.pem.crt b/openapi-generator/test/specs/localstack/cache/server.test.pem.crt deleted file mode 100644 index 0b95895..0000000 --- a/openapi-generator/test/specs/localstack/cache/server.test.pem.crt +++ /dev/null @@ -1,97 +0,0 @@ ------BEGIN CERTIFICATE----- -MIIGWTCCBUGgAwIBAgISA8x1EBwVQKws8CsVwKOtHxMTMA0GCSqGSIb3DQEBCwUA -MDIxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1MZXQncyBFbmNyeXB0MQswCQYDVQQD -EwJSMzAeFw0yMzA2MjQyMDA2MjBaFw0yMzA5MjIyMDA2MTlaMCUxIzAhBgNVBAMT -GmxvY2FsaG9zdC5sb2NhbHN0YWNrLmNsb3VkMIIBIjANBgkqhkiG9w0BAQEFAAOC -AQ8AMIIBCgKCAQEAtuuY1TuUFVS6966wHJhL4rcCzMxLvPJ8no6fGePAPB4S+R3V -wp71UrTsM7zt/CfYRYnkRa6otY2k4NOEF0QkrwRuGOJUZFzRRsJ5iPivv1OzpfGW -RsV9zqJB5qlHorHg5P+Fq1qLQhLqMMdPmTGhsf/8V6tluQ4UMHgaj6uf428Zdf0P -drR56fIWAqwWSpZnJYBJkol3/GP4Uxbd7QP+zN2GljARtozzelNxQBWgoIhVo4Q8 -xacNPE7hPLYeOyJ5W7OjPDnR5Y3td9vQg49fSgAk/VWg+XoQll1kFOM3CLxv3Njy -1mhoq3ZDzxgxYdUb1OqDeX7YuPfTmrry7t3+UQIDAQABo4IDdDCCA3AwDgYDVR0P -AQH/BAQDAgWgMB0GA1UdJQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjAMBgNVHRMB -Af8EAjAAMB0GA1UdDgQWBBQjA13j9gxM4TMdtc2Y9vFynWsE+zAfBgNVHSMEGDAW -gBQULrMXt1hWy65QCUDmH6+dixTCxjBVBggrBgEFBQcBAQRJMEcwIQYIKwYBBQUH -MAGGFWh0dHA6Ly9yMy5vLmxlbmNyLm9yZzAiBggrBgEFBQcwAoYWaHR0cDovL3Iz -LmkubGVuY3Iub3JnLzCCAXoGA1UdEQSCAXEwggFtgicqLmFtcGxpZnlhcHAubG9j -YWxob3N0LmxvY2Fsc3RhY2suY2xvdWSCJyouY2xvdWRmcm9udC5sb2NhbGhvc3Qu -bG9jYWxzdGFjay5jbG91ZIIgKi5lbGIubG9jYWxob3N0LmxvY2Fsc3RhY2suY2xv -dWSCKCouZXhlY3V0ZS1hcGkubG9jYWxob3N0LmxvY2Fsc3RhY2suY2xvdWSCHCou -bG9jYWxob3N0LmxvY2Fsc3RhY2suY2xvdWSCJyoub3BlbnNlYXJjaC5sb2NhbGhv -c3QubG9jYWxzdGFjay5jbG91ZIInKi5zMy13ZWJzaXRlLmxvY2FsaG9zdC5sb2Nh -bHN0YWNrLmNsb3Vkgh8qLnMzLmxvY2FsaG9zdC5sb2NhbHN0YWNrLmNsb3VkgiAq -LnNjbS5sb2NhbGhvc3QubG9jYWxzdGFjay5jbG91ZIIabG9jYWxob3N0LmxvY2Fs -c3RhY2suY2xvdWQwEwYDVR0gBAwwCjAIBgZngQwBAgEwggEFBgorBgEEAdZ5AgQC -BIH2BIHzAPEAdgB6MoxU2LcttiDqOOBSHumEFnAyE4VNO9IrwTpXo1LrUgAAAYjv -Oq1ZAAAEAwBHMEUCIQDeLLchWTLThBy15PH72K1CeUPDHLuGCFO8CCJFVh392AIg -Ryz+nmoNYlQcy6MBUQBCgYVciCnrFPnbL8qNWc3J2okAdwDoPtDaPvUGNTLnVyi8 -iWvJA9PL0RFr7Otp4Xd9bQa9bgAAAYjvOq1PAAAEAwBIMEYCIQCJS5m5Dz6gGGPP -o9Zvbw6sGrT0K/umxPCnrPfpU3MBMgIhAIohiRpxIv2SRyLzUXQr1ani1dCklTpl -C6IU2wE0YQpUMA0GCSqGSIb3DQEBCwUAA4IBAQC429PPt82YPxbChUViGeAtOPdS -vol/VrRChQwWs+nai+puPXuuPIefvSRqo8eO6kOmSgwn3KkQtfbz3cLILk7WGCC9 -YsoE2tRPWmJtGqxUIY4YN3ESb+zx81Y+1Bst497Yw2H0J5FFFjdc0tmUFqWbaiNx -Gx1v/lZVt/92wzBp9EscokIMoOxFdTT0IPF8yF6UM7Ed4u0B4XZCFnaWbcKmWLPy -QHrZq8OBkdXJgWEYgOkwtxlq3WUbhxqz8gCWC4JuSfzSoj5w4etzrNBmkGJ5TtHi -0PzSe5L3kKsqu86UmDUDfQ0ugzumbusFpC2Ev62ETFKyW70pnj0IW/OZEdYM ------END CERTIFICATE----- ------BEGIN CERTIFICATE----- -MIIFFjCCAv6gAwIBAgIRAJErCErPDBinU/bWLiWnX1owDQYJKoZIhvcNAQELBQAw -TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh -cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMjAwOTA0MDAwMDAw -WhcNMjUwOTE1MTYwMDAwWjAyMQswCQYDVQQGEwJVUzEWMBQGA1UEChMNTGV0J3Mg -RW5jcnlwdDELMAkGA1UEAxMCUjMwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK -AoIBAQC7AhUozPaglNMPEuyNVZLD+ILxmaZ6QoinXSaqtSu5xUyxr45r+XXIo9cP -R5QUVTVXjJ6oojkZ9YI8QqlObvU7wy7bjcCwXPNZOOftz2nwWgsbvsCUJCWH+jdx -sxPnHKzhm+/b5DtFUkWWqcFTzjTIUu61ru2P3mBw4qVUq7ZtDpelQDRrK9O8Zutm -NHz6a4uPVymZ+DAXXbpyb/uBxa3Shlg9F8fnCbvxK/eG3MHacV3URuPMrSXBiLxg -Z3Vms/EY96Jc5lP/Ooi2R6X/ExjqmAl3P51T+c8B5fWmcBcUr2Ok/5mzk53cU6cG -/kiFHaFpriV1uxPMUgP17VGhi9sVAgMBAAGjggEIMIIBBDAOBgNVHQ8BAf8EBAMC -AYYwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMBIGA1UdEwEB/wQIMAYB -Af8CAQAwHQYDVR0OBBYEFBQusxe3WFbLrlAJQOYfr52LFMLGMB8GA1UdIwQYMBaA -FHm0WeZ7tuXkAXOACIjIGlj26ZtuMDIGCCsGAQUFBwEBBCYwJDAiBggrBgEFBQcw -AoYWaHR0cDovL3gxLmkubGVuY3Iub3JnLzAnBgNVHR8EIDAeMBygGqAYhhZodHRw -Oi8veDEuYy5sZW5jci5vcmcvMCIGA1UdIAQbMBkwCAYGZ4EMAQIBMA0GCysGAQQB -gt8TAQEBMA0GCSqGSIb3DQEBCwUAA4ICAQCFyk5HPqP3hUSFvNVneLKYY611TR6W -PTNlclQtgaDqw+34IL9fzLdwALduO/ZelN7kIJ+m74uyA+eitRY8kc607TkC53wl -ikfmZW4/RvTZ8M6UK+5UzhK8jCdLuMGYL6KvzXGRSgi3yLgjewQtCPkIVz6D2QQz -CkcheAmCJ8MqyJu5zlzyZMjAvnnAT45tRAxekrsu94sQ4egdRCnbWSDtY7kh+BIm -lJNXoB1lBMEKIq4QDUOXoRgffuDghje1WrG9ML+Hbisq/yFOGwXD9RiX8F6sw6W4 -avAuvDszue5L3sz85K+EC4Y/wFVDNvZo4TYXao6Z0f+lQKc0t8DQYzk1OXVu8rp2 -yJMC6alLbBfODALZvYH7n7do1AZls4I9d1P4jnkDrQoxB3UqQ9hVl3LEKQ73xF1O -yK5GhDDX8oVfGKF5u+decIsH4YaTw7mP3GFxJSqv3+0lUFJoi5Lc5da149p90Ids -hCExroL1+7mryIkXPeFM5TgO9r0rvZaBFOvV2z0gp35Z0+L4WPlbuEjN/lxPFin+ -HlUjr8gRsI3qfJOQFy/9rKIJR0Y/8Omwt/8oTWgy1mdeHmmjk7j1nYsvC9JSQ6Zv -MldlTTKB3zhThV1+XWYp6rjd5JW1zbVWEkLNxE7GJThEUG3szgBVGP7pSWTUTsqX -nLRbwHOoq7hHwg== ------END CERTIFICATE----- ------BEGIN CERTIFICATE----- -MIIFYDCCBEigAwIBAgIQQAF3ITfU6UK47naqPGQKtzANBgkqhkiG9w0BAQsFADA/ -MSQwIgYDVQQKExtEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdCBDby4xFzAVBgNVBAMT -DkRTVCBSb290IENBIFgzMB4XDTIxMDEyMDE5MTQwM1oXDTI0MDkzMDE4MTQwM1ow -TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh -cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwggIiMA0GCSqGSIb3DQEB -AQUAA4ICDwAwggIKAoICAQCt6CRz9BQ385ueK1coHIe+3LffOJCMbjzmV6B493XC -ov71am72AE8o295ohmxEk7axY/0UEmu/H9LqMZshftEzPLpI9d1537O4/xLxIZpL -wYqGcWlKZmZsj348cL+tKSIG8+TA5oCu4kuPt5l+lAOf00eXfJlII1PoOK5PCm+D -LtFJV4yAdLbaL9A4jXsDcCEbdfIwPPqPrt3aY6vrFk/CjhFLfs8L6P+1dy70sntK -4EwSJQxwjQMpoOFTJOwT2e4ZvxCzSow/iaNhUd6shweU9GNx7C7ib1uYgeGJXDR5 -bHbvO5BieebbpJovJsXQEOEO3tkQjhb7t/eo98flAgeYjzYIlefiN5YNNnWe+w5y -sR2bvAP5SQXYgd0FtCrWQemsAXaVCg/Y39W9Eh81LygXbNKYwagJZHduRze6zqxZ -Xmidf3LWicUGQSk+WT7dJvUkyRGnWqNMQB9GoZm1pzpRboY7nn1ypxIFeFntPlF4 -FQsDj43QLwWyPntKHEtzBRL8xurgUBN8Q5N0s8p0544fAQjQMNRbcTa0B7rBMDBc -SLeCO5imfWCKoqMpgsy6vYMEG6KDA0Gh1gXxG8K28Kh8hjtGqEgqiNx2mna/H2ql -PRmP6zjzZN7IKw0KKP/32+IVQtQi0Cdd4Xn+GOdwiK1O5tmLOsbdJ1Fu/7xk9TND -TwIDAQABo4IBRjCCAUIwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYw -SwYIKwYBBQUHAQEEPzA9MDsGCCsGAQUFBzAChi9odHRwOi8vYXBwcy5pZGVudHJ1 -c3QuY29tL3Jvb3RzL2RzdHJvb3RjYXgzLnA3YzAfBgNVHSMEGDAWgBTEp7Gkeyxx -+tvhS5B1/8QVYIWJEDBUBgNVHSAETTBLMAgGBmeBDAECATA/BgsrBgEEAYLfEwEB -ATAwMC4GCCsGAQUFBwIBFiJodHRwOi8vY3BzLnJvb3QteDEubGV0c2VuY3J5cHQu -b3JnMDwGA1UdHwQ1MDMwMaAvoC2GK2h0dHA6Ly9jcmwuaWRlbnRydXN0LmNvbS9E -U1RST09UQ0FYM0NSTC5jcmwwHQYDVR0OBBYEFHm0WeZ7tuXkAXOACIjIGlj26Ztu -MA0GCSqGSIb3DQEBCwUAA4IBAQAKcwBslm7/DlLQrt2M51oGrS+o44+/yQoDFVDC -5WxCu2+b9LRPwkSICHXM6webFGJueN7sJ7o5XPWioW5WlHAQU7G75K/QosMrAdSW -9MUgNTP52GE24HGNtLi1qoJFlcDyqSMo59ahy2cI2qBDLKobkx/J3vWraV0T9VuG -WCLKTVXkcGdtwlfFRjlBz4pYg1htmf5X6DYO8A4jqv2Il9DjXA6USbW1FzXSLr9O -he8Y4IWS6wY7bCkjCWDcRQJMEhg76fsO3txE+FiYruq9RUWhiF1myv4Q6W+CyBFC -Dfvp7OOGAN6dEOM4+qR9sdjoSYKEBpsr6GtPAQw4dy753ec5 ------END CERTIFICATE----- \ No newline at end of file diff --git a/openapi-generator/test/specs/localstack/cache/server.test.pem.key b/openapi-generator/test/specs/localstack/cache/server.test.pem.key deleted file mode 100644 index 4ee21ea..0000000 --- a/openapi-generator/test/specs/localstack/cache/server.test.pem.key +++ /dev/null @@ -1,28 +0,0 @@ ------BEGIN PRIVATE KEY----- -MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC265jVO5QVVLr3 -rrAcmEvitwLMzEu88nyejp8Z48A8HhL5HdXCnvVStOwzvO38J9hFieRFrqi1jaTg -04QXRCSvBG4Y4lRkXNFGwnmI+K+/U7Ol8ZZGxX3OokHmqUeiseDk/4WrWotCEuow -x0+ZMaGx//xXq2W5DhQweBqPq5/jbxl1/Q92tHnp8hYCrBZKlmclgEmSiXf8Y/hT -Ft3tA/7M3YaWMBG2jPN6U3FAFaCgiFWjhDzFpw08TuE8th47Inlbs6M8OdHlje13 -29CDj19KACT9VaD5ehCWXWQU4zcIvG/c2PLWaGirdkPPGDFh1RvU6oN5fti499Oa -uvLu3f5RAgMBAAECggEABKQ/0ZFcdZob0HMnVuJqcotQT+ATP+0rSl62HNMRqrTc -qGOga/raoMmkgL+XjmF4dHNGTppa/5hjiaz0Wh7Ji4NiQ9FicNWGHfSLXvVoiENY -eKqDtLIIOjkV0QOUpMU8vrLZMnrus7OFK82y8GE5CCpFvffEcgiwbHZvvhuNyBib -lvTziO3Vv5fJ99rD4/7wz/1d0Jcwb/7xozYfSStWeC6/RZMNMHOjCX4zHL0z1ry/ -Sgk5YZ1kkl9PCZGaiA7aQ/eH5rpxVpuM6aIsvNwdaFr4E12onMiog2ldOEtFbZVG -WQTWsILjVj8MK9fI1aHZMMGcfXaCuy8+3p+KhMhRzQKBgQDsvzwfeBUgjQ77M37A -lRdTZHspeaxjKQMr1vOKXOawxzr7JIQ01X0bgHC/wsS5lX259/9giBnadU+/HjuY -vxZXrrvtmdOFwShe3QypXgaft3wCLan4Df/9N7wRvYyCSJSBhvc0tSdX46u63rdx -k9VgYE73SAkjpq1riijxFvjwmwKBgQDFy8KOG6jxY2x8Tq3prkmJOEuBZJnOSxVs -3XbWrH9D75afGULCUwDWG96ZBc+otQ2uyrCDwCBVwe9eU/NZDGH6wcfa2P6vu5Tj -28ICz9Aie4V0gEdy+SK/J4n6zXzs9e0jF1qhIrRjlCma0A6/5PwQpPmQ9DEsuoyX -f380cHkNgwKBgQCj5EtB2cZ+b0hUvDReK5gnQeNFNhcR2l14puiX+3I0JOf+3iur -y7M9K7Bh//piI0wTRsyCzhVft2CKhOpq9rYH403z0U6uRKam7U4LnazmOoZdl7EX -qNFzQXcvrNGti4NLG9zcnx/qZxEGX5IMzXOksWdZJoQ1KvjY/p8TL30MSwKBgAdO -iKhhQzNvndFVwrzwME0+ZCOqiLgDNA5qe/pgMu9aiXDlKP8uu8gtDWMPwOUVkyTS -3gRv84HXgTU12rZ+a5wszmo6O+ZYAp8MPjWGYcT0VTDBkGIh6/OtzT4TmzrRtunl -8fYj5xAKqCLM7s6N8fXXclS1gJ+LYKg0EInqYb5rAoGANrkOuxR9EuQJSyxPqYxI -ZujvPlBFZP0YdNkEBsgBRczee0w8W8HE9Ry4bm/r7A0ZGXEffqAEN9fqbtTpCgoN -PUGUMeyF3b9AMysrMf5gV+8VMvTcdxGrcwGile335p8dUJv7HzkCKWwZ8DBdQNvJ -fwFn4LJthOKDPZ7G9OTYAwc= ------END PRIVATE KEY----- \ No newline at end of file diff --git a/openapi-generator/test/specs/localstack/cache/service-catalog-2_2_1_dev-1_31_28.pickle b/openapi-generator/test/specs/localstack/cache/service-catalog-2_2_1_dev-1_31_28.pickle deleted file mode 100644 index 01177496a713b5c5bb2870c95892df74e47275eb..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 352716 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%0D+1-7F81HP^S?TKd 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%0APHoZ> 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 From d2f5a9001458126e7c315ef89ebdf5b26b7282fc Mon Sep 17 00:00:00 2001 From: Nexushunter Date: Sun, 3 Sep 2023 13:09:08 -0400 Subject: [PATCH 04/13] fix: remove unused import, update paramter name --- .../lib/src/openapi_generator_runner.dart | 9 ++----- openapi-generator/test/generator_test.dart | 26 +++++++++---------- 2 files changed, 15 insertions(+), 20 deletions(-) diff --git a/openapi-generator/lib/src/openapi_generator_runner.dart b/openapi-generator/lib/src/openapi_generator_runner.dart index 5022740..c42fb92 100755 --- a/openapi-generator/lib/src/openapi_generator_runner.dart +++ b/openapi-generator/lib/src/openapi_generator_runner.dart @@ -6,7 +6,6 @@ import 'dart:isolate'; import 'package:analyzer/dart/element/element.dart'; import 'package:build/build.dart'; import 'package:logging/logging.dart'; -import 'package:openapi_generator/src/determine_flutter_project_status.dart'; import 'package:openapi_generator/src/models/output_message.dart'; import 'package:openapi_generator/src/utils.dart'; import 'package:openapi_generator_annotations/openapi_generator_annotations.dart' @@ -25,12 +24,8 @@ class OpenapiGenerator extends GeneratorForAnnotation { OpenapiGenerator({ this.testMode = false, this.runner = const CommandRunner(), - Logger? log, - }) : _log = log ?? Logger('OpenApiGenerator') { - _log.onRecord.listen((event) { - print(event.toString()); - }); - } + Logger? logger, + }) : _log = logger ?? Logger('OpenApiGenerator'); @override FutureOr generateForAnnotatedElement( diff --git a/openapi-generator/test/generator_test.dart b/openapi-generator/test/generator_test.dart index 48f3748..34bade0 100644 --- a/openapi-generator/test/generator_test.dart +++ b/openapi-generator/test/generator_test.dart @@ -46,7 +46,7 @@ void main() { final logs = []; logger.onRecord.listen(logs.add); try { - await OpenapiGenerator(log: logger).generateForAnnotatedElement( + await OpenapiGenerator(logger: logger).generateForAnnotatedElement( MockMethodElement(), defaultAnnotations, MockBuildStep()); fail('Should throw when not ClassElement'); } catch (_, __) { @@ -108,7 +108,7 @@ void main() { providedPubspecPath: anyNamed('providedPubspecPath'))) .thenAnswer((_) async => false); - await OpenapiGenerator(log: logger, runner: mockRunner) + await OpenapiGenerator(logger: logger, runner: mockRunner) .generateForAnnotatedElement( MockClassElement(), defaultAnnotations, MockBuildStep()); @@ -136,7 +136,7 @@ void main() { providedPubspecPath: anyNamed('providedPubspecPath'))) .thenAnswer((_) async => true); - await OpenapiGenerator(log: logger, runner: mockRunner) + await OpenapiGenerator(logger: logger, runner: mockRunner) .generateForAnnotatedElement( MockClassElement(), annotations, MockBuildStep()); @@ -164,7 +164,7 @@ void main() { providedPubspecPath: anyNamed('providedPubspecPath'))) .thenAnswer((_) async => true); - await OpenapiGenerator(log: logger, runner: mockRunner) + await OpenapiGenerator(logger: logger, runner: mockRunner) .generateForAnnotatedElement( MockClassElement(), annotations, MockBuildStep()); @@ -193,7 +193,7 @@ void main() { ), ).thenAnswer((_) async => true); - await OpenapiGenerator(log: logger, runner: mockRunner) + await OpenapiGenerator(logger: logger, runner: mockRunner) .generateForAnnotatedElement( MockClassElement(), annotations, MockBuildStep()); @@ -206,7 +206,7 @@ void main() { late OpenapiGenerator generator; setUpAll(() { resetMockitoState(); - generator = OpenapiGenerator(log: logger, runner: mockRunner); + generator = OpenapiGenerator(logger: logger, runner: mockRunner); when(mockRunner.runCommand( command: anyNamed('command'), workingDirectory: anyNamed('workingDirectory'))) @@ -289,7 +289,7 @@ void main() { late OpenapiGenerator generator; setUpAll(() { resetMockitoState(); - generator = OpenapiGenerator(log: logger, runner: mockRunner); + generator = OpenapiGenerator(logger: logger, runner: mockRunner); }); test('warning when using remote spec', () async { final logs = []; @@ -632,7 +632,7 @@ void main() { logger.onRecord.listen(logs.add); when(mockedArgs.shouldFetchDependencies).thenReturn(false); - await OpenapiGenerator(log: logger) + await OpenapiGenerator(logger: logger) .fetchDependencies(baseCommand: 'cmd', args: mockedArgs); expect(logs.length, 1); @@ -651,7 +651,7 @@ void main() { .thenAnswer( (_) => Future.value(ProcessResult(999, 0, 'yes', ''))); - await OpenapiGenerator(log: logger, runner: mockRunner) + await OpenapiGenerator(logger: logger, runner: mockRunner) .fetchDependencies(baseCommand: 'dart', args: mockedArgs); expect(logs.length, 2); @@ -676,7 +676,7 @@ void main() { .thenAnswer( (_) => Future.value(ProcessResult(999, 0, 'yes', ''))); - await OpenapiGenerator(log: logger, runner: mockRunner) + await OpenapiGenerator(logger: logger, runner: mockRunner) .fetchDependencies(baseCommand: 'dart', args: mockedArgs); expect(logs.length, 2); @@ -875,7 +875,7 @@ void main() { workingDirectory: anyNamed('workingDirectory'))) .thenAnswer((_) => Future.value(ProcessResult(999, 0, '', ''))); try { - await OpenapiGenerator(runner: mockRunner, log: logger) + await OpenapiGenerator(runner: mockRunner, logger: logger) .formatCode(args: mockedArgs); expect(logs.length, 1); expect(logs[0].message, 'Successfully formatted code.'); @@ -926,7 +926,7 @@ void main() { when(mockedArgs.jarArgs) .thenAnswer((realInvocation) => realArguments.jarArgs); when(mockedArgs.isDebug).thenReturn(false); - await OpenapiGenerator(runner: mockRunner, log: logger) + await OpenapiGenerator(runner: mockRunner, logger: logger) .runOpenApiJar(arguments: mockedArgs); expect(logs.length, 2); expect( @@ -960,7 +960,7 @@ void main() { when(mockedArgs.jarArgs) .thenAnswer((realInvocation) => realArguments.jarArgs); when(mockedArgs.isDebug).thenReturn(true); - await OpenapiGenerator(runner: mockRunner, log: logger) + await OpenapiGenerator(runner: mockRunner, logger: logger) .runOpenApiJar(arguments: mockedArgs); expect(logs.length, 2); expect( From feead33bac9ce9ef36d6cbf3ab8dc8dbbfb0a817 Mon Sep 17 00:00:00 2001 From: Nexushunter Date: Sun, 3 Sep 2023 13:15:43 -0400 Subject: [PATCH 05/13] fix: failing test --- openapi-generator/test/generator_test.dart | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/openapi-generator/test/generator_test.dart b/openapi-generator/test/generator_test.dart index 34bade0..1957fd3 100644 --- a/openapi-generator/test/generator_test.dart +++ b/openapi-generator/test/generator_test.dart @@ -53,11 +53,11 @@ void main() { expect(logs.length, 1); expect( logs[0].message, - [ + contains([ ':::::::::::::::::::::::::::::::::::::::::::', ':: Openapi generator for dart ::', ':::::::::::::::::::::::::::::::::::::::::::', - ].join('\n')); + ].join('\n'))); expect(logs[0].level, Level.INFO); } }); From 3dd705460e5dc09e86e568419c99198ff92b4e4b Mon Sep 17 00:00:00 2001 From: Nexushunter Date: Mon, 4 Sep 2023 11:53:34 -0400 Subject: [PATCH 06/13] fix: remove extra testing infra since it is no longer used, add additional configs, refactor function --- .github/workflows/code_quality.yml | 6 - openapi-generator/docker-compose.yaml | 13 -- openapi-generator/test/builder_test.dart | 107 ------------- openapi-generator/test/generator_test.dart | 149 +++++++++++++----- openapi-generator/test/specs/buckets.sh | 6 - .../next_gen_builder_dio_alt_test_config.dart | 16 ++ .../next_gen_builder_flutter_test_config.dart | 2 +- ...next_gen_builder_flutterw_test_config.dart | 2 +- .../next_gen_builder_fvm_test_config.dart | 2 +- .../next_gen_builder_local_test_config.dart | 16 ++ .../next_gen_builder_test_aws_config.dart | 2 +- .../specs/next_gen_builder_test_config.dart | 2 +- openapi-generator/test/specs/test_config.dart | 2 +- .../test/test_annotations/test_configs.dart | 79 ---------- .../test/test_annotations/test_generator.dart | 113 ------------- openapi-generator/test/utils.dart | 55 ++----- .../test/verify_generation_test.dart | 17 -- 17 files changed, 158 insertions(+), 431 deletions(-) delete mode 100644 openapi-generator/docker-compose.yaml delete mode 100644 openapi-generator/test/builder_test.dart delete mode 100755 openapi-generator/test/specs/buckets.sh create mode 100644 openapi-generator/test/specs/next_gen_builder_dio_alt_test_config.dart create mode 100644 openapi-generator/test/specs/next_gen_builder_local_test_config.dart delete mode 100644 openapi-generator/test/test_annotations/test_configs.dart delete mode 100644 openapi-generator/test/test_annotations/test_generator.dart delete mode 100644 openapi-generator/test/verify_generation_test.dart diff --git a/.github/workflows/code_quality.yml b/.github/workflows/code_quality.yml index 686cc55..71d16f3 100644 --- a/.github/workflows/code_quality.yml +++ b/.github/workflows/code_quality.yml @@ -25,9 +25,6 @@ jobs: steps: - name: Checkout uses: actions/checkout@v3 - - name: Start Docker compose containers - if: ${{ matrix.work_dir == 'openapi-generator' }} - run: docker-compose -f "docker-compose.yaml" up -d --build - name: Setup Dart uses: dart-lang/setup-dart@v1.5.0 with: @@ -54,9 +51,6 @@ jobs: verbose: true flags: ${{ matrix.work_dir }} CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} - - name: Stop Docker Container - if: ${{ matrix.work_dir == 'openapi-generator' && always() }} - run: docker-compose -f "docker-compose.yaml" down build: name: Build example project 🛠️ diff --git a/openapi-generator/docker-compose.yaml b/openapi-generator/docker-compose.yaml deleted file mode 100644 index 64f3ca2..0000000 --- a/openapi-generator/docker-compose.yaml +++ /dev/null @@ -1,13 +0,0 @@ -version: '3' -services: - local-s3: - container_name: localstack - image: localstack/localstack:latest - ports: - - "4566:4566" - environment: - - SERVICES=S3 - - AWS_DEFAULT_REGION=us-east-1 - volumes: - - './test/specs/localstack:/var/lib/localstack' - - './test/specs/buckets.sh:/etc/localstack/init/ready.d/buckets.sh' diff --git a/openapi-generator/test/builder_test.dart b/openapi-generator/test/builder_test.dart deleted file mode 100644 index edf49f9..0000000 --- a/openapi-generator/test/builder_test.dart +++ /dev/null @@ -1,107 +0,0 @@ -import 'package:test/expect.dart'; -import 'package:test/scaffolding.dart'; - -import 'utils.dart'; - -/// We test the build runner by mocking the specs and then checking the output -/// content for the expected generate command. -void main() { - group('generator dio', () { - test('to generate appropriate openapi cli command', () async { - expect( - await generate(''' - @Openapi( - additionalProperties: - DioProperties(pubName: 'petstore_api', pubAuthor: 'Johnny dep...'), - inputSpecFile: '../openapi-spec.yaml', - typeMappings: {'Pet': 'ExamplePet'}, - generatorName: Generator.dio, - runSourceGenOnOutput: true, - alwaysRun: true, - outputDirectory: 'api/petstore_api') - '''), - contains( - 'generate -o=api/petstore_api -i=../openapi-spec.yaml -g=dart-dio --type-mappings=Pet=ExamplePet --additional-properties=allowUnicodeIdentifiers=false,ensureUniqueParams=true,useEnumExtension=true,prependFormOrBodyParameters=false,pubAuthor=Johnny dep...,pubName=petstore_api,legacyDiscriminatorBehavior=true,sortModelPropertiesByRequiredFlag=true,sortParamsByRequiredFlag=true,wrapper=none')); - }); - - test('to generate command with import and type mappings', () async { - expect( - await generate(''' - @Openapi( - inputSpecFile: '../openapi-spec.yaml', - typeMappings: {'int-or-string':'IntOrString'}, - importMappings: {'IntOrString':'./int_or_string.dart'}, - generatorName: Generator.dio, - outputDirectory: '${testSpecPath}output', - ) - '''), - contains( - 'generate -o=${testSpecPath}output -i=../openapi-spec.yaml -g=dart-dio --import-mappings=IntOrString=./int_or_string.dart --type-mappings=int-or-string=IntOrString')); - }); - - test('to generate command with inline schema mappings', () async { - expect( - await generate(''' - @Openapi( - inputSpecFile: '../openapi-spec.yaml', - typeMappings: {'int-or-string':'IntOrString'}, - inlineSchemaNameMappings: {'inline_object_2':'SomethingMapped','inline_object_4':'nothing_new'}, - generatorName: Generator.dio, - outputDirectory: '${testSpecPath}output', - ) - '''), - contains(''' - generate -o=${testSpecPath}output -i=../openapi-spec.yaml -g=dart-dio --inline-schema-name-mappings=inline_object_2=SomethingMapped,inline_object_4=nothing_new --type-mappings=int-or-string=IntOrString - ''' - .trim())); - }); - - // test('to generate command with inline schema options', () async { - // expect(await generate(''' - // @Openapi( - // inputSpecFile: '../openapi-spec.yaml', - // inlineSchemaOptions: InlineSchemaOptions(skipSchemaReuse: true,refactorAllofInlineSchemas: true,resolveInlineEnums: true), - // generatorName: Generator.dio) - // '''), contains(''' - // generate -i ../openapi-spec.yaml -g dart-dio --type-mappings=int-or-string=IntOrString --inline-schema-name-mappings=inline_object_2=SomethingMapped,inline_object_4=nothing_new - // '''.trim())); - // }); - }); - - group('generator dioAlt', () { - test('to generate appropriate openapi cli command', () async { - expect( - await generate(''' - @Openapi( - additionalProperties: - DioProperties(pubName: 'petstore_api', pubAuthor: 'Johnny dep...'), - inputSpecFile: '../openapi-spec.yaml', - typeMappings: {'Pet': 'ExamplePet'}, - generatorName: Generator.dio, - runSourceGenOnOutput: true, - alwaysRun: true, - outputDirectory: 'api/petstore_api') - '''), - contains(''' - generate -o=api/petstore_api -i=../openapi-spec.yaml -g=dart-dio --type-mappings=Pet=ExamplePet --additional-properties=allowUnicodeIdentifiers=false,ensureUniqueParams=true,useEnumExtension=true,prependFormOrBodyParameters=false,pubAuthor=Johnny dep...,pubName=petstore_api,legacyDiscriminatorBehavior=true,sortModelPropertiesByRequiredFlag=true,sortParamsByRequiredFlag=true,wrapper=none - ''' - .trim())); - }); - - test('to generate command with import and type mappings for dioAlt', - () async { - expect( - await generate(''' - @Openapi( - inputSpecFile: '../openapi-spec.yaml', - typeMappings: {'int-or-string':'IntOrString'}, - importMappings: {'IntOrString':'./int_or_string.dart'}, - generatorName: Generator.dioAlt, - outputDirectory: '${testSpecPath}output', - ) - '''), - contains( - 'generate -o=${testSpecPath}output -i=../openapi-spec.yaml -g=dart2-api --import-mappings=IntOrString=./int_or_string.dart --type-mappings=int-or-string=IntOrString')); - }); - }); -} diff --git a/openapi-generator/test/generator_test.dart b/openapi-generator/test/generator_test.dart index 1957fd3..c753f1f 100644 --- a/openapi-generator/test/generator_test.dart +++ b/openapi-generator/test/generator_test.dart @@ -1,7 +1,6 @@ import 'dart:io'; import 'package:analyzer/dart/element/type.dart'; -import 'package:build_test/build_test.dart'; import 'package:logging/logging.dart'; import 'package:mockito/mockito.dart'; import 'package:openapi_generator/src/models/command.dart'; @@ -30,15 +29,8 @@ void main() { mockedArgs = MockGeneratorArguments(); mockRunner = MockCommandRunner(); mockedAnnotations = MockConstantReader(); - defaultAnnotations = (await resolveSource( - File('$testSpecPath/next_gen_builder_test_config.dart') - .readAsStringSync(), - (resolver) async => - (await resolver.findLibraryByName('test_lib'))!)) - .getClass('TestClassConfig')! - .metadata - .map((e) => ConstantReader(e.computeConstantValue()!)) - .first; + defaultAnnotations = + await loadAnnoation('next_gen_builder_test_config.dart'); realArguments = GeneratorArguments(annotations: defaultAnnotations); }); @@ -117,16 +109,8 @@ void main() { test('flutter when wrapper is fvm', () async { final logs = []; logger.onRecord.listen(logs.add); - final annotations = (await resolveSource( - File('$testSpecPath/next_gen_builder_fvm_test_config.dart') - .readAsStringSync(), - (resolver) async => - (await resolver.findLibraryByName('test_lib'))!)) - .getClass('TestClassConfig')! - .metadata - .map((e) => ConstantReader(e.computeConstantValue()!)) - .first; - + final annotations = + await loadAnnoation('next_gen_builder_fvm_test_config.dart'); when(mockRunner.checkForFlutterEnvironemt( wrapper: argThat( TypeMatcher() @@ -145,15 +129,8 @@ void main() { test('flutter when wrapper is ./flutter', () async { final logs = []; logger.onRecord.listen(logs.add); - final annotations = (await resolveSource( - File('$testSpecPath/next_gen_builder_flutterw_test_config.dart') - .readAsStringSync(), - (resolver) async => - (await resolver.findLibraryByName('test_lib'))!)) - .getClass('TestClassConfig')! - .metadata - .map((e) => ConstantReader(e.computeConstantValue()!)) - .first; + final annotations = + await loadAnnoation('next_gen_builder_flutterw_test_config.dart'); when(mockRunner.checkForFlutterEnvironemt( wrapper: argThat( @@ -173,15 +150,8 @@ void main() { test('when defined in pubspec', () async { final logs = []; logger.onRecord.listen(logs.add); - final annotations = (await resolveSource( - File('$testSpecPath/next_gen_builder_flutter_test_config.dart') - .readAsStringSync(), - (resolver) async => - (await resolver.findLibraryByName('test_lib'))!)) - .getClass('TestClassConfig')! - .metadata - .map((e) => ConstantReader(e.computeConstantValue()!)) - .first; + final annotations = + await loadAnnoation('next_gen_builder_flutter_test_config.dart'); when( mockRunner.checkForFlutterEnvironemt( @@ -201,6 +171,109 @@ void main() { }); }); + group('uses correct generator', () { + test('dart', () async { + final logs = []; + logger.onRecord.listen(logs.add); + + final annotations = + await loadAnnoation('next_gen_builder_local_test_config.dart'); + + when(mockRunner.runCommand( + command: anyNamed('command'), + workingDirectory: anyNamed('workingDirectory'))) + .thenAnswer( + (_) async => ProcessResult(999, 0, 'stdout', 'stderr')); + + when(mockRunner.isSpecFileDirty( + cachedSpec: anyNamed('cachedSpec'), + loadedSpec: anyNamed('loadedSpec'))) + .thenAnswer((_) async => true); + final args = GeneratorArguments(annotations: annotations); + await OpenapiGenerator(logger: logger, runner: mockRunner) + .generatorV2( + args: args, + baseCommand: 'dart', + annotatedPath: 'annotatedPath'); + final generationLogIndex = logs.indexWhere((element) => + element.message.contains( + 'Running following command to generate openapi client - ')); + logs.forEach((element) { + print(element.message); + }); + final log = logs[generationLogIndex]; + expect(log.message, contains('-g=dart')); + final sourceGenLogIndex = logs + .indexWhere((element) => element.message.contains('source gen')); + expect(logs[sourceGenLogIndex].message, + 'Skipping source gen because generator does not need it.'); + }); + test('dio', () async { + final logs = []; + logger.onRecord.listen(logs.add); + + final annotations = + await loadAnnoation('next_gen_builder_test_config.dart'); + + when(mockRunner.runCommand( + command: anyNamed('command'), + workingDirectory: anyNamed('workingDirectory'))) + .thenAnswer( + (_) async => ProcessResult(999, 0, 'stdout', 'stderr')); + + when(mockRunner.isSpecFileDirty( + cachedSpec: anyNamed('cachedSpec'), + loadedSpec: anyNamed('loadedSpec'))) + .thenAnswer((_) async => true); + final args = GeneratorArguments(annotations: annotations); + await OpenapiGenerator(logger: logger, runner: mockRunner) + .generatorV2( + args: args, + baseCommand: 'dart', + annotatedPath: 'annotatedPath'); + final generationLogIndex = logs.indexWhere((element) => + element.message.contains( + 'Running following command to generate openapi client - ')); + logs.forEach((element) { + print(element.message); + }); + final log = logs[generationLogIndex]; + expect(log.message, contains('-g=dart-dio')); + }); + test('dioAlt', () async { + final logs = []; + logger.onRecord.listen(logs.add); + + final annotations = + await loadAnnoation('next_gen_builder_dio_alt_test_config.dart'); + + when(mockRunner.runCommand( + command: anyNamed('command'), + workingDirectory: anyNamed('workingDirectory'))) + .thenAnswer( + (_) async => ProcessResult(999, 0, 'stdout', 'stderr')); + + when(mockRunner.isSpecFileDirty( + cachedSpec: anyNamed('cachedSpec'), + loadedSpec: anyNamed('loadedSpec'))) + .thenAnswer((_) async => true); + final args = GeneratorArguments(annotations: annotations); + await OpenapiGenerator(logger: logger, runner: mockRunner) + .generatorV2( + args: args, + baseCommand: 'dart', + annotatedPath: 'annotatedPath'); + final generationLogIndex = logs.indexWhere((element) => + element.message.contains( + 'Running following command to generate openapi client - ')); + logs.forEach((element) { + print(element.message); + }); + final log = logs[generationLogIndex]; + expect(log.message, contains('-g=dart2-api')); + }); + }); + group('generatorV2', () { group('completes successfully', () { late OpenapiGenerator generator; diff --git a/openapi-generator/test/specs/buckets.sh b/openapi-generator/test/specs/buckets.sh deleted file mode 100755 index 17ef658..0000000 --- a/openapi-generator/test/specs/buckets.sh +++ /dev/null @@ -1,6 +0,0 @@ -#!/bin/bash -# A simple bash script that sets up the local stack testing environment for AWS Remote specs -awslocal s3 mb s3://bucket -SPEC="$(curl -XGET https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml)" -echo "$SPEC" >> oasspec.yaml -awslocal s3api put-object --bucket bucket --key openapi.yaml --body oasspec.yaml \ No newline at end of file diff --git a/openapi-generator/test/specs/next_gen_builder_dio_alt_test_config.dart b/openapi-generator/test/specs/next_gen_builder_dio_alt_test_config.dart new file mode 100644 index 0000000..e147d6a --- /dev/null +++ b/openapi-generator/test/specs/next_gen_builder_dio_alt_test_config.dart @@ -0,0 +1,16 @@ +library test_lib; + +import 'package:openapi_generator_annotations/openapi_generator_annotations.dart'; + +@Openapi( + inputSpecFile: + 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', + inputSpec: RemoteSpec( + path: + 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', + ), + generatorName: Generator.dioAlt, + useNextGen: true, + cachePath: './test/specs/output-nextgen/expected-args/cache.json', + outputDirectory: './test/specs/output-nextgen/expected-args') +class TestClassConfig {} diff --git a/openapi-generator/test/specs/next_gen_builder_flutter_test_config.dart b/openapi-generator/test/specs/next_gen_builder_flutter_test_config.dart index b06211f..8f2f3c8 100644 --- a/openapi-generator/test/specs/next_gen_builder_flutter_test_config.dart +++ b/openapi-generator/test/specs/next_gen_builder_flutter_test_config.dart @@ -10,4 +10,4 @@ import 'package:openapi_generator_annotations/openapi_generator_annotations.dart cachePath: './test/specs/managed-cache.json', projectPubspecPath: './test/specs/flutter_pubspec.test.yaml', ) -class TestClassConfig extends OpenapiGeneratorConfig {} +class TestClassConfig {} diff --git a/openapi-generator/test/specs/next_gen_builder_flutterw_test_config.dart b/openapi-generator/test/specs/next_gen_builder_flutterw_test_config.dart index 8198482..f71442c 100644 --- a/openapi-generator/test/specs/next_gen_builder_flutterw_test_config.dart +++ b/openapi-generator/test/specs/next_gen_builder_flutterw_test_config.dart @@ -14,4 +14,4 @@ import 'package:openapi_generator_annotations/openapi_generator_annotations.dart additionalProperties: AdditionalProperties(wrapper: Wrapper.flutterw), cachePath: './test/specs/output-nextgen/expected-args/cache.json', outputDirectory: './test/specs/output-nextgen/expected-args') -class TestClassConfig extends OpenapiGeneratorConfig {} +class TestClassConfig {} diff --git a/openapi-generator/test/specs/next_gen_builder_fvm_test_config.dart b/openapi-generator/test/specs/next_gen_builder_fvm_test_config.dart index 2a316b5..69e4b5c 100644 --- a/openapi-generator/test/specs/next_gen_builder_fvm_test_config.dart +++ b/openapi-generator/test/specs/next_gen_builder_fvm_test_config.dart @@ -16,4 +16,4 @@ import 'package:openapi_generator_annotations/openapi_generator_annotations.dart useNextGen: true, cachePath: './test/specs/output-nextgen/expected-args/cache.json', outputDirectory: './test/specs/output-nextgen/expected-args') -class TestClassConfig extends OpenapiGeneratorConfig {} +class TestClassConfig {} diff --git a/openapi-generator/test/specs/next_gen_builder_local_test_config.dart b/openapi-generator/test/specs/next_gen_builder_local_test_config.dart new file mode 100644 index 0000000..ec5da7e --- /dev/null +++ b/openapi-generator/test/specs/next_gen_builder_local_test_config.dart @@ -0,0 +1,16 @@ +library test_lib; + +import 'package:openapi_generator_annotations/openapi_generator_annotations.dart'; + +@Openapi( + inputSpecFile: + 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', + inputSpec: InputSpec( + path: './test/specs/openapi.test.yaml', + ), + generatorName: Generator.dart, + fetchDependencies: true, + useNextGen: true, + cachePath: './test/specs/output-nextgen/expected-args/cache.json', + outputDirectory: './test/specs/output-nextgen/expected-args') +class TestClassConfig {} diff --git a/openapi-generator/test/specs/next_gen_builder_test_aws_config.dart b/openapi-generator/test/specs/next_gen_builder_test_aws_config.dart index 5fd3f12..d29e3b7 100644 --- a/openapi-generator/test/specs/next_gen_builder_test_aws_config.dart +++ b/openapi-generator/test/specs/next_gen_builder_test_aws_config.dart @@ -18,4 +18,4 @@ import 'package:openapi_generator_annotations/openapi_generator_annotations.dart useNextGen: true, cachePath: './test/specs/output-nextgen/expected-args/cache.json', outputDirectory: './test/specs/output-nextgen/expected-args') -class TestClassConfig extends OpenapiGeneratorConfig {} +class TestClassConfig {} diff --git a/openapi-generator/test/specs/next_gen_builder_test_config.dart b/openapi-generator/test/specs/next_gen_builder_test_config.dart index d9f36c3..859f19e 100644 --- a/openapi-generator/test/specs/next_gen_builder_test_config.dart +++ b/openapi-generator/test/specs/next_gen_builder_test_config.dart @@ -13,4 +13,4 @@ import 'package:openapi_generator_annotations/openapi_generator_annotations.dart useNextGen: true, cachePath: './test/specs/output-nextgen/expected-args/cache.json', outputDirectory: './test/specs/output-nextgen/expected-args') -class TestClassConfig extends OpenapiGeneratorConfig {} +class TestClassConfig {} diff --git a/openapi-generator/test/specs/test_config.dart b/openapi-generator/test/specs/test_config.dart index 89b72b0..c0e70b9 100644 --- a/openapi-generator/test/specs/test_config.dart +++ b/openapi-generator/test/specs/test_config.dart @@ -22,4 +22,4 @@ import 'package:openapi_generator_annotations/openapi_generator_annotations.dart overwriteExistingFiles: true, projectPubspecPath: './test/specs/dart_pubspec.test.yaml', ) -class TestClassConfig extends OpenapiGeneratorConfig {} +class TestClassConfig {} diff --git a/openapi-generator/test/test_annotations/test_configs.dart b/openapi-generator/test/test_annotations/test_configs.dart deleted file mode 100644 index 70bd3f4..0000000 --- a/openapi-generator/test/test_annotations/test_configs.dart +++ /dev/null @@ -1,79 +0,0 @@ -library test_annotations; - -import 'package:openapi_generator_annotations/openapi_generator_annotations.dart'; -import 'package:source_gen_test/annotations.dart'; - -@ShouldGenerate(r''' -const alwaysRun = false; - -const fetchDependencies = true; - -const generatorName = 'dio'; - -const inputSpecFile = ''; - -const runSourceGenOnOutput = true; - -const skipSpecValidation = false; - -const useNextGen = false; -''') -@Openapi(inputSpecFile: '', generatorName: Generator.dio) -class TestClassDefault extends OpenapiGeneratorConfig {} - -@ShouldThrow('useNextGen must be set when using cachePath', element: false) -@Openapi(inputSpecFile: '', generatorName: Generator.dio, cachePath: './') -class TestClassInvalidCachePathUsage extends OpenapiGeneratorConfig {} - -@ShouldGenerate(r''' -const additionalProperties = wrapper = 'flutterw'; - -const alwaysRun = false; - -const fetchDependencies = true; - -const generatorName = 'dart'; - -const inputSpecFile = ''; - -const runSourceGenOnOutput = true; - -const skipSpecValidation = false; - -const useNextGen = false; -''') -@Openapi( - inputSpecFile: '', - generatorName: Generator.dart, - additionalProperties: AdditionalProperties( - wrapper: Wrapper.flutterw, - ), -) -class TestClassHasCustomAnnotations extends OpenapiGeneratorConfig {} - -@ShouldGenerate(r''' -const additionalProperties = wrapper = 'flutterw', nullableFields = 'true'; - -const alwaysRun = false; - -const fetchDependencies = true; - -const generatorName = 'dart'; - -const inputSpecFile = ''; - -const runSourceGenOnOutput = true; - -const skipSpecValidation = false; - -const useNextGen = false; -''') -@Openapi( - inputSpecFile: '', - generatorName: Generator.dart, - additionalProperties: DioProperties( - wrapper: Wrapper.flutterw, - nullableFields: true, - ), -) -class TestClassHasDioProperties extends OpenapiGeneratorConfig {} diff --git a/openapi-generator/test/test_annotations/test_generator.dart b/openapi-generator/test/test_annotations/test_generator.dart deleted file mode 100644 index 1bee080..0000000 --- a/openapi-generator/test/test_annotations/test_generator.dart +++ /dev/null @@ -1,113 +0,0 @@ -import 'package:analyzer/dart/element/element.dart'; -import 'package:build/src/builder/build_step.dart'; -import 'package:openapi_generator/src/utils.dart'; -import 'package:openapi_generator_annotations/openapi_generator_annotations.dart'; -import 'package:source_gen/source_gen.dart' as src_gen; - -class TestGenerator extends src_gen.GeneratorForAnnotation { - final bool requireTestClassPrefix; - - const TestGenerator({this.requireTestClassPrefix = true}); - - @override - Iterable generateForAnnotatedElement(Element element, - src_gen.ConstantReader annotation, BuildStep buildStep) sync* { - assert(!annotation.isNull, 'The source generator should\'nt be null'); - - if (element is! ClassElement) { - throw src_gen.InvalidGenerationSourceError( - 'Only supports annotated classes.', - todo: 'Remove `TestAnnotation` from the associated element.', - element: element, - ); - } - - if (requireTestClassPrefix && !element.name.startsWith('TestClass')) { - throw src_gen.InvalidGenerationSourceError( - 'All classes must start with `TestClass`.', - todo: 'Rename the type or remove the `TestAnnotation` from class.', - element: element, - ); - } - - if (!(annotation.read('useNextGen').literalValue as bool)) { - if (annotation.read('cachePath').literalValue != null) { - throw src_gen.InvalidGenerationSourceError( - 'useNextGen must be set when using cachePath'); - } - } - - // KEEP THIS IN LINE WITH THE FIELDS OF THE ANNOTATION CLASS - final fields = [ - SupportedFields(name: 'additionalProperties', type: AdditionalProperties), - SupportedFields( - name: 'overwriteExistingFiles', isDeprecated: true, type: bool), - SupportedFields(name: 'skipSpecValidation', type: bool), - SupportedFields(name: 'inputSpecFile', isRequired: true, type: String), - SupportedFields(name: 'templateDirectory', type: String), - SupportedFields(name: 'generatorName', isRequired: true, type: Generator), - SupportedFields(name: 'outputDirectory', type: Map), - SupportedFields(name: 'typeMappings', type: Map), - SupportedFields(name: 'importMappings', type: Map), - SupportedFields(name: 'reservedWordsMappings', type: Map), - SupportedFields(name: 'inlineSchemaNameMappings', type: Map), - // SupportedFields(name:'inlineSchemaOptions'), - SupportedFields(name: 'apiPackage', type: String), - SupportedFields(name: 'fetchDependencies', type: bool), - SupportedFields(name: 'runSourceGenOnOutput', type: bool), - SupportedFields(name: 'alwaysRun', isDeprecated: true, type: bool), - SupportedFields(name: 'cachePath', type: String), - SupportedFields(name: 'useNextGen', type: bool), - SupportedFields(name: 'projectPubspecPath', type: String), - ]..sort((a, b) => a.name.compareTo(b.name)); - for (final field in fields) { - final v = annotation.read(field.name); - try { - if ([ - 'inputSpecFile', - 'projectPubspecPath', - 'apiPackage', - 'templateDirectory', - 'generatorName' - ].any((element) => field.name == element)) { - yield 'const ${field.name}=\'${convertToPropertyValue(v.objectValue)}\';\n'; - } else if (field.name == 'additionalProperties') { - final mapping = v.revive().namedArguments.map( - (key, value) => MapEntry(key, convertToPropertyValue(value))); - // TODO: Is this the expected behaviour? - // Iterable> entries; - // if (v.objectValue.type is DioProperties) { - // entries = DioProperties.fromMap(mapping).toMap().entries; - // } else if (v.objectValue.type is DioAltProperties) { - // entries = DioAltProperties.fromMap(mapping).toMap().entries; - // } else { - // entries = AdditionalProperties.fromMap(mapping).toMap().entries; - // } - yield 'const ${field.name}=${mapping.entries.fold('', foldStringMap(valueModifier: (value) => '\'$value\''))};'; - } else { - yield 'const ${field.name}=${convertToPropertyValue(v.objectValue)};\n'; - } - } catch (_, __) { - continue; - } - } - } - - @override - String toString() => - 'TestGenerator (requireTestClassPrefix:$requireTestClassPrefix)'; -} - -class SupportedFields { - final String name; - final bool isRequired; - final bool isDeprecated; - final T? type; - - const SupportedFields({ - required this.name, - this.isDeprecated = false, - this.isRequired = false, - required this.type, - }); -} diff --git a/openapi-generator/test/utils.dart b/openapi-generator/test/utils.dart index eea873a..97bdb38 100644 --- a/openapi-generator/test/utils.dart +++ b/openapi-generator/test/utils.dart @@ -1,54 +1,17 @@ import 'dart:io'; -import 'package:build/build.dart'; import 'package:build_test/build_test.dart'; -import 'package:openapi_generator/src/models/output_message.dart'; -import 'package:openapi_generator/src/openapi_generator_runner.dart'; import 'package:source_gen/source_gen.dart'; -final String pkgName = 'pkg'; - -final Builder builder = LibraryBuilder(OpenapiGenerator(testMode: true), - generatedExtension: '.openapi_generator'); final testSpecPath = '${Directory.current.path}${Platform.pathSeparator}test${Platform.pathSeparator}specs${Platform.pathSeparator}'; -/// Runs an in memory test variant of the generator with the given [source]. -/// -/// [path] available so an override for the adds generated comment test can -/// compare the output. -Future generate(String source, {String path = 'lib/myapp.dart'}) async { - final spec = File('${testSpecPath}openapi.test.yaml').readAsStringSync(); - var srcs = { - 'openapi_generator_annotations|lib/src/openapi_generator_annotations_base.dart': - File('../openapi-generator-annotations/lib/src/openapi_generator_annotations_base.dart') - .readAsStringSync(), - 'openapi_generator|$path': ''' - import 'package:openapi_generator_annotations/src/openapi_generator_annotations_base.dart'; - $source - class MyApp { - } - ''', - 'openapi_generator|openapi-spec.yaml': spec - }; - - // Capture any message from generation; if there is one, return that instead of - // the generated output. - String? logMessage; - void captureLog(dynamic logRecord) { - if (logRecord is OutputMessage) { - logMessage = - '${logMessage ?? ''}\n${logRecord.level} ${logRecord.message} \n ${logRecord.additionalContext} \n ${logRecord.stackTrace}'; - } else { - logMessage = - '${logMessage ?? ''}\n${logRecord.message ?? ''}\n${logRecord.error ?? ''}\n${logRecord.stackTrace ?? ''}'; - } - } - - var writer = InMemoryAssetWriter(); - await testBuilder(builder, srcs, - rootPackage: pkgName, writer: writer, onLog: captureLog); - return logMessage ?? - String.fromCharCodes( - writer.assets[AssetId(pkgName, 'lib/value.g.dart')] ?? []); -} +Future loadAnnoation(String testConfigPath) async => + (await resolveSource( + File('$testSpecPath/$testConfigPath').readAsStringSync(), + (resolver) async => + (await resolver.findLibraryByName('test_lib'))!)) + .getClass('TestClassConfig')! + .metadata + .map((e) => ConstantReader(e.computeConstantValue()!)) + .first; diff --git a/openapi-generator/test/verify_generation_test.dart b/openapi-generator/test/verify_generation_test.dart deleted file mode 100644 index e1dec00..0000000 --- a/openapi-generator/test/verify_generation_test.dart +++ /dev/null @@ -1,17 +0,0 @@ -import 'dart:io'; - -import 'package:openapi_generator_annotations/openapi_generator_annotations.dart'; -import 'package:source_gen_test/source_gen_test.dart'; - -import 'test_annotations/test_generator.dart'; - -void main() async { - final reader = await initializeLibraryReaderForDirectory( - '${Directory.current.path}${Platform.pathSeparator}test${Platform.pathSeparator}test_annotations', - 'test_configs.dart', - ); - - initializeBuildLogTracking(); - - testAnnotatedElements(reader, const TestGenerator()); -} From 37af696ac90f27e47c31f87bb5c60c952bf56230 Mon Sep 17 00:00:00 2001 From: Nexushunter Date: Tue, 19 Sep 2023 09:42:23 -0400 Subject: [PATCH 07/13] fix: Consume testing version of the source_gen branch to simplify testing. --- .../openapi_generator_annotations_base.dart | 14 +-- openapi-generator-annotations/pubspec.yaml | 8 ++ .../openapi_generator_annotations_test.dart | 2 +- openapi-generator/.gitignore | 1 + .../lib/src/extensions/type_methods.dart | 98 ------------------- .../lib/src/gen_on_spec_changes.dart | 34 +++---- .../lib/src/models/generator_arguments.dart | 75 +++++++------- .../lib/src/openapi_generator_runner.dart | 7 +- openapi-generator/pubspec.yaml | 9 ++ openapi-generator/test/command_test.dart | 80 +++++++++++++++ .../test/generator_arguments_test.dart | 50 ++++++---- openapi-generator/test/generator_test.dart | 40 ++++---- .../specs/next_gen_builder_test_config.dart | 2 +- 13 files changed, 211 insertions(+), 209 deletions(-) diff --git a/openapi-generator-annotations/lib/src/openapi_generator_annotations_base.dart b/openapi-generator-annotations/lib/src/openapi_generator_annotations_base.dart index 13861b3..289e6f6 100644 --- a/openapi-generator-annotations/lib/src/openapi_generator_annotations_base.dart +++ b/openapi-generator-annotations/lib/src/openapi_generator_annotations_base.dart @@ -1,8 +1,11 @@ +library openapi_generator_annotations; + import 'dart:convert'; import 'dart:io'; import 'package:crypto/crypto.dart'; import 'package:meta/meta.dart'; +import 'package:source_gen/source_gen.dart'; /// Config base class /// Your annotated class must extend this config class @@ -226,11 +229,6 @@ class RemoteSpec extends InputSpec { const RemoteSpec.empty() : this(path: 'http://localhost:8080/'); Uri get url => Uri.parse(path); - - RemoteSpec.fromMap(Map map) - : headerDelegate = - map['headerDelegate'] ?? const RemoteSpecHeaderDelegate(), - super.fromMap(map); } /// Default [RemoteSpecHeaderDelegate] used when retrieving a remote OAS spec. @@ -266,12 +264,6 @@ class AWSRemoteSpecHeaderDelegate extends RemoteSpecHeaderDelegate { this.accessKeyId = null, }) : super(); - AWSRemoteSpecHeaderDelegate.fromMap(Map map) - : bucket = map['bucket'], - accessKeyId = map['accessKeyId'], - secretAccessKey = map['secretAccessKey'], - super.fromMap(map); - /// Generates the [header] map used within the GET request. /// /// Assumes that the user's auth AWS credentials diff --git a/openapi-generator-annotations/pubspec.yaml b/openapi-generator-annotations/pubspec.yaml index 5dfa1cf..b5539e8 100644 --- a/openapi-generator-annotations/pubspec.yaml +++ b/openapi-generator-annotations/pubspec.yaml @@ -10,8 +10,16 @@ environment: dependencies: crypto: '>=3.0.0 <4.0.0' meta: '>=1.3.0 <2.0.0' + source_gen: dev_dependencies: test: source_gen_test: lint: + +dependency_overrides: + source_gen: + git: + ref: reviver + url: git@github.com:Nexushunter/source_gen.git + path: source_gen \ No newline at end of file diff --git a/openapi-generator-annotations/test/openapi_generator_annotations_test.dart b/openapi-generator-annotations/test/openapi_generator_annotations_test.dart index a8ea25b..26ab99b 100644 --- a/openapi-generator-annotations/test/openapi_generator_annotations_test.dart +++ b/openapi-generator-annotations/test/openapi_generator_annotations_test.dart @@ -91,6 +91,7 @@ void main() { expect(remote.path, 'http://localhost:8080/'); expect(remote.headerDelegate, isA()); }); + test('uses path', () { final remote = RemoteSpec(path: 'https://example.com/path'); expect(remote.path, 'https://example.com/path'); @@ -112,7 +113,6 @@ void main() { accessKeyId: 'test', secretAccessKey: 'test', ); - test('signs the url correctly', () { final now = DateTime.now(); final actual = delegate.authHeaderContent( diff --git a/openapi-generator/.gitignore b/openapi-generator/.gitignore index 125d434..1810161 100755 --- a/openapi-generator/.gitignore +++ b/openapi-generator/.gitignore @@ -169,5 +169,6 @@ example/.dart_tool # Generated test output test/specs/test-cached.json +test/specs/commands-cache.json test/specs/localstack test/mocks.mocks.dart \ No newline at end of file diff --git a/openapi-generator/lib/src/extensions/type_methods.dart b/openapi-generator/lib/src/extensions/type_methods.dart index dbeb212..72a7160 100644 --- a/openapi-generator/lib/src/extensions/type_methods.dart +++ b/openapi-generator/lib/src/extensions/type_methods.dart @@ -1,8 +1,6 @@ import 'dart:mirrors'; import 'package:analyzer/dart/element/type.dart'; -import 'package:openapi_generator/src/utils.dart'; -import 'package:openapi_generator_annotations/openapi_generator_annotations.dart'; import 'package:source_gen/source_gen.dart' show ConstantReader, TypeChecker; /// Extension adding the type methods to `ConstantReader`. @@ -73,99 +71,3 @@ extension TypeMethods on ConstantReader { return values[enumIndex]; } } - -extension ReadProperty on ConstantReader { - T readPropertyOrDefault(String name, T defaultValue) { - final v = peek(name); - if (v == null) { - return defaultValue; - } - - if (isA(v, InputSpec)) { - final revived = v.revive(); - - if (isA(v, RemoteSpec)) { - final map = revived.namedArguments; - final delegate = map['headerDelegate']; - final mapped = { - 'path': convertToPropertyValue(map['path']!), - }; - if (delegate?.isNull ?? true) { - return RemoteSpec.fromMap(mapped) as T; - } else { - final delegateReader = ConstantReader(delegate); - if (isA(delegateReader, AWSRemoteSpecHeaderDelegate)) { - mapped['headerDelegate'] = AWSRemoteSpecHeaderDelegate.fromMap( - delegateReader.revive().namedArguments.map( - (key, value) => MapEntry( - key, - convertToPropertyValue(value), - ), - ), - ); - } - return RemoteSpec.fromMap(mapped) as T; - } - } else { - final map = revived.namedArguments.map( - (key, value) => MapEntry( - key, - convertToPropertyValue(value), - ), - ); - return InputSpec.fromMap(map) as T; - } - } - - if (isA(v, AdditionalProperties)) { - final map = v.revive().namedArguments.map( - (key, value) => MapEntry( - key, - convertToPropertyValue(value), - ), - ); - if (isA(v, DioProperties)) { - return DioProperties.fromMap(map) as T; - } else if (isA(v, DioAltProperties)) { - return DioAltProperties.fromMap(map) as T; - } else { - return AdditionalProperties.fromMap(map) as T; - } - } - - if (isA(v, InlineSchemaOptions)) { - return InlineSchemaOptions.fromMap( - v.revive().namedArguments.map( - (key, value) => MapEntry( - key, - convertToPropertyValue(value), - ), - ), - ) as T; - } - - if (isA(v, Map)) { - return v.mapValue.map((key, value) => MapEntry( - convertToPropertyValue(key!), convertToPropertyValue(value!))) as T; - } else if (isA(v, bool)) { - return v.boolValue as T; - } else if (isA(v, double)) { - return v.doubleValue as T; - } else if (isA(v, int)) { - return v.intValue as T; - } else if (isA(v, String)) { - return v.stringValue as T; - } else if (isA(v, Set)) { - return v.setValue.map(convertToPropertyValue) as T; - } else if (isA(v, List)) { - return v.listValue.map(convertToPropertyValue) as T; - } else if (isA(v, Enum)) { - return v.enumValue(); - } else { - return defaultValue; - } - } -} - -bool isA(ConstantReader? v, Type t) => - v?.instanceOf(TypeChecker.fromRuntime(t)) ?? false; diff --git a/openapi-generator/lib/src/gen_on_spec_changes.dart b/openapi-generator/lib/src/gen_on_spec_changes.dart index e221305..176c6de 100644 --- a/openapi-generator/lib/src/gen_on_spec_changes.dart +++ b/openapi-generator/lib/src/gen_on_spec_changes.dart @@ -59,23 +59,23 @@ FutureOr> loadSpec( } } else { Map? headers; - if (specConfig.headerDelegate is AWSRemoteSpecHeaderDelegate) { - try { - headers = (specConfig.headerDelegate as AWSRemoteSpecHeaderDelegate) - .header(path: specConfig.url.path); - } catch (e, st) { - return Future.error( - OutputMessage( - message: 'failed to generate AWS headers', - additionalContext: e, - stackTrace: st, - level: Level.SEVERE, - ), - ); - } - } else { - headers = specConfig.headerDelegate.header(); - } + // if (specConfig.headerDelegate is AWSRemoteSpecHeaderDelegate) { + // try { + // headers = (specConfig.headerDelegate as AWSRemoteSpecHeaderDelegate) + // .header(path: specConfig.url.path); + // } catch (e, st) { + // return Future.error( + // OutputMessage( + // message: 'failed to generate AWS headers', + // additionalContext: e, + // stackTrace: st, + // level: Level.SEVERE, + // ), + // ); + // } + // } else { + // headers = specConfig.headerDelegate.header(); + // } final resp = await http.get(specConfig.url, headers: headers); if (resp.statusCode == 200) { diff --git a/openapi-generator/lib/src/models/generator_arguments.dart b/openapi-generator/lib/src/models/generator_arguments.dart index c43c392..ee5420b 100644 --- a/openapi-generator/lib/src/models/generator_arguments.dart +++ b/openapi-generator/lib/src/models/generator_arguments.dart @@ -2,10 +2,8 @@ import 'dart:async'; import 'dart:io'; import 'package:logging/logging.dart'; -import 'package:openapi_generator/src/extensions/type_methods.dart'; import 'package:openapi_generator/src/models/output_message.dart'; import 'package:openapi_generator_annotations/openapi_generator_annotations.dart'; -import 'package:source_gen/source_gen.dart' as src_gen; import '../utils.dart'; @@ -74,6 +72,7 @@ class GeneratorArguments { /// Use the provided spec instead of one located in [Directory.current]. /// /// Default: openapi.(ya?ml) | openapi.json + @Deprecated('Use inputSpec instead.') String _inputFile; /// Provides an OAS spec file. @@ -114,12 +113,12 @@ class GeneratorArguments { final InlineSchemaOptions? inlineSchemaOptions; GeneratorArguments({ - required src_gen.ConstantReader annotations, + required Openapi annotation, bool alwaysRun = false, - String inputSpecFile = '', + String? inputSpecFile, InputSpec inputSpec = const InputSpec.empty(), String templateDirectory = '', - Generator generator = Generator.dart, + Generator? generator, Map typeMapping = const {}, Map importMapping = const {}, Map reservedWordsMapping = const {}, @@ -130,47 +129,39 @@ class GeneratorArguments { bool runSourceGen = true, String? outputDirectory, bool fetchDependencies = true, - bool useNextGen = false, + bool? useNextGen, String? cachePath, String? pubspecPath, bool isDebug = false, - }) : alwaysRun = annotations.readPropertyOrDefault('alwaysRun', alwaysRun), - _inputFile = - annotations.readPropertyOrDefault('inputSpecFile', inputSpecFile), - templateDirectory = annotations.readPropertyOrDefault( - 'templateDirectory', templateDirectory), - generator = - annotations.readPropertyOrDefault('generatorName', generator), - typeMappings = - annotations.readPropertyOrDefault('typeMappings', typeMapping), - importMappings = - annotations.readPropertyOrDefault('importMappings', importMapping), - reservedWordsMappings = annotations.readPropertyOrDefault( - 'reservedWordsMappings', reservedWordsMapping), - inlineSchemaNameMappings = annotations.readPropertyOrDefault( - 'inlineSchemaNameMappings', inlineSchemaNameMapping), - additionalProperties = annotations.readPropertyOrDefault( - 'additionalProperties', additionalProperties), - inlineSchemaOptions = annotations.readPropertyOrDefault( - 'inlineSchemaOptions', inlineSchemaOptions), - skipValidation = annotations.readPropertyOrDefault( - 'skipSpecValidation', skipValidation), - runSourceGen = annotations.readPropertyOrDefault( - 'runSourceGenOnOutput', runSourceGen), - shouldFetchDependencies = annotations.readPropertyOrDefault( - 'fetchDependencies', fetchDependencies), - outputDirectory = annotations.readPropertyOrDefault( - 'outputDirectory', outputDirectory ?? Directory.current.path), - useNextGen = - annotations.readPropertyOrDefault('useNextGen', useNextGen), - cachePath = annotations.readPropertyOrDefault( - 'cachePath', cachePath ?? defaultCachedPath), - pubspecPath = annotations.readPropertyOrDefault( - 'projectPubspecPath', + }) : alwaysRun = annotation.alwaysRun ?? alwaysRun, + _inputFile = inputSpecFile ?? annotation.inputSpecFile, + templateDirectory = annotation.templateDirectory ?? templateDirectory, + generator = generator ?? annotation.generatorName, + typeMappings = annotation.typeMappings ?? typeMapping, + importMappings = annotation.importMappings ?? importMapping, + reservedWordsMappings = + annotation.reservedWordsMappings ?? reservedWordsMapping, + inlineSchemaNameMappings = + annotation.inlineSchemaNameMappings ?? inlineSchemaNameMapping, + additionalProperties = + additionalProperties ?? annotation.additionalProperties, + inlineSchemaOptions = inlineSchemaOptions, + // ?? annotations.readPropertyOrDefault( + // 'inlineSchemaOptions', inlineSchemaOptions), + skipValidation = annotation.skipSpecValidation ?? skipValidation, + runSourceGen = annotation.runSourceGenOnOutput ?? runSourceGen, + shouldFetchDependencies = + annotation.fetchDependencies ?? fetchDependencies, + outputDirectory = annotation.outputDirectory ?? + outputDirectory ?? + Directory.current.path, + useNextGen = useNextGen ?? annotation.useNextGen, + cachePath = cachePath ?? annotation.cachePath ?? defaultCachedPath, + pubspecPath = annotation.projectPubspecPath ?? pubspecPath ?? - '${Directory.current.path}${Platform.pathSeparator}pubspec.yaml'), - isDebug = annotations.readPropertyOrDefault('debugLogging', isDebug), - inputSpec = annotations.readPropertyOrDefault('inputSpec', inputSpec); + '${Directory.current.path}${Platform.pathSeparator}pubspec.yaml', + isDebug = annotation.debugLogging, + inputSpec = annotation.inputSpec ?? inputSpec; /// The stringified name of the [Generator]. String get generatorName => generator == Generator.dart diff --git a/openapi-generator/lib/src/openapi_generator_runner.dart b/openapi-generator/lib/src/openapi_generator_runner.dart index c42fb92..6e687e2 100755 --- a/openapi-generator/lib/src/openapi_generator_runner.dart +++ b/openapi-generator/lib/src/openapi_generator_runner.dart @@ -49,13 +49,14 @@ class OpenapiGenerator extends GeneratorForAnnotation { todo: 'Remove the [Openapi] annotation from `$friendlyName`.', ); } else { - if (!(annotations.read('useNextGen').literalValue as bool) && - annotations.read('cachePath').literalValue != null) { + final apiAnnotation = Reviver(annotations) as annots.Openapi; + + if (!apiAnnotation.useNextGen && apiAnnotation.cachePath != null) { throw AssertionError('useNextGen must be set when using cachePath'); } try { // Transform the annotations. - final args = GeneratorArguments(annotations: annotations); + final args = GeneratorArguments(annotation: apiAnnotation); // Determine if the project has a dependency on the flutter sdk or not. final baseCommand = await runner.checkForFlutterEnvironemt( wrapper: args.wrapper, providedPubspecPath: args.pubspecPath) diff --git a/openapi-generator/pubspec.yaml b/openapi-generator/pubspec.yaml index a785eba..ad6a235 100755 --- a/openapi-generator/pubspec.yaml +++ b/openapi-generator/pubspec.yaml @@ -25,3 +25,12 @@ dev_dependencies: pedantic: coverage: ^1.6.3 mockito: + +dependency_overrides: + openapi_generator_annotations: + path: ../openapi-generator-annotations + source_gen: + git: + ref: reviver + url: git@github.com:Nexushunter/source_gen.git + path: source_gen \ No newline at end of file diff --git a/openapi-generator/test/command_test.dart b/openapi-generator/test/command_test.dart index be502a7..23967fa 100644 --- a/openapi-generator/test/command_test.dart +++ b/openapi-generator/test/command_test.dart @@ -1,7 +1,11 @@ +import 'dart:io'; + import 'package:openapi_generator/src/models/command.dart'; import 'package:openapi_generator_annotations/openapi_generator_annotations.dart'; import 'package:test/test.dart'; +import 'utils.dart'; + void main() { group('Command', () { final testArgs = ['pub', 'get']; @@ -32,4 +36,80 @@ void main() { expect(command.executable, 'dart'); }); }); + + group('CommandRunner', () { + final runner = CommandRunner(); + test( + 'runCommand returns a process', + () async => expect( + await runner.runCommand( + command: Command(executable: 'dart', arguments: ['--version']), + workingDirectory: './'), + isA(), + ), + ); + test('loads an annotated file', () async { + expect( + await runner.loadAnnotatedFile( + path: '$testSpecPath/next_gen_builder_test_config.dart'), + '''library test_lib; + +import 'package:openapi_generator_annotations/openapi_generator_annotations.dart'; + +@Openapi( + inputSpecFile: + 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', + inputSpec: RemoteSpec( + path: + 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', + ), + generatorName: Generator.dio, + useNextGen: true, + cachePath: './test/specs/output-nextgen/expected-args/cache.json', + outputDirectory: './test/specs/output-nextgen/expected-args') +class TestClassConfig {}''' + .split('\n'), + ); + }); + test( + 'writes annotation file', + () async => expect( + runner.writeAnnotatedFile( + path: '$testSpecPath/next_gen_builder_test_config.dart', + content: '''library test_lib; + +import 'package:openapi_generator_annotations/openapi_generator_annotations.dart'; + +@Openapi( + inputSpecFile: + 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', + inputSpec: RemoteSpec( + path: + 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', + ), + generatorName: Generator.dio, + useNextGen: true, + cachePath: './test/specs/output-nextgen/expected-args/cache.json', + outputDirectory: './test/specs/output-nextgen/expected-args') +class TestClassConfig {}''' + .split('\n')), + completes)); + test( + 'writes cache spec file', + () async => expect( + runner.cacheSpecFile( + updatedSpec: {}, + cachedPath: '$testSpecPath/commands-cache.json'), + completes)); + test( + 'checks for flutter environment', + () async => expect( + await runner.checkForFlutterEnvironemt(wrapper: Wrapper.fvm), + isTrue)); + test( + 'checks spec dirty status', + () async => expect( + await runner.isSpecFileDirty(cachedSpec: {}, loadedSpec: {}), + isFalse)); + }); } diff --git a/openapi-generator/test/generator_arguments_test.dart b/openapi-generator/test/generator_arguments_test.dart index f7d676e..622b618 100644 --- a/openapi-generator/test/generator_arguments_test.dart +++ b/openapi-generator/test/generator_arguments_test.dart @@ -1,19 +1,18 @@ import 'dart:io'; -import 'package:build_test/build_test.dart'; import 'package:openapi_generator/src/models/generator_arguments.dart'; import 'package:openapi_generator/src/models/output_message.dart'; import 'package:openapi_generator/src/utils.dart'; import 'package:openapi_generator_annotations/openapi_generator_annotations.dart'; -import 'package:source_gen/source_gen.dart' as src_gen; import 'package:test/test.dart'; void main() { group('GeneratorArguments', () { group('defaults', () { late GeneratorArguments args; - setUpAll(() => - args = GeneratorArguments(annotations: src_gen.ConstantReader(null))); + setUpAll(() => args = GeneratorArguments( + annotation: + Openapi(inputSpecFile: '', generatorName: Generator.dart))); test('alwaysRun', () => expect(args.alwaysRun, isFalse)); test('useNextGen', () => expect(args.useNextGen, isFalse)); test('cachePath', () => expect(args.cachePath, defaultCachedPath)); @@ -82,9 +81,11 @@ void main() { }); }); group('accepts overrides', () { - final annos = src_gen.ConstantReader(null); final args = GeneratorArguments( - annotations: annos, + annotation: Openapi( + inputSpecFile: '', + generatorName: Generator.dart, + ), alwaysRun: true, useNextGen: true, cachePath: 'test', @@ -100,7 +101,9 @@ void main() { typeMapping: {'package': 'type'}, reservedWordsMapping: {'const': 'final'}, inlineSchemaNameMapping: {'L': 'R'}, - additionalProperties: AdditionalProperties(wrapper: Wrapper.fvm), + additionalProperties: AdditionalProperties( + wrapper: Wrapper.fvm, + ), pubspecPath: 'testing/pubspec.yaml', ); test('alwaysRun', () => expect(args.alwaysRun, isTrue)); @@ -154,18 +157,27 @@ void main() { ); }); test('uses config', () async { - final config = File( - '${Directory.current.path}${Platform.pathSeparator}test${Platform.pathSeparator}specs${Platform.pathSeparator}test_config.dart') - .readAsStringSync(); - final annotations = (await resolveSource( - config, - (resolver) async => - (await resolver.findLibraryByName('test_lib'))!)) - .getClass('TestClassConfig')! - .metadata - .map((e) => src_gen.ConstantReader(e.computeConstantValue()!)) - .first; - final args = GeneratorArguments(annotations: annotations); + final annotation = Openapi( + inputSpecFile: './openapi.test.yaml', + inputSpec: InputSpec(path: './test/specs/openapi.test.yaml'), + generatorName: Generator.dio, + useNextGen: true, + cachePath: './test/specs/output/cache.json', + typeMappings: {'key': 'value'}, + templateDirectory: 'template', + alwaysRun: true, + outputDirectory: './test/specs/output', + runSourceGenOnOutput: true, + apiPackage: 'test', + skipSpecValidation: false, + importMappings: {'package': 'test'}, + reservedWordsMappings: {'const': 'final'}, + additionalProperties: AdditionalProperties(wrapper: Wrapper.fvm), + inlineSchemaNameMappings: {'200resp': 'OkResp'}, + overwriteExistingFiles: true, + projectPubspecPath: './test/specs/dart_pubspec.test.yaml', + ); + final args = GeneratorArguments(annotation: annotation); expect(args.alwaysRun, isTrue); expect(args.useNextGen, isTrue); expect(args.cachePath, './test/specs/output/cache.json'); diff --git a/openapi-generator/test/generator_test.dart b/openapi-generator/test/generator_test.dart index c753f1f..136d9b7 100644 --- a/openapi-generator/test/generator_test.dart +++ b/openapi-generator/test/generator_test.dart @@ -9,7 +9,7 @@ import 'package:openapi_generator/src/models/output_message.dart'; import 'package:openapi_generator/src/openapi_generator_runner.dart'; import 'package:openapi_generator/src/utils.dart'; import 'package:openapi_generator_annotations/openapi_generator_annotations.dart'; -import 'package:source_gen/source_gen.dart'; +import 'package:source_gen/source_gen.dart' as src_gen; import 'package:test/test.dart'; import 'mocks.mocks.dart'; @@ -19,7 +19,8 @@ void main() { group('OpenApiGenerator', () { group('NextGen', () { late MockConstantReader mockedAnnotations; - late ConstantReader defaultAnnotations; + late src_gen.ConstantReader defaultAnnotations; + late Openapi annotation; late GeneratorArguments realArguments; late MockGeneratorArguments mockedArgs; late MockCommandRunner mockRunner; @@ -31,7 +32,8 @@ void main() { mockedAnnotations = MockConstantReader(); defaultAnnotations = await loadAnnoation('next_gen_builder_test_config.dart'); - realArguments = GeneratorArguments(annotations: defaultAnnotations); + annotation = src_gen.Reviver(defaultAnnotations).toInstance(); + realArguments = GeneratorArguments(annotation: annotation); }); test('should have banner logger', () async { @@ -60,8 +62,8 @@ void main() { MockMethodElement(), defaultAnnotations, MockBuildStep()); fail('Should throw when not ClassElement'); } catch (e, _) { - expect(e, isA()); - e as InvalidGenerationSourceError; + expect(e, isA()); + e as src_gen.InvalidGenerationSourceError; expect(e.message, 'Generator cannot target ``.'); expect(e.todo, 'Remove the [Openapi] annotation from ``.'); } @@ -176,9 +178,6 @@ void main() { final logs = []; logger.onRecord.listen(logs.add); - final annotations = - await loadAnnoation('next_gen_builder_local_test_config.dart'); - when(mockRunner.runCommand( command: anyNamed('command'), workingDirectory: anyNamed('workingDirectory'))) @@ -189,7 +188,7 @@ void main() { cachedSpec: anyNamed('cachedSpec'), loadedSpec: anyNamed('loadedSpec'))) .thenAnswer((_) async => true); - final args = GeneratorArguments(annotations: annotations); + final args = GeneratorArguments(annotation: annotation); await OpenapiGenerator(logger: logger, runner: mockRunner) .generatorV2( args: args, @@ -212,9 +211,6 @@ void main() { final logs = []; logger.onRecord.listen(logs.add); - final annotations = - await loadAnnoation('next_gen_builder_test_config.dart'); - when(mockRunner.runCommand( command: anyNamed('command'), workingDirectory: anyNamed('workingDirectory'))) @@ -225,7 +221,7 @@ void main() { cachedSpec: anyNamed('cachedSpec'), loadedSpec: anyNamed('loadedSpec'))) .thenAnswer((_) async => true); - final args = GeneratorArguments(annotations: annotations); + final args = GeneratorArguments(annotation: annotation); await OpenapiGenerator(logger: logger, runner: mockRunner) .generatorV2( args: args, @@ -244,9 +240,6 @@ void main() { final logs = []; logger.onRecord.listen(logs.add); - final annotations = - await loadAnnoation('next_gen_builder_dio_alt_test_config.dart'); - when(mockRunner.runCommand( command: anyNamed('command'), workingDirectory: anyNamed('workingDirectory'))) @@ -257,7 +250,20 @@ void main() { cachedSpec: anyNamed('cachedSpec'), loadedSpec: anyNamed('loadedSpec'))) .thenAnswer((_) async => true); - final args = GeneratorArguments(annotations: annotations); + final args = GeneratorArguments( + annotation: Openapi( + inputSpecFile: + 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', + inputSpec: RemoteSpec( + path: + 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', + ), + generatorName: Generator.dioAlt, + useNextGen: true, + cachePath: + './test/specs/output-nextgen/expected-args/cache.json', + outputDirectory: './test/specs/output-nextgen/expected-args'), + ); await OpenapiGenerator(logger: logger, runner: mockRunner) .generatorV2( args: args, diff --git a/openapi-generator/test/specs/next_gen_builder_test_config.dart b/openapi-generator/test/specs/next_gen_builder_test_config.dart index 859f19e..07546d2 100644 --- a/openapi-generator/test/specs/next_gen_builder_test_config.dart +++ b/openapi-generator/test/specs/next_gen_builder_test_config.dart @@ -13,4 +13,4 @@ import 'package:openapi_generator_annotations/openapi_generator_annotations.dart useNextGen: true, cachePath: './test/specs/output-nextgen/expected-args/cache.json', outputDirectory: './test/specs/output-nextgen/expected-args') -class TestClassConfig {} +class TestClassConfig {} \ No newline at end of file From 4156d9a18bf83337e608219315d19abbe08f8bd8 Mon Sep 17 00:00:00 2001 From: Nexushunter Date: Fri, 22 Sep 2023 20:54:04 -0400 Subject: [PATCH 08/13] fix: Correct most of the tests while using the newest verison of the source gen changes --- .../openapi_generator_annotations_test.dart | 1 + .../lib/src/models/generator_arguments.dart | 47 ++++++++++--------- .../lib/src/openapi_generator_runner.dart | 2 +- openapi-generator/test/generator_test.dart | 19 ++------ openapi-generator/test/mocks.dart | 2 - .../next_gen_builder_local_test_config.dart | 16 ------- .../next_gen_builder_test_aws_config.dart | 21 --------- ...next_gen_builder_test_invalid_config.dart} | 4 +- 8 files changed, 34 insertions(+), 78 deletions(-) delete mode 100644 openapi-generator/test/specs/next_gen_builder_local_test_config.dart delete mode 100644 openapi-generator/test/specs/next_gen_builder_test_aws_config.dart rename openapi-generator/test/specs/{next_gen_builder_dio_alt_test_config.dart => next_gen_builder_test_invalid_config.dart} (89%) diff --git a/openapi-generator-annotations/test/openapi_generator_annotations_test.dart b/openapi-generator-annotations/test/openapi_generator_annotations_test.dart index 26ab99b..3011960 100644 --- a/openapi-generator-annotations/test/openapi_generator_annotations_test.dart +++ b/openapi-generator-annotations/test/openapi_generator_annotations_test.dart @@ -176,6 +176,7 @@ void main() { } }); test('uses the provided environment', () async { + print(Directory.current.path); final result = Process.runSync( 'dart', [ diff --git a/openapi-generator/lib/src/models/generator_arguments.dart b/openapi-generator/lib/src/models/generator_arguments.dart index ee5420b..5ec1246 100644 --- a/openapi-generator/lib/src/models/generator_arguments.dart +++ b/openapi-generator/lib/src/models/generator_arguments.dart @@ -114,44 +114,47 @@ class GeneratorArguments { GeneratorArguments({ required Openapi annotation, - bool alwaysRun = false, + bool? alwaysRun, String? inputSpecFile, - InputSpec inputSpec = const InputSpec.empty(), - String templateDirectory = '', + InputSpec? inputSpec, + String? templateDirectory, Generator? generator, - Map typeMapping = const {}, - Map importMapping = const {}, - Map reservedWordsMapping = const {}, - Map inlineSchemaNameMapping = const {}, + Map? typeMapping, + Map? importMapping, + Map? reservedWordsMapping, + Map? inlineSchemaNameMapping, AdditionalProperties? additionalProperties, InlineSchemaOptions? inlineSchemaOptions, - bool skipValidation = false, - bool runSourceGen = true, + bool? skipValidation, + bool? runSourceGen, String? outputDirectory, - bool fetchDependencies = true, + bool? fetchDependencies, bool? useNextGen, String? cachePath, String? pubspecPath, - bool isDebug = false, - }) : alwaysRun = annotation.alwaysRun ?? alwaysRun, + bool? isDebug, + }) : alwaysRun = alwaysRun ?? annotation.alwaysRun ?? true, _inputFile = inputSpecFile ?? annotation.inputSpecFile, - templateDirectory = annotation.templateDirectory ?? templateDirectory, + templateDirectory = + templateDirectory ?? annotation.templateDirectory ?? '', generator = generator ?? annotation.generatorName, - typeMappings = annotation.typeMappings ?? typeMapping, - importMappings = annotation.importMappings ?? importMapping, + typeMappings = typeMapping ?? annotation.typeMappings ?? {}, + importMappings = importMapping ?? annotation.importMappings ?? {}, reservedWordsMappings = - annotation.reservedWordsMappings ?? reservedWordsMapping, - inlineSchemaNameMappings = - annotation.inlineSchemaNameMappings ?? inlineSchemaNameMapping, + reservedWordsMapping ?? annotation.reservedWordsMappings ?? {}, + inlineSchemaNameMappings = inlineSchemaNameMapping ?? + annotation.inlineSchemaNameMappings ?? + {}, additionalProperties = additionalProperties ?? annotation.additionalProperties, inlineSchemaOptions = inlineSchemaOptions, // ?? annotations.readPropertyOrDefault( // 'inlineSchemaOptions', inlineSchemaOptions), - skipValidation = annotation.skipSpecValidation ?? skipValidation, - runSourceGen = annotation.runSourceGenOnOutput ?? runSourceGen, + skipValidation = + skipValidation ?? annotation.skipSpecValidation ?? false, + runSourceGen = runSourceGen ?? annotation.runSourceGenOnOutput ?? true, shouldFetchDependencies = - annotation.fetchDependencies ?? fetchDependencies, + fetchDependencies ?? annotation.fetchDependencies ?? true, outputDirectory = annotation.outputDirectory ?? outputDirectory ?? Directory.current.path, @@ -161,7 +164,7 @@ class GeneratorArguments { pubspecPath ?? '${Directory.current.path}${Platform.pathSeparator}pubspec.yaml', isDebug = annotation.debugLogging, - inputSpec = annotation.inputSpec ?? inputSpec; + inputSpec = inputSpec ?? annotation.inputSpec ?? InputSpec.empty(); /// The stringified name of the [Generator]. String get generatorName => generator == Generator.dart diff --git a/openapi-generator/lib/src/openapi_generator_runner.dart b/openapi-generator/lib/src/openapi_generator_runner.dart index 6e687e2..4f182d5 100755 --- a/openapi-generator/lib/src/openapi_generator_runner.dart +++ b/openapi-generator/lib/src/openapi_generator_runner.dart @@ -49,7 +49,7 @@ class OpenapiGenerator extends GeneratorForAnnotation { todo: 'Remove the [Openapi] annotation from `$friendlyName`.', ); } else { - final apiAnnotation = Reviver(annotations) as annots.Openapi; + final apiAnnotation = Reviver(annotations).toInstance() as annots.Openapi; if (!apiAnnotation.useNextGen && apiAnnotation.cachePath != null) { throw AssertionError('useNextGen must be set when using cachePath'); diff --git a/openapi-generator/test/generator_test.dart b/openapi-generator/test/generator_test.dart index 136d9b7..efa9937 100644 --- a/openapi-generator/test/generator_test.dart +++ b/openapi-generator/test/generator_test.dart @@ -18,7 +18,6 @@ import 'utils.dart'; void main() { group('OpenApiGenerator', () { group('NextGen', () { - late MockConstantReader mockedAnnotations; late src_gen.ConstantReader defaultAnnotations; late Openapi annotation; late GeneratorArguments realArguments; @@ -29,7 +28,6 @@ void main() { resetMockitoState(); mockedArgs = MockGeneratorArguments(); mockRunner = MockCommandRunner(); - mockedAnnotations = MockConstantReader(); defaultAnnotations = await loadAnnoation('next_gen_builder_test_config.dart'); annotation = src_gen.Reviver(defaultAnnotations).toInstance(); @@ -71,19 +69,11 @@ void main() { test('throws AssertionError when useCache is set but useNextGen is not', () async { - final mockedUseNextGen = MockConstantReader(); - when(mockedUseNextGen.literalValue).thenReturn(false); - - final mockedUseCachePath = MockConstantReader(); - when(mockedUseCachePath.literalValue).thenReturn('something'); - - when(mockedAnnotations.read('useNextGen')).thenReturn(mockedUseNextGen); - when(mockedAnnotations.read('cachePath')) - .thenReturn(mockedUseCachePath); - try { await OpenapiGenerator().generateForAnnotatedElement( - MockClassElement(), mockedAnnotations, MockBuildStep()); + MockClassElement(), + await loadAnnoation('next_gen_builder_test_invalid_config.dart'), + MockBuildStep()); fail('Should throw when useNextGen is false and cache path is set.'); } catch (e, _) { expect(e, isA()); @@ -188,7 +178,8 @@ void main() { cachedSpec: anyNamed('cachedSpec'), loadedSpec: anyNamed('loadedSpec'))) .thenAnswer((_) async => true); - final args = GeneratorArguments(annotation: annotation); + final args = GeneratorArguments( + annotation: annotation, generator: Generator.dart); await OpenapiGenerator(logger: logger, runner: mockRunner) .generatorV2( args: args, diff --git a/openapi-generator/test/mocks.dart b/openapi-generator/test/mocks.dart index 301fd6f..d167d09 100644 --- a/openapi-generator/test/mocks.dart +++ b/openapi-generator/test/mocks.dart @@ -7,11 +7,9 @@ import 'package:openapi_generator/src/models/command.dart'; import 'package:openapi_generator/src/models/generator_arguments.dart'; import 'package:openapi_generator/src/openapi_generator_runner.dart'; import 'package:openapi_generator_annotations/openapi_generator_annotations.dart'; -import 'package:source_gen/source_gen.dart'; @GenerateNiceMocks([ MockSpec(), - MockSpec(), MockSpec(), MockSpec(), MockSpec(), diff --git a/openapi-generator/test/specs/next_gen_builder_local_test_config.dart b/openapi-generator/test/specs/next_gen_builder_local_test_config.dart deleted file mode 100644 index ec5da7e..0000000 --- a/openapi-generator/test/specs/next_gen_builder_local_test_config.dart +++ /dev/null @@ -1,16 +0,0 @@ -library test_lib; - -import 'package:openapi_generator_annotations/openapi_generator_annotations.dart'; - -@Openapi( - inputSpecFile: - 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', - inputSpec: InputSpec( - path: './test/specs/openapi.test.yaml', - ), - generatorName: Generator.dart, - fetchDependencies: true, - useNextGen: true, - cachePath: './test/specs/output-nextgen/expected-args/cache.json', - outputDirectory: './test/specs/output-nextgen/expected-args') -class TestClassConfig {} diff --git a/openapi-generator/test/specs/next_gen_builder_test_aws_config.dart b/openapi-generator/test/specs/next_gen_builder_test_aws_config.dart deleted file mode 100644 index d29e3b7..0000000 --- a/openapi-generator/test/specs/next_gen_builder_test_aws_config.dart +++ /dev/null @@ -1,21 +0,0 @@ -library test_lib; - -import 'package:openapi_generator_annotations/openapi_generator_annotations.dart'; - -@Openapi( - inputSpecFile: - 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', - inputSpec: RemoteSpec( - path: - 'http://bucket.s3.us-east-1.localhost.localstack.cloud:4566/openapi.yaml', - headerDelegate: AWSRemoteSpecHeaderDelegate( - bucket: 'bucket', - accessKeyId: 'test', - secretAccessKey: 'test', - ), - ), - generatorName: Generator.dio, - useNextGen: true, - cachePath: './test/specs/output-nextgen/expected-args/cache.json', - outputDirectory: './test/specs/output-nextgen/expected-args') -class TestClassConfig {} diff --git a/openapi-generator/test/specs/next_gen_builder_dio_alt_test_config.dart b/openapi-generator/test/specs/next_gen_builder_test_invalid_config.dart similarity index 89% rename from openapi-generator/test/specs/next_gen_builder_dio_alt_test_config.dart rename to openapi-generator/test/specs/next_gen_builder_test_invalid_config.dart index e147d6a..a19474d 100644 --- a/openapi-generator/test/specs/next_gen_builder_dio_alt_test_config.dart +++ b/openapi-generator/test/specs/next_gen_builder_test_invalid_config.dart @@ -9,8 +9,8 @@ import 'package:openapi_generator_annotations/openapi_generator_annotations.dart path: 'https://raw.githubusercontent.com/Nexushunter/tagmine-api/main/openapi.yaml', ), - generatorName: Generator.dioAlt, - useNextGen: true, + generatorName: Generator.dio, + useNextGen: false, cachePath: './test/specs/output-nextgen/expected-args/cache.json', outputDirectory: './test/specs/output-nextgen/expected-args') class TestClassConfig {} From 8266ab1b8d49350205ba5f43d9eefc4404029c59 Mon Sep 17 00:00:00 2001 From: Nexushunter Date: Fri, 22 Sep 2023 21:38:21 -0400 Subject: [PATCH 09/13] fix: dep override --- openapi-generator/pubspec.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/openapi-generator/pubspec.yaml b/openapi-generator/pubspec.yaml index 3256d5b..83c1451 100755 --- a/openapi-generator/pubspec.yaml +++ b/openapi-generator/pubspec.yaml @@ -32,5 +32,5 @@ dependency_overrides: source_gen: git: ref: reviver - url: git@github.com:Nexushunter/source_gen.git + url: https://github.com/Nexushunter/source_gen.git path: source_gen \ No newline at end of file From ea76ec8c12dc302b64060059f21b38fd75c45c93 Mon Sep 17 00:00:00 2001 From: Nexushunter Date: Fri, 22 Sep 2023 21:39:28 -0400 Subject: [PATCH 10/13] fix: dep overrides v2 --- openapi-generator-annotations/pubspec.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/openapi-generator-annotations/pubspec.yaml b/openapi-generator-annotations/pubspec.yaml index cdb217c..a1a8b8e 100644 --- a/openapi-generator-annotations/pubspec.yaml +++ b/openapi-generator-annotations/pubspec.yaml @@ -21,5 +21,5 @@ dependency_overrides: source_gen: git: ref: reviver - url: git@github.com:Nexushunter/source_gen.git + url: https://github.com/Nexushunter/source_gen.git path: source_gen \ No newline at end of file From e63c9b9b74cf681d1c16fb93f9b055c6f56cf3d4 Mon Sep 17 00:00:00 2001 From: Nexushunter Date: Sun, 24 Sep 2023 11:31:43 -0400 Subject: [PATCH 11/13] fix: fmt --- openapi-generator/lib/src/extensions/type_methods.dart | 2 +- openapi-generator/test/specs/next_gen_builder_test_config.dart | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/openapi-generator/lib/src/extensions/type_methods.dart b/openapi-generator/lib/src/extensions/type_methods.dart index 555447a..72a7160 100644 --- a/openapi-generator/lib/src/extensions/type_methods.dart +++ b/openapi-generator/lib/src/extensions/type_methods.dart @@ -70,4 +70,4 @@ extension TypeMethods on ConstantReader { return values[enumIndex]; } -} \ No newline at end of file +} diff --git a/openapi-generator/test/specs/next_gen_builder_test_config.dart b/openapi-generator/test/specs/next_gen_builder_test_config.dart index 07546d2..859f19e 100644 --- a/openapi-generator/test/specs/next_gen_builder_test_config.dart +++ b/openapi-generator/test/specs/next_gen_builder_test_config.dart @@ -13,4 +13,4 @@ import 'package:openapi_generator_annotations/openapi_generator_annotations.dart useNextGen: true, cachePath: './test/specs/output-nextgen/expected-args/cache.json', outputDirectory: './test/specs/output-nextgen/expected-args') -class TestClassConfig {} \ No newline at end of file +class TestClassConfig {} From 64090ffb09baacf234b8e80676d392d543045f3f Mon Sep 17 00:00:00 2001 From: Nexushunter Date: Sun, 24 Sep 2023 11:38:20 -0400 Subject: [PATCH 12/13] fix: update example dep override to have reviver --- example/pubspec.yaml | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/example/pubspec.yaml b/example/pubspec.yaml index 16e3f52..2dc40d3 100644 --- a/example/pubspec.yaml +++ b/example/pubspec.yaml @@ -27,7 +27,11 @@ dependency_overrides: path: ../openapi-generator openapi_generator_cli: path: ../openapi-generator-cli - + source_gen: + git: + ref: reviver + url: https://github.com/Nexushunter/source_gen + path: source_gen # Dependencies specify other packages that your package needs in order to work. # To automatically upgrade your package dependencies to the latest versions From bfb0ec4f66296e38d3ad3cb5dac15f532a477def Mon Sep 17 00:00:00 2001 From: Nexushunter Date: Sun, 24 Sep 2023 11:43:23 -0400 Subject: [PATCH 13/13] fix: Apply types to default empty maps --- .../lib/src/models/generator_arguments.dart | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/openapi-generator/lib/src/models/generator_arguments.dart b/openapi-generator/lib/src/models/generator_arguments.dart index 5ec1246..d82962c 100644 --- a/openapi-generator/lib/src/models/generator_arguments.dart +++ b/openapi-generator/lib/src/models/generator_arguments.dart @@ -138,13 +138,16 @@ class GeneratorArguments { templateDirectory = templateDirectory ?? annotation.templateDirectory ?? '', generator = generator ?? annotation.generatorName, - typeMappings = typeMapping ?? annotation.typeMappings ?? {}, - importMappings = importMapping ?? annotation.importMappings ?? {}, - reservedWordsMappings = - reservedWordsMapping ?? annotation.reservedWordsMappings ?? {}, + typeMappings = + typeMapping ?? annotation.typeMappings ?? {}, + importMappings = + importMapping ?? annotation.importMappings ?? {}, + reservedWordsMappings = reservedWordsMapping ?? + annotation.reservedWordsMappings ?? + {}, inlineSchemaNameMappings = inlineSchemaNameMapping ?? annotation.inlineSchemaNameMappings ?? - {}, + {}, additionalProperties = additionalProperties ?? annotation.additionalProperties, inlineSchemaOptions = inlineSchemaOptions,