parse.File JavaScript and Node.js code examples

it('beforeSaveFile should throw error', async () => {
  await reconfigureServer({ filesAdapter: mockAdapter });
  Parse.Cloud.beforeSaveFile(() => {
   throw new Parse.Error(400, 'some-error-message');
  });
  const file = new Parse.File('popeye.txt', [1, 2, 3], 'text/plain');
  try {
   await file.save({ useMasterKey: true });
  } catch (error) {
   expect(error.message).toBe('some-error-message');
  }
 });

it('beforeDeleteFile should call with fileObject', async () => {
  await reconfigureServer({ filesAdapter: mockAdapter });
  Parse.Cloud.beforeDeleteFile((req) => {
   expect(req.file).toBeInstanceOf(Parse.File);
   expect(req.file._name).toEqual('popeye.txt');
   expect(req.file._url).toEqual('http://www.somewhere.com/popeye.txt');
   expect(req.fileSize).toBe(null);
  });
  const file = new Parse.File('popeye.txt');
  await file.destroy({ useMasterKey: true });
 });

it('beforeSaveFile should return file that is already saved and not save anything to files adapter', async () => {
  await reconfigureServer({ filesAdapter: mockAdapter });
  const createFileSpy = spyOn(mockAdapter, 'createFile').and.callThrough();
  Parse.Cloud.beforeSaveFile(() => {
   const newFile = new Parse.File('some-file.txt');
   newFile._url = 'http://www.somewhere.com/parse/files/some-app-id/some-file.txt';
   return newFile;
  });
  const file = new Parse.File('popeye.txt', [1, 2, 3], 'text/plain');
  const result = await file.save({ useMasterKey: true });
  expect(result).toBe(file);
  expect(result._name).toBe('some-file.txt');
  expect(result._url).toBe('http://www.somewhere.com/parse/files/some-app-id/some-file.txt');
  expect(createFileSpy).not.toHaveBeenCalled();
 });

it('beforeSave change propagates through the afterSave #1931', done => {
  Parse.Cloud.beforeSave('ChangingObject', function(request) {
   request.object.unset('file');
   request.object.unset('date');
  });

  Parse.Cloud.afterSave('ChangingObject', function(request) {
   expect(request.object.has('file')).toBe(false);
   expect(request.object.has('date')).toBe(false);
   expect(request.object.get('file')).toBeUndefined();
   return Promise.resolve();
  });
  const file = new Parse.File('yolo.txt', [1, 2, 3], 'text/plain');
  file
   .save()
   .then(() => {
    const obj = new Parse.Object('ChangingObject');
    return obj.save({ file, date: new Date() });
   })
   .then(
    () => {
     done();
    },
    () => {
     fail();
     done();
    }
   );
 });

it('beforeSaveFile should return same file data with new file name', async () => {
  await reconfigureServer({ filesAdapter: mockAdapter });
  const config = Config.get('test');
  config.filesController.options.preserveFileName = true;
  Parse.Cloud.beforeSaveFile(async ({ file }) => {
   expect(file.name()).toBe('popeye.txt');
   const fileData = await file.getData();
   const newFile = new Parse.File('2020-04-01.txt', { base64: fileData });
   return newFile;
  });
  const file = new Parse.File('popeye.txt', [1, 2, 3], 'text/plain');
  const result = await file.save({ useMasterKey: true });
  expect(result.name()).toBe('2020-04-01.txt');
 });

it('afterSaveFile should call with fileObject', async (done) => {
  await reconfigureServer({ filesAdapter: mockAdapter });
  Parse.Cloud.beforeSaveFile(async (req) => {
   req.file.setTags({ tagA: 'some-tag' });
   req.file.setMetadata({ foo: 'bar' });
  });
  Parse.Cloud.afterSaveFile(async (req) => {
   expect(req.master).toBe(true);
   expect(req.file._tags).toEqual({ tagA: 'some-tag' });
   expect(req.file._metadata).toEqual({ foo: 'bar' });
   done();
  });
  const file = new Parse.File('popeye.txt', [1, 2, 3], 'text/plain');
  await file.save({ useMasterKey: true });
 });

it('should be able to block login if an error is thrown even if the user has a attached file', async done => {
  let hit = 0;
  Parse.Cloud.beforeLogin(req => {
   hit++;
   if (req.object.get('isBanned')) {
    throw new Error('banned account');
   }
  });

  const user = await Parse.User.signUp('tupac', 'shakur');
  const base64 = 'V29ya2luZyBhdCBQYXJzZSBpcyBncmVhdCE=';
  const file = new Parse.File('myfile.txt', { base64 });
  await file.save();
  await user.save({ isBanned: true, file });

  try {
   await Parse.User.logIn('tupac', 'shakur');
   throw new Error('should not have been logged in.');
  } catch (e) {
   expect(e.message).toBe('banned account');
  }
  expect(hit).toBe(1);
  done();
 });

it('afterSaveFile should set fileSize to null if beforeSave returns an already saved file', async () => {
  await reconfigureServer({ filesAdapter: mockAdapter });
  const createFileSpy = spyOn(mockAdapter, 'createFile').and.callThrough();
  Parse.Cloud.beforeSaveFile((req) => {
   expect(req.fileSize).toBe(3);
   const newFile = new Parse.File('some-file.txt');
   newFile._url = 'http://www.somewhere.com/parse/files/some-app-id/some-file.txt';
   return newFile;
  });
  Parse.Cloud.afterSaveFile((req) => {
   expect(req.fileSize).toBe(null);
  });
  const file = new Parse.File('popeye.txt', [1, 2, 3], 'text/plain');
  const result = await file.save({ useMasterKey: true });
  expect(result).toBe(result);
  expect(result._name).toBe('some-file.txt');
  expect(result._url).toBe('http://www.somewhere.com/parse/files/some-app-id/some-file.txt');
  expect(createFileSpy).not.toHaveBeenCalled();
 });

