Parse.Cloud.define("loginWithFacebook", function(request) {

  var params = request.params
  var authData = params.authData
  var id = params.id
  var expiredBy = params.expiredBy

  var facebookAuthData = {
    "id": id,
    "access_token": authData,
    "expiration_date": expiredBy
  }

  Parse.FacebookUtils.logIn(facebookAuthData, { useMasterKey: true }) 
    .then(function(user) {
        if (user.isNew()) {
            console.log("NEW User logged in with id " + user.id + " with session token : " + user.sessionToken)
        } else {
          console.log("Existing User logged in with id " + user.id + " with session token : " + user.sessionToken)
        }
    })
    .catch(function(error) {
      console.log('ERROR','loginWithFacebook() - Error with facebook login : '+ error);
      throw error
    })
  
})

func processFBLogin() {
        
        if let accessToken = AccessToken.current {
            
            logger.debug("Facebook user logged in with toke \(accessToken.appID)- \(accessToken.tokenString)")
            
            PFCloud.callFunction(inBackground: "loginWithFacebook", withParameters: ["id":accessToken.userID, "authData":accessToken.tokenString, "expiredBy":accessToken.expirationDate], block: {
                
                (response: Any?, error: Error?) -> Void in
                
                if error == nil {

                    if let loggedinUser = PFUser.current() {
                        logger.debug("FB login successful - sessiontoken \(loggedinUser.sessionToken) ")
                    } else {
                        
                        logger.debug("FB login failed ")
                        
                    }

                } else {
                    
                    logger.error("Error with facebook login \(String(describing: error?.localizedDescription))")
                }
            })
            
        } else {
            
            logger.info("No FB token available")
        }

    }

 info: Ran cloud function loginWithFacebook for user undefined with:
   Input: {"id":"xxxxxxxxxx","expiredBy":"2020-05-24T15:48:42.018Z","authData":"adasdasdasdasdasdasda"}
   Result: undefined {"functionName":"loginWithFacebook","params":{"id":"xxxxxxxxxx","expiredBy":"2020-05-24T15:48:42.018Z","authData":"adasdasdasdasdasdasda"}}
 verbose: RESPONSE from [POST] /parse/functions/loginWithFacebook: {
   "response": {}
 } {"result":{"response":{}}}
 verbose: REQUEST for [POST] /parse/users: {
   "authData": {
     "facebook": {
       "id": "xxxxxxxxxx",
       "access_token": "adasdasdasdasdasdasda",
       "expiration_date": {
         "__type": "Date",
         "iso": "2020-05-24T15:48:42.018Z"
       }
     }
   }
 } {"method":"POST","url":"/parse/users","headers":{"host":"myApp.herokuapp.com","connection":"close","user-agent":"node-XMLHttpRequest, Parse/js2.11.0 (NodeJS 13.11.0)","accept":"*/*","content-type":"text/plain","x-request-id":"c9ec003f-70c6-4b03-bb2e-acbda997836b","x-forwarded-for":"54.92.152.225","x-forwarded-proto":"https","x-forwarded-port":"443","via":"1.1 vegur","connect-time":"1","x-request-start":"1585152709435","total-route-time":"0","content-length":"569"},"body":{"authData":{"facebook":{"id":"xxxxxx","access_token":"adasdasdasdasdasdasda","expiration_date":{"__type":"Date","iso":"2020-05-24T15:48:42.018Z"}}}}}
 heroku/router at=info method=POST path="/parse/functions/loginWithFacebook" host=myApp.herokuapp.com request_id=2d5de5a0-f465-4387-aa7a-e4c3f575566c fwd="122.169.14.163" dyno=web.1 connect=1ms service=14ms status=200 bytes=625 protocol=https
 heroku/router at=info method=POST path="/parse/users" host=myApp.herokuapp.com request_id=c9ec003f-70c6-4b03-bb2e-acbda997836b fwd="54.92.152.225" dyno=web.1 connect=1ms service=298ms status=201 bytes=794 protocol=https
 verbose: RESPONSE from [POST] /parse/users: {
   "status": 201,
   "response": {
     "objectId": "efsyICJCAq",
     "createdAt": "2020-03-25T16:11:49.440Z",
     "username": "hDTtBCA6oSpZGDR7a9kpemoFC"
   },
   "location": "http://myApp.herokuapp.com/parse/users/efsyICJCAq"
 } {"result":{"status":201,"response":{"objectId":"efsyICJCAq","createdAt":"2020-03-25T16:11:49.440Z","username":"sdfsdfsdfsdf"},"location":"http://myApp.herokuapp.com/parse/users/efsyICJCAq"}}
 Existing User logged in with id efsyICJCAq with session token : undefined

