vsn 0.1.26 → 0.1.29

package/test/MessageList.spec.ts

@@ -0,0 +1,101 @@
+import MessageList from "../src/MessageList";
+
+describe('MessageList', () => {
+    it("should reset properly", () => {
+        const list = new MessageList();
+        list.merge({
+            'foo': ['bar', 'baz']
+        });
+        console.info(list.keys);
+        expect(list.length).toBe(1);
+        expect(list['foo']).toEqual(['bar', 'baz']);
+
+        list.reset();
+
+        expect(list.length).toBe(0);
+        expect(list['foo']).toEqual(undefined);
+    });
+
+    it("should add messages", () => {
+        const list = new MessageList({
+            'foo': ['bar', 'baz']
+        });
+
+        // Add list
+        list.add('foo', ['biz', 'blarg']);
+        expect(list['foo']).toEqual(['bar', 'baz', 'biz', 'blarg']);
+
+        // Add single error and replace
+        list.add('foo', 'replaced', true);
+        expect(list['foo']).toEqual(['replaced']);
+    });
+
+    it("should merge messages", () => {
+        const list = new MessageList();
+        list.merge({
+            'foo': ['bar', 'baz'],
+            'test': ['test 1', 'test 2']
+        });
+
+        list.merge({
+            'foo': ['merged 1', 'merged 2'],
+            'test': ['test 3', 'test 4'],
+            'new': ['new 1', 'new 2']
+        });
+
+        expect(list['foo']).toEqual(['bar', 'baz', 'merged 1', 'merged 2']);
+        expect(list['test']).toEqual(['test 1', 'test 2', 'test 3', 'test 4']);
+        expect(list['new']).toEqual(['new 1', 'new 2']);
+    });
+
+    it("should replace messages", () => {
+        const list = new MessageList();
+        list.merge({
+            'foo': ['bar', 'baz'],
+            'test': ['test 1', 'test 2']
+        });
+
+        list.merge({
+            'foo': ['merged 1', 'merged 2'],
+            'test': ['test 3', 'test 4'],
+            'new': ['new 1', 'new 2']
+        }, true);
+
+        expect(list['foo']).toEqual(['merged 1', 'merged 2']);
+        expect(list['test']).toEqual(['test 3', 'test 4']);
+        expect(list['new']).toEqual(['new 1', 'new 2']);
+    });
+
+    it("should return a list", () => {
+        const list = new MessageList(),
+            items = {
+                'foo': ['bar', 'baz'],
+                'test': ['test 1', 'test 2']
+            };
+        list.merge(items);
+        expect(list.list).toEqual(items);
+    });
+
+    it("should ignore empty additions", () => {
+        const list = new MessageList();
+        list.merge({});
+        list.merge(null);
+        expect(list.length).toEqual(0);
+
+        list.merge({
+            'empty': [],
+            'null': null
+        });
+        expect(list.length).toEqual(0);
+    });
+
+    it("should cache list getter result", () => {
+        const messageList = new MessageList({
+            'foo': ['bar', 'baz']
+        }),
+            list = messageList.list;
+        expect(list).toBe(messageList.list);
+        messageList.add('bar', 'baz');
+        expect(list).not.toBe(messageList.list);
+    });
+});

package/test/Scope/DynamicScopeData.spec.ts