it('beforeSaveFile should not change file if nothing is returned', async () => {
  await reconfigureServer({ filesAdapter: mockAdapter });
  Parse.Cloud.beforeSaveFile(() => {
   return;
  });
  const file = new Parse.File('popeye.txt', [1, 2, 3], 'text/plain');
  const result = await file.save({ useMasterKey: true });
  expect(result).toBe(file);
 });

it('beforeSaveFile should contain metadata and tags saved from client', async () => {
  await reconfigureServer({ filesAdapter: mockAdapter });
  const createFileSpy = spyOn(mockAdapter, 'createFile').and.callThrough();
  Parse.Cloud.beforeSaveFile(async (req) => {
   expect(req.triggerName).toEqual('beforeSaveFile');
   expect(req.fileSize).toBe(3);
   expect(req.file).toBeInstanceOf(Parse.File);
   expect(req.file.name()).toBe('popeye.txt');
   expect(req.file.metadata()).toEqual({ foo: 'bar' });
   expect(req.file.tags()).toEqual({ bar: 'foo' });
  });
  const file = new Parse.File('popeye.txt', [1, 2, 3], 'text/plain');
  file.setMetadata({ foo: 'bar' });
  file.setTags({ bar: 'foo' });
  const result = await file.save({ useMasterKey: true });
  expect(result).toBeInstanceOf(Parse.File);
  const options = {
   metadata: { foo: 'bar' },
   tags: { bar: 'foo' },
  };
  expect(createFileSpy).toHaveBeenCalledWith(jasmine.any(String), jasmine.any(Buffer), 'text/plain', options);
 });

it('afterDeleteFile should call with fileObject', async (done) => {
  await reconfigureServer({ filesAdapter: mockAdapter });
  Parse.Cloud.beforeDeleteFile((req) => {
   expect(req.file).toBeInstanceOf(Parse.File);
   expect(req.file._name).toEqual('popeye.txt');
   expect(req.file._url).toEqual('http://www.somewhere.com/popeye.txt');
  });
  Parse.Cloud.afterDeleteFile((req) => {
   expect(req.file).toBeInstanceOf(Parse.File);
   expect(req.file._name).toEqual('popeye.txt');
   expect(req.file._url).toEqual('http://www.somewhere.com/popeye.txt');
   done();
  });
  const file = new Parse.File('popeye.txt');
  await file.destroy({ useMasterKey: true });
 });

it('afterSaveFile should change fileSize when file data changes', async (done) => {
  await reconfigureServer({ filesAdapter: mockAdapter });
  Parse.Cloud.beforeSaveFile(async (req) => {
   expect(req.fileSize).toBe(3);
   expect(req.master).toBe(true);
   const newFile = new Parse.File('donald_duck.pdf', [4, 5, 6, 7, 8, 9], 'application/pdf');
   return newFile;
  });
  Parse.Cloud.afterSaveFile(async (req) => {
   expect(req.fileSize).toBe(6);
   expect(req.master).toBe(true);
   done();
  });
  const file = new Parse.File('popeye.txt', [1, 2, 3], 'text/plain');
  await file.save({ useMasterKey: true });
 });

it('beforeSaveFile should change values of uploaded file by editing fileObject directly', async () => {
  await reconfigureServer({ filesAdapter: mockAdapter });
  const createFileSpy = spyOn(mockAdapter, 'createFile').and.callThrough();
  Parse.Cloud.beforeSaveFile(async (req) => {
   expect(req.triggerName).toEqual('beforeSaveFile');
   expect(req.master).toBe(true);
   req.file.addMetadata('foo', 'bar');
   req.file.addTag('tagA', 'some-tag');
  });
  const file = new Parse.File('popeye.txt', [1, 2, 3], 'text/plain');
  const result = await file.save({ useMasterKey: true });
  expect(result).toBe(file);
  const newData = new Buffer([1, 2, 3]);
  const newOptions = {
   tags: {
    tagA: 'some-tag',
   },
   metadata: {
    foo: 'bar',
   },
  };
  expect(createFileSpy).toHaveBeenCalledWith(jasmine.any(String), newData, 'text/plain', newOptions);
 });

it('beforeDeleteFile should throw error', async (done) => {
  await reconfigureServer({ filesAdapter: mockAdapter });
  Parse.Cloud.beforeDeleteFile(() => {
   throw new Error('some error message');
  });
  const file = new Parse.File('popeye.txt');
  try {
   await file.destroy({ useMasterKey: true });
  } catch (error) {
   expect(error.message).toBe('some error message');
   done();
  }
 })

it('afterSaveFile should throw error', async () => {
  await reconfigureServer({ filesAdapter: mockAdapter });
  Parse.Cloud.afterSaveFile(async () => {
   throw new Parse.Error(400, 'some-error-message');
  });
  const filename = 'donald_duck.pdf';
  const file = new Parse.File(filename, [1, 2, 3], 'text/plain');
  try {
   await file.save({ useMasterKey: true });
  } catch (error) {
   expect(error.message).toBe('some-error-message');
  }
 });

How to use Filefunctionin parse

Best JavaScript code snippets using parse.File(Showing top 15 results out of 315)

How to use
File
function
in
parse