RestWrite.prototype.createSessionTokenIfNeeded = function() {

logger.info('Message - createSessionTokenIfNeeded - For class - ' + this.className)
  if (this.className !== '_User') {
    return;
  }
  // Don't generate session for updating user (this.query is set) unless authData exists
  if (this.query && !this.data.authData) {
    return;
  }
  logger.info('Message - createSessionTokenIfNeeded - Not update call - going ahead')

  // Don't generate new sessionToken if linking via sessionToken
  if (this.auth.user && this.data.authData) {
    return;
  }
  logger.info('Message - createSessionTokenIfNeeded - not linking so going ahead')

  if (
    !this.storage['authProvider'] && // signup call, with (THIS IS FAILING)
    this.config.preventLoginWithUnverifiedEmail && // no login without verification
    this.config.verifyUserEmails
  ) {
    // verification is on
    logger.info('Message - createSessionTokenIfNeeded - returning as no auth provider, preventLoginWihoutEmail, verifyEmail')   
    logger.info('Message - createSessionTokenIfNeeded - authProvider = ' + this.storage['authProvider'] + ' preventLoginWihoutEmail = ' + this.config.preventLoginWithUnverifiedEmail + ' verifyUserEmails = ' + this.config.verifyUserEmails)
    return; // do not create the session token in that case!
  }
  logger.info('Message - createSessionTokenIfNeeded - before calling - return this.createSessionToken()' )

  return this.createSessionToken();
};

return this.handleAuthDataValidation(authData).then(() => {
      if (results.length > 1) {
        // More than 1 user with the passed id's
        throw new Parse.Error(
          Parse.Error.ACCOUNT_ALREADY_LINKED,
          'this auth is already used'
        );
      } 
    });

if (
    !this.storage['authProvider'] && // signup call, with
    this.config.preventLoginWithUnverifiedEmail && // no login without verification
    this.config.verifyUserEmails
  ) {
    // verification is on
    return; // do not create the session token in that case!
  }
  return this.createSessionToken();

