scratch-blocks 2.0.0-beta.1 → 2.0.0-spork.1

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

@@ -1,310 +0,0 @@
-/**
- * @license
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {assert} from '../../../node_modules/chai/chai.js';
-import {runTestCases, TestCase} from './common.js';
-
-/**
- * Field value test case.
- * @implements {TestCase}
- * @record
- */
-export class FieldValueTestCase {
-  /**
-   * Class for a a field value test case.
-   */
-  constructor() {
-    /**
-     * @type {*} The value to use in test.
-     */
-    this.value;
-    /**
-     * @type {*} The expected value.
-     */
-    this.expectedValue;
-    /**
-     * @type {string|undefined} The expected text value. Provided if different
-     *    from String(expectedValue).
-     */
-    this.expectedText;
-    /**
-     * @type {!RegExp|string|undefined} The optional error message matcher.
-     *    Provided if test case is expected to throw.
-     */
-    this.errMsgMatcher;
-  }
-}
-
-/**
- * Field creation test case.
- * @extends {FieldValueTestCase}
- * @record
- */
-export class FieldCreationTestCase {
-  /**
-   * Class for a field creation test case.
-   */
-  constructor() {
-    /**
-     * @type {Array<*>} The arguments to pass to field constructor.
-     */
-    this.args;
-    /**
-     * @type {string} The json to use in field creation.
-     */
-    this.json;
-  }
-}
-
-/**
- * Assert a field's value is the same as the expected value.
- * @param {!Blockly.Field} field The field.
- * @param {*} expectedValue The expected value.
- * @param {string=} expectedText The expected text.
- */
-export function assertFieldValue(
-  field,
-  expectedValue,
-  expectedText = undefined,
-) {
-  const actualValue = field.getValue();
-  const actualText = field.getText();
-  if (expectedText === undefined) {
-    expectedText = String(expectedValue);
-  }
-  assert.deepEqual(actualValue, expectedValue);
-  assert.deepEqual(actualText, expectedText);
-}
-
-/**
- * Runs provided creation test cases.
- * @param {!Array<!FieldCreationTestCase>} testCases The test cases to run.
- * @param {function(!Blockly.Field, !FieldCreationTestCase)} assertion The
- *    assertion to use.
- * @param {function(new:Blockly.Field,!FieldCreationTestCase):Blockly.Field
- *    } creation A function that returns an instance of the field based on the
- *    provided test case.
- * @private
- */
-function runCreationTests_(testCases, assertion, creation) {
-  /**
-   * Creates test callback for creation test.
-   * @param {FieldCreationTestCase} testCase The test case to use.
-   * @return {Function} The test callback.
-   */
-  const createTestFn = (testCase) => {
-    return function () {
-      const field = creation.call(this, testCase);
-      assertion(field, testCase);
-    };
-  };
-  runTestCases(testCases, createTestFn);
-}
-
-/**
- * Runs provided creation test cases.
- * @param {!Array<!FieldCreationTestCase>} testCases The test cases to run.
- * @param {function(new:Blockly.Field,!FieldCreationTestCase):Blockly.Field
- *    } creation A function that returns an instance of the field based on the
- *    provided test case.
- * @private
- */
-function runCreationTestsAssertThrows_(testCases, creation) {
-  /**
-   * Creates test callback for creation test.
-   * @param {!FieldCreationTestCase} testCase The test case to use.
-   * @return {!Function} The test callback.
-   */
-  const createTestFn = (testCase) => {
-    return function () {
-      assert.throws(function () {
-        creation.call(this, testCase);
-      }, testCase.errMsgMatcher);
-    };
-  };
-  runTestCases(testCases, createTestFn);
-}
-
-/**
- * Runs suite of tests for constructor for the specified field.
- * @param {function(new:Blockly.Field, *=)} TestedField The class of the field
- *    being tested.
- * @param {Array<!FieldCreationTestCase>} validValueTestCases Test cases with
- *    valid values for given field.
- * @param {Array<!FieldCreationTestCase>} invalidValueTestCases Test cases with
- *    invalid values for given field.
- * @param {function(!Blockly.Field, !FieldCreationTestCase)
- *    } validRunAssertField Asserts that field has expected values.
- * @param {function(!Blockly.Field)=} assertFieldDefault Asserts that field has
- *    default values. If undefined, tests will check that field throws when
- *    invalid value is passed rather than asserting default.
- * @param {function(!FieldCreationTestCase=)=} customCreateWithJs Custom
- *    creation function to use in tests.
- */
-export function runConstructorSuiteTests(
-  TestedField,
-  validValueTestCases,
-  invalidValueTestCases,
-  validRunAssertField,
-  assertFieldDefault,
-  customCreateWithJs,
-) {
-  suite('Constructor', function () {
-    if (assertFieldDefault) {
-      test('Empty', function () {
-        const field = customCreateWithJs
-          ? customCreateWithJs.call(this)
-          : new TestedField();
-        assertFieldDefault(field);
-      });
-    } else {
-      test('Empty', function () {
-        assert.throws(function () {
-          customCreateWithJs
-            ? customCreateWithJs.call(this)
-            : new TestedField();
-        });
-      });
-    }
-
-    /**
-     * Creates a field using its constructor and the provided test case.
-     * @param {!FieldCreationTestCase} testCase The test case information.
-     * @return {!Blockly.Field} The instantiated field.
-     */
-    const createWithJs = function (testCase) {
-      return customCreateWithJs
-        ? customCreateWithJs.call(this, testCase)
-        : new TestedField(...testCase.args);
-    };
-    if (assertFieldDefault) {
-      runCreationTests_(
-        invalidValueTestCases,
-        assertFieldDefault,
-        createWithJs,
-      );
-    } else {
-      runCreationTestsAssertThrows_(invalidValueTestCases, createWithJs);
-    }
-    runCreationTests_(validValueTestCases, validRunAssertField, createWithJs);
-  });
-}
-
-/**
- * Runs suite of tests for fromJson creation of specified field.
- * @param {function(new:Blockly.Field, *=)} TestedField The class of the field
- *    being tested.
- * @param {!Array<!FieldCreationTestCase>} validValueTestCases Test cases with
- *    valid values for given field.
- * @param {!Array<!FieldCreationTestCase>} invalidValueTestCases Test cases with
- *    invalid values for given field.
- * @param {function(!Blockly.Field, !FieldValueTestCase)
- *    } validRunAssertField Asserts that field has expected values.
- * @param {function(!Blockly.Field)=} assertFieldDefault Asserts that field has
- *    default values. If undefined, tests will check that field throws when
- *    invalid value is passed rather than asserting default.
- * @param {function(!FieldCreationTestCase=)=} customCreateWithJson Custom
- *    creation function to use in tests.
- */
-export function runFromJsonSuiteTests(
-  TestedField,
-  validValueTestCases,
-  invalidValueTestCases,
-  validRunAssertField,
-  assertFieldDefault,
-  customCreateWithJson,
-) {
-  suite('fromJson', function () {
-    if (assertFieldDefault) {
-      test('Empty', function () {
-        const field = customCreateWithJson
-          ? customCreateWithJson.call(this)
-          : TestedField.fromJson({});
-        assertFieldDefault(field);
-      });
-    } else {
-      test('Empty', function () {
-        assert.throws(function () {
-          customCreateWithJson
-            ? customCreateWithJson.call(this)
-            : TestedField.fromJson({});
-        });
-      });
-    }
-
-    /**
-     * Creates a field using fromJson and the provided test case.
-     * @param {!FieldCreationTestCase} testCase The test case information.
-     * @return {!Blockly.Field} The instantiated field.
-     */
-    const createWithJson = function (testCase) {
-      return customCreateWithJson
-        ? customCreateWithJson.call(this, testCase)
-        : TestedField.fromJson(testCase.json);
-    };
-    if (assertFieldDefault) {
-      runCreationTests_(
-        invalidValueTestCases,
-        assertFieldDefault,
-        createWithJson,
-      );
-    } else {
-      runCreationTestsAssertThrows_(invalidValueTestCases, createWithJson);
-    }
-    runCreationTests_(validValueTestCases, validRunAssertField, createWithJson);
-  });
-}
-
-/**
- * Runs tests for setValue calls.
- * @param {!Array<!FieldValueTestCase>} validValueTestCases Test cases with
- *    valid values.
- * @param {!Array<!FieldValueTestCase>} invalidValueTestCases Test cases with
- *    invalid values.
- * @param {*} invalidRunExpectedValue Expected value for field after invalid
- *    call to setValue.
- * @param {string=} invalidRunExpectedText Expected text for field after invalid
- *    call to setValue.
- */
-export function runSetValueTests(
-  validValueTestCases,
-  invalidValueTestCases,
-  invalidRunExpectedValue,
-  invalidRunExpectedText,
-) {
-  /**
-   * Creates test callback for invalid setValue test.
-   * @param {!FieldValueTestCase} testCase The test case information.
-   * @return {!Function} The test callback.
-   */
-  const createInvalidSetValueTestCallback = (testCase) => {
-    return function () {
-      this.field.setValue(testCase.value);
-      assertFieldValue(
-        this.field,
-        invalidRunExpectedValue,
-        invalidRunExpectedText,
-      );
-    };
-  };
-  /**
-   * Creates test callback for valid setValue test.
-   * @param {!FieldValueTestCase} testCase The test case information.
-   * @return {!Function} The test callback.
-   */
-  const createValidSetValueTestCallback = (testCase) => {
-    return function () {
-      this.field.setValue(testCase.value);
-      assertFieldValue(
-        this.field,
-        testCase.expectedValue,
-        testCase.expectedText,
-      );
-    };
-  };
-  runTestCases(invalidValueTestCases, createInvalidSetValueTestCallback);
-  runTestCases(validValueTestCases, createValidSetValueTestCallback);
-}

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

