emailjs-imap-client/dist/client-unit.js

JavaScript IMAP client

"use strict";

var _client = _interopRequireWildcard(require("./client"));

var _emailjsImapHandler = require("emailjs-imap-handler");

var _common = require("./common");

function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

/* eslint-disable no-unused-expressions */
describe('browserbox unit tests', () => {
  var br;
  beforeEach(() => {
    const auth = {
      user: 'baldrian',
      pass: 'sleeper.de'
    };
    br = new _client.default('somehost', 1234, {
      auth,
      logLevel: _common.LOG_LEVEL_NONE
    });
    br.client.socket = {
      send: () => {},
      upgradeToSecure: () => {}
    };
  });
  describe('#_onIdle', () => {
    it('should call enterIdle', () => {
      sinon.stub(br, 'enterIdle');
      br._authenticated = true;
      br._enteredIdle = false;

      br._onIdle();

      expect(br.enterIdle.callCount).to.equal(1);
    });
    it('should not call enterIdle', () => {
      sinon.stub(br, 'enterIdle');
      br._enteredIdle = true;

      br._onIdle();

      expect(br.enterIdle.callCount).to.equal(0);
    });
  });
  describe('#openConnection', () => {
    beforeEach(() => {
      sinon.stub(br.client, 'connect');
      sinon.stub(br.client, 'close');
      sinon.stub(br.client, 'enqueueCommand');
    });
    it('should open connection', () => {
      br.client.connect.returns(Promise.resolve());
      br.client.enqueueCommand.returns(Promise.resolve({
        capability: ['capa1', 'capa2']
      }));
      setTimeout(() => br.client.onready(), 0);
      return br.openConnection().then(() => {
        expect(br.client.connect.calledOnce).to.be.true;
        expect(br.client.enqueueCommand.calledOnce).to.be.true;
        expect(br._capability.length).to.equal(2);
        expect(br._capability[0]).to.equal('capa1');
        expect(br._capability[1]).to.equal('capa2');
      });
    });
  });
  describe('#connect', () => {
    beforeEach(() => {
      sinon.stub(br.client, 'connect');
      sinon.stub(br.client, 'close');
      sinon.stub(br, 'updateCapability');
      sinon.stub(br, 'upgradeConnection');
      sinon.stub(br, 'updateId');
      sinon.stub(br, 'login');
      sinon.stub(br, 'compressConnection');
    });
    it('should connect', () => {
      br.client.connect.returns(Promise.resolve());
      br.updateCapability.returns(Promise.resolve());
      br.upgradeConnection.returns(Promise.resolve());
      br.updateId.returns(Promise.resolve());
      br.login.returns(Promise.resolve());
      br.compressConnection.returns(Promise.resolve());
      setTimeout(() => br.client.onready(), 0);
      return br.connect().then(() => {
        expect(br.client.connect.calledOnce).to.be.true;
        expect(br.updateCapability.calledOnce).to.be.true;
        expect(br.upgradeConnection.calledOnce).to.be.true;
        expect(br.updateId.calledOnce).to.be.true;
        expect(br.login.calledOnce).to.be.true;
        expect(br.compressConnection.calledOnce).to.be.true;
      });
    });
    it('should fail to login', done => {
      br.client.connect.returns(Promise.resolve());
      br.updateCapability.returns(Promise.resolve());
      br.upgradeConnection.returns(Promise.resolve());
      br.updateId.returns(Promise.resolve());
      br.login.throws(new Error());
      setTimeout(() => br.client.onready(), 0);
      br.connect().catch(err => {
        expect(err).to.exist;
        expect(br.client.connect.calledOnce).to.be.true;
        expect(br.client.close.calledOnce).to.be.true;
        expect(br.updateCapability.calledOnce).to.be.true;
        expect(br.upgradeConnection.calledOnce).to.be.true;
        expect(br.updateId.calledOnce).to.be.true;
        expect(br.login.calledOnce).to.be.true;
        expect(br.compressConnection.called).to.be.false;
        done();
      });
    });
    it('should timeout', done => {
      br.client.connect.returns(Promise.resolve());
      br.timeoutConnection = 1;
      br.connect().catch(err => {
        expect(err).to.exist;
        expect(br.client.connect.calledOnce).to.be.true;
        expect(br.client.close.calledOnce).to.be.true;
        expect(br.updateCapability.called).to.be.false;
        expect(br.upgradeConnection.called).to.be.false;
        expect(br.updateId.called).to.be.false;
        expect(br.login.called).to.be.false;
        expect(br.compressConnection.called).to.be.false;
        done();
      });
    });
  });
  describe('#close', () => {
    it('should force-close', () => {
      sinon.stub(br.client, 'close').returns(Promise.resolve());
      return br.close().then(() => {
        expect(br._state).to.equal(_client.STATE_LOGOUT);
        expect(br.client.close.calledOnce).to.be.true;
      });
    });
  });
  describe('#exec', () => {
    beforeEach(() => {
      sinon.stub(br, 'breakIdle');
    });
    it('should send string command', () => {
      sinon.stub(br.client, 'enqueueCommand').returns(Promise.resolve({}));
      return br.exec('TEST').then(res => {
        expect(res).to.deep.equal({});
        expect(br.client.enqueueCommand.args[0][0]).to.equal('TEST');
      });
    });
    it('should update capability from response', () => {
      sinon.stub(br.client, 'enqueueCommand').returns(Promise.resolve({
        capability: ['A', 'B']
      }));
      return br.exec('TEST').then(res => {
        expect(res).to.deep.equal({
          capability: ['A', 'B']
        });
        expect(br._capability).to.deep.equal(['A', 'B']);
      });
    });
  });
  describe('#enterIdle', () => {
    it('should periodically send NOOP if IDLE not supported', done => {
      sinon.stub(br, 'exec').callsFake(command => {
        expect(command).to.equal('NOOP');
        done();
      });
      br._capability = [];
      br._selectedMailbox = 'FOO';
      br.timeoutNoop = 1;
      br.enterIdle();
    });
    it('should periodically send NOOP if no mailbox selected', done => {
      sinon.stub(br, 'exec').callsFake(command => {
        expect(command).to.equal('NOOP');
        done();
      });
      br._capability = ['IDLE'];
      br._selectedMailbox = undefined;
      br.timeoutNoop = 1;
      br.enterIdle();
    });
    it('should break IDLE after timeout', done => {
      sinon.stub(br.client, 'enqueueCommand');
      sinon.stub(br.client.socket, 'send').callsFake(payload => {
        expect(br.client.enqueueCommand.args[0][0].command).to.equal('IDLE');
        expect([].slice.call(new Uint8Array(payload))).to.deep.equal([0x44, 0x4f, 0x4e, 0x45, 0x0d, 0x0a]);
        done();
      });
      br._capability = ['IDLE'];
      br._selectedMailbox = 'FOO';
      br.timeoutIdle = 1;
      br.enterIdle();
    });
  });
  describe('#breakIdle', () => {
    it('should send DONE to socket', () => {
      sinon.stub(br.client.socket, 'send');
      br._enteredIdle = 'IDLE';
      br.breakIdle();
      expect([].slice.call(new Uint8Array(br.client.socket.send.args[0][0]))).to.deep.equal([0x44, 0x4f, 0x4e, 0x45, 0x0d, 0x0a]);
    });
  });
  describe('#upgradeConnection', () => {
    it('should do nothing if already secured', () => {
      br.client.secureMode = true;
      br._capability = ['starttls'];
      return br.upgradeConnection();
    });
    it('should do nothing if STARTTLS not available', () => {
      br.client.secureMode = false;
      br._capability = [];
      return br.upgradeConnection();
    });
    it('should run STARTTLS', () => {
      sinon.stub(br.client, 'upgrade');
      sinon.stub(br, 'exec').withArgs('STARTTLS').returns(Promise.resolve());
      sinon.stub(br, 'updateCapability').returns(Promise.resolve());
      br._capability = ['STARTTLS'];
      return br.upgradeConnection().then(() => {
        expect(br.client.upgrade.callCount).to.equal(1);
        expect(br._capability.length).to.equal(0);
      });
    });
  });
  describe('#updateCapability', () => {
    beforeEach(() => {
      sinon.stub(br, 'exec');
    });
    it('should do nothing if capability is set', () => {
      br._capability = ['abc'];
      return br.updateCapability();
    });
    it('should run CAPABILITY if capability not set', () => {
      br.exec.returns(Promise.resolve());
      br._capability = [];
      return br.updateCapability().then(() => {
        expect(br.exec.args[0][0]).to.equal('CAPABILITY');
      });
    });
    it('should force run CAPABILITY', () => {
      br.exec.returns(Promise.resolve());
      br._capability = ['abc'];
      return br.updateCapability(true).then(() => {
        expect(br.exec.args[0][0]).to.equal('CAPABILITY');
      });
    });
    it('should do nothing if connection is not yet upgraded', () => {
      br._capability = [];
      br.client.secureMode = false;
      br._requireTLS = true;
      br.updateCapability();
    });
  });
  describe('#listNamespaces', () => {
    beforeEach(() => {
      sinon.stub(br, 'exec');
    });
    it('should run NAMESPACE if supported', () => {
      br.exec.returns(Promise.resolve({
        payload: {
          NAMESPACE: [{
            attributes: [[[{
              type: 'STRING',
              value: 'INBOX.'
            }, {
              type: 'STRING',
              value: '.'
            }]], null, null]
          }]
        }
      }));
      br._capability = ['NAMESPACE'];
      return br.listNamespaces().then(namespaces => {
        expect(namespaces).to.deep.equal({
          personal: [{
            prefix: 'INBOX.',
            delimiter: '.'
          }],
          users: false,
          shared: false
        });
        expect(br.exec.args[0][0]).to.equal('NAMESPACE');
        expect(br.exec.args[0][1]).to.equal('NAMESPACE');
      });
    });
    it('should do nothing if not supported', () => {
      br._capability = [];
      return br.listNamespaces().then(namespaces => {
        expect(namespaces).to.be.false;
        expect(br.exec.callCount).to.equal(0);
      });
    });
  });
  describe('#compressConnection', () => {
    beforeEach(() => {
      sinon.stub(br, 'exec');
      sinon.stub(br.client, 'enableCompression');
    });
    it('should run COMPRESS=DEFLATE if supported', () => {
      br.exec.withArgs({
        command: 'COMPRESS',
        attributes: [{
          type: 'ATOM',
          value: 'DEFLATE'
        }]
      }).returns(Promise.resolve({}));
      br._enableCompression = true;
      br._capability = ['COMPRESS=DEFLATE'];
      return br.compressConnection().then(() => {
        expect(br.exec.callCount).to.equal(1);
        expect(br.client.enableCompression.callCount).to.equal(1);
      });
    });
    it('should do nothing if not supported', () => {
      br._capability = [];
      return br.compressConnection().then(() => {
        expect(br.exec.callCount).to.equal(0);
      });
    });
    it('should do nothing if not enabled', () => {
      br._enableCompression = false;
      br._capability = ['COMPRESS=DEFLATE'];
      return br.compressConnection().then(() => {
        expect(br.exec.callCount).to.equal(0);
      });
    });
  });
  describe('#login', () => {
    it('should call LOGIN', () => {
      sinon.stub(br, 'exec').returns(Promise.resolve({}));
      sinon.stub(br, 'updateCapability').returns(Promise.resolve(true));
      return br.login({
        user: 'u1',
        pass: 'p1'
      }).then(() => {
        expect(br.exec.callCount).to.equal(1);
        expect(br.exec.args[0][0]).to.deep.equal({
          command: 'login',
          attributes: [{
            type: 'STRING',
            value: 'u1'
          }, {
            type: 'STRING',
            value: 'p1',
            sensitive: true
          }]
        });
      });
    });
    it('should call XOAUTH2', () => {
      sinon.stub(br, 'exec').returns(Promise.resolve({}));
      sinon.stub(br, 'updateCapability').returns(Promise.resolve(true));
      br._capability = ['AUTH=XOAUTH2'];
      br.login({
        user: 'u1',
        xoauth2: 'abc'
      }).then(() => {
        expect(br.exec.callCount).to.equal(1);
        expect(br.exec.args[0][0]).to.deep.equal({
          command: 'AUTHENTICATE',
          attributes: [{
            type: 'ATOM',
            value: 'XOAUTH2'
          }, {
            type: 'ATOM',
            value: 'dXNlcj11MQFhdXRoPUJlYXJlciBhYmMBAQ==',
            sensitive: true
          }]
        });
      });
    });
  });
  describe('#updateId', () => {
    beforeEach(() => {
      sinon.stub(br, 'exec');
    });
    it('should not nothing if not supported', () => {
      br._capability = [];
      return br.updateId({
        a: 'b',
        c: 'd'
      }).then(() => {
        expect(br.serverId).to.be.false;
      });
    });
    it('should send NIL', () => {
      br.exec.withArgs({
        command: 'ID',
        attributes: [null]
      }).returns(Promise.resolve({
        payload: {
          ID: [{
            attributes: [null]
          }]
        }
      }));
      br._capability = ['ID'];
      return br.updateId(null).then(() => {
        expect(br.serverId).to.deep.equal({});
      });
    });
    it('should exhange ID values', () => {
      br.exec.withArgs({
        command: 'ID',
        attributes: [['ckey1', 'cval1', 'ckey2', 'cval2']]
      }).returns(Promise.resolve({
        payload: {
          ID: [{
            attributes: [[{
              value: 'skey1'
            }, {
              value: 'sval1'
            }, {
              value: 'skey2'
            }, {
              value: 'sval2'
            }]]
          }]
        }
      }));
      br._capability = ['ID'];
      return br.updateId({
        ckey1: 'cval1',
        ckey2: 'cval2'
      }).then(() => {
        expect(br.serverId).to.deep.equal({
          skey1: 'sval1',
          skey2: 'sval2'
        });
      });
    });
  });
  describe('#listMailboxes', () => {
    beforeEach(() => {
      sinon.stub(br, 'exec');
    });
    it('should call LIST and LSUB in sequence', () => {
      br.exec.withArgs({
        command: 'LIST',
        attributes: ['', '*']
      }).returns(Promise.resolve({
        payload: {
          LIST: [false]
        }
      }));
      br.exec.withArgs({
        command: 'LSUB',
        attributes: ['', '*']
      }).returns(Promise.resolve({
        payload: {
          LSUB: [false]
        }
      }));
      return br.listMailboxes().then(tree => {
        expect(tree).to.exist;
      });
    });
    it('should not die on NIL separators', () => {
      br.exec.withArgs({
        command: 'LIST',
        attributes: ['', '*']
      }).returns(Promise.resolve({
        payload: {
          LIST: [(0, _emailjsImapHandler.parser)((0, _common.toTypedArray)('* LIST (\\NoInferiors) NIL "INBOX"'))]
        }
      }));
      br.exec.withArgs({
        command: 'LSUB',
        attributes: ['', '*']
      }).returns(Promise.resolve({
        payload: {
          LSUB: [(0, _emailjsImapHandler.parser)((0, _common.toTypedArray)('* LSUB (\\NoInferiors) NIL "INBOX"'))]
        }
      }));
      return br.listMailboxes().then(tree => {
        expect(tree).to.exist;
      });
    });
  });
  describe('#createMailbox', () => {
    beforeEach(() => {
      sinon.stub(br, 'exec');
    });
    it('should call CREATE with a string payload', () => {
      // The spec allows unquoted ATOM-style syntax too, but for
      // simplicity we always generate a string even if it could be
      // expressed as an atom.
      br.exec.withArgs({
        command: 'CREATE',
        attributes: ['mailboxname']
      }).returns(Promise.resolve());
      return br.createMailbox('mailboxname').then(() => {
        expect(br.exec.callCount).to.equal(1);
      });
    });
    it('should call mutf7 encode the argument', () => {
      // From RFC 3501
      br.exec.withArgs({
        command: 'CREATE',
        attributes: ['~peter/mail/&U,BTFw-/&ZeVnLIqe-']
      }).returns(Promise.resolve());
      return br.createMailbox('~peter/mail/\u53f0\u5317/\u65e5\u672c\u8a9e').then(() => {
        expect(br.exec.callCount).to.equal(1);
      });
    });
    it('should treat an ALREADYEXISTS response as success', () => {
      var fakeErr = {
        code: 'ALREADYEXISTS'
      };
      br.exec.withArgs({
        command: 'CREATE',
        attributes: ['mailboxname']
      }).returns(Promise.reject(fakeErr));
      return br.createMailbox('mailboxname').then(() => {
        expect(br.exec.callCount).to.equal(1);
      });
    });
  });
  describe('#deleteMailbox', () => {
    beforeEach(() => {
      sinon.stub(br, 'exec');
    });
    it('should call DELETE with a string payload', () => {
      br.exec.withArgs({
        command: 'DELETE',
        attributes: ['mailboxname']
      }).returns(Promise.resolve());
      return br.deleteMailbox('mailboxname').then(() => {
        expect(br.exec.callCount).to.equal(1);
      });
    });
    it('should call mutf7 encode the argument', () => {
      // From RFC 3501
      br.exec.withArgs({
        command: 'DELETE',
        attributes: ['~peter/mail/&U,BTFw-/&ZeVnLIqe-']
      }).returns(Promise.resolve());
      return br.deleteMailbox('~peter/mail/\u53f0\u5317/\u65e5\u672c\u8a9e').then(() => {
        expect(br.exec.callCount).to.equal(1);
      });
    });
  });
  describe.skip('#listMessages', () => {
    beforeEach(() => {
      sinon.stub(br, 'exec');
      sinon.stub(br, '_buildFETCHCommand');
      sinon.stub(br, '_parseFETCH');
    });
    it('should call FETCH', () => {
      br.exec.returns(Promise.resolve('abc'));

      br._buildFETCHCommand.withArgs(['1:2', ['uid', 'flags'], {
        byUid: true
      }]).returns({});

      return br.listMessages('INBOX', '1:2', ['uid', 'flags'], {
        byUid: true
      }).then(() => {
        expect(br._buildFETCHCommand.callCount).to.equal(1);
        expect(br._parseFETCH.withArgs('abc').callCount).to.equal(1);
      });
    });
  });
  describe.skip('#search', () => {
    beforeEach(() => {
      sinon.stub(br, 'exec');
      sinon.stub(br, '_buildSEARCHCommand');
      sinon.stub(br, '_parseSEARCH');
    });
    it('should call SEARCH', () => {
      br.exec.returns(Promise.resolve('abc'));

      br._buildSEARCHCommand.withArgs({
        uid: 1
      }, {
        byUid: true
      }).returns({});

      return br.search('INBOX', {
        uid: 1
      }, {
        byUid: true
      }).then(() => {
        expect(br._buildSEARCHCommand.callCount).to.equal(1);
        expect(br.exec.callCount).to.equal(1);
        expect(br._parseSEARCH.withArgs('abc').callCount).to.equal(1);
      });
    });
  });
  describe('#upload', () => {
    beforeEach(() => {
      sinon.stub(br, 'exec');
    });
    it('should call APPEND with custom flag', () => {
      br.exec.returns(Promise.resolve());
      return br.upload('mailbox', 'this is a message', {
        flags: ['\\$MyFlag']
      }).then(() => {
        expect(br.exec.callCount).to.equal(1);
      });
    });
    it('should call APPEND w/o flags', () => {
      br.exec.returns(Promise.resolve());
      return br.upload('mailbox', 'this is a message').then(() => {
        expect(br.exec.callCount).to.equal(1);
      });
    });
  });
  describe.skip('#setFlags', () => {
    beforeEach(() => {
      sinon.stub(br, 'exec');
      sinon.stub(br, '_buildSTORECommand');
      sinon.stub(br, '_parseFETCH');
    });
    it('should call STORE', () => {
      br.exec.returns(Promise.resolve('abc'));

      br._buildSTORECommand.withArgs('1:2', 'FLAGS', ['\\Seen', '$MyFlag'], {
        byUid: true
      }).returns({});

      return br.setFlags('INBOX', '1:2', ['\\Seen', '$MyFlag'], {
        byUid: true
      }).then(() => {
        expect(br.exec.callCount).to.equal(1);
        expect(br._parseFETCH.withArgs('abc').callCount).to.equal(1);
      });
    });
  });
  describe.skip('#store', () => {
    beforeEach(() => {
      sinon.stub(br, 'exec');
      sinon.stub(br, '_buildSTORECommand');
      sinon.stub(br, '_parseFETCH');
    });
    it('should call STORE', () => {
      br.exec.returns(Promise.resolve('abc'));

      br._buildSTORECommand.withArgs('1:2', '+X-GM-LABELS', ['\\Sent', '\\Junk'], {
        byUid: true
      }).returns({});

      return br.store('INBOX', '1:2', '+X-GM-LABELS', ['\\Sent', '\\Junk'], {
        byUid: true
      }).then(() => {
        expect(br._buildSTORECommand.callCount).to.equal(1);
        expect(br.exec.callCount).to.equal(1);
        expect(br._parseFETCH.withArgs('abc').callCount).to.equal(1);
      });
    });
  });
  describe('#deleteMessages', () => {
    beforeEach(() => {
      sinon.stub(br, 'setFlags');
      sinon.stub(br, 'exec');
    });
    it('should call UID EXPUNGE', () => {
      br.exec.withArgs({
        command: 'UID EXPUNGE',
        attributes: [{
          type: 'sequence',
          value: '1:2'
        }]
      }).returns(Promise.resolve('abc'));
      br.setFlags.withArgs('INBOX', '1:2', {
        add: '\\Deleted'
      }).returns(Promise.resolve());
      br._capability = ['UIDPLUS'];
      return br.deleteMessages('INBOX', '1:2', {
        byUid: true
      }).then(() => {
        expect(br.exec.callCount).to.equal(1);
      });
    });
    it('should call EXPUNGE', () => {
      br.exec.withArgs('EXPUNGE').returns(Promise.resolve('abc'));
      br.setFlags.withArgs('INBOX', '1:2', {
        add: '\\Deleted'
      }).returns(Promise.resolve());
      br._capability = [];
      return br.deleteMessages('INBOX', '1:2', {
        byUid: true
      }).then(() => {
        expect(br.exec.callCount).to.equal(1);
      });
    });
  });
  describe('#copyMessages', () => {
    beforeEach(() => {
      sinon.stub(br, 'exec');
    });
    it('should call COPY', () => {
      br.exec.withArgs({
        command: 'UID COPY',
        attributes: [{
          type: 'sequence',
          value: '1:2'
        }, {
          type: 'atom',
          value: '[Gmail]/Trash'
        }]
      }).returns(Promise.resolve({
        copyuid: ['1', '1:2', '4,3']
      }));
      return br.copyMessages('INBOX', '1:2', '[Gmail]/Trash', {
        byUid: true
      }).then(response => {
        expect(response).to.deep.equal({
          srcSeqSet: '1:2',
          destSeqSet: '4,3'
        });
        expect(br.exec.callCount).to.equal(1);
      });
    });
  });
  describe('#moveMessages', () => {
    beforeEach(() => {
      sinon.stub(br, 'exec');
      sinon.stub(br, 'copyMessages');
      sinon.stub(br, 'deleteMessages');
    });
    it('should call MOVE if supported', () => {
      br.exec.withArgs({
        command: 'UID MOVE',
        attributes: [{
          type: 'sequence',
          value: '1:2'
        }, {
          type: 'atom',
          value: '[Gmail]/Trash'
        }]
      }, ['OK']).returns(Promise.resolve('abc'));
      br._capability = ['MOVE'];
      return br.moveMessages('INBOX', '1:2', '[Gmail]/Trash', {
        byUid: true
      }).then(() => {
        expect(br.exec.callCount).to.equal(1);
      });
    });
    it('should fallback to copy+expunge', () => {
      br.copyMessages.withArgs('INBOX', '1:2', '[Gmail]/Trash', {
        byUid: true
      }).returns(Promise.resolve());
      br.deleteMessages.withArgs('1:2', {
        byUid: true
      }).returns(Promise.resolve());
      br._capability = [];
      return br.moveMessages('INBOX', '1:2', '[Gmail]/Trash', {
        byUid: true
      }).then(() => {
        expect(br.deleteMessages.callCount).to.equal(1);
      });
    });
  });
  describe('#_shouldSelectMailbox', () => {
    it('should return true when ctx is undefined', () => {
      expect(br._shouldSelectMailbox('path')).to.be.true;
    });
    it('should return true when a different path is queued', () => {
      sinon.stub(br.client, 'getPreviouslyQueued').returns({
        request: {
          command: 'SELECT',
          attributes: [{
            type: 'STRING',
            value: 'queued path'
          }]
        }
      });
      expect(br._shouldSelectMailbox('path', {})).to.be.true;
    });
    it('should return false when the same path is queued', () => {
      sinon.stub(br.client, 'getPreviouslyQueued').returns({
        request: {
          command: 'SELECT',
          attributes: [{
            type: 'STRING',
            value: 'queued path'
          }]
        }
      });
      expect(br._shouldSelectMailbox('queued path', {})).to.be.false;
    });
  });
  describe('#selectMailbox', () => {
    const path = '[Gmail]/Trash';
    beforeEach(() => {
      sinon.stub(br, 'exec');
    });
    it('should run SELECT', () => {
      br.exec.withArgs({
        command: 'SELECT',
        attributes: [{
          type: 'STRING',
          value: path
        }]
      }).returns(Promise.resolve({
        code: 'READ-WRITE'
      }));
      return br.selectMailbox(path).then(() => {
        expect(br.exec.callCount).to.equal(1);
        expect(br._state).to.equal(_client.STATE_SELECTED);
      });
    });
    it('should run SELECT with CONDSTORE', () => {
      br.exec.withArgs({
        command: 'SELECT',
        attributes: [{
          type: 'STRING',
          value: path
        }, [{
          type: 'ATOM',
          value: 'CONDSTORE'
        }]]
      }).returns(Promise.resolve({
        code: 'READ-WRITE'
      }));
      br._capability = ['CONDSTORE'];
      return br.selectMailbox(path, {
        condstore: true
      }).then(() => {
        expect(br.exec.callCount).to.equal(1);
        expect(br._state).to.equal(_client.STATE_SELECTED);
      });
    });
    describe('should emit onselectmailbox before selectMailbox is resolved', () => {
      beforeEach(() => {
        br.exec.returns(Promise.resolve({
          code: 'READ-WRITE'
        }));
      });
      it('when it returns a promise', () => {
        var promiseResolved = false;

        br.onselectmailbox = () => new Promise(resolve => {
          resolve();
          promiseResolved = true;
        });

        var onselectmailboxSpy = sinon.spy(br, 'onselectmailbox');
        return br.selectMailbox(path).then(() => {
          expect(onselectmailboxSpy.withArgs(path).callCount).to.equal(1);
          expect(promiseResolved).to.equal(true);
        });
      });
      it('when it does not return a promise', () => {
        br.onselectmailbox = () => {};

        var onselectmailboxSpy = sinon.spy(br, 'onselectmailbox');
        return br.selectMailbox(path).then(() => {
          expect(onselectmailboxSpy.withArgs(path).callCount).to.equal(1);
        });
      });
    });
    it('should emit onclosemailbox', () => {
      let called = false;
      br.exec.returns(Promise.resolve('abc')).returns(Promise.resolve({
        code: 'READ-WRITE'
      }));

      br.onclosemailbox = path => {
        expect(path).to.equal('yyy');
        called = true;
      };

      br._selectedMailbox = 'yyy';
      return br.selectMailbox(path).then(() => {
        expect(called).to.be.true;
      });
    });
  });
  describe('#hasCapability', () => {
    it('should detect existing capability', () => {
      br._capability = ['ZZZ'];
      expect(br.hasCapability('zzz')).to.be.true;
    });
    it('should detect non existing capability', () => {
      br._capability = ['ZZZ'];
      expect(br.hasCapability('ooo')).to.be.false;
      expect(br.hasCapability()).to.be.false;
    });
  });
  describe('#_untaggedOkHandler', () => {
    it('should update capability if present', () => {
      br._untaggedOkHandler({
        capability: ['abc']
      }, () => {});

      expect(br._capability).to.deep.equal(['abc']);
    });
  });
  describe('#_untaggedCapabilityHandler', () => {
    it('should update capability', () => {
      br._untaggedCapabilityHandler({
        attributes: [{
          value: 'abc'
        }]
      }, () => {});

      expect(br._capability).to.deep.equal(['ABC']);
    });
  });
  describe('#_untaggedExistsHandler', () => {
    it('should emit onupdate', () => {
      br.onupdate = sinon.stub();
      br._selectedMailbox = 'FOO';

      br._untaggedExistsHandler({
        nr: 123
      }, () => {});

      expect(br.onupdate.withArgs('FOO', 'exists', 123).callCount).to.equal(1);
    });
  });
  describe('#_untaggedExpungeHandler', () => {
    it('should emit onupdate', () => {
      br.onupdate = sinon.stub();
      br._selectedMailbox = 'FOO';

      br._untaggedExpungeHandler({
        nr: 123
      }, () => {});

      expect(br.onupdate.withArgs('FOO', 'expunge', 123).callCount).to.equal(1);
    });
  });
  describe.skip('#_untaggedFetchHandler', () => {
    it('should emit onupdate', () => {
      br.onupdate = sinon.stub();
      sinon.stub(br, '_parseFETCH').returns('abc');
      br._selectedMailbox = 'FOO';

      br._untaggedFetchHandler({
        nr: 123
      }, () => {});

      expect(br.onupdate.withArgs('FOO', 'fetch', 'abc').callCount).to.equal(1);
      expect(br._parseFETCH.args[0][0]).to.deep.equal({
        payload: {
          FETCH: [{
            nr: 123
          }]
        }
      });
    });
  });
  describe('#_changeState', () => {
    it('should set the state value', () => {
      br._changeState(12345);

      expect(br._state).to.equal(12345);
    });
    it('should emit onclosemailbox if mailbox was closed', () => {
      br.onclosemailbox = sinon.stub();
      br._state = _client.STATE_SELECTED;
      br._selectedMailbox = 'aaa';

      br._changeState(12345);

      expect(br._selectedMailbox).to.be.false;
      expect(br.onclosemailbox.withArgs('aaa').callCount).to.equal(1);
    });
  });
  describe('#_ensurePath', () => {
    it('should create the path if not present', () => {
      var tree = {
        children: []
      };
      expect(br._ensurePath(tree, 'hello/world', '/')).to.deep.equal({
        name: 'world',
        delimiter: '/',
        path: 'hello/world',
        children: []
      });
      expect(tree).to.deep.equal({
        children: [{
          name: 'hello',
          delimiter: '/',
          path: 'hello',
          children: [{
            name: 'world',
            delimiter: '/',
            path: 'hello/world',
            children: []
          }]
        }]
      });
    });
    it('should return existing path if possible', () => {
      var tree = {
        children: [{
          name: 'hello',
          delimiter: '/',
          path: 'hello',
          children: [{
            name: 'world',
            delimiter: '/',
            path: 'hello/world',
            children: [],
            abc: 123
          }]
        }]
      };
      expect(br._ensurePath(tree, 'hello/world', '/')).to.deep.equal({
        name: 'world',
        delimiter: '/',
        path: 'hello/world',
        children: [],
        abc: 123
      });
    });
    it('should handle case insensitive Inbox', () => {
      var tree = {
        children: []
      };
      expect(br._ensurePath(tree, 'Inbox/world', '/')).to.deep.equal({
        name: 'world',
        delimiter: '/',
        path: 'Inbox/world',
        children: []
      });
      expect(br._ensurePath(tree, 'INBOX/worlds', '/')).to.deep.equal({
        name: 'worlds',
        delimiter: '/',
        path: 'INBOX/worlds',
        children: []
      });
      expect(tree).to.deep.equal({
        children: [{
          name: 'Inbox',
          delimiter: '/',
          path: 'Inbox',
          children: [{
            name: 'world',
            delimiter: '/',
            path: 'Inbox/world',
            children: []
          }, {
            name: 'worlds',
            delimiter: '/',
            path: 'INBOX/worlds',
            children: []
          }]
        }]
      });
    });
  });
  describe('untagged updates', () => {
    it('should receive information about untagged exists', done => {
      br.client._connectionReady = true;
      br._selectedMailbox = 'FOO';

      br.onupdate = (path, type, value) => {
        expect(path).to.equal('FOO');
        expect(type).to.equal('exists');
        expect(value).to.equal(123);
        done();
      };

      br.client._onData({
        /* * 123 EXISTS\r\n */
        data: new Uint8Array([42, 32, 49, 50, 51, 32, 69, 88, 73, 83, 84, 83, 13, 10]).buffer
      });
    });
    it('should receive information about untagged expunge', done => {
      br.client._connectionReady = true;
      br._selectedMailbox = 'FOO';

      br.onupdate = (path, type, value) => {
        expect(path).to.equal('FOO');
        expect(type).to.equal('expunge');
        expect(value).to.equal(456);
        done();
      };

      br.client._onData({
        /* * 456 EXPUNGE\r\n */
        data: new Uint8Array([42, 32, 52, 53, 54, 32, 69, 88, 80, 85, 78, 71, 69, 13, 10]).buffer
      });
    });
    it('should receive information about untagged fetch', done => {
      br.client._connectionReady = true;
      br._selectedMailbox = 'FOO';

      br.onupdate = (path, type, value) => {
        expect(path).to.equal('FOO');
        expect(type).to.equal('fetch');
        expect(value).to.deep.equal({
          '#': 123,
          flags: ['\\Seen'],
          modseq: '4'
        });
        done();
      };

      br.client._onData({
        /* * 123 FETCH (FLAGS (\\Seen) MODSEQ (4))\r\n */
        data: new Uint8Array([42, 32, 49, 50, 51, 32, 70, 69, 84, 67, 72, 32, 40, 70, 76, 65, 71, 83, 32, 40, 92, 83, 101, 101, 110, 41, 32, 77, 79, 68, 83, 69, 81, 32, 40, 52, 41, 41, 13, 10]).buffer
      });
    });
  });
});
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/client-unit.js"],"names":["describe","br","beforeEach","auth","user","pass","ImapClient","logLevel","client","socket","send","upgradeToSecure","it","sinon","stub","_authenticated","_enteredIdle","_onIdle","expect","enterIdle","callCount","to","equal","connect","returns","Promise","resolve","enqueueCommand","capability","setTimeout","onready","openConnection","then","calledOnce","be","true","_capability","length","updateCapability","upgradeConnection","updateId","login","compressConnection","done","throws","Error","catch","err","exist","close","called","false","timeoutConnection","_state","STATE_LOGOUT","exec","res","deep","args","callsFake","command","_selectedMailbox","timeoutNoop","undefined","payload","slice","call","Uint8Array","timeoutIdle","breakIdle","secureMode","withArgs","upgrade","_requireTLS","NAMESPACE","attributes","type","value","listNamespaces","namespaces","personal","prefix","delimiter","users","shared","_enableCompression","enableCompression","sensitive","xoauth2","a","c","serverId","ID","ckey1","ckey2","skey1","skey2","LIST","LSUB","listMailboxes","tree","createMailbox","fakeErr","code","reject","deleteMailbox","skip","_buildFETCHCommand","byUid","listMessages","_parseFETCH","_buildSEARCHCommand","uid","search","_parseSEARCH","upload","flags","_buildSTORECommand","setFlags","store","add","deleteMessages","copyuid","copyMessages","response","srcSeqSet","destSeqSet","moveMessages","_shouldSelectMailbox","request","path","selectMailbox","STATE_SELECTED","condstore","promiseResolved","onselectmailbox","onselectmailboxSpy","spy","onclosemailbox","hasCapability","_untaggedOkHandler","_untaggedCapabilityHandler","onupdate","_untaggedExistsHandler","nr","_untaggedExpungeHandler","_untaggedFetchHandler","FETCH","_changeState","children","_ensurePath","name","abc","_connectionReady","_onData","data","buffer","modseq"],"mappings":"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