blockly/tests/mocha/tooltip_test.js

/**
 * @license
 * Copyright 2020 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */

goog.declareModuleId('Blockly.test.tooltip');

import {sharedTestSetup, sharedTestTeardown, workspaceTeardown} from './test_helpers/setup_teardown.js';


suite('Tooltip', function() {
  setup(function() {
    sharedTestSetup.call(this);
    this.workspace = new Blockly.Workspace();

    Blockly.defineBlocksWithJsonArray([
      {
        'type': 'test_block',
        'message0': '%1',
        'args0': [
          {
            'type': 'field_input',
            'name': 'FIELD',
          },
        ],
      },
    ]);
  });

  teardown(function() {
    delete Blockly.Blocks['test_block'];
    sharedTestTeardown.call(this);
  });

  suite('Custom Tooltip', function() {
    setup(function() {
      this.renderedWorkspace = Blockly.inject('blocklyDiv', {});
    });

    teardown(function() {
      workspaceTeardown.call(this, this.renderedWorkspace);
    });

    test('Custom function is called', function() {
      // Custom tooltip function is registered and should be called when mouse
      // events are fired.
      let wasCalled = false;
      const customFn = function() {
        wasCalled = true;
      };
      Blockly.Tooltip.setCustomTooltip(customFn);

      this.block = this.renderedWorkspace.newBlock('test_block');
      this.block.setTooltip('Test Tooltip');

      // Fire pointer events directly on the relevant SVG.
      this.block.pathObject.svgPath.dispatchEvent(
          new PointerEvent('pointerover'));
      this.block.pathObject.svgPath.dispatchEvent(new PointerEvent('pointermove'));
      this.clock.runAll();

      chai.assert.isTrue(
          wasCalled, 'Expected custom tooltip function to have been called');
    });
  });

  suite('set/getTooltip', function() {
    const tooltipText = 'testTooltip';

    function assertTooltip(obj) {
      chai.assert.equal(obj.getTooltip(), tooltipText);
    }

    function setStringTooltip(obj) {
      obj.setTooltip(tooltipText);
    }

    function setFunctionTooltip(obj) {
      obj.setTooltip(() => tooltipText);
    }

    function setNestedFunctionTooltip(obj) {
      function nestFunction(fn, count) {
        if (!count) {
          return fn;
        }
        return () => nestFunction(fn, --count);
      }
      obj.setTooltip(nestFunction(() => tooltipText, 5));
    }

    function setFunctionReturningObjectTooltip(obj) {
      obj.setTooltip(() => {
        return {
          tooltip: tooltipText,
        };
      });
    }

    function setObjectTooltip(obj) {
      obj.setTooltip({tooltip: tooltipText});
    }

    suite('Headless Blocks', function() {
      setup(function() {
        this.block = this.workspace.newBlock('test_block');
      });

      test('String', function() {
        setStringTooltip(this.block);
        assertTooltip(this.block);
      });

      test('Function', function() {
        setFunctionTooltip(this.block);
        assertTooltip(this.block);
      });

      test('Nested Function', function() {
        setNestedFunctionTooltip(this.block);
        assertTooltip(this.block);
      });

      test('Function returning object', function() {
        setFunctionReturningObjectTooltip(this.block);
        chai.assert.throws(
            this.block.getTooltip.bind(this.block),
            'Tooltip function must return a string.');
      });

      test('Object', function() {
        setObjectTooltip(this.block);
        assertTooltip(this.block);
      });
    });

    suite('Rendered Blocks', function() {
      setup(function() {
        this.renderedWorkspace = Blockly.inject('blocklyDiv');
        this.block = this.renderedWorkspace.newBlock('test_block');
        this.block.initSvg();
        this.block.render();
      });

      teardown(function() {
        workspaceTeardown.call(this, this.renderedWorkspace);
      });

      test('String', function() {
        setStringTooltip(this.block);
        assertTooltip(this.block);
      });

      test('Function', function() {
        setFunctionTooltip(this.block);
        assertTooltip(this.block);
      });

      test('Nested Function', function() {
        setNestedFunctionTooltip(this.block);
        assertTooltip(this.block);
      });

      test('Function returning object', function() {
        setFunctionReturningObjectTooltip(this.block);
        chai.assert.throws(
            this.block.getTooltip.bind(this.block),
            'Tooltip function must return a string.');
      });

      test('Object', function() {
        setObjectTooltip(this.block);
        assertTooltip(this.block);
      });
    });

    suite('Headless Fields', function() {
      setup(function() {
        this.block = this.workspace.newBlock('test_block');
        this.field = this.block.getField('FIELD');
      });

      test('String', function() {
        setStringTooltip(this.field);
        assertTooltip(this.field);
      });

      test('Function', function() {
        setFunctionTooltip(this.field);
        assertTooltip(this.field);
      });

      test('Nested Function', function() {
        setNestedFunctionTooltip(this.field);
        assertTooltip(this.field);
      });

      test('Function returning object', function() {
        setFunctionReturningObjectTooltip(this.field);
        chai.assert.throws(
            this.field.getTooltip.bind(this.field),
            'Tooltip function must return a string.');
      });

      test('Object', function() {
        setObjectTooltip(this.field);
        assertTooltip(this.field);
      });

      test('Null', function() {
        setStringTooltip(this.block);
        this.field.setTooltip(null);
        assertTooltip(this.field);
      });
    });

    suite('Rendered Fields', function() {
      setup(function() {
        this.renderedWorkspace = Blockly.inject('blocklyDiv');
        this.block = this.renderedWorkspace.newBlock('test_block');
        this.block.initSvg();
        this.block.render();
        this.field = this.block.getField('FIELD');
      });

      teardown(function() {
        workspaceTeardown.call(this, this.renderedWorkspace);
      });

      test('String', function() {
        setStringTooltip(this.field);
        assertTooltip(this.field);
      });

      test('Function', function() {
        setFunctionTooltip(this.field);
        assertTooltip(this.field);
      });

      test('Nested Function', function() {
        setNestedFunctionTooltip(this.field);
        assertTooltip(this.field);
      });

      test('Function returning object', function() {
        setFunctionReturningObjectTooltip(this.field);
        chai.assert.throws(
            this.field.getTooltip.bind(this.field),
            'Tooltip function must return a string.');
      });

      test('Object', function() {
        setObjectTooltip(this.field);
        assertTooltip(this.field);
      });

      test('Null', function() {
        setStringTooltip(this.block);
        this.field.setTooltip(null);
        assertTooltip(this.field);
      });
    });
  });
});