Functional Testing

We use functional tests to make sure the Kibana UI works as expected. It replaces hours of manual testing by automating user interaction. To have better control over our functional test environment, and to make it more accessible to plugin authors, Kibana uses a tool called the FunctionalTestRunner.

The FunctionalTestRunner is very bare bones and gets most of its functionality from its config file, located at {kib-repo}blob/6.8/test/functional/config.js[test/functional/config.js]. If you’re writing a plugin you will have your own config file. See Functional Tests for Plugins for more info.

There are three ways to run the tests depending on your goals:

When run without any arguments the FunctionalTestRunner automatically loads the configuration in the standard location, but you can override that behavior with the --config flag. List configs with multiple --config arguments.

There are also command line flags for --bail and --grep, which behave just like their mocha counterparts. For instance, use --grep=foo to run only tests that match a regular expression.

Logging can also be customized with --quiet, --debug, or --verbose flags.

Use the --help flag for more options.

The tests are written in mocha using expect for assertions.

We use chromedriver, leadfoot, and digdug for automating Chrome. When the FunctionalTestRunner launches, digdug opens a Tunnel which starts chromedriver and a stripped-down instance of Chrome. It also creates an instance of Leadfoot’s Command class, which is available via the remote service. The remote communicates to Chrome through the digdug Tunnel. See the leadfoot/Command API docs for all the commands you can use with remote.

The FunctionalTestRunner automatically transpiles functional tests using babel, so that tests can use the same ECMAScript features that Kibana source code uses. See {kib-repo}blob/6.8/style_guides/js_style_guide.md[style_guides/js_style_guide.md].

Provider:

Code run by the FunctionalTestRunner is wrapped in a function so it can be passed around via config files and be parameterized. Any of these Provider functions may be asynchronous and should return/resolve-to the value they are meant to provide. Provider functions will always be called with a single argument: a provider API (see the Provider API Section).

A config provider:

// config and test files use `export default`
export default function (/* { providerAPI } */) {
  return {
    // ...
  }
}

The annotated example file below shows the basic structure every test suite uses. It starts by importing expect.js and defining its default export: an anonymous Test Provider. The test provider then destructures the Provider API for the getService() and getPageObjects() functions. It uses these functions to collect the dependencies of this suite. The rest of the test file will look pretty normal to mocha.js users. describe(), it(), before() and the lot are used to define suites that happen to automate a browser via services and objects of type PageObject.

import expect from 'expect.js';
// test files must `export default` a function that defines a test suite
export default function ({ getService, getPageObject }) {

  // most test files will start off by loading some services
  const retry = getService('retry');
  const testSubjects = getService('testSubjects');
  const esArchiver = getService('esArchiver');

  // for historical reasons, PageObjects are loaded in a single API call
  // and returned on an object with a key/value for each requested PageObject
  const PageObjects = getPageObjects(['common', 'visualize']);

  // every file must define a top-level suite before defining hooks/tests
  describe('My Test Suite', () => {

    // most suites start with a before hook that navigates to a specific
    // app/page and restores some archives into elasticsearch with esArchiver
    before(async () => {
      await Promise.all([
        // start with an empty .kibana index
        esArchiver.load('empty_kibana'),
        // load some basic log data only if the index doesn't exist
        esArchiver.loadIfNeeded('makelogs')
      ]);
      // go to the page described by `apps.visualize` in the config
      await PageObjects.common.navigateTo('visualize');
    });

    // right after the before() hook definition, add the teardown steps
    // that will tidy up elasticsearch for other test suites
    after(async () => {
      // we unload the empty_kibana archive but not the makelogs
      // archive because we don't make any changes to it, and subsequent
      // suites could use it if they call `.loadIfNeeded()`.
      await esArchiver.unload('empty_kibana');
    });

    // This series of tests illustrate how tests generally verify
    // one step of a larger process and then move on to the next in
    // a new test, each step building on top of the previous
    it('Vis Listing Page is empty');
    it('Create a new vis');
    it('Shows new vis in listing page');
    it('Opens the saved vis');
    it('Respects time filter changes');
    it(...
  });

}

The first and only argument to all providers is a Provider API Object. This object can be used to load service/page objects and config/test files.

Within config files the API has the following properties

Within service and PageObject Providers the API is:

Within a test Provider the API is exactly the same as the service providers API but with an additional method:

The FunctionalTestRunner comes with three built-in services:

The Kibana functional tests define the vast majority of the actual functionality used by tests.

Services are intentionally generic. They can be literally anything (even nothing). Some services have helpers for interacting with a specific types of UI elements, like pointSeriesVis, and others are more foundational, like log or config. Whenever you want to provide some functionality in a reusable package, consider making a custom service.

To create a custom service somethingUseful:

The purpose for each PageObject is pretty self-explanatory. The visualize PageObject provides helpers for interacting with the visualize app, dashboard is the same for the dashboard app, and so on.

One exception is the "common" PageObject. A holdover from the intern implementation, the common PageObject is a collection of helpers useful across pages. Now that we have shareable services, and those services can be shared with other FunctionalTestRunner configurations, we will continue to move functionality out of the common PageObject and into services.

Please add new methods to existing or new services rather than further expanding the CommonPage class.

Remember that you can’t run an individual test in the file (it block) because the whole describe needs to be run in order. There should only be one top level describe in a file.

Another important gotcha is writing stable tests by being mindful of timing. All methods on remote run asynchronously. It’s better to write interactions that wait for changes on the UI to appear before moving onto the next step.

For example, rather than writing an interaction that simply clicks a button, write an interaction with the a higher-level purpose in mind:

Bad example: PageObjects.app.clickButton()

class AppPage {
  // what can people who call this method expect from the
  // UI after the promise resolves? Since the reaction to most
  // clicks is asynchronous the behavior is dependant on timing
  // and likely to cause test that fail unexpectedly
  async clickButton () {
    await testSubjects.click(‘menuButton’);
  }
}

Good example: PageObjects.app.openMenu()

class AppPage {
  // unlike `clickButton()`, callers of `openMenu()` know
  // the state that the UI will be in before they move on to
  // the next step
  async openMenu () {
    await testSubjects.click(‘menuButton’);
    await testSubjects.exists(‘menu’);
  }
}

Writing in this way will ensure your test timings are not flaky or based on assumptions about UI updates after interactions.

From the command line run:

node --debug-brk --inspect scripts/functional_test_runner

This prints out a URL that you can visit in Chrome and debug your functional tests in the browser.

You can also see additional logs in the terminal by running the FunctionalTestRunner with the --debug or --verbose flag. Add more logs with statements in your tests like

// load the log service
const log = getService(‘log’);

// log.debug only writes when using the `--debug` or `--verbose` flag.
log.debug(‘done clicking menu’);