Test on command line and Vagrant

.travis.yml

+language: node_js
+
+node_js:
+  - "6.2"
+
+sudo: required
+
+before_script:
+  - echo "PLACE_HOLDER"
+
+script:
+  - npm run test

Vagrantfile

 # -*- mode: ruby -*-
 # vi: set ft=ruby :
 
-# All Vagrant configuration is done below. The "2" in Vagrant.configure
-# configures the configuration version (we support older styles for
-# backwards compatibility). Please don't change it unless you know what
-# you're doing.
 Vagrant.configure(2) do |config|
-  # The most common configuration options are documented and commented below.
-  # For a complete reference, please see the online documentation at
-  # https://docs.vagrantup.com.
-
   # Every Vagrant development environment requires a box. You can search for
   # boxes at https://atlas.hashicorp.com/search.
   config.vm.box = "bento/centos-7.2"
@@ -25,21 +17,18 @@ Vagrant.configure(2) do |config|
   config.vm.network 'private_network', ip: '192.168.50.10'
   config.vm.hostname = 'zimbra.zboxapp.dev'
   config.vm.network 'forwarded_port', guest: 7071, host: 7071
-  config.vm.network 'forwarded_port', guest: 8081, host: 6081
-  config.vm.network 'forwarded_port', guest: 9081, host: 9081
   config.vm.network 'forwarded_port', guest: 443, host: 7443
   config.vm.network 'forwarded_port', guest: 80, host: 7080
-  config.vm.network 'forwarded_port', guest: 27017, host: 27017
 
 
   config.vm.provider 'virtualbox' do |v|
-    v.name = 'newManagerZimbra'
+    v.name = 'zimbra-admin-api-js'
     v.memory = 2048
     v.cpus = 2
   end
 
   config.vm.provider 'parallels' do |v|
-    v.name = 'newManagerZimbra'
+    v.name = 'zimbra-admin-api-js'
     v.memory = 2048
     v.cpus = 2
   end

package.json

@@ -2,10 +2,14 @@
   "name": "zimbra-admin-api-js",
   "version": "0.3.6",
   "main": "src/index.js",