PFFacebookUtils.logInInBackground(withReadPermissions: facebookPermissions) {
               (loggedInUser: PFUser?, error: Error?) in
          
           if error == nil && loggedInUser != nil {
                //fetch email, name etc details from Facebook 
                 saveUserDetailsOnParse(...)
           }

func saveUserDetailsOnParse(isNewUser: Bool, user: PFUser?, socialId: String, email: String, name: String, profileImageURL: String?, loginProvider: String, callback: @escaping (String, NSError?) -> ())  {
       
       if name != "" {
          //if email based user logged in then name will be blank so update/add only if not blank ie for social login
           PFUser.current()?["name"] = name
       }
       if profileImageURL != nil {
           
           //if email based or Apple user logged in then URL will be blank so update/add only if not blank ie for social login
           PFUser.current()?["profile_image_url"] = profileImageURL!
       }
               
       PFUser.current()?["email"] = email
       
       if isNewUser {
          //if logged in user isNew  property is true
           self.saveNewUserToParse(socialId: socialId, loginProvider: loginProvider) { (errorMessage, error) in
               
               callback(errorMessage, error)
           }

       } else {
           //save details for existing user
           PFUser.current()?.saveInBackground(block: { (successSaveUser, error) in
              
             
               if successSaveUser {
                   logger.debug("User attributes updated to Parse")
                   callback("User attributes updated to Parse", nil)
                   
               } else {
                   
                   logger.debug("Error saving current PFUser post login to parse")
                   callback("Error saving current PFUser post login to parse", error! as NSError)
                   
               }
           })
       }
       
   }

var express = require('express');
var cors = require('cors');
var ParseServer = require('parse-server').ParseServer;
var path = require('path');

var databaseUri = process.env.DATABASE_URI || process.env.MONGODB_URI;

var api = new ParseServer({
  databaseURI: databaseUri,
  cloud: process.env.CLOUD_CODE_MAIN || __dirname + '/cloud/main.js',
  appId: process.env.APP_ID,
  masterKey: process.env.MASTER_KEY, //Add your master key here. Keep it secret!
  serverURL: process.env.SERVER_URL ,  // Don't forget to change to https if needed
  javascriptKey: process.env.JAVASCRIPT_KEY,// || '',  //** add this line no need to set values, they will be overwritten by heroku config vars
  restAPIKey: process.env.REST_API_KEY,// || '', //** add this line
  clientKey: process.env.CLIENT_KEY,// || '', //** add this line
  verbose:process.env.VERBOSE,
  logLevel: process.env.LOG_LEVEL, // VERBOSE, INFO, ERROR, NONE, defaults to INFO
  push: {
        ios: {
            pfx: 'certs/ApplePush.p12', // the path and filename to the .p12 file you exported earlier. 
            passphrase: process.env.APPLE_PUSH_PASSPHRASE,
            topic: process.env.APPLE_PUSH_TOPIC, // The bundle identifier associated with your app
            production: false //
        }
    },
  auth: {
    facebook: {
      appIds: process.env.FACEBOOK_APP_ID
    },
    apple: {
      
      client_id: process.env.IOS_BUNDLE_ID // optional (for extra validation), use the Service ID from Apple.
    }
  },
  verifyUserEmails: true,
  emailVerifyTokenValidityDuration: 2 * 60 * 60, 
  preventLoginWithUnverifiedEmail: true, 

  publicServerURL: process.env.SERVER_URL,
  appName: process.env.APP_NAME,
  emailAdapter: {
    module: '@parse/simple-mailgun-adapter',
    options: {
      fromAddress: process.env.APP_SUPPORT_EMAIL,
      domain: process.env.MAILGUN_DOMAIN,
      apiKey: process.env.MAILGUN_API_KEY,
    }
  },
  passwordPolicy: {
    validatorPattern: /^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.{8,})/, 
    validationError: 'Password must have at least 8 characters, contain at least 1 digit, 1 upper case and 1 lower case character.',
    doNotAllowUsername: true, 
    maxPasswordAge: 90, 
    maxPasswordHistory: 5, 
    resetTokenValidityDuration: 24*60*60, 
  }

});
var app = express();
app.use(cors()); 

// Serve static assets from the /public folder
app.use('/public', express.static(path.join(__dirname, '/public')));

// Serve the Parse API on the /parse URL prefix
var mountPath = process.env.PARSE_MOUNT || '/parse';
app.use(mountPath, api);

// Parse Server plays nicely with the rest of your web routes
app.get('/', function(req, res) {
  res.status(200).send('Make sure to star the parse-server repo on GitHub!');
});

// There will be a test page available on the /test path of your server url
// Remove this before launching your app
app.get('/test', function(req, res) {
  res.sendFile(path.join(__dirname, '/public/test.html'));
});

var port = process.env.PORT || 1337;
var httpServer = require('http').createServer(app);
httpServer.listen(port, function() {
    console.log('parse-server-example running on port ' + port + '.');
});

{
  "name": "name",
  "version": "1.0.0",
  "description": " example Parse API server using the parse-server module",
  "main": "index.js",
  "repository": {
    "type": "git",
    "url": "https://github.com/myrepo/my-parse-server"
    
  },
  "license": "MIT",
  "dependencies": {
    "express": "4.17.1",
    "underscore":"*",
    "parse": "2.12.0",
    "cryptoutils":"*",
    "cors":"*",
    "parse-server": "4.4.0  "
    
  },
  "scripts": {
    "start": "node index.js"
  },
  "engines": {
    "node": ">9.0.0",
    "npm": "6.13.7"
  }
}

func saveNewUserToParse(socialId: String?, loginProvider: String?, callback: @escaping (String, NSError?) -> ())  {
                            
        // Setup some seed values for the newly created user
 
        PFUser.current()?.saveInBackground(block: { (successSaveUser, error) in

                //MARK: Getting error 206 here
           if successSaveUser {
                callback("New user's attributes saved to Parse", nil)
            } else {
              
                    logger.debug("Error saving current PFUser post login/signup to parse  \(error!.localizedDescription)")
                    callback("Error saving current PFUser post login/signup to parse", error! as NSError)
            }
        })
        
    }

import Parse

