scratch-blocks 1.2.0-beta.1 → 2.0.0-beta.2

package/blockly-rc/tests/mocha/test_helpers/serialization.js

@@ -1,124 +0,0 @@
-/**
- * @license
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {assert} from '../../../node_modules/chai/chai.js';
-import {runTestCases} from './common.js';
-
-/**
- * Serialization test case.
- * @implements {TestCase}
- * @record
- */
-export class SerializationTestCase {
-  /**
-   * Class for a block serialization test case.
-   */
-  constructor() {
-    /**
-     * @type {string} The block xml to use for test. Do not provide if json is
-     *     provided.
-     */
-    this.xml;
-    /**
-     * @type {string|undefined} The expected xml after round trip. Provided if
-     *    it different from xml that was passed in.
-     */
-    this.expectedXml;
-    /**
-     * @type {string} The block json to use for test. Do not provide if xml is
-     *     provided.
-     */
-    this.json;
-    /**
-     * @type {string|undefined} The expected json after round trip. Provided if
-     *    it is different from json that was passed in.
-     */
-    this.expectedJson;
-  }
-  /**
-   * Asserts that the block created from xml has the expected structure.
-   * @param {!Blockly.Block} block The block to check.
-   */
-  assertBlockStructure(block) {}
-}
-
-/**
- * Runs serialization test suite.
- * @param {!Array<!SerializationTestCase>} testCases The test cases to run.
- */
-export const runSerializationTestSuite = (testCases) => {
-  /**
-   * Creates test callback for xmlToBlock test.
-   * @param {!SerializationTestCase} testCase The test case information.
-   * @return {!Function} The test callback.
-   */
-  const createSerializedDataToBlockTestCallback = (testCase) => {
-    return function () {
-      let block;
-      if (testCase.json) {
-        block = Blockly.serialization.blocks.append(
-          testCase.json,
-          this.workspace,
-          {recordUndo: true},
-        );
-      } else {
-        block = Blockly.Xml.domToBlock(
-          Blockly.utils.xml.textToDom(testCase.xml),
-          this.workspace,
-        );
-      }
-      this.clock.runAll();
-      testCase.assertBlockStructure(block);
-    };
-  };
-  /**
-   * Creates test callback for xml round trip test.
-   * @param {!SerializationTestCase} testCase The test case information.
-   * @return {!Function} The test callback.
-   */
-  const createRoundTripTestCallback = (testCase) => {
-    return function () {
-      if (testCase.json) {
-        const block = Blockly.serialization.blocks.append(
-          testCase.json,
-          this.workspace,
-          {recordUndo: true},
-        );
-        this.clock.runAll();
-        const generatedJson = Blockly.serialization.blocks.save(block);
-        const expectedJson = testCase.expectedJson || testCase.json;
-        assert.deepEqual(generatedJson, expectedJson);
-      } else {
-        const block = Blockly.Xml.domToBlock(
-          Blockly.utils.xml.textToDom(testCase.xml),
-          this.workspace,
-        );
-        this.clock.runAll();
-        const generatedXml = Blockly.Xml.domToPrettyText(
-          Blockly.Xml.blockToDom(block),
-        );
-        const expectedXml = testCase.expectedXml || testCase.xml;
-        assert.equal(generatedXml, expectedXml);
-      }
-    };
-  };
-  suite('Serialization', function () {
-    suite('xmlToBlock', function () {
-      runTestCases(testCases, createSerializedDataToBlockTestCallback);
-    });
-    suite('xml round-trip', function () {
-      setup(function () {
-        sinon.stub(Blockly.utils.idGenerator.TEST_ONLY, 'genUid').returns('1');
-      });
-
-      teardown(function () {
-        sinon.restore();
-      });
-
-      runTestCases(testCases, createRoundTripTestCallback);
-    });
-  });
-};

package/blockly-rc/tests/mocha/test_helpers/setup_teardown.js