@@ -1,81 +0,0 @@
-/**
- * @license
- * Copyright 2023 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-export class MockIcon {
-  getType() {
-    return new Blockly.icons.IconType('mock icon');
-  }
-
-  initView() {}
-
-  dispose() {}
-
-  getWeight() {}
-
-  getSize() {
-    return new Blockly.utils.Size(0, 0);
-  }
-
-  applyColour() {}
-
-  hideForInsertionMarker() {}
-
-  updateEditable() {}
-
-  updateCollapsed() {}
-
-  isShownWhenCollapsed() {}
-
-  setOffsetInBlock() {}
-
-  onLocationChange() {}
-
-  onClick() {}
-}
-
-export class MockSerializableIcon extends MockIcon {
-  constructor() {
-    super();
-    this.state = '';
-  }
-
-  getType() {
-    return new Blockly.icons.IconType('serializable icon');
-  }
-
-  getWeight() {
-    return 1;
-  }
-
-  saveState() {
-    return 'some state';
-  }
-
-  loadState(state) {
-    this.state = state;
-  }
-}
-
-export class MockBubbleIcon extends MockIcon {
-  constructor() {
-    super();
-    this.visible = false;
-  }
-
-  getType() {
-    return new Blockly.icons.IconType('bubble icon');
-  }
-
-  updateCollapsed() {}
-
-  bubbleIsVisible() {
-    return this.visible;
-  }
-
-  setBubbleVisible(visible) {
-    this.visible = visible;
-  }
-}

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

@@ -1,302 +0,0 @@
-/**
- * @license
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {assert} from '../../../node_modules/chai/chai.js';
-import {ConnectionType} from '../../../build/src/core/connection_type.js';
-import {VariableModel} from '../../../build/src/core/variable_model.js';
-
-/**
- * Asserts that the procedure definition or call block has the expected var
- * models.
- * @param {!Blockly.Block} block The procedure definition or call block to
- *    check.
- * @param {!Array<string>} varIds An array of variable ids.
- */
-function assertBlockVarModels(block, varIds) {
-  const expectedVarModels = [];
-  for (let i = 0; i < varIds.length; i++) {
-    expectedVarModels.push(block.workspace.getVariableById(varIds[i]));
-  }
-  assert.sameDeepOrderedMembers(block.getVarModels(), expectedVarModels);
-}
-
-/**
- * Asserts that the procedure call block has the expected arguments.
- * @param {!Blockly.Block} callBlock The procedure definition block.
- * @param {Array<string>=} args An array of argument names.
- */
-function assertCallBlockArgsStructure(callBlock, args) {
-  // inputList also contains "TOPROW"
-  assert.equal(
-    callBlock.inputList.length - 1,
-    args.length,
-    'call block has the expected number of args',
-  );
-
-  for (let i = 0; i < args.length; i++) {
-    const expectedName = args[i];
-    const callInput = callBlock.inputList[i + 1];
-    assert.equal(callInput.type, ConnectionType.INPUT_VALUE);
-    assert.equal(callInput.name, 'ARG' + i);
-    assert.equal(
-      callInput.fieldRow[0].getValue(),
-      expectedName,
-      'Call block consts did not match expected.',
-    );
-  }
-  assert.sameOrderedMembers(callBlock.getVars(), args);
-}
-
-/**
- * Asserts that the procedure definition block has the expected inputs and
- *    fields.
- * @param {!Blockly.Block} defBlock The procedure definition block.
- * @param {boolean=} hasReturn If we expect the procedure def to have a return
- *     input or not.
- * @param {Array<string>=} args An array of argument names.
- * @param {Array<string>=} varIds An array of variable ids.
- * @param {boolean=} hasStatements If we expect the procedure def to have a
- *     statement input or not.
- */
-export function assertDefBlockStructure(
-  defBlock,
-  hasReturn = false,
-  args = [],
-  varIds = [],
-  hasStatements = true,
-) {
-  if (hasStatements) {
-    assert.isNotNull(
-      defBlock.getInput('STACK'),
-      'Def block should have STACK input',
-    );
-  } else {
-    assert.isNull(
-      defBlock.getInput('STACK'),
-      'Def block should not have STACK input',
-    );
-  }
-  if (hasReturn) {
-    assert.isNotNull(
-      defBlock.getInput('RETURN'),
-      'Def block should have RETURN input',
-    );
-  } else {
-    assert.isNull(
-      defBlock.getInput('RETURN'),
-      'Def block should not have RETURN input',
-    );
-  }
-  if (args.length) {
-    assert.include(
-      defBlock.toString(),
-      'with',
-      'Def block string should include "with"',
-    );
-  } else {
-    assert.notInclude(
-      defBlock.toString(),
-      'with',
-      'Def block string should not include "with"',
-    );
-  }
-
-  assert.sameOrderedMembers(defBlock.getVars(), args);
-  assertBlockVarModels(defBlock, varIds);
-}
-
-/**
- * Asserts that the procedure call block has the expected inputs and
- *    fields.
- * @param {!Blockly.Block} callBlock The procedure call block.
- * @param {Array<string>=} args An array of argument names.
- * @param {Array<string>=} varIds An array of variable ids.
- * @param {string=} name The name we expect the caller to have.
- */
-export function assertCallBlockStructure(
-  callBlock,
-  args = [],
-  varIds = [],
-  name = undefined,
-) {
-  if (args.length) {
-    assert.include(callBlock.toString(), 'with');
-  } else {
-    assert.notInclude(callBlock.toString(), 'with');
-  }
-
-  assertCallBlockArgsStructure(callBlock, args);
-  assertBlockVarModels(callBlock, varIds);
-  if (name !== undefined) {
-    assert.equal(callBlock.getFieldValue('NAME'), name);
-  }
-}
-
-/**
- * Creates procedure definition block using domToBlock call.
- * @param {!Blockly.Workspace} workspace The Blockly workspace.
- * @param {boolean=} hasReturn Whether the procedure definition should have
- *    return.
- * @param {Array<string>=} args An array of argument names.
- * @param {string=} name The name of the def block (defaults to 'proc name').
- * @return {Blockly.Block} The created block.
- */
-export function createProcDefBlock(
-  workspace,
-  hasReturn = false,
-  args = [],
-  name = 'proc name',
-) {
-  const type = hasReturn ? 'procedures_defreturn' : 'procedures_defnoreturn';
-  let xml = `<block type="${type}">`;
-  for (let i = 0; i < args.length; i++) {
-    xml += `    <mutation><arg name="${args[i]}"></arg></mutation>\n`;
-  }
-  xml += `  <field name="NAME">${name}</field>` + '</block>';
-  return Blockly.Xml.domToBlock(Blockly.utils.xml.textToDom(xml), workspace);
-}
-
-/**
- * Creates procedure call block using domToBlock call.
- * @param {!Blockly.Workspace} workspace The Blockly workspace.
- * @param {boolean=} hasReturn Whether the corresponding procedure definition
- *    has return.
- * @param {string=} name The name of the caller block (defaults to 'proc name').
- * @return {Blockly.Block} The created block.
- */
-export function createProcCallBlock(
-  workspace,
-  hasReturn = false,
-  name = 'proc name',
-) {
-  const type = hasReturn ? 'procedures_callreturn' : 'procedures_callnoreturn';
-  return Blockly.Xml.domToBlock(
-    Blockly.utils.xml.textToDom(
-      `<block type="${type}">` + `  <mutation name="${name}"/>` + `</block>`,
-    ),
-    workspace,
-  );
-}
-
-export class MockProcedureModel {
-  constructor(name = '') {
-    this.id = Blockly.utils.idGenerator.genUid();
-    this.name = name;
-    this.parameters = [];
-    this.returnTypes = null;
-    this.enabled = true;
-  }
-
-  static loadState(state, workspace) {
-    return new MockProcedureModel();
-  }
-
-  saveState() {
-    return {};
-  }
-
-  setName(name) {
-    this.name = name;
-    return this;
-  }
-
-  insertParameter(parameterModel, index) {
-    this.parameters.splice(index, 0, parameterModel);
-    return this;
-  }
-
-  deleteParameter(index) {
-    this.parameters.splice(index, 1);
-    return this;
-  }
-
-  setReturnTypes(types) {
-    this.returnTypes = types;
-    return this;
-  }
-
-  setEnabled(enabled) {
-    this.enabled = enabled;
-    return this;
-  }
-
-  getId() {
-    return this.id;
-  }
-
-  getName() {
-    return this.name;
-  }
-
-  getParameter(index) {
-    return this.parameters[index];
-  }
-
-  getParameters() {
-    return [...this.parameters];
-  }
-
-  getReturnTypes() {
-    return this.returnTypes;
-  }
-
-  getEnabled() {
-    return this.enabled;
-  }
-
-  startPublishing() {}
-
-  stopPublishing() {}
-}
-
-export class MockParameterModel {
-  constructor(name) {
-    this.id = Blockly.utils.idGenerator.genUid();
-    this.name = name;
-    this.types = [];
-  }
-
-  static loadState(state, workspace) {
-    return new MockParameterModel('test');
-  }
-
-  saveState() {
-    return {};
-  }
-
-  setName(name) {
-    this.name = name;
-    return this;
-  }
-
-  setTypes(types) {
-    this.types = types;
-    return this;
-  }
-
-  getName() {
-    return this.name;
-  }
-
-  getTypes() {
-    return this.types;
-  }
-
-  getId() {
-    return this.id;
-  }
-}
-
-export class MockParameterModelWithVar extends MockParameterModel {
-  constructor(name, workspace) {
-    super(name);
-    this.variable = new VariableModel(workspace, name);
-  }
-
-  getVariableModel() {
-    return this.variable;
-  }
-}