scratch-blocks 1.1.206 → 2.0.0-beta.1

package/blockly-rc/tests/mocha/generator_test.js

@@ -0,0 +1,233 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {assert} from '../../node_modules/chai/chai.js';
+import * as Blockly from '../../build/src/core/blockly.js';
+import {DartGenerator} from '../../build/src/generators/dart/dart_generator.js';
+import {JavascriptGenerator} from '../../build/src/generators/javascript/javascript_generator.js';
+import {LuaGenerator} from '../../build/src/generators/lua/lua_generator.js';
+import {PhpGenerator} from '../../build/src/generators/php/php_generator.js';
+import {PythonGenerator} from '../../build/src/generators/python/python_generator.js';
+import {
+  sharedTestSetup,
+  sharedTestTeardown,
+} from './test_helpers/setup_teardown.js';
+
+suite('Generator', function () {
+  setup(function () {
+    sharedTestSetup.call(this);
+    this.workspace = new Blockly.Workspace();
+  });
+
+  teardown(function () {
+    sharedTestTeardown.call(this);
+  });
+
+  suite('prefix', function () {
+    setup(function () {
+      this.generator = new Blockly.CodeGenerator('INTERCAL');
+    });
+
+    test('Nothing', function () {
+      assert.equal(this.generator.prefixLines('', ''), '');
+    });
+
+    test('One word', function () {
+      assert.equal(this.generator.prefixLines('Hello', '@'), '@Hello');
+    });
+
+    test('One line', function () {
+      assert.equal(this.generator.prefixLines('Hello\n', '12'), '12Hello\n');
+    });
+
+    test('Two lines', function () {
+      assert.equal(
+        this.generator.prefixLines('Hello\nWorld\n', '***'),
+        '***Hello\n***World\n',
+      );
+    });
+  });
+
+  suite('blockToCode', function () {
+    setup(function () {
+      Blockly.defineBlocksWithJsonArray([
+        {
+          'type': 'stack_block',
+          'message0': '',
+          'previousStatement': null,
+          'nextStatement': null,
+        },
+        {
+          'type': 'row_block',
+          'message0': '%1',
+          'args0': [
+            {
+              'type': 'input_value',
+              'name': 'INPUT',
+            },
+          ],
+          'output': null,
+          'nextStatement': null,
+        },
+      ]);
+      const rowBlock = this.workspace.newBlock('row_block');
+      const stackBlock = this.workspace.newBlock('stack_block');
+
+      this.blockToCodeTest = function (
+        generator,
+        blockDisabled,
+        opt_thisOnly,
+        expectedCode,
+        opt_message,
+      ) {
+        generator.forBlock['row_block'] = function (_) {
+          return 'row_block';
+        };
+        generator.forBlock['stack_block'] = function (_) {
+          return 'stack_block';
+        };
+        rowBlock.nextConnection.connect(stackBlock.previousConnection);
+        rowBlock.setDisabledReason(blockDisabled, 'test reason');
+
+        const code = generator.blockToCode(rowBlock, opt_thisOnly);
+        delete generator.forBlock['stack_block'];
+        delete generator.forBlock['row_block'];
+        assert.equal(code, expectedCode, opt_message);
+      };
+    });
+
+    const testCase = [
+      [new DartGenerator(), 'Dart'],
+      [new JavascriptGenerator(), 'JavaScript'],
+      [new LuaGenerator(), 'Lua'],
+      [new PhpGenerator(), 'PHP'],
+      [new PythonGenerator(), 'Python'],
+    ];
+
+    suite('Trivial', function () {
+      testCase.forEach(function (testCase) {
+        const generator = testCase[0];
+        const name = testCase[1];
+        test(name, function () {
+          generator.init(this.workspace);
+          this.blockToCodeTest(
+            generator,
+            /* blockDisabled = */ false,
+            /* opt_thisOnly = */ true,
+            'row_block',
+          );
+          this.blockToCodeTest(
+            generator,
+            /* blockDisabled = */ false,
+            /* opt_thisOnly = */ false,
+            'row_blockstack_block',
+            'thisOnly=false',
+          );
+        });
+      });
+    });
+
+    suite('Disabled block', function () {
+      testCase.forEach(function (testCase) {
+        const generator = testCase[0];
+        const name = testCase[1];
+        test(name, function () {
+          this.blockToCodeTest(
+            generator,
+            /* blockDisabled = */ true,
+            /* opt_thisOnly = */ true,
+            '',
+          );
+          this.blockToCodeTest(
+            generator,
+            /* blockDisabled = */ true,
+            /* opt_thisOnly = */ false,
+            'stack_block',
+            'thisOnly=false',
+          );
+        });
+      });
+    });
+
+    suite('Nested block', function () {
+      setup(function () {
+        Blockly.defineBlocksWithJsonArray([
+          {
+            'type': 'test_loop_block',
+            'message0': 'Repeat Loop',
+            'message1': '%1',
+            'args1': [
+              {
+                'type': 'input_statement',
+                'name': 'DO',
+              },
+            ],
+            'previousStatement': null,
+            'nextStatement': null,
+          },
+        ]);
+        const blockA = this.workspace.newBlock('test_loop_block');
+        const blockB = this.workspace.newBlock('test_loop_block');
+        const blockC = this.workspace.newBlock('test_loop_block');
+        this.loopTest = function (
+          generator,
+          opt_thisOnly,
+          expectedCode,
+          opt_message,
+        ) {
+          generator.forBlock['test_loop_block'] = function (block) {
+            return '{' + generator.statementToCode(block, 'DO') + '}';
+          };
+          blockA.getInput('DO').connection.connect(blockB.previousConnection);
+          blockA.nextConnection.connect(blockC.previousConnection);
+
+          const code = generator.blockToCode(blockA, opt_thisOnly);
+          assert.equal(code, expectedCode, opt_message);
+        };
+      });
+
+      testCase.forEach(function (testCase) {
+        const generator = testCase[0];
+        const name = testCase[1];
+        test(name, function () {
+          this.loopTest(generator, true, '{  {}}');
+          this.loopTest(generator, false, '{  {}}{}', 'thisOnly=false');
+        });
+      });
+    });
+
+    suite('Names', function () {
+      setup(function () {
+        class TestGenerator extends Blockly.CodeGenerator {
+          init() {
+            super.init();
+            this.nameDB_ = sinon.createStubInstance(Blockly.Names, {
+              getName: 'foo',
+            });
+          }
+        }
+        this.generator = new TestGenerator();
+      });
+      test('No nameDB_ initialized', function () {
+        assert.throws(() => {
+          this.generator.getVariableName('foo');
+        });
+      });
+
+      test('Get variable name', function () {
+        this.generator.init();
+
+        assert.equal(this.generator.getVariableName('foo'), 'foo');
+      });
+
+      test('Get procedure name', function () {
+        this.generator.init();
+
+        assert.equal(this.generator.getProcedureName('foo'), 'foo');
+      });
+    });
+  });
+});

