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