@@ -1,209 +0,0 @@
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as eventUtils from '../../../build/src/core/events/utils.js';
-
-/**
- * Safely disposes of Blockly workspace, logging any errors.
- * Assumes that sharedTestSetup has also been called. This should be called
- * using workspaceTeardown.call(this).
- * @param {!Blockly.Workspace} workspace The workspace to dispose.
- */
-export function workspaceTeardown(workspace) {
-  try {
-    this.clock.runAll(); // Run all queued setTimeout calls.
-    workspace.dispose();
-    this.clock.runAll(); // Run all remaining queued setTimeout calls.
-  } catch (e) {
-    const testRef = this.currentTest || this.test;
-    console.error(testRef.fullTitle() + '\n', e);
-  }
-}
-
-/**
- * Creates stub for Blockly.Events.fire that advances the clock forward after
- * the event fires so it is processed immediately instead of on a timeout.
- * @param {!SinonClock} clock The sinon clock.
- * @return {!SinonStub} The created stub.
- * @private
- */
-function createEventsFireStubFireImmediately_(clock) {
-  const stub = sinon.stub(eventUtils.TEST_ONLY, 'fireInternal');
-  stub.callsFake(function (event) {
-    // Call original method.
-    stub.wrappedMethod.call(this, ...arguments);
-    // Advance clock forward to run any queued events.
-    clock.runAll();
-  });
-  return stub;
-}
-
-/**
- * Adds message to shared cleanup object so that it is cleaned from
- *    Blockly.Messages global in sharedTestTeardown.
- * @param {!Object} sharedCleanupObj The shared cleanup object created in
- *    sharedTestSetup.
- * @param {string} message The message to add to shared cleanup object.
- */
-export function addMessageToCleanup(sharedCleanupObj, message) {
-  sharedCleanupObj.messagesCleanup_.push(message);
-}
-
-/**
- * Adds block type to shared cleanup object so that it is cleaned from
- *    Blockly.Blocks global in sharedTestTeardown.
- * @param {!Object} sharedCleanupObj The shared cleanup object created in
- *    sharedTestSetup.
- * @param {string} blockType The block type to add to shared cleanup object.
- */
-export function addBlockTypeToCleanup(sharedCleanupObj, blockType) {
-  sharedCleanupObj.blockTypesCleanup_.push(blockType);
-}
-
-/**
- * Wraps Blockly.defineBlocksWithJsonArray using stub in order to keep track of
- * block types passed in to method on shared cleanup object so they are cleaned
- * from Blockly.Blocks global in sharedTestTeardown.
- * @param {!Object} sharedCleanupObj The shared cleanup object created in
- *    sharedTestSetup.
- * @private
- */
-function wrapDefineBlocksWithJsonArrayWithCleanup_(sharedCleanupObj) {
-  const stub = sinon.stub(
-    Blockly.common.TEST_ONLY,
-    'defineBlocksWithJsonArrayInternal',
-  );
-  stub.callsFake(function (jsonArray) {
-    if (jsonArray) {
-      jsonArray.forEach((jsonBlock) => {
-        if (jsonBlock) {
-          addBlockTypeToCleanup(sharedCleanupObj, jsonBlock['type']);
-        }
-      });
-    }
-    // Calls original method.
-    stub.wrappedMethod.call(this, ...arguments);
-  });
-}
-
-/**
- * Shared setup method that sets up fake timer for clock so that pending
- * setTimeout calls can be cleared in test teardown along with other common
- * stubs. Should be called in setup of outermost suite using
- * sharedTestSetup.call(this).
- * The sinon fake timer defined on this.clock_ should not be reset in tests to
- * avoid causing issues with cleanup in sharedTestTeardown.
- *
- * Stubs created in this setup (unless disabled by options passed):
- *  - Blockly.Events.fire - this.eventsFireStub - wraps fire event to trigger
- *      fireNow_ call immediately, rather than on timeout
- *  - Blockly.defineBlocksWithJsonArray - thin wrapper that adds logic to keep
- *      track of block types defined so that they can be undefined in
- *      sharedTestTeardown and calls original method.
- *
- * @param {Object<string, boolean>} options Options to enable/disable setup
- *    of certain stubs.
- * @return {{clock: *}} The fake clock (as part of an object to make refactoring
- *     easier).
- */
-export function sharedTestSetup(options = {}) {
-  this.sharedSetupCalled_ = true;
-  // Sandbox created for greater control when certain stubs are cleared.
-  this.sharedSetupSandbox_ = sinon.createSandbox();
-  this.clock = this.sharedSetupSandbox_.useFakeTimers();
-  if (options['fireEventsNow'] === undefined || options['fireEventsNow']) {
-    // Stubs event firing unless passed option "fireEventsNow: false"
-    this.eventsFireStub = createEventsFireStubFireImmediately_(this.clock);
-  }
-  this.sharedCleanup = {
-    blockTypesCleanup_: [],
-    messagesCleanup_: [],
-  };
-  this.blockTypesCleanup_ = this.sharedCleanup.blockTypesCleanup_;
-  this.messagesCleanup_ = this.sharedCleanup.messagesCleanup_;
-  wrapDefineBlocksWithJsonArrayWithCleanup_(this.sharedCleanup);
-  return {
-    clock: this.clock,
-  };
-}
-
-/**
- * Shared cleanup method that clears up pending setTimeout calls, disposes of
- * workspace, and resets global variables. Should be called in setup of
- * outermost suite using sharedTestTeardown.call(this).
- */
-export function sharedTestTeardown() {
-  const testRef = this.currentTest || this.test;
-  if (!this.sharedSetupCalled_) {
-    console.error('"' + testRef.fullTitle() + '" did not call sharedTestSetup');
-  }
-
-  try {
-    if (this.workspace) {
-      workspaceTeardown.call(this, this.workspace);
-      this.workspace = null;
-    } else {
-      this.clock.runAll(); // Run all queued setTimeout calls.
-    }
-  } catch (e) {
-    console.error(testRef.fullTitle() + '\n', e);
-  } finally {
-    // Clear Blockly.Event state.
-    eventUtils.setGroup(false);
-    while (!eventUtils.isEnabled()) {
-      eventUtils.enable();
-    }
-    eventUtils.setRecordUndo(true);
-    if (eventUtils.TEST_ONLY.FIRE_QUEUE.length) {
-      // If this happens, it may mean that some previous test is missing cleanup
-      // (i.e. a previous test added an event to the queue on a timeout that
-      // did not use a stubbed clock).
-      eventUtils.TEST_ONLY.FIRE_QUEUE.length = 0;
-      console.warn(
-        '"' +
-          testRef.fullTitle() +
-          '" needed cleanup of Blockly.Events.TEST_ONLY.FIRE_QUEUE. This may ' +
-          'indicate leakage from an earlier test',
-      );
-    }
-
-    // Restore all stubbed methods.
-    this.sharedSetupSandbox_.restore();
-    sinon.restore();
-
-    const blockTypes = this.sharedCleanup.blockTypesCleanup_;
-    for (let i = 0; i < blockTypes.length; i++) {
-      delete Blockly.Blocks[blockTypes[i]];
-    }
-    const messages = this.sharedCleanup.messagesCleanup_;
-    for (let i = 0; i < messages.length; i++) {
-      delete Blockly.Msg[messages[i]];
-    }
-
-    Blockly.WidgetDiv.testOnly_setDiv(null);
-  }
-}
-
-/**
- * Creates stub for Blockly.utils.idGenerator.genUid that returns the provided id or ids.
- * Recommended to also assert that the stub is called the expected number of
- * times.
- * @param {string|!Array<string>} returnIds The return values to use for the
- *    created stub. If a single value is passed, then the stub always returns
- *    that value.
- * @return {!SinonStub} The created stub.
- */
-export function createGenUidStubWithReturns(returnIds) {
-  const stub = sinon.stub(Blockly.utils.idGenerator.TEST_ONLY, 'genUid');
-  if (Array.isArray(returnIds)) {
-    for (let i = 0; i < returnIds.length; i++) {
-      stub.onCall(i).returns(returnIds[i]);
-    }
-  } else {
-    stub.returns(returnIds);
-  }
-  return stub;
-}

