mirror of
https://github.com/axios/axios.git
synced 2026-04-11 02:11:50 +08:00
5945e40bb1
* fix(interceptor): handle the error in the same interceptor * fix(interceptor): pass the config and data in promise chain * fix(interceptor): filter out unexpected config and data in promise chain --------- Co-authored-by: Jay <jasonsaayman@gmail.com>
676 lines
19 KiB
JavaScript
676 lines
19 KiB
JavaScript
describe('interceptors', function () {
|
|
beforeEach(function () {
|
|
jasmine.Ajax.install();
|
|
});
|
|
|
|
afterEach(function () {
|
|
jasmine.Ajax.uninstall();
|
|
axios.interceptors.request.handlers = [];
|
|
axios.interceptors.response.handlers = [];
|
|
});
|
|
|
|
it('should add a request interceptor (asynchronous by default)', function (done) {
|
|
let asyncFlag = false;
|
|
axios.interceptors.request.use(function (config) {
|
|
config.headers.test = 'added by interceptor';
|
|
expect(asyncFlag).toBe(true);
|
|
return config;
|
|
});
|
|
|
|
axios('/foo');
|
|
asyncFlag = true;
|
|
|
|
getAjaxRequest().then(function (request) {
|
|
expect(request.requestHeaders.test).toBe('added by interceptor');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should add a request interceptor (explicitly flagged as asynchronous)', function (done) {
|
|
let asyncFlag = false;
|
|
axios.interceptors.request.use(function (config) {
|
|
config.headers.test = 'added by interceptor';
|
|
expect(asyncFlag).toBe(true);
|
|
return config;
|
|
}, null, { synchronous: false });
|
|
|
|
axios('/foo');
|
|
asyncFlag = true;
|
|
|
|
getAjaxRequest().then(function (request) {
|
|
expect(request.requestHeaders.test).toBe('added by interceptor');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should add a request interceptor that is executed synchronously when flag is provided', function (done) {
|
|
let asyncFlag = false;
|
|
axios.interceptors.request.use(function (config) {
|
|
config.headers.test = 'added by synchronous interceptor';
|
|
expect(asyncFlag).toBe(false);
|
|
return config;
|
|
}, null, { synchronous: true });
|
|
|
|
axios('/foo');
|
|
asyncFlag = true;
|
|
|
|
getAjaxRequest().then(function (request) {
|
|
expect(request.requestHeaders.test).toBe('added by synchronous interceptor');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should execute asynchronously when not all interceptors are explicitly flagged as synchronous', function (done) {
|
|
let asyncFlag = false;
|
|
axios.interceptors.request.use(function (config) {
|
|
config.headers.foo = 'uh oh, async';
|
|
expect(asyncFlag).toBe(true);
|
|
return config;
|
|
});
|
|
|
|
axios.interceptors.request.use(function (config) {
|
|
config.headers.test = 'added by synchronous interceptor';
|
|
expect(asyncFlag).toBe(true);
|
|
return config;
|
|
}, null, { synchronous: true });
|
|
|
|
axios.interceptors.request.use(function (config) {
|
|
config.headers.test = 'added by the async interceptor';
|
|
expect(asyncFlag).toBe(true);
|
|
return config;
|
|
});
|
|
|
|
axios('/foo');
|
|
asyncFlag = true;
|
|
|
|
getAjaxRequest().then(function (request) {
|
|
expect(request.requestHeaders.foo).toBe('uh oh, async');
|
|
/* request interceptors have a reversed execution order */
|
|
expect(request.requestHeaders.test).toBe('added by synchronous interceptor');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('runs the interceptor if runWhen function is provided and resolves to true', function (done) {
|
|
function onGetCall(config) {
|
|
return config.method === 'get';
|
|
}
|
|
axios.interceptors.request.use(function (config) {
|
|
config.headers.test = 'special get headers';
|
|
return config;
|
|
}, null, { runWhen: onGetCall });
|
|
|
|
axios('/foo');
|
|
|
|
getAjaxRequest().then(function (request) {
|
|
expect(request.requestHeaders.test).toBe('special get headers');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('does not run the interceptor if runWhen function is provided and resolves to false', function (done) {
|
|
function onPostCall(config) {
|
|
return config.method === 'post';
|
|
}
|
|
axios.interceptors.request.use(function (config) {
|
|
config.headers.test = 'special get headers';
|
|
return config;
|
|
}, null, { runWhen: onPostCall });
|
|
|
|
axios('/foo');
|
|
|
|
getAjaxRequest().then(function (request) {
|
|
expect(request.requestHeaders.test).toBeUndefined()
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('does not run async interceptor if runWhen function is provided and resolves to false (and run synchronously)', function (done) {
|
|
let asyncFlag = false;
|
|
|
|
function onPostCall(config) {
|
|
return config.method === 'post';
|
|
}
|
|
axios.interceptors.request.use(function (config) {
|
|
config.headers.test = 'special get headers';
|
|
return config;
|
|
}, null, { synchronous: false, runWhen: onPostCall });
|
|
|
|
axios.interceptors.request.use(function (config) {
|
|
config.headers.sync = 'hello world';
|
|
expect(asyncFlag).toBe(false);
|
|
return config;
|
|
}, null, { synchronous: true });
|
|
|
|
axios('/foo');
|
|
asyncFlag = true
|
|
|
|
getAjaxRequest().then(function (request) {
|
|
expect(request.requestHeaders.test).toBeUndefined()
|
|
expect(request.requestHeaders.sync).toBe('hello world')
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should add a request interceptor with an onRejected block that is called if interceptor code fails', function (done) {
|
|
const rejectedSpy = jasmine.createSpy('rejectedSpy');
|
|
const error = new Error('deadly error');
|
|
axios.interceptors.request.use(function () {
|
|
throw error;
|
|
}, rejectedSpy, { synchronous: true });
|
|
|
|
axios('/foo').catch(done);
|
|
|
|
getAjaxRequest().then(function () {
|
|
expect(rejectedSpy).toHaveBeenCalledWith(error);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should add a request interceptor that returns a new config object', function (done) {
|
|
axios.interceptors.request.use(function () {
|
|
return {
|
|
url: '/bar',
|
|
method: 'post'
|
|
};
|
|
});
|
|
|
|
axios('/foo');
|
|
|
|
getAjaxRequest().then(function (request) {
|
|
expect(request.method).toBe('POST');
|
|
expect(request.url).toBe('/bar');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should add a request interceptor that returns a promise', function (done) {
|
|
axios.interceptors.request.use(function (config) {
|
|
return new Promise(function (resolve) {
|
|
// do something async
|
|
setTimeout(function () {
|
|
config.headers.async = 'promise';
|
|
resolve(config);
|
|
}, 100);
|
|
});
|
|
});
|
|
|
|
axios('/foo');
|
|
|
|
getAjaxRequest().then(function (request) {
|
|
expect(request.requestHeaders.async).toBe('promise');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should add multiple request interceptors', function (done) {
|
|
axios.interceptors.request.use(function (config) {
|
|
config.headers.test1 = '1';
|
|
return config;
|
|
});
|
|
axios.interceptors.request.use(function (config) {
|
|
config.headers.test2 = '2';
|
|
return config;
|
|
});
|
|
axios.interceptors.request.use(function (config) {
|
|
config.headers.test3 = '3';
|
|
return config;
|
|
});
|
|
|
|
axios('/foo');
|
|
|
|
getAjaxRequest().then(function (request) {
|
|
expect(request.requestHeaders.test1).toBe('1');
|
|
expect(request.requestHeaders.test2).toBe('2');
|
|
expect(request.requestHeaders.test3).toBe('3');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should add a response interceptor', function (done) {
|
|
let response;
|
|
|
|
axios.interceptors.response.use(function (data) {
|
|
data.data = data.data + ' - modified by interceptor';
|
|
return data;
|
|
});
|
|
|
|
axios('/foo').then(function (data) {
|
|
response = data;
|
|
});
|
|
|
|
getAjaxRequest().then(function (request) {
|
|
request.respondWith({
|
|
status: 200,
|
|
responseText: 'OK'
|
|
});
|
|
|
|
setTimeout(function () {
|
|
expect(response.data).toBe('OK - modified by interceptor');
|
|
done();
|
|
}, 100);
|
|
});
|
|
});
|
|
|
|
it('should add a response interceptor when request interceptor is defined', function (done) {
|
|
let response;
|
|
|
|
axios.interceptors.request.use(function (data) {
|
|
return data;
|
|
});
|
|
|
|
axios.interceptors.response.use(function (data) {
|
|
data.data = data.data + ' - modified by interceptor';
|
|
return data;
|
|
});
|
|
|
|
axios('/foo').then(function (data) {
|
|
response = data;
|
|
});
|
|
|
|
getAjaxRequest().then(function (request) {
|
|
request.respondWith({
|
|
status: 200,
|
|
responseText: 'OK'
|
|
});
|
|
|
|
setTimeout(function () {
|
|
expect(response.data).toBe('OK - modified by interceptor');
|
|
done();
|
|
}, 100);
|
|
});
|
|
});
|
|
|
|
it('should add a response interceptor that returns a new data object', function (done) {
|
|
let response;
|
|
|
|
axios.interceptors.response.use(function () {
|
|
return {
|
|
data: 'stuff'
|
|
};
|
|
});
|
|
|
|
axios('/foo').then(function (data) {
|
|
response = data;
|
|
});
|
|
|
|
getAjaxRequest().then(function (request) {
|
|
request.respondWith({
|
|
status: 200,
|
|
responseText: 'OK'
|
|
});
|
|
|
|
setTimeout(function () {
|
|
expect(response.data).toBe('stuff');
|
|
done();
|
|
}, 100);
|
|
});
|
|
});
|
|
|
|
it('should add a response interceptor that returns a promise', function (done) {
|
|
let response;
|
|
|
|
axios.interceptors.response.use(function (data) {
|
|
return new Promise(function (resolve) {
|
|
// do something async
|
|
setTimeout(function () {
|
|
data.data = 'you have been promised!';
|
|
resolve(data);
|
|
}, 10);
|
|
});
|
|
});
|
|
|
|
axios('/foo').then(function (data) {
|
|
response = data;
|
|
});
|
|
|
|
getAjaxRequest().then(function (request) {
|
|
request.respondWith({
|
|
status: 200,
|
|
responseText: 'OK'
|
|
});
|
|
|
|
setTimeout(function () {
|
|
expect(response.data).toBe('you have been promised!');
|
|
done();
|
|
}, 100);
|
|
});
|
|
});
|
|
|
|
describe('given you add multiple response interceptors', function () {
|
|
|
|
describe('and when the response was fulfilled', function () {
|
|
|
|
function fireRequestAndExpect(expectation) {
|
|
let response;
|
|
axios('/foo').then(function(data) {
|
|
response = data;
|
|
});
|
|
getAjaxRequest().then(function (request) {
|
|
request.respondWith({
|
|
status: 200,
|
|
responseText: 'OK'
|
|
});
|
|
|
|
setTimeout(function() {
|
|
expectation(response)
|
|
}, 100);
|
|
});
|
|
}
|
|
|
|
it('then each interceptor is executed', function (done) {
|
|
const interceptor1 = jasmine.createSpy('interceptor1');
|
|
const interceptor2 = jasmine.createSpy('interceptor2');
|
|
axios.interceptors.response.use(interceptor1);
|
|
axios.interceptors.response.use(interceptor2);
|
|
|
|
fireRequestAndExpect(function () {
|
|
expect(interceptor1).toHaveBeenCalled();
|
|
expect(interceptor2).toHaveBeenCalled();
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('then they are executed in the order they were added', function (done) {
|
|
const interceptor1 = jasmine.createSpy('interceptor1');
|
|
const interceptor2 = jasmine.createSpy('interceptor2');
|
|
axios.interceptors.response.use(interceptor1);
|
|
axios.interceptors.response.use(interceptor2);
|
|
|
|
fireRequestAndExpect(function () {
|
|
expect(interceptor1).toHaveBeenCalledBefore(interceptor2);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('then only the last interceptor\'s result is returned', function (done) {
|
|
axios.interceptors.response.use(function() {
|
|
return 'response 1';
|
|
});
|
|
axios.interceptors.response.use(function() {
|
|
return 'response 2';
|
|
});
|
|
|
|
fireRequestAndExpect(function (response) {
|
|
expect(response).toBe('response 2');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('then every interceptor receives the result of it\'s predecessor', function (done) {
|
|
axios.interceptors.response.use(function() {
|
|
return 'response 1';
|
|
});
|
|
axios.interceptors.response.use(function(response) {
|
|
return [response, 'response 2'];
|
|
});
|
|
|
|
fireRequestAndExpect(function (response) {
|
|
expect(response).toEqual(['response 1', 'response 2']);
|
|
done();
|
|
});
|
|
});
|
|
|
|
describe('and when the fulfillment-interceptor throws', function () {
|
|
|
|
function fireRequestCatchAndExpect(expectation) {
|
|
axios('/foo').catch(function(data) {
|
|
// dont handle result
|
|
});
|
|
getAjaxRequest().then(function (request) {
|
|
request.respondWith({
|
|
status: 200,
|
|
responseText: 'OK'
|
|
});
|
|
|
|
setTimeout(function() {
|
|
expectation()
|
|
}, 100);
|
|
});
|
|
}
|
|
|
|
it('then the following fulfillment-interceptor is not called', function (done) {
|
|
axios.interceptors.response.use(function() {
|
|
throw Error('throwing interceptor');
|
|
});
|
|
const interceptor2 = jasmine.createSpy('interceptor2');
|
|
axios.interceptors.response.use(interceptor2);
|
|
|
|
fireRequestCatchAndExpect(function () {
|
|
expect(interceptor2).not.toHaveBeenCalled();
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('then the following rejection-interceptor is called', function (done) {
|
|
axios.interceptors.response.use(function() {
|
|
throw Error('throwing interceptor');
|
|
});
|
|
const unusedFulfillInterceptor = function() {};
|
|
const rejectIntercept = jasmine.createSpy('rejectIntercept');
|
|
axios.interceptors.response.use(unusedFulfillInterceptor, rejectIntercept);
|
|
|
|
fireRequestCatchAndExpect(function () {
|
|
expect(rejectIntercept).toHaveBeenCalled();
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('once caught, another following fulfill-interceptor is called again (just like in a promise chain)', function (done) {
|
|
axios.interceptors.response.use(function() {
|
|
throw Error('throwing interceptor');
|
|
});
|
|
|
|
const unusedFulfillInterceptor = function() {};
|
|
const catchingThrowingInterceptor = function() {};
|
|
axios.interceptors.response.use(unusedFulfillInterceptor, catchingThrowingInterceptor);
|
|
|
|
const interceptor3 = jasmine.createSpy('interceptor3');
|
|
axios.interceptors.response.use(interceptor3);
|
|
|
|
fireRequestCatchAndExpect(function () {
|
|
expect(interceptor3).toHaveBeenCalled();
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
it('should allow removing interceptors', function (done) {
|
|
let response, intercept;
|
|
|
|
axios.interceptors.response.use(function (data) {
|
|
data.data = data.data + '1';
|
|
return data;
|
|
});
|
|
intercept = axios.interceptors.response.use(function (data) {
|
|
data.data = data.data + '2';
|
|
return data;
|
|
});
|
|
axios.interceptors.response.use(function (data) {
|
|
data.data = data.data + '3';
|
|
return data;
|
|
});
|
|
|
|
axios.interceptors.response.eject(intercept);
|
|
|
|
axios('/foo').then(function (data) {
|
|
response = data;
|
|
});
|
|
|
|
getAjaxRequest().then(function (request) {
|
|
request.respondWith({
|
|
status: 200,
|
|
responseText: 'OK'
|
|
});
|
|
|
|
setTimeout(function () {
|
|
expect(response.data).toBe('OK13');
|
|
done();
|
|
}, 100);
|
|
});
|
|
});
|
|
|
|
it('should remove async interceptor before making request and execute synchronously', function (done) {
|
|
let asyncFlag = false;
|
|
const asyncIntercept = axios.interceptors.request.use(function (config) {
|
|
config.headers.async = 'async it!';
|
|
return config;
|
|
}, null, { synchronous: false });
|
|
|
|
const syncIntercept = axios.interceptors.request.use(function (config) {
|
|
config.headers.sync = 'hello world';
|
|
expect(asyncFlag).toBe(false);
|
|
return config;
|
|
}, null, { synchronous: true });
|
|
|
|
|
|
axios.interceptors.request.eject(asyncIntercept);
|
|
|
|
axios('/foo')
|
|
asyncFlag = true
|
|
|
|
getAjaxRequest().then(function (request) {
|
|
expect(request.requestHeaders.async).toBeUndefined();
|
|
expect(request.requestHeaders.sync).toBe('hello world');
|
|
done()
|
|
});
|
|
});
|
|
|
|
it('should execute interceptors before transformers', function (done) {
|
|
axios.interceptors.request.use(function (config) {
|
|
config.data.baz = 'qux';
|
|
return config;
|
|
});
|
|
|
|
axios.post('/foo', {
|
|
foo: 'bar'
|
|
});
|
|
|
|
getAjaxRequest().then(function (request) {
|
|
expect(request.params).toEqual('{"foo":"bar","baz":"qux"}');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should modify base URL in request interceptor', function (done) {
|
|
const instance = axios.create({
|
|
baseURL: 'http://test.com/'
|
|
});
|
|
|
|
instance.interceptors.request.use(function (config) {
|
|
config.baseURL = 'http://rebase.com/';
|
|
return config;
|
|
});
|
|
|
|
instance.get('/foo');
|
|
|
|
getAjaxRequest().then(function (request) {
|
|
expect(request.url).toBe('http://rebase.com/foo');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should clear all request interceptors', function () {
|
|
const instance = axios.create({
|
|
baseURL: 'http://test.com/'
|
|
});
|
|
|
|
instance.interceptors.request.use(function (config) {
|
|
return config
|
|
});
|
|
|
|
instance.interceptors.request.clear();
|
|
|
|
expect(instance.interceptors.request.handlers.length).toBe(0);
|
|
});
|
|
|
|
it('should clear all response interceptors', function () {
|
|
const instance = axios.create({
|
|
baseURL: 'http://test.com/'
|
|
});
|
|
|
|
instance.interceptors.response.use(function (config) {
|
|
return config
|
|
});
|
|
|
|
instance.interceptors.response.clear();
|
|
|
|
expect(instance.interceptors.response.handlers.length).toBe(0);
|
|
});
|
|
|
|
it('should handler the error in the same request interceptors', function (done) {
|
|
const rejectedSpy1 = jasmine.createSpy('rejectedSpy1');
|
|
const rejectedSpy2 = jasmine.createSpy('rejectedSpy2');
|
|
const error1 = new Error('deadly error 1');
|
|
const error2 = new Error('deadly error 2');
|
|
axios.interceptors.request.use(function () {
|
|
throw error1;
|
|
}, rejectedSpy1);
|
|
|
|
axios.interceptors.request.use(function () {
|
|
throw error2;
|
|
}, rejectedSpy2);
|
|
|
|
axios('/foo').catch();
|
|
|
|
getAjaxRequest().then(function () {
|
|
expect(rejectedSpy1).toHaveBeenCalledWith(error1);
|
|
expect(rejectedSpy2).toHaveBeenCalledWith(error2);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should handle the error in the same response interceptors', function (done) {
|
|
const rejectedSpy1 = jasmine.createSpy('rejectedSpy1');
|
|
const rejectedSpy2 = jasmine.createSpy('rejectedSpy2');
|
|
const error1 = new Error('deadly error 1');
|
|
const error2 = new Error('deadly error 2');
|
|
axios.interceptors.response.use(function () {
|
|
throw error1;
|
|
}, rejectedSpy1);
|
|
|
|
axios.interceptors.response.use(function () {
|
|
throw error2;
|
|
}, rejectedSpy2);
|
|
|
|
axios('/foo');
|
|
|
|
getAjaxRequest().then(function (request) {
|
|
request.respondWith({
|
|
status: 200,
|
|
responseText: 'OK'
|
|
});
|
|
|
|
setTimeout(function () {
|
|
expect(rejectedSpy1).toHaveBeenCalledWith(error1);
|
|
expect(rejectedSpy2).toHaveBeenCalledWith(error2);
|
|
done();
|
|
}, 100);
|
|
});
|
|
});
|
|
|
|
it('should skip the modification of config in the interceptors throwing error', function (done) {
|
|
const rejectedSpy = jasmine.createSpy('rejectedSpy');
|
|
const error = new Error('deadly error');
|
|
|
|
axios.interceptors.request.use(function (config) {
|
|
config.headers.test = 'added by interceptor';
|
|
return config;
|
|
});
|
|
|
|
axios.interceptors.request.use(function () {
|
|
throw error;
|
|
}, rejectedSpy);
|
|
|
|
axios('/foo').catch();
|
|
|
|
getAjaxRequest().then(function (request) {
|
|
expect(rejectedSpy).toHaveBeenCalledWith(error);
|
|
expect(request.requestHeaders.test).toBe('added by interceptor');
|
|
done();
|
|
});
|
|
});
|
|
});
|