How to use the parse/node.Parse.Object function in parse

it('should generate separate session for each call', async () => {
        const myObject = new Parse.Object('MyObject'); // This is important because transaction only works on pre-existing collections
        await myObject.save();
        await myObject.destroy();

        const myObject2 = new Parse.Object('MyObject2'); // This is important because transaction only works on pre-existing collections
        await myObject2.save();
        await myObject2.destroy();

        spyOn(databaseAdapter, 'createObject').and.callThrough();

        let myObjectCalls = 0;
        Parse.Cloud.beforeSave('MyObject', async () => {
          myObjectCalls++;
          if (myObjectCalls === 2) {
            try {
              await RESTController.request('POST', 'batch', {
                requests: [
                  {
                    method: 'POST',
                    path: '/1/classes/MyObject2',
                    body: { key: 'value1' },

.then(() => {
        const obj = new Parse.Object('AnObject');
        const anotherObject = new Parse.Object('AnotherObject');
        return obj.save({
          anotherObject,
        });
      })
      .then(() => {

'newRequiredFieldWithDefaultValue is required'
          );
        }
        obj.set('newRequiredFieldWithDefaultValue', 'some value2');
        obj.set('newNotRequiredField', '');
        obj.set('newNotRequiredFieldWithDefaultValue', null);
        obj.unset('newRegularField');
        await obj.save();
        expect(obj.get('newRequiredField')).toEqual('some value2');
        expect(obj.get('newRequiredFieldWithDefaultValue')).toEqual(
          'some value2'
        );
        expect(obj.get('newNotRequiredField')).toEqual('');
        expect(obj.get('newNotRequiredFieldWithDefaultValue')).toEqual(null);
        expect(obj.get('newRegularField')).toEqual(undefined);
        obj = new Parse.Object('NewClass');
        obj.set('newRequiredField', 'some value3');
        obj.set('newRequiredFieldWithDefaultValue', 'some value3');
        obj.set('newNotRequiredField', 'some value3');
        obj.set('newNotRequiredFieldWithDefaultValue', 'some value3');
        obj.set('newRegularField', 'some value3');
        await obj.save();
        expect(obj.get('newRequiredField')).toEqual('some value3');
        expect(obj.get('newRequiredFieldWithDefaultValue')).toEqual(
          'some value3'
        );
        expect(obj.get('newNotRequiredField')).toEqual('some value3');
        expect(obj.get('newNotRequiredFieldWithDefaultValue')).toEqual(
          'some value3'
        );
        expect(obj.get('newRegularField')).toEqual('some value3');
        done();

obj = new Parse.Object('NewClassForBeforeSaveTest');
    await obj.save();

    expect(obj.get('foo1')).toEqual('some value 1');
    expect(obj.get('foo2')).toEqual('some value 2');
    expect(obj.get('foo3')).toEqual('some default value 3');
    expect(obj.get('foo4')).toEqual('some default value 4');

    Parse.Cloud.beforeSave('NewClassForBeforeSaveTest', req => {
      req.object.set('foo1', 'some value 1');
      req.object.set('foo2', 'some value 2');
      req.object.set('foo3', undefined);
      req.object.unset('foo4');
    });

    obj = new Parse.Object('NewClassForBeforeSaveTest');
    obj.set('foo3', 'some value 3');
    obj.set('foo4', 'some value 4');
    await obj.save();

    expect(obj.get('foo1')).toEqual('some value 1');
    expect(obj.get('foo2')).toEqual('some value 2');
    expect(obj.get('foo3')).toEqual('some default value 3');
    expect(obj.get('foo4')).toEqual('some default value 4');

    Parse.Cloud.beforeSave('NewClassForBeforeSaveTest', req => {
      req.object.set('foo1', 'some value 1');
      req.object.set('foo2', undefined);
      req.object.set('foo3', undefined);
      req.object.unset('foo4');
    });

.then(() => {
        const obj = new Parse.Object('AnObject');
        obj.set('desiredField', 'This value should be kept');
        obj.set('undesiredField', 'This value should be IGNORED');
        return obj.save();
      })
      .then(() => {

defaultValue: 'some string',
          },
          foo4: { type: 'Date', required: true },
          foo5: { type: 'Number', defaultValue: 5 },
          ptr: { type: 'Pointer', targetClass: 'SomeClass', required: false },
          defaultFalse: {
            type: 'Boolean',
            required: true,
            defaultValue: false,
          },
          defaultZero: { type: 'Number', defaultValue: 0 },
          relation: { type: 'Relation', targetClass: 'SomeClass' },
        },
        classLevelPermissions: defaultClassLevelPermissions,
      });
      const obj = new Parse.Object('NewClassWithOptions');
      try {
        await obj.save();
        fail('should fail');
      } catch (e) {
        expect(e.code).toEqual(142);
      }
      const date = new Date();
      obj.set('foo4', date);
      await obj.save();
      expect(obj.get('foo1')).toBeUndefined();
      expect(obj.get('foo2')).toEqual(10);
      expect(obj.get('foo3')).toEqual('some string');
      expect(obj.get('foo4')).toEqual(date);
      expect(obj.get('foo5')).toEqual(5);
      expect(obj.get('ptr')).toBeUndefined();
      expect(obj.get('defaultFalse')).toEqual(false);

it_exclude_dbs(['postgres'])('get compound indexes on startup', done => {
      const obj = new Parse.Object('TestObject');
      obj.set('subject', 'subject');
      obj.set('comment', 'comment');
      obj
        .save()
        .then(() => {
          return config.database.adapter.createIndex('TestObject', {
            subject: 'text',
            comment: 'text',
          });
        })
        .then(() => {
          return reconfigureServer({
            appId: 'test',
            restAPIKey: 'test',
            publicServerURL: 'http://localhost:8378/1',
          });

obj.set('foo4', 'some value 4');
    await obj.save();

    expect(obj.get('foo1')).toEqual('some value 1');
    expect(obj.get('foo2')).toEqual('some value 2');
    expect(obj.get('foo3')).toEqual('some default value 3');
    expect(obj.get('foo4')).toEqual('some default value 4');

    Parse.Cloud.beforeSave('NewClassForBeforeSaveTest', req => {
      req.object.set('foo1', 'some value 1');
      req.object.set('foo2', undefined);
      req.object.set('foo3', undefined);
      req.object.unset('foo4');
    });

    obj = new Parse.Object('NewClassForBeforeSaveTest');
    obj.set('foo2', 'some value 2');
    obj.set('foo3', 'some value 3');
    obj.set('foo4', 'some value 4');

    try {
      await obj.save();
      fail('should fail');
    } catch (e) {
      expect(e.message).toEqual('foo2 is required');
    }

    Parse.Cloud.beforeSave('NewClassForBeforeSaveTest', req => {
      req.object.set('foo1', 'some value 1');
      req.object.unset('foo2');
      req.object.set('foo3', undefined);
      req.object.unset('foo4');

.then(savedObj1 => {
        const obj2 = new Parse.Object('HasPointersAndRelations');
        obj2.set('aPointer', savedObj1);
        const relation = obj2.relation('aRelation');
        relation.add(obj1);
        return obj2.save();
      })
      .then(() => {

const simpleOneObject = () => {
      const obj = new Parse.Object('SimpleOne');
      obj.set('aNumber', 5);
      obj.set('aString', 'string');
      obj.set('aBool', true);
      return obj;
    };