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

var p = require('../src/predicates');
var logger = {
  log: function() {},
  error: function() {}
};

describe('userCheckIgnore', function() {
  it('should return true if no user function', function() {
    var item = {level: 'debug', body: 'stuff', _originalArgs: [1,2,3]};
    var settings = {reportLevel: 'debug'};
    expect(p.userCheckIgnore(logger)(item, settings)).to.be.ok();
  });
  it('should return true if checkIgnore is not a function', function() {
    var item = {level: 'debug', body: 'stuff', _originalArgs: [1,2,3]};
    var settings = {reportLevel: 'debug', checkIgnore: true};
    expect(p.userCheckIgnore(logger)(item, settings)).to.be.ok();
  });
  it('should return true if checkIgnore returns false', function() {
    var item = {level: 'debug', body: 'stuff', _originalArgs: [1,2,3]};
    var settings = {reportLevel: 'debug', checkIgnore: function() {
      return false;
    }};
    expect(p.userCheckIgnore(logger)(item, settings)).to.be.ok();
  });
  it('should return false if checkIgnore returns true', function() {
    var item = {level: 'debug', body: 'stuff', _originalArgs: [1,2,3]};
    var settings = {reportLevel: 'debug', checkIgnore: function() {
      return true;
    }};
    expect(p.userCheckIgnore(logger)(item, settings)).to.not.be.ok();
  });
  it('should return true if checkIgnore throws', function() {
    var item = {level: 'debug', body: 'stuff', _originalArgs: [1,2,3]};
    var settings = {reportLevel: 'debug', checkIgnore: function() {
      throw new Error('bork bork');
    }};
    expect(p.userCheckIgnore(logger)(item, settings)).to.be.ok();
    expect(settings.checkIgnore).to.not.be.ok();
  });
  it('should get the right arguments', function() {
    var item = {level: 'debug', body: 'stuff', _originalArgs: [1,2,3]};
    var settings = {reportLevel: 'debug', checkIgnore: function(isUncaught, args, payload) {
      expect(isUncaught).to.not.be.ok();
      expect(args).to.eql([1,2,3]);
      expect(payload).to.eql(item);
    }};
    expect(p.userCheckIgnore(logger)(item, settings)).to.be.ok();
  });
});

