2016-06-06 15:59:21 -04:00
|
|
|
var test = require('tap').test;
|
2016-06-06 16:17:12 -04:00
|
|
|
var Blocks = require('../../src/engine/blocks');
|
2016-06-06 15:59:21 -04:00
|
|
|
|
|
|
|
test('spec', function (t) {
|
|
|
|
var b = new Blocks();
|
|
|
|
|
|
|
|
t.type(Blocks, 'function');
|
|
|
|
t.type(b, 'object');
|
|
|
|
t.ok(b instanceof Blocks);
|
|
|
|
|
|
|
|
t.type(b._blocks, 'object');
|
2016-08-11 11:11:27 -04:00
|
|
|
t.type(b._scripts, 'object');
|
|
|
|
t.ok(Array.isArray(b._scripts));
|
2016-06-06 15:59:21 -04:00
|
|
|
|
|
|
|
t.type(b.createBlock, 'function');
|
|
|
|
t.type(b.moveBlock, 'function');
|
|
|
|
t.type(b.changeBlock, 'function');
|
|
|
|
t.type(b.deleteBlock, 'function');
|
2016-06-07 11:34:01 -04:00
|
|
|
t.type(b.getBlock, 'function');
|
2016-08-11 11:11:27 -04:00
|
|
|
t.type(b.getScripts, 'function');
|
2016-06-07 11:34:01 -04:00
|
|
|
t.type(b.getNextBlock, 'function');
|
2016-08-10 11:27:21 -04:00
|
|
|
t.type(b.getBranch, 'function');
|
2016-06-07 11:34:01 -04:00
|
|
|
t.type(b.getOpcode, 'function');
|
2016-06-06 15:59:21 -04:00
|
|
|
|
2016-06-07 11:34:01 -04:00
|
|
|
|
|
|
|
t.end();
|
|
|
|
});
|
|
|
|
|
|
|
|
// Getter tests
|
|
|
|
test('getBlock', function (t) {
|
|
|
|
var b = new Blocks();
|
|
|
|
b.createBlock({
|
|
|
|
id: 'foo',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: true
|
|
|
|
});
|
|
|
|
var block = b.getBlock('foo');
|
|
|
|
t.type(block, 'object');
|
|
|
|
var notBlock = b.getBlock('?');
|
|
|
|
t.type(notBlock, 'undefined');
|
|
|
|
t.end();
|
|
|
|
});
|
|
|
|
|
2016-08-11 11:11:27 -04:00
|
|
|
test('getScripts', function (t) {
|
2016-06-07 11:34:01 -04:00
|
|
|
var b = new Blocks();
|
2016-08-11 11:11:27 -04:00
|
|
|
var scripts = b.getScripts();
|
|
|
|
t.type(scripts, 'object');
|
|
|
|
t.equals(scripts.length, 0);
|
2016-06-07 11:34:01 -04:00
|
|
|
// Create two top-level blocks and one not.
|
|
|
|
b.createBlock({
|
|
|
|
id: 'foo',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: true
|
|
|
|
});
|
|
|
|
b.createBlock({
|
|
|
|
id: 'foo2',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: true
|
|
|
|
});
|
|
|
|
b.createBlock({
|
|
|
|
id: 'foo3',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: false
|
|
|
|
});
|
|
|
|
|
2016-08-11 11:11:27 -04:00
|
|
|
scripts = b.getScripts();
|
|
|
|
t.type(scripts, 'object');
|
|
|
|
t.equals(scripts.length, 2);
|
|
|
|
t.ok(scripts.indexOf('foo') > -1);
|
|
|
|
t.ok(scripts.indexOf('foo2') > -1);
|
|
|
|
t.equals(scripts.indexOf('foo3'), -1);
|
2016-06-07 11:34:01 -04:00
|
|
|
t.end();
|
|
|
|
|
|
|
|
});
|
|
|
|
|
|
|
|
test('getNextBlock', function (t) {
|
|
|
|
var b = new Blocks();
|
|
|
|
b.createBlock({
|
|
|
|
id: 'foo',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: true
|
|
|
|
});
|
|
|
|
|
|
|
|
var next = b.getNextBlock('foo');
|
|
|
|
t.equals(next, null);
|
|
|
|
|
|
|
|
// Add a block with "foo" as its next.
|
|
|
|
b.createBlock({
|
|
|
|
id: 'foo2',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: 'foo',
|
|
|
|
fields: {},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: true
|
|
|
|
});
|
|
|
|
|
|
|
|
next = b.getNextBlock('foo2');
|
|
|
|
t.equals(next, 'foo');
|
|
|
|
|
|
|
|
// Block that doesn't exist.
|
|
|
|
var noBlock = b.getNextBlock('?');
|
|
|
|
t.equals(noBlock, null);
|
|
|
|
|
|
|
|
t.end();
|
|
|
|
});
|
|
|
|
|
2016-08-10 11:27:21 -04:00
|
|
|
test('getBranch', function (t) {
|
2016-06-07 11:34:01 -04:00
|
|
|
var b = new Blocks();
|
2016-08-10 11:27:21 -04:00
|
|
|
// Single branch
|
2016-06-07 11:34:01 -04:00
|
|
|
b.createBlock({
|
|
|
|
id: 'foo',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {
|
|
|
|
SUBSTACK: {
|
|
|
|
name: 'SUBSTACK',
|
2016-09-06 10:55:52 -04:00
|
|
|
block: 'foo2',
|
|
|
|
shadow: null
|
2016-06-07 11:34:01 -04:00
|
|
|
}
|
|
|
|
},
|
|
|
|
topLevel: true
|
|
|
|
});
|
|
|
|
b.createBlock({
|
|
|
|
id: 'foo2',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: false
|
|
|
|
});
|
|
|
|
|
2016-08-10 11:27:21 -04:00
|
|
|
var branch = b.getBranch('foo');
|
|
|
|
t.equals(branch, 'foo2');
|
2016-06-07 11:34:01 -04:00
|
|
|
|
2016-08-10 11:27:21 -04:00
|
|
|
var notBranch = b.getBranch('?');
|
|
|
|
t.equals(notBranch, null);
|
2016-06-07 11:34:01 -04:00
|
|
|
|
|
|
|
t.end();
|
|
|
|
});
|
|
|
|
|
2016-08-10 11:27:21 -04:00
|
|
|
test('getBranch2', function (t) {
|
2016-06-07 11:34:01 -04:00
|
|
|
var b = new Blocks();
|
2016-08-10 11:27:21 -04:00
|
|
|
// Second branch
|
2016-06-07 11:34:01 -04:00
|
|
|
b.createBlock({
|
|
|
|
id: 'foo',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {
|
|
|
|
SUBSTACK: {
|
|
|
|
name: 'SUBSTACK',
|
2016-09-06 10:55:52 -04:00
|
|
|
block: 'foo2',
|
|
|
|
shadow: null
|
2016-06-07 11:34:01 -04:00
|
|
|
},
|
|
|
|
SUBSTACK2: {
|
|
|
|
name: 'SUBSTACK2',
|
2016-09-06 10:55:52 -04:00
|
|
|
block: 'foo3',
|
|
|
|
shadow: null
|
2016-06-07 11:34:01 -04:00
|
|
|
}
|
|
|
|
},
|
|
|
|
topLevel: true
|
|
|
|
});
|
|
|
|
b.createBlock({
|
|
|
|
id: 'foo2',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: false
|
|
|
|
});
|
|
|
|
b.createBlock({
|
|
|
|
id: 'foo3',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: false
|
|
|
|
});
|
|
|
|
|
2016-08-10 11:27:21 -04:00
|
|
|
var branch1 = b.getBranch('foo', 1);
|
|
|
|
var branch2 = b.getBranch('foo', 2);
|
|
|
|
t.equals(branch1, 'foo2');
|
|
|
|
t.equals(branch2, 'foo3');
|
2016-06-07 11:34:01 -04:00
|
|
|
|
|
|
|
t.end();
|
|
|
|
});
|
|
|
|
|
2016-08-10 11:27:21 -04:00
|
|
|
test('getBranch with none', function (t) {
|
2016-06-07 11:34:01 -04:00
|
|
|
var b = new Blocks();
|
|
|
|
b.createBlock({
|
|
|
|
id: 'foo',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: true
|
|
|
|
});
|
2016-08-10 11:27:21 -04:00
|
|
|
var noBranch = b.getBranch('foo');
|
|
|
|
t.equals(noBranch, null);
|
2016-06-07 11:34:01 -04:00
|
|
|
t.end();
|
|
|
|
});
|
|
|
|
|
|
|
|
test('getOpcode', function (t) {
|
|
|
|
var b = new Blocks();
|
2017-03-22 04:48:30 -04:00
|
|
|
var block = {
|
2016-06-07 11:34:01 -04:00
|
|
|
id: 'foo',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: true
|
2017-03-22 04:48:30 -04:00
|
|
|
};
|
|
|
|
b.createBlock(block);
|
|
|
|
var opcode = b.getOpcode(block);
|
2016-06-07 11:34:01 -04:00
|
|
|
t.equals(opcode, 'TEST_BLOCK');
|
2017-03-22 04:48:30 -04:00
|
|
|
var undefinedBlock = b.getBlock('?');
|
|
|
|
var undefinedOpcode = b.getOpcode(undefinedBlock);
|
|
|
|
t.equals(undefinedOpcode, null);
|
2016-06-06 15:59:21 -04:00
|
|
|
t.end();
|
|
|
|
});
|
|
|
|
|
2016-06-07 11:34:01 -04:00
|
|
|
// Block events tests
|
2016-06-06 15:59:21 -04:00
|
|
|
test('create', function (t) {
|
|
|
|
var b = new Blocks();
|
|
|
|
b.createBlock({
|
|
|
|
id: 'foo',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: true
|
|
|
|
});
|
|
|
|
|
2016-10-23 12:41:45 -04:00
|
|
|
t.type(b._blocks.foo, 'object');
|
|
|
|
t.equal(b._blocks.foo.opcode, 'TEST_BLOCK');
|
2016-08-11 11:11:27 -04:00
|
|
|
t.notEqual(b._scripts.indexOf('foo'), -1);
|
2016-06-06 15:59:21 -04:00
|
|
|
t.end();
|
|
|
|
});
|
|
|
|
|
|
|
|
test('move', function (t) {
|
|
|
|
var b = new Blocks();
|
|
|
|
b.createBlock({
|
|
|
|
id: 'foo',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: true
|
|
|
|
});
|
|
|
|
b.createBlock({
|
|
|
|
id: 'bar',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: true
|
|
|
|
});
|
|
|
|
|
|
|
|
// Attach 'bar' to the end of 'foo'
|
|
|
|
b.moveBlock({
|
|
|
|
id: 'bar',
|
|
|
|
newParent: 'foo'
|
|
|
|
});
|
2016-08-11 11:11:27 -04:00
|
|
|
t.equal(b._scripts.length, 1);
|
2016-06-06 15:59:21 -04:00
|
|
|
t.equal(Object.keys(b._blocks).length, 2);
|
2016-10-23 12:41:45 -04:00
|
|
|
t.equal(b._blocks.foo.next, 'bar');
|
2016-06-06 15:59:21 -04:00
|
|
|
|
|
|
|
// Detach 'bar' from 'foo'
|
|
|
|
b.moveBlock({
|
|
|
|
id: 'bar',
|
|
|
|
oldParent: 'foo'
|
|
|
|
});
|
2016-08-11 11:11:27 -04:00
|
|
|
t.equal(b._scripts.length, 2);
|
2016-06-06 15:59:21 -04:00
|
|
|
t.equal(Object.keys(b._blocks).length, 2);
|
2016-10-23 12:41:45 -04:00
|
|
|
t.equal(b._blocks.foo.next, null);
|
2016-06-06 15:59:21 -04:00
|
|
|
|
|
|
|
t.end();
|
|
|
|
});
|
|
|
|
|
2016-09-08 09:40:01 -04:00
|
|
|
test('move into empty', function (t) {
|
|
|
|
var b = new Blocks();
|
|
|
|
b.createBlock({
|
|
|
|
id: 'foo',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: true
|
|
|
|
});
|
|
|
|
b.createBlock({
|
|
|
|
id: 'bar',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: true
|
|
|
|
});
|
|
|
|
b.moveBlock({
|
|
|
|
id: 'bar',
|
|
|
|
newInput: 'fooInput',
|
|
|
|
newParent: 'foo'
|
|
|
|
});
|
2016-10-23 12:41:45 -04:00
|
|
|
t.equal(b._blocks.foo.inputs.fooInput.block, 'bar');
|
2016-09-08 09:40:01 -04:00
|
|
|
t.end();
|
|
|
|
});
|
|
|
|
|
|
|
|
test('move no obscure shadow', function (t) {
|
|
|
|
var b = new Blocks();
|
|
|
|
b.createBlock({
|
|
|
|
id: 'foo',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {
|
2016-10-24 11:02:19 -04:00
|
|
|
fooInput: {
|
2016-09-08 09:40:01 -04:00
|
|
|
name: 'fooInput',
|
|
|
|
block: 'x',
|
|
|
|
shadow: 'y'
|
|
|
|
}
|
|
|
|
},
|
|
|
|
topLevel: true
|
|
|
|
});
|
|
|
|
b.createBlock({
|
|
|
|
id: 'bar',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: true
|
|
|
|
});
|
|
|
|
b.moveBlock({
|
|
|
|
id: 'bar',
|
|
|
|
newInput: 'fooInput',
|
|
|
|
newParent: 'foo'
|
|
|
|
});
|
2016-10-23 12:41:45 -04:00
|
|
|
t.equal(b._blocks.foo.inputs.fooInput.block, 'bar');
|
|
|
|
t.equal(b._blocks.foo.inputs.fooInput.shadow, 'y');
|
2016-09-08 09:40:01 -04:00
|
|
|
t.end();
|
|
|
|
});
|
|
|
|
|
2016-06-07 11:40:47 -04:00
|
|
|
test('change', function (t) {
|
|
|
|
var b = new Blocks();
|
|
|
|
b.createBlock({
|
|
|
|
id: 'foo',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {
|
|
|
|
someField: {
|
|
|
|
name: 'someField',
|
|
|
|
value: 'initial-value'
|
|
|
|
}
|
|
|
|
},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: true
|
|
|
|
});
|
|
|
|
|
|
|
|
// Test that the field is updated
|
2016-10-23 12:41:45 -04:00
|
|
|
t.equal(b._blocks.foo.fields.someField.value, 'initial-value');
|
2016-06-07 11:40:47 -04:00
|
|
|
|
|
|
|
b.changeBlock({
|
|
|
|
element: 'field',
|
|
|
|
id: 'foo',
|
|
|
|
name: 'someField',
|
|
|
|
value: 'final-value'
|
|
|
|
});
|
|
|
|
|
2016-10-23 12:41:45 -04:00
|
|
|
t.equal(b._blocks.foo.fields.someField.value, 'final-value');
|
2016-06-07 11:40:47 -04:00
|
|
|
|
|
|
|
// Invalid cases
|
|
|
|
// No `element`
|
|
|
|
b.changeBlock({
|
|
|
|
id: 'foo',
|
|
|
|
name: 'someField',
|
|
|
|
value: 'invalid-value'
|
|
|
|
});
|
2016-10-23 12:41:45 -04:00
|
|
|
t.equal(b._blocks.foo.fields.someField.value, 'final-value');
|
2016-06-07 11:40:47 -04:00
|
|
|
|
|
|
|
// No block ID
|
|
|
|
b.changeBlock({
|
|
|
|
element: 'field',
|
|
|
|
name: 'someField',
|
|
|
|
value: 'invalid-value'
|
|
|
|
});
|
2016-10-23 12:41:45 -04:00
|
|
|
t.equal(b._blocks.foo.fields.someField.value, 'final-value');
|
2016-06-07 11:40:47 -04:00
|
|
|
|
|
|
|
// No such field
|
|
|
|
b.changeBlock({
|
|
|
|
element: 'field',
|
|
|
|
id: 'foo',
|
|
|
|
name: 'someWrongField',
|
|
|
|
value: 'final-value'
|
|
|
|
});
|
2016-10-23 12:41:45 -04:00
|
|
|
t.equal(b._blocks.foo.fields.someField.value, 'final-value');
|
2016-06-07 11:40:47 -04:00
|
|
|
|
|
|
|
t.end();
|
|
|
|
});
|
|
|
|
|
2016-06-06 15:59:21 -04:00
|
|
|
test('delete', function (t) {
|
|
|
|
var b = new Blocks();
|
|
|
|
b.createBlock({
|
|
|
|
id: 'foo',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: true
|
|
|
|
});
|
|
|
|
b.deleteBlock({
|
|
|
|
id: 'foo'
|
|
|
|
});
|
|
|
|
|
2016-10-23 12:41:45 -04:00
|
|
|
t.type(b._blocks.foo, 'undefined');
|
2016-08-11 11:11:27 -04:00
|
|
|
t.equal(b._scripts.indexOf('foo'), -1);
|
2016-06-06 15:59:21 -04:00
|
|
|
t.end();
|
|
|
|
});
|
2016-06-07 11:11:20 -04:00
|
|
|
|
|
|
|
test('delete chain', function (t) {
|
|
|
|
// Create a chain of connected blocks and delete the top one.
|
|
|
|
// All of them should be deleted.
|
|
|
|
var b = new Blocks();
|
|
|
|
b.createBlock({
|
|
|
|
id: 'foo',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: 'foo2',
|
|
|
|
fields: {},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: true
|
|
|
|
});
|
|
|
|
b.createBlock({
|
|
|
|
id: 'foo2',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: 'foo3',
|
|
|
|
fields: {},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: false
|
|
|
|
});
|
|
|
|
b.createBlock({
|
|
|
|
id: 'foo3',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: false
|
|
|
|
});
|
|
|
|
b.deleteBlock({
|
|
|
|
id: 'foo'
|
|
|
|
});
|
2016-10-23 12:41:45 -04:00
|
|
|
t.type(b._blocks.foo, 'undefined');
|
|
|
|
t.type(b._blocks.foo2, 'undefined');
|
|
|
|
t.type(b._blocks.foo3, 'undefined');
|
2016-08-11 11:11:27 -04:00
|
|
|
t.equal(b._scripts.indexOf('foo'), -1);
|
2016-06-07 11:11:20 -04:00
|
|
|
t.equal(Object.keys(b._blocks).length, 0);
|
2016-08-11 11:11:27 -04:00
|
|
|
t.equal(b._scripts.length, 0);
|
2016-06-07 11:11:20 -04:00
|
|
|
t.end();
|
|
|
|
});
|
2016-06-07 11:18:41 -04:00
|
|
|
|
|
|
|
test('delete inputs', function (t) {
|
|
|
|
// Create a block with two inputs, one of which has its own input.
|
|
|
|
// Delete the block - all of them should be deleted.
|
|
|
|
var b = new Blocks();
|
|
|
|
b.createBlock({
|
|
|
|
id: 'foo',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {
|
|
|
|
input1: {
|
|
|
|
name: 'input1',
|
2016-09-06 10:55:52 -04:00
|
|
|
block: 'foo2',
|
|
|
|
shadow: 'foo2'
|
2016-06-07 11:18:41 -04:00
|
|
|
},
|
|
|
|
SUBSTACK: {
|
|
|
|
name: 'SUBSTACK',
|
2016-09-06 10:55:52 -04:00
|
|
|
block: 'foo3',
|
|
|
|
shadow: null
|
2016-06-07 11:18:41 -04:00
|
|
|
}
|
|
|
|
},
|
|
|
|
topLevel: true
|
|
|
|
});
|
|
|
|
b.createBlock({
|
|
|
|
id: 'foo2',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: false
|
|
|
|
});
|
2016-09-06 10:55:52 -04:00
|
|
|
b.createBlock({
|
|
|
|
id: 'foo5',
|
|
|
|
opcode: 'TEST_OBSCURED_SHADOW',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: false
|
|
|
|
});
|
2016-06-07 11:18:41 -04:00
|
|
|
b.createBlock({
|
|
|
|
id: 'foo3',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {
|
|
|
|
subinput: {
|
|
|
|
name: 'subinput',
|
2016-09-06 10:55:52 -04:00
|
|
|
block: 'foo4',
|
|
|
|
shadow: 'foo5'
|
2016-06-07 11:18:41 -04:00
|
|
|
}
|
|
|
|
},
|
|
|
|
topLevel: false
|
|
|
|
});
|
|
|
|
b.createBlock({
|
|
|
|
id: 'foo4',
|
|
|
|
opcode: 'TEST_BLOCK',
|
|
|
|
next: null,
|
|
|
|
fields: {},
|
|
|
|
inputs: {},
|
|
|
|
topLevel: false
|
|
|
|
});
|
|
|
|
b.deleteBlock({
|
|
|
|
id: 'foo'
|
|
|
|
});
|
2016-10-23 12:41:45 -04:00
|
|
|
t.type(b._blocks.foo, 'undefined');
|
|
|
|
t.type(b._blocks.foo2, 'undefined');
|
|
|
|
t.type(b._blocks.foo3, 'undefined');
|
|
|
|
t.type(b._blocks.foo4, 'undefined');
|
|
|
|
t.type(b._blocks.foo5, 'undefined');
|
2016-08-11 11:11:27 -04:00
|
|
|
t.equal(b._scripts.indexOf('foo'), -1);
|
2016-06-07 11:18:41 -04:00
|
|
|
t.equal(Object.keys(b._blocks).length, 0);
|
2016-08-11 11:11:27 -04:00
|
|
|
t.equal(b._scripts.length, 0);
|
2016-06-07 11:18:41 -04:00
|
|
|
t.end();
|
|
|
|
});
|