ParseFileTest.js

'use strict';

const assert = require('assert');
const { Readable } = require('stream');
const Parse = require('../../node');

describe('Parse.File', () => {
  it('can save file with uri', async () => {
    // Try https
    const parseLogo =
      'https://raw.githubusercontent.com/parse-community/parse-server/master/.github/parse-server-logo.png';
    const file1 = new Parse.File('parse-server-logo', { uri: parseLogo });
    await file1.save();

    const object = new Parse.Object('TestObject');
    object.set('file1', file1);
    await object.save();

    const query = new Parse.Query('TestObject');
    let result = await query.get(object.id);

    assert.equal(file1.name(), result.get('file1').name());
    assert.equal(file1.url(), result.get('file1').url());

    // Try http
    const file2 = new Parse.File('parse-server-logo', { uri: file1.url() });
    await file2.save();

    object.set('file2', file2);
    await object.save();

    result = await query.get(object.id);
    assert.equal(file2.url(), result.get('file2').url());
  });

  it('can cancel save file with uri', async () => {
    const parseLogo =
      'https://raw.githubusercontent.com/parse-community/parse-server/master/.github/parse-server-logo.png';
    const file = new Parse.File('parse-server-logo', { uri: parseLogo });
    file.save().then(() => {
      assert.equal(file.name(), undefined);
      assert.equal(file.url(), undefined);
    });
    file.cancel();
  });

  it('can get file upload / download progress', async () => {
    const file = new Parse.File('parse-js-test-file', [61, 170, 236, 120]);
    let progress = 0;
    await file.save({
      progress: (value, loaded, total) => {
        progress = value;
        expect(loaded).toBeDefined();
        expect(total).toBeDefined();
      },
    });
    expect(progress).toBe(1);
    progress = 0;
    file._data = null;
    await file.getData({
      progress: (value, loaded, total) => {
        progress = value;
        expect(loaded).toBeDefined();
        expect(total).toBeDefined();
      },
    });
    expect(progress).toBe(1);
  });

  it('can not get data from unsaved file', async () => {
    const file = new Parse.File('parse-server-logo', [61, 170, 236, 120]);
    file._data = null;
    try {
      await file.getData();
    } catch (e) {
      assert.equal(e.message, 'Cannot retrieve data for unsaved ParseFile.');
    }
  });

  it('can get file data from byte array', async () => {
    const file = new Parse.File('parse-server-logo', [61, 170, 236, 120]);
    let data = await file.getData();
    assert.equal(data, 'ParseA==');
    file._data = null;
    await file.save();
    assert.equal(file._data, null);
    data = await file.getData();
    assert.equal(data, 'ParseA==');
  });

  it('can get file data from base64 (saved)', async () => {
    const file = new Parse.File('parse-server-logo', { base64: 'ParseA==' });
    await file.save();
    let data = await file.getData();
    assert.equal(data, 'ParseA==');
    file._data = null;
    await file.save();
    assert.equal(file._data, null);
    data = await file.getData();
    assert.equal(data, 'ParseA==');
  });

  it('can get file data from base64 (unsaved)', async () => {
    const file = new Parse.File('parse-server-logo', { base64: 'ParseA==' });
    const data = await file.getData();
    assert.equal(data, 'ParseA==');
  });

  it('can get file data from full base64', async () => {
    const file = new Parse.File('parse-server-logo', {
      base64: 'data:image/jpeg;base64,ParseA==',
    });
    await file.save();
    let data = await file.getData();
    assert.equal(data, 'ParseA==');
    file._data = null;
    await file.save();
    assert.equal(file._data, null);
    data = await file.getData();
    assert.equal(data, 'ParseA==');
  });

  it('can delete file', async () => {
    const parseLogo =
      'https://raw.githubusercontent.com/parse-community/parse-server/master/.github/parse-server-logo.png';
    const file = new Parse.File('parse-server-logo', { uri: parseLogo });
    await file.save();
    const data = await file.getData();

    const deletedFile = await file.destroy();
    const deletedData = await file.getData();
    assert.equal(file, deletedFile);
    assert.notEqual(data, deletedData);
  });

  it('can handle delete file error', async () => {
    const parseLogo =
      'https://raw.githubusercontent.com/parse-community/parse-server/master/.github/parse-server-logo.png';
    const file = new Parse.File('parse-server-logo', { uri: parseLogo });
    try {
      await file.destroy();
      assert.equal(false, true);
    } catch (e) {
      assert.equal(e.code, Parse.Error.FILE_DELETE_ERROR);
    }
  });

  it('can save file from Buffer', async () => {
    const data = Buffer.from([61, 170, 236, 120]);
    const file = new Parse.File('buffer-file.bin', data);
    await file.save();

    assert(file.url());
    assert(file.name());

    const object = new Parse.Object('TestObject');
    object.set('file', file);
    await object.save();

    const query = new Parse.Query('TestObject');
    const result = await query.get(object.id);
    assert.equal(result.get('file').name(), file.name());
    assert.equal(result.get('file').url(), file.url());

    const retrieved = await file.getData();
    assert.equal(retrieved, data.toString('base64'));
  });

  it('can save file from Buffer with content type', async () => {
    const data = Buffer.from('hello world');
    const file = new Parse.File('hello.txt', data, 'text/plain');
    await file.save();

    assert(file.url());
    const retrieved = await file.getData();
    assert.equal(Buffer.from(retrieved, 'base64').toString(), 'hello world');
  });

  it('can save file from Readable stream', async () => {
    const data = Buffer.from([61, 170, 236, 120]);
    const stream = Readable.from(data);
    const file = new Parse.File('stream-file.bin', stream);
    await file.save();

    assert(file.url());
    assert(file.name());

    const object = new Parse.Object('TestObject');
    object.set('file', file);
    await object.save();

    const query = new Parse.Query('TestObject');
    const result = await query.get(object.id);
    assert.equal(result.get('file').name(), file.name());
    assert.equal(result.get('file').url(), file.url());

    const retrieved = await file.getData();
    assert.equal(retrieved, data.toString('base64'));
  });

  it('can save file from Readable stream with content type', async () => {
    const stream = Readable.from(Buffer.from('hello world'));
    const file = new Parse.File('hello.txt', stream, 'text/plain');
    await file.save();

    assert(file.url());
    const retrieved = await file.getData();
    assert.equal(Buffer.from(retrieved, 'base64').toString(), 'hello world');
  });

  it('can save file to localDatastore', async () => {
    Parse.enableLocalDatastore();
    const file = new Parse.File('parse-js-sdk', [61, 170, 236, 120]);
    const object = new Parse.Object('TestObject');
    await object.pin();

    object.set('file', file);
    await object.save();

    const query = new Parse.Query(TestObject);
    query.fromLocalDatastore();
    query.equalTo('objectId', object.id);
    const results = await query.find();

    const url = results[0].get('file').url();
    assert.equal(results.length, 1);
    assert.notEqual(url, undefined);
    assert.equal(url, file.url());
  });
});