describe('urlIsSafeListed', function() {
  var item = {
    level: 'critical',
    body: {trace: {frames: [
      {filename: 'http://api.fake.com/v1/something'},
      {filename: 'http://api.example.com/v1/something'},
      {filename: 'http://api.fake.com/v2/something'}
    ]}}
  };
  var traceChainItem = {
    level: 'critical',
    body: {trace_chain: [{frames: [
      {filename: 'http://api.fake.com/v1/something'},
      {filename: 'http://api.example.com/v1/something'},
      {filename: 'http://api.fake.com/v2/something'}
    ]},
    {frames: [
      {filename: 'http://api.fake1.com/v2/something'},
      {filename: 'http://api.example1.com/v2/something'},
      {filename: 'http://api.fake1.com/v3/something'}
    ]}
    ]}
  };
  it('should return true with no safelist', function() {
    var settings = {
      reportLevel: 'debug'
    };
    expect(p.urlIsSafeListed(logger)(item, settings)).to.be.ok();
    expect(p.urlIsSafeListed(logger)(traceChainItem, settings)).to.be.ok();
  });
  it('should return true with no trace', function() {
    var item = {
      level: 'critical',
      body: {message: 'hey'}
    };
    var settings = {
      reportLevel: 'debug',
      hostSafeList: ['fake.com', 'example.com']
    };
    expect(p.urlIsSafeListed(logger)(item, settings)).to.be.ok();
  });
  it('should return true if at least one regex matches at least one filename in the trace', function() {
    var settings = {
      reportLevel: 'debug',
      hostSafeList: ['example.com']
    };
    expect(p.urlIsSafeListed(logger)(item, settings)).to.be.ok();
    expect(p.urlIsSafeListed(logger)(traceChainItem, settings)).to.be.ok();
  });
  it('should return true if the filename is not a string', function() {
    var item = {
      level: 'critical',
      body: {trace: {frames: [
        {filename: {url: 'http://api.fake.com/v1/something'}},
        {filename: {url: 'http://api.example.com/v1/something'}},
        {filename: {url: 'http://api.fake.com/v2/something'}},
      ]}}
    };
    var traceChainItem = {
      level: 'critical',
      body: {trace_chain: [{frames: [
        {filename: {url: 'http://api.fake.com/v1/something'}},
        {filename: {url: 'http://api.example.com/v1/something'}},
        {filename: {url: 'http://api.fake.com/v2/something'}},
      ]},
      {frames: [
        {filename: {url: 'http://api.fake.com/v1/something'}},
        {filename: {url: 'http://api.example.com/v1/something'}},
        {filename: {url: 'http://api.fake.com/v2/something'}},
      ]}
      ]}
    };
    var settings = {
      reportLevel: 'debug',
      hostSafeList: ['nope.com']
    };
    expect(p.urlIsSafeListed(logger)(item, settings)).to.be.ok();
    expect(p.urlIsSafeListed(logger)(traceChainItem, settings)).to.be.ok();
  });
  it('should return true if there is no frames key', function() {
    var item = {
      level: 'critical',
      body: {trace: {notframes: []}}
    };
    var traceChainItem = {
      level: 'critical',
      body: {trace_chain: [
        {notframes: []},
        {notframes: []}
      ]}
    };
    var settings = {
      reportLevel: 'debug',
      hostSafeList: ['nope.com']
    };
    expect(p.urlIsSafeListed(logger)(item, settings)).to.be.ok();
    expect(p.urlIsSafeListed(logger)(traceChainItem, settings)).to.be.ok();
  });
  it('should return true if there are no frames', function() {
    var item = {
      level: 'critical',
      body: {trace: {frames: []}}
    };
    var traceChainItem = {
      level: 'critical',
      body: {trace_chain: [
        {frames: []},
        {frames: []}
      ]}
    };
    var settings = {
      reportLevel: 'debug',
      hostSafeList: ['nope.com']
    };
    expect(p.urlIsSafeListed(logger)(item, settings)).to.be.ok();
    expect(p.urlIsSafeListed(logger)(traceChainItem, settings)).to.be.ok();
  });
  it('should return false if nothing in the safelist matches', function() {
    var settings = {
      reportLevel: 'debug',
      hostSafeList: ['baz\.com', 'foo\.com']
    };
    expect(p.urlIsSafeListed(logger)(item, settings)).to.not.be.ok();
    expect(p.urlIsSafeListed(logger)(traceChainItem, settings)).to.not.be.ok();
  });
});