+  "engines": {
+    "node": ">=6.2"
+  },
   "dependencies": {
     "crypto-browserify": "^3.11.0",
     "js-zimbra": "github:zboxapp/js-zimbra",
     "merge": "^1.2.0",
+    "object.entries": "^1.0.3",
     "options-api": "^1.1.0",
     "sprintf-js": "^1.0.3",
     "superagent": "^1.8.3",
@@ -35,7 +39,7 @@
     "webpack": "1.12.9"
   },
   "scripts": {
-    "test": "grunt mocha",
+    "test": "mocha",
     "build": "webpack",
     "dev": "WEBPACK_ENV=dev webpack --progress --colors --watch",
     "run": "webpack --progress --watch",

src/index.js

@@ -8,6 +8,12 @@ var pjson = require('../package.json');
 var Dictionary = require('./utils/dictionary.js');
 var ResponseParser = require('./utils/response_parser.js');
 var ErrorBuilder = require('./zimbra/error.js');
+var entries = require ('object.entries');
+
+// Hack Para que Object tenga entries
+if (!Object.entries) {
+    entries.shim();
+}
 
 // TODO: To many parseResponse types
 class ZimbraAdminApi {
@@ -678,8 +684,5 @@ class ZimbraAdminApi {
 
 }
 
-if (typeof module === 'object' && typeof module.exports === 'object') {
-  module.exports = ZimbraAdminApi;
-} else {
-  window.ZimbraAdminApi = ZimbraAdminApi;
-}
+
+module.exports = ZimbraAdminApi;

test/js/spec/test.js

-/* global describe, it, SpotifyWebApi, expect, beforeEach, afterEach, sinon */
+'use strict';
+
+var requireHelper = require('./require_helper'),
+    ZimbraAdminApi = requireHelper('index.js'),
+    expect = require('chai').expect,
+    superagent = require('superagent');
+
 (function() {
-  'use strict';
 
   var auth_data = {
-    'url': 'http://zimbra.zboxapp.dev:9000/service/admin/soap',
+    'url': 'https://localhost:7071/service/admin/soap',
     'user': 'admin@zboxapp.dev',
     'password':'12345678'
   };
@@ -12,6 +17,7 @@
     this.timeout(10000);
 
     it('Should remove the token', function(done){
+      console.log("HOLA------------")
       let api = new ZimbraAdminApi(auth_data);
       api.login(function(err, data){
         if (err) console.error(err);

test/require_helper.js

+// require_helper.js
+'use strict';
+
+module.exports = function (path) {
+    return require((process.env.APP_DIR_FOR_CODE_COVERAGE || '../src/') + path);
+};

test/test.js

+'use strict';
+
+// For node SSL Access
+process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+
+var requireHelper = require('./require_helper'),
+    ZimbraAdminApi = requireHelper('index.js'),
+    expect = require('chai').expect,
+    superagent = require('superagent');
+
+var zimbraURL = process.env.ZIMBRA_URL || 'https://localhost:7071/service/admin/soap';
+var zimbraAdminUser = process.env.ZIMBRA_USER || 'admin@zboxapp.dev';
+var zimbraAdminPassword = process.env.ZIMBRA_PASSWORD || '12345678';
+
+(function() {
+  'use strict';
+
+  var auth_data = {
+    'url': zimbraURL,
+    'user': zimbraAdminUser,
+    'password': zimbraAdminPassword
+  };
+
+  describe('Basic tests', function() {
+    this.timeout(10000);
+
+    // it('Should remove the token', function(done){
+    //   let api = new ZimbraAdminApi(auth_data);
+    //   api.login(function(err, data){
+    //     if (err) console.error(err);
+    //     done();
+    //   });
+    // });
+
+    it('domain.getAdmins() should return the domain admins', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      api.getDomainAdmins('customer.dev', function(err, data){
+        if (err) console.error(err);
+        expect(data.account.length).to.be.above(1);
+        expect(data.account[0].constructor.name).to.be.equal('Account');
+        done();
+      });
+    });
+
+    it('addAdmin should add Admin', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      let domain_admin = Date.now() + '@customer.dev';
+      let resource_name = Date.now() + '.dev';
+      api.createAccount(domain_admin, '12dda.222', {},  function(err, account){
+        if (err) return console.error(err);
+        api.createDomain(resource_name, {}, function(err, data){
+          if (err) console.error(err);
+          let domain = data;
+          const coses = ['basic', 'premium'];
+          api.addDomainAdmin(domain.name, account.id, coses,  function(e, d){
+            if (e) return console.error(e);
+            expect(err).to.be.null;
+            d.getACLs(function(e, acls){
+              if (e) return console.error(e);
+              const expectedGrants = ["domainAdminRights", "set.dl.zimbraACE"];
+              const actualGrants = acls.map(function(acl){return acl.rightName}).sort()
+              expect(expectedGrants[0]).to.be.equal(actualGrants[0]);
+              expect(expectedGrants[2]).to.be.equal(actualGrants[2]);
+              d.getAdmins(function(e, admins){
+                if (e) return console.error(e);
+                expect(admins.account[0].name).to.be.equal(domain_admin);
+                done();
+              })
+            });
+          });
+        });
+      });
+    });
+
+    it('removeAdmin should remove the Admin', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      let domain_admin = 'domain_admin@customer.dev';
+      let resource_name = Date.now() + '.dev';
+      api.createDomain(resource_name, {}, function(err, domain){
+        domain.addAdmin(domain_admin, [], function(e, d){
+          api.removeDomainAdmin(domain.name, domain_admin, [], function(e, d){
+            domain.getACLs(function(e, d){
+              if (e) return console.error(e);
+              expect(d.length).to.be.equal(0);
+              done();
+            });
+          });
+        });
+      });
+    });
+
+    it('Should return the viewMailPath', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      api.getAccountViewMailPath('admin@zboxapp.dev', null, function(err, account){
+        if (err) return console.error(err);
+        expect(account).to.match(/adminPreAuth=1$/);
+        done();
+      });
+    });
+
+    it('getDistributionListOwners should return the DL owners', function(done) {
+      let api = new ZimbraAdminApi(auth_data);
+      api.getDistributionListOwners('restringida@customer.dev', function(err, data){
+        if (err) console.log(err);
+        expect(data[0].type).to.be.exist;
+        done();
+      });
+    });
+
+    it('addDistributionListOwner to DL should add Owner', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      let owner_email = 'domain_admin@customer.dev';
+      let resource_name = Date.now() + '@customer.dev';
+      api.createDistributionList(resource_name, {}, function(err, dl){
+        if (err) return console.error(err);
+        api.addDistributionListOwner(dl.name, owner_email, function(e, dl){
+          if (e) return console.error(e);
+          expect(e).to.be.null;
+          api.getDistributionListOwners(resource_name, function(err, data){
+            if (err) return console.error(err);
+            expect(data[0].name).to.be.equal(owner_email);
+            done();
+          })
+        });
+      });
+    });
+
+    it('removeDistributionListOwner should remove the Owner', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      let owner_email = 'domain_admin@customer.dev';
+      let resource_name = Date.now() + '@customer.dev';
+      api.createDistributionList(resource_name, {}, function(err, dl){
+        dl.addOwner(owner_email, function(e, d){
+          api.removeDistributionListOwner(dl.name, owner_email, function(err, data){
+            if (err) return console.error(err);
+            api.getDistributionListOwners(resource_name, function(err, data){
+              if (err) return console.error(err);
+              expect(data).to.be.empty;
+              done();
+            });
+          })
+        });
+      });
+    });
+
+    it('should return the Delegated Token', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      api.delegateAuth('admin', 3672, function(err, data) {
+        if (err) console.error(err);
+        expect(data.authToken).to.exist;
+        expect(data.lifetime).to.equal(3672000);
+        done();
+      });
+    });
+
+    it('Should Flush the Cache', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      const flush_data = {type: 'domain', allServers: 1, entry: 'zboxapp.dev'};
+      api.flushCache(flush_data, function(err, data){
+        if (err) console.log(err);
+        expect(err).to.not.exist;
+        done();
+      })
+    });
+
+    it('should get all domains', function(done) {
+      let api = new ZimbraAdminApi(auth_data);
+      api.getAllDomains(function(err, data){
+        if (err) console.log(err);
+        expect(data.domain[0].constructor.name).to.equal('Domain');
+        done();
+      });
+    });
+
+    it('should get all domains as an Object', function(done) {
+      let auth_data_tmp = Object.assign({}, auth_data)
+      auth_data_tmp.arrayAsObject = true;
+      auth_data_tmp.arrayAsObjectKey = 'name';
+      let api = new ZimbraAdminApi(auth_data_tmp);
+      api.getAllDomains(function(err, data){
+        if (err) console.log(err);
+        expect(data.domain['customer.dev']).to.exist;
+        done();
+      });
+    });
+
+    it('should get all accounts', function(done) {
+      // var callback = sinon.spy();
+      let api = new ZimbraAdminApi(auth_data);
+      api.getAllAccounts(function(err, data){
+        if (err) console.log(err);
+        expect(data.account[0].constructor.name).to.equal('Account');
+        done();
+      });
+    });
+
+    it('should get all accounts as an Object', function(done) {
+      let auth_data_tmp2 = Object.assign({}, auth_data)
+      auth_data_tmp2.arrayAsObject = true;
+      let api = new ZimbraAdminApi(auth_data_tmp2);
+      api.getAllAccounts(function(err, data){
+        if (err) console.log(err);
+        expect(Object.keys(data.account)[0]).to.match(/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
+        done();
+      });
+    });
+
+    it('should get all distribution_lists', function(done) {
+      let api = new ZimbraAdminApi(auth_data);
+      api.getAllDistributionLists(function(err, data){
+        if (err) console.log(err);
+        expect(data.dl[0].constructor.name).to.equal('DistributionList');
+        done();
+      });
+    });
+
+    it('should get and return an account', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      api.getAccount('admin@zboxapp.dev', function(err, data){
+        expect(data.constructor.name).to.equal('Account');
+        expect(data.name).to.equal('admin@zboxapp.dev');
+        done();
+      });
+    });
+
+    it('should return an error if account not found', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      api.getAccount('noexiste@nuncajams.com', function(err, data){
+        expect(err.extra.code).to.equal('account.NO_SUCH_ACCOUNT');
+        done();
+      });
+    });
+
+    it('should return an error if domain not found', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      api.getDomain('nuncajams.com', function(err, data){
+        expect(err.extra.code).to.equal('account.NO_SUCH_DOMAIN');
+        done();
+      });
+    });
+
+    it('should return the DL', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      api.getDistributionList('abierta@customer.dev', function(err, data){
+        expect(data.name).to.equal('abierta@customer.dev');
+        done();
+      });
+    });
+
+    it('should get and return with name or id', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      let callback = function(err, data){
+        let domain_id = data.id;
+        api.getDomain(domain_id, function(err, data){
+          if (err) return console.error(err);
+          expect(data.name).to.equal('zboxapp.dev');
+          done();
+        });
+      };
+      api.getDomain('zboxapp.dev', callback);
+    });
+
+    it('getInfo() should return the logged user info', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      let callback = function(err, data) {
+        if (err) return console.log(err);
+        api.getInfo(function(err, data){
+          if (err) return console.log(err);
+          expect(data.name).to.equal('admin@zboxapp.dev');
+          done();
+        });
+      };
+      api.login(callback);
+    });
+
+    it('should return Error with wrong Login', function(done){
+      let auth_obj = {
+        'url': zimbraURL,
+        'user': 'admin@zboxapp.dev',
+        'password':'12345678910'
+      }
+      let api = new ZimbraAdminApi(auth_obj);
+      api.login(function(err, data){
+        expect(err.extra.code).to.be.equal("account.AUTH_FAILED");
+        expect(err.extra.reason).to.match(/authentication failed/);
+        done();
+      });
+    });
+
+    it('should return directorySearch with total info', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      let query_object = {limit: 10, domain: 'customer.dev', types: "accounts"};
+      api.directorySearch(query_object, function(err, data){
+        expect(data.more).to.equal(true);
+        expect(data.total).to.be.above(1);
+        expect(data.account.length).to.be.at.least(1);
+        done();
+      });
+    });
+
+    it('countAccounts hould return {} for empty Domain', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      api.countAccounts('empty.com', function(err, data){
+        if (err) console.error(err);
+        expect(data).to.be.empty;
+        done();
+      });
+    });
+
+    it('Should return correct response from BatchRequest', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      api.client.options.timeout = 5000;
+      let callback = function(err, data) {
+        if (err) return console.error(err);
+        expect(data.GetAllAccountsResponse).to.exist;
+        expect(data.GetAllDomainsResponse).to.exist;
+        done();
+      }
+      const getAllAccounts = api.buildRequestData('GetAllAccounts', callback);
+      const getAllDomains = api.buildRequestData('GetAllDomains', callback);
+      const that = this;
+      let getCallback = function(err, response){
+        if (err) return this.handleError(err);
+        api.makeBatchRequest([getAllAccounts, getAllDomains], callback);
+      };
+      api.login(getCallback);
+    });
+
+    it('Should return errors for BatchRequest', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      api.client.options.timeout = 5000;
+      const getAllAccounts = api.directorySearch({types: 'account'});
+      const deleteAccount = api.removeAccount('pollotron@example.com');
+      const getAllDomains = api.directorySearch({types: 'domains'});
+      api.login(function(err, data){
+        api.makeBatchRequest([deleteAccount, getAllDomains, getAllAccounts], function(err, data){
+          expect(data.errors.length).to.be.above(1);
+          expect(data.errors[0].constructor.name).to.equal('Error');
+          expect(data.errors[0].extra.code).to.exist;
+          expect(data.errors[1].extra.reason).to.exist;
+          done();
+        }, {onError: 'continue'});
+      });
+    });
+
+  });
+
+  describe('Account tests', function() {
+    this.timeout(10000);
+
+    it('should return the account membership', function(done){
+      const account = 'admin@zboxapp.dev';
+      let api = new ZimbraAdminApi(auth_data);
+      api.getAccountMembership(account, function(err, data){
+        if (err) return console.log(err);
+        expect(data[0].constructor.name).to.be.equal('DistributionList');
+        done();
+      });
+    });
+
+    it('should return the account membership when used as account method', function(done){
+      const account = 'admin@zboxapp.dev';
+      let api = new ZimbraAdminApi(auth_data);
+      api.getAccount(account, function(err, account){
+        if (err) return console.log(err);
+        account.getAccountMembership(function(err, data){
+          if (err) return console.log(err);
+          expect(data[0].constructor.name).to.be.equal('DistributionList');
+          done();
+        });
+      })
+    });
+
+    it('should return OK if the account membership is empty', function(done){
+      const account = 'pbruna@itlinux.cl';
+      let api = new ZimbraAdminApi(auth_data);
+      api.getAccountMembership(account, function(err, data){
+        if (err) return console.log(err);
+        console.log(data);
+        expect(data.length).to.be.equal(0);
+        done();
+      });
+    });
+
+    it('should create and return an account', function(done){
+      let account_name = Date.now() + '@big.com';
+      let account_password = Date.now();
+      let account_attributes = {};
+      let api = new ZimbraAdminApi(auth_data);
+      api.createAccount(account_name, account_password, account_attributes, function(err, data){
+        if (err) return console.log(err);
+        expect(data.name).to.equal(account_name);
+        done();
+      });
+    });
+
+    it('should create and return an account with extra attributes', function(done){
+      let account_name = Date.now() + '@big.com';
+      let account_password = Date.now();
+      let account_attributes = { 'sn': 'Bruna', 'givenName': 'Patricio' };
+      let api = new ZimbraAdminApi(auth_data);
+      api.createAccount(account_name, account_password, account_attributes, function(err, data){
+        if (err) return console.log(err);
+        expect(data.attrs.sn).to.equal('Bruna');
+        expect(data.attrs.givenName).to.equal('Patricio');
+        done();
+      });
+    });
+
+    it('Should create Account with an array attributes', function(done){
+      let account_name = Date.now() + '@big.com';
+      let account_password = Date.now();
+      let account_attributes = { 'sn': 'Bruna', 'givenName': 'Patricio' };
+      account_attributes.amavisBlacklistSender = ['1.com', '2.com', '3.com'];
+      let api = new ZimbraAdminApi(auth_data);
+      api.createAccount(account_name, account_password, account_attributes, function(err, data){
+        if (err) return console.log(err);
+        expect(data.attrs.sn).to.equal('Bruna');
+        expect(data.attrs.givenName).to.equal('Patricio');
+        done();
+      });
+    });
+
+    it('should modify Account attributes', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      let description = Date.now().toString();
+      let physicalDeliveryOfficeName = Date.now().toString();
+      let attributes = {
+        physicalDeliveryOfficeName: physicalDeliveryOfficeName,
+        description: description
+      };
+      api.getAccount('admin@zboxapp.dev', function(err, data){
+        if (err) return console.log(err);
+        api.modifyAccount(data.id, attributes, function(err, data){
+          if (err) return console.log(err);
+          expect(data.attrs.description).to.be.equal(description);
+          expect(data.attrs.physicalDeliveryOfficeName).to.be.equal(physicalDeliveryOfficeName);
+          done();
+        });
+      });
+    });
+
+    it('should remove account', function(done){
+      let account_name = Date.now() + '@big.com';
+      let account_password = Date.now();
+      let account_attributes = {};
+      let api = new ZimbraAdminApi(auth_data);
+      api.createAccount(account_name, account_password, account_attributes, function(err, data){
+        if (err) return console.log(err);
+        api.removeAccount(data.id, function(err, data){
+          if (err) return console.log(err);
+          expect(data._jsns).to.equal("urn:zimbraAdmin");
+          done();
+        });
+      });
+    });
+
+    it('should set password', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      api.getAccount('pbruna@itlinux.cl', function(err, data){
+        let account = data;
+        account.setPassword('123456789', function(err, data){
+          if (err) return console.log(err);
+          expect(data).to.be.empty;
+          done();
+        });
+      });
+    });
+
+    it('Should Return Error for Invalid Password', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      api.getAccount('pbruna@itlinux.cl', function(err, data){
+        let account = data;
+        account.setPassword('', function(err, data){
+          expect(err).to.exist;
+          done();
+        });
+      });
+    });
+
+    it('Should Get The Account Mailbox', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      api.getAccount('cos_basic_13@customer.dev', function(err, data){
+        let account = data;
+        account.getMailbox(function(err, data){
+          if (err) return console.log(err);
+          expect(data.size).to.be.exist;
+          done();
+        });
+      });
+    });
+
+    it('Should Get The Account Mailbox Size', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      api.getAccount('cos_basic_13@customer.dev', function(err, data){
+        let account = data;
+        account.getMailboxSize(function(err, data){
+          if (err) return console.log(err);
+          expect(data).to.be.at.least(0);
+          done();
+        });
+      });
+    });
+
+    it('Should return error for bad AddAccountAlias', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      let alias = 'pbruna@gmail.com';
+      api.getAccount('pbruna@itlinux.cl', function(err, data){
+        let account = data;
+        account.addAccountAlias(alias, function(err, data){
+          expect(err.extra.code).to.be.equal("account.NO_SUCH_DOMAIN");
+          done();
+        });
+      });
+    });
+
+    it('AddAccountAlias should add the alias', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      let alias = Date.now() + '@itlinux.cl';
+      api.getAccount('pbruna@itlinux.cl', function(err, data){
+        let account = data;
+        account.addAccountAlias(alias, function(err, data){
+          if (err) return console.error(err);
+          expect(err).to.be.null;
+          done();
+        });
+      });
+    });
+
+    it('RemoveAccountAlias should remove the alias', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      let alias = Date.now() + '@itlinux.cl';
+      api.getAccount('pbruna@itlinux.cl', function(err, data){
+        let account = data;
+        account.addAccountAlias(alias, function(err, data){
+          if (err) return console.error(err);
+          account.removeAccountAlias(alias, function(err, data){
+            if (err) return console.error(err);
+            expect(err).to.be.null;
+            done();
+          });
+        });
+      });
+    });
+
+    it('Should rename the account', function(done){
+      let account_name = Date.now() + '@big.com';
+      let new_name = Date.now() + '1' + '@big.com';
+      let account_password = Date.now();
+      let account_attributes = {};
+      let api = new ZimbraAdminApi(auth_data);
+      api.createAccount(account_name, account_password, account_attributes, function(err, account){
+        if (err) return console.log(err);
+        const account_id = account.id;
+        account.rename(new_name, function(err, data){
+          if (err) return console.log(err);
+          expect(data.id).to.equal(account_id);
+          expect(data.name).to.equal(new_name);
+          done();
+        });
+      });
+    });
+
+    it('Should return the viewMailPath', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      api.getAccount('admin@zboxapp.dev', function(err, account){
+        if (err) return console.error(err);
+        account.viewMailPath(null, function(err, data){
+          if (err) return console.log(err);
+          expect(data).to.match(/adminPreAuth=1$/);
+          done();
+        });
+      });
+    });
+
+    // it('Should enable the account Archiving', function(done){
+    //   let account_name = Date.now() + '@zboxtest.com';
+    //   let account_password = Date.now();
+    //   let api = new ZimbraAdminApi(auth_data);
+    //   api.createAccount(account_name, account_password, {}, function(err, account){
+    //     if (err) return console.log(err);
+    //     account.enableArchiving('default', function(err, account){
+    //       if (err) return console.log(err);
+    //       expect(account.archiveEnabled).to.be.true;
+    //       expect(account.attrs.zimbraArchiveAccount).to.match(/com\.archive$/);
+    //       done();
+    //     });
+    //   });
+    // });
+    //
+    // it('Should disable the account Archiving', function(done){
+    //   let account_name = Date.now() + '@zboxtest.com';
+    //   let account_password = Date.now();
+    //   let api = new ZimbraAdminApi(auth_data);
+    //   api.createAccount(account_name, account_password, {}, function(err, account){
+    //     if (err) return console.log(err);
+    //     account.enableArchiving('default', function(err, account){
+    //       if (err) return console.log(err);
+    //       account.disableArchiving(function(err, account){
+    //         if (err) return console.log(err);
+    //         expect(account.archiveEnabled).to.be.false;
+    //         expect(account.attrs.zimbraArchiveAccount).to.match(/com\.archive$/);
+    //         done();
+    //       });
+    //     });
+    //   });
+    // });
+
+
+  });
+
+  describe('Domain tests', function() {
+    this.timeout(5000);
+
+    it('Should return if the domain is an alias Domain', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      api.getDomain('reseller.alias', function(err, data){
+        if (err) return console.log(err);
+        expect(data.isAliasDomain).to.be.true;
+        expect(data.masterDomainName).to.be.equal('reseller.dev');
+        done();
+      });
+    });
+
+    it('Should return false if the domain is not an alias Domain', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      api.getDomain('reseller.dev', function(err, data){
+        if (err) return console.log(err);
+        expect(data.isAliasDomain).to.be.false;
+        expect(data.masterDomainName).to.be.undefined;
+        done();
+      });
+    });
+
+    it('should create and return Domain', function(done){
+      let resource_name = Date.now() + '.dev';
+      let resource_attributes = {};
+      let api = new ZimbraAdminApi(auth_data);
+      api.createDomain(resource_name, resource_attributes, function(err, data){
+        if (err) return console.log(err);
+        expect(data.name).to.equal(resource_name);
+        done();
+      });
+    });
+
+    it('should return error "account.DOMAIN_EXISTS" if Domain Exists', function(done){
+      let resource_name = 'zboxapp.dev';
+      let resource_attributes = {};
+      let api = new ZimbraAdminApi(auth_data);
+      api.createDomain(resource_name, resource_attributes, function(err, data){
+        expect(err.extra.code).to.equal('account.DOMAIN_EXISTS');
+        done();
+      });
+    });
+
+    it('should create and return Domain with attributes', function(done){
+      let resource_name = Date.now() + '.dev';
+      let resource_attributes = {
+        zimbraSkinLogoURL: 'http://www.zboxapp.com',
+        postOfficeBox: 'ZBoxApp'
+      };
+      let api = new ZimbraAdminApi(auth_data);
+      let callback = function(err, data){
+        if (err) return console.log(err);
+        expect(data.attrs.zimbraSkinLogoURL).to.equal('http://www.zboxapp.com');
+        expect(data.attrs.postOfficeBox).to.equal('ZBoxApp');
+        done();
+      };
+      api.createDomain(resource_name, resource_attributes, callback);
+    });
+
+    it('should modify Domain attributes', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      let description = Date.now().toString();
+      let attributes = {
+        description: description
+      };
+      api.getDomain('zboxapp.dev', function(err, data){
+        if (err) console.log(err);
+        api.modifyDomain(data.id, attributes, function(err, data){
+          expect(data.attrs.description).to.be.equal(description);
+          done();
+        });
+      });
+    });
+
+    it('should remove Domain', function(done){
+      let resource_name = Date.now() + '.dev';
+      let resource_attributes = {};
+      let api = new ZimbraAdminApi(auth_data);
+      api.createDomain(resource_name, resource_attributes, function(err, data){
+        if (err) return console.log(err);
+        api.removeDomain(data.id, function(err, data){
+          if (err) return console.log(err);
+          expect(data._jsns).to.equal("urn:zimbraAdmin");
+          done();
+        });
+      });
+    });
+
+    it('should counts of account for the Domain', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      api.countAccounts('customer.dev', function(err, data){
+        if (err) console.error(err);
+        expect(data.default.used).to.be.above(1);
+        done();
+      });
+    });
+
+    it('Batch Count Account Response Should return the correct', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      const callback = function(err, data){
+        if (err) console.error(err);
+        expect(data[0].default.used).to.be.above(1);
+        done();
+      };
+      api.batchCountAccounts(['customer.dev', 'zboxapp.dev'], callback);
+    });
+
+
+    it('domain.countAccounts() should return the counts', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      api.getDomain('customer.dev', function(err, data){
+        if (err) console.error(err);
+        let domain = data;
+        domain.countAccounts(function(e, d){
+          expect(d.default.used).to.be.above(1);
+          done();
+        });
+      });
+    });
+
+    it('domain.countAccounts() should return the account Limits', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      api.getDomain('customer.dev', function(err, domain){
+        if (err) console.error(err);
+        api.getCos("basic", function(err, cos){
+          if (err) console.error(err);
+          const cosMax = {"zimbraDomainCOSMaxAccounts": `${cos.id}:200`};
+          api.modifyDomain(domain.id, cosMax, function(err, data){
+            if (err) console.error(err);
+            domain.countAccounts(function(err, d){
+              if (err) console.error(err);
+              expect(d.basic.limit).to.be.above(1);
+              done();
+            });
+          })
+        })
+
+      });
+    });
+
+    it('domain.getAdmins() should return the domain admins', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      api.getDomain('customer.dev', function(err, data){
+        if (err) console.error(err);
+        let domain = data;
+        domain.getAdmins(function(e, d){
+          if (e) return console.error(e);
+          expect(d.account.length).to.be.above(1);
+          expect(d.account[0].constructor.name).to.be.equal('Account');
+          done();
+        });
+      });
+    });
+
+    it('domain.getAllDistributionLists should return the DLs', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      api.getDomain('customer.dev', function(err, data){
+        if (err) console.error(err);
+        let domain = data;
+        domain.getAllDistributionLists(function(e, d){
+          if (e) return console.log(e);
+          expect(d[0].constructor.name).to.be.equal('DistributionList');
+          done();
+        });
+      });
+    });
+
+    it('addAdmin should add Admin', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      let domain_admin = Date.now() + '@customer.dev';
+      let resource_name = Date.now() + '.dev';
+      api.createAccount(domain_admin, '12dda.222', {},  function(err, account){
+        if (err) return console.error(err);
+        api.createDomain(resource_name, {}, function(err, data){
+          if (err) console.error(err);
+          let domain = data;
+          const coses = ['basic', 'premium'];
+          domain.addAdmin(account.id, coses,  function(e, d){
+            if (e) return console.error(e);
+            expect(err).to.be.null;
+            d.getACLs(function(e, acls){
+              if (e) return console.error(e);
+              const expectedGrants = ["domainAdminRights", "set.dl.zimbraACE"];
+              const actualGrants = acls.map(function(acl){return acl.rightName}).sort()
+              expect(expectedGrants[0]).to.be.equal(actualGrants[0]);
+              expect(expectedGrants[2]).to.be.equal(actualGrants[2]);
+              d.getAdmins(function(e, admins){
+                if (e) return console.error(e);
+                expect(admins.account[0].name).to.be.equal(domain_admin);
+                done();
+              })
+            });
+          });
+        });
+      });
+    });
+
+    it('removeAdmin should remove the Admin', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      let domain_admin = 'domain_admin@customer.dev';
+      let resource_name = Date.now() + '.dev';
+      api.createDomain(resource_name, {}, function(err, domain){
+        domain.addAdmin(domain_admin, [], function(e, d){
+          domain.removeAdmin(domain_admin, [], function(e, d){
+            domain.getACLs(function(e, d){
+              if (e) return console.error(e);
+              expect(d.length).to.be.equal(0);
+              done();
+            });
+          });
+        });
+      });
+    });
+
+  });
+
+  describe('DistributionList tests', function() {
+    this.timeout(5000);
+
+    it('should remove DL', function(done){
+      let resource_name = Date.now() + '@zboxapp.dev';
+      let resource_attributes = {};
+      let api = new ZimbraAdminApi(auth_data);
+      api.createDistributionList(resource_name, resource_attributes, function(err, data){
+        if (err) return console.log(err);
+        api.removeDistributionList(data.id, function(err, data){
+          if (err) return console.log(err);
+          expect(data._jsns).to.equal("urn:zimbraAdmin");
+          done();
+        });
+      });
+    });
+
+    it('should modify DistributionList attributes', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      let description = Date.now().toString();
+      let attributes = {
+        description: description
+      };
+      api.getDistributionList('abierta@customer.dev', function(err, data){
+        if (err) console.log(err);
+        api.modifyDistributionList(data.id, attributes, function(err, data){
+          expect(data.attrs.description).to.be.equal(description);
+          done();
+        });
+      });
+    });
+
+    it('Add member to DL should work with only one', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      let member = Date.now().toString() + '@customer.dev';
+      api.getDistributionList('abierta@customer.dev', function(err, data){
+        if (err) console.log(err);
+        const dl = data;
+        dl.addMembers(member, function(err, data){
+          if (err) return console.error(err);
+          expect(err).to.be.null;
+          done();
+        });
+      });
+    });
+
+    it('Add member to DL should work with array', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      let name = Date.now().toString();
+      let members = [name + '@customer.dev', name + '@zboxapp.dev' ];
+      api.getDistributionList('abierta@customer.dev', function(err, data){
+        if (err) console.log(err);
+        const dl = data;
+        dl.addMembers(members, function(err, data){
+          if (err) return console.error(err);
+          expect(err).to.be.null;
+          done();
+        });
+      });
+    });
+
+    it('Remove members works with an array', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      let name = Date.now().toString();
+      let members = [name + '@customer.dev', name + '@zboxapp.dev' ];
+      api.getDistributionList('abierta@customer.dev', function(err, data){
+        if (err) console.log(err);
+        const dl = data;
+        const original_members = dl.members;
+        dl.addMembers(members, function(err, data){
+          if (err) return console.error(err);
+          dl.removeMembers(members, function(err, data){
+            if (err) return console.error(err);
+            api.getDistributionList('abierta@customer.dev', function(err, data){
+              expect(original_members.length).to.be.equal(data.members.length);
+              done();
+            });
+          });
+        });
+      });
+    });
+
+    it('dl.getOwners should return the DL owners', function(done) {
+      let api = new ZimbraAdminApi(auth_data);
+      api.getDistributionList('restringida@customer.dev', function(err, data){
+        if (err) console.log(err);
+        const dl = data;
+        dl.getOwners(function(err, data){
+          if (err) console.log(err);
+          expect(data[0].type).to.be.exist;
+          done();
+        });
+      });
+    });
+
+    it('addOwner to DL should add Owner', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      let owner_email = 'domain_admin@customer.dev';
+      let resource_name = Date.now() + '@customer.dev';
+      api.createDistributionList(resource_name, {}, function(err, dl){
+        dl.addOwner(owner_email, function(e, dl){
+          if (e) return console.error(e);
+          expect(err).to.be.null;
+          dl.getACLs(function(e, d){
+            if (e) return console.error(e);
+            expect(d[0].grantee.name).to.be.equal(owner_email);
+            done();
+          });
+        });
+      });
+    });
+
+    it('removeOwner should remove the Owner', function(done){
+      let api = new ZimbraAdminApi(auth_data);
+      let owner_email = 'domain_admin@customer.dev';
+      let resource_name = Date.now() + '@customer.dev';
+      api.createDistributionList(resource_name, {}, function(err, dl){
+        dl.addOwner(owner_email, function(e, d){
+          d.removeOwner(owner_email, function(e, d){
+            d.getACLs(function(e, d){
+              if (e) return console.error(e);
+              expect(d.length).to.be.equal(0);
+              done();
+            });
+          });
+        });
+      });
+    });
+
+    it('Should rename the DL', function(done){
+      let dl_name = Date.now() + '@big.com';
+      let new_name = Date.now() + '1' + '@big.com';
+      let dl_attrs = {};
+      let api = new ZimbraAdminApi(auth_data);
+      api.createDistributionList(dl_name, dl_attrs, function(err, dl){
+        if (err) return console.log(err);
+        const dl_id = dl.id;
+        dl.rename(new_name, function(err, data){
+          if (err) return console.log(err);
+          expect(data.id).to.equal(dl_id);
+          expect(data.name).to.equal(new_name);
+          done();
+        });
+      });
+    });
+
+
+
+  });
+
+  describe('Grants tests', function() {
+    this.timeout(5000);
+
+    it('should get the Grants with null target_data', function(done) {
+      let api = new ZimbraAdminApi(auth_data);
+      let grantee_data = {type: 'usr', identifier: 'domain_admin@customer.dev'};
+      api.getGrants(null, grantee_data, function(err, data){
+        if (err) console.log(err);
+        expect(data[0].constructor.name).to.equal('Grant');
+        done();
+      });
+    });
+
+    it('should get the Grants with null grantee_data', function(done) {
+      let api = new ZimbraAdminApi(auth_data);
+      let target_data = {type: 'domain', identifier: 'customer.dev'};
+      api.getGrants(target_data, null, function(err, data){
+        if (err) console.log(err);
+        expect(data[0].constructor.name).to.equal('Grant');
+        expect(data[0].right._content).to.equal("domainAdminRights");
+        done();
+      });
+    });
+
+    it('should return Empty Array if no Grants', function(done) {
+      let api = new ZimbraAdminApi(auth_data);
+      let target_data = {type: 'domain', identifier: 'zboxapp.dev'};
+      api.getGrants(target_data, null, function(err, data){
+        if (err) console.log(err);
+        expect(data).to.be.empty;
+        done();
+      });
+    });
+  });
+
+})();

