blockly/tests/mocha/field_angle_test.js

/**
 * @license
 * Copyright 2019 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */

goog.declareModuleId('Blockly.test.fieldAngle');

import * as Blockly from '../../build/src/core/blockly.js';
import {
  assertFieldValue,
  runConstructorSuiteTests,
  runFromJsonSuiteTests,
  runSetValueTests,
} from './test_helpers/fields.js';
import {
  createTestBlock,
  defineRowBlock,
} from './test_helpers/block_definitions.js';
import {
  sharedTestSetup,
  sharedTestTeardown,
  workspaceTeardown,
} from './test_helpers/setup_teardown.js';

suite('Angle Fields', function () {
  setup(function () {
    sharedTestSetup.call(this);
  });
  teardown(function () {
    sharedTestTeardown.call(this);
  });
  /**
   * Configuration for field tests with invalid values.
   * @type {!Array<!FieldCreationTestCase>}
   */
  const invalidValueTestCases = [
    {title: 'Undefined', value: undefined},
    {title: 'Null', value: null},
    {title: 'NaN', value: NaN},
    {title: 'Non-Parsable String', value: 'bad'},
    {title: 'Infinity', value: Infinity, expectedValue: Infinity},
    {title: 'Negative Infinity', value: -Infinity, expectedValue: -Infinity},
    {title: 'Infinity String', value: 'Infinity', expectedValue: Infinity},
    {
      title: 'Negative Infinity String',
      value: '-Infinity',
      expectedValue: -Infinity,
    },
  ];
  /**
   * Configuration for field tests with valid values.
   * @type {!Array<!FieldCreationTestCase>}
   */

  const validValueTestCases = [
    {title: 'Integer', value: 1, expectedValue: 1},
    {title: 'Float', value: 1.5, expectedValue: 1.5},
    {title: 'Integer String', value: '1', expectedValue: 1},
    {title: 'Float String', value: '1.5', expectedValue: 1.5},
    {title: '> 360°', value: 362, expectedValue: 2},
  ];
  const addArgsAndJson = function (testCase) {
    testCase.args = [testCase.value];
    testCase.json = {'angle': testCase.value};
  };
  invalidValueTestCases.forEach(addArgsAndJson);
  validValueTestCases.forEach(addArgsAndJson);

  /**
   * The expected default value for the field being tested.
   * @type {*}
   */
  const defaultFieldValue = 0;
  /**
   * Asserts that the field property values are set to default.
   * @param {FieldTemplate} field The field to check.
   */
  const assertFieldDefault = function (field) {
    assertFieldValue(field, defaultFieldValue);
  };
  /**
   * Asserts that the field properties are correct based on the test case.
   * @param {!Blockly.FieldAngle} field The field to check.
   * @param {!FieldValueTestCase} testCase The test case.
   */
  const validTestCaseAssertField = function (field, testCase) {
    assertFieldValue(field, testCase.expectedValue);
  };

  runConstructorSuiteTests(
    Blockly.FieldAngle,
    validValueTestCases,
    invalidValueTestCases,
    validTestCaseAssertField,
    assertFieldDefault,
  );

  runFromJsonSuiteTests(
    Blockly.FieldAngle,
    validValueTestCases,
    invalidValueTestCases,
    validTestCaseAssertField,
    assertFieldDefault,
  );

  suite('setValue', function () {
    suite('Empty -> New Value', function () {
      setup(function () {
        this.field = new Blockly.FieldAngle();
      });
      runSetValueTests(
        validValueTestCases,
        invalidValueTestCases,
        defaultFieldValue,
      );
      test('With source block', function () {
        this.field.setSourceBlock(createTestBlock());
        this.field.setValue(2.5);
        assertFieldValue(this.field, 2.5);
      });
    });
    suite('Value -> New Value', function () {
      const initialValue = 1;
      setup(function () {
        this.field = new Blockly.FieldAngle(initialValue);
      });
      runSetValueTests(
        validValueTestCases,
        invalidValueTestCases,
        initialValue,
      );
      test('With source block', function () {
        this.field.setSourceBlock(createTestBlock());
        this.field.setValue(2.5);
        assertFieldValue(this.field, 2.5);
      });
    });
  });
  suite('Validators', function () {
    setup(function () {
      this.field = new Blockly.FieldAngle(1);
      this.field.htmlInput_ = document.createElement('input');
      this.field.htmlInput_.setAttribute('data-old-value', '1');
      this.field.htmlInput_.setAttribute('data-untyped-default-value', '1');
      this.stub = sinon.stub(this.field, 'resizeEditor_');
    });
    teardown(function () {
      sinon.restore();
    });
    const testSuites = [
      {
        title: 'Null Validator',
        validator: function () {
          return null;
        },
        value: 2,
        expectedValue: '1',
      },
      {
        title: 'Force Mult of 30 Validator',
        validator: function (newValue) {
          return Math.round(newValue / 30) * 30;
        },
        value: 25,
        expectedValue: 30,
      },
      {
        title: 'Returns Undefined Validator',
        validator: function () {},
        value: 2,
        expectedValue: 2,
      },
    ];
    testSuites.forEach(function (suiteInfo) {
      suite(suiteInfo.title, function () {
        setup(function () {
          this.field.setValidator(suiteInfo.validator);
        });
        test('When Editing', function () {
          this.field.isBeingEdited_ = true;
          this.field.htmlInput_.value = String(suiteInfo.value);
          this.field.onHtmlInputChange_(null);
          assertFieldValue(
            this.field,
            suiteInfo.expectedValue,
            String(suiteInfo.value),
          );
        });
        test('When Not Editing', function () {
          this.field.setValue(suiteInfo.value);
          assertFieldValue(this.field, +suiteInfo.expectedValue);
        });
      });
    });
  });
  suite('Customizations', function () {
    suite('Clockwise', function () {
      test('JS Configuration', function () {
        const field = new Blockly.FieldAngle(0, null, {
          clockwise: true,
        });
        chai.assert.isTrue(field.clockwise);
      });
      test('JSON Definition', function () {
        const field = Blockly.FieldAngle.fromJson({
          value: 0,
          clockwise: true,
        });
        chai.assert.isTrue(field.clockwise);
      });
      test('Constant', function () {
        // Note: Generally constants should be set at compile time, not
        // runtime (since they are constants) but for testing purposes we
        // can do this.
        Blockly.FieldAngle.CLOCKWISE = true;
        const field = new Blockly.FieldAngle();
        chai.assert.isTrue(field.clockwise);
      });
    });
    suite('Offset', function () {
      test('JS Configuration', function () {
        const field = new Blockly.FieldAngle(0, null, {
          offset: 90,
        });
        chai.assert.equal(field.offset, 90);
      });
      test('JSON Definition', function () {
        const field = Blockly.FieldAngle.fromJson({
          value: 0,
          offset: 90,
        });
        chai.assert.equal(field.offset, 90);
      });
      test('Constant', function () {
        // Note: Generally constants should be set at compile time, not
        // runtime (since they are constants) but for testing purposes we
        // can do this.
        Blockly.FieldAngle.OFFSET = 90;
        const field = new Blockly.FieldAngle();
        chai.assert.equal(field.offset, 90);
      });
      test('Null', function () {
        // Note: Generally constants should be set at compile time, not
        // runtime (since they are constants) but for testing purposes we
        // can do this.
        Blockly.FieldAngle.OFFSET = 90;
        const field = Blockly.FieldAngle.fromJson({
          value: 0,
          offset: null,
        });
        chai.assert.equal(field.offset, 90);
      });
    });
    suite('Wrap', function () {
      test('JS Configuration', function () {
        const field = new Blockly.FieldAngle(0, null, {
          wrap: 180,
        });
        chai.assert.equal(field.wrap, 180);
      });
      test('JSON Definition', function () {
        const field = Blockly.FieldAngle.fromJson({
          value: 0,
          wrap: 180,
        });
        chai.assert.equal(field.wrap, 180);
      });
      test('Constant', function () {
        // Note: Generally constants should be set at compile time, not
        // runtime (since they are constants) but for testing purposes we
        // can do this.
        Blockly.FieldAngle.WRAP = 180;
        const field = new Blockly.FieldAngle();
        chai.assert.equal(field.wrap, 180);
      });
      test('Null', function () {
        // Note: Generally constants should be set at compile time, not
        // runtime (since they are constants) but for testing purposes we
        // can do this.
        Blockly.FieldAngle.WRAP = 180;
        const field = Blockly.FieldAngle.fromJson({
          value: 0,
          wrap: null,
        });
        chai.assert.equal(field.wrap, 180);
      });
    });
    suite('Round', function () {
      test('JS Configuration', function () {
        const field = new Blockly.FieldAngle(0, null, {
          round: 30,
        });
        chai.assert.equal(field.round, 30);
      });
      test('JSON Definition', function () {
        const field = Blockly.FieldAngle.fromJson({
          value: 0,
          round: 30,
        });
        chai.assert.equal(field.round, 30);
      });
      test('Constant', function () {
        // Note: Generally constants should be set at compile time, not
        // runtime (since they are constants) but for testing purposes we
        // can do this.
        Blockly.FieldAngle.ROUND = 30;
        const field = new Blockly.FieldAngle();
        chai.assert.equal(field.round, 30);
      });
      test('Null', function () {
        // Note: Generally constants should be set at compile time, not
        // runtime (since they are constants) but for testing purposes we
        // can do this.
        Blockly.FieldAngle.ROUND = 30;
        const field = Blockly.FieldAngle.fromJson({
          value: 0,
          round: null,
        });
        chai.assert.equal(field.round, 30);
      });
    });
    suite('Mode', function () {
      suite('Compass', function () {
        test('JS Configuration', function () {
          const field = new Blockly.FieldAngle(0, null, {
            mode: 'compass',
          });
          chai.assert.equal(field.offset, 90);
          chai.assert.isTrue(field.clockwise);
        });
        test('JS Configuration', function () {
          const field = Blockly.FieldAngle.fromJson({
            value: 0,
            mode: 'compass',
          });
          chai.assert.equal(field.offset, 90);
          chai.assert.isTrue(field.clockwise);
        });
      });
      suite('Protractor', function () {
        test('JS Configuration', function () {
          const field = new Blockly.FieldAngle(0, null, {
            mode: 'protractor',
          });
          chai.assert.equal(field.offset, 0);
          chai.assert.isFalse(field.clockwise);
        });
        test('JS Configuration', function () {
          const field = Blockly.FieldAngle.fromJson({
            value: 0,
            mode: 'protractor',
          });
          chai.assert.equal(field.offset, 0);
          chai.assert.isFalse(field.clockwise);
        });
      });
    });
  });

  suite('Serialization', function () {
    setup(function () {
      this.workspace = new Blockly.Workspace();
      defineRowBlock();

      this.assertValue = (value) => {
        const block = this.workspace.newBlock('row_block');
        const field = new Blockly.FieldAngle(value);
        block.getInput('INPUT').appendField(field, 'ANGLE');
        const jso = Blockly.serialization.blocks.save(block);
        chai.assert.deepEqual(jso['fields'], {'ANGLE': value});
      };
    });

    teardown(function () {
      workspaceTeardown.call(this, this.workspace);
    });

    test('Simple', function () {
      this.assertValue(90);
    });

    test('Max precision', function () {
      this.assertValue(1.000000000000001);
    });

    test('Smallest number', function () {
      this.assertValue(5e-324);
    });
  });
});