package/blockly-rc/tests/mocha/test_helpers/toolbox_definitions.js

@@ -1,271 +0,0 @@
-/**
- * @license
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * Get JSON for a toolbox that contains categories.
- * @return {Blockly.utils.toolbox.ToolboxJson} The array holding information
- *    for a toolbox.
- */
-export function getCategoryJSON() {
-  return {
-    'contents': [
-      {
-        'kind': 'CATEGORY',
-        'cssconfig': {
-          'container': 'something',
-        },
-        'contents': [
-          {
-            'kind': 'BLOCK',
-            'blockxml':
-              '<block type="basic_block"><field name="TEXT">FirstCategory-FirstBlock</field></block>',
-          },
-          {
-            'kind': 'BLOCK',
-            'blockxml':
-              '<block type="basic_block"><field name="TEXT">FirstCategory-SecondBlock</field></block>',
-          },
-        ],
-        'name': 'First',
-      },
-      {
-        'kind': 'CATEGORY',
-        'contents': [
-          {
-            'kind': 'BLOCK',
-            'blockxml':
-              '<block type="basic_block"><field name="TEXT">SecondCategory-FirstBlock</field></block>',
-          },
-        ],
-        'name': 'Second',
-      },
-    ],
-  };
-}
-
-/**
- * Get JSON for a simple toolbox.
- * @return {Blockly.utils.toolbox.ToolboxJson} The array holding information
- *    for a simple toolbox.
- */
-export function getSimpleJson() {
-  return {
-    'contents': [
-      {
-        'kind': 'BLOCK',
-        'blockxml': `<block type="logic_compare">
-          <field name="OP">NEQ</field>
-          <value name="A">
-            <shadow type="math_number">
-              <field name="NUM">1</field>
-            </shadow>
-          </value>
-          <value name="B">
-            <block type="math_number">
-              <field name="NUM">2</field>
-            </block>
-          </value>
-        </block>`,
-      },
-      {
-        'kind': 'SEP',
-        'gap': '20',
-      },
-      {
-        'kind': 'BUTTON',
-        'text': 'insert',
-        'callbackkey': 'insertConnectionRows',
-      },
-      {
-        'kind': 'LABEL',
-        'text': 'tooltips',
-      },
-    ],
-  };
-}
-
-export function getProperSimpleJson() {
-  return {
-    'contents': [
-      {
-        'kind': 'BLOCK',
-        'type': 'logic_compare',
-        'fields': {
-          'OP': 'NEQ',
-        },
-        'inputs': {
-          'A': {
-            'shadow': {
-              'type': 'math_number',
-              'fields': {
-                'NUM': 1,
-              },
-            },
-          },
-          'B': {
-            'block': {
-              'type': 'math_number',
-              'fields': {
-                'NUM': 2,
-              },
-            },
-          },
-        },
-      },
-      {
-        'kind': 'SEP',
-        'gap': '20',
-      },
-      {
-        'kind': 'BUTTON',
-        'text': 'insert',
-        'callbackkey': 'insertConnectionRows',
-      },
-      {
-        'kind': 'LABEL',
-        'text': 'tooltips',
-      },
-    ],
-  };
-}
-
-/**
- * Get JSON for a toolbox that contains categories that contain categories.
- * @return {Blockly.utils.toolbox.ToolboxJson} The array holding information
- *    for a toolbox.
- */
-export function getDeeplyNestedJSON() {
-  return {
-    'contents': [
-      {
-        'kind': 'CATEGORY',
-        'cssconfig': {
-          'container': 'something',
-        },
-        'contents': [
-          {
-            'kind': 'CATEGORY',
-            'contents': [
-              {
-                'kind': 'CATEGORY',
-                'contents': [
-                  {
-                    'kind': 'BLOCK',
-                    'blockxml':
-                      '<block type="basic_block"><field name="TEXT">NestedCategory-FirstBlock</field></block>',
-                  },
-                  {
-                    'kind': 'BLOCK',
-                    'blockxml':
-                      '<block type="basic_block"><field name="TEXT">NestedCategory-SecondBlock</field></block>',
-                  },
-                ],
-                'name': 'NestedCategoryInner',
-              },
-            ],
-            'name': 'NestedCategoryMiddle',
-          },
-        ],
-        'name': 'NestedCategoryOuter',
-      },
-      {
-        'kind': 'CATEGORY',
-        'contents': [
-          {
-            'kind': 'BLOCK',
-            'blockxml':
-              '<block type="basic_block"><field name="TEXT">SecondCategory-FirstBlock</field></block>',
-          },
-        ],
-        'name': 'Second',
-      },
-    ],
-  };
-}
-
-/**
- * Get an array filled with xml elements.
- * @return {Array<Node>} Array holding xml elements for a toolbox.
- */
-export function getXmlArray() {
-  const block = Blockly.utils.xml.textToDom(
-    `<block type="logic_compare">
-        <field name="OP">NEQ</field>
-        <value name="A">
-          <shadow type="math_number">
-            <field name="NUM">1</field>
-          </shadow>
-        </value>
-        <value name="B">
-          <block type="math_number">
-            <field name="NUM">2</field>
-          </block>
-        </value>
-      </block>`,
-  );
-  const separator = Blockly.utils.xml.textToDom('<sep gap="20"></sep>');
-  const button = Blockly.utils.xml.textToDom(
-    '<button text="insert" callbackkey="insertConnectionRows"></button>',
-  );
-  const label = Blockly.utils.xml.textToDom('<label text="tooltips"></label>');
-  return [block, separator, button, label];
-}
-
-export function getInjectedToolbox() {
-  /**
-   * Category: First
-   *   sep
-   *   basic_block
-   *   basic_block
-   * Category: second
-   *   basic_block
-   * Category: Variables
-   *   custom: VARIABLE
-   * Category: NestedCategory
-   *   Category: NestedItemOne
-   */
-  const toolboxXml = document.getElementById('toolbox-test');
-  const workspace = Blockly.inject('blocklyDiv', {
-    toolbox: toolboxXml,
-  });
-  return workspace.getToolbox();
-}
-
-export function getBasicToolbox() {
-  const workspace = new Blockly.WorkspaceSvg(new Blockly.Options({}));
-  const toolbox = new Blockly.Toolbox(workspace);
-  toolbox.HtmlDiv = document.createElement('div');
-  toolbox.flyout_ = sinon.createStubInstance(Blockly.VerticalFlyout);
-  return toolbox;
-}
-
-export function getCollapsibleItem(toolbox) {
-  const contents = toolbox.contents_;
-  for (let i = 0; i < contents.length; i++) {
-    const item = contents[i];
-    if (item.isCollapsible()) {
-      return item;
-    }
-  }
-}
-
-export function getNonCollapsibleItem(toolbox) {
-  const contents = toolbox.contents_;
-  for (let i = 0; i < contents.length; i++) {
-    const item = contents[i];
-    if (!item.isCollapsible()) {
-      return item;
-    }
-  }
-}
-
-export function getChildItem(toolbox) {
-  return toolbox.getToolboxItemById('nestedCategory');
-}
-
-export function getSeparator(toolbox) {
-  return toolbox.getToolboxItemById('separator');
-}