vagrant/provision/playbook.yml

@@ -23,19 +23,3 @@
     - role: common
     - role: bertvv.bind
     - role: pbruna.zimbradev
-
-  tasks:
-    - name: Instala Mongo DB y dependencias
-      yum: name={{ item }} state=present
-      with_items:
-        - mongodb-org
-        - python-pymongo
-
-    - name: Configura mongo
-      copy: src=./roles/common/files/mongod.conf dest=/etc/mongod.conf
-
-    - name: Inicia servicio mongodb
-      service: name=mongod state=started enabled=yes
-
-    - name: Configura DB y usuario mongo
-      mongodb_user: database=manager name=manager password=manager state=present

vagrant/provision/roles/common/files/mongo.repo

-[mongodb-org-3.2]
-name=MongoDB Repository
-baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/3.2/x86_64/
-gpgcheck=1
-enabled=1
-gpgkey=https://www.mongodb.org/static/pgp/server-3.2.asc

vagrant/provision/roles/common/files/mongod.conf

-# mongod.conf
-
-# for documentation of all options, see:
-#   http://docs.mongodb.org/manual/reference/configuration-options/
-
-# where to write logging data.
-systemLog:
-  destination: file
-  logAppend: true
-  path: /var/log/mongodb/mongod.log
-
-# Where and how to store data.
-storage:
-  dbPath: /var/lib/mongo
-  journal:
-    enabled: true
-#  engine:
-#  mmapv1:
-#  wiredTiger:
-
-# how the process runs
-processManagement:
-  fork: true  # fork and run in background
-  pidFilePath: /var/run/mongodb/mongod.pid  # location of pidfile
-
-# network interfaces
-net:
-  port: 27017
-  bindIp: 0.0.0.0  # Listen to local interface only, comment to listen on all interfaces.
-
-
-#security:
-
-#operationProfiling:
-
-#replication:
-
-#sharding:
-
-## Enterprise-Only Options
-
-#auditLog:
-
-#snmp:

