683 lines
31 KiB
JavaScript
683 lines
31 KiB
JavaScript
'use strict';
|
|
|
|
/* global it:false */
|
|
/* global describe:false */
|
|
/* global before:false */
|
|
/* global after:false */
|
|
|
|
const common = require('./common.js'),
|
|
expect = require('expect.js'),
|
|
mail = require('../../mail.js'),
|
|
superagent = require('../../superagent.js'),
|
|
_ = require('../../underscore.js');
|
|
|
|
describe('Mail API', function () {
|
|
const { setup, cleanup, serverUrl, owner, dashboardDomain, dashboardFqdn, mailFqdn } = common;
|
|
|
|
let publicKey;
|
|
before(async () => {
|
|
await setup();
|
|
const d = await mail.getDomain(dashboardDomain);
|
|
publicKey = d.dkimKey.publicKey.split('\n').slice(1, -2).join(''); // remove header, footer and new lines
|
|
});
|
|
|
|
after(cleanup);
|
|
|
|
describe('crud', function () {
|
|
it('cannot get non-existing domain', async function () {
|
|
const response = await superagent.get(`${serverUrl}/api/v1/mail/doesnotexist.com`)
|
|
.query({ access_token: owner.token })
|
|
.ok(() => true);
|
|
|
|
expect(response.status).to.equal(404);
|
|
});
|
|
|
|
it('can get domain', async function () {
|
|
const response = await superagent.get(`${serverUrl}/api/v1/mail/${dashboardDomain}`)
|
|
.query({ access_token: owner.token });
|
|
|
|
expect(response.status).to.equal(200);
|
|
expect(response.body.domain).to.equal(dashboardDomain);
|
|
expect(response.body.enabled).to.equal(false);
|
|
expect(response.body.mailFromValidation).to.equal(true);
|
|
expect(response.body.catchAll).to.be.an(Array);
|
|
expect(response.body.catchAll.length).to.equal(0);
|
|
expect(response.body.relay).to.be.an('object');
|
|
expect(response.body.relay.provider).to.equal('cloudron-smtp');
|
|
});
|
|
});
|
|
|
|
describe('status', function () {
|
|
let resolve = null;
|
|
let dnsAnswerQueue = [];
|
|
let dkimDomain, spfDomain, mxDomain, dmarcDomain;
|
|
|
|
before(async function () {
|
|
const dig = require('../../dig.js');
|
|
|
|
// replace dns resolveTxt()
|
|
resolve = dig.resolve;
|
|
dig.resolve = async function (hostname, type/*, options*/) {
|
|
expect(hostname).to.be.a('string');
|
|
|
|
if (!dnsAnswerQueue[hostname] || !(type in dnsAnswerQueue[hostname])) throw new Error('no mock answer');
|
|
|
|
if (dnsAnswerQueue[hostname][type] === null) throw new Error({ code: 'ENODATA'} );
|
|
|
|
return dnsAnswerQueue[hostname][type];
|
|
};
|
|
|
|
dkimDomain = `cloudron._domainkey.${dashboardDomain}`; // no suffix for provisioned domains
|
|
spfDomain = dashboardDomain;
|
|
mxDomain = dashboardDomain;
|
|
dmarcDomain = '_dmarc.' + dashboardDomain;
|
|
|
|
const response = await superagent.post(`${serverUrl}/api/v1/mail/${dashboardDomain}/enable`)
|
|
.query({ access_token: owner.token })
|
|
.send({ enabled: true });
|
|
|
|
expect(response.status).to.be(202);
|
|
});
|
|
|
|
after(function (done) {
|
|
const dig = require('../../dig.js');
|
|
|
|
dig.resolve = resolve;
|
|
|
|
done();
|
|
});
|
|
|
|
it('does not fail when dns errors', async function () {
|
|
const response = await superagent.get(`${serverUrl}/api/v1/mail/${dashboardDomain}/status`)
|
|
.query({ access_token: owner.token });
|
|
|
|
expect(response.status).to.equal(200);
|
|
});
|
|
|
|
function clearDnsAnswerQueue() {
|
|
dnsAnswerQueue = { };
|
|
dnsAnswerQueue[dkimDomain] = { };
|
|
dnsAnswerQueue[spfDomain] = { };
|
|
dnsAnswerQueue[mxDomain] = { };
|
|
dnsAnswerQueue[dmarcDomain] = { };
|
|
}
|
|
|
|
it('succeeds with dns errors', async function () {
|
|
clearDnsAnswerQueue();
|
|
|
|
const response = await superagent.get(`${serverUrl}/api/v1/mail/${dashboardDomain}` + '/status')
|
|
.query({ access_token: owner.token });
|
|
expect(response.status).to.equal(200);
|
|
|
|
expect(response.body.dns.dkim).to.be.an('object');
|
|
expect(response.body.dns.dkim.domain).to.eql(dkimDomain);
|
|
expect(response.body.dns.dkim.type).to.eql('TXT');
|
|
expect(response.body.dns.dkim.value).to.eql(null);
|
|
expect(response.body.dns.dkim.expected).to.eql(`v=DKIM1; t=s; p=${publicKey}`);
|
|
expect(response.body.dns.dkim.status).to.eql(false);
|
|
|
|
expect(response.body.dns.spf).to.be.an('object');
|
|
expect(response.body.dns.spf.domain).to.eql(spfDomain);
|
|
expect(response.body.dns.spf.type).to.eql('TXT');
|
|
expect(response.body.dns.spf.value).to.eql(null);
|
|
expect(response.body.dns.spf.expected).to.eql(`v=spf1 a:${dashboardFqdn} ~all`);
|
|
expect(response.body.dns.spf.status).to.eql(false);
|
|
|
|
expect(response.body.dns.dmarc).to.be.an('object');
|
|
expect(response.body.dns.dmarc.type).to.eql('TXT');
|
|
expect(response.body.dns.dmarc.value).to.eql(null);
|
|
expect(response.body.dns.dmarc.expected).to.eql('v=DMARC1; p=reject; pct=100');
|
|
expect(response.body.dns.dmarc.status).to.eql(false);
|
|
|
|
expect(response.body.dns.mx).to.be.an('object');
|
|
expect(response.body.dns.mx.type).to.eql('MX');
|
|
expect(response.body.dns.mx.value).to.eql(null);
|
|
expect(response.body.dns.mx.expected).to.eql(`10 ${mailFqdn}.`);
|
|
expect(response.body.dns.mx.status).to.eql(false);
|
|
|
|
expect(response.body.dns.ptr4).to.be.an('object');
|
|
expect(response.body.dns.ptr4.type).to.eql('PTR');
|
|
// expect(response.body.ptr.value).to.eql(null); this will be anything random
|
|
expect(response.body.dns.ptr4.expected).to.eql(mailFqdn);
|
|
expect(response.body.dns.ptr4.status).to.eql(false);
|
|
});
|
|
|
|
it('succeeds with "undefined" spf, dkim, dmarc, mx, ptr records', async function () {
|
|
clearDnsAnswerQueue();
|
|
|
|
dnsAnswerQueue[dkimDomain].TXT = null;
|
|
dnsAnswerQueue[spfDomain].TXT = null;
|
|
dnsAnswerQueue[mxDomain].MX = null;
|
|
dnsAnswerQueue[dmarcDomain].TXT = null;
|
|
|
|
const response = await superagent.get(`${serverUrl}/api/v1/mail/${dashboardDomain}` + '/status')
|
|
.query({ access_token: owner.token });
|
|
|
|
expect(response.status).to.equal(200);
|
|
|
|
expect(response.body.dns.spf).to.be.an('object');
|
|
expect(response.body.dns.spf.expected).to.eql(`v=spf1 a:${dashboardFqdn} ~all`);
|
|
expect(response.body.dns.spf.status).to.eql(false);
|
|
expect(response.body.dns.spf.value).to.eql(null);
|
|
|
|
expect(response.body.dns.dkim).to.be.an('object');
|
|
expect(response.body.dns.dkim.expected).to.eql(`v=DKIM1; t=s; p=${publicKey}`);
|
|
expect(response.body.dns.dkim.status).to.eql(false);
|
|
expect(response.body.dns.dkim.value).to.eql(null);
|
|
|
|
expect(response.body.dns.dmarc).to.be.an('object');
|
|
expect(response.body.dns.dmarc.expected).to.eql('v=DMARC1; p=reject; pct=100');
|
|
expect(response.body.dns.dmarc.status).to.eql(false);
|
|
expect(response.body.dns.dmarc.value).to.eql(null);
|
|
|
|
expect(response.body.dns.mx).to.be.an('object');
|
|
expect(response.body.dns.mx.status).to.eql(false);
|
|
expect(response.body.dns.mx.expected).to.eql(`10 ${mailFqdn}.`);
|
|
expect(response.body.dns.mx.value).to.eql(null);
|
|
|
|
expect(response.body.dns.ptr4).to.be.an('object');
|
|
expect(response.body.dns.ptr4.expected).to.eql(mailFqdn);
|
|
expect(response.body.dns.ptr4.status).to.eql(false);
|
|
// expect(response.body.ptr.value).to.eql(null); this will be anything random
|
|
});
|
|
|
|
it('succeeds with all different spf, dkim, dmarc, mx, ptr records', async function () {
|
|
clearDnsAnswerQueue();
|
|
|
|
dnsAnswerQueue[mxDomain].MX = [ { priority: '20', exchange: mailFqdn }, { priority: '10', exchange: 'some.other.server' } ];
|
|
dnsAnswerQueue[dmarcDomain].TXT = [['v=DMARC2; p=reject; pct=100']];
|
|
dnsAnswerQueue[dkimDomain].TXT = [['v=DKIM2; t=s; p=' + publicKey]];
|
|
dnsAnswerQueue[spfDomain].TXT = [['v=spf1 a:random.com ~all']];
|
|
|
|
const response = await superagent.get(`${serverUrl}/api/v1/mail/${dashboardDomain}` + '/status')
|
|
.query({ access_token: owner.token });
|
|
|
|
expect(response.status).to.equal(200);
|
|
|
|
expect(response.body.dns.spf).to.be.an('object');
|
|
expect(response.body.dns.spf.expected).to.eql(`v=spf1 a:${dashboardFqdn} a:random.com ~all`);
|
|
expect(response.body.dns.spf.status).to.eql(false);
|
|
expect(response.body.dns.spf.value).to.eql('v=spf1 a:random.com ~all');
|
|
|
|
expect(response.body.dns.dkim).to.be.an('object');
|
|
expect(response.body.dns.dkim.expected).to.eql('v=DKIM1; t=s; p=' + publicKey);
|
|
expect(response.body.dns.dkim.status).to.eql(true); // as long as p= matches we are good
|
|
expect(response.body.dns.dkim.value).to.eql('v=DKIM2; t=s; p=' + publicKey);
|
|
|
|
expect(response.body.dns.dmarc).to.be.an('object');
|
|
expect(response.body.dns.dmarc.expected).to.eql('v=DMARC1; p=reject; pct=100');
|
|
expect(response.body.dns.dmarc.status).to.eql(false);
|
|
expect(response.body.dns.dmarc.value).to.eql('v=DMARC2; p=reject; pct=100');
|
|
|
|
expect(response.body.dns.mx).to.be.an('object');
|
|
expect(response.body.dns.mx.status).to.eql(true);
|
|
expect(response.body.dns.mx.expected).to.eql(`10 ${mailFqdn}.`);
|
|
expect(response.body.dns.mx.value).to.eql(`20 ${mailFqdn}. 10 some.other.server.`);
|
|
|
|
expect(response.body.dns.ptr4).to.be.an('object');
|
|
expect(response.body.dns.ptr4.expected).to.eql(mailFqdn);
|
|
expect(response.body.dns.ptr4.status).to.eql(false);
|
|
// expect(response.body.ptr.value).to.eql(null); this will be anything random
|
|
|
|
expect(response.body.relay).to.be.an('object');
|
|
});
|
|
|
|
it('succeeds with existing embedded spf', async function () {
|
|
clearDnsAnswerQueue();
|
|
|
|
dnsAnswerQueue[spfDomain].TXT = [['v=spf1 a:example.com a:' + mailFqdn + ' ~all']];
|
|
|
|
const response = await superagent.get(`${serverUrl}/api/v1/mail/${dashboardDomain}/status`)
|
|
.query({ access_token: owner.token });
|
|
|
|
expect(response.status).to.equal(200);
|
|
|
|
expect(response.body.dns.spf).to.be.an('object');
|
|
expect(response.body.dns.spf.domain).to.eql(spfDomain);
|
|
expect(response.body.dns.spf.type).to.eql('TXT');
|
|
expect(response.body.dns.spf.value).to.eql(`v=spf1 a:example.com a:${mailFqdn} ~all`);
|
|
expect(response.body.dns.spf.expected).to.eql(`v=spf1 a:example.com a:${mailFqdn} ~all`);
|
|
expect(response.body.dns.spf.status).to.eql(true);
|
|
});
|
|
|
|
it('succeeds with modified DMARC1 values', async function () {
|
|
clearDnsAnswerQueue();
|
|
|
|
dnsAnswerQueue[dmarcDomain].TXT = [['v=DMARC1; p=reject; rua=mailto:rua@example.com; pct=100']];
|
|
|
|
const response = await superagent.get(`${serverUrl}/api/v1/mail/${dashboardDomain}/status`)
|
|
.query({ access_token: owner.token });
|
|
|
|
expect(response.status).to.equal(200);
|
|
|
|
expect(response.body.dns.dmarc).to.be.an('object');
|
|
expect(response.body.dns.dmarc.expected).to.eql('v=DMARC1; p=reject; pct=100');
|
|
expect(response.body.dns.dmarc.status).to.eql(true);
|
|
expect(response.body.dns.dmarc.value).to.eql('v=DMARC1; p=reject; rua=mailto:rua@example.com; pct=100');
|
|
});
|
|
|
|
it('succeeds with all correct records', async function () {
|
|
clearDnsAnswerQueue();
|
|
|
|
dnsAnswerQueue[mxDomain].MX = [ { priority: '10', exchange: mailFqdn } ];
|
|
dnsAnswerQueue[dmarcDomain].TXT = [['v=DMARC1; p=reject; pct=100']];
|
|
dnsAnswerQueue[dkimDomain].TXT = [['v=DKIM1; t=s; p=', publicKey ]];
|
|
dnsAnswerQueue[spfDomain].TXT = [[`v=spf1 a:${dashboardFqdn} ~all`]];
|
|
|
|
const response = await superagent.get(`${serverUrl}/api/v1/mail/${dashboardDomain}` + '/status')
|
|
.query({ access_token: owner.token });
|
|
|
|
expect(response.status).to.equal(200);
|
|
|
|
expect(response.body.dns.dkim).to.be.an('object');
|
|
expect(response.body.dns.dkim.domain).to.eql(dkimDomain);
|
|
expect(response.body.dns.dkim.type).to.eql('TXT');
|
|
expect(response.body.dns.dkim.value).to.eql(`v=DKIM1; t=s; p=${publicKey}`);
|
|
expect(response.body.dns.dkim.expected).to.eql(`v=DKIM1; t=s; p=${publicKey}`);
|
|
expect(response.body.dns.dkim.status).to.eql(true);
|
|
|
|
expect(response.body.dns.spf).to.be.an('object');
|
|
expect(response.body.dns.spf.domain).to.eql(spfDomain);
|
|
expect(response.body.dns.spf.type).to.eql('TXT');
|
|
expect(response.body.dns.spf.value).to.eql(`v=spf1 a:${dashboardFqdn} ~all`);
|
|
expect(response.body.dns.spf.expected).to.eql(`v=spf1 a:${dashboardFqdn} ~all`);
|
|
expect(response.body.dns.spf.status).to.eql(true);
|
|
|
|
expect(response.body.dns.dmarc).to.be.an('object');
|
|
expect(response.body.dns.dmarc.expected).to.eql('v=DMARC1; p=reject; pct=100');
|
|
expect(response.body.dns.dmarc.status).to.eql(true);
|
|
expect(response.body.dns.dmarc.value).to.eql('v=DMARC1; p=reject; pct=100');
|
|
|
|
expect(response.body.dns.mx).to.be.an('object');
|
|
expect(response.body.dns.mx.status).to.eql(true);
|
|
expect(response.body.dns.mx.expected).to.eql(`10 ${mailFqdn}.`);
|
|
expect(response.body.dns.mx.value).to.eql(`10 ${mailFqdn}.`);
|
|
});
|
|
});
|
|
|
|
describe('mail from validation', function () {
|
|
it('get mail from validation succeeds', async function () {
|
|
const response = await superagent.get(`${serverUrl}/api/v1/mail/${dashboardDomain}`)
|
|
.query({ access_token: owner.token });
|
|
|
|
expect(response.status).to.equal(200);
|
|
expect(response.body.mailFromValidation).to.eql(true);
|
|
});
|
|
|
|
it('cannot set without enabled field', async function () {
|
|
const response = await superagent.post(`${serverUrl}/api/v1/mail/${dashboardDomain}/mail_from_validation`)
|
|
.query({ access_token: owner.token })
|
|
.send({ })
|
|
.ok(() => true);
|
|
|
|
expect(response.status).to.equal(400);
|
|
});
|
|
|
|
it('can set with enabled field', async function () {
|
|
const response = await superagent.post(`${serverUrl}/api/v1/mail/${dashboardDomain}/mail_from_validation`)
|
|
.query({ access_token: owner.token })
|
|
.send({ enabled: false });
|
|
|
|
expect(response.status).to.equal(202);
|
|
});
|
|
});
|
|
|
|
describe('catch_all', function () {
|
|
it('get catch_all succeeds', async function () {
|
|
const response = await superagent.get(`${serverUrl}/api/v1/mail/${dashboardDomain}`)
|
|
.query({ access_token: owner.token });
|
|
expect(response.status).to.equal(200);
|
|
expect(response.body.catchAll).to.eql([]);
|
|
});
|
|
|
|
it('cannot set without addresses field', async function () {
|
|
const response = await superagent.post(`${serverUrl}/api/v1/mail/${dashboardDomain}/catch_all`)
|
|
.query({ access_token: owner.token })
|
|
.send({ })
|
|
.ok(() => true);
|
|
|
|
expect(response.status).to.equal(400);
|
|
});
|
|
|
|
it('cannot set with bad addresses field', async function () {
|
|
const response = await superagent.post(`${serverUrl}/api/v1/mail/${dashboardDomain}/catch_all`)
|
|
.query({ access_token: owner.token })
|
|
.send({ addresses: [ 'user1', 123 ] })
|
|
.ok(() => true);
|
|
|
|
expect(response.status).to.equal(400);
|
|
});
|
|
|
|
it('cannot set with bad addresses field', async function () {
|
|
const response = await superagent.post(`${serverUrl}/api/v1/mail/${dashboardDomain}/catch_all`)
|
|
.query({ access_token: owner.token })
|
|
.send({ addresses: [ 'user1' ] })
|
|
.ok(() => true);
|
|
|
|
expect(response.status).to.equal(400);
|
|
});
|
|
|
|
it('set succeeds', async function () {
|
|
const response = await superagent.post(`${serverUrl}/api/v1/mail/${dashboardDomain}/catch_all`)
|
|
.query({ access_token: owner.token })
|
|
.send({ addresses: [ `user1@${dashboardDomain}` ] });
|
|
|
|
expect(response.status).to.equal(202);
|
|
});
|
|
|
|
it('get succeeds', async function () {
|
|
const response = await superagent.get(`${serverUrl}/api/v1/mail/${dashboardDomain}`)
|
|
.query({ access_token: owner.token });
|
|
|
|
expect(response.status).to.equal(200);
|
|
expect(response.body.catchAll).to.eql([ `user1@${dashboardDomain}` ]);
|
|
});
|
|
});
|
|
|
|
describe('mail relay', function () {
|
|
it('get mail relay succeeds', async function () {
|
|
const response = await superagent.get(`${serverUrl}/api/v1/mail/${dashboardDomain}`)
|
|
.query({ access_token: owner.token });
|
|
expect(response.status).to.equal(200);
|
|
expect(response.body.relay).to.eql({ provider: 'cloudron-smtp' });
|
|
});
|
|
|
|
it('cannot set without provider field', async function () {
|
|
const response = await superagent.post(`${serverUrl}/api/v1/mail/${dashboardDomain}/relay`)
|
|
.query({ access_token: owner.token })
|
|
.send({ })
|
|
.ok(() => true);
|
|
|
|
expect(response.status).to.equal(400);
|
|
});
|
|
|
|
it('cannot set with bad host', async function () {
|
|
const response = await superagent.post(`${serverUrl}/api/v1/mail/${dashboardDomain}/relay`)
|
|
.query({ access_token: owner.token })
|
|
.send({ provider: 'external-smtp', host: true })
|
|
.ok(() => true);
|
|
|
|
expect(response.status).to.equal(400);
|
|
});
|
|
|
|
it('set fails because mail server is unreachable', async function () {
|
|
const response = await superagent.post(`${serverUrl}/api/v1/mail/${dashboardDomain}/relay`)
|
|
.query({ access_token: owner.token })
|
|
.send({ provider: 'external-smtp', host: 'host', port: 25, username: 'u', password: 'p', tls: true })
|
|
.ok(() => true);
|
|
|
|
expect(response.status).to.equal(400);
|
|
});
|
|
|
|
it('get succeeds', async function () {
|
|
const relay = { provider: 'external-smtp', host: 'host', port: 25, username: 'u', password: 'p', tls: true };
|
|
|
|
await mail.setMailRelay(dashboardDomain, relay, { skipVerify: true });
|
|
|
|
const response = await superagent.get(`${serverUrl}/api/v1/mail/${dashboardDomain}`)
|
|
.query({ access_token: owner.token });
|
|
|
|
expect(response.status).to.equal(200);
|
|
expect(_.omit(response.body.relay, ['password'])).to.eql(_.omit(relay, ['password']));
|
|
});
|
|
});
|
|
|
|
describe('mailboxes', function () {
|
|
const MAILBOX_NAME = 'support';
|
|
|
|
it('add succeeds', async function () {
|
|
const response = await superagent.post(`${serverUrl}/api/v1/mail/${dashboardDomain}/mailboxes`)
|
|
.send({ name: MAILBOX_NAME, ownerId: owner.id, ownerType: 'user', active: true, storageQuota: 10, messagesQuota: 20 })
|
|
.query({ access_token: owner.token });
|
|
|
|
expect(response.status).to.equal(201);
|
|
});
|
|
|
|
it('cannot add again', async function () {
|
|
const response = await superagent.post(`${serverUrl}/api/v1/mail/${dashboardDomain}/mailboxes`)
|
|
.send({ name: MAILBOX_NAME, ownerId: owner.id, ownerType: 'user', active: true, storageQuota: 10, messagesQuota: 20 })
|
|
.query({ access_token: owner.token })
|
|
.ok(() => true);
|
|
|
|
expect(response.status).to.equal(409);
|
|
});
|
|
|
|
it('get fails if not exist', async function () {
|
|
const response = await superagent.get(`${serverUrl}/api/v1/mail/${dashboardDomain}/mailboxes/someuserdoesnotexist`)
|
|
.query({ access_token: owner.token })
|
|
.ok(() => true);
|
|
|
|
expect(response.status).to.equal(404);
|
|
});
|
|
|
|
it('get succeeds', async function () {
|
|
const response = await superagent.get(`${serverUrl}/api/v1/mail/${dashboardDomain}/mailboxes/${MAILBOX_NAME}`)
|
|
.query({ access_token: owner.token });
|
|
|
|
expect(response.status).to.equal(200);
|
|
expect(response.body.mailbox).to.be.an('object');
|
|
expect(response.body.mailbox.name).to.equal(MAILBOX_NAME);
|
|
expect(response.body.mailbox.ownerId).to.equal(owner.id);
|
|
expect(response.body.mailbox.ownerType).to.equal('user');
|
|
expect(response.body.mailbox.aliasName).to.equal(null);
|
|
expect(response.body.mailbox.aliasDomain).to.equal(null);
|
|
expect(response.body.mailbox.domain).to.equal(dashboardDomain);
|
|
expect(response.body.mailbox.storageQuota).to.equal(10);
|
|
expect(response.body.mailbox.messagesQuota).to.equal(20);
|
|
});
|
|
|
|
it('listing succeeds', async function () {
|
|
const response = await superagent.get(`${serverUrl}/api/v1/mail/${dashboardDomain}/mailboxes`)
|
|
.query({ access_token: owner.token });
|
|
|
|
expect(response.status).to.equal(200);
|
|
expect(response.body.mailboxes.length).to.eql(1);
|
|
expect(response.body.mailboxes[0]).to.be.an('object');
|
|
expect(response.body.mailboxes[0].name).to.equal(MAILBOX_NAME);
|
|
expect(response.body.mailboxes[0].ownerId).to.equal(owner.id);
|
|
expect(response.body.mailboxes[0].ownerType).to.equal('user');
|
|
expect(response.body.mailboxes[0].aliases).to.eql([]);
|
|
expect(response.body.mailboxes[0].domain).to.equal(dashboardDomain);
|
|
expect(response.body.mailboxes[0].storageQuota).to.equal(10);
|
|
expect(response.body.mailboxes[0].messagesQuota).to.equal(20);
|
|
});
|
|
|
|
it('disable fails even if not exist', async function () {
|
|
const response = await superagent.del(`${serverUrl}/api/v1/mail/${dashboardDomain}/mailboxes/someuserdoesnotexist`)
|
|
.send({ deleteMails: false })
|
|
.query({ access_token: owner.token })
|
|
.ok(() => true);
|
|
|
|
expect(response.status).to.equal(404);
|
|
});
|
|
|
|
it('disable succeeds', async function () {
|
|
const response = await superagent.del(`${serverUrl}/api/v1/mail/${dashboardDomain}/mailboxes/${MAILBOX_NAME}`)
|
|
.send({ deleteMails: false })
|
|
.query({ access_token: owner.token });
|
|
|
|
expect(response.status).to.equal(201);
|
|
|
|
const response2 = await superagent.get(`${serverUrl}/api/v1/mail/${dashboardDomain}` + '/mailboxes/' + MAILBOX_NAME)
|
|
.query({ access_token: owner.token })
|
|
.ok(() => true);
|
|
expect(response2.status).to.equal(404);
|
|
});
|
|
});
|
|
|
|
describe('aliases', function () {
|
|
const MAILBOX_NAME = 'support';
|
|
|
|
after(async function () {
|
|
await mail._delByDomain(dashboardDomain);
|
|
});
|
|
|
|
it('add the mailbox', async function () {
|
|
const response = await superagent.post(`${serverUrl}/api/v1/mail/${dashboardDomain}/mailboxes`)
|
|
.send({ name: MAILBOX_NAME, ownerId: owner.id, ownerType: 'user', active: true, storageQuota: 10, messagesQuota: 20 })
|
|
.query({ access_token: owner.token });
|
|
|
|
expect(response.status).to.equal(201);
|
|
});
|
|
|
|
it('set fails if aliases is missing', async function () {
|
|
const response = await superagent.put(`${serverUrl}/api/v1/mail/${dashboardDomain}/mailboxes/${MAILBOX_NAME}/aliases`)
|
|
.query({ access_token: owner.token })
|
|
.ok(() => true);
|
|
|
|
expect(response.status).to.equal(400);
|
|
});
|
|
|
|
it('set fails if user does not exist', async function () {
|
|
const response = await superagent.put(`${serverUrl}/api/v1/mail/${dashboardDomain}/mailboxes/randomuser/aliases`)
|
|
.send({ aliases: [{ name: 'hello', domain: dashboardDomain}, {name: 'there', domain: dashboardDomain}] })
|
|
.query({ access_token: owner.token })
|
|
.ok(() => true);
|
|
|
|
expect(response.status).to.equal(404);
|
|
});
|
|
|
|
it('set fails if aliases is the wrong type', async function () {
|
|
const response = await superagent.put(`${serverUrl}/api/v1/mail/${dashboardDomain}/mailboxes/${MAILBOX_NAME}/aliases`)
|
|
.send({ aliases: 'hello, there' })
|
|
.query({ access_token: owner.token })
|
|
.ok(() => true);
|
|
|
|
expect(response.status).to.equal(400);
|
|
});
|
|
|
|
it('set succeeds', async function () {
|
|
const response = await superagent.put(`${serverUrl}/api/v1/mail/${dashboardDomain}/mailboxes/${MAILBOX_NAME}/aliases`)
|
|
.send({ aliases: [{ name: 'hello*', domain: dashboardDomain}, {name: 'there', domain: dashboardDomain}] })
|
|
.query({ access_token: owner.token });
|
|
|
|
expect(response.status).to.equal(202);
|
|
});
|
|
|
|
it('get succeeds', async function () {
|
|
const response = await superagent.get(`${serverUrl}/api/v1/mail/${dashboardDomain}` + '/mailboxes/' + MAILBOX_NAME + '/aliases')
|
|
.query({ access_token: owner.token });
|
|
|
|
expect(response.status).to.equal(200);
|
|
expect(response.body.aliases).to.eql([{ name: 'hello*', domain: dashboardDomain}, {name: 'there', domain: dashboardDomain}]);
|
|
});
|
|
|
|
it('get fails if mailbox does not exist', async function () {
|
|
const response = await superagent.get(`${serverUrl}/api/v1/mail/${dashboardDomain}` + '/mailboxes/somerandomuser/aliases')
|
|
.query({ access_token: owner.token })
|
|
.ok(() => true);
|
|
|
|
expect(response.status).to.equal(404);
|
|
});
|
|
});
|
|
|
|
describe('mailinglists', function () {
|
|
const LIST_NAME = 'people';
|
|
|
|
after(async function () {
|
|
await mail._delByDomain(dashboardDomain);
|
|
});
|
|
|
|
it('add fails without groupId', async function () {
|
|
const response = await superagent.post(`${serverUrl}/api/v1/mail/${dashboardDomain}/lists`)
|
|
.query({ access_token: owner.token })
|
|
.ok(() => true);
|
|
|
|
expect(response.status).to.equal(400);
|
|
});
|
|
|
|
it('add fails with invalid groupId', async function () {
|
|
const response = await superagent.post(`${serverUrl}/api/v1/mail/${dashboardDomain}/lists`)
|
|
.send({ groupId: {} })
|
|
.query({ access_token: owner.token })
|
|
.ok(() => true);
|
|
|
|
expect(response.status).to.equal(400);
|
|
});
|
|
|
|
it('add fails without members array', async function () {
|
|
const response = await superagent.post(`${serverUrl}/api/v1/mail/${dashboardDomain}/lists`)
|
|
.send({ name: LIST_NAME })
|
|
.query({ access_token: owner.token })
|
|
.ok(() => true);
|
|
|
|
expect(response.status).to.equal(400);
|
|
});
|
|
|
|
it('add succeeds', async function () {
|
|
const response = await superagent.post(`${serverUrl}/api/v1/mail/${dashboardDomain}/lists`)
|
|
.send({ name: LIST_NAME, members: [ `admin2@${dashboardDomain}`, `${owner.username}@${dashboardDomain}`], membersOnly: false, active: true })
|
|
.query({ access_token: owner.token });
|
|
|
|
expect(response.status).to.equal(201);
|
|
});
|
|
|
|
it('add twice fails', async function () {
|
|
const response = await superagent.post(`${serverUrl}/api/v1/mail/${dashboardDomain}/lists`)
|
|
.send({ name: LIST_NAME, members: [ `admin2@${dashboardDomain}`, `${owner.username}@${dashboardDomain}`], membersOnly: false, active: true })
|
|
.query({ access_token: owner.token })
|
|
.ok(() => true);
|
|
|
|
expect(response.status).to.equal(409);
|
|
});
|
|
|
|
it('get fails if not exist', async function (){
|
|
const response = await superagent.get(`${serverUrl}/api/v1/mail/${dashboardDomain}/lists/doesnotexist`)
|
|
.query({ access_token: owner.token })
|
|
.ok(() => true);
|
|
|
|
expect(response.status).to.equal(404);
|
|
});
|
|
|
|
it('get succeeds', async function () {
|
|
const response = await superagent.get(`${serverUrl}/api/v1/mail/${dashboardDomain}/lists/${LIST_NAME}`)
|
|
.query({ access_token: owner.token });
|
|
|
|
expect(response.status).to.equal(200);
|
|
expect(response.body.list).to.be.an('object');
|
|
expect(response.body.list.name).to.equal(LIST_NAME);
|
|
expect(response.body.list.ownerId).to.equal('admin');
|
|
expect(response.body.list.aliasName).to.equal(null);
|
|
expect(response.body.list.domain).to.equal(dashboardDomain);
|
|
expect(response.body.list.members).to.eql([ `admin2@${dashboardDomain}`, `superadmin@${dashboardDomain}` ]);
|
|
expect(response.body.list.membersOnly).to.be(false);
|
|
});
|
|
|
|
it('get all succeeds', async function () {
|
|
const response = await superagent.get(`${serverUrl}/api/v1/mail/${dashboardDomain}/lists`)
|
|
.query({ access_token: owner.token });
|
|
|
|
expect(response.status).to.equal(200);
|
|
expect(response.body.lists).to.be.an(Array);
|
|
expect(response.body.lists.length).to.equal(1);
|
|
expect(response.body.lists[0].name).to.equal(LIST_NAME);
|
|
expect(response.body.lists[0].ownerId).to.equal('admin');
|
|
expect(response.body.lists[0].aliasName).to.equal(null);
|
|
expect(response.body.lists[0].domain).to.equal(dashboardDomain);
|
|
expect(response.body.lists[0].members).to.eql([ `admin2@${dashboardDomain}`, `superadmin@${dashboardDomain}` ]);
|
|
expect(response.body.lists[0].membersOnly).to.be(false);
|
|
});
|
|
|
|
it('del fails if list does not exist', async function () {
|
|
const response = await superagent.del(`${serverUrl}/api/v1/mail/${dashboardDomain}` + '/lists/' + 'doesnotexist')
|
|
.query({ access_token: owner.token })
|
|
.ok(() => true);
|
|
|
|
expect(response.status).to.equal(404);
|
|
});
|
|
|
|
it('del succeeds', async function () {
|
|
const response = await superagent.del(`${serverUrl}/api/v1/mail/${dashboardDomain}/lists/${LIST_NAME}`)
|
|
.query({ access_token: owner.token });
|
|
|
|
expect(response.status).to.equal(204);
|
|
|
|
const response2 = await superagent.get(`${serverUrl}/api/v1/mail/${dashboardDomain}/lists/${LIST_NAME}`)
|
|
.query({ access_token: owner.token })
|
|
.ok(() => true);
|
|
|
|
expect(response2.status).to.equal(404);
|
|
});
|
|
});
|
|
});
|