mirror of
https://github.com/google/blockly.git
synced 2026-01-05 08:00:09 +01:00
ce22f42868
* chore(deps): Add pretter-plugin-organize-imports * chore: Remove insignificant blank lines in import sections Since prettier-plugin-organize-imports sorts imports within sections separated by blank lines, but preserves the section divisions, remove any blank lines that are not dividing imports into meaningful sections. Do not remove blank lines separating side-effect-only imports from main imports. * chore: Remove unneded eslint-disable directives * chore: Organise imports
1068 lines
35 KiB
JavaScript
1068 lines
35 KiB
JavaScript
/**
|
|
* @license
|
|
* Copyright 2021 Google LLC
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
import * as Blockly from '../../build/src/core/blockly.js';
|
|
import {assert} from '../../node_modules/chai/chai.js';
|
|
import {
|
|
defineRowBlock,
|
|
defineStackBlock,
|
|
defineStatementBlock,
|
|
} from './test_helpers/block_definitions.js';
|
|
import {
|
|
MockParameterModel,
|
|
MockProcedureModel,
|
|
} from './test_helpers/procedures.js';
|
|
import {
|
|
createGenUidStubWithReturns,
|
|
sharedTestSetup,
|
|
sharedTestTeardown,
|
|
workspaceTeardown,
|
|
} from './test_helpers/setup_teardown.js';
|
|
|
|
suite('JSO Serialization', function () {
|
|
setup(function () {
|
|
sharedTestSetup.call(this);
|
|
this.workspace = new Blockly.Workspace();
|
|
this.sandbox = sinon.createSandbox();
|
|
|
|
defineStackBlock();
|
|
defineRowBlock();
|
|
defineStatementBlock();
|
|
|
|
createGenUidStubWithReturns(new Array(10).fill().map((_, i) => 'id' + i));
|
|
});
|
|
|
|
teardown(function () {
|
|
this.sandbox.restore();
|
|
workspaceTeardown.call(this, this.workspace);
|
|
sharedTestTeardown.call(this);
|
|
});
|
|
|
|
function assertProperty(obj, property, value) {
|
|
assert.deepEqual(obj[property], value);
|
|
}
|
|
|
|
function assertNoProperty(obj, property) {
|
|
assertProperty(obj, property, undefined);
|
|
}
|
|
|
|
suite('Blocks', function () {
|
|
test('Null on insertionMarkers', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
block.setInsertionMarker(true);
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assert.isNull(jso);
|
|
});
|
|
|
|
test('Basic', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assertProperty(jso, 'type', 'row_block');
|
|
assertProperty(jso, 'id', 'id0');
|
|
});
|
|
|
|
test('saveId false', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
const jso = Blockly.serialization.blocks.save(block, {saveIds: false});
|
|
assertProperty(jso, 'id', undefined);
|
|
});
|
|
|
|
suite('Attributes', function () {
|
|
suite('Collapsed', function () {
|
|
test('True', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
block.setCollapsed(true);
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assertProperty(jso, 'collapsed', true);
|
|
});
|
|
|
|
test('False', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
block.setCollapsed(false);
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assertNoProperty(jso, 'collapsed');
|
|
});
|
|
});
|
|
|
|
suite('DisabledReasons', function () {
|
|
test('One reason', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
block.setDisabledReason(true, 'test reason');
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assertProperty(jso, 'disabledReasons', ['test reason']);
|
|
});
|
|
|
|
test('Zero reasons', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
block.setDisabledReason(false, 'test reason');
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assertNoProperty(jso, 'disabledReasons');
|
|
});
|
|
|
|
test('Multiple reasons', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
block.setDisabledReason(true, 'test reason 1');
|
|
block.setDisabledReason(true, 'test reason 2');
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assertProperty(jso, 'disabledReasons', [
|
|
'test reason 1',
|
|
'test reason 2',
|
|
]);
|
|
});
|
|
});
|
|
|
|
suite('Inline', function () {
|
|
test('True', function () {
|
|
const block = this.workspace.newBlock('statement_block');
|
|
block.setInputsInline(true);
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assertProperty(jso, 'inline', true);
|
|
});
|
|
|
|
test('False', function () {
|
|
const block = this.workspace.newBlock('statement_block');
|
|
block.setInputsInline(false);
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assertProperty(jso, 'inline', false);
|
|
});
|
|
|
|
test('undefined', function () {
|
|
const block = this.workspace.newBlock('statement_block');
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assertNoProperty(jso, 'inline');
|
|
});
|
|
|
|
test('True, matching default', function () {
|
|
const block = this.workspace.newBlock('statement_block');
|
|
block.setInputsInline(true);
|
|
block.inputsInlineDefault = true;
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assertNoProperty(jso, 'inline');
|
|
});
|
|
|
|
test('False, matching default', function () {
|
|
const block = this.workspace.newBlock('statement_block');
|
|
block.setInputsInline(false);
|
|
block.inputsInlineDefault = false;
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assertNoProperty(jso, 'inline');
|
|
});
|
|
});
|
|
|
|
suite('Data', function () {
|
|
test('No data', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assertNoProperty(jso, 'data');
|
|
});
|
|
|
|
test('With data', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
block.data = 'some data';
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assertProperty(jso, 'data', 'some data');
|
|
});
|
|
});
|
|
});
|
|
|
|
suite('Coords', function () {
|
|
test('No coordinates', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assertNoProperty(jso, 'x');
|
|
assertNoProperty(jso, 'y');
|
|
});
|
|
|
|
test('Simple', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
block.moveBy(42, 42);
|
|
const jso = Blockly.serialization.blocks.save(block, {
|
|
addCoordinates: true,
|
|
});
|
|
assertProperty(jso, 'x', 42);
|
|
assertProperty(jso, 'y', 42);
|
|
});
|
|
|
|
test('Negative', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
block.moveBy(-42, -42);
|
|
const jso = Blockly.serialization.blocks.save(block, {
|
|
addCoordinates: true,
|
|
});
|
|
assertProperty(jso, 'x', -42);
|
|
assertProperty(jso, 'y', -42);
|
|
});
|
|
|
|
test('Zero', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
const jso = Blockly.serialization.blocks.save(block, {
|
|
addCoordinates: true,
|
|
});
|
|
assertProperty(jso, 'x', 0);
|
|
assertProperty(jso, 'y', 0);
|
|
});
|
|
});
|
|
|
|
// Mutators.
|
|
suite('Extra state', function () {
|
|
test('Simple value', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
block.saveExtraState = function () {
|
|
return 'some extra state';
|
|
};
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assertProperty(jso, 'extraState', 'some extra state');
|
|
});
|
|
|
|
test('Object', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
block.saveExtraState = function () {
|
|
return {
|
|
'extra1': 'state1',
|
|
'extra2': 42,
|
|
'extra3': true,
|
|
};
|
|
};
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assertProperty(jso, 'extraState', {
|
|
'extra1': 'state1',
|
|
'extra2': 42,
|
|
'extra3': true,
|
|
});
|
|
});
|
|
|
|
test('Array', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
block.saveExtraState = function () {
|
|
return ['state1', 42, true];
|
|
};
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assertProperty(jso, 'extraState', ['state1', 42, true]);
|
|
});
|
|
|
|
test('Xml hooks', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
block.mutationToDom = function () {
|
|
const container = Blockly.utils.xml.createElement('mutation');
|
|
container.setAttribute('value', 'some value');
|
|
return container;
|
|
};
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assertProperty(
|
|
jso,
|
|
'extraState',
|
|
'<mutation value="some value"></mutation>',
|
|
);
|
|
});
|
|
});
|
|
|
|
suite('Icons', function () {
|
|
suite('Comment', function () {
|
|
test('Basic', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
block.setCommentText('test');
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assertProperty(jso, 'icons', {
|
|
'comment': {
|
|
'text': 'test',
|
|
'pinned': false,
|
|
'height': 80,
|
|
'width': 160,
|
|
},
|
|
});
|
|
});
|
|
|
|
test('Pinned', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
block.setCommentText('test');
|
|
block.getIcon(Blockly.icons.CommentIcon.TYPE).setBubbleVisible(true);
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assertProperty(jso, 'icons', {
|
|
'comment': {
|
|
'text': 'test',
|
|
'pinned': true,
|
|
'height': 80,
|
|
'width': 160,
|
|
},
|
|
});
|
|
});
|
|
|
|
test('Size', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
block.setCommentText('test');
|
|
block
|
|
.getIcon(Blockly.icons.CommentIcon.TYPE)
|
|
.setBubbleSize(new Blockly.utils.Size(320, 40));
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assertProperty(jso, 'icons', {
|
|
'comment': {
|
|
'text': 'test',
|
|
'pinned': false,
|
|
'height': 40,
|
|
'width': 320,
|
|
},
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
suite('Fields', function () {
|
|
class StringStateField extends Blockly.Field {
|
|
constructor(value, validator = undefined, config = undefined) {
|
|
super(value, validator, config);
|
|
this.SERIALIZABLE = true;
|
|
}
|
|
|
|
saveState() {
|
|
return 'some state';
|
|
}
|
|
}
|
|
|
|
class ObjectStateField extends Blockly.Field {
|
|
constructor(value, validator = undefined, config = undefined) {
|
|
super(value, validator, config);
|
|
this.SERIALIZABLE = true;
|
|
}
|
|
|
|
saveState() {
|
|
return {
|
|
'prop1': 'state1',
|
|
'prop2': 42,
|
|
'prop3': true,
|
|
};
|
|
}
|
|
}
|
|
|
|
class ArrayStateField extends Blockly.Field {
|
|
constructor(value, validator = undefined, config = undefined) {
|
|
super(value, validator, config);
|
|
this.SERIALIZABLE = true;
|
|
}
|
|
|
|
saveState() {
|
|
return ['state1', 42, true];
|
|
}
|
|
}
|
|
|
|
class XmlStateField extends Blockly.Field {
|
|
constructor(value, validator = undefined, config = undefined) {
|
|
super(value, validator, config);
|
|
this.SERIALIZABLE = true;
|
|
}
|
|
}
|
|
|
|
test('Simple value', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
block.getInput('INPUT').appendField(new StringStateField(''), 'FIELD');
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assertProperty(jso, 'fields', {'FIELD': 'some state'});
|
|
});
|
|
|
|
test('Object', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
block.getInput('INPUT').appendField(new ObjectStateField(''), 'FIELD');
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assertProperty(jso, 'fields', {
|
|
'FIELD': {
|
|
'prop1': 'state1',
|
|
'prop2': 42,
|
|
'prop3': true,
|
|
},
|
|
});
|
|
});
|
|
|
|
test('Array', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
block.getInput('INPUT').appendField(new ArrayStateField(''), 'FIELD');
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assertProperty(jso, 'fields', {'FIELD': ['state1', 42, true]});
|
|
});
|
|
});
|
|
|
|
suite('Connected blocks', function () {
|
|
setup(function () {
|
|
this.assertInput = function (jso, name, value) {
|
|
assert.deepInclude(jso['inputs'][name], value);
|
|
};
|
|
|
|
this.createBlockWithChild = function (blockType, inputName) {
|
|
const block = this.workspace.newBlock(blockType);
|
|
const childBlock = this.workspace.newBlock(blockType);
|
|
block
|
|
.getInput(inputName)
|
|
.connection.connect(
|
|
childBlock.outputConnection || childBlock.previousConnection,
|
|
);
|
|
return block;
|
|
};
|
|
|
|
this.createBlockWithShadow = function (blockType, inputName) {
|
|
const block = this.workspace.newBlock(blockType);
|
|
block
|
|
.getInput(inputName)
|
|
.connection.setShadowDom(
|
|
Blockly.utils.xml.textToDom(
|
|
'<shadow type="' + blockType + '" id="test"></shadow>',
|
|
),
|
|
);
|
|
return block;
|
|
};
|
|
|
|
this.createBlockWithShadowAndChild = function (blockType, inputName) {
|
|
const block = this.workspace.newBlock(blockType);
|
|
const childBlock = this.workspace.newBlock(blockType);
|
|
block
|
|
.getInput(inputName)
|
|
.connection.connect(
|
|
childBlock.outputConnection || childBlock.previousConnection,
|
|
);
|
|
block
|
|
.getInput(inputName)
|
|
.connection.setShadowDom(
|
|
Blockly.utils.xml.textToDom(
|
|
'<shadow type="' + blockType + '" id="test"></shadow>',
|
|
),
|
|
);
|
|
return block;
|
|
};
|
|
|
|
this.assertChild = function (blockType, inputName) {
|
|
const block = this.createBlockWithChild(blockType, inputName);
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
this.assertInput(jso, inputName, {
|
|
'block': {'type': blockType, 'id': 'id2'},
|
|
});
|
|
};
|
|
|
|
this.assertShadow = function (blockType, inputName) {
|
|
const block = this.createBlockWithShadow(blockType, inputName);
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
this.assertInput(jso, inputName, {
|
|
'shadow': {'type': blockType, 'id': 'test'},
|
|
});
|
|
};
|
|
|
|
this.assertOverwrittenShadow = function (blockType, inputName) {
|
|
const block = this.createBlockWithShadowAndChild(
|
|
blockType,
|
|
inputName,
|
|
);
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
this.assertInput(jso, inputName, {
|
|
'block': {
|
|
'type': blockType,
|
|
'id': 'id2',
|
|
},
|
|
'shadow': {
|
|
'type': blockType,
|
|
'id': 'test',
|
|
},
|
|
});
|
|
};
|
|
|
|
this.assertNoChild = function (blockType, inputName) {
|
|
const block = this.createBlockWithChild(blockType, inputName);
|
|
const jso = Blockly.serialization.blocks.save(block, {
|
|
addInputBlocks: false,
|
|
});
|
|
assert.isUndefined(jso['inputs']);
|
|
};
|
|
|
|
this.assertNoShadow = function (blockType, inputName) {
|
|
const block = this.createBlockWithShadow(blockType, inputName);
|
|
const jso = Blockly.serialization.blocks.save(block, {
|
|
addInputBlocks: false,
|
|
});
|
|
assert.isUndefined(jso['inputs']);
|
|
};
|
|
|
|
this.assertNoOverwrittenShadow = function (blockType, inputName) {
|
|
const block = this.createBlockWithShadowAndChild(
|
|
blockType,
|
|
inputName,
|
|
);
|
|
const jso = Blockly.serialization.blocks.save(block, {
|
|
addInputBlocks: false,
|
|
});
|
|
assert.isUndefined(jso['inputs']);
|
|
};
|
|
});
|
|
|
|
suite('Editing shadow value', function () {
|
|
test('Not overwritten', function () {
|
|
const block = this.workspace.newBlock('text_print');
|
|
block.getInput('TEXT').connection.setShadowState({
|
|
'type': 'text',
|
|
'id': 'id',
|
|
});
|
|
block.getInputTargetBlock('TEXT').setFieldValue('new value', 'TEXT');
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
this.assertInput(jso, 'TEXT', {
|
|
'shadow': {
|
|
'type': 'text',
|
|
'id': 'id',
|
|
'fields': {
|
|
'TEXT': 'new value',
|
|
},
|
|
},
|
|
});
|
|
});
|
|
|
|
test('Overwritten', function () {
|
|
const block = this.workspace.newBlock('text_print');
|
|
block.getInput('TEXT').connection.setShadowState({
|
|
'type': 'text',
|
|
'id': 'id',
|
|
});
|
|
block.getInputTargetBlock('TEXT').setFieldValue('new value', 'TEXT');
|
|
const childBlock = this.workspace.newBlock('text');
|
|
block
|
|
.getInput('TEXT')
|
|
.connection.connect(childBlock.outputConnection);
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
this.assertInput(jso, 'TEXT', {
|
|
'shadow': {
|
|
'type': 'text',
|
|
'id': 'id',
|
|
'fields': {
|
|
'TEXT': 'new value',
|
|
},
|
|
},
|
|
'block': {
|
|
'type': 'text',
|
|
'id': 'id3',
|
|
'fields': {
|
|
'TEXT': '',
|
|
},
|
|
},
|
|
});
|
|
});
|
|
});
|
|
|
|
suite('Value', function () {
|
|
suite('With serialization', function () {
|
|
test('Child', function () {
|
|
this.assertChild('row_block', 'INPUT');
|
|
});
|
|
|
|
test('Shadow', function () {
|
|
this.assertShadow('row_block', 'INPUT');
|
|
});
|
|
|
|
test('Overwritten shadow', function () {
|
|
this.assertOverwrittenShadow('row_block', 'INPUT');
|
|
});
|
|
});
|
|
|
|
suite('Without serialization', function () {
|
|
test('Child', function () {
|
|
this.assertNoChild('row_block', 'INPUT');
|
|
});
|
|
|
|
test('Shadow', function () {
|
|
this.assertNoShadow('row_block', 'INPUT');
|
|
});
|
|
|
|
test('Overwritten shadow', function () {
|
|
this.assertNoOverwrittenShadow('row_block', 'INPUT');
|
|
});
|
|
});
|
|
});
|
|
|
|
suite('Statement', function () {
|
|
suite('With serialization', function () {
|
|
test('Child', function () {
|
|
this.assertChild('statement_block', 'NAME');
|
|
});
|
|
|
|
test('Shadow', function () {
|
|
this.assertShadow('statement_block', 'NAME');
|
|
});
|
|
|
|
test('Overwritten shadow', function () {
|
|
this.assertOverwrittenShadow('statement_block', 'NAME');
|
|
});
|
|
|
|
test('Child with next blocks', function () {
|
|
const block = this.workspace.newBlock('statement_block');
|
|
const childBlock = this.workspace.newBlock('stack_block');
|
|
const grandChildBlock = this.workspace.newBlock('stack_block');
|
|
block
|
|
.getInput('NAME')
|
|
.connection.connect(childBlock.previousConnection);
|
|
childBlock.nextConnection.connect(
|
|
grandChildBlock.previousConnection,
|
|
);
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
this.assertInput(jso, 'NAME', {
|
|
'block': {
|
|
'type': 'stack_block',
|
|
'id': 'id2',
|
|
'next': {
|
|
'block': {
|
|
'type': 'stack_block',
|
|
'id': 'id4',
|
|
},
|
|
},
|
|
},
|
|
});
|
|
});
|
|
});
|
|
|
|
suite('Without serialization', function () {
|
|
test('Child', function () {
|
|
this.assertNoChild('statement_block', 'NAME');
|
|
});
|
|
|
|
test('Shadow', function () {
|
|
this.assertNoShadow('statement_block', 'NAME');
|
|
});
|
|
|
|
test('Overwritten shadow', function () {
|
|
this.assertNoOverwrittenShadow('statement_block', 'NAME');
|
|
});
|
|
});
|
|
});
|
|
|
|
suite('Next', function () {
|
|
setup(function () {
|
|
this.createNextWithChild = function () {
|
|
const block = this.workspace.newBlock('stack_block');
|
|
const childBlock = this.workspace.newBlock('stack_block');
|
|
block.nextConnection.connect(childBlock.previousConnection);
|
|
return block;
|
|
};
|
|
|
|
this.createNextWithShadow = function () {
|
|
const block = this.workspace.newBlock('stack_block');
|
|
block.nextConnection.setShadowDom(
|
|
Blockly.utils.xml.textToDom(
|
|
'<shadow type="stack_block" id="test"></shadow>',
|
|
),
|
|
);
|
|
return block;
|
|
};
|
|
|
|
this.createNextWithShadowAndChild = function () {
|
|
const block = this.workspace.newBlock('stack_block');
|
|
const childBlock = this.workspace.newBlock('stack_block');
|
|
block.nextConnection.connect(childBlock.previousConnection);
|
|
block.nextConnection.setShadowDom(
|
|
Blockly.utils.xml.textToDom(
|
|
'<shadow type="stack_block" id="test"></shadow>',
|
|
),
|
|
);
|
|
return block;
|
|
};
|
|
});
|
|
|
|
suite('With serialization', function () {
|
|
test('Child', function () {
|
|
const block = this.createNextWithChild();
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assert.deepInclude(jso['next'], {
|
|
'block': {'type': 'stack_block', 'id': 'id2'},
|
|
});
|
|
});
|
|
|
|
test('Shadow', function () {
|
|
const block = this.createNextWithShadow();
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assert.deepInclude(jso['next'], {
|
|
'shadow': {'type': 'stack_block', 'id': 'test'},
|
|
});
|
|
});
|
|
|
|
test('Overwritten shadow', function () {
|
|
const block = this.createNextWithShadowAndChild();
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assert.deepInclude(jso['next'], {
|
|
'block': {
|
|
'type': 'stack_block',
|
|
'id': 'id2',
|
|
},
|
|
'shadow': {
|
|
'type': 'stack_block',
|
|
'id': 'test',
|
|
},
|
|
});
|
|
});
|
|
|
|
test('Next block with inputs', function () {
|
|
const block = this.workspace.newBlock('stack_block');
|
|
const childBlock = this.workspace.newBlock('statement_block');
|
|
const grandChildBlock = this.workspace.newBlock('stack_block');
|
|
block.nextConnection.connect(childBlock.previousConnection);
|
|
childBlock
|
|
.getInput('NAME')
|
|
.connection.connect(grandChildBlock.previousConnection);
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assert.deepInclude(jso['next'], {
|
|
'block': {
|
|
'type': 'statement_block',
|
|
'id': 'id2',
|
|
'inputs': {
|
|
'NAME': {
|
|
'block': {
|
|
'type': 'stack_block',
|
|
'id': 'id4',
|
|
},
|
|
},
|
|
},
|
|
},
|
|
});
|
|
});
|
|
});
|
|
|
|
suite('Without serialization', function () {
|
|
test('Child', function () {
|
|
const block = this.createNextWithChild();
|
|
const jso = Blockly.serialization.blocks.save(block, {
|
|
addNextBlocks: false,
|
|
});
|
|
assert.isUndefined(jso['next']);
|
|
});
|
|
|
|
test('Shadow', function () {
|
|
const block = this.createNextWithShadow();
|
|
const jso = Blockly.serialization.blocks.save(block, {
|
|
addNextBlocks: false,
|
|
});
|
|
assert.isUndefined(jso['next']);
|
|
});
|
|
|
|
test('Overwritten shadow', function () {
|
|
const block = this.createNextWithShadowAndChild();
|
|
const jso = Blockly.serialization.blocks.save(block, {
|
|
addNextBlocks: false,
|
|
});
|
|
assert.isUndefined(jso['next']);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
suite('Do full serialization', function () {
|
|
suite('True', function () {
|
|
test('Single block', function () {
|
|
const block = this.workspace.newBlock('variables_get');
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assert.deepEqual(jso['fields']['VAR'], {
|
|
'id': 'id2',
|
|
'name': 'item',
|
|
'type': '',
|
|
});
|
|
});
|
|
|
|
test('Input block', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
const childBlock = this.workspace.newBlock('variables_get');
|
|
block
|
|
.getInput('INPUT')
|
|
.connection.connect(childBlock.outputConnection);
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assert.deepEqual(jso['inputs']['INPUT']['block']['fields']['VAR'], {
|
|
'id': 'id4',
|
|
'name': 'item',
|
|
'type': '',
|
|
});
|
|
});
|
|
|
|
test('Next block', function () {
|
|
const block = this.workspace.newBlock('stack_block');
|
|
const childBlock = this.workspace.newBlock('variables_set');
|
|
block.nextConnection.connect(childBlock.previousConnection);
|
|
const jso = Blockly.serialization.blocks.save(block);
|
|
assert.deepEqual(jso['next']['block']['fields']['VAR'], {
|
|
'id': 'id4',
|
|
'name': 'item',
|
|
'type': '',
|
|
});
|
|
});
|
|
});
|
|
|
|
suite('False', function () {
|
|
test('Single block', function () {
|
|
const block = this.workspace.newBlock('variables_get');
|
|
const jso = Blockly.serialization.blocks.save(block, {
|
|
doFullSerialization: false,
|
|
});
|
|
assert.deepEqual(jso['fields']['VAR'], {'id': 'id2'});
|
|
assert.isUndefined(jso['fields']['VAR']['name']);
|
|
assert.isUndefined(jso['fields']['VAR']['type']);
|
|
});
|
|
|
|
test('Input block', function () {
|
|
const block = this.workspace.newBlock('row_block');
|
|
const childBlock = this.workspace.newBlock('variables_get');
|
|
block
|
|
.getInput('INPUT')
|
|
.connection.connect(childBlock.outputConnection);
|
|
const jso = Blockly.serialization.blocks.save(block, {
|
|
doFullSerialization: false,
|
|
});
|
|
assert.deepEqual(jso['inputs']['INPUT']['block']['fields']['VAR'], {
|
|
'id': 'id4',
|
|
});
|
|
assert.isUndefined(
|
|
jso['inputs']['INPUT']['block']['fields']['VAR']['name'],
|
|
);
|
|
assert.isUndefined(
|
|
jso['inputs']['INPUT']['block']['fields']['VAR']['type'],
|
|
);
|
|
});
|
|
|
|
test('Next block', function () {
|
|
const block = this.workspace.newBlock('stack_block');
|
|
const childBlock = this.workspace.newBlock('variables_set');
|
|
block.nextConnection.connect(childBlock.previousConnection);
|
|
const jso = Blockly.serialization.blocks.save(block, {
|
|
doFullSerialization: false,
|
|
});
|
|
assert.deepEqual(jso['next']['block']['fields']['VAR'], {
|
|
'id': 'id4',
|
|
});
|
|
assert.isUndefined(jso['next']['block']['fields']['VAR']['name']);
|
|
assert.isUndefined(jso['next']['block']['fields']['VAR']['type']);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
suite('Variables', function () {
|
|
test('Without type', function () {
|
|
this.workspace.createVariable('testVar', '', 'testId');
|
|
const jso = Blockly.serialization.workspaces.save(this.workspace);
|
|
const variable = jso['variables'][0];
|
|
assertProperty(variable, 'name', 'testVar');
|
|
assertProperty(variable, 'id', 'testId');
|
|
assertNoProperty(variable, 'type');
|
|
});
|
|
|
|
test('With type', function () {
|
|
this.workspace.createVariable('testVar', 'testType', 'testId');
|
|
const jso = Blockly.serialization.workspaces.save(this.workspace);
|
|
const variable = jso['variables'][0];
|
|
assertProperty(variable, 'name', 'testVar');
|
|
assertProperty(variable, 'id', 'testId');
|
|
assertProperty(variable, 'type', 'testType');
|
|
});
|
|
});
|
|
|
|
suite('Procedures', function () {
|
|
setup(function () {
|
|
this.procedureMap = this.workspace.getProcedureMap();
|
|
this.serializer =
|
|
new Blockly.serialization.procedures.ProcedureSerializer(
|
|
MockProcedureModel,
|
|
MockParameterModel,
|
|
);
|
|
});
|
|
|
|
teardown(function () {
|
|
this.procedureMap = null;
|
|
this.serializer = null;
|
|
});
|
|
|
|
test('save is called on the procedure model', function () {
|
|
const proc = new MockProcedureModel();
|
|
this.workspace.getProcedureMap().set('test', proc);
|
|
const spy = this.sandbox.spy(proc, 'saveState');
|
|
|
|
this.serializer.save(this.workspace);
|
|
|
|
assert.isTrue(
|
|
spy.calledOnce,
|
|
'Expected the saveState method to be called on the procedure model',
|
|
);
|
|
});
|
|
|
|
test('save is called on each parameter model', function () {
|
|
const proc = new MockProcedureModel();
|
|
const param1 = new MockParameterModel();
|
|
const param2 = new MockParameterModel();
|
|
proc.insertParameter(param1, 0);
|
|
proc.insertParameter(param2, 1);
|
|
this.workspace.getProcedureMap().set('test', proc);
|
|
const spy1 = this.sandbox.spy(param1, 'saveState');
|
|
const spy2 = this.sandbox.spy(param2, 'saveState');
|
|
|
|
this.serializer.save(this.workspace);
|
|
|
|
assert.isTrue(
|
|
spy1.calledOnce,
|
|
'Expected the saveState method to be called on the first parameter model',
|
|
);
|
|
assert.isTrue(
|
|
spy2.calledOnce,
|
|
'Expected the saveState method to be called on the first parameter model',
|
|
);
|
|
});
|
|
});
|
|
|
|
suite('Workspace comments', function () {
|
|
suite('IDs', function () {
|
|
test('IDs are saved by default', function () {
|
|
const comment = new Blockly.comments.WorkspaceComment(
|
|
this.workspace,
|
|
'testID',
|
|
);
|
|
|
|
const json = Blockly.serialization.workspaceComments.save(comment);
|
|
|
|
assertProperty(json, 'id', 'testID');
|
|
});
|
|
|
|
test('saving IDs can be disabled', function () {
|
|
const comment = new Blockly.comments.WorkspaceComment(
|
|
this.workspace,
|
|
'testID',
|
|
);
|
|
|
|
const json = Blockly.serialization.workspaceComments.save(comment, {
|
|
saveIds: false,
|
|
});
|
|
|
|
assertNoProperty(json, 'id');
|
|
});
|
|
});
|
|
|
|
suite('Coordinates', function () {
|
|
test('coordinates are not saved by default', function () {
|
|
const comment = new Blockly.comments.WorkspaceComment(this.workspace);
|
|
comment.moveTo(new Blockly.utils.Coordinate(42, 1337));
|
|
|
|
const json = Blockly.serialization.workspaceComments.save(comment);
|
|
|
|
assertNoProperty(json, 'x');
|
|
assertNoProperty(json, 'y');
|
|
});
|
|
|
|
test('saving coordinates can be enabled', function () {
|
|
const comment = new Blockly.comments.WorkspaceComment(this.workspace);
|
|
comment.moveTo(new Blockly.utils.Coordinate(42, 1337));
|
|
|
|
const json = Blockly.serialization.workspaceComments.save(comment, {
|
|
addCoordinates: true,
|
|
});
|
|
|
|
assertProperty(json, 'x', 42);
|
|
assertProperty(json, 'y', 1337);
|
|
});
|
|
});
|
|
|
|
suite('Text', function () {
|
|
test('the empty string is not saved', function () {
|
|
const comment = new Blockly.comments.WorkspaceComment(this.workspace);
|
|
comment.setText('');
|
|
|
|
const json = Blockly.serialization.workspaceComments.save(comment);
|
|
|
|
assertNoProperty(json, 'text');
|
|
});
|
|
|
|
test('text is saved', function () {
|
|
const comment = new Blockly.comments.WorkspaceComment(this.workspace);
|
|
comment.setText('test text');
|
|
|
|
const json = Blockly.serialization.workspaceComments.save(comment);
|
|
|
|
assertProperty(json, 'text', 'test text');
|
|
});
|
|
});
|
|
|
|
test('size is saved', function () {
|
|
const comment = new Blockly.comments.WorkspaceComment(this.workspace);
|
|
comment.setSize(new Blockly.utils.Size(42, 1337));
|
|
|
|
const json = Blockly.serialization.workspaceComments.save(comment);
|
|
|
|
assertProperty(json, 'width', 42);
|
|
assertProperty(json, 'height', 1337);
|
|
});
|
|
|
|
suite('Collapsed', function () {
|
|
test('collapsed is not saved if false', function () {
|
|
const comment = new Blockly.comments.WorkspaceComment(this.workspace);
|
|
comment.setCollapsed(false);
|
|
|
|
const json = Blockly.serialization.workspaceComments.save(comment);
|
|
|
|
assertNoProperty(json, 'collapsed');
|
|
});
|
|
|
|
test('collapsed is saved if true', function () {
|
|
const comment = new Blockly.comments.WorkspaceComment(this.workspace);
|
|
comment.setCollapsed(true);
|
|
|
|
const json = Blockly.serialization.workspaceComments.save(comment);
|
|
|
|
assertProperty(json, 'collapsed', true);
|
|
});
|
|
});
|
|
|
|
suite('Editable', function () {
|
|
test('editable is not saved if true', function () {
|
|
const comment = new Blockly.comments.WorkspaceComment(this.workspace);
|
|
comment.setEditable(true);
|
|
|
|
const json = Blockly.serialization.workspaceComments.save(comment);
|
|
|
|
assertNoProperty(json, 'editable');
|
|
});
|
|
|
|
test('editable is saved if false', function () {
|
|
const comment = new Blockly.comments.WorkspaceComment(this.workspace);
|
|
comment.setEditable(false);
|
|
|
|
const json = Blockly.serialization.workspaceComments.save(comment);
|
|
|
|
assertProperty(json, 'editable', false);
|
|
});
|
|
});
|
|
|
|
suite('Movable', function () {
|
|
test('movable is not saved if true', function () {
|
|
const comment = new Blockly.comments.WorkspaceComment(this.workspace);
|
|
comment.setMovable(true);
|
|
|
|
const json = Blockly.serialization.workspaceComments.save(comment);
|
|
|
|
assertNoProperty(json, 'movable');
|
|
});
|
|
|
|
test('movable is saved if false', function () {
|
|
const comment = new Blockly.comments.WorkspaceComment(this.workspace);
|
|
comment.setMovable(false);
|
|
|
|
const json = Blockly.serialization.workspaceComments.save(comment);
|
|
|
|
assertProperty(json, 'movable', false);
|
|
});
|
|
});
|
|
|
|
suite('Deletable', function () {
|
|
test('deletable is not saved if true', function () {
|
|
const comment = new Blockly.comments.WorkspaceComment(this.workspace);
|
|
comment.setDeletable(true);
|
|
|
|
const json = Blockly.serialization.workspaceComments.save(comment);
|
|
|
|
assertNoProperty(json, 'deletable');
|
|
});
|
|
|
|
test('deletable is saved if false', function () {
|
|
const comment = new Blockly.comments.WorkspaceComment(this.workspace);
|
|
comment.setDeletable(false);
|
|
|
|
const json = Blockly.serialization.workspaceComments.save(comment);
|
|
|
|
assertProperty(json, 'deletable', false);
|
|
});
|
|
});
|
|
});
|
|
});
|