func loginWithFacebook() {
	
	PFFacebookUtils.logInInBackground(withReadPermissions: facebookPermissions) {
		(loggedInUser: PFUser?, error: Error?) in
		
		if error == nil && loggedInUser != nil {
			
			saveUserDetailsOnParse(isNewUser: loggedInUser!.isNew, user: loggedInUser! ,socialId: socialId, email: userEmail, name: userName, profileImageURL: profileImageURL, loginProvider: "facebook", callback: { (message, error) in
				
				if error == nil {
					//proceed to home screen
				} else {
					//show error
				}
			})
		}
	}
}



func saveUserDetailsOnParse(isNewUser: Bool, user: PFUser?, socialId: String, email: String, name: String,  loginProvider: String, callback: @escaping (String, NSError?) -> ())  {
	
	if name != "" && PFUser.current()?["name"] == nil {
		
		PFUser.current()?["name"] = name
	}
	PFUser.current()?["email"] = email
	
	if isNewUser {
		//if logged in user isNew  property is true
		self.saveNewUserToParse() { (errorMessage, error) in
			
			callback(errorMessage, error)
		}
		
	} else {
		//save details for existing user
		PFUser.current()?.saveInBackground(block: { (successSaveUser, error) in
			if successSaveUser {
				logger.debug("User attributes updated to Parse")
				callback("User attributes updated to Parse", nil)
				
			} else {
				
				logger.debug("Error saving current PFUser post login to parse")
				callback("Error saving current PFUser post login to parse", error! as NSError)
				
			}
		})
	}
	
}

func saveNewUserToParse(callback: @escaping (String, NSError?) -> ())  {
	
	//Set some initial values in PFUser.current()
	
	PFUser.current()?.saveInBackground(block: { (successSaveUser, error) in
		
		//MARK: Getting error 206 here
		if successSaveUser {
			callback("New user's attributes saved to Parse", nil)
		} else {
			
			logger.debug("Error saving current PFUser post login/signup to parse  \(error!.localizedDescription)")
			callback("Error saving current PFUser post login/signup to parse", error! as NSError)
		}
	})
	
}

func loginWithFB() {
		
		PFFacebookUtils.logInInBackground(withReadPermissions: facebookPermissions) {
				(loggedInUser: PFUser?, error: Error?) in
		   
			if error == nil && loggedInUser != nil {

				//this causes the issue
				loggedInUser!.email = "a@a.com"

				loggedInUser!.saveInBackground { (savedStatus, error) in

					if error != nil {
							
						logger.error("Enountered error \(error)")
					} else {
						
						logger.info("Saved successfully")
					}
				}
			}
		}

	}

it('test facebook signup with verifyUserEmails=true', done => {

   config.verifyUserEmails = true //added this to test

   const data = {
     authData: {
       facebook: {
         id: '8675309',
         access_token: 'jenny',
       },
     },
   };
   let newUserSignedUpByFacebookObjectId;
   rest
     .create(config, auth.nobody(config), '_User', data)
     .then(r => {
       expect(typeof r.response.objectId).toEqual('string');
       expect(typeof r.response.createdAt).toEqual('string');
       expect(typeof r.response.sessionToken).toEqual('string');
       newUserSignedUpByFacebookObjectId = r.response.objectId;
       return rest.create(config, auth.nobody(config), '_User', data);
     })
     .then(r => {
       expect(typeof r.response.objectId).toEqual('string');
       expect(typeof r.response.createdAt).toEqual('string');
       expect(typeof r.response.username).toEqual('string');
       expect(typeof r.response.updatedAt).toEqual('string');
       expect(r.response.objectId).toEqual(newUserSignedUpByFacebookObjectId);
       return rest.find(config, auth.master(config), '_Session', {
         sessionToken: r.response.sessionToken,
       });
     })
     .then(response => {
       expect(response.results.length).toEqual(1);
       const output = response.results[0];
       expect(output.user.objectId).toEqual(newUserSignedUpByFacebookObjectId);
       done();
     })
     .catch(err => {
       jfail(err);
       done();
     });
 });

> parse-server@6.0.0-alpha.14 pretest
> cross-env MONGODB_VERSION=${MONGODB_VERSION:=5.3.2} MONGODB_TOPOLOGY=${MONGODB_TOPOLOGY:=standalone} mongodb-runner start

  ◜ Starting a MongoDB deployment to test against...
