first commit

node_modules/fetch-s/test/core/fetch.spec.js

@@ -0,0 +1,48 @@
+import fetchMock from 'fetch-mock';
+import _fetch from './../../src/core/fetchTimeout';
+
+describe('test _fetch ...', () => {
+	beforeEach(function() {
+		const headers = {
+			'Content-Type': 'application/json;charset=utf-8',
+			'Access-Control-Allow-Origin': '*'
+		};
+		const body = { foo: 'bar' };
+
+		fetchMock.get('http://www.example.com', {
+			status: 200,
+			body,
+			headers
+		});
+	});
+
+	afterEach(function() {
+		fetchMock.restore();
+	});
+	it('测试定时器', async () => {
+		await _fetch(
+			'http://www.example.com',
+			{
+				method: 'GET'
+			},
+			1000
+		)
+			.then(r => {
+				return r.json();
+			})
+			.then(d => {
+				expect(d).toEqual({ foo: 'bar' });
+			});
+	});
+	it('测试超时时异常', async () => {
+		await _fetch(
+			'http://www.example.com',
+			{
+				method: 'GET'
+			},
+			0
+		).catch(e => {
+			expect(e).toEqual(new Error('Request timed out'));
+		});
+	});
+});

node_modules/fetch-s/test/core/interceptors.spec.js

@@ -0,0 +1,39 @@
+import Interceptor from './../../src/core/interceptors';
+
+describe('test Interceptor...', () => {
+	it('测试添加拦截器', () => {
+		let interceptors = new Interceptor();
+		interceptors.use(function() {}, function() {});
+		interceptors.use(function() {}, function() {});
+		interceptors.use(function() {}, function() {});
+		expect(interceptors.queue.length).toBe(3);
+	});
+	it('测试执行、移除拦截器', () => {
+		let interceptors = new Interceptor();
+		let num = 1;
+		interceptors.use(
+			function() {
+				num++;
+			},
+			function() {}
+		);
+		interceptors.use(
+			function() {
+				num = num + 2;
+			},
+			function() {}
+		);
+		interceptors.use(
+			function() {
+				num = num + 3;
+			},
+			function() {}
+		);
+		interceptors.eject(1);
+
+		interceptors.forEach(interceptor => {
+			interceptor.resolve();
+		});
+		expect(num).toBe(5);
+	});
+});

node_modules/fetch-s/test/core/jsonp.spec.js

@@ -0,0 +1,34 @@
+import fetchs from './../../src/fetchs';
+
+// See http://doc.jsfiddle.net/use/echo.html
+let url = 'http://jsfiddle.net/echo/jsonp/';
+
+describe('JSONP单元测试', () => {
+	let originalTimeout;
+
+	beforeEach(function () {
+		originalTimeout = jasmine.DEFAULT_TIMEOUT_INTERVAL;
+		jasmine.DEFAULT_TIMEOUT_INTERVAL = 10000;
+	});
+	afterEach(function () {
+		jasmine.DEFAULT_TIMEOUT_INTERVAL = originalTimeout;
+	});
+
+	it('测试正常请求', done => {
+		fetchs
+			.jsonp(url, {
+				data: {
+					a: '1',
+					b: '2'
+				},
+				cache: true
+			})
+			.then(r => {
+				expect(r.data).toEqual({
+					a: '1',
+					b: '2'
+				});
+				done();
+			});
+	});
+});

node_modules/fetch-s/test/karma.conf.js

@@ -0,0 +1,75 @@
+// Karma configuration
+// Generated on Fri Mar 30 2018 14:29:01 GMT+0800 (CST)
+
+module.exports = function(config) {
+	config.set({
+		// base path that will be used to resolve all patterns (eg. files, exclude)
+		basePath: '',
+
+		// frameworks to use
+		// available frameworks: https://npmjs.org/browse/keyword/karma-adapter
+		frameworks: ['jasmine'],
+
+		// list of files / patterns to load in the browser
+		files: ['../test/**/*.spec.js'],
+
+		// list of files / patterns to exclude
+		exclude: [],
+
+		// preprocess matching files before serving them to the browser
+		// available preprocessors: https://npmjs.org/browse/keyword/karma-preprocessor
+		preprocessors: {
+			'../test/**/*.spec.js': ['webpack'],
+			'../src/**/*.js': ['coverage']
+		},
+		coverageReporter: {
+			type: 'lcov',
+			dir: '../coverage/',
+			subdir: '.'
+		},
+		// test results reporter to use
+		// possible values: 'dots', 'progress'
+		// available reporters: https://npmjs.org/browse/keyword/karma-reporter
+		reporters: ['progress', 'coverage'],
+
+		// web server port
+		port: 9876,
+
+		// enable / disable colors in the output (reporters and logs)
+		colors: true,
+
+		// level of logging
+		// possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG
+		logLevel: config.LOG_INFO,
+
+		// enable / disable watching file and executing tests whenever any file changes
+		autoWatch: true,
+
+		// start these browsers
+		// available browser launchers: https://npmjs.org/browse/keyword/karma-launcher
+		browsers: ['ChromeHeadless'],
+
+		// Continuous Integration mode
+		// if true, Karma captures browsers, runs the tests and exits
+		singleRun: true, //（change）
+
+		// Concurrency level
+		// how many browser should be started simultaneous
+		concurrency: Infinity,
+		webpack: {
+			module: {
+				loaders: [
+					{
+						test: /\.js$/,
+						loader: 'babel-loader',
+						exclude: /(node_modules)/,
+						query: {
+							presets: ['env'],
+							plugins: ['istanbul']
+						  }
+					}
+				]
+			}
+		}
+	});
+};

