Testing and debugging

You can download the required *-cli-config.json file from the Solution Envoy of the runtime (stage) you want to connect with. To do so

1. open Solution Designer

2. go to CI/CD

3. in the Pipeline Configurations table search for a "deploy" pipeline for your desired deployment target

4. click on the link provided in the Solution Envoy column

5. inside Solution Envoy click on Infrastructure

6. click on Download in the Solution CLI Setup window to download the config file

This file will be prefixed with the name of the stage and ending with -cli-config.json.

fss setup-envoy -f <path/to/your/{name of your stage}-cli-config.json>
fss prepare-debug

The CLI will prompt you to authenticate yourself.

Create a local-bindings.json file and place it in your project's root directory. Make sure it's added to the .gitignore file, so it will not get uploaded to your git repository.

Depending on your project you might have to set up event topic bindings if it uses events or API bindings for an API dependency that you modelled within an integration namespace. If your project uses both than you have to configure both in the local-bindings.json file.

The steps that must be followed are:

1. Open a *.test.ts file (it won't work with implementation files)

2. Set some breakpoints in the implementation files

3. Navigate to the debug section on the left menu bar

4. Launch the debug in VS Code on "Current Test"

5. On the sidebar it is possible to trace variables

Debug a Factory Command by following the structure below:

it('works on an existing rootEntity1 that we find', async () => {

    // The beforeAll() block will run automatically before this test, provided it was implemented

    const runner = new cptest_FactoryCommand1Runner();

    // Give input to factory command
    runner.input = testEnvironment.factory.entity.ns.FactoryCommandIdentifier_Input();
    runner.input.property1 =  value1;
    runner.input.property2 =  value2;

    // This will return the created instance of the root entity
    const factory_output = await runner.run();

    console.warn('No tests available');
    expect(true).to.equal(true);
});

Debug an Instance Command by following the structure below:

it('works on an existing rootEntity1 that we find', async () => {

    // Give input to factory command
    runner.input = testEnvironment.factory.entity.ns.InstanceCommandIdentifier_Input();
    runner.input.property1 =  value1;
    runner.input.property2 =  value2;


    // Use the Id of the created entity
    // This will return the modified instance of the root entity
    const instance_output =  await runner.run(createdEntity._id);

    console.warn('No tests available');
    expect(true).to.equal(true);

    instance_output._id;
    instance_output.prop1;
    instance_output.prop2;
});

Debug a Service by following the structure below:

it('works on an existing rootEntity1 that we find', async () => {

     // The beforeAll() block will run automatically before this test, provided it was implemented

     const runner = new cptest_Service1Runner();

     // Give input to factory command
     runner.input = testEnvironment.factory.entity.ns.Service1Identifier_Input();
     runner.input.property1 =  value1;
     runner.input.property2 =  value2;

     // This returns the output entity
     const service_output = await runner.run();

     console.warn('No tests available');
     expect(true).to.equal(true);

     // Get the output of the service and store it in local variable
     service_output.prop1;
     service_output.prop2;
});

Debug an External Entity by following the structure below:

describe('ns:ExternalEntityId', () => {

  const testEnvironment = new TestEnvironment();
  before(async () => {
    // This block will run automatically before all tests.
    // Alternatively, use beforeEach() to define what should automatically happen before each test.
    // This is an optional block.
  });
  after(async () => {
    // This block will run automatically after all tests.
    // Alternatively, use afterEach() to define what should automatically happen after each test.
    // This is an optional block.

    // Recommended: remove all instances that were created
    // await testEnvironment.cleanup();
  });

  describe('create', () => {
    it('works', async () => {
     // const runner = new externalEntityRunners.ns_ExternalEntityIdConstructorRunner();
     // await runner.run();
      console.warn('No tests available');
      expect(true).to.equal(true);
    });
  });

  describe('load', () => {
    it('works', async () => {
      // const runner = new externalEntityRunners.ns_ExternalEntityIdLoaderRunner();
      // await runner.run();
      console.warn('No tests available');
      expect(true).to.equal(true);
    });
  });

  describe('validate', () => {
    it('works', async () => {
       // const runner = new externalEntityRunners.ns_ExternalEntityIdValidatorRunner();
       // await runner.run(false);
      console.warn('No tests available');
      expect(true).to.equal(true);
    });
  });
});

Debug an Operation by following the structure below:

it('works on an existing rootEntity1 that we find', async () => {

    // The beforeAll() block will run automatically before this test, provided it was implemented

    const runner = new cptest_Service1Runner();

    // Initialize the path parameters of the operation
    runner.request.path.parameter1 =  value1;

    // Initialize the query parameters of the operation
    runner.request.query.parameter1 =  value2;

    // Initialize the request body and its properties of the operation
    // If body is a complex body
    runner.request.body =  testEnvironment.factory.schema.nspacrnm.SchemaIdentifier();
    runner.request.body.property1 = value1;
    runner.request.body.property2 = value2;

    await runner.run();

    console.warn('No tests available');
    expect(true).to.equal(true);

    // Get the output of the command and store it in local variable
    const operation_response = runner.response;
});

Debug an Error Middleware by following the structure below:

describe('apitest_ErrorMiddleware', () => {
  const testEnvironment = new TestEnvironment();
  before(async () => {
    // This block will run automatically before all tests.
    // Alternatively, use beforeEach() to define what should automatically happen before each test.
    // This is an optional block.
  });
  after(async () => {
    // This block will run automatically after all tests.
    // Alternatively, use afterEach() to define what should automatically happen after each test.
    // This is an optional block.

    // Recommended: remove all instances that were created
    // await testEnvironment.cleanup();
  });
  it('works', async () => {

    // Create runner instance
    const runner = new errorMiddlewareRunners.apitest_ErrorMiddlewareRunner();

    // Assign an error object that will be passed to error middleware
    runner.error = new cptest_SomeCustomError();

    // Execute error middleware
    await runner.run();

    // Have some expectation aganist the response returned from error middleware
    expect(runner.response.status).to.equal(500);
    expect(runner.response.body.code).to.equal('E19001');
    expect(runner.response.body.message).to.equal('An error occurred');
  });

});

1. Create a JSON file named log-config.json in your project's root directory

2. Add an entry in the .gitignore file for log-config.json so it is not pushed to your repository

3. Adjust your VS Code launch configuration to allow output display from std. Open .vscode/launch.json in configurations and add "outputCapture": "std"

The supported log levels are:

• error

• warn

• info

• debug

• trace

In the example below:

1. Every file under the path "/src-impl/api/apitest/operations" in your project will be configured to log level debug

2. Test file "/src-impl/api/apitest/operations/addDate.test" will be configured to log level warn

3. File "/src-impl/api/apitest/operations/addDate" will be configured to log level warn

4. All sdk files under "/sdk/v1" will be configured to log level error

5. All sdk files under "/sdk/v1/handler" will be configured to log level trace

{
  "/src-impl/api/apitest/operations/*": "debug",
  "/src-impl/api/apitest/operations/addDate.test": "warn",
  "/src-impl/api/apitest/operations/addDate": "trace",
  "/sdk/v1/*": "error",
  "/sdk/v1/handler/*": "trace"
}