> parse-server@6.0.0-alpha.14 test
> npm run testonly "spec/rest.spec.js"


> parse-server@6.0.0-alpha.14 testonly
> cross-env MONGODB_VERSION=${MONGODB_VERSION:=5.3.2} MONGODB_TOPOLOGY=${MONGODB_TOPOLOGY:=standalone} TESTING=1 jasmine "spec/rest.spec.js"

Randomized with seed 86934
Started
Jasmine started
warn: DeprecationWarning: The Parse Server option 'allowClientClassCreation' default will change to 'false' in a future version.
warn: DeprecationWarning: The Parse Server option 'allowExpiredAuthDataToken' default will change to 'false' in a future version.
.
  rest create
    ✓ handles object and subdocument
.    ✓ should generate objectId when not set by client with allowCustomObjectId true
.    ✓ is backwards compatible when _id size changes
.    ✓ can create a session with no expiration
.    ✓ handles anonymous user signup and upgrade to new user
.    ✓ handles create on non-existent class when disabled client class creation
.    ✓ test specified session length
.    ✓ handles create on existent class when disabled client class creation
.    ✓ handles user signup
.    ✓ sets current user in new sessions
.    ✓ handles no anonymous users config
.    ✓ test default session length
.    ✓ stores pointers
.    ✓ cannot set objectId
.    ✓ should use objectId from client when allowCustomObjectId true
.    ✓ can create object in volatileClasses if masterKey
.    ✓ handles anonymous user signup
.    ✓ should throw on invalid objectId when allowCustomObjectId true
.    ✓ test facebook signup and login
.    ✓ handles _id
.    ✓ stores pointers to objectIds larger than 10 characters
.    ✓ cannot set id
.    ✓ locks down session
.    ✓ test facebook signup with verifyUserEmails=true
.    ✓ can use custom _id size
.    ✓ cannot create object in volatileClasses if not masterKey
.    ✓ handles array, object, date

.  rest update
    ✓ ignores createdAt

.  read-only masterKey
    ✓ properly blocks writes
.    ✓ properly throws on rest.create, rest.update and rest.del
.    ✓ should throw when trying to create schema
.    ✓ should throw when trying to create schema with a name
.    ✓ should throw when masterKey and readOnlyMasterKey are the same
.    ✓ should throw when trying to create RestWrite
.    ✓ should throw when trying to update the global config
.    ✓ should throw when trying to send push
.    ✓ should throw when trying to update schema
.    ✓ should throw when trying to delete schema




38 specs, 0 failures
Finished in 2.061 seconds
Randomized with seed 86934 (jasmine --random=true --seed=86934)
Executed 38 of 38 specs SUCCESS in 2 secs.
Randomized with seed 86934.

> parse-server@6.0.0-alpha.14 posttest
> cross-env MONGODB_VERSION=${MONGODB_VERSION:=5.3.2} MONGODB_TOPOLOGY=${MONGODB_TOPOLOGY:=standalone} mongodb-runner stop

it('test facebook signup with verifyUserEmails=true', done => {

    reconfigureServer({
      appName: 'unused',
      verifyUserEmails: true,
      publicServerURL: 'http://localhost:8378/1',
    })
    .then(() => {

      const data = {
        authData: {
          facebook: {
            id: '8675309',
            access_token: 'jenny',
          },
        },
      };
      let newUserSignedUpByFacebookObjectId;
      rest
        .create(config, auth.nobody(config), '_User', data)
        .then(r => {
          expect(typeof r.response.objectId).toEqual('string');
          expect(typeof r.response.createdAt).toEqual('string');
          expect(typeof r.response.sessionToken).toEqual('string');
          newUserSignedUpByFacebookObjectId = r.response.objectId;
          return rest.create(config, auth.nobody(config), '_User', data);
        })
        .then(r => {
          expect(typeof r.response.objectId).toEqual('string');
          expect(typeof r.response.createdAt).toEqual('string');
          expect(typeof r.response.username).toEqual('string');
          expect(typeof r.response.updatedAt).toEqual('string');
          expect(r.response.objectId).toEqual(newUserSignedUpByFacebookObjectId);
          return rest.find(config, auth.master(config), '_Session', {
            sessionToken: r.response.sessionToken,
          });
        })
        .then(response => {
          expect(response.results.length).toEqual(1);
          const output = response.results[0];
          expect(output.user.objectId).toEqual(newUserSignedUpByFacebookObjectId);
          done();
        })
        .catch(err => {
          jfail(err);
          done();
        });
    });
    
  })

