fix: solving blackbox tests problems

docs/contributing.md

@@ -65,7 +65,7 @@ describe('LANGUAGE_MY_PRESET', () => {
  beforeEach(() => {
  generator = new LanguageGenerator({ presets: [LANGUAGE_MY_PRESET] });
  });
-
+ 
  test('should render xxx', async () => {
  const input = {
  $id: 'Clazz',

docs/presets.md

@@ -65,7 +65,7 @@ class Root {
 }
 ```
 
-The preset renderes the TypeScript class by calling **preset hooks**, which is callbacks that is called for rendering parts of the class. 
+The generator renderes the TypeScript class by calling **preset hooks**, which is callbacks that is called for rendering parts of the class. 
 ```html
 <self>
  <properties />

src/generators/csharp/CSharpFileGenerator.ts

@@ -11,14 +11,15 @@ export class CSharpFileGenerator extends CSharpGenerator implements AbstractFile
  * @param input
  * @param outputDirectory where you want the models generated to
  * @param options
+ * @param ensureFilesWritten verify that the files is completely written before returning, this can happen if the file system is swamped with write requests. 
  */
- public async generateToFiles(input: Record<string, unknown> | InputMetaModel, outputDirectory: string, options: CSharpRenderCompleteModelOptions): Promise<OutputModel[]> {
+ public async generateToFiles(input: Record<string, unknown> | InputMetaModel, outputDirectory: string, options: CSharpRenderCompleteModelOptions, ensureFilesWritten = false): Promise<OutputModel[]> {
  let generatedModels = await this.generateCompleteModels(input, options);
  //Filter anything out that have not been successfully generated
  generatedModels = generatedModels.filter((outputModel) => { return outputModel.modelName !== ''; });
  for (const outputModel of generatedModels) {
  const filePath = path.resolve(outputDirectory, `${outputModel.modelName}.cs`);
- await FileHelpers.writerToFileSystem(outputModel.result, filePath);
+ await FileHelpers.writerToFileSystem(outputModel.result, filePath, ensureFilesWritten);
  }
  return generatedModels;
  }

src/generators/dart/DartFileGenerator.ts

@@ -11,14 +11,15 @@ export class DartFileGenerator extends DartGenerator implements AbstractFileGene
  * @param input
  * @param outputDirectory where you want the models generated to
  * @param options
+ * @param ensureFilesWritten verify that the files is completely written before returning, this can happen if the file system is swamped with write requests. 
  */
- public async generateToFiles(input: Record<string, unknown> | InputMetaModel, outputDirectory: string, options: DartRenderCompleteModelOptions): Promise<OutputModel[]> {
+ public async generateToFiles(input: Record<string, unknown> | InputMetaModel, outputDirectory: string, options: DartRenderCompleteModelOptions, ensureFilesWritten = false): Promise<OutputModel[]> {
  let generatedModels = await this.generateCompleteModels(input, options);
  //Filter anything out that have not been successfully generated
  generatedModels = generatedModels.filter((outputModel) => { return outputModel.modelName !== ''; });
  for (const outputModel of generatedModels) {
  const filePath = path.resolve(outputDirectory, `${outputModel.modelName}.dart`);
- await FileHelpers.writerToFileSystem(outputModel.result, filePath);
+ await FileHelpers.writerToFileSystem(outputModel.result, filePath, ensureFilesWritten);
  }
  return generatedModels;
  }

src/generators/go/GoFileGenerator.ts

@@ -11,14 +11,15 @@ export class GoFileGenerator extends GoGenerator implements AbstractFileGenerato
  * @param input
  * @param outputDirectory where you want the models generated to
  * @param options
+ * @param ensureFilesWritten verify that the files is completely written before returning, this can happen if the file system is swamped with write requests. 
  */
- public async generateToFiles(input: Record<string, unknown> | InputMetaModel, outputDirectory: string, options: GoRenderCompleteModelOptions): Promise<OutputModel[]> {
+ public async generateToFiles(input: Record<string, unknown> | InputMetaModel, outputDirectory: string, options: GoRenderCompleteModelOptions, ensureFilesWritten = false): Promise<OutputModel[]> {
  let generatedModels = await this.generateCompleteModels(input, options);
  //Filter anything out that have not been successfully generated
  generatedModels = generatedModels.filter((outputModel) => { return outputModel.modelName !== ''; });
  for (const outputModel of generatedModels) {
  const filePath = path.resolve(outputDirectory, `${outputModel.modelName}.go`);
- await FileHelpers.writerToFileSystem(outputModel.result, filePath);
+ await FileHelpers.writerToFileSystem(outputModel.result, filePath, ensureFilesWritten);
  }
  return generatedModels;
  }

src/generators/java/JavaConstrainer.ts

@@ -1,4 +1,4 @@
-import { ConstrainedEnumValueModel } from 'models';
+import { ConstrainedEnumValueModel } from '../../models';
 import { TypeMapping } from '../../helpers';
 import { defaultEnumKeyConstraints, defaultEnumValueConstraints } from './constrainer/EnumConstrainer';
 import { defaultModelNameConstraints } from './constrainer/ModelNameConstrainer';

src/generators/java/JavaFileGenerator.ts

@@ -11,14 +11,15 @@ export class JavaFileGenerator extends JavaGenerator implements AbstractFileGene
  * @param input
  * @param outputDirectory where you want the models generated to
  * @param options
+ * @param ensureFilesWritten verify that the files is completely written before returning, this can happen if the file system is swamped with write requests. 
  */
- public async generateToFiles(input: Record<string, unknown> | InputMetaModel, outputDirectory: string, options: JavaRenderCompleteModelOptions): Promise<OutputModel[]> {
+ public async generateToFiles(input: Record<string, unknown> | InputMetaModel, outputDirectory: string, options: JavaRenderCompleteModelOptions, ensureFilesWritten = false): Promise<OutputModel[]> {
  let generatedModels = await this.generateCompleteModels(input, options);
  //Filter anything out that have not been successfully generated
  generatedModels = generatedModels.filter((outputModel) => { return outputModel.modelName !== ''; });
  for (const outputModel of generatedModels) {
  const filePath = path.resolve(outputDirectory, `${outputModel.modelName}.java`);
- await FileHelpers.writerToFileSystem(outputModel.result, filePath);
+ await FileHelpers.writerToFileSystem(outputModel.result, filePath, ensureFilesWritten);
  }
  return generatedModels;
  }

src/generators/java/JavaPreset.ts

@@ -1,5 +1,4 @@
-import { ConstrainedEnumModel } from 'models/ConstrainedMetaModel';
-import { Preset, ClassPreset, EnumPreset, PresetArgs, EnumArgs } from '../../models';
+import { Preset, ClassPreset, EnumPreset, PresetArgs, EnumArgs, ConstrainedEnumModel } from '../../models';
 import { JavaOptions } from './JavaGenerator';
 import { ClassRenderer, JAVA_DEFAULT_CLASS_PRESET } from './renderers/ClassRenderer';
 import { EnumRenderer, JAVA_DEFAULT_ENUM_PRESET } from './renderers/EnumRenderer';

src/generators/javascript/JavaScriptFileGenerator.ts

@@ -11,14 +11,15 @@ export class JavaScriptFileGenerator extends JavaScriptGenerator implements Abst
  * @param input
  * @param outputDirectory where you want the models generated to
  * @param options
+ * @param ensureFilesWritten verify that the files is completely written before returning, this can happen if the file system is swamped with write requests. 
  */
- public async generateToFiles(input: Record<string, unknown> | InputMetaModel, outputDirectory: string, options?: JavaScriptRenderCompleteModelOptions): Promise<OutputModel[]> {
+ public async generateToFiles(input: Record<string, unknown> | InputMetaModel, outputDirectory: string, options?: JavaScriptRenderCompleteModelOptions, ensureFilesWritten = false): Promise<OutputModel[]> {
  let generatedModels = await this.generateCompleteModels(input, options || {});
  //Filter anything out that have not been successfully generated
  generatedModels = generatedModels.filter((outputModel) => { return outputModel.modelName !== ''; });
  for (const outputModel of generatedModels) {
  const filePath = path.resolve(outputDirectory, `${outputModel.modelName}.js`);
- await FileHelpers.writerToFileSystem(outputModel.result, filePath);
+ await FileHelpers.writerToFileSystem(outputModel.result, filePath, ensureFilesWritten);
  }
  return generatedModels;
  }

src/generators/python/PythonFileGenerator.ts

@@ -11,14 +11,15 @@ export class PythonFileGenerator extends PythonGenerator implements AbstractFile
  * @param input
  * @param outputDirectory where you want the models generated to
  * @param options
+ * @param ensureFilesWritten verify that the files is completely written before returning, this can happen if the file system is swamped with write requests. 
  */
- public async generateToFiles(input: Record<string, unknown> | InputMetaModel, outputDirectory: string, options: PythonRenderCompleteModelOptions): Promise<OutputModel[]> {
+ public async generateToFiles(input: Record<string, unknown> | InputMetaModel, outputDirectory: string, options: PythonRenderCompleteModelOptions, ensureFilesWritten = false): Promise<OutputModel[]> {
  let generatedModels = await this.generateCompleteModels(input, options);
  //Filter anything out that have not been successfully generated
  generatedModels = generatedModels.filter((outputModel) => { return outputModel.modelName !== ''; });
  for (const outputModel of generatedModels) {
  const filePath = path.resolve(outputDirectory, `${outputModel.modelName}.py`);
- await FileHelpers.writerToFileSystem(outputModel.result, filePath);
+ await FileHelpers.writerToFileSystem(outputModel.result, filePath, ensureFilesWritten);
  }
  return generatedModels;
  }

src/generators/rust/RustFileGenerator.ts

@@ -11,15 +11,16 @@ export class RustFileGenerator extends RustGenerator implements AbstractFileGene
  * @param input
  * @param outputDirectory where you want the models generated to
  * @param options
+ * @param ensureFilesWritten verify that the files is completely written before returning, this can happen if the file system is swamped with write requests. 
  */
- public async generateToFiles(input: Record<string, unknown> | InputMetaModel, outputDirectory: string, options: RustRenderCompleteModelOptions): Promise<OutputModel[]> {
+ public async generateToFiles(input: Record<string, unknown> | InputMetaModel, outputDirectory: string, options: RustRenderCompleteModelOptions, ensureFilesWritten = false): Promise<OutputModel[]> {
  let generatedModels = await this.generateCompleteModels(input, options);
  //Filter anything out that have not been successfully generated
  generatedModels = generatedModels.filter((outputModel) => { return outputModel.modelName !== '' && outputModel.modelName !== undefined; });
  for (const outputModel of generatedModels) {
  const fileName = FormatHelpers.snakeCase(outputModel.modelName);
  const filePath = path.resolve(outputDirectory, `${fileName}.rs`);
- await FileHelpers.writerToFileSystem(outputModel.result, filePath);
+ await FileHelpers.writerToFileSystem(outputModel.result, filePath, ensureFilesWritten);
  }
  return generatedModels;
  }
@@ -30,18 +31,19 @@ export class RustFileGenerator extends RustGenerator implements AbstractFileGene
  * @param input
  * @param outputDirectory where you want the models generated to
  * @param options
+ * @param ensureFilesWritten verify that the files is completely written before returning, this can happen if the file system is swamped with write requests. 
  */
- public async generateToPackage(input: Record<string, unknown> | InputMetaModel, outputDirectory: string, options: RustRenderCompleteModelOptions): Promise<OutputModel[]> {
+ public async generateToPackage(input: Record<string, unknown> | InputMetaModel, outputDirectory: string, options: RustRenderCompleteModelOptions, ensureFilesWritten = false): Promise<OutputModel[]> {
  // Crate package expects source code to be written to src/<filename>.rs
  const sourceOutputDirectory = `${outputDirectory}/src`;
- let generatedModels = await this.generateToFiles(input, sourceOutputDirectory, options);
+ let generatedModels = await this.generateToFiles(input, sourceOutputDirectory, options, ensureFilesWritten);
  // render lib.rs and Cargo.toml
  if (options.supportFiles) {
  const supportOutput = await this.generateCompleteSupport(input, options);
  generatedModels = generatedModels.concat(supportOutput);
  for (const outputModel of supportOutput) {
  const filePath = path.resolve(outputDirectory, outputModel.model.name);
- await FileHelpers.writerToFileSystem(outputModel.result, filePath);
+ await FileHelpers.writerToFileSystem(outputModel.result, filePath, ensureFilesWritten);
  }
  }
  return generatedModels;

src/generators/rust/constrainer/EnumConstrainer.ts

@@ -46,7 +46,7 @@ export function defaultEnumKeyConstraints(customConstraints?: Partial<ModelEnumK
 }
 
 export function defaultEnumValueConstraints(): EnumValueConstraint {
- return ({enumValue}) => {
+ return ({ enumValue }) => {
  return enumValue;
  };
 }

src/generators/typescript/TypeScriptFileGenerator.ts

@@ -11,14 +11,15 @@ export class TypeScriptFileGenerator extends TypeScriptGenerator implements Abst
  * @param input
  * @param outputDirectory where you want the models generated to
  * @param options
+ * @param ensureFilesWritten verify that the files is completely written before returning, this can happen if the file system is swamped with write requests. 
  */
- public async generateToFiles(input: Record<string, unknown> | InputMetaModel, outputDirectory: string, options?: TypeScriptRenderCompleteModelOptions): Promise<OutputModel[]> {
+ public async generateToFiles(input: Record<string, unknown> | InputMetaModel, outputDirectory: string, options?: TypeScriptRenderCompleteModelOptions, ensureFilesWritten = false): Promise<OutputModel[]> {
  let generatedModels = await this.generateCompleteModels(input, options || {});
  //Filter anything out that have not been successfully generated
  generatedModels = generatedModels.filter((outputModel) => { return outputModel.modelName !== ''; });
  for (const outputModel of generatedModels) {
  const filePath = path.resolve(outputDirectory, `${outputModel.modelName}.ts`);
- await FileHelpers.writerToFileSystem(outputModel.result, filePath);
+ await FileHelpers.writerToFileSystem(outputModel.result, filePath, ensureFilesWritten);
  }
  return generatedModels;
  }

src/generators/typescript/TypeScriptGenerator.ts

@@ -4,7 +4,7 @@ import {
  defaultGeneratorOptions
 } from '../AbstractGenerator';
 import { ConstrainedEnumModel, ConstrainedMetaModel, ConstrainedObjectModel, InputMetaModel, MetaModel, RenderOutput } from '../../models';
-import { constrainMetaModel, Constraints, split, TypeMapping, hasPreset, renderJavaScriptDependency } from '../../helpers';
+import { constrainMetaModel, Constraints, split, TypeMapping, hasPreset, SplitOptions, renderJavaScriptDependency } from '../../helpers';
 import { TypeScriptPreset, TS_DEFAULT_PRESET } from './TypeScriptPreset';
 import { ClassRenderer } from './renderers/ClassRenderer';
 import { InterfaceRenderer } from './renderers/InterfaceRenderer';
@@ -31,7 +31,7 @@ export interface TypeScriptRenderCompleteModelOptions {
 /**
  * Generator for TypeScript
  */
-export class TypeScriptGenerator extends AbstractGenerator<TypeScriptOptions,TypeScriptRenderCompleteModelOptions> {
+export class TypeScriptGenerator extends AbstractGenerator<TypeScriptOptions, TypeScriptRenderCompleteModelOptions> {
  static defaultOptions: TypeScriptOptions = {
  ...defaultGeneratorOptions,
  renderTypes: true,
@@ -53,7 +53,7 @@ export class TypeScriptGenerator extends AbstractGenerator<TypeScriptOptions,Typ
 
  splitMetaModel(model: MetaModel): MetaModel[] {
  //These are the models that we have separate renderers for
- const metaModelsToSplit = {
+ const metaModelsToSplit: SplitOptions = {
  splitEnum: true, 
  splitObject: true
  };