vagrant/provision/roles/common/files/nginx-env.conf

-env NODE_TLS_REJECT_UNAUTHORIZED=0;
-env zbox_rbac_config=/var/www/zbox-manager-rbac/config.json;

vagrant/provision/roles/common/files/passenger.conf

-passenger_root /usr/lib/ruby/1.8/phusion_passenger/locations.ini;
-passenger_ruby /opt/rh/ruby193/root/usr/bin/ruby;
-passenger_instance_registry_dir /var/run/passenger-instreg;

vagrant/provision/roles/common/files/passenger.repo

-[passenger]
-name=passenger
-baseurl=https://oss-binaries.phusionpassenger.com/yum/passenger/el/$releasever/$basearch
-repo_gpgcheck=1
-gpgcheck=0
-enabled=1
-gpgkey=https://packagecloud.io/gpg.key
-sslverify=1
-sslcacert=/etc/pki/tls/certs/ca-bundle.crt
-
-[passenger-source]
-name=passenger-source
-baseurl=https://oss-binaries.phusionpassenger.com/yum/passenger/el/$releasever/SRPMS
-repo_gpgcheck=1
-gpgcheck=0
-enabled=1
-gpgkey=https://packagecloud.io/gpg.key
-sslverify=1
-sslcacert=/etc/pki/tls/certs/ca-bundle.crt