package/blockly-rc/tests/mocha/gesture_test.js

@@ -0,0 +1,97 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {assert} from '../../node_modules/chai/chai.js';
+import {assertEventFired, assertEventNotFired} from './test_helpers/events.js';
+import {defineBasicBlockWithField} from './test_helpers/block_definitions.js';
+import {dispatchPointerEvent} from './test_helpers/user_input.js';
+import * as eventUtils from '../../build/src/core/events/utils.js';
+import {
+  sharedTestSetup,
+  sharedTestTeardown,
+} from './test_helpers/setup_teardown.js';
+
+suite('Gesture', function () {
+  function testGestureIsFieldClick(block, isFieldClick, eventsFireStub) {
+    const field = block.getField('NAME');
+    const eventTarget = field.getClickTarget_();
+    assert.exists(eventTarget, 'Precondition: missing click target for field');
+
+    eventsFireStub.resetHistory();
+    dispatchPointerEvent(eventTarget, 'pointerdown');
+
+    const fieldWorkspace = field.sourceBlock_.workspace;
+    // Gestures triggered on flyouts are stored on targetWorkspace.
+    const gestureWorkspace = fieldWorkspace.targetWorkspace || fieldWorkspace;
+    const gesture = gestureWorkspace.currentGesture_;
+    assert.exists(gesture, 'Gesture exists after pointerdown.');
+    const isFieldClickSpy = sinon.spy(gesture, 'isFieldClick');
+
+    dispatchPointerEvent(eventTarget, 'pointerup');
+    dispatchPointerEvent(eventTarget, 'click');
+
+    sinon.assert.called(isFieldClickSpy);
+    assert.isTrue(isFieldClickSpy.alwaysReturned(isFieldClick));
+
+    assertEventFired(
+      eventsFireStub,
+      Blockly.Events.Selected,
+      {newElementId: block.id, type: eventUtils.SELECTED},
+      fieldWorkspace.id,
+    );
+    assertEventNotFired(eventsFireStub, Blockly.Events.Click, {
+      type: eventUtils.CLICK,
+    });
+  }
+
+  function getTopFlyoutBlock(flyout) {
+    return flyout.workspace_.getTopBlocks(false)[0];
+  }
+
+  setup(function () {
+    sharedTestSetup.call(this);
+    defineBasicBlockWithField();
+    const toolbox = document.getElementById('gesture-test-toolbox');
+    this.workspace = Blockly.inject('blocklyDiv', {toolbox: toolbox});
+  });
+
+  teardown(function () {
+    sharedTestTeardown.call(this);
+  });
+
+  test('Constructor', function () {
+    const e = {id: 'dummy_test_event'};
+    const gesture = new Blockly.Gesture(e, this.workspace);
+    assert.equal(gesture.mostRecentEvent, e);
+    assert.equal(gesture.creatorWorkspace, this.workspace);
+  });
+
+  test('Field click - Click in workspace', function () {
+    const block = this.workspace.newBlock('test_field_block');
+    block.initSvg();
+    block.render();
+
+    testGestureIsFieldClick(block, true, this.eventsFireStub);
+  });
+
+  test('Field click - Auto close flyout', function () {
+    const flyout = this.workspace.getFlyout(true);
+    assert.exists(flyout, 'Precondition: missing flyout');
+    flyout.autoClose = true;
+
+    const block = getTopFlyoutBlock(flyout);
+    testGestureIsFieldClick(block, false, this.eventsFireStub);
+  });
+
+  test('Field click - Always open flyout', function () {
+    const flyout = this.workspace.getFlyout(true);
+    assert.exists(flyout, 'Precondition: missing flyout');
+    flyout.autoClose = false;
+
+    const block = getTopFlyoutBlock(flyout);
+    testGestureIsFieldClick(block, true, this.eventsFireStub);
+  });
+});

