mirror of
https://github.com/thinkjs/thinkjs.git
synced 2025-12-08 18:26:23 +00:00
373 lines
8.2 KiB
JavaScript
373 lines
8.2 KiB
JavaScript
import test from 'ava';
|
|
const helper = require('think-helper');
|
|
const mock = require('mock-require');
|
|
const mockie = require('../../lib/mockie');
|
|
const utils = require('../../lib/utils');
|
|
// const path = require('path');
|
|
|
|
function getApplication() {
|
|
return mock.reRequire('../../../lib/application');
|
|
}
|
|
|
|
const defaultOption = {
|
|
ROOT_PATH: __dirname
|
|
// APP_PATH: path.resolve(__dirname,'../runtime')
|
|
};
|
|
|
|
const ctx = {
|
|
app: {modules: ''},
|
|
body: 'hello thinkjs',
|
|
status: 404,
|
|
ip: '10.10.10.10',
|
|
ips: '10.10.10.10,11.11.11.11',
|
|
module: '',
|
|
method: 'GET',
|
|
userAgent: 'test',
|
|
referrer(onlyHost) {
|
|
return onlyHost;
|
|
},
|
|
referer(onlyHost) {
|
|
return onlyHost;
|
|
},
|
|
download() {
|
|
return true;
|
|
},
|
|
type: 'text/html; charset=UTF-8',
|
|
isGet: true,
|
|
isPost: false,
|
|
isCli: true,
|
|
params: {name: 'thinkjs'},
|
|
header: {
|
|
accept: 'application/json, text/plain, */*',
|
|
'Accept-Encoding': 'gzip, deflate, br'
|
|
},
|
|
res: {
|
|
},
|
|
redirect(url, alt) {
|
|
return url;
|
|
},
|
|
set(name, value) {
|
|
if (helper.isObject(name)) {
|
|
this.header = Object.assign({}, this.header, name);
|
|
return;
|
|
}
|
|
this.header[name] = value;
|
|
},
|
|
isMethod(method) {
|
|
return method === this.method;
|
|
},
|
|
isAjax() {
|
|
return true;
|
|
},
|
|
isJsonp(callback) {
|
|
return callback;
|
|
},
|
|
json(str) {
|
|
return JSON.parse(str);
|
|
},
|
|
jsonp(data, callback) {
|
|
return data;
|
|
},
|
|
success(data, message) {
|
|
return {
|
|
errno: 0,
|
|
data,
|
|
errmsg: message || ''
|
|
};
|
|
},
|
|
fail({errno, errmsg, data}) {
|
|
return {errno, errmsg, data};
|
|
},
|
|
expires(time) { return time },
|
|
param(name, value) {
|
|
if (value) {
|
|
this.params[name] = value;
|
|
return value;
|
|
}
|
|
return this.params[name];
|
|
},
|
|
post(name, value) { return value },
|
|
file(name, value) { return value },
|
|
cookie(name, value) { return value }
|
|
};
|
|
|
|
mockie.mockCluster(false);
|
|
mockie.mockThinkCluster({isFirstWorker: () => { return true }});
|
|
const App = getApplication();
|
|
const app = new App(defaultOption);
|
|
const controller = new think.Controller(ctx);
|
|
app.parseArgv = () => { return {} };
|
|
app.run();
|
|
|
|
test('get/set body', async t => {
|
|
const body = 'hello thinkjs again';
|
|
t.is(controller.body, ctx.body);
|
|
controller.body = body;
|
|
t.is(controller.body, body);
|
|
});
|
|
|
|
test('get/set status', async t => {
|
|
const status = 200;
|
|
t.is(controller.status, ctx.status);
|
|
controller.status = status;
|
|
t.is(controller.status, status);
|
|
});
|
|
|
|
test('get/set type', async t => {
|
|
const contentType = 'some content type';
|
|
t.is(controller.type, ctx.type);
|
|
controller.type = contentType;
|
|
t.is(controller.type, contentType);
|
|
});
|
|
|
|
test('get ip', async t => {
|
|
t.is(controller.ip, ctx.ip);
|
|
});
|
|
|
|
test('get ips', async t => {
|
|
t.is(controller.ips, ctx.ips);
|
|
});
|
|
|
|
test('config function', async t => {
|
|
t.is(controller.config('port'), 8360);
|
|
controller.config('port', 8361, ctx.module);
|
|
t.is(controller.config('port'), 8361);
|
|
});
|
|
|
|
test('get method', async t => {
|
|
t.is(controller.method, ctx.method);
|
|
});
|
|
|
|
test('isMethod method', async t => {
|
|
t.is(controller.isMethod(ctx.method), true);
|
|
});
|
|
|
|
test('get isGet', async t => {
|
|
t.is(controller.isGet, true);
|
|
});
|
|
|
|
test('get isPost', async t => {
|
|
t.is(controller.isPost, false);
|
|
});
|
|
|
|
test('isCli method', async t => {
|
|
t.is(controller.isCli, true);
|
|
});
|
|
|
|
test('isAjax method', async t => {
|
|
t.is(controller.isAjax('GET'), true);
|
|
});
|
|
|
|
test('jsonp method', async t => {
|
|
t.is(controller.jsonp('callback'), 'callback');
|
|
});
|
|
|
|
test('isJsonp method', async t => {
|
|
t.is(controller.isJsonp('callback'), 'callback');
|
|
});
|
|
|
|
test('json method', async t => {
|
|
const obj = {
|
|
name: 'thinkjs'
|
|
};
|
|
t.deepEqual(controller.json(JSON.stringify(obj)), obj);
|
|
});
|
|
|
|
test('success method', async t => {
|
|
const data = {name: 'thinkjs'};
|
|
t.deepEqual(controller.success(data).data, data);
|
|
});
|
|
|
|
test('fail method', async t => {
|
|
const data = {
|
|
errno: 404,
|
|
errmsg: 'error',
|
|
data: []
|
|
};
|
|
t.deepEqual(controller.fail(data), data);
|
|
});
|
|
|
|
test('expires method', async t => {
|
|
t.deepEqual(controller.expires(20000), 20000);
|
|
});
|
|
|
|
test('get method', async t => {
|
|
t.deepEqual(controller.get('name'), 'thinkjs');
|
|
});
|
|
|
|
test('query method', async t => {
|
|
t.deepEqual(controller.query('test', 'test'), 'test');
|
|
});
|
|
|
|
test('post method', async t => {
|
|
t.deepEqual(controller.post('test', 'test'), 'test');
|
|
});
|
|
|
|
test('file method', async t => {
|
|
t.deepEqual(controller.file('test', 'test'), 'test');
|
|
});
|
|
|
|
test('cookie method', async t => {
|
|
t.deepEqual(controller.cookie('test', 'test'), 'test');
|
|
});
|
|
|
|
test('header method', async t => {
|
|
t.is(controller.header('accept'), ctx.header.accept);
|
|
controller.header('Connection', 'keep-alive');
|
|
t.is(controller.header('Connection'), 'keep-alive');
|
|
controller.header({Host: 'thinkjs.org'});
|
|
t.is(controller.header('Host'), 'thinkjs.org');
|
|
ctx.res.headersSent = true;
|
|
t.is(controller.header('Connection', 'keep-alive'), undefined);
|
|
t.is(controller.header(), undefined);
|
|
});
|
|
|
|
test('userAgent method', async t => {
|
|
t.deepEqual(controller.userAgent, 'test');
|
|
});
|
|
|
|
test('referrer method', async t => {
|
|
t.deepEqual(controller.referrer(true), true);
|
|
});
|
|
|
|
test('referer method', async t => {
|
|
t.deepEqual(controller.referer(true), true);
|
|
});
|
|
|
|
test('redirect method', async t => {
|
|
const url = 'https://thinkjs.org/';
|
|
t.deepEqual(controller.redirect(url), false);
|
|
});
|
|
|
|
test('controller method', async t => {
|
|
think.app = {
|
|
controllers: {
|
|
test: class TestController {}
|
|
}
|
|
};
|
|
t.is(controller.controller('test') instanceof think.app.controllers.test, true);
|
|
});
|
|
|
|
test('controller method in modules', async t => {
|
|
think.app = {
|
|
controllers: {
|
|
common: {
|
|
test: class TestController {}
|
|
}
|
|
}
|
|
};
|
|
ctx.app.modules = ['test'];
|
|
t.is(controller.controller('test') instanceof think.app.controllers.common.test, true);
|
|
});
|
|
|
|
test.serial('service method with modules', async t => {
|
|
think.app = {
|
|
services: {
|
|
common: {
|
|
test: class TestService {}
|
|
}
|
|
},
|
|
modules: ['test', 'common']
|
|
};
|
|
const ins = controller.service('test');
|
|
t.is(ins instanceof think.app.services.common.test, true);
|
|
});
|
|
|
|
test.serial('service method with autocomplete modules', async t => {
|
|
t.plan(2);
|
|
think.app = {
|
|
services: {
|
|
home: {
|
|
home_test: class HomeTestService {}
|
|
},
|
|
common: {
|
|
test: class TestService {}
|
|
}
|
|
},
|
|
modules: ['home', 'common']
|
|
};
|
|
const newCtx = Object.assign({}, ctx);
|
|
newCtx.module = 'home';
|
|
|
|
const newController = new think.Controller(newCtx);
|
|
const insA = newController.service('home_test', 'home');
|
|
t.true(insA instanceof think.app.services.home.home_test);
|
|
|
|
const insB = newController.service('home_test');
|
|
t.true(insB instanceof think.app.services.home.home_test);
|
|
});
|
|
|
|
test.serial('service method', async t => {
|
|
think.app = {
|
|
services: {
|
|
test: {}
|
|
},
|
|
modules: []
|
|
};
|
|
const ins = controller.service('test');
|
|
t.deepEqual(ins, think.app.services.test);
|
|
});
|
|
|
|
test('download method', async t => {
|
|
t.deepEqual(controller.download(), true);
|
|
});
|
|
|
|
test.serial('action method', async t => {
|
|
let runAction = false;
|
|
let runCallAction = false;
|
|
let runAfterAction = false;
|
|
think.app = {
|
|
controllers: {
|
|
test: class TestController {
|
|
testAction() {
|
|
runAction = true;
|
|
}
|
|
__call() {
|
|
runCallAction = true;
|
|
}
|
|
__after() {
|
|
runAfterAction = true;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
await controller.action('test', 'test');
|
|
t.is(runAction, true);
|
|
await controller.action('test', 'none');
|
|
t.is(runCallAction, true);
|
|
t.is(runAfterAction, true);
|
|
});
|
|
|
|
test.serial('action with __before and return false', async t => {
|
|
let runAction = false;
|
|
think.app = {
|
|
controllers: {
|
|
test: class TestController {
|
|
__before() {
|
|
return false;
|
|
}
|
|
testAction() {
|
|
runAction = true;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
await controller.action('test', 'test');
|
|
t.is(runAction, false);
|
|
});
|
|
|
|
test.serial('action with __before', async t => {
|
|
const runAction = false;
|
|
think.app = {
|
|
controllers: {
|
|
test: class TestController {
|
|
__before() {
|
|
return 'test';
|
|
}
|
|
}
|
|
}
|
|
};
|
|
await controller.action('test', 'test');
|
|
t.is(runAction, false);
|
|
});
|