electron/spec/api-protocol-spec.js
2016-02-23 12:54:20 +05:30

870 lines
24 KiB
JavaScript

const assert = require('assert');
const http = require('http');
const path = require('path');
const qs = require('querystring');
const remote = require('electron').remote;
const BrowserWindow = remote.require('electron').BrowserWindow;
const protocol = remote.require('electron').protocol;
const session = remote.require('electron').session;
describe('protocol module', function() {
var protocolName = 'sp';
var text = 'valar morghulis';
var postData = {
name: 'post test',
type: 'string'
};
afterEach(function(done) {
protocol.unregisterProtocol(protocolName, function() {
protocol.uninterceptProtocol('http', function() {
done();
});
});
});
describe('protocol.register(Any)Protocol', function() {
var emptyHandler = function(request, callback) {
callback();
};
it('throws error when scheme is already registered', function(done) {
protocol.registerStringProtocol(protocolName, emptyHandler, function(error) {
assert.equal(error, null);
protocol.registerBufferProtocol(protocolName, emptyHandler, function(error) {
assert.notEqual(error, null);
done();
});
});
});
it('does not crash when handler is called twice', function(done) {
var doubleHandler = function(request, callback) {
try {
callback(text);
callback();
} catch (error) {
// Ignore error
}
};
protocol.registerStringProtocol(protocolName, doubleHandler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: protocolName + "://fake-host",
success: function(data) {
assert.equal(data, text);
done();
},
error: function(xhr, errorType, error) {
done(error);
}
});
});
});
it('sends error when callback is called with nothing', function(done) {
protocol.registerBufferProtocol(protocolName, emptyHandler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: protocolName + "://fake-host",
success: function() {
return done('request succeeded but it should not');
},
error: function(xhr, errorType) {
assert.equal(errorType, 'error');
return done();
}
});
});
});
it('does not crash when callback is called in next tick', function(done) {
var handler = function(request, callback) {
setImmediate(function() {
callback(text);
});
};
protocol.registerStringProtocol(protocolName, handler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: protocolName + "://fake-host",
success: function(data) {
assert.equal(data, text);
done();
},
error: function(xhr, errorType, error) {
done(error);
}
});
});
});
});
describe('protocol.unregisterProtocol', function() {
it('returns error when scheme does not exist', function(done) {
protocol.unregisterProtocol('not-exist', function(error) {
assert.notEqual(error, null);
done();
});
});
});
describe('protocol.registerStringProtocol', function() {
it('sends string as response', function(done) {
var handler = function(request, callback) {
callback(text);
};
protocol.registerStringProtocol(protocolName, handler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: protocolName + "://fake-host",
success: function(data) {
assert.equal(data, text);
done();
},
error: function(xhr, errorType, error) {
done(error);
}
});
});
});
it('sets Access-Control-Allow-Origin', function(done) {
var handler = function(request, callback) {
callback(text);
};
protocol.registerStringProtocol(protocolName, handler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: protocolName + "://fake-host",
success: function(data, status, request) {
assert.equal(data, text);
assert.equal(request.getResponseHeader('Access-Control-Allow-Origin'), '*');
done();
},
error: function(xhr, errorType, error) {
done(error);
}
});
});
});
it('sends object as response', function(done) {
var handler = function(request, callback) {
callback({
data: text,
mimeType: 'text/html'
});
};
protocol.registerStringProtocol(protocolName, handler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: protocolName + "://fake-host",
success: function(data) {
assert.equal(data, text);
done();
},
error: function(xhr, errorType, error) {
done(error);
}
});
});
});
it('fails when sending object other than string', function(done) {
var handler = function(request, callback) {
callback(new Date);
};
protocol.registerBufferProtocol(protocolName, handler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: protocolName + "://fake-host",
success: function() {
done('request succeeded but it should not');
},
error: function(xhr, errorType) {
assert.equal(errorType, 'error');
done();
}
});
});
});
});
describe('protocol.registerBufferProtocol', function() {
var buffer = new Buffer(text);
it('sends Buffer as response', function(done) {
var handler = function(request, callback) {
callback(buffer);
};
protocol.registerBufferProtocol(protocolName, handler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: protocolName + "://fake-host",
success: function(data) {
assert.equal(data, text);
done();
},
error: function(xhr, errorType, error) {
done(error);
}
});
});
});
it('sets Access-Control-Allow-Origin', function(done) {
var handler = function(request, callback) {
callback(buffer);
};
protocol.registerBufferProtocol(protocolName, handler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: protocolName + "://fake-host",
success: function(data, status, request) {
assert.equal(data, text);
assert.equal(request.getResponseHeader('Access-Control-Allow-Origin'), '*');
done();
},
error: function(xhr, errorType, error) {
done(error);
}
});
});
});
it('sends object as response', function(done) {
var handler = function(request, callback) {
callback({
data: buffer,
mimeType: 'text/html'
});
};
protocol.registerBufferProtocol(protocolName, handler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: protocolName + "://fake-host",
success: function(data) {
assert.equal(data, text);
done();
},
error: function(xhr, errorType, error) {
done(error);
}
});
});
});
it('fails when sending string', function(done) {
var handler = function(request, callback) {
callback(text);
};
protocol.registerBufferProtocol(protocolName, handler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: protocolName + "://fake-host",
success: function() {
done('request succeeded but it should not');
},
error: function(xhr, errorType) {
assert.equal(errorType, 'error');
done();
}
});
});
});
});
describe('protocol.registerFileProtocol', function() {
var filePath = path.join(__dirname, 'fixtures', 'asar', 'a.asar', 'file1');
var fileContent = require('fs').readFileSync(filePath);
var normalPath = path.join(__dirname, 'fixtures', 'pages', 'a.html');
var normalContent = require('fs').readFileSync(normalPath);
it('sends file path as response', function(done) {
var handler = function(request, callback) {
callback(filePath);
};
protocol.registerFileProtocol(protocolName, handler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: protocolName + "://fake-host",
success: function(data) {
assert.equal(data, String(fileContent));
return done();
},
error: function(xhr, errorType, error) {
return done(error);
}
});
});
});
it('sets Access-Control-Allow-Origin', function(done) {
var handler = function(request, callback) {
callback(filePath);
};
protocol.registerFileProtocol(protocolName, handler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: protocolName + "://fake-host",
success: function(data, status, request) {
assert.equal(data, String(fileContent));
assert.equal(request.getResponseHeader('Access-Control-Allow-Origin'), '*');
done();
},
error: function(xhr, errorType, error) {
done(error);
}
});
});
});
it('sends object as response', function(done) {
var handler = function(request, callback) {
callback({
path: filePath
});
};
protocol.registerFileProtocol(protocolName, handler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: protocolName + "://fake-host",
success: function(data) {
assert.equal(data, String(fileContent));
done();
},
error: function(xhr, errorType, error) {
done(error);
}
});
});
});
it('can send normal file', function(done) {
var handler = function(request, callback) {
callback(normalPath);
};
protocol.registerFileProtocol(protocolName, handler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: protocolName + "://fake-host",
success: function(data) {
assert.equal(data, String(normalContent));
done();
},
error: function(xhr, errorType, error) {
done(error);
}
});
});
});
it('fails when sending unexist-file', function(done) {
var fakeFilePath = path.join(__dirname, 'fixtures', 'asar', 'a.asar', 'not-exist');
var handler = function(request, callback) {
callback(fakeFilePath);
};
protocol.registerBufferProtocol(protocolName, handler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: protocolName + "://fake-host",
success: function() {
done('request succeeded but it should not');
},
error: function(xhr, errorType) {
assert.equal(errorType, 'error');
done();
}
});
});
});
it('fails when sending unsupported content', function(done) {
var handler = function(request, callback) {
callback(new Date);
};
protocol.registerBufferProtocol(protocolName, handler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: protocolName + "://fake-host",
success: function() {
done('request succeeded but it should not');
},
error: function(xhr, errorType) {
assert.equal(errorType, 'error');
done();
}
});
});
});
});
describe('protocol.registerHttpProtocol', function() {
it('sends url as response', function(done) {
var server = http.createServer(function(req, res) {
assert.notEqual(req.headers.accept, '');
res.end(text);
server.close();
});
server.listen(0, '127.0.0.1', function() {
var port = server.address().port;
var url = "http://127.0.0.1:" + port;
var handler = function(request, callback) {
callback({
url: url
});
};
protocol.registerHttpProtocol(protocolName, handler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: protocolName + "://fake-host",
success: function(data) {
assert.equal(data, text);
done();
},
error: function(xhr, errorType, error) {
done(error);
}
});
});
});
});
it('fails when sending invalid url', function(done) {
var handler = function(request, callback) {
callback({
url: 'url'
});
};
protocol.registerHttpProtocol(protocolName, handler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: protocolName + "://fake-host",
success: function() {
done('request succeeded but it should not');
},
error: function(xhr, errorType) {
assert.equal(errorType, 'error');
done();
}
});
});
});
it('fails when sending unsupported content', function(done) {
var handler = function(request, callback) {
callback(new Date);
};
protocol.registerHttpProtocol(protocolName, handler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: protocolName + "://fake-host",
success: function() {
done('request succeeded but it should not');
},
error: function(xhr, errorType) {
assert.equal(errorType, 'error');
done();
}
});
});
});
});
describe('protocol.isProtocolHandled', function() {
it('returns true for file:', function(done) {
protocol.isProtocolHandled('file', function(result) {
assert.equal(result, true);
done();
});
});
it('returns true for http:', function(done) {
protocol.isProtocolHandled('http', function(result) {
assert.equal(result, true);
done();
});
});
it('returns true for https:', function(done) {
protocol.isProtocolHandled('https', function(result) {
assert.equal(result, true);
done();
});
});
it('returns false when scheme is not registred', function(done) {
protocol.isProtocolHandled('no-exist', function(result) {
assert.equal(result, false);
done();
});
});
it('returns true for custom protocol', function(done) {
var emptyHandler = function(request, callback) {
callback();
};
protocol.registerStringProtocol(protocolName, emptyHandler, function(error) {
assert.equal(error, null);
protocol.isProtocolHandled(protocolName, function(result) {
assert.equal(result, true);
done();
});
});
});
it('returns true for intercepted protocol', function(done) {
var emptyHandler = function(request, callback) {
callback();
};
protocol.interceptStringProtocol('http', emptyHandler, function(error) {
assert.equal(error, null);
protocol.isProtocolHandled('http', function(result) {
assert.equal(result, true);
done();
});
});
});
});
describe('protocol.intercept(Any)Protocol', function() {
var emptyHandler = function(request, callback) {
callback();
};
it('throws error when scheme is already intercepted', function(done) {
protocol.interceptStringProtocol('http', emptyHandler, function(error) {
assert.equal(error, null);
protocol.interceptBufferProtocol('http', emptyHandler, function(error) {
assert.notEqual(error, null);
done();
});
});
});
it('does not crash when handler is called twice', function(done) {
var doubleHandler = function(request, callback) {
try {
callback(text);
callback();
} catch (error) {
// Ignore error
}
};
protocol.interceptStringProtocol('http', doubleHandler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: 'http://fake-host',
success: function(data) {
assert.equal(data, text);
done();
},
error: function(xhr, errorType, error) {
done(error);
}
});
});
});
it('sends error when callback is called with nothing', function(done) {
if (process.env.TRAVIS === 'true') {
return done();
}
protocol.interceptBufferProtocol('http', emptyHandler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: 'http://fake-host',
success: function() {
done('request succeeded but it should not');
},
error: function(xhr, errorType) {
assert.equal(errorType, 'error');
done();
}
});
});
});
});
describe('protocol.interceptStringProtocol', function() {
it('can intercept http protocol', function(done) {
var handler = function(request, callback) {
callback(text);
};
protocol.interceptStringProtocol('http', handler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: 'http://fake-host',
success: function(data) {
assert.equal(data, text);
done();
},
error: function(xhr, errorType, error) {
done(error);
}
});
});
});
it('can set content-type', function(done) {
var handler = function(request, callback) {
callback({
mimeType: 'application/json',
data: '{"value": 1}'
});
};
protocol.interceptStringProtocol('http', handler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: 'http://fake-host',
success: function(data) {
assert.equal(typeof data, 'object');
assert.equal(data.value, 1);
done();
},
error: function(xhr, errorType, error) {
done(error);
}
});
});
});
it('can receive post data', function(done) {
var handler = function(request, callback) {
var uploadData = request.uploadData[0].bytes.toString();
callback({
data: uploadData
});
};
protocol.interceptStringProtocol('http', handler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: "http://fake-host",
type: "POST",
data: postData,
success: function(data) {
assert.deepEqual(qs.parse(data), postData);
done();
},
error: function(xhr, errorType, error) {
done(error);
}
});
});
});
});
describe('protocol.interceptBufferProtocol', function() {
it('can intercept http protocol', function(done) {
var handler = function(request, callback) {
callback(new Buffer(text));
};
protocol.interceptBufferProtocol('http', handler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: 'http://fake-host',
success: function(data) {
assert.equal(data, text);
done();
},
error: function(xhr, errorType, error) {
done(error);
}
});
});
});
it('can receive post data', function(done) {
var handler = function(request, callback) {
var uploadData = request.uploadData[0].bytes;
callback(uploadData);
};
protocol.interceptBufferProtocol('http', handler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: "http://fake-host",
type: "POST",
data: postData,
success: function(data) {
assert.equal(data, $.param(postData));
done();
},
error: function(xhr, errorType, error) {
done(error);
}
});
});
});
});
describe('protocol.interceptHttpProtocol', function() {
it('can send POST request', function(done) {
var server = http.createServer(function(req, res) {
var body = '';
req.on('data', function(chunk) {
body += chunk;
});
req.on('end', function() {
res.end(body);
});
server.close();
});
server.listen(0, '127.0.0.1', function() {
var port = server.address().port;
var url = "http://127.0.0.1:" + port;
var handler = function(request, callback) {
var data = {
url: url,
method: 'POST',
uploadData: {
contentType: 'application/x-www-form-urlencoded',
data: request.uploadData[0].bytes.toString()
},
session: null
};
callback(data);
};
protocol.interceptHttpProtocol('http', handler, function(error) {
if (error) {
return done(error);
}
$.ajax({
url: "http://fake-host",
type: "POST",
data: postData,
success: function(data) {
assert.deepEqual(qs.parse(data), postData);
done();
},
error: function(xhr, errorType, error) {
done(error);
}
});
});
});
});
});
describe('protocol.uninterceptProtocol', function() {
it('returns error when scheme does not exist', function(done) {
protocol.uninterceptProtocol('not-exist', function(error) {
assert.notEqual(error, null);
done();
});
});
it('returns error when scheme is not intercepted', function(done) {
protocol.uninterceptProtocol('http', function(error) {
assert.notEqual(error, null);
done();
});
});
});
describe('protocol.fromPartition', function() {
var partitionName = 'temp';
var tempProtocol = session.fromPartition(partitionName).protocol;
var w = null;
beforeEach(function() {
if (w != null) {
w.destroy();
}
w = new BrowserWindow({
show: false,
width: 400,
height: 400,
webPreferences: {
partition: partitionName
}
});
});
afterEach(function() {
if (w != null) {
w.destroy();
}
w = null;
});
it('handles requests from a partition', function(done) {
var handler = function(error, callback) {
callback({
data: text
});
};
tempProtocol.registerStringProtocol(protocolName, handler, function(error) {
if (error) {
return done(error);
}
protocol.isProtocolHandled(protocolName, function(result) {
assert.equal(result, false);
});
tempProtocol.isProtocolHandled(protocolName, function(result) {
assert.equal(result, true);
w.webContents.on('did-finish-load', function() {
done();
});
w.loadURL(protocolName + "://fake-host");
});
});
});
});
});