@@ -0,0 +1,141 @@
+import {DynamicScopeData} from "../../src/Scope/DynamicScopeData";
+
+
+describe('DynamicScopeData', () => {
+    it("Should trigger a change event when any field is changed", () => {
+        const m = new DynamicScopeData(['foo']);
+        let value = null,
+            field = null;
+
+        m.on('change', (_field, values) => {
+            field = _field;
+            value = values.value;
+        });
+
+        m.foo = 'testing';
+
+        expect<string | null>(field).toBe('foo');
+        expect(value).toBe(m.foo);
+    });
+
+    it("Should create the given fields from an object", () => {
+        const m = new DynamicScopeData({
+            field_1: 1,
+            field_2: 'yes',
+            field_3: true
+        });
+        expect(m.getProperties().length).toBe(3);
+
+        m.setData({field_4: 4, field_5: 5});
+        expect(m.getProperties().length).toBe(5);
+        const data = m.getData();
+        expect(data['field_1']).toBe(1);
+        expect(data['field_2']).toBe('yes');
+        expect(data['field_3']).toBe(true);
+        expect(data['field_4']).toBe(4);
+        expect(data['field_5']).toBe(5);
+    });
+
+    it("Should create the given fields from an array", () => {
+        const m = new DynamicScopeData([
+            'field_1',
+            'field_2',
+            'field_3'
+        ]);
+        expect(m.getProperties().length).toBe(3);
+    });
+
+    it("Should trigger a change event when a field is changed", () => {
+        const m = new DynamicScopeData({
+                field_1: 1,
+                field_2: 'yes',
+                field_3: true
+            });
+
+        let oldValue = null,
+            oldValueCheck = null,
+            value = null;
+
+        m.bindToProperties('change', [
+            'field_2',
+            'field_1'
+        ], (values) => {
+            oldValue = values.oldValue;
+            value = values.value;
+        });
+
+        // Test to make sure field_1 change event is being called
+        oldValueCheck = m.field_1;
+        m.field_1 = 2;
+        expect(value).toBe(m.field_1);
+        expect(oldValue).toBe(oldValueCheck);
+
+        // Test to make sure field_2 change event is being called
+        oldValueCheck = m.field_2;
+        m.field_2 = 'no';
+        expect(value).toBe(m.field_2);
+        expect(oldValue).toBe(oldValueCheck);
+
+        // Test to make sure fields that aren't being listened to aren't
+        // triggering the event
+        oldValueCheck = m.foo;
+        m.foo = false;
+        expect(value).not.toBe(m.foo);
+        expect(oldValue).not.toBe(oldValueCheck);
+    });
+
+    it("Should trigger a change:field event when any field is changed", () => {
+        const m = new DynamicScopeData(['field_1']);
+        let value = null;
+
+        m.on('change:field_1', (values) => {
+            value = values.value;
+        });
+
+        m.field_1 = 'testing';
+
+        expect(value).toBe(m.field_1);
+    });
+
+    it("should save last data and return true with is modfied if something is modified", () => {
+        const m = new DynamicScopeData({
+            field_1: 1,
+            field_2: 'foo'
+        });
+        m.setLastData();
+        expect(m.isModified()).toBe(false);
+        m.field_1 = 2;
+        m.field_2 = null;
+        expect(m.isModified()).toBe(true);
+        m.setLastData();
+        expect(m.isModified()).toBe(false);
+        m.field_2 = 'bar';
+        expect(m.isModified()).toBe(true);
+    });
+
+    it("should revert to last data correctly", () => {
+        const m = new DynamicScopeData({
+            field_1: 1,
+            field_2: 'bar'
+        });
+        m.setLastData();
+        expect(m.isModified()).toBe(false);
+        m.field_1 = 2;
+        m.field_2 = null;
+        expect(m.isModified()).toBe(true);
+        m.revert();
+        expect(m.isModified()).toBe(false);
+        expect(m.field_1).toBe(1);
+        expect(m.field_2).toBe('bar');
+    });
+
+    it("should return the field object", () => {
+        const m = new DynamicScopeData({
+            field_1: 1,
+            field_2: 'string field!'
+        }),
+            field = m.getProperty('field_2');
+        expect(field.value).toBe('string field!');
+
+    });
+});

package/test/Scope.spec.ts

