Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 253 insertions, 0 deletions

diff --git a/testing/xpcshell/node-ws/test/event-target.test.js b/testing/xpcshell/node-ws/test/event-target.test.js
new file mode 100644
index 0000000000..5caaa5c273
--- /dev/null
+++ b/testing/xpcshell/node-ws/test/event-target.test.js
@@ -0,0 +1,253 @@
+'use strict';
+
+const assert = require('assert');
+
+const {
+  CloseEvent,
+  ErrorEvent,
+  Event,
+  MessageEvent
+} = require('../lib/event-target');
+
+describe('Event', () => {
+  describe('#ctor', () => {
+    it('takes a `type` argument', () => {
+      const event = new Event('foo');
+
+      assert.strictEqual(event.type, 'foo');
+    });
+  });
+
+  describe('Properties', () => {
+    describe('`target`', () => {
+      it('is enumerable and configurable', () => {
+        const descriptor = Object.getOwnPropertyDescriptor(
+          Event.prototype,
+          'target'
+        );
+
+        assert.strictEqual(descriptor.configurable, true);
+        assert.strictEqual(descriptor.enumerable, true);
+        assert.ok(descriptor.get !== undefined);
+        assert.ok(descriptor.set === undefined);
+      });
+
+      it('defaults to `null`', () => {
+        const event = new Event('foo');
+
+        assert.strictEqual(event.target, null);
+      });
+    });
+
+    describe('`type`', () => {
+      it('is enumerable and configurable', () => {
+        const descriptor = Object.getOwnPropertyDescriptor(
+          Event.prototype,
+          'type'
+        );
+
+        assert.strictEqual(descriptor.configurable, true);
+        assert.strictEqual(descriptor.enumerable, true);
+        assert.ok(descriptor.get !== undefined);
+        assert.ok(descriptor.set === undefined);
+      });
+    });
+  });
+});
+
+describe('CloseEvent', () => {
+  it('inherits from `Event`', () => {
+    assert.ok(CloseEvent.prototype instanceof Event);
+  });
+
+  describe('#ctor', () => {
+    it('takes a `type` argument', () => {
+      const event = new CloseEvent('foo');
+
+      assert.strictEqual(event.type, 'foo');
+    });
+
+    it('takes an optional `options` argument', () => {
+      const event = new CloseEvent('close', {
+        code: 1000,
+        reason: 'foo',
+        wasClean: true
+      });
+
+      assert.strictEqual(event.type, 'close');
+      assert.strictEqual(event.code, 1000);
+      assert.strictEqual(event.reason, 'foo');
+      assert.strictEqual(event.wasClean, true);
+    });
+  });
+
+  describe('Properties', () => {
+    describe('`code`', () => {
+      it('is enumerable and configurable', () => {
+        const descriptor = Object.getOwnPropertyDescriptor(
+          CloseEvent.prototype,
+          'code'
+        );
+
+        assert.strictEqual(descriptor.configurable, true);
+        assert.strictEqual(descriptor.enumerable, true);
+        assert.ok(descriptor.get !== undefined);
+        assert.ok(descriptor.set === undefined);
+      });
+
+      it('defaults to 0', () => {
+        const event = new CloseEvent('close');
+
+        assert.strictEqual(event.code, 0);
+      });
+    });
+
+    describe('`reason`', () => {
+      it('is enumerable and configurable', () => {
+        const descriptor = Object.getOwnPropertyDescriptor(
+          CloseEvent.prototype,
+          'reason'
+        );
+
+        assert.strictEqual(descriptor.configurable, true);
+        assert.strictEqual(descriptor.enumerable, true);
+        assert.ok(descriptor.get !== undefined);
+        assert.ok(descriptor.set === undefined);
+      });
+
+      it('defaults to an empty string', () => {
+        const event = new CloseEvent('close');
+
+        assert.strictEqual(event.reason, '');
+      });
+    });
+
+    describe('`wasClean`', () => {
+      it('is enumerable and configurable', () => {
+        const descriptor = Object.getOwnPropertyDescriptor(
+          CloseEvent.prototype,
+          'wasClean'
+        );
+
+        assert.strictEqual(descriptor.configurable, true);
+        assert.strictEqual(descriptor.enumerable, true);
+        assert.ok(descriptor.get !== undefined);
+        assert.ok(descriptor.set === undefined);
+      });
+
+      it('defaults to false', () => {
+        const event = new CloseEvent('close');
+
+        assert.strictEqual(event.wasClean, false);
+      });
+    });
+  });
+});
+
+describe('ErrorEvent', () => {
+  it('inherits from `Event`', () => {
+    assert.ok(ErrorEvent.prototype instanceof Event);
+  });
+
+  describe('#ctor', () => {
+    it('takes a `type` argument', () => {
+      const event = new ErrorEvent('foo');
+
+      assert.strictEqual(event.type, 'foo');
+    });
+
+    it('takes an optional `options` argument', () => {
+      const error = new Error('Oops');
+      const event = new ErrorEvent('error', { error, message: error.message });
+
+      assert.strictEqual(event.type, 'error');
+      assert.strictEqual(event.error, error);
+      assert.strictEqual(event.message, error.message);
+    });
+  });
+
+  describe('Properties', () => {
+    describe('`error`', () => {
+      it('is enumerable and configurable', () => {
+        const descriptor = Object.getOwnPropertyDescriptor(
+          ErrorEvent.prototype,
+          'error'
+        );
+
+        assert.strictEqual(descriptor.configurable, true);
+        assert.strictEqual(descriptor.enumerable, true);
+        assert.ok(descriptor.get !== undefined);
+        assert.ok(descriptor.set === undefined);
+      });
+
+      it('defaults to `null`', () => {
+        const event = new ErrorEvent('error');
+
+        assert.strictEqual(event.error, null);
+      });
+    });
+
+    describe('`message`', () => {
+      it('is enumerable and configurable', () => {
+        const descriptor = Object.getOwnPropertyDescriptor(
+          ErrorEvent.prototype,
+          'message'
+        );
+
+        assert.strictEqual(descriptor.configurable, true);
+        assert.strictEqual(descriptor.enumerable, true);
+        assert.ok(descriptor.get !== undefined);
+        assert.ok(descriptor.set === undefined);
+      });
+
+      it('defaults to an empty string', () => {
+        const event = new ErrorEvent('error');
+
+        assert.strictEqual(event.message, '');
+      });
+    });
+  });
+});
+
+describe('MessageEvent', () => {
+  it('inherits from `Event`', () => {
+    assert.ok(MessageEvent.prototype instanceof Event);
+  });
+
+  describe('#ctor', () => {
+    it('takes a `type` argument', () => {
+      const event = new MessageEvent('foo');
+
+      assert.strictEqual(event.type, 'foo');
+    });
+
+    it('takes an optional `options` argument', () => {
+      const event = new MessageEvent('message', { data: 'bar' });
+
+      assert.strictEqual(event.type, 'message');
+      assert.strictEqual(event.data, 'bar');
+    });
+  });
+
+  describe('Properties', () => {
+    describe('`data`', () => {
+      it('is enumerable and configurable', () => {
+        const descriptor = Object.getOwnPropertyDescriptor(
+          MessageEvent.prototype,
+          'data'
+        );
+
+        assert.strictEqual(descriptor.configurable, true);
+        assert.strictEqual(descriptor.enumerable, true);
+        assert.ok(descriptor.get !== undefined);
+        assert.ok(descriptor.set === undefined);
+      });
+
+      it('defaults to `null`', () => {
+        const event = new MessageEvent('message');
+
+        assert.strictEqual(event.data, null);
+      });
+    });
+  });
+});