/* globals expect */
/* globals describe */
/* globals it */

var _ = require('../src/utility');
var t = require('../src/transforms');

function itemFromArgs(args) {
  var item = _.createItem(args);
  item.level = 'debug';
  return item;
}

var fakeLogger = {
  error: function () {},
  log: function () {},
};

describe('itemToPayload', function () {
  it('ignores options.payload.body but merges in other payload options', function (done) {
    var args = ['a message', { custom: 'stuff' }];
    var item = itemFromArgs(args);
    item.accessToken = 'abc123';
    item._isUncaught = true;
    item._originalArgs = ['c', 3];
    item.data = {};
    var options = {
      endpoint: 'api.rollbar.com',
      payload: { body: 'hey', x: 42 },
    };
    t.itemToPayload(item, options, function (e, i) {
      expect(i._isUncaught).to.eql(item._isUncaught);
      expect(i._originalArgs).to.eql(item._originalArgs);

      // This transform shouldn't apply any payload keys.
      expect(i.body).to.not.eql('hey');
      expect(i.x).to.not.eql(42);
      done(e);
    });
  });
  it('ignores handles trailing slash in endpoint', function (done) {
    var args = ['a message', { custom: 'stuff' }];
    var item = itemFromArgs(args);
    item.accessToken = 'abc123';
    item.data = { message: 'a message' };
    var options = {
      endpoint: 'api.rollbar.com/',
    };
    t.itemToPayload(item, options, function (e, i) {
      expect(i.message).to.eql('a message');
      done(e);
    });
  });
});

describe('addPayloadOptions', function () {
  it('ignores options.payload.body but merges in other payload options', function (done) {
    var args = ['a message', { custom: 'stuff' }];
    var item = itemFromArgs(args);
    item.accessToken = 'abc123';
    var options = {
      endpoint: 'api.rollbar.com',
      payload: { body: 'hey', x: 42 },
    };
    t.addPayloadOptions(item, options, function (e, i) {
      expect(i.data.body).to.not.eql('hey');
      expect(i.data.x).to.eql(42);
      done(e);
    });
  });
});

describe('addTelemetryData', function () {
  it('adds the data to the right place if events exist', function (done) {
    var item = {
      data: {
        body: {
          message: 'hello world',
        },
      },
      telemetryEvents: [
        {
          type: 'log',
          body: {
            subtype: 'console',
            message: 'bork',
          },
          timestamp_ms: 12345,
          level: 'info',
        },
        {
          type: 'manual',
          body: {
            hello: 'world',
          },
          timestamp_ms: 88889,
          level: 'info',
        },
      ],
    };
    var options = {};
    t.addTelemetryData(item, options, function (e, i) {
      expect(i.data.body.telemetry.length).to.eql(2);
      expect(i.data.body.telemetry[0].type).to.eql('log');
      done(e);
    });
  });
});

describe('addConfiguredOptions', function () {
  it('adds the configured options', function (done) {
    var item = {
      data: {
        body: {
          message: 'hello world',
        },
        notifier: {
          name: 'rollbar-js',
        },
      },
    };
    var options = {
      accessToken: 'abc123',
      foo: 'bar',
      captureUncaught: true,
      _configuredOptions: {
        accessToken: 'abc123',
        captureUncaught: true,
      },
    };
    t.addConfiguredOptions(item, options, function (e, i) {
      expect(i.data.notifier.configured_options).to.eql({
        captureUncaught: true,
      });
      done(e);
    });
  });
});

describe('userTransform', function () {
  it('calls user transform if is present and a function', function (done) {
    var args = ['a message'];
    var item = itemFromArgs(args);
    var options = {
      endpoint: 'api.rollbar.com',
      transform: function (newItem, item) {
        newItem.origin = item;
        newItem.message = 'HELLO';
      },
    };
    var payload = {
      access_token: '123',
      data: item,
    };
    expect(payload.data.message).to.not.eql('HELLO');
    t.userTransform(fakeLogger)(payload, options, function (e, i) {
      expect(i.data.origin).to.be.an('object');
      expect(i.data.message).to.eql('HELLO');
      done(e);
    });
  });
  it('does nothing if transform is not a function', function (done) {
    var args = ['a message'];
    var item = itemFromArgs(args);
    var options = {
      endpoint: 'api.rollbar.com',
      transform: 'hi there',
    };
    var payload = {
      access_token: '123',
      data: item,
    };
    expect(payload.data.message).to.not.eql('HELLO');
    t.userTransform(fakeLogger)(payload, options, function (e, i) {
      expect(i.data.message).to.not.eql('HELLO');
      done(e);
    });
  });
  it('does nothing if transform throws', function (done) {
    var args = ['a message'];
    var item = itemFromArgs(args);
    var options = {
      endpoint: 'api.rollbar.com',
      transform: function (i) {
        i.data.message = 'HELLO';
        throw 'bork';
      },
    };
    var payload = {
      access_token: '123',
      data: item,
    };
    expect(payload.data.message).to.not.eql('HELLO');
    t.userTransform(fakeLogger)(payload, options, function (e, i) {
      expect(i.data.message).to.not.eql('HELLO');
      expect(options.transform).to.not.be.ok();
      done(e);
    });
  });

  it('waits for promise resolution if transform returns a promise', function (done) {
    var args = ['a message'];
    var item = itemFromArgs(args);
    var payload = {
      access_token: '123',
      data: item,
    };
    var options = {
      endpoint: 'api.rollbar.com',
      transform: function (newItem) {
        newItem.message = 'HELLO';
        return Promise.resolve();
      },
    };
    t.userTransform(fakeLogger)(payload, options, function (e, i) {
      expect(i.data.message).to.eql('HELLO');
      done(e);
    });
    expect(payload.data.message).to.not.eql('HELLO');
  });

  it('uses resolved value if transform returns a promise with a value', function (done) {
    var args = ['a message'];
    var item = itemFromArgs(args);
    var payload = {
      access_token: '123',
      data: item,
    };
    var options = {
      endpoint: 'api.rollbar.com',
      transform: function (newItem) {
        return Promise.resolve({ message: 'HELLO' });
      },
    };
    t.userTransform(fakeLogger)(payload, options, function (e, i) {
      expect(i.data.message).to.eql('HELLO');
      expect(i.data).to.not.eql(item);
      done(e);
    });
    expect(payload.data.message).to.not.eql('HELLO');
  });

  it('uses untransformed value if transform returns a promise that rejects', function (done) {
    var args = ['a message'];
    var item = itemFromArgs(args);
    var err = { message: 'HELLO' };
    var payload = {
      access_token: '123',
      data: item,
    };
    var options = {
      endpoint: 'api.rollbar.com',
      transform: function (newItem) {
        return Promise.reject(err);
      },
    };
    t.userTransform(fakeLogger)(payload, options, function (e, i) {
      expect(i.data.message).to.not.eql('HELLO');
      expect(i.data).to.eql(item);
      expect(e).to.eql(err);
      done();
    });
    expect(payload.data.message).to.not.eql('HELLO');
  });
});