describe('urlIsNotBlockListed', function() {
  var item = {
    level: 'critical',
    body: {trace: {frames: [
      {filename: 'http://api.fake.com/v1/something'},
      {filename: 'http://api.example.com/v1/something'},
      {filename: 'http://api.fake.com/v2/something'}
    ]}}
  };
  var traceChainItem = {
    level: 'critical',
    body: {trace_chain: [{frames: [
      {filename: 'http://api.fake.com/v1/something'},
      {filename: 'http://api.example.com/v1/something'},
      {filename: 'http://api.fake.com/v2/something'}
    ]},
    {frames: [
      {filename: 'http://api.fake1.com/v2/something'},
      {filename: 'http://api.example1.com/v2/something'},
      {filename: 'http://api.fake1.com/v3/something'}
    ]}
    ]}
  };
  it('should return true with no blocklist', function() {
    var settings = {
      reportLevel: 'debug'
    };
    expect(p.urlIsNotBlockListed(logger)(item, settings)).to.be.ok();
    expect(p.urlIsNotBlockListed(logger)(traceChainItem, settings)).to.be.ok();
  });
  it('should return true with no trace', function() {
    var item = {
      level: 'critical',
      body: {message: 'hey'}
    };
    var settings = {
      reportLevel: 'debug',
      hostBlockList: ['fake.com', 'other.com']
    };
    expect(p.urlIsNotBlockListed(logger)(item, settings)).to.be.ok();
  });
  it('should return false if any regex matches at least one filename in the trace', function() {
    var settings = {
      reportLevel: 'debug',
      hostBlockList: ['example.com', 'other.com']
    };
    expect(p.urlIsNotBlockListed(logger)(item, settings)).to.not.be.ok();
    expect(p.urlIsNotBlockListed(logger)(traceChainItem, settings)).to.not.be.ok();
  });
  it('should return true if the filename is not a string', function() {
    var item = {
      level: 'critical',
      body: {trace: {frames: [
        {filename: {url: 'http://api.fake.com/v1/something'}},
        {filename: {url: 'http://api.example.com/v1/something'}},
        {filename: {url: 'http://api.fake.com/v2/something'}},
      ]}}
    };
    var traceChainItem = {
      level: 'critical',
      body: {trace_chain: [{frames: [
        {filename: {url: 'http://api.fake.com/v1/something'}},
        {filename: {url: 'http://api.example.com/v1/something'}},
        {filename: {url: 'http://api.fake.com/v2/something'}},
      ]},
      {frames: [
        {filename: {url: 'http://api.fake.com/v1/something'}},
        {filename: {url: 'http://api.example.com/v1/something'}},
        {filename: {url: 'http://api.fake.com/v2/something'}},
      ]}
      ]}
    };
    var settings = {
      reportLevel: 'debug',
      hostBlockList: ['example.com', 'other.com']
    };
    expect(p.urlIsNotBlockListed(logger)(item, settings)).to.be.ok();
    expect(p.urlIsNotBlockListed(logger)(traceChainItem, settings)).to.be.ok();
  });
  it('should return true if there is no frames key', function() {
    var item = {
      level: 'critical',
      body: {trace: {notframes: []}}
    };
    var traceChainItem = {
      level: 'critical',
      body: {trace_chain: [
        {notframes: []},
        {notframes: []}
      ]}
    };
    var settings = {
      reportLevel: 'debug',
      hostBlockList: ['nope.com']
    };
    expect(p.urlIsNotBlockListed(logger)(item, settings)).to.be.ok();
    expect(p.urlIsNotBlockListed(logger)(traceChainItem, settings)).to.be.ok();
  });
  it('should return true if there are no frames', function() {
    var item = {
      level: 'critical',
      body: {trace: {frames: []}}
    };
    var traceChainItem = {
      level: 'critical',
      body: {trace_chain: [
        {frames: []},
        {frames: []}
      ]}
    };
    var settings = {
      reportLevel: 'debug',
      hostBlockList: ['nope.com']
    };
    expect(p.urlIsNotBlockListed(logger)(item, settings)).to.be.ok();
    expect(p.urlIsNotBlockListed(logger)(traceChainItem, settings)).to.be.ok();
  });
  it('should return true if nothing in the blocklist matches', function() {
    var settings = {
      reportLevel: 'debug',
      hostBlockList: ['baz\.com', 'foo\.com']
    };
    expect(p.urlIsNotBlockListed(logger)(item, settings)).to.be.ok();
    expect(p.urlIsNotBlockListed(logger)(traceChainItem, settings)).to.be.ok();
  });
});