node_modules/fetch-s/test/typescript/fetchs.ts

@@ -0,0 +1,62 @@
+import fetchs, { FetchsConfig, FetchsResponse, FetchsInstance } from '../../';
+
+fetchs.interceptors.request.use(
+    function(config: FetchsConfig) {
+        // Do something before request is sent
+        return config;
+    },
+    function(error: any) {
+        // Do something with request error
+        return Promise.reject(error);
+    }
+);
+
+fetchs.interceptors.response.use(
+    function(response: FetchsResponse) {
+        // Do something with response data
+        return response.data;
+    },
+    function(error: any) {
+        // Do something with response error
+        return Promise.reject(error);
+    }
+);
+fetchs
+    .request({
+        method: 'GET',
+        timeout: 23,
+        credentials: 'include'
+    })
+    .then((response: FetchsResponse) => {
+        response;
+    });
+
+fetchs.post('/user', {
+    a: 1
+});
+
+fetchs.get('/user', {
+    data: {
+        a: 1
+    }
+});
+
+fetchs.jsonp('/user', {
+    cache: false,
+    data: {
+        a: 1
+    }
+});
+
+const instance: FetchsInstance = fetchs.create({
+    origin: 'https://www.example.com'
+});
+
+instance
+    .get('/user?ID=12345')
+    .then(function(response: FetchsConfig) {
+        console.log(response);
+    })
+    .catch(function(error: any) {
+        console.log(error);
+    });

node_modules/fetch-s/test/unit/create.spec.js

@@ -0,0 +1,38 @@
+import fetchMock from 'fetch-mock';
+import fetchs from './../../src/fetchs';
+
+describe('创建实例单元测试', () => {
+	beforeEach(function() {
+		const headers = {
+			'Content-Type': 'application/json;charset=utf-8',
+			'Access-Control-Allow-Origin': '*'
+		};
+		const body = { foo: 'bar' };
+
+		fetchMock.get('http://www.example.com/api/', {
+			status: 200,
+			body,
+			headers
+		});
+	});
+
+	afterEach(function() {
+		fetchMock.restore();
+	});
+	it('json', async () => {
+		const instance = fetchs.create({
+			origin: 'https://www.example.com'
+		});
+
+		await instance
+			.get('/api/', {
+				timeout: 1000
+			})
+			.then(r => {
+				expect(r.data).toEqual({ foo: 'bar' });
+			})
+			.catch(e => {
+				console.dir('error', e);
+			});
+	});
+});

node_modules/fetch-s/test/unit/get.spec.js

@@ -0,0 +1,44 @@
+import fetchMock from 'fetch-mock';
+import fetchs from './../../src/fetchs';
+
+describe('GET单元测试', () => {
+	beforeEach(function() {
+		const headers = {
+			'Content-Type': 'application/json;charset=utf-8',
+			'Access-Control-Allow-Origin': '*'
+		};
+		const body = { foo: 'bar' };
+
+		fetchMock.get('http://www.example.com/', {
+			status: 200,
+			body,
+			headers
+		});
+	});
+
+	afterEach(function() {
+		fetchMock.restore();
+	});
+	it('json', async () => {
+		await fetchs
+			.get('http://www.example.com/', {
+				timeout: 1000
+			})
+			.then(r => {
+				expect(r.data).toEqual({ foo: 'bar' });
+			})
+			.catch(e => {
+				console.dir('error', e);
+			});
+	});
+	it('timeout', async () => {
+		await fetchs
+			.get('http://www.example.com/', {
+				dataType: 'json',
+				timeout: 0
+			})
+			.catch(e => {
+				expect(e).toEqual(new Error('Request timed out'));
+			});
+	});
+});

