How to use the parse/node.User function in parse

it('calls create to generate patched Parse.Object', () => {
      const q = new Query(Parse.User);
      expect(q).to.be.ok;
      expect(modelCreateSpy).to.have.been.calledWith(Parse.User, sessionToken);
    });
  });

it('calls create to generate patched Parse.Object', () => {
      const q = new Query(Parse.User);
      expect(q).to.be.ok;
      expect(modelCreateSpy).to.have.been.calledWith(Parse.User, sessionToken);
    });
  });

const usernameFor = async (sessionToken: string): Promise => {
  const user = await Parse.User.become(sessionToken);
  const username = user.getUsername();
  await Parse.User.logOut();
  return username;
};

it('should properly interpret a query v2', (done) => {
    const user = new Parse.User();
    user.set("username", "foo");
    user.set("password", "bar");
    return user.save().then((user) => {
      const objIdQuery = new Parse.Query("_User").equalTo("objectId", user.id);
      const blockedUserQuery = user.relation("blockedUsers").query();

      const aResponseQuery = new Parse.Query("MatchRelationshipActivityResponse");
      aResponseQuery.equalTo("userA", user);
      aResponseQuery.equalTo("userAResponse", 1);

      const bResponseQuery = new Parse.Query("MatchRelationshipActivityResponse");
      bResponseQuery.equalTo("userB", user);
      bResponseQuery.equalTo("userBResponse", 1);

      const matchOr = Parse.Query.or(aResponseQuery, bResponseQuery);
      const matchRelationshipA = new Parse.Query("_User");

it("notEqualTo with Relation is working", function(done) {
    const user = new Parse.User();
    user.setPassword("asdf");
    user.setUsername("zxcv");

    const user1 = new Parse.User();
    user1.setPassword("asdf");
    user1.setUsername("qwerty");

    const user2 = new Parse.User();
    user2.setPassword("asdf");
    user2.setUsername("asdf");

    const Cake = Parse.Object.extend("Cake");
    const cake1 = new Cake();
    const cake2 = new Cake();
    const cake3 = new Cake();


    user.signUp().then(function(){
      return user1.signUp();
    }).then(function(){
      return user2.signUp();
    }).then(function(){
      const relLike1 = cake1.relation("liker");
      relLike1.add([user, user1]);

it('containedIn null array', (done) => {
    const emails = ['contact@xyz.com', 'contact@zyx.com', null];
    const user = new Parse.User();
    user.setUsername(emails[0]);
    user.setPassword('asdf');
    user.signUp().then(() => {
      const query = new Parse.Query(Parse.User);
      query.containedIn('username', emails);
      return query.find({ useMasterKey: true });
    }).then((results) => {
      equal(results.length, 1);
      done();
    }, done.fail);
  });

tags: ['nofilter', 'latergram', 'tbt'],
    };

    q = new Parse.Query('Image');
    q.equalTo('tags', 'selfie');
    expect(matchesQuery(img, q)).toBe(false);
    q.equalTo('tags', 'tbt');
    expect(matchesQuery(img, q)).toBe(true);

    const q2 = new Parse.Query('Image');
    q2.containsAll('tags', ['latergram', 'nofilter']);
    expect(matchesQuery(img, q2)).toBe(true);
    q2.containsAll('tags', ['latergram', 'selfie']);
    expect(matchesQuery(img, q2)).toBe(false);

    const u = new Parse.User();
    u.id = 'U2';
    q = new Parse.Query('Image');
    q.equalTo('owner', u);

    img = {
      className: 'Image',
      objectId: 'I1',
      owner: {
        className: '_User',
        objectId: 'U2',
      },
    };
    expect(matchesQuery(img, q)).toBe(true);

    img.owner.objectId = 'U3';
    expect(matchesQuery(img, q)).toBe(false);

let numCreated = 0;
    const user1 = new Parse.User();
    user1.setPassword('asdf');
    user1.setUsername('u1');
    user1.setEmail('dupe@dupe.dupe');
    const p1 = user1.signUp();
    p1.then(() => {
      numCreated++;
      expect(numCreated).toEqual(1);
    }, error => {
      numFailed++;
      expect(numFailed).toEqual(1);
      expect(error.code).toEqual(Parse.Error.EMAIL_TAKEN);
    });

    const user2 = new Parse.User();
    user2.setPassword('asdf');
    user2.setUsername('u2');
    user2.setEmail('dupe@dupe.dupe');
    const p2 = user2.signUp();
    p2.then(() => {
      numCreated++;
      expect(numCreated).toEqual(1);
    }, error => {
      numFailed++;
      expect(numFailed).toEqual(1);
      expect(error.code).toEqual(Parse.Error.EMAIL_TAKEN);
    });

    Parse.Promise.when([p1, p2])
      .then(() => {
        fail('one of the users should not have been created');

function createTestUser() {
  const user = new Parse.User();
  user.set('username', 'test');
  user.set('password', 'moon-y');
  return user.signUp();
}

beforeEach(function(done) {
    const Parse = require('parse/node');

    spyOn(Parse, 'Query').and.returnValue({
      first: jasmine.createSpy('first').and.returnValue(
        Promise.resolve(
          new Parse.Object('_Session', {
            user: new Parse.User({ id: 'userId' }),
          })
        )
      ),
      equalTo: function() {},
    });

    done();
  });