describe('messageIsIgnored', function() {
  it('true if no ignoredMessages setting', function() {
    var item = {
      level: 'critical',
      body: {
        trace: {exception: {message: 'bork bork'}},
        message: {body: 'fuzz'}
      }
    };
    var settings = {
      reportLevel: 'debug'
    };
    expect(p.messageIsIgnored(logger)(item, settings)).to.be.ok();
  });
  it('true if ignoredMessages is empty', function() {
    var item = {
      level: 'critical',
      body: {
        trace: {exception: {message: 'bork bork'}},
        message: {body: 'fuzz'}
      }
    };
    var settings = {
      reportLevel: 'debug',
      ignoredMessages: []
    };
    expect(p.messageIsIgnored(logger)(item, settings)).to.be.ok();
  });
  it('true if no exception message', function() {
    var item = {
      level: 'critical',
      body: {
        trace: {exception: {}},
        message: 'fuzz'
      }
    };
    var settings = {
      reportLevel: 'debug',
      ignoredMessages: ['bork bork', 'fuzz']
    };
    expect(p.messageIsIgnored(logger)(item, settings)).to.be.ok();
  });
  it('true if no ignoredMessages match', function() {
    var item = {
      level: 'critical',
      body: {
        trace: {exception: {message: 'bork bork'}},
        message: {body: 'fuzz'}
      }
    };
    var settings = {
      reportLevel: 'debug',
      ignoredMessages: ['fake', 'stuff']
    };
    expect(p.messageIsIgnored(logger)(item, settings)).to.be.ok();
  });
  it('false if any ignoredMessages match', function() {
    var item = {
      level: 'critical',
      body: {
        trace: {exception: {message: 'bork bork'}},
        message: {body: 'fuzz'}
      }
    };
    var settings = {
      reportLevel: 'debug',
      ignoredMessages: ['bork bork', 'stuff']
    };
    expect(p.messageIsIgnored(logger)(item, settings)).to.not.be.ok();
  });
  it('false if ignoredMessages regex match', function() {
    var item = {
      level: 'critical',
      body: {
        message: {body: 'This is an ignored message'}
      }
    };
    var settings = {
      reportLevel: 'debug',
      ignoredMessages: ['^This is an .{7} message$']
    };
    expect(p.messageIsIgnored(logger)(item, settings)).to.not.be.ok();
  });
  it('false if ignoredMessages literal match', function() {
    var item = {
      level: 'critical',
      body: {
        message: {body: '{"data":{"messages":[{"message":"Unauthorized"}]}}'}
      }
    };
    var settings = {
      reportLevel: 'debug',
      ignoredMessages: ['{"data":{"messages":\\[']
    };
    expect(p.messageIsIgnored(logger)(item, settings)).to.not.be.ok();
  });
  it('false if ignoredMessages more literal regex matches', function() {
    var item = {
      level: 'critical',
      body: {
        message: {body: 'Match these characters: (*+?)'}
      }
    };
    var settings = {
      reportLevel: 'debug',
      ignoredMessages: ['\\(\\*\\+\\?\\)']
    };
    expect(p.messageIsIgnored(logger)(item, settings)).to.not.be.ok();
  });
  it('false if both trace and body message but ignoredMessages only match body', function() {
    var item = {
      level: 'critical',
      body: {
        trace: {exception: {message: 'bork bork'}},
        message: {body: 'fuzz'}
      }
    };
    var settings = {
      reportLevel: 'debug',
      ignoredMessages: ['fuzz', 'stuff']
    };
    expect(p.messageIsIgnored(logger)(item, settings)).to.not.be.ok();
  });
  it('false if ignoredMessages match something in body exception message', function() {
    var item = {
      level: 'critical',
      body: {
        trace: {frames: []},
        message: {body: 'fuzz'}
      }
    };
    var settings = {
      reportLevel: 'debug',
      ignoredMessages: ['stuff', 'fuzz']
    };
    expect(p.messageIsIgnored(logger)(item, settings)).to.not.be.ok();
  });
  it("true if trace_chain doesn't match", function() {
    var item = {
      level: 'critical',
      body: {
        trace_chain: [
          {exception: {message: 'inner bork'}},
          {exception: {message: 'outer bork'}}
        ]
      }
    };
    var settings = {
      reportLevel: 'debug',
      ignoredMessages: ['stuff', 'fuzz']
    };
    expect(p.messageIsIgnored(logger)(item, settings)).to.be.ok();
  });
  it("false if first trace_chain trace matches", function() {
    var item = {
      level: 'critical',
      body: {
        trace_chain: [
          {exception: {message: 'inner stuff'}},
          {exception: {message: 'outer bork'}}
        ]
      }
    };
    var settings = {
      reportLevel: 'debug',
      ignoredMessages: ['stuff', 'fuzz']
    };
    expect(p.messageIsIgnored(logger)(item, settings)).to.not.be.ok();
  });
  it("false if last trace_chain trace matches", function() {
    var item = {
      level: 'critical',
      body: {
        trace_chain: [
          {exception: {message: 'inner bork'}},
          {exception: {message: 'outer fuzz'}}
        ]
      }
    };
    var settings = {
      reportLevel: 'debug',
      ignoredMessages: ['stuff', 'fuzz']
    };
    expect(p.messageIsIgnored(logger)(item, settings)).to.not.be.ok();
  });
});