vsn 0.1.26 → 0.1.27

package/test/Model/DataModel.spec.ts

@@ -0,0 +1,141 @@
+import {DataModel} from "../../src/Model/DataModel";
+
+
+describe('Model', () => {
+    it("Should trigger a change event when any field is changed", () => {
+        const m = new DataModel(['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 DataModel({
+            field_1: 1,
+            field_2: 'yes',
+            field_3: true
+        });
+        expect(m.getFields().length).toBe(3);
+
+        m.setData({field_4: 4, field_5: 5});
+        expect(m.getFields().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 DataModel([
+            'field_1',
+            'field_2',
+            'field_3'
+        ]);
+        expect(m.getFields().length).toBe(3);
+    });
+
+    it("Should trigger a change event when a field is changed", () => {
+        const m = new DataModel({
+                field_1: 1,
+                field_2: 'yes',
+                field_3: true
+            });
+
+        let oldValue = null,
+            oldValueCheck = null,
+            value = null;
+
+        m.bindToFields('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 DataModel(['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 DataModel({
+            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 DataModel({
+            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 DataModel({
+            field_1: 1,
+            field_2: 'string field!'
+        }),
+            field = m.getField('field_2');
+        expect(field.value).toBe('string field!');
+
+    });
+});

package/test/Model.spec.ts

@@ -0,0 +1,306 @@
+import {field, Field} from "../src/Model/fields/Field";
+import {Model} from "../src/Model";
+import {Collection} from "../src/Model/Collection";
+import {EmailField} from "../src/Model/fields/EmailField";
+import {FloatField} from "../src/Model/fields/FloatField";
+import {PositiveIntegerField} from "../src/Model/fields/PositiveNumberField";
+import {StringField} from "../src/Model/fields/StringField";
+import {BooleanField} from "../src/Model/fields/BooleanField";
+
+class TestCollection extends Collection<TestModel> {
+    getDefault: () => any = (): any => {
+        for(const i of this) {
+            if(i.is_default)
+                return i;
+        }
+    };
+}
+
+class AbstractTestModel extends Model {
+    @field()
+    id!: number;
+
+    @field(Field, {
+        required:true
+    })
+    required_field!: string | null;
+}
+
+class TestModel extends AbstractTestModel {
+    static collectionClass = TestCollection;
+
+    @field()
+    foo!: boolean;
+
+    @field()
+    name!: string;
+
+    @field()
+    is_default!: boolean;
+
+    @field(Field, null)
+    invalid_field!: string;
+
+    @field(EmailField)
+    email!: string;
+
+    @field(FloatField, {
+        toFixed: 3
+    })
+    float_field!: number;
+
+    @field(PositiveIntegerField)
+    positive_integer_field!: number;
+
+    @field(StringField)
+    string_field!: string;
+
+    @field(BooleanField)
+    boolean_field!: boolean;
+}
+
+class TestModel2 extends AbstractTestModel {
+    @field()
+    shouldnt_exist!: boolean;
+}
+
+
+describe('Model', () => {
+    it("should throw an error when a field is required and the value is null", function() {
+        const m = new TestModel();
+        expect(m.validate()['required_field'].length).toBe(1);
+    });
+
+    it("should be invalid when a field validation fails", function() {
+        const m = new TestModel({
+            required_field: true,
+            email: 'testing'
+        });
+        expect(m.validate()['email'].length).toBe(1);
+    });
+
+    it("should not throw an error when a field that is required value is not null", function() {
+        const m = new TestModel();
+        m.required_field = 'yes';
+        expect(m.validate()['required_field']).toBe(undefined);
+        expect(m.hasErrors()).toBe(false);
+        expect(m.errors.length).toBe(0);
+        m.required_field = null;
+        m.validate();
+        expect(m.hasErrors()).toBe(true);
+        expect(m.errors.length).toBe(1);
+    });
+
+    it("Should trigger a change event when any field is changed", () => {
+        const m = new TestModel();
+        let value: string | null = null,
+            field: string | null = null;
+
+        m.on('change', (_field, values) => {
+            field = _field;
+            value = values.value;
+        });
+
+        m.required_field = 'testing';
+
+        expect<string | null>(field).toBe('required_field');
+        expect<string | null>(value).toBe(m.required_field);
+    });
+
+    it("Should trigger a change event when a field is changed", () => {
+        const m = new TestModel({
+                id: 1,
+                required_field: 'yes',
+                foo: true,
+                positive_integer_field: 1
+            });
+
+        let oldValue = null,
+            oldValueCheck: number | null = null,
+            value: number | null  = null;
+
+        m.bindToFields('change', [
+            'required_field',
+            'id',
+            'shouldnt_exist',
+            'positive_integer_field'
+        ], (values) => {
+            oldValue = values.oldValue;
+            value = values.value;
+        });
+
+        // Test to make sure id change event is being called
+        oldValueCheck = m.id;
+        m.id = 2;
+        expect(value).toBe(m.id);
+        expect(oldValue).toBe(oldValueCheck);
+
+        // Test to make sure required_field change event is being called
+        const stringValueCheck: string | null = m.required_field;
+        m.required_field = 'no';
+        expect(value).toBe(m.required_field as any);
+        expect(oldValue).toBe(stringValueCheck);
+
+        // Test to make sure positive_integer_field change event is being called
+        oldValueCheck = m.positive_integer_field;
+        m.positive_integer_field = 15;
+        expect(value).toBe(m.positive_integer_field);
+        expect(oldValue).toBe(oldValueCheck);
+
+        // Test to make sure fields that aren't being listened to aren't
+        // triggering the event
+        const boolValueCheck: boolean = m.foo;
+        m.foo = false;
+        expect(value).not.toBe(m.foo as any);
+        expect(oldValue).not.toBe(boolValueCheck);
+
+        // Test to make sure fields that aren't being listened to aren't
+        // triggering the event
+        oldValueCheck = m.shouldnt_exist;
+        m.foo = true;
+        expect(value).not.toBe(m.foo as any);
+        expect(oldValue).not.toBe(oldValueCheck);
+    });
+
+    it("Should trigger a change:field event when any field is changed", () => {
+        const m = new TestModel();
+        let value: string | null = null;
+
+        m.on('change:required_field', (values) => {
+            value = values.value;
+        });
+
+        m.required_field = 'testing';
+
+        expect<string | null>(value).toBe(m.required_field);
+    });
+
+    it("should save last data and return true with is modfied if something is modified", () => {
+        const m = new TestModel({
+            id: 1,
+            required_field: 'required!'
+        });
+        m.setLastData();
+        expect(m.isModified()).toBe(false);
+        m.id = 2;
+        expect(m.isModified()).toBe(true);
+        m.setLastData();
+        expect(m.isModified()).toBe(false);
+        m.required_field = 'still required';
+        expect(m.isModified()).toBe(true);
+    });
+
+    it("should revert to last data correctly", () => {
+        const m = new TestModel({
+            id: 1,
+            required_field: 'required!'
+        });
+        m.setLastData();
+        expect(m.isModified()).toBe(false);
+        m.id = 2;
+        m.required_field = null;
+        expect(m.isModified()).toBe(true);
+        m.revert();
+        expect(m.isModified()).toBe(false);
+        expect(m.id).toBe(1);
+        expect<string | null>(m.required_field).toBe('required!');
+    });
+
+    it("should return the field object", () => {
+        const m = new TestModel({
+            id: 1,
+            required_field: 'required!'
+        }),
+            field = m.getField('required_field');
+        expect(field.value).toBe('required!');
+
+    });
+
+    it("should ignore data that does not match a field", () => {
+        const m = new TestModel({
+            id: 1,
+            required_field: 'required!'
+        });
+        m.setLastData();
+        m.setData({
+            spam: 1,
+            bar: 'Baz!'
+        });
+        expect(m.isModified()).toBe(false);
+    });
+
+    it("should cast values to field types", () => {
+        const m = new TestModel({
+            float_field: '1.5111',
+            positive_integer_field: '-1',
+            string_field: 1,
+            boolean_field: 'true'
+        });
+        expect(m.float_field).toBe(1.511);
+        expect(m.positive_integer_field).toBe(0);
+        expect(m.string_field).toBe('1');
+        expect(m.boolean_field).toBe(true);
+    });
+});
+
+describe('Collection', () => {
+    it("should be able to use methods defined in TestCollection", function() {
+        const collection = new TestCollection();
+
+        collection.push(new TestModel({
+            name: 'Model 1',
+            is_default: false
+        }));
+
+        collection.push(new TestModel({
+            name: 'Model 2',
+            is_default: true
+        }));
+
+        collection.push(new TestModel({
+            name: 'Model 3',
+            is_default: false
+        }));
+
+        collection.push(new TestModel({
+            name: 'Model 4',
+            is_default: false
+        }));
+
+        expect(collection.getDefault().name).toBe('Model 2');
+    });
+
+    it("should return data from all models in the collection", function() {
+        const collection = new TestCollection();
+
+        collection.push(new TestModel({
+            name: 'Model 1',
+            is_default: false
+        }));
+
+        collection.push(new TestModel({
+            name: 'Model 2',
+            is_default: true
+        }));
+
+        collection.push(new TestModel({
+            name: 'Model 3',
+            is_default: false
+        }));
+
+        collection.push(new TestModel({
+            name: 'Model 4',
+            is_default: false
+        }));
+        const collectionData = collection.getData();
+
+        expect(collectionData[0].name).toBe('Model 1');
+        expect(collectionData[0].is_default).toBe(false);
+        expect(collectionData[1].name).toBe('Model 2');
+        expect(collectionData[1].is_default).toBe(true);
+        expect(collectionData[2].name).toBe('Model 3');
+        expect(collectionData[2].is_default).toBe(false);
+        expect(collectionData[3].name).toBe('Model 4');
+        expect(collectionData[3].is_default).toBe(false);
+    });
+});

package/test/Scope.spec.ts

@@ -30,7 +30,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 +44,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);