Merge branch 'dev' of github.com:two-factor/two-factor into dev

__tests__/functions/databases/mongoose/create.js

@@ -0,0 +1,58 @@
+const mongoose = require('mongoose');
+const mongooseCreate = require ('../../../../functions/databases/mongoose/create');
+
+describe('tests the create function', () => {
+    class FakeClient {
+        constructor(
+          AccSID,
+          AuthToken
+        ) {
+          this.AccSID = AccSID;
+          this.AuthToken = AuthToken;
+          this.client = {
+            verify: {
+              services: {
+                create: () => {
+                  const isError = this.isError;
+                  return new Promise((resolve, reject) => {
+                    if (isError) {
+                      reject(new Error("fake error message"));
+                    }
+                    resolve({
+                      sid: "fakeSid"
+                    });
+                  });
+                }
+              }
+            }
+          };
+            this.TwoAuthUser = {
+                create: ({
+                    userID,
+                    sid,
+                    phone
+                }) => {
+                    return new Promise((resolve, reject) => {
+                        resolve(5)
+                    })
+                }
+            };
+            this.create = mongooseCreate;
+        }
+      }
+
+      it('generates a user with the right sid', async () => {
+        const newClient = new FakeClient();
+        // create a user using client.create()
+        let result = await newClient.create('ian', '+17604307620')
+        expect(result).toBe(5)
+        // query database for that user
+      });
+
+      it('passes error message on rejection', () => {
+        const newClient = new FakeClient();
+        let users = newClient.users;
+        newClient.create('ian', '+17604307620').catch(err => { expect(err instanceof Error).toBeTruthy();
+      });
+    });
+});

__tests__/functions/databases/mongoose/send.js

@@ -0,0 +1,4 @@
+const mongoose = require("mongoose");
+const mongooseSend = require("../../../../functions/databases/mongoose/send");
+
+

__tests__/functions/databases/postgresql/create.js

@@ -1,15 +1,39 @@
-// const client = require('../../../../index')(process.env.SID, process.env.AUTH, {
-//   isPostgres: true,
-//   appName: 'testApp',
-//   connectionURI: 'postgres://postgres:yellowjacket@localhost/twoauthtest',
-// });
-
-// // client.create("ian", "+17604207520");
-
-// client
-//   .create('ian', '+12016750593')
-//   .then(res => console.log(res))
-//   .catch(err => console.log(err));
-// // describe("Tests for Postgres Send", () => {
-
-// // });
+const create = require("../../../../functions/databases/postgres/create");
+describe('tests the pg create method', () => {
+  class FakeClient {
+    constructor(isError) {
+      this.users = {};
+      this.isError = isError;
+      this.pgConnect = function () {
+        return new Promise((resolve, reject) => {
+          resolve({
+            database: {
+              query: (query, values) => new Promise((resolve, reject) => {
+                resolve('fakeUser');
+              }),
+            },
+            done: () => null,
+          });
+        });
+      };
+      this.client = {
+        verify: {
+          services: {
+            create: () => new Promise((resolve, reject) => {
+              resolve({ sid: 'testSID' });
+            }),
+          },
+        },
+      };
+      this.create = create;
+    }
+  }
+
+  it("generates a postgres row with the correct sid", () => {
+    const fakeClient = new FakeClient(false);
+    let database = fakeClient.pgConnect();
+    return fakeClient.create('fakeUser', '+11231231234').then((user) => {
+      expect(user).toEqual('fakeUser');
+    })
+  })
+});

functions/databases/postgres/create.js

@@ -7,9 +7,11 @@ module.exports = function (userID, phone) {
     this.pgConnect()
       .then(({ database, done }) => {
         if (typeof phone !== 'string') {
+          done();
           reject(new Error('typeof phone must be string'));
         }
         if (phone.substring(0, 2) !== '+1') {
+          done();
           reject(new Error('phone must be string formatted as such: +1XXXXXXXXXX'));
         }
         client.verify.services

functions/databases/postgres/verify.js

@@ -1,15 +1,50 @@
-module.exports = function(userID, phone) {
+module.exports = function(userID, code) {
+  const { pgConnect } = this;
   return new Promise((resolve, reject) => {
-    this.pgConnect()
+    pgConnect()
       .then(({ database, done }) => {
-        // pgClient.query... blah blah logic
-        //invoke done before your resolve this promise
-        done();
+        //Query to just check if the user was created
+        const query = "SELECT * FROM twoauthusers WHERE userid=$1";
+        const values = [String(userID)];
+
+        database
+          .query(query, values)
+          .then(res => {
+            const { sid, phone } = res.rows[0];
+
+            if (!sid)
+              reject(new Error("SID Error: No SID exists for this user."));
+            if (!phone)
+              reject(
+                new Error(
+                  "Phone Number Error: No phone number exists for this user."
+                )
+              );
+
+            return this.client.verify
+              .services(sid)
+              .verificationChecks.create({
+                to: phone,
+                code
+              })
+              .then(verification => {
+                if (verification.status === "approved") resolve(true);
+                resolve(false);
+              })
+              .catch(err => {
+                done();
+                resolve(false);
+              });
+          })
+          .catch(err => {
+            done();
+            reject(new Error("Could not find Database at Connection URI."));
+          });
       })
-      .catch((err, done) => {
-        //invoke done before you reject
+      .catch(err => {
         done();
-        reject(err);
+        reject(new Error("Could not find Database at Connection URI."));
       });
   });
+  //invoke done before you reject
 };