vagrant/provision/roles/common/files/pdns-nginx.conf

-upstream pdns {
-   server localhost:8091;
-}
-
-
-server {
-  listen  8081;
-  server_name pdns;
-
-  location / {
-    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-    proxy_set_header x-api-key 'otto';
-    proxy_pass http://pdns/;
-    proxy_buffering off;
-    proxy_read_timeout 300s;
-    gzip off;
-  }
-
-  client_max_body_size 4G;
-  keepalive_timeout 10;
-}

vagrant/provision/roles/common/files/pdns.repo

-[pdns-MIND]
-name=PowerDNS server packages for RHEL6 and friends.
-baseurl=https://www.monshouwer.eu/download/3rd_party/pdns/el6/$basearch/
-gpgcheck=0
-enabled=1

vagrant/provision/roles/common/files/zbox-rbac-manager.conf

-# Conf para ZBOX-RBAC
-
-server {
-    listen       8070;
-    server_name  rbac-manager.zboxapp.com;
-
-    error_log /var/log/nginx/rbac-error.log warn;
-    access_log /var/log/nginx/rbac-access.log;
-
-    #ssl_ciphers  HIGH:!aNULL:!MD5;
-    #ssl_prefer_server_ciphers   on;
-
-    root /var/www/zbox-manager-rbac;
-    passenger_enabled on;
-    # Tell Passenger that your app is a Node.js app
-    passenger_app_type node;
-    passenger_startup_file /var/www/zbox-manager-rbac/lib/index.js;
-
-    gzip            on;
-    gzip_min_length 1000;
-    gzip_proxied    expired no-cache no-store private auth;
-    gzip_types      text/plain application/xml application/javascript application/json;
-
-  client_max_body_size 4G;
-  keepalive_timeout 10;
-
-}