package/blockly-rc/tests/mocha/icon_test.js

@@ -0,0 +1,369 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {assert} from '../../node_modules/chai/chai.js';
+import {
+  sharedTestSetup,
+  sharedTestTeardown,
+} from './test_helpers/setup_teardown.js';
+import {defineEmptyBlock} from './test_helpers/block_definitions.js';
+import {MockIcon, MockSerializableIcon} from './test_helpers/icon_mocks.js';
+
+suite('Icon', function () {
+  setup(function () {
+    this.clock = sharedTestSetup.call(this, {fireEventsNow: false}).clock;
+    defineEmptyBlock();
+  });
+
+  teardown(function () {
+    sharedTestTeardown.call(this);
+  });
+
+  class MockNonSerializableIcon extends MockIcon {
+    getType() {
+      return 'non-serializable icon';
+    }
+  }
+
+  function createHeadlessWorkspace() {
+    return new Blockly.Workspace();
+  }
+
+  function createWorkspaceSvg() {
+    const workspace = new Blockly.WorkspaceSvg(new Blockly.Options({}));
+    workspace.createDom();
+    return workspace;
+  }
+
+  function createUninitializedBlock(workspace) {
+    return workspace.newBlock('empty_block');
+  }
+
+  function createInitializedBlock(workspace) {
+    const block = workspace.newBlock('empty_block');
+    block.initSvg();
+    block.render();
+    return block;
+  }
+
+  function createHeadlessBlock(workspace) {
+    return createUninitializedBlock(workspace);
+  }
+
+  suite('Hooks getting properly triggered by the block', function () {
+    suite('Triggering view initialization', function () {
+      test('initView is not called by headless blocks', function () {
+        const workspace = createHeadlessWorkspace();
+        const block = createUninitializedBlock(workspace);
+        const icon = new MockIcon();
+        const initViewSpy = sinon.spy(icon, 'initView');
+
+        block.addIcon(icon);
+
+        assert.isFalse(
+          initViewSpy.called,
+          'Expected initView to not be called',
+        );
+      });
+
+      test(
+        'initView is called by headful blocks that are currently ' +
+          'rendered when the icon is added',
+        function () {
+          const workspace = new Blockly.WorkspaceSvg(new Blockly.Options({}));
+          workspace.createDom();
+          const block = createInitializedBlock(workspace);
+          const icon = new MockIcon();
+          const initViewSpy = sinon.spy(icon, 'initView');
+
+          block.addIcon(icon);
+          assert.isTrue(
+            initViewSpy.calledOnce,
+            'Expected initView to be called',
+          );
+        },
+      );
+    });
+
+    suite('Triggering applying colors', function () {
+      test('applyColour is not called by headless blocks', function () {
+        const workspace = createHeadlessWorkspace();
+        const block = createUninitializedBlock(workspace);
+        const icon = new MockIcon();
+        const applyColourSpy = sinon.spy(icon, 'applyColour');
+
+        block.addIcon(icon);
+
+        assert.isFalse(
+          applyColourSpy.called,
+          'Expected applyColour to not be called',
+        );
+      });
+
+      test(
+        'applyColour is called by headful blocks that are currently ' +
+          'rendered when the icon is added',
+        function () {
+          const workspace = createWorkspaceSvg();
+          const block = createInitializedBlock(workspace);
+          const icon = new MockIcon();
+          const applyColourSpy = sinon.spy(icon, 'applyColour');
+
+          block.addIcon(icon);
+          assert.isTrue(
+            applyColourSpy.calledOnce,
+            'Expected applyColour to be called',
+          );
+        },
+      );
+
+      test("applyColour is called when the block's color changes", function () {
+        const workspace = createWorkspaceSvg();
+        const block = createInitializedBlock(workspace);
+        const icon = new MockIcon();
+        const applyColourSpy = sinon.spy(icon, 'applyColour');
+
+        block.addIcon(icon);
+        applyColourSpy.resetHistory();
+        block.setColour('#cccccc');
+        assert.isTrue(
+          applyColourSpy.calledOnce,
+          'Expected applyColour to be called',
+        );
+      });
+
+      test("applyColour is called when the block's style changes", function () {
+        const workspace = createWorkspaceSvg();
+        const block = createInitializedBlock(workspace);
+        const icon = new MockIcon();
+        const applyColourSpy = sinon.spy(icon, 'applyColour');
+
+        block.addIcon(icon);
+        applyColourSpy.resetHistory();
+        block.setStyle('logic_block');
+        assert.isTrue(
+          applyColourSpy.calledOnce,
+          'Expected applyColour to be called',
+        );
+      });
+
+      test('applyColour is called when the block is disabled', function () {
+        const workspace = createWorkspaceSvg();
+        const block = createInitializedBlock(workspace);
+        const icon = new MockIcon();
+        const applyColourSpy = sinon.spy(icon, 'applyColour');
+
+        block.addIcon(icon);
+        applyColourSpy.resetHistory();
+        block.setDisabledReason(true, 'test reason');
+        assert.isTrue(
+          applyColourSpy.calledOnce,
+          'Expected applyColour to be called',
+        );
+      });
+
+      test('applyColour is called when the block becomes a shadow', function () {
+        const workspace = createWorkspaceSvg();
+        const block = createInitializedBlock(workspace);
+        const icon = new MockIcon();
+        const applyColourSpy = sinon.spy(icon, 'applyColour');
+
+        block.addIcon(icon);
+        applyColourSpy.resetHistory();
+        block.setShadow(true);
+        assert.isTrue(
+          applyColourSpy.calledOnce,
+          'Expected applyColour to be called',
+        );
+      });
+    });
+
+    suite('Triggering updating editability', function () {
+      test('updateEditable is not called by headless blocks', function () {
+        const workspace = createHeadlessWorkspace();
+        const block = createUninitializedBlock(workspace);
+        const icon = new MockIcon();
+        const updateEditableSpy = sinon.spy(icon, 'updateEditable');
+
+        block.addIcon(icon);
+
+        assert.isFalse(
+          updateEditableSpy.called,
+          'Expected updateEditable to not be called',
+        );
+      });
+
+      test(
+        'updateEditable is called by headful blocks that are currently ' +
+          'rendered when the icon is added',
+        function () {
+          const workspace = createWorkspaceSvg();
+          const block = createInitializedBlock(workspace);
+          const icon = new MockIcon();
+          const updateEditableSpy = sinon.spy(icon, 'updateEditable');
+
+          block.addIcon(icon);
+          assert.isTrue(
+            updateEditableSpy.calledOnce,
+            'Expected updateEditable to be called',
+          );
+        },
+      );
+
+      test('updateEditable is called when the block is made ineditable', function () {
+        const workspace = createWorkspaceSvg();
+        const block = createInitializedBlock(workspace);
+        const icon = new MockIcon();
+        const updateEditableSpy = sinon.spy(icon, 'updateEditable');
+
+        block.addIcon(icon);
+        updateEditableSpy.resetHistory();
+        block.setEditable(false);
+        assert.isTrue(
+          updateEditableSpy.calledOnce,
+          'Expected updateEditable to be called',
+        );
+      });
+
+      test('updateEditable is called when the block is made editable', function () {
+        const workspace = createWorkspaceSvg();
+        const block = createInitializedBlock(workspace);
+        const icon = new MockIcon();
+        const updateEditableSpy = sinon.spy(icon, 'updateEditable');
+
+        block.addIcon(icon);
+        block.setEditable(false);
+        updateEditableSpy.resetHistory();
+        block.setEditable(true);
+        assert.isTrue(
+          updateEditableSpy.calledOnce,
+          'Expected updateEditable to be called',
+        );
+      });
+    });
+
+    suite('Triggering updating collapsed-ness', function () {
+      test('updateCollapsed is not called by headless blocks', function () {
+        const workspace = createHeadlessWorkspace();
+        const block = createUninitializedBlock(workspace);
+        const icon = new MockIcon();
+        const updateCollapsedSpy = sinon.spy(icon, 'updateCollapsed');
+
+        block.addIcon(icon);
+        block.setCollapsed(true);
+        block.setCollapsed(false);
+
+        assert.isFalse(
+          updateCollapsedSpy.called,
+          'Expected updateCollapsed to not be called',
+        );
+      });
+
+      test('updateCollapsed is called when the block is collapsed', function () {
+        const workspace = createWorkspaceSvg();
+        const block = createInitializedBlock(workspace);
+        const icon = new MockIcon();
+        const updateCollapsedSpy = sinon.stub(icon, 'updateCollapsed');
+        block.addIcon(icon);
+
+        updateCollapsedSpy.resetHistory();
+        block.setCollapsed(true);
+        this.clock.runAll();
+
+        assert.isTrue(
+          updateCollapsedSpy.called,
+          'Expected updateCollapsed to be called',
+        );
+      });
+
+      test('updateCollapsed is called when the block is expanded', function () {
+        const workspace = createWorkspaceSvg();
+        const block = createInitializedBlock(workspace);
+        const icon = new MockIcon();
+        const updateCollapsedSpy = sinon.spy(icon, 'updateCollapsed');
+        block.addIcon(icon);
+
+        block.setCollapsed(true);
+        block.setCollapsed(false);
+        this.clock.runAll();
+
+        assert.isTrue(
+          updateCollapsedSpy.called,
+          'Expected updateCollapsed to be called',
+        );
+      });
+    });
+  });
+
+  suite('Serialization', function () {
+    test('serializable icons are saved', function () {
+      const block = createHeadlessBlock(createHeadlessWorkspace());
+      block.addIcon(new MockSerializableIcon());
+      const json = Blockly.serialization.blocks.save(block);
+      assert.deepNestedInclude(
+        json,
+        {'icons': {'serializable icon': 'some state'}},
+        'Expected the JSON to include the saved state of the ' +
+          'serializable icon.',
+      );
+    });
+
+    test('non-serializable icons are not saved', function () {
+      const block = createHeadlessBlock(createHeadlessWorkspace());
+      block.addIcon(new MockNonSerializableIcon());
+      const json = Blockly.serialization.blocks.save(block);
+      assert.notProperty(
+        json,
+        'icons',
+        'Expected the JSON to not include any saved state for icons',
+      );
+    });
+  });
+
+  suite('Deserialization', function () {
+    test('registered icons are instantiated and added to the block', function () {
+      Blockly.icons.registry.register(
+        'serializable icon',
+        MockSerializableIcon,
+      );
+
+      const workspace = createHeadlessWorkspace();
+      const json = {
+        'type': 'empty_block',
+        'icons': {
+          'serializable icon': 'some state',
+        },
+      };
+      const block = Blockly.serialization.blocks.append(json, workspace);
+      assert.equal(
+        block.getIcon('serializable icon').state,
+        'some state',
+        'Expected the icon to have been properly instantiated and ' +
+          'deserialized',
+      );
+
+      Blockly.icons.registry.unregister('serializable icon');
+    });
+
+    test('trying to deserialize an unregistered icon throws an error', function () {
+      const workspace = createHeadlessWorkspace();
+      const json = {
+        'type': 'empty_block',
+        'icons': {
+          'serializable icon': 'some state',
+        },
+      };
+      assert.throws(
+        () => {
+          Blockly.serialization.blocks.append(json, workspace);
+        },
+        Blockly.serialization.exceptions.UnregisteredIcon,
+        '',
+        'Expected deserializing an unregistered icon to throw',
+      );
+    });
+  });
+});