node_modules/fetch-s/test/unit/jsonp.spec.js

@@ -0,0 +1,42 @@
+import jsonp from './../../src/core/jsonp';
+
+// See http://doc.jsfiddle.net/use/echo.html
+let url ="http://jsfiddle.net/echo/jsonp/?a=1&b=2";
+
+describe('test jsonp...', () => {
+	
+	let originalTimeout;
+
+    beforeEach(function() {
+    	originalTimeout = jasmine.DEFAULT_TIMEOUT_INTERVAL;
+    	jasmine.DEFAULT_TIMEOUT_INTERVAL = 10000;
+	});
+	afterEach(function() {
+		jasmine.DEFAULT_TIMEOUT_INTERVAL = originalTimeout;
+	});
+
+	it('测试正常请求', done => {
+		jsonp({
+			url: url,
+			timeout: 8000,
+			cache: true
+		}).then(data => {
+			expect(data).toEqual({
+				a: '1',
+				b: '2'
+			});
+			done();
+		})
+	});
+
+	it('测试超时', done => {
+		jsonp({
+			url: url,
+			timeout: 1,
+			cache: false
+		}).catch(e => {
+			expect(e).toEqual(new Error('Request timed out'));
+			done();
+		});
+	});
+});

node_modules/fetch-s/test/unit/post.spec.js

@@ -0,0 +1,42 @@
+import fetchMock from 'fetch-mock';
+import fetchs from './../../src/fetchs';
+
+describe('POST单元测试', () => {
+	beforeEach(function() {
+		const headers = {
+			'Content-Type': 'application/json;charset=utf-8',
+			'Access-Control-Allow-Origin': '*'
+		};
+		const body = { foo: 'bar' };
+
+		fetchMock.post('http://www.example.com/', {
+			status: 200,
+			body,
+			headers
+		});
+	});
+
+	afterEach(function() {
+		fetchMock.restore();
+	});
+
+	it('json', async () => {
+		await fetchs
+			.post('http://www.example.com/', {
+				timeout: 1000
+			})
+			.then(r => {
+				expect(r.data).toEqual({ foo: 'bar' });
+			});
+	});
+	it('timeout', async () => {
+		await fetchs
+			.post('http://www.example.com/', {
+				dataType: 'json',
+				timeout: 0
+			})
+			.catch(e => {
+				expect(e).toEqual(new Error('Request timed out'));
+			});
+	});
+});

node_modules/fetch-s/test/utils/buildURL.spec.js

@@ -0,0 +1,25 @@
+import buildURL from './../../src/utils/buildURL';
+
+describe('test buildURL...', () => {
+	const origin = 'http://github.com';
+	it('测试url相对路径', () => {
+		let url = '/RekingZhang/';
+		let params = {
+			a: 1,
+			b: 2
+		};
+		expect(buildURL(origin, url, params)).toBe(
+			'http://github.com/RekingZhang/?a=1&b=2'
+		);
+	});
+	it('测试url为绝对路径', () => {
+		let url = 'https://github.com/RekingZhang/';
+		let params = {
+			a: 1,
+			b: 2
+		};
+		expect(buildURL(origin, url, params)).toBe(
+			'https://github.com/RekingZhang/?a=1&b=2'
+		);
+	});
+});

node_modules/fetch-s/test/utils/clone.spec.js

@@ -0,0 +1,34 @@
+import clone from './../../src/utils/clone';
+
+describe('test clone...', () => {
+	it('测试Object', () => {
+		let obj = {
+			a: 1,
+			b: 'as',
+			c: {
+				a: '23'
+			}
+		};
+		expect(clone(obj)).toEqual(obj);
+	});
+	it('测试Date', () => {
+		let obj = {
+			a: 1,
+			b: new Date()
+		};
+		expect(clone(obj)).toEqual(obj);
+	});
+	it('测试Array', () => {
+		let obj = {
+			a: 1,
+			b: new Date(),
+			c: [
+				1,
+				{
+					a: 23
+				}
+			]
+		};
+		expect(clone(obj)).toEqual(obj);
+	});
+});

node_modules/fetch-s/test/utils/extend.spec.js

@@ -0,0 +1,17 @@
+import extend from './../../src/utils/extend';
+
+describe('test extend...', () => {
+	it('测试Object', () => {
+		let obj = {
+			a: 1,
+			b: 'as',
+			c: {
+				a: '23'
+			}
+		};
+		let extendObj = extend(obj,{
+			a:3
+		});
+		expect(extendObj).toEqual(obj);
+	});
+});

node_modules/fetch-s/test/utils/paramsSerializer.spec.js

