public generateCode()

in packages/autorest.gotest/src/generator/fakeTestGenerator.ts [22:99]


  public generateCode(extraParam: Record<string, unknown> = {}): void {
    this.renderAndWrite(this.context.codeModel.testModel.mockTest, 'fakeTest.go.njk', `${this.getFilePrefix(Config.testFilePrefix)}fake_test.go`, extraParam, {
      getParamsValue: (params: Array<ParameterOutput>) => {
        return params
          .map((p) => {
            if (p.paramName == 'subscriptionID') {
              return 'testsuite.subscriptionId';
            }
            return p.paramOutput;
          })
          .join(', ');
      },
      getExampleParams: (params: Array<ParameterOutput>) => {
        return params
          .map((p) => {
            if (p.paramName === 'ctx' || p.paramName === 'options') {
              return p.paramOutput;
            }
            return 'example' + capitalize(p.paramName);
          })
          .join(', ');
      },
      getHttpCode: (op: Operation) => {
        const successCodes = new Array<string>();
        if (isMultiRespOperation(op)) {
          for (const response of values(op.responses)) {
            if (!isSchemaResponse(response)) {
              // the operation contains a mix of schemas and non-schema responses
              successCodes.push(`${formatStatusCode(response.protocol.http!.statusCodes[0])}`);
              continue;
            }
            successCodes.push(`${formatStatusCode(response.protocol.http!.statusCodes[0])}`);
          }
        } else {
          for (const statusCode of values(getStatusCodes(op))) {
            successCodes.push(`${formatStatusCode(statusCode)}`);
          }
        }
        for (const successCode of successCodes) {
          return successCode;
        }
      },
      funcMethodReturns: (op: Operation, packageName: string): string => {
        let serverResponse = undefined;
        if (isLROOperation(op)) {
          let respType = `${packageName}.${getResponseEnvelopeName(op)}`;
          if (isPageableOperation(op)) {
            respType = `azfake.PagerResponder[${packageName}.${getResponseEnvelopeName(op)}]`;
          }
          serverResponse = `resp azfake.PollerResponder[${respType}], errResp azfake.ErrorResponder`;
        } else if (isPageableOperation(op)) {
          // if (op.language.go!.paging.isNextOp) {
          //   // we don't generate a public API for the methods used to advance pages, so skip it here
          // //   continue;
          // }
          serverResponse = `resp azfake.PagerResponder[${packageName}.${getResponseEnvelopeName(op)}]`;
        } else {
          serverResponse = `resp azfake.Responder[${packageName}.${getResponseEnvelopeName(op)}], errResp azfake.ErrorResponder`;
        }

        return `func(${getAPIParametersSig(op, packageName)}) (${serverResponse})`;
      },
      getParameterType: (op: Operation, pkgName: string, paramName: string): string => {
        const methodParams = getMethodParameters(op);
        for (const methodParam of values(methodParams)) {
          if (methodParam.language.go!.name === paramName) {
            return formatParameterTypeName(methodParam, pkgName);
          }
        }
        return;
      },
      capitalize: capitalize,
      uncapitalize: uncapitalize,
      cutClientSuffix: (client: string): string => {
        return client.substring(0, client.lastIndexOf('Client'));
      },
    });
  }