vagrant/provision/roles/common/files/zboxrbac-conf.json

-{
- "port": 30000,
- "zimbra_url": "https://localhost:7071/service/admin/soap"
-}

vagrant/provision/roles/common/tasks/main.yml

 ---
-# tasks file for cartertdte.mta
-- name: RH Install epel-release
-  yum: name=epel-release update_cache=yes
+- name: Copia hosts
+  template:
+    src: hosts.j2
+    dest: /etc/hosts
+    owner: root
+    mode: '0644'
 
 - name: Deshabilita SELINUX
   lineinfile: dest=/etc/sysconfig/selinux regexp=^SELINUX= line=SELINUX=disabled
 
+- name: Copia repo de Nodejs
+  copy: src=node.repo dest=/etc/yum.repos.d/nodesource-el.repo
+
 - name: Instala paquetes Base
   yum: name={{ item }} state=present
   with_items:
     - "{{ system_packages }}"
 
-- name: Copia resolv.conf
-  copy: src=resolv.conf dest=/etc/resolv.conf
-
-- name: Copia pdns.repo
-  copy: src=pdns.repo dest=/etc/yum.repos.d/pdns.repo
-
-- name: Copia mongo.repo
-  copy: src=mongo.repo dest=/etc/yum.repos.d/mongo.repo
-
-- name: "Copia NGinx FS"
-  copy: src=nginx-filesystem-1.10.0-8.p5.0.29.el6.noarch.rpm dest=/tmp/nginx-filesystem-1.10.0-8.p5.0.29.el6.noarch.rpm
-
-
-- name: Copia repo de Nodejs
-  copy: src=node.repo dest=/etc/yum.repos.d/nodesource-el.repo
-
 - name: Desactiva SELINUX
   selinux: state=disabled
 
