jjkiers/cloudron-box
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity
Files
ea430b255bbeaedf0c87b0d8a9d5747cb31046e1
cloudron-box/src/routes/test/mail-test.js
T

857 lines
37 KiB
JavaScript
Raw Normal View History

Move email_status into mail route
2018-01-20 18:30:14 -08:00
'use strict';
/* global it:false */
/* global describe:false */
/* global before:false */
/* global after:false */
var async = require('async'),
Make port a constant
2019-07-25 15:43:51 -07:00
constants = require('../../constants.js'),
tokens: add lastUsedTime
2021-03-15 12:47:57 -07:00
crypto = require('crypto'),
Move email_status into mail route
2018-01-20 18:30:14 -08:00
database = require('../../database.js'),
expect = require('expect.js'),
readDkimPublicKeySync has moved
2018-01-25 15:38:29 -08:00
mail = require('../../mail.js'),
Fix mail route tests
2018-01-21 00:40:30 -08:00
maildb = require('../../maildb.js'),
Move email_status into mail route
2018-01-20 18:30:14 -08:00
server = require('../../server.js'),
config.js is dead, long live config.js
2019-07-26 10:49:29 -07:00
settings = require('../../settings.js'),
Add mailbox rest api tests
2018-01-29 18:51:53 +01:00
superagent = require('superagent'),
Hide mail relay password
2019-02-15 10:55:15 -08:00
userdb = require('../../userdb.js'),
_ = require('underscore');
Move email_status into mail route
2018-01-20 18:30:14 -08:00
Make port a constant
2019-07-25 15:43:51 -07:00
var SERVER_URL = 'http://localhost:' + constants.PORT;
Move email_status into mail route
2018-01-20 18:30:14 -08:00
admin -> dashboard
2021-05-05 12:29:04 -07:00
const DASHBOARD_DOMAIN = {
Fix tests
2018-09-10 11:22:40 -07:00
domain: 'admin.com',
zoneName: 'admin.com',
config: {},
provider: 'noop',
fallbackCertificate: null,
tlsConfig: { provider: 'fallback' }
};
Add email domain rest api CRUD testing
2018-01-29 17:18:01 +01:00
const DOMAIN_0 = {
domain: 'example-mail-test.com',
zoneName: 'example-mail-test.com',
config: {},
provider: 'noop',
Fixup all the tests to use domain tlsConfig
2018-01-31 18:09:38 +01:00
fallbackCertificate: null,
tlsConfig: { provider: 'fallback' }
Add email domain rest api CRUD testing
2018-01-29 17:18:01 +01:00
};
Fix mail rest api tests
2018-04-13 12:54:40 +02:00
const USERNAME = 'superadmin', PASSWORD = 'Foobar?1337', EMAIL ='silly@me.com', MAILBOX_NAME = 'superman';
const LIST_NAME = 'devs';
Move email_status into mail route
2018-01-20 18:30:14 -08:00
var token = null;
Add mailbox rest api tests
2018-01-29 18:51:53 +01:00
var userId = '';
Move email_status into mail route
2018-01-20 18:30:14 -08:00
function setup(done) {
async.series([
server.start.bind(null),
database._clear.bind(null),
Fix tests
2018-09-10 11:22:40 -07:00
function dnsSetup(callback) {
dnsSetup -> setup
2018-10-30 13:36:00 -07:00
superagent.post(SERVER_URL + '/api/v1/cloudron/setup')
admin -> dashboard
2021-05-05 12:29:04 -07:00
.send({ dnsConfig: { provider: DASHBOARD_DOMAIN.provider, domain: DASHBOARD_DOMAIN.domain, config: DASHBOARD_DOMAIN.config, tlsConfig: { provider: 'fallback' } } })
Fix tests
2018-09-10 11:22:40 -07:00
.end(function (error, result) {
expect(result).to.be.ok();
expect(result.statusCode).to.eql(200);
callback();
});
},
Move email_status into mail route
2018-01-20 18:30:14 -08:00
Fix setup and restore to have a task style API
2018-12-15 15:27:16 -08:00
function waitForSetup(done) {
async.retry({ times: 5, interval: 4000 }, function (retryCallback) {
superagent.get(SERVER_URL + '/api/v1/cloudron/status')
.end(function (error, result) {
if (!result || result.statusCode !== 200) return retryCallback(new Error('Bad result'));
if (!result.body.setup.active && result.body.setup.errorMessage === '' && result.body.adminFqdn) return retryCallback();
retryCallback(new Error('Not done yet: ' + JSON.stringify(result.body)));
});
}, done);
},
Move email_status into mail route
2018-01-20 18:30:14 -08:00
function createAdmin(callback) {
superagent.post(SERVER_URL + '/api/v1/cloudron/activate')
.query({ setupToken: 'somesetuptoken' })
.send({ username: USERNAME, password: PASSWORD, email: EMAIL })
.end(function (error, result) {
Add mailbox rest api tests
2018-01-29 18:51:53 +01:00
expect(error).to.not.be.ok();
Move email_status into mail route
2018-01-20 18:30:14 -08:00
expect(result).to.be.ok();
expect(result.statusCode).to.eql(201);
// stash token for further use
token = result.body.token;
callback();
});
Add mailbox rest api tests
2018-01-29 18:51:53 +01:00
},
Fix tests
2018-09-10 11:22:40 -07:00
function createDomain(callback) {
superagent.post(SERVER_URL + '/api/v1/domains')
.query({ access_token: token })
.send(DOMAIN_0)
.end(function (error, result) {
expect(result.statusCode).to.equal(201);
callback();
});
},
Add mailbox rest api tests
2018-01-29 18:51:53 +01:00
function getUserId(callback) {
userdb.getByUsername(USERNAME, function (error, result) {
expect(error).to.not.be.ok();
userId = result.id;
callback();
});
Move email_status into mail route
2018-01-20 18:30:14 -08:00
}
], done);
}
function cleanup(done) {
database._clear(function (error) {
expect(!error).to.be.ok();
server.stop(done);
});
}
describe('Mail API', function () {
before(setup);
after(cleanup);
Add email domain rest api CRUD testing
2018-01-29 17:18:01 +01:00
describe('crud', function () {
it('cannot get non-existing domain', function (done) {
superagent.get(SERVER_URL + '/api/v1/mail/doesnotexist.com')
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(404);
done();
});
});
it('can get domain', function (done) {
superagent.get(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain)
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(200);
expect(res.body.domain).to.equal(DOMAIN_0.domain);
expect(res.body.enabled).to.equal(false);
expect(res.body.mailFromValidation).to.equal(true);
expect(res.body.catchAll).to.be.an(Array);
expect(res.body.catchAll.length).to.equal(0);
expect(res.body.relay).to.be.an('object');
expect(res.body.relay.provider).to.equal('cloudron-smtp');
done();
});
});
});
fix email route tests
2018-01-29 17:45:10 +01:00
describe('status', function () {
Move email_status into mail route
2018-01-20 18:30:14 -08:00
var resolve = null;
var dnsAnswerQueue = [];
var dkimDomain, spfDomain, mxDomain, dmarcDomain;
before(function (done) {
Use the native dns resolver
2018-02-08 10:21:31 -08:00
var dns = require('../../native-dns.js');
Move email_status into mail route
2018-01-20 18:30:14 -08:00
// replace dns resolveTxt()
Use the native dns resolver
2018-02-08 10:21:31 -08:00
resolve = dns.resolve;
dns.resolve = function (hostname, type, options, callback) {
Move email_status into mail route
2018-01-20 18:30:14 -08:00
expect(hostname).to.be.a('string');
expect(callback).to.be.a('function');
if (!dnsAnswerQueue[hostname] || !(type in dnsAnswerQueue[hostname])) return callback(new Error('no mock answer'));
Use the native dns resolver
2018-02-08 10:21:31 -08:00
if (dnsAnswerQueue[hostname][type] === null) return callback(new Error({ code: 'ENODATA'} ));
Move email_status into mail route
2018-01-20 18:30:14 -08:00
callback(null, dnsAnswerQueue[hostname][type]);
};
admin -> dashboard
2021-05-05 12:29:04 -07:00
const suffix = crypto.createHash('sha256').update(settings.dashboardDomain()).digest('hex').substr(0, 6);
tokens: add lastUsedTime
2021-03-15 12:47:57 -07:00
dkimDomain = `cloudron-${suffix}._domainkey.${DOMAIN_0.domain}`;
Add email domain rest api CRUD testing
2018-01-29 17:18:01 +01:00
spfDomain = DOMAIN_0.domain;
mxDomain = DOMAIN_0.domain;
dmarcDomain = '_dmarc.' + DOMAIN_0.domain;
Move email_status into mail route
2018-01-20 18:30:14 -08:00
remove mail domain add/remove API
2020-03-31 12:04:46 -07:00
superagent.post(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/enable')
fix email route tests
2018-01-29 17:45:10 +01:00
.query({ access_token: token })
remove mail domain add/remove API
2020-03-31 12:04:46 -07:00
.send({ enabled: true })
fix email route tests
2018-01-29 17:45:10 +01:00
.end(function (err, res) {
remove mail domain add/remove API
2020-03-31 12:04:46 -07:00
expect(res.statusCode).to.equal(202);
make mail test pass
2019-02-08 11:08:14 -08:00
remove mail domain add/remove API
2020-03-31 12:04:46 -07:00
done();
Use the native dns resolver
2018-02-08 10:21:31 -08:00
});
Move email_status into mail route
2018-01-20 18:30:14 -08:00
});
after(function (done) {
Use the native dns resolver
2018-02-08 10:21:31 -08:00
var dns = require('../../native-dns.js');
Move email_status into mail route
2018-01-20 18:30:14 -08:00
Use the native dns resolver
2018-02-08 10:21:31 -08:00
dns.resolve = resolve;
Move email_status into mail route
2018-01-20 18:30:14 -08:00
remove mail domain add/remove API
2020-03-31 12:04:46 -07:00
done();
Move email_status into mail route
2018-01-20 18:30:14 -08:00
});
it('does not fail when dns errors', function (done) {
Add email domain rest api CRUD testing
2018-01-29 17:18:01 +01:00
superagent.get(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/status')
Move email_status into mail route
2018-01-20 18:30:14 -08:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(200);
done();
});
});
function clearDnsAnswerQueue() {
dnsAnswerQueue = { };
dnsAnswerQueue[dkimDomain] = { };
dnsAnswerQueue[spfDomain] = { };
dnsAnswerQueue[mxDomain] = { };
dnsAnswerQueue[dmarcDomain] = { };
}
it('succeeds with dns errors', function (done) {
clearDnsAnswerQueue();
Add email domain rest api CRUD testing
2018-01-29 17:18:01 +01:00
superagent.get(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/status')
Move email_status into mail route
2018-01-20 18:30:14 -08:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(200);
expect(res.body.dns.dkim).to.be.an('object');
expect(res.body.dns.dkim.domain).to.eql(dkimDomain);
expect(res.body.dns.dkim.type).to.eql('TXT');
expect(res.body.dns.dkim.value).to.eql(null);
Use the native dns resolver
2018-02-08 10:21:31 -08:00
expect(res.body.dns.dkim.expected).to.eql('v=DKIM1; t=s; p=' + mail._readDkimPublicKeySync(DOMAIN_0.domain));
Move email_status into mail route
2018-01-20 18:30:14 -08:00
expect(res.body.dns.dkim.status).to.eql(false);
expect(res.body.dns.spf).to.be.an('object');
expect(res.body.dns.spf.domain).to.eql(spfDomain);
expect(res.body.dns.spf.type).to.eql('TXT');
expect(res.body.dns.spf.value).to.eql(null);
admin -> dashboard
2021-05-05 12:29:04 -07:00
expect(res.body.dns.spf.expected).to.eql('v=spf1 a:' + settings.dashboardFqdn() + ' ~all');
Move email_status into mail route
2018-01-20 18:30:14 -08:00
expect(res.body.dns.spf.status).to.eql(false);
expect(res.body.dns.dmarc).to.be.an('object');
expect(res.body.dns.dmarc.type).to.eql('TXT');
expect(res.body.dns.dmarc.value).to.eql(null);
Use the native dns resolver
2018-02-08 10:21:31 -08:00
expect(res.body.dns.dmarc.expected).to.eql('v=DMARC1; p=reject; pct=100');
Move email_status into mail route
2018-01-20 18:30:14 -08:00
expect(res.body.dns.dmarc.status).to.eql(false);
expect(res.body.dns.mx).to.be.an('object');
expect(res.body.dns.mx.type).to.eql('MX');
expect(res.body.dns.mx.value).to.eql(null);
config.js is dead, long live config.js
2019-07-26 10:49:29 -07:00
expect(res.body.dns.mx.expected).to.eql('10 ' + settings.mailFqdn() + '.');
Move email_status into mail route
2018-01-20 18:30:14 -08:00
expect(res.body.dns.mx.status).to.eql(false);
expect(res.body.dns.ptr).to.be.an('object');
expect(res.body.dns.ptr.type).to.eql('PTR');
// expect(res.body.ptr.value).to.eql(null); this will be anything random
config.js is dead, long live config.js
2019-07-26 10:49:29 -07:00
expect(res.body.dns.ptr.expected).to.eql(settings.mailFqdn());
Move email_status into mail route
2018-01-20 18:30:14 -08:00
expect(res.body.dns.ptr.status).to.eql(false);
done();
});
});
it('succeeds with "undefined" spf, dkim, dmarc, mx, ptr records', function (done) {
clearDnsAnswerQueue();
dnsAnswerQueue[dkimDomain].TXT = null;
dnsAnswerQueue[spfDomain].TXT = null;
dnsAnswerQueue[mxDomain].MX = null;
dnsAnswerQueue[dmarcDomain].TXT = null;
Add email domain rest api CRUD testing
2018-01-29 17:18:01 +01:00
superagent.get(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/status')
Move email_status into mail route
2018-01-20 18:30:14 -08:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(200);
expect(res.body.dns.spf).to.be.an('object');
admin -> dashboard
2021-05-05 12:29:04 -07:00
expect(res.body.dns.spf.expected).to.eql('v=spf1 a:' + settings.dashboardFqdn() + ' ~all');
Move email_status into mail route
2018-01-20 18:30:14 -08:00
expect(res.body.dns.spf.status).to.eql(false);
expect(res.body.dns.spf.value).to.eql(null);
expect(res.body.dns.dkim).to.be.an('object');
Use the native dns resolver
2018-02-08 10:21:31 -08:00
expect(res.body.dns.dkim.expected).to.eql('v=DKIM1; t=s; p=' + mail._readDkimPublicKeySync(DOMAIN_0.domain));
Move email_status into mail route
2018-01-20 18:30:14 -08:00
expect(res.body.dns.dkim.status).to.eql(false);
expect(res.body.dns.dkim.value).to.eql(null);
expect(res.body.dns.dmarc).to.be.an('object');
Use the native dns resolver
2018-02-08 10:21:31 -08:00
expect(res.body.dns.dmarc.expected).to.eql('v=DMARC1; p=reject; pct=100');
Move email_status into mail route
2018-01-20 18:30:14 -08:00
expect(res.body.dns.dmarc.status).to.eql(false);
expect(res.body.dns.dmarc.value).to.eql(null);
expect(res.body.dns.mx).to.be.an('object');
expect(res.body.dns.mx.status).to.eql(false);
config.js is dead, long live config.js
2019-07-26 10:49:29 -07:00
expect(res.body.dns.mx.expected).to.eql('10 ' + settings.mailFqdn() + '.');
Move email_status into mail route
2018-01-20 18:30:14 -08:00
expect(res.body.dns.mx.value).to.eql(null);
expect(res.body.dns.ptr).to.be.an('object');
config.js is dead, long live config.js
2019-07-26 10:49:29 -07:00
expect(res.body.dns.ptr.expected).to.eql(settings.mailFqdn());
Move email_status into mail route
2018-01-20 18:30:14 -08:00
expect(res.body.dns.ptr.status).to.eql(false);
// expect(res.body.ptr.value).to.eql(null); this will be anything random
done();
});
});
it('succeeds with all different spf, dkim, dmarc, mx, ptr records', function (done) {
clearDnsAnswerQueue();
mail: allow alternate mx
2020-04-22 17:16:52 -07:00
dnsAnswerQueue[mxDomain].MX = [ { priority: '20', exchange: settings.mailFqdn() }, { priority: '10', exchange: 'some.other.server' } ];
Use the native dns resolver
2018-02-08 10:21:31 -08:00
dnsAnswerQueue[dmarcDomain].TXT = [['v=DMARC2; p=reject; pct=100']];
dnsAnswerQueue[dkimDomain].TXT = [['v=DKIM2; t=s; p=' + mail._readDkimPublicKeySync(DOMAIN_0.domain)]];
dnsAnswerQueue[spfDomain].TXT = [['v=spf1 a:random.com ~all']];
Move email_status into mail route
2018-01-20 18:30:14 -08:00
Add email domain rest api CRUD testing
2018-01-29 17:18:01 +01:00
superagent.get(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/status')
Move email_status into mail route
2018-01-20 18:30:14 -08:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(200);
expect(res.body.dns.spf).to.be.an('object');
admin -> dashboard
2021-05-05 12:29:04 -07:00
expect(res.body.dns.spf.expected).to.eql('v=spf1 a:' + settings.dashboardFqdn() + ' a:random.com ~all');
Move email_status into mail route
2018-01-20 18:30:14 -08:00
expect(res.body.dns.spf.status).to.eql(false);
Use the native dns resolver
2018-02-08 10:21:31 -08:00
expect(res.body.dns.spf.value).to.eql('v=spf1 a:random.com ~all');
Move email_status into mail route
2018-01-20 18:30:14 -08:00
expect(res.body.dns.dkim).to.be.an('object');
Use the native dns resolver
2018-02-08 10:21:31 -08:00
expect(res.body.dns.dkim.expected).to.eql('v=DKIM1; t=s; p=' + mail._readDkimPublicKeySync(DOMAIN_0.domain));
add membersOnly flag to a mailing list
2020-04-17 16:55:23 -07:00
expect(res.body.dns.dkim.status).to.eql(true); // as long as p= matches we are good
Use the native dns resolver
2018-02-08 10:21:31 -08:00
expect(res.body.dns.dkim.value).to.eql('v=DKIM2; t=s; p=' + mail._readDkimPublicKeySync(DOMAIN_0.domain));
Move email_status into mail route
2018-01-20 18:30:14 -08:00
expect(res.body.dns.dmarc).to.be.an('object');
Use the native dns resolver
2018-02-08 10:21:31 -08:00
expect(res.body.dns.dmarc.expected).to.eql('v=DMARC1; p=reject; pct=100');
Move email_status into mail route
2018-01-20 18:30:14 -08:00
expect(res.body.dns.dmarc.status).to.eql(false);
Use the native dns resolver
2018-02-08 10:21:31 -08:00
expect(res.body.dns.dmarc.value).to.eql('v=DMARC2; p=reject; pct=100');
Move email_status into mail route
2018-01-20 18:30:14 -08:00
expect(res.body.dns.mx).to.be.an('object');
mail: allow alternate mx
2020-04-22 17:16:52 -07:00
expect(res.body.dns.mx.status).to.eql(true);
config.js is dead, long live config.js
2019-07-26 10:49:29 -07:00
expect(res.body.dns.mx.expected).to.eql('10 ' + settings.mailFqdn() + '.');
mail: allow alternate mx
2020-04-22 17:16:52 -07:00
expect(res.body.dns.mx.value).to.eql('20 ' + settings.mailFqdn() + '. 10 some.other.server.');
Move email_status into mail route
2018-01-20 18:30:14 -08:00
expect(res.body.dns.ptr).to.be.an('object');
config.js is dead, long live config.js
2019-07-26 10:49:29 -07:00
expect(res.body.dns.ptr.expected).to.eql(settings.mailFqdn());
Move email_status into mail route
2018-01-20 18:30:14 -08:00
expect(res.body.dns.ptr.status).to.eql(false);
// expect(res.body.ptr.value).to.eql(null); this will be anything random
expect(res.body.relay).to.be.an('object');
done();
});
});
it('succeeds with existing embedded spf', function (done) {
clearDnsAnswerQueue();
config.js is dead, long live config.js
2019-07-26 10:49:29 -07:00
dnsAnswerQueue[spfDomain].TXT = [['v=spf1 a:example.com a:' + settings.mailFqdn() + ' ~all']];
Move email_status into mail route
2018-01-20 18:30:14 -08:00
Add email domain rest api CRUD testing
2018-01-29 17:18:01 +01:00
superagent.get(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/status')
Move email_status into mail route
2018-01-20 18:30:14 -08:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(200);
expect(res.body.dns.spf).to.be.an('object');
expect(res.body.dns.spf.domain).to.eql(spfDomain);
expect(res.body.dns.spf.type).to.eql('TXT');
config.js is dead, long live config.js
2019-07-26 10:49:29 -07:00
expect(res.body.dns.spf.value).to.eql('v=spf1 a:example.com a:' + settings.mailFqdn() + ' ~all');
expect(res.body.dns.spf.expected).to.eql('v=spf1 a:example.com a:' + settings.mailFqdn() + ' ~all');
Move email_status into mail route
2018-01-20 18:30:14 -08:00
expect(res.body.dns.spf.status).to.eql(true);
done();
});
});
Add more detailed checking of DMARC
2018-08-12 13:43:45 -07:00
it('succeeds with modified DMARC1 values', function (done) {
clearDnsAnswerQueue();
dnsAnswerQueue[dmarcDomain].TXT = [['v=DMARC1; p=reject; rua=mailto:rua@example.com; pct=100']];
superagent.get(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/status')
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(200);
expect(res.body.dns.dmarc).to.be.an('object');
expect(res.body.dns.dmarc.expected).to.eql('v=DMARC1; p=reject; pct=100');
expect(res.body.dns.dmarc.status).to.eql(true);
expect(res.body.dns.dmarc.value).to.eql('v=DMARC1; p=reject; rua=mailto:rua@example.com; pct=100');
done();
});
});
Move email_status into mail route
2018-01-20 18:30:14 -08:00
it('succeeds with all correct records', function (done) {
clearDnsAnswerQueue();
config.js is dead, long live config.js
2019-07-26 10:49:29 -07:00
dnsAnswerQueue[mxDomain].MX = [ { priority: '10', exchange: settings.mailFqdn() } ];
Use the native dns resolver
2018-02-08 10:21:31 -08:00
dnsAnswerQueue[dmarcDomain].TXT = [['v=DMARC1; p=reject; pct=100']];
dnsAnswerQueue[dkimDomain].TXT = [['v=DKIM1; t=s; p=', mail._readDkimPublicKeySync(DOMAIN_0.domain) ]];
admin -> dashboard
2021-05-05 12:29:04 -07:00
dnsAnswerQueue[spfDomain].TXT = [['v=spf1 a:' + settings.dashboardFqdn() + ' ~all']];
Move email_status into mail route
2018-01-20 18:30:14 -08:00
Add email domain rest api CRUD testing
2018-01-29 17:18:01 +01:00
superagent.get(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/status')
Move email_status into mail route
2018-01-20 18:30:14 -08:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(200);
expect(res.body.dns.dkim).to.be.an('object');
expect(res.body.dns.dkim.domain).to.eql(dkimDomain);
expect(res.body.dns.dkim.type).to.eql('TXT');
Use the native dns resolver
2018-02-08 10:21:31 -08:00
expect(res.body.dns.dkim.value).to.eql('v=DKIM1; t=s; p=' + mail._readDkimPublicKeySync(DOMAIN_0.domain));
expect(res.body.dns.dkim.expected).to.eql('v=DKIM1; t=s; p=' + mail._readDkimPublicKeySync(DOMAIN_0.domain));
Move email_status into mail route
2018-01-20 18:30:14 -08:00
expect(res.body.dns.dkim.status).to.eql(true);
expect(res.body.dns.spf).to.be.an('object');
expect(res.body.dns.spf.domain).to.eql(spfDomain);
expect(res.body.dns.spf.type).to.eql('TXT');
admin -> dashboard
2021-05-05 12:29:04 -07:00
expect(res.body.dns.spf.value).to.eql('v=spf1 a:' + settings.dashboardFqdn() + ' ~all');
expect(res.body.dns.spf.expected).to.eql('v=spf1 a:' + settings.dashboardFqdn() + ' ~all');
Move email_status into mail route
2018-01-20 18:30:14 -08:00
expect(res.body.dns.spf.status).to.eql(true);
expect(res.body.dns.dmarc).to.be.an('object');
Use the native dns resolver
2018-02-08 10:21:31 -08:00
expect(res.body.dns.dmarc.expected).to.eql('v=DMARC1; p=reject; pct=100');
Move email_status into mail route
2018-01-20 18:30:14 -08:00
expect(res.body.dns.dmarc.status).to.eql(true);
Use the native dns resolver
2018-02-08 10:21:31 -08:00
expect(res.body.dns.dmarc.value).to.eql('v=DMARC1; p=reject; pct=100');
Move email_status into mail route
2018-01-20 18:30:14 -08:00
expect(res.body.dns.mx).to.be.an('object');
expect(res.body.dns.mx.status).to.eql(true);
config.js is dead, long live config.js
2019-07-26 10:49:29 -07:00
expect(res.body.dns.mx.expected).to.eql('10 ' + settings.mailFqdn() + '.');
expect(res.body.dns.mx.value).to.eql('10 ' + settings.mailFqdn() + '.');
Move email_status into mail route
2018-01-20 18:30:14 -08:00
done();
});
});
});
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
fix email route tests
2018-01-29 17:45:10 +01:00
describe('mail from validation', function () {
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
it('get mail from validation succeeds', function (done) {
Add email domain rest api CRUD testing
2018-01-29 17:18:01 +01:00
superagent.get(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain)
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(200);
Fix mail route tests
2018-01-21 00:40:30 -08:00
expect(res.body.mailFromValidation).to.eql(true);
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
done();
});
});
it('cannot set without enabled field', function (done) {
fix email route tests
2018-01-29 17:45:10 +01:00
superagent.post(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/mail_from_validation')
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
.query({ access_token: token })
.send({ })
.end(function (err, res) {
expect(res.statusCode).to.equal(400);
done();
});
});
it('can set with enabled field', function (done) {
fix email route tests
2018-01-29 17:45:10 +01:00
superagent.post(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/mail_from_validation')
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
.query({ access_token: token })
.send({ enabled: false })
.end(function (err, res) {
expect(res.statusCode).to.equal(202);
done();
});
});
});
fix email route tests
2018-01-29 17:45:10 +01:00
describe('catch_all', function () {
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
it('get catch_all succeeds', function (done) {
fix email route tests
2018-01-29 17:45:10 +01:00
superagent.get(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain)
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(200);
Fix mail route tests
2018-01-21 00:40:30 -08:00
expect(res.body.catchAll).to.eql([ ]);
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
done();
});
});
Fix mail rest api tests
2018-04-13 12:54:40 +02:00
it('cannot set without addresses field', function (done) {
fix email route tests
2018-01-29 17:45:10 +01:00
superagent.post(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/catch_all')
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(400);
done();
});
});
Fix mail rest api tests
2018-04-13 12:54:40 +02:00
it('cannot set with bad addresses field', function (done) {
fix email route tests
2018-01-29 17:45:10 +01:00
superagent.post(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/catch_all')
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
.query({ access_token: token })
Fix mail rest api tests
2018-04-13 12:54:40 +02:00
.send({ addresses: [ 'user1', 123 ] })
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
.end(function (err, res) {
expect(res.statusCode).to.equal(400);
done();
});
});
it('set succeeds', function (done) {
fix email route tests
2018-01-29 17:45:10 +01:00
superagent.post(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/catch_all')
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
.query({ access_token: token })
Fix mail rest api tests
2018-04-13 12:54:40 +02:00
.send({ addresses: [ 'user1' ] })
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
.end(function (err, res) {
expect(res.statusCode).to.equal(202);
done();
});
});
it('get succeeds', function (done) {
fix email route tests
2018-01-29 17:45:10 +01:00
superagent.get(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain)
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(200);
Fix mail route tests
2018-01-21 00:40:30 -08:00
expect(res.body.catchAll).to.eql([ 'user1' ]);
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
done();
});
});
});
fix email route tests
2018-01-29 17:45:10 +01:00
describe('mail relay', function () {
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
it('get mail relay succeeds', function (done) {
fix email route tests
2018-01-29 17:45:10 +01:00
superagent.get(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain)
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(200);
Fix mail route tests
2018-01-21 00:40:30 -08:00
expect(res.body.relay).to.eql({ provider: 'cloudron-smtp' });
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
done();
});
});
it('cannot set without provider field', function (done) {
fix email route tests
2018-01-29 17:45:10 +01:00
superagent.post(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/relay')
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
.query({ access_token: token })
.send({ })
.end(function (err, res) {
expect(res.statusCode).to.equal(400);
done();
});
});
it('cannot set with bad host', function (done) {
fix email route tests
2018-01-29 17:45:10 +01:00
superagent.post(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/relay')
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
.query({ access_token: token })
.send({ provider: 'external-smtp', host: true })
.end(function (err, res) {
expect(res.statusCode).to.equal(400);
done();
});
});
it('set fails because mail server is unreachable', function (done) {
fix email route tests
2018-01-29 17:45:10 +01:00
superagent.post(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/relay')
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
.query({ access_token: token })
.send({ provider: 'external-smtp', host: 'host', port: 25, username: 'u', password: 'p', tls: true })
.end(function (err, res) {
expect(res.statusCode).to.equal(400);
done();
});
});
it('get succeeds', function (done) {
var relay = { provider: 'external-smtp', host: 'host', port: 25, username: 'u', password: 'p', tls: true };
fix email route tests
2018-01-29 17:45:10 +01:00
maildb.update(DOMAIN_0.domain, { relay: relay }, function (error) { // skip the mail server verify()
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
expect(error).to.not.be.ok();
fix email route tests
2018-01-29 17:45:10 +01:00
superagent.get(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain)
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(200);
Hide mail relay password
2019-02-15 10:55:15 -08:00
expect(_.omit(res.body.relay, 'password')).to.eql(_.omit(relay, 'password'));
Move mail related settings to new mail route
2018-01-20 18:56:17 -08:00
done();
});
});
});
});
Add mailbox rest api tests
2018-01-29 18:51:53 +01:00
describe('mailboxes', function () {
Fix test
2018-04-07 18:39:17 -07:00
it('add succeeds', function (done) {
mail: make mailbox API based on mailbox name
2018-04-03 12:18:26 -07:00
superagent.post(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/mailboxes')
Fix failing tests
2021-04-30 09:44:25 -07:00
.send({ name: MAILBOX_NAME, ownerId: userId, ownerType: 'user', active: true })
Add mailbox rest api tests
2018-01-29 18:51:53 +01:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(201);
done();
});
});
Fix test
2018-04-07 18:39:17 -07:00
it('cannot add again', function (done) {
mail: make mailbox API based on mailbox name
2018-04-03 12:18:26 -07:00
superagent.post(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/mailboxes')
Fix failing tests
2021-04-30 09:44:25 -07:00
.send({ name: MAILBOX_NAME, ownerId: userId, ownerType: 'user', active: true })
Add mailbox rest api tests
2018-01-29 18:51:53 +01:00
.query({ access_token: token })
.end(function (err, res) {
Fix test
2018-04-07 18:39:17 -07:00
expect(res.statusCode).to.equal(409);
Add mailbox rest api tests
2018-01-29 18:51:53 +01:00
done();
});
});
it('get fails if not exist', function (done) {
superagent.get(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/mailboxes/' + 'someuserdoesnotexist')
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(404);
done();
});
});
it('get succeeds', function (done) {
mail: make mailbox API based on mailbox name
2018-04-03 12:18:26 -07:00
superagent.get(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/mailboxes/' + MAILBOX_NAME)
Add mailbox rest api tests
2018-01-29 18:51:53 +01:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(200);
expect(res.body.mailbox).to.be.an('object');
mail: make mailbox API based on mailbox name
2018-04-03 12:18:26 -07:00
expect(res.body.mailbox.name).to.equal(MAILBOX_NAME);
Add mailbox rest api tests
2018-01-29 18:51:53 +01:00
expect(res.body.mailbox.ownerId).to.equal(userId);
mail: owner can be a group
2020-11-12 23:25:33 -08:00
expect(res.body.mailbox.ownerType).to.equal('user');
mail: implement aliases across domains
2020-04-19 18:44:16 -07:00
expect(res.body.mailbox.aliasName).to.equal(null);
expect(res.body.mailbox.aliasDomain).to.equal(null);
Add mailbox rest api tests
2018-01-29 18:51:53 +01:00
expect(res.body.mailbox.domain).to.equal(DOMAIN_0.domain);
done();
});
});
it('listing succeeds', function (done) {
superagent.get(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/mailboxes')
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(200);
expect(res.body.mailboxes.length).to.eql(1);
expect(res.body.mailboxes[0]).to.be.an('object');
mail: make mailbox API based on mailbox name
2018-04-03 12:18:26 -07:00
expect(res.body.mailboxes[0].name).to.equal(MAILBOX_NAME);
Add mailbox rest api tests
2018-01-29 18:51:53 +01:00
expect(res.body.mailboxes[0].ownerId).to.equal(userId);
mail: owner can be a group
2020-11-12 23:25:33 -08:00
expect(res.body.mailboxes[0].ownerType).to.equal('user');
Fix test
2021-01-07 22:21:41 -08:00
expect(res.body.mailboxes[0].aliases).to.eql([]);
Add mailbox rest api tests
2018-01-29 18:51:53 +01:00
expect(res.body.mailboxes[0].domain).to.equal(DOMAIN_0.domain);
done();
});
});
mail: make mailbox API based on mailbox name
2018-04-03 12:18:26 -07:00
it('disable fails even if not exist', function (done) {
Add mailbox rest api tests
2018-01-29 18:51:53 +01:00
superagent.del(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/mailboxes/' + 'someuserdoesnotexist')
Add option to remove mailbox data
2020-07-27 22:26:10 -07:00
.send({ deleteMails: false })
Add mailbox rest api tests
2018-01-29 18:51:53 +01:00
.query({ access_token: token })
.end(function (err, res) {
mail: make mailbox API based on mailbox name
2018-04-03 12:18:26 -07:00
expect(res.statusCode).to.equal(404);
Add mailbox rest api tests
2018-01-29 18:51:53 +01:00
done();
});
});
it('disable succeeds', function (done) {
mail: make mailbox API based on mailbox name
2018-04-03 12:18:26 -07:00
superagent.del(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/mailboxes/' + MAILBOX_NAME)
Add option to remove mailbox data
2020-07-27 22:26:10 -07:00
.send({ deleteMails: false })
Add mailbox rest api tests
2018-01-29 18:51:53 +01:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(201);
mail: make mailbox API based on mailbox name
2018-04-03 12:18:26 -07:00
superagent.get(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/mailboxes/' + MAILBOX_NAME)
Add mailbox rest api tests
2018-01-29 18:51:53 +01:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(404);
done();
});
});
});
});
Add email alias route tests
2018-01-29 19:39:07 +01:00
describe('aliases', function () {
after(function (done) {
make it clear it is exported for testing
2020-07-27 22:07:25 -07:00
mail._removeMailboxes(DOMAIN_0.domain, function (error) {
Add API to remove mailboxes by domain
2018-02-11 01:18:29 -08:00
if (error) return done(error);
remove mail domain add/remove API
2020-03-31 12:04:46 -07:00
done();
Add API to remove mailboxes by domain
2018-02-11 01:18:29 -08:00
});
Add email alias route tests
2018-01-29 19:39:07 +01:00
});
test: fix alias routes
2020-04-22 18:16:33 -07:00
it('add the mailbox', function (done) {
superagent.post(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/mailboxes')
Fix failing tests
2021-04-30 09:44:25 -07:00
.send({ name: MAILBOX_NAME, ownerId: userId, ownerType: 'user', active: true })
Add email alias route tests
2018-01-29 19:39:07 +01:00
.query({ access_token: token })
.end(function (err, res) {
test: fix alias routes
2020-04-22 18:16:33 -07:00
expect(res.statusCode).to.equal(201);
Add email alias route tests
2018-01-29 19:39:07 +01:00
done();
});
});
test: fix alias routes
2020-04-22 18:16:33 -07:00
it('set fails if aliases is missing', function (done) {
superagent.put(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/mailboxes/' + MAILBOX_NAME + '/aliases')
Add email alias route tests
2018-01-29 19:39:07 +01:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(400);
done();
});
});
test: fix alias routes
2020-04-22 18:16:33 -07:00
it('set fails if user does not exist', function (done) {
superagent.put(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/mailboxes/randomuser/aliases')
mail: implement aliases across domains
2020-04-19 18:44:16 -07:00
.send({ aliases: [{ name: 'hello', domain: DOMAIN_0.domain}, {name: 'there', domain: DOMAIN_0.domain}] })
Add email alias route tests
2018-01-29 19:39:07 +01:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(404);
done();
});
});
test: fix alias routes
2020-04-22 18:16:33 -07:00
it('set fails if aliases is the wrong type', function (done) {
superagent.put(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/mailboxes/' + MAILBOX_NAME + '/aliases')
.send({ aliases: 'hello, there' })
Add email alias route tests
2018-01-29 19:39:07 +01:00
.query({ access_token: token })
.end(function (err, res) {
test: fix alias routes
2020-04-22 18:16:33 -07:00
expect(res.statusCode).to.equal(400);
Add email alias route tests
2018-01-29 19:39:07 +01:00
done();
});
});
it('set succeeds', function (done) {
test: fix alias routes
2020-04-22 18:16:33 -07:00
superagent.put(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/mailboxes/' + MAILBOX_NAME + '/aliases')
mail: implement aliases across domains
2020-04-19 18:44:16 -07:00
.send({ aliases: [{ name: 'hello', domain: DOMAIN_0.domain}, {name: 'there', domain: DOMAIN_0.domain}] })
Add email alias route tests
2018-01-29 19:39:07 +01:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(202);
done();
});
});
it('get succeeds', function (done) {
test: fix alias routes
2020-04-22 18:16:33 -07:00
superagent.get(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/mailboxes/' + MAILBOX_NAME + '/aliases')
Add email alias route tests
2018-01-29 19:39:07 +01:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(200);
mail: implement aliases across domains
2020-04-19 18:44:16 -07:00
expect(res.body.aliases).to.eql([{ name: 'hello', domain: DOMAIN_0.domain}, {name: 'there', domain: DOMAIN_0.domain}]);
Add email alias route tests
2018-01-29 19:39:07 +01:00
done();
});
});
mail: make mailbox API based on mailbox name
2018-04-03 12:18:26 -07:00
it('get fails if mailbox does not exist', function (done) {
test: fix alias routes
2020-04-22 18:16:33 -07:00
superagent.get(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/mailboxes/somerandomuser/aliases')
Add email alias route tests
2018-01-29 19:39:07 +01:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(404);
done();
});
});
});
Add mailinglist rest api tests
2018-01-30 12:23:08 +01:00
describe('mailinglists', function () {
after(function (done) {
make it clear it is exported for testing
2020-07-27 22:07:25 -07:00
mail._removeMailboxes(DOMAIN_0.domain, function (error) {
Add API to remove mailboxes by domain
2018-02-11 01:18:29 -08:00
if (error) return done(error);
remove mail domain add/remove API
2020-03-31 12:04:46 -07:00
done();
Add API to remove mailboxes by domain
2018-02-11 01:18:29 -08:00
});
Add mailinglist rest api tests
2018-01-30 12:23:08 +01:00
});
it('add fails without groupId', function (done) {
superagent.post(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/lists')
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(400);
done();
});
});
it('add fails with invalid groupId', function (done) {
superagent.post(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/lists')
.send({ groupId: {} })
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(400);
done();
});
});
mail: validate list and mailbox names
2018-04-05 16:07:51 -07:00
it('add fails without members array', function (done) {
Add mailinglist rest api tests
2018-01-30 12:23:08 +01:00
superagent.post(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/lists')
mail: validate list and mailbox names
2018-04-05 16:07:51 -07:00
.send({ name: LIST_NAME })
Add mailinglist rest api tests
2018-01-30 12:23:08 +01:00
.query({ access_token: token })
.end(function (err, res) {
mail: validate list and mailbox names
2018-04-05 16:07:51 -07:00
expect(res.statusCode).to.equal(400);
done();
Add mailinglist rest api tests
2018-01-30 12:23:08 +01:00
});
});
it('add succeeds', function (done) {
superagent.post(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/lists')
Fix failing tests
2021-04-30 09:44:25 -07:00
.send({ name: LIST_NAME, members: [ `admin2@${DOMAIN_0.domain}`, `${USERNAME}@${DOMAIN_0.domain}`], membersOnly: false, active: true })
Add mailinglist rest api tests
2018-01-30 12:23:08 +01:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(201);
done();
});
});
it('add twice fails', function (done) {
superagent.post(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/lists')
Fix failing tests
2021-04-30 09:44:25 -07:00
.send({ name: LIST_NAME, members: [ `admin2@${DOMAIN_0.domain}`, `${USERNAME}@${DOMAIN_0.domain}`], membersOnly: false, active: true })
Add mailinglist rest api tests
2018-01-30 12:23:08 +01:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(409);
done();
});
});
it('get fails if not exist', function (done) {
superagent.get(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/lists/' + 'doesnotexist')
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(404);
done();
});
});
it('get succeeds', function (done) {
mail: make list API based on list name
2018-04-03 09:34:33 -07:00
superagent.get(SERVER_URL + `/api/v1/mail/${DOMAIN_0.domain}/lists/${LIST_NAME}`)
Add mailinglist rest api tests
2018-01-30 12:23:08 +01:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(200);
expect(res.body.list).to.be.an('object');
mail: make list API based on list name
2018-04-03 09:34:33 -07:00
expect(res.body.list.name).to.equal(LIST_NAME);
mail: validate list and mailbox names
2018-04-05 16:07:51 -07:00
expect(res.body.list.ownerId).to.equal('admin');
mail: implement aliases across domains
2020-04-19 18:44:16 -07:00
expect(res.body.list.aliasName).to.equal(null);
Add mailinglist rest api tests
2018-01-30 12:23:08 +01:00
expect(res.body.list.domain).to.equal(DOMAIN_0.domain);
Make mail tests work
2019-09-12 13:59:31 -07:00
expect(res.body.list.members).to.eql([ `admin2@${DOMAIN_0.domain}`, `superadmin@${DOMAIN_0.domain}` ]);
add membersOnly flag to a mailing list
2020-04-17 16:55:23 -07:00
expect(res.body.list.membersOnly).to.be(false);
Add mailinglist rest api tests
2018-01-30 12:23:08 +01:00
done();
});
});
it('get all succeeds', function (done) {
superagent.get(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/lists')
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(200);
expect(res.body.lists).to.be.an(Array);
expect(res.body.lists.length).to.equal(1);
mail: make list API based on list name
2018-04-03 09:34:33 -07:00
expect(res.body.lists[0].name).to.equal(LIST_NAME);
mail: validate list and mailbox names
2018-04-05 16:07:51 -07:00
expect(res.body.lists[0].ownerId).to.equal('admin');
mail: implement aliases across domains
2020-04-19 18:44:16 -07:00
expect(res.body.lists[0].aliasName).to.equal(null);
Add mailinglist rest api tests
2018-01-30 12:23:08 +01:00
expect(res.body.lists[0].domain).to.equal(DOMAIN_0.domain);
Make mail tests work
2019-09-12 13:59:31 -07:00
expect(res.body.lists[0].members).to.eql([ `admin2@${DOMAIN_0.domain}`, `superadmin@${DOMAIN_0.domain}` ]);
add membersOnly flag to a mailing list
2020-04-17 16:55:23 -07:00
expect(res.body.lists[0].membersOnly).to.be(false);
Add mailinglist rest api tests
2018-01-30 12:23:08 +01:00
done();
});
});
it('del fails if list does not exist', function (done) {
superagent.del(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/lists/' + 'doesnotexist')
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(404);
done();
});
});
it('del succeeds', function (done) {
mail: make list API based on list name
2018-04-03 09:34:33 -07:00
superagent.del(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/lists/' + LIST_NAME)
Add mailinglist rest api tests
2018-01-30 12:23:08 +01:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(204);
mail: make list API based on list name
2018-04-03 09:34:33 -07:00
superagent.get(SERVER_URL + '/api/v1/mail/' + DOMAIN_0.domain + '/lists/' + LIST_NAME)
Add mailinglist rest api tests
2018-01-30 12:23:08 +01:00
.query({ access_token: token })
.end(function (err, res) {
expect(res.statusCode).to.equal(404);
done();
});
});
});
});
Move email_status into mail route
2018-01-20 18:30:14 -08:00
});
Reference in New Issue Copy Permalink