@@ -0,0 +1,39 @@
+import paramsSerializer from './../../src/utils/paramsSerializer';
+
+describe('test buildURL...', () => {
+	const origin = 'http://github.com';
+	it('测试参数为JSON对象', () => {
+		let params = {
+			a: 1,
+			b: 2
+		};
+		expect(paramsSerializer(params)).toBe('a=1&b=2');
+	});
+	it('测试参数为URLSearchParams对象', () => {
+		let params = new URLSearchParams('a=1&b=2');
+		expect(paramsSerializer(params)).toBe('a=1&b=2');
+	});
+
+	it('测试参数为String', () => {
+		let params = 'a=1';
+		expect(paramsSerializer(params)).toBe('a=1');
+	});
+
+	it('测试参数为Date', () => {
+		let params = {
+			time: new Date('2017-08-09')
+		};
+		expect(paramsSerializer(params)).toBe(
+			'time=' + new Date('2017-08-09').toISOString()
+		);
+	});
+
+	it('测试参数编码', () => {
+		let params = {
+			name: '张三'
+		};
+		expect(paramsSerializer(params)).toBe(
+			'name=' + encodeURIComponent('张三')
+		);
+	});
+});

node_modules/fetch-s/test/utils/type.spec.js

@@ -0,0 +1,115 @@
+import types from './../../src/utils/type';
+
+describe('test types...', () => {
+	it('isArray', () => {
+		expect(types.isArray([])).toBe(true);
+
+		expect(types.isArray({})).toBe(false);
+
+		expect(types.isArray(arguments)).toBe(false);
+	});
+
+	it('isArrayBuffer', () => {
+		let buffer = new ArrayBuffer(8);
+		expect(types.isArrayBuffer(buffer)).toBe(true);
+
+		expect(types.isArrayBuffer([])).toBe(false);
+	});
+
+	it('isArrayBufferView', () => {
+		expect(
+			types.isArrayBufferView(new DataView(new ArrayBuffer(2)))
+		).toEqual(true);
+	});
+
+	it('isBlob', () => {
+		let debug = { hello: 'world' };
+		let blob = new Blob([JSON.stringify(debug, null, 2)], {
+			type: 'application/json'
+		});
+		expect(types.isBlob(blob)).toBe(true);
+
+		expect(types.isBlob(debug)).toBe(false);
+	});
+
+	it('isDate', () => {
+		expect(types.isDate(new Date())).toBe(true);
+
+		expect(types.isDate(+new Date())).toBe(false);
+	});
+
+	it('isFormData', () => {
+		let formData = new FormData();
+		formData.append('username', 'Groucho');
+		expect(types.isFormData(formData)).toBe(true);
+
+		expect(types.isFormData('formData')).toBe(false);
+	});
+
+	it('isFile', () => {
+		let file = new File(['foo'], './../index.js', {
+			type: 'text/plain'
+		});
+		expect(types.isFile(file)).toBe(true);
+
+		expect(types.isFile('formData')).toBe(false);
+	});
+
+	it('isFunction', () => {
+		expect(types.isFunction(function fn() {})).toBe(true);
+
+		expect(types.isFunction(() => {})).toBe(true);
+
+		expect(types.isFunction(Array)).toBe(true);
+
+		expect(types.isFunction({})).toBe(false);
+	});
+
+	it('isNull', () => {
+		let a = null;
+		expect(types.isNull(a)).toBe(true);
+
+		expect(types.isNull('')).toBe(false);
+	});
+
+	it('isNumber', () => {
+		expect(types.isNumber(1.2)).toBe(true);
+
+		expect(types.isNumber(-1)).toBe(true);
+
+		expect(types.isNumber(2)).toBe(true);
+
+		expect(types.isNumber('2')).toBe(false);
+	});
+
+	it('isObject', () => {
+		expect(types.isObject({})).toBe(true);
+
+		expect(types.isObject('')).toBe(false);
+
+		expect(types.isObject(null)).toBe(false);
+	});
+
+	it('isString', () => {
+		expect(types.isString('2323')).toBe(true);
+
+		expect(types.isString({})).toBe(false);
+	});
+	it('isUndefined', () => {
+		let a,
+			b = 1;
+		expect(types.isUndefined(a)).toBe(true);
+
+		expect(types.isUndefined(b)).toBe(false);
+	});
+
+	it('isURLSearchParams', () => {
+		expect(
+			types.isURLSearchParams(
+				new URLSearchParams('q=URLUtils.searchParams&topic=api')
+			)
+		).toBe(true);
+		expect(types.isURLSearchParams('a=1')).toBe(false);
+		expect(types.isURLSearchParams({ a: 1 })).toBe(false);
+	});
+});