test(numbers): add tests for numbers

fbschema/Integer.json

@@ -2,35 +2,35 @@
   "title": "Integer Collection",
   "type": "object",
   "properties": {
-    "simpleInteger": {
+    "simple": {
       "type": "integer"
     },
-    "minimumInteger": {
+    "minimum": {
       "type": "integer",
       "minimum": 3
     },
-    "exclusiveMinimumInteger": {
+    "exclusiveMinimum": {
       "type": "integer",
       "exclusiveMinimum": 3
     },
-    "maximumInteger": {
+    "maximum": {
       "type": "integer",
       "maximum": 10
     },
-    "exclusiveMaximumInteger": {
+    "exclusiveMaximum": {
       "type": "integer",
       "exclusiveMaximum": 10
     },
-    "multipleOfInteger": {
+    "multipleOf": {
       "type": "integer",
       "multipleOf": 10
     },
-    "rangeInteger": {
+    "range": {
       "type": "integer",
       "minimum": 0,
       "maximum": 100
     },
-    "enumInteger": {
+    "enum": {
       "type": "integer",
       "enum": [
         1,

fbschema/Number.json

@@ -2,35 +2,35 @@
   "title": "Number Collection",
   "type": "object",
   "properties": {
-    "simpleNumber": {
+    "simple": {
       "type": "number"
     },
-    "minimumNumber": {
+    "minimum": {
       "type": "number",
       "minimum": 3
     },
-    "exclusiveMinimumNumber": {
+    "exclusiveMinimum": {
       "type": "number",
       "exclusiveMinimum": 3
     },
-    "maximumNumber": {
+    "maximum": {
       "type": "number",
       "maximum": 10
     },
-    "exclusiveMaximumNumber": {
+    "exclusiveMaximum": {
       "type": "number",
       "exclusiveMaximum": 10
     },
-    "multipleOfNumber": {
+    "multipleOf": {
       "type": "number",
-      "multipleOf": 10
+      "multipleOf": 0.5
     },
-    "rangeNumber": {
+    "range": {
       "type": "number",
       "minimum": 0,
       "maximum": 100
     },
-    "enumNumber": {
+    "enum": {
       "type": "number",
       "enum": [
         1.1,

fbschema/String.json

@@ -2,18 +2,18 @@
   "title": "String Collection",
   "type": "object",
   "properties": {
-    "simpleString": {
+    "simple": {
       "type": "string"
     },
-    "minLengthString": {
+    "minLength": {
       "type": "string",
-      "minLength": "3"
+      "minLength": 3
     },
-    "maxLengthString": {
+    "maxLength": {
       "type": "string",
-      "maxLength": "10"
+      "maxLength": 10
     },
-    "enumString": {
+    "enum": {
       "enum": [
         "1",
         "2",

test/Integer.ts

@@ -0,0 +1,154 @@
+import * as chai from 'chai';
+
+import {firestore} from './common';
+
+const expect = chai.expect;
+const collection = firestore.collection('IntegerCollection');
+
+describe('Integer Tests:', () => {
+  describe('Create Tests:', () => {
+    it('Accepts property of type `integer`', () => {
+      return collection
+        .add({
+          simple: 1,
+        })
+        .then(() => expect(true).to.be.true);
+    });
+
+    it('Does not accept property of type other than `integer`', () => {
+      return collection
+        .add({
+          simple: '1',
+        })
+        .catch(() => expect(true).to.be.true);
+    });
+
+    it('Does not accept property of type `number`', () => {
+      return collection
+        .add({
+          simple: 0.1,
+        })
+        .catch(() => expect(true).to.be.true);
+    });
+
+    it('Accepts integer of 3 when `minimum` set to 3', () => {
+      return collection
+        .add({
+          minimum: 3,
+        })
+        .then(() => expect(true).to.be.true);
+    });
+
+    it('Does not accept integer of 2 when `minimum` set to 3', () => {
+      return collection
+        .add({
+          minimum: 2,
+        })
+        .catch(() => expect(true).to.be.true);
+    });
+
+    it('Accepts integer of 4 when `exclusiveMinimum` set to 3', () => {
+      return collection
+        .add({
+          exclusiveMinimum: 4,
+        })
+        .then(() => expect(true).to.be.true);
+    });
+
+    it('Does not accept integer of 3 when `exclusiveMinimum` set to 3', () => {
+      return collection
+        .add({
+          exclusiveMinimum: 3,
+        })
+        .catch(() => expect(true).to.be.true);
+    });
+
+    it('Accepts integer of 10 when `maximum` set to 10', () => {
+      return collection
+        .add({
+          maximum: 10,
+        })
+        .then(() => expect(true).to.be.true);
+    });
+
+    it('Does not accept integer of 11 when `maximum` set to 10', () => {
+      return collection
+        .add({
+          maximum: 11,
+        })
+        .catch(() => expect(true).to.be.true);
+    });
+
+    it('Accepts integer of 9 when `exclusiveMaximum` set to 10', () => {
+      return collection
+        .add({
+          exclusiveMaximum: 9,
+        })
+        .then(() => expect(true).to.be.true);
+    });
+
+    it('Does not accept integer of 10 when `exclusiveMaximum` set to 10', () => {
+      return collection
+        .add({
+          exclusiveMaximum: 10,
+        })
+        .catch(() => expect(true).to.be.true);
+    });
+
+    it('Accepts integer of 100 when `multipleOf` set to 10', () => {
+      return collection
+        .add({
+          multipleOf: 100,
+        })
+        .then(() => expect(true).to.be.true);
+    });
+
+    it('Does not accept integer of 101 when `multipleOf` set to 10', () => {
+      return collection
+        .add({
+          multipleOf: 101,
+        })
+        .catch(() => expect(true).to.be.true);
+    });
+
+    it('Accepts integer of 50 when `minimum` is set to 0 and `maximum` is set to 100', () => {
+      return collection
+        .add({
+          range: 50,
+        })
+        .then(() => expect(true).to.be.true);
+    });
+
+    it('Does not accept integer of -1 when `minimum` is set to 0 and `maximum` is set to 100', () => {
+      return collection
+        .add({
+          range: -1,
+        })
+        .catch(() => expect(true).to.be.true);
+    });
+
+    it('Does not accept integer of 101 when `minimum` is set to 0 and `maximum` is set to 100', () => {
+      return collection
+        .add({
+          range: 101,
+        })
+        .catch(() => expect(true).to.be.true);
+    });
+
+    it('Accepts integer of accepted enum value', () => {
+      return collection
+        .add({
+          enum: 1,
+        })
+        .then(() => expect(true).to.be.true);
+    });
+
+    it('Does not accept integer of unaccepted enum value', () => {
+      return collection
+        .add({
+          enum: 4,
+        })
+        .catch(() => expect(true).to.be.true);
+    });
+  });
+});