package/blockly-rc/tests/mocha/test_helpers/user_input.js

@@ -1,62 +0,0 @@
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {KeyCodes} from '../../../build/src/core/utils/keycodes.js';
-
-/**
- * Triggers pointer event on target.
- * @param {!EventTarget} target The object receiving the event.
- * @param {string} type The type of mouse event (eg: mousedown, mouseup,
- *    click).
- * @param {Object<string, string>=} properties Properties to pass into event
- *    constructor.
- */
-export function dispatchPointerEvent(target, type, properties) {
-  const eventInitDict = {
-    cancelable: true,
-    bubbles: true,
-    isPrimary: true,
-    pressure: 0.5,
-    clientX: 10,
-    clientY: 10,
-  };
-  if (properties) {
-    Object.assign(eventInitDict, properties);
-  }
-  const event = new PointerEvent(type, eventInitDict);
-  target.dispatchEvent(event);
-}
-
-/**
- * Creates a key down event used for testing.
- * @param {number} keyCode The keycode for the event. Use Blockly.utils.KeyCodes enum.
- * @param {!Array<number>=} modifiers A list of modifiers. Use Blockly.utils.KeyCodes enum.
- * @return {!KeyboardEvent} The mocked keydown event.
- */
-export function createKeyDownEvent(keyCode, modifiers) {
-  const event = {
-    keyCode: keyCode,
-  };
-  if (modifiers && modifiers.length > 0) {
-    event.altKey = modifiers.includes(KeyCodes.ALT);
-    event.ctrlKey = modifiers.includes(KeyCodes.CTRL);
-    event.metaKey = modifiers.includes(KeyCodes.META);
-    event.shiftKey = modifiers.includes(KeyCodes.SHIFT);
-  }
-  return new KeyboardEvent('keydown', event);
-}
-
-/**
- * Simulates mouse click by triggering relevant mouse events.
- * @param {!EventTarget} target The object receiving the event.
- * @param {Object<string, string>=} properties Properties to pass into event
- *    constructor.
- */
-export function simulateClick(target, properties) {
-  dispatchPointerEvent(target, 'pointerdown', properties);
-  dispatchPointerEvent(target, 'pointerup', properties);
-  dispatchPointerEvent(target, 'click', properties);
-}

package/blockly-rc/tests/mocha/test_helpers/variables.js

@@ -1,23 +0,0 @@
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {assert} from '../../../node_modules/chai/chai.js';
-
-/**
- * Check if a variable with the given values exists.
- * @param {Blockly.Workspace|Blockly.VariableMap} container The workspace  or
- *     variableMap the checked variable belongs to.
- * @param {!string} name The expected name of the variable.
- * @param {!string} type The expected type of the variable.
- * @param {!string} id The expected id of the variable.
- */
-export function assertVariableValues(container, name, type, id) {
-  const variable = container.getVariableById(id);
-  assert.isDefined(variable);
-  assert.equal(variable.name, name);
-  assert.equal(variable.type, type);
-  assert.equal(variable.getId(), id);
-}