it('test facebook signup with verifyUserEmails=true', done => {

   const emailAdapter = {
     sendVerificationEmail: options => {
       sendEmailOptions = options;
     },
     sendPasswordResetEmail: () => Promise.resolve(),
     sendMail: () => {},
   };


   reconfigureServer({
     appName: 'unused',
     verifyUserEmails: true,
     emailAdapter: emailAdapter,
     emailVerifyTokenValidityDuration: 0.5, 
     publicServerURL: 'http://localhost:8378/1',
   })
   .then(() => {

     const data = {
       authData: {
         facebook: {
           id: '8675309',
           access_token: 'jenny',
         },
       },
     };
     let newUserSignedUpByFacebookObjectId;
     rest
       .create(config, auth.nobody(config), '_User', data)
       .then(r => {
         console.warn('Error206: New FB user created ' + r.response.objectId);

         expect(typeof r.response.objectId).toEqual('string');
         expect(typeof r.response.createdAt).toEqual('string');
         expect(typeof r.response.sessionToken).toEqual('string');
         newUserSignedUpByFacebookObjectId = r.response.objectId;
         return rest.create(config, auth.nobody(config), '_User', data);
       })
       .then(r => {
         console.warn('Error206: FB user queried ' + r.response.objectId);

         expect(typeof r.response.objectId).toEqual('string');
         expect(typeof r.response.createdAt).toEqual('string');
         expect(typeof r.response.username).toEqual('string');
         expect(typeof r.response.updatedAt).toEqual('string');
         expect(r.response.objectId).toEqual(newUserSignedUpByFacebookObjectId);
         return rest.find(config, auth.master(config), '_Session', {
           sessionToken: r.response.sessionToken,
         });
       })
       .then(response => {
         expect(response.results.length).toEqual(1);
         const output = response.results[0];
         expect(output.user.objectId).toEqual(newUserSignedUpByFacebookObjectId);
         done();
       })
       .catch(err => {
         jfail(err);
         done();
       });
   });
   
 })

const autoWithDrawRequestJob = schedule.scheduleJob({rule: '* * 0 * *', tz: "Asia/Kolkata"}, function(){
  console.log('Running resetPriceDropDate job');
  Parse.Cloud.run("cloudJob",null,{useMasterKey:true});
});

it('test async facebook signup with verifyUserEmails=true', async done => {
    const emailAdapter = {
      sendVerificationEmail: options => {
        sendEmailOptions = options;
      },
      sendPasswordResetEmail: () => Promise.resolve(),
      sendMail: () => {},
    };


    await reconfigureServer({
      appName: 'unused',
      verifyUserEmails: false,
      emailAdapter: emailAdapter,
      emailVerifyTokenValidityDuration: 0.5, // 0.5 second
      publicServerURL: 'http://localhost:8378/1',
    })

      const data = {
        authData: {
          facebook: {
            id: '8675309',
            access_token: 'jenny',
          },
        },
      };

    let newUserSignedUpByFacebookObjectId;
    rest
      .create(config, auth.nobody(config), '_User', data)
      .then(r => {
        expect(typeof r.response.objectId).toEqual('string');
        expect(typeof r.response.createdAt).toEqual('string');
        expect(typeof r.response.sessionToken).toEqual('string');
        newUserSignedUpByFacebookObjectId = r.response.objectId;
        return rest.create(config, auth.nobody(config), '_User', data);
      })
      .then(r => {
        expect(typeof r.response.objectId).toEqual('string');
        expect(typeof r.response.createdAt).toEqual('string');
        expect(typeof r.response.username).toEqual('string');
        expect(typeof r.response.updatedAt).toEqual('string');
        expect(r.response.objectId).toEqual(newUserSignedUpByFacebookObjectId);
        return rest.find(config, auth.master(config), '_Session', {
          sessionToken: r.response.sessionToken,
        });
      })
      .then(response => {
        expect(response.results.length).toEqual(1);
        const output = response.results[0];
        expect(output.user.objectId).toEqual(newUserSignedUpByFacebookObjectId);
        done();
      })
      .catch(err => {
        jfail(err);
        done();
      });

  });