-
-- name: Instala todos los Fucking paquetes
-  yum: name={{ item }} state=present disable_gpg_check=yes
-  with_items:
-    - nodejs
-    - curl-devel
-    - GeoIP
-    - gd
-    - gperftools
-    - pcre
-    - libev
-    - git
-
-- name: Copia hosts
-  template:
-    src: hosts.j2
-    dest: /etc/hosts
-    owner: root
-    mode: '0644'
-
 - name: Desahbilita postfix
   service: name=postfix state=stopped enabled=no
 
 - name: Desahbilita iptables
   service: name=firewalld state=stopped enabled=no
+
+- name: Copia resolv.conf
+  copy: src=resolv.conf dest=/etc/resolv.conf

vagrant/provision/roles/common/templates/hosts.j2

 127.0.0.1 localhost.localdomain localhost
-{{ ansible_all_ipv4_addresses|last }} {{ansible_nodename}} {{ansible_hostname}}
+192.168.50.10 {{ansible_nodename}} {{ansible_hostname}}

vagrant/provision/roles/common/vars/main.yml

 ---
 # vars file for cartertdte.mta
 system_packages:
+  - epel-release
   - screen
   - wget
   - curl
@@ -18,10 +19,13 @@ system_packages:
   - bind-utils
   - tcpdump
   - tzdata
+  - tzdata-java
   - zsh
   - vim
   - dos2unix
   - libselinux-python
   - python-pycurl
   - mailx
-  - unzip
\ No newline at end of file
+  - unzip
+  - git
+  - deltarpm

vagrant/provision/roles/pbruna.zimbradev/vars/main.yml

@@ -59,6 +59,14 @@ zimbra_domains:
   - name: 'zboxapp.com'
     bcategory: '76424135-5'
 
+  - name: 'big.com'
+    bcategory: '76424135-5'
+
+  - name: 'itlinux.cl'
+    bcategory: '13834853-9'
+    accounts:
+      - name: 'pbruna@itlinux.cl'
+      
   - name: 'customer.dev.archive'
     bcategory: '13834853-9'
     accounts: