private generateVariable()

in lib/apiScenario/gen/restlerApiScenarioGenerator.ts [314:386]

• 58 lines of code
• 17 McCabe index (conditional complexity)

  private generateVariable(parameter: Parameter): Variable | string | undefined {
    const genValue = (name: string, schema: Schema): VarValue => {
      if (util.isObject(schema)) {
        const ret: VarValue = {};
        const allOf = [...(schema.allOf ?? []), ...(schema.oneOf ?? [])];
        const s = {
          required: cloneDeep(schema.required) ?? [],
          properties: cloneDeep(schema.properties) ?? {},
        };
        while (allOf.length > 0) {
          const item = this.jsonLoader.resolveRefObj(allOf.shift()!);
          allOf.push(...(item.allOf ?? []), ...(item.oneOf ?? []));
          s.required = [...s.required, ...(item.required ?? [])];
          s.properties = { ...s.properties, ...(item.properties ?? {}) };
        }

        for (const name of s.required) {
          const prop = this.jsonLoader.resolveRefObj(s.properties[name]);
          ret[name] = genValue(name, prop);
        }

        return ret;
      }

      if (schema.default) {
        return schema.default;
      }

      if (schema.enum) {
        return schema.enum[0];
      }

      if (schema.type === "string" && envVariables.includes(name)) {
        return `$(${name})`;
      }

      if (schema.type === "array") {
        const prop = this.jsonLoader.resolveRefObj(schema.items!) as Schema;
        return this.mocker.mock(schema, name, genValue("", prop));
      }

      return this.mocker.mock(schema, name);
    };

    if (parameter.in === "body") {
      const schema = this.jsonLoader.resolveRefObj(parameter.schema!);
      const value: Variable = {
        type: "object",
        value: genValue(parameter.name, schema) as { [key: string]: VarValue },
      };
      return value;
    }

    if (parameter.in === "path" && parameter.type === "string") {
      // set prefix length to 8, thus 8+6<15, which is the minimum max length of resource name
      return { type: "string", prefix: `${parameter.name.toLocaleLowerCase().substring(0, 8)}` };
    }

    switch (parameter.type) {
      case "string":
        return this.mocker.mock(parameter, parameter.name);
      case "integer":
      case "number":
        return { type: "int", value: this.mocker.mock(parameter, parameter.name) };
      case "boolean":
        return { type: "bool", value: this.mocker.mock(parameter, parameter.name) };
      case "array":
        return { type: "array", value: this.mocker.mock(parameter, parameter.name) };
      default:
        logger.warn(`Unsupported type ${parameter.type} of parameter ${parameter.name}`);
        return undefined;
    }
  }