@@ -1,4 +1,5 @@
-import {Scope, WrappedArray} from "../src/Scope";
+import {Scope} from "../src/Scope";
+import {WrappedArray} from "../src/Scope/WrappedArray";
 
 class Test {
     public testing: string = 'test';
@@ -30,7 +31,7 @@ describe('WrappedArray', () => {
     it("should behave like an array", async () => {
         const a = new WrappedArray();
         let removes: number = 0;
-        a.bind('remove', (e) => {
+        a.on('remove', (e) => {
              removes += 1;
         });
         a.push(1);
@@ -44,7 +45,7 @@ describe('WrappedArray', () => {
     it("should trigger change events", async () => {
         const a = new WrappedArray();
         let changes: number = 0;
-        a.bind('change', (e) => {
+        a.on('change', (e) => {
              changes += 1;
         });
         a.push(1);
@@ -54,4 +55,15 @@ describe('WrappedArray', () => {
         expect(changes).toBe(6);
         expect(a.length).toBe(0);
     });
+
+    it("should set types correctly", async () => {
+        const scope = new Scope();
+        scope.setType('test', 'integer');
+        scope.set('test', '1');
+        expect(scope.get('test')).toBe(1);
+
+        scope.setType('testing', 'string');
+        scope.set('testing', 2);
+        expect(scope.get('testing')).toBe('2');
+    });
 });

package/test/SimplePromise.spec.ts

@@ -0,0 +1,271 @@
+import {IDeferred, SimplePromise} from "../src/SimplePromise";
+
+
+class Test {
+    constructor(
+        public value: string = 'test'
+    ) {}
+}
+class Testing {
+    constructor(
+        public test: Test
+    ) {}
+}
+
+
+describe('Promise', () => {
+    let dummy: any = null,
+        dummy2: any = null;
+
+    beforeEach(() => {
+        dummy = jasmine.createSpyObj('dummy', ['callback']);
+        dummy2 = jasmine.createSpyObj('dummy2', ['callback']);
+    });
+
+    it("defer should work properly with resolve", () => {
+        const d: IDeferred<Test> = SimplePromise.defer<Test>();
+        const t: Test = new Test();
+        expect(dummy.callback).not.toHaveBeenCalled();
+        d.promise.then(dummy.callback.bind(dummy));
+        d.resolve(t);
+        expect(dummy.callback).toHaveBeenCalled();
+        expect(d.promise['result']).toBe(t);
+    });
+
+    it("defer should work properly with reject", () => {
+        const d: IDeferred<Test> = SimplePromise.defer<Test>();
+        const t: Test = new Test();
+        expect(dummy.callback).not.toHaveBeenCalled();
+        expect(dummy2.callback).not.toHaveBeenCalled();
+        d.promise.then(dummy.callback.bind(dummy), dummy2.callback.bind(dummy2));
+        d.reject("failed");
+        expect(dummy.callback).not.toHaveBeenCalled();
+        expect(dummy2.callback).toHaveBeenCalled();
+        expect(d.promise['result']).toBe("failed");
+    });
+
+    it("defer should work properly with finally", () => {
+        const d: IDeferred<Test> = SimplePromise.defer<Test>();
+        expect(dummy.callback).not.toHaveBeenCalled();
+        expect(dummy2.callback).not.toHaveBeenCalled();
+        d.promise.then((result: Test) => {
+            expect(false).toBe(true); // should never be called
+            return result;
+        }, (reason: string) => {
+            expect(dummy2.callback).not.toHaveBeenCalled();
+            return reason;
+        }).finally(dummy2.callback.bind(dummy2));
+
+        d.reject("failed");
+        expect(dummy2.callback).toHaveBeenCalled();
+        expect(d.promise['result']).toBe("failed");
+    });
+
+    it("test race with reject", () => {
+        const d: IDeferred<Test> = SimplePromise.defer<Test>();
+        const d2: IDeferred<Test> = SimplePromise.defer<Test>();
+        const t: Test = new Test();
+        expect(dummy.callback).not.toHaveBeenCalled();
+        expect(dummy2.callback).not.toHaveBeenCalled();
+        SimplePromise.race([
+            d.promise,
+            d2.promise
+        ]).then(dummy.callback.bind(dummy), dummy2.callback.bind(dummy2));
+
+        d.reject("failed");
+        d2.resolve(t);
+        expect(dummy.callback).not.toHaveBeenCalled();
+        expect(dummy2.callback).toHaveBeenCalled();
+        expect(d.promise['result']).toBe("failed");
+    });
+
+    it("test race with resolve", () => {
+        const d: IDeferred<Test> = SimplePromise.defer<Test>();
+        const d2: IDeferred<Test> = SimplePromise.defer<Test>();
+        const t: Test = new Test();
+        expect(dummy.callback).not.toHaveBeenCalled();
+        expect(dummy2.callback).not.toHaveBeenCalled();
+        SimplePromise.race([
+            d.promise,
+            d2.promise
+        ]).then(dummy.callback.bind(dummy), dummy2.callback.bind(dummy2));
+
+        d.resolve(t);
+        d.reject("failed");
+        expect(dummy.callback).toHaveBeenCalled();
+        expect(dummy2.callback).not.toHaveBeenCalled();
+        expect(d.promise['result']).toBe(t);
+    });
+
+    it("test all with resolve", () => {
+        const d: IDeferred<Test> = SimplePromise.defer<Test>();
+        const d2: IDeferred<Test> = SimplePromise.defer<Test>();
+        const t: Test = new Test();
+        expect(dummy.callback).not.toHaveBeenCalled();
+        expect(dummy2.callback).not.toHaveBeenCalled();
+        SimplePromise.all([
+            d.promise,
+            d2.promise
+        ]).then(dummy.callback.bind(dummy), dummy2.callback.bind(dummy2));
+
+        d.resolve(t);
+        expect(dummy.callback).not.toHaveBeenCalled();
+        expect(dummy2.callback).not.toHaveBeenCalled();
+        d2.resolve(t);
+        expect(dummy.callback).toHaveBeenCalled();
+        expect(dummy2.callback).not.toHaveBeenCalled();
+        expect(d.promise['result']).toBe(t);
+    });
+
+    it("test all with reject", () => {
+        const d: IDeferred<Test> = SimplePromise.defer<Test>();
+        const d2: IDeferred<Test> = SimplePromise.defer<Test>();
+        const t: Test = new Test();
+        expect(dummy.callback).not.toHaveBeenCalled();
+        expect(dummy2.callback).not.toHaveBeenCalled();
+        SimplePromise.all([
+            d.promise,
+            d2.promise
+        ]).then(dummy.callback.bind(dummy), dummy2.callback.bind(dummy2));
+
+        d.resolve(t);
+        expect(dummy.callback).not.toHaveBeenCalled();
+        expect(dummy2.callback).not.toHaveBeenCalled();
+        d2.reject("failed");
+        expect(dummy.callback).not.toHaveBeenCalled();
+        expect(dummy2.callback).toHaveBeenCalled();
+        expect(d2.promise['result']).toBe("failed");
+    });
+
+    it("resolve static function should work properly", () => {
+        const t: Test = new Test();
+        expect(dummy.callback).not.toHaveBeenCalled();
+        expect(dummy2.callback).not.toHaveBeenCalled();
+        SimplePromise.resolve(t).then(dummy.callback.bind(dummy), dummy2.callback.bind(dummy2));
+        expect(dummy.callback).toHaveBeenCalled();
+        expect(dummy2.callback).not.toHaveBeenCalled();
+    });
+
+    it("reject static function should work properly", () => {
+        const t: Test = new Test();
+        expect(dummy.callback).not.toHaveBeenCalled();
+        expect(dummy2.callback).not.toHaveBeenCalled();
+        SimplePromise.reject("failed").then(dummy.callback.bind(dummy), dummy2.callback.bind(dummy2));
+        expect(dummy.callback).not.toHaveBeenCalled();
+        expect(dummy2.callback).toHaveBeenCalled();
+    });
+
+    it("should be rejected if error is thrown", () => {
+        const t: Test = new Test();
+        expect(dummy.callback).not.toHaveBeenCalled();
+        expect(dummy2.callback).not.toHaveBeenCalled();
+        new SimplePromise<Test>((resolve, reject) => {
+            throw Error('failed');
+        }).then(dummy.callback.bind(dummy), dummy2.callback.bind(dummy2));
+        expect(dummy.callback).not.toHaveBeenCalled();
+        expect(dummy2.callback).toHaveBeenCalled();
+    });
+
+    it("should process multiple then statements in the correct order", () => {
+        const d: IDeferred<Test> = SimplePromise.defer<Test>();
+        const t: Test = new Test();
+        d.promise.then<Test>((result: Test): Test => {
+            expect(result.value).toBe('test');
+            result.value = 'then 1';
+            return result;
+        });
+        d.promise.then<Test>((result: Test): Test => {
+            expect(result.value).toBe('then 1');
+            result.value = 'then 2';
+            return result;
+        });
+        d.promise.then<Test>((result: Test): Test => {
+            expect(result.value).toBe('then 2');
+            result.value = 'then 3';
+            return result;
+        });
+        d.promise.then<Test>((result: Test): Test => {
+            expect(result.value).toBe('then 3');
+            result.value = 'then 4';
+            return result;
+        });
+
+        d.resolve(t);
+    });
+
+    it("should process chained then statements in the correct order", () => {
+        const d: IDeferred<Test> = SimplePromise.defer<Test>();
+        const t: Test = new Test();
+        d.promise.then<Testing>((result: Test) => {
+            expect(d.promise['result']).toBe(result);
+            return new Testing(result);
+        }).then((result: Testing | undefined): Testing => {
+            expect((result as any as Testing).test).toBe(t);
+            return result as any as Testing;
+        });
+        d.resolve(t);
+    });
+
+    it("should process callback on previously resolved promise", (done) => {
+        const d: IDeferred<Test> = SimplePromise.defer<Test>();
+        const t: Test = new Test();
+        d.resolve(t);
+
+        d.promise.then<Testing>((result: Test) => {
+            expect(d.promise['result']).toBe(result);
+            done();
+            return new Testing(result);
+        });
+    });
+
+    it("should process callback on previously rejected promise", (done) => {
+        const d: IDeferred<Test> = SimplePromise.defer<Test>();
+        d.reject('Failure.');
+
+        d.promise.then<Testing>((result: Test) => {
+            expect(false).toBe(true);
+            return new Testing(result);
+        }, (reason?: string): string => {
+            expect(reason).toBe('Failure.');
+            done();
+
+            return reason as string;
+        });
+    });
+
+    it("should process Promise.all callbacks with previously resolved promises", (done) => {
+        const d: IDeferred<Test> = SimplePromise.defer<Test>();
+        const d2: IDeferred<Test> = SimplePromise.defer<Test>();
+        const t: Test = new Test();
+        const t2: Test = new Test();
+        d2.resolve(t2);
+
+        SimplePromise.all<Test>([d.promise, d2.promise]).then((results?: Test[]) => {
+            if (results === undefined) return;
+            expect(d.promise['result']).toBe(results[0]);
+            expect(d2.promise['result']).toBe(results[1]);
+            done();
+        });
+
+        d.resolve(t);
+    });
+
+    it("should process Promise.all callbacks with previously rejected promises", (done) => {
+        const d: IDeferred<Test> = SimplePromise.defer<Test>();
+        const d2: IDeferred<Test> = SimplePromise.defer<Test>();
+        const t: Test = new Test();
+        const t2: Test = new Test();
+        d.reject('Failure.');
+
+        SimplePromise.all<Test>([d.promise, d2.promise]).then((results?: Test[]) => {
+            expect(false).toBe(true);
+        }, (reason?: string): string => {
+            expect(reason).toBe('Failure.');
+            done();
+
+            return reason as string;
+        });
+
+        d2.resolve(t2);
+    });
+});

package/test/Tag/TagList.spec.ts

@@ -1,7 +1,7 @@
 import {DOM} from "../../src/DOM";
 import {Query} from "../../src/Query";
 import {TagList} from "../../src/Tag/List";
-import {DOMObject} from "../../dist/DOM/DOMObject";
+import {DOMObject} from "../../src/DOM/DOMObject";
 
 describe('TagList', () => {
     it("should be able to fail properly", (done) => {

package/test/attributes/Bind.spec.ts

@@ -60,7 +60,7 @@ describe('Bind', () => {
             const test = document.getElementById('test');
             const tag = await dom.getTagForElement(test);
 
-            tag.scope.bind('change:id', () => {
+            tag.scope.on('change:id', () => {
                 expect(test.getAttribute('id')).toBe('new-id');
                 expect(tag.scope.get('id')).toBe('new-id');
                 done();
@@ -81,7 +81,7 @@ describe('Bind', () => {
             const tag = await dom.getTagForElement(test);
             expect(tag.scope.get('val')).toBe('testing');
 
-            tag.scope.get('test').bind('change:val', () => {
+            tag.scope.get('test').on('change:val', () => {
                 expect(tag.scope.get('val')).toBe('new-val');
                 done();
             });
@@ -102,7 +102,7 @@ describe('Bind', () => {
             const tag = await dom.getTagForElement(test);
             expect(tag.scope.get('val')).toBe('testing');
 
-            tag.scope.get('test').bind('change:val', () => {
+            tag.scope.get('test').on('change:val', () => {
                 expect(tag.scope.get('val')).toBe('new-val');
                 done();
             });
@@ -127,7 +127,7 @@ describe('Bind', () => {
             const tag = await dom.getTagForElement(test);
             expect(tag.scope.get('val')).toBe('testing');
 
-             tag.scope.get('test').bind('change:val', () => {
+             tag.scope.get('test').on('change:val', () => {
                 expect(test.innerHTML).toBe('new-val');
                 done();
             });
@@ -148,7 +148,7 @@ describe('Bind', () => {
             const tag = await dom.getTagForElement(test);
             expect(tag.scope.get('val')).toBe('testing');
 
-            tag.bind('mutate', () => {
+            tag.on('mutate', () => {
                 expect(test.getAttribute('value')).toBe('new-val');
                 done();
             });

package/test/attributes/ListItem.spec.ts

@@ -74,7 +74,7 @@ describe('ListItem', () => {
             const controller: ListItemController = list.scope.get('controller').wrapped;
             const listAttr: List = await list.getAttribute('vsn-list') as List;
 
-            list.bind('add', () => {
+            list.on('add', () => {
                 const listItem = listAttr.tags[0];
 
                 expect(listItem.scope.wrapped instanceof ListItemSpecTestItem).toBeTrue();