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.

k5 setup-envoy -f <path/to/your/{name of your stage}-cli-config.json>
k5 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.

To configure the schema registry for local debugging, please execute the following steps:

1. Create a new file .env in the root directory of your project folder

2. Add the schema registry configuration properties to the .env. Please choose the right values, depending on your installation. You can get the relevant information either from your administrator or by checking the environment variables of your deployed service using the OpenShift console.

   SCHEMA_REGISTRY_SECURITY_ENABLED=<true/false>
   SCHEMA_REGISTRY_URL=<schema-registry-url>
   SCHEMA_REGISTRY_AUTH_SERVER_URL=<schema-registry-authentication-server-url>
   SCHEMA_REGISTRY_AUTH_REALM=<schema-registry-authentication-server-url>
   SCHEMA_REGISTRY_CLIENT_ID=<schema-registry-˚client-id>
   SCHEMA_REGISTRY_CLIENT_SECRET=<schema-registry-client-secret>

   Note:

SCHEMA_REGISTRY_AUTH_SERVER_URL, SCHEMA_REGISTRY_AUTH_REALM, SCHEMA_REGISTRY_CLIENT_ID, SCHEMA_REGISTRY_CLIENT_SECRET are only needed if the schema registry has security enabled

1. Open the file /.vscode/launch.json
2. Add the property "envFile" to the configurations and set the value to the just created .env file. The launch.json should look similar:

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "node",
      "request": "launch",
      "name": "Current Test",
      "protocol": "inspector",
      "showAsyncStacks": true,
      "console": "internalConsole",
      "internalConsoleOptions": "openOnSessionStart",
      "preLaunchTask": "Update Debug Credentials",
      "program": "${workspaceFolder}/node_modules/mocha/bin/_mocha",
      "cwd": "${workspaceFolder}/",
      "args": [
        "--require",
        "ts-node/register/transpile-only",
        "--colors",
        "${file}"
      ],
      "outputCapture": "std",
      "envFile": "${workspaceFolder}/.env"
    }
  ]
}

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();

    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);

    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 () => {
     // Initialize runner 
     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();

     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 Agent by following the structure below:

it('works on an existing agent', async () => {   
     // Initialize runner    
     const runner = new cptest_Agent1Runner();

     // Set message key, headers and timestamp 
     runner.messageKey = 'messageKey'
     runner.messageHeaders['key'] = 'value';
     runner.messageTimestamp = new Date.now().toString();

     // Execute Agent
     await runner.run();

     expect(true).to.equal(true);

});

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:

import { TestEnvironment } from 'solution-framework';
import { DebugRequestContext } from 'solution-framework';
import { loadAndPrepareDebugConfig } from 'solution-framework';
import { TestRequest as Request } from 'solution-framework';
import { ApiOperation1Api } from './ApiOperation1Api';
import { errors } from 'solution-framework';

describe('ApiOperation1Api', () => {
  const testEnvironment = new TestEnvironment();
  let requestContext: DebugRequestContext;
  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.
    requestContext = loadAndPrepareDebugConfig().requestContext;

  });
  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();
  });

});

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"
}