it('Create', () => co(function * () {
let server = yield apemanApi({
port,
configuration: {
$api: {
pingPong: {
ping () {
return 'pong'
}
},
$serverMiddlewares: [
create('/sse/bomb', (client) => co(function * () {
let count = 10
while (count >= 0) {
client.send('tick', JSON.stringify(count))
yield asleep(100)
count--
}
client.send('boom!')
}), { keep: false })
],
$pathname: '/api/rpc'
}
}
})
assert(server)
let client = apemanApiClient(`${baseUrl}/api/rpc`)
assert.ok(client)
{
let pingPong = yield client.connect('pingPong')
let pong = yield pingPong.ping()
assert.equal(pong, 'pong')
}
yield asleep(300)
let eventSource = new EventSource(`${baseUrl}/sse/bomb`)
eventSource.on('tick', (event) => {
let { data } = event
console.log('tick', data)
})
yield asleep(500)
yield server.close()
}))
it('Create', () => co(function * () {
let server = yield apemanApi({
port,
configuration: {
$api: {
pingPong: {
ping () {
return 'pong'
}
},
$middlewares: [
create({})
],
$pathname: '/api/rpc'
}
}
})
assert(server)
let client = apemanApiClient(`${baseUrl}/api/rpc`)
assert.ok(client)
{
let pingPong = yield client.connect('pingPong')
let pong = yield pingPong.ping()
assert.equal(pong, 'pong')
}
yield asleep(300)
yield server.close()
}))
before(async () => {
port = await aport()
server = rfunc({
foo: {
async bar (text) {
const d = new Date()
await asleep(100)
return {
time: new Date() - d,
text
}
},
hoge () {
throw Object.assign(new Error('hoge!'), {status: 400})
},
$spec: {
name: 'foo-api',
methods: {
hello: {desc: 'Say hello'},
bye: {desc: 'Say bye'}
}
}
},
baz () {
return 'This is baz!'
},
$pathname: BASE_URL
})
server.listen(port)
baseUrl = `http://localhost:${port}${BASE_URL}`
})
create('/sse/bomb', (client) => co(function * () {
let count = 10
while (count >= 0) {
client.send('tick', JSON.stringify(count))
yield asleep(100)
count--
}
client.send('boom!')
}), { keep: false })
it('Do request', () => co(function * () {
let client = apemanApiClient(`${proxyBaseUrl}/api/rpc`)
assert.ok(client)
{
let pingPong = yield client.connect('pingPong')
let pong = yield pingPong.ping()
assert.equal(pong, 'pong')
}
{
let { statusCode, body } = yield request({
url: `${proxyBaseUrl}/api/rpc/proxy/hoge`,
method: 'POST'
})
assert.equal(statusCode, 200)
assert.equal(body, 'request successfully proxied!')
}
yield asleep(300)
}))
return co.wrap(function * apemanMiddlewareSse (ctx, next) {
let { query: params = {} } = ctx
ctx.connected = true
if (_skip(ctx.url)) {
yield next()
return
}
let { req, res } = ctx
let client = new SSEClient(req, res)
client.params = params
client.fire = (event, data) => client.send(event, JSON.stringify(data))
client.initialize()
try {
yield Promise.resolve(handler(client, ctx))
} catch (e) {
throw e
}
while (keep && ctx.connected) {
yield asleep(0)
}
})
it('Create', () => co(function * () {
let server = yield apemanApi({
port,
configuration: {
$api: {
pingPong: {
ping () {
let { lang } = this
return 'pong:' + lang
}
},
$middlewares: [
create(loc, {})
],
$pathname: '/api/rpc'
}
}
})
assert(server)
let agent = superagent()
let client = apemanApiClient(`${baseUrl}/api/rpc`, { agent })
assert.ok(client)
{
let pingPong = yield client.connect('pingPong')
let pong = yield pingPong.ping()
assert.equal(pong, 'pong:en')
}
{
agent.set('accept-language', 'ja')
let pingPong = yield client.connect('pingPong')
let pong = yield pingPong.ping()
assert.equal(pong, 'pong:ja')
}
yield asleep(300)
yield server.close()
}))
it('Akv', async () => {
let filename = `${__dirname}/../tmp/testing-akv/akv.json`
let akv = new AKV(filename, {interval: 100})
await akv.touch()
assert.ok(fs.existsSync(filename))
await akv.destroy()
assert.ok(!fs.existsSync(filename))
{
let {storage} = akv
await storage.write({foo: 'baz'})
let data = await storage.read()
assert.deepEqual(data, {foo: 'baz'})
assert.ok(storage.needsFlush)
await asleep(300)
assert.ok(!storage.needsFlush)
}
for (let i = 0; i < 5; i++) {
await akv.set('index', String(i))
let index = await akv.get('index')
assert.equal(index, String(i))
}
for (let i = 0; i < 100; i++) {
akv.set('index', String(i))
akv.get('index').then((index) => {
// console.log('index', index)
})
}
assert.equal(await akv.get('index'), '99')
assert.deepEqual(await akv.all(), await akv.all())
assert.deepEqual(await akv.keys(), await akv.keys())
await akv.commit()
})
it('Command', () => co(function * () {
let configuration = require.resolve('../misc/mocks/mock-Apemanfile')
let server = yield apemanApi({
port,
configuration
})
assert(server)
// Describe for all api
{
let { statusCode, body, headers } = yield request({
url: `${baseUrl}/api`,
method: 'OPTIONS'
})
assert.equal(statusCode, 200)
let spec = body.data.attributes
assert.ok(spec)
}
// Use default scope
{
let { statusCode, body } = yield request({
url: `${baseUrl}/api/sign/signin`,
method: 'POST',
json: true,
body: {
data: {
type: 'invocations',
id: uuid.v4(),
attributes: {
params: [ 'foo', 'bar' ]
}
}
}
})
assert.equal(statusCode, 200)
let { returns } = body.data.attributes
assert.deepEqual(returns, { success: true })
}
// Use default scope with camel
{
let { statusCode, body } = yield request({
url: `${baseUrl}/api/hoge-hoge/say-hey`,
method: 'POST',
json: true,
body: {
data: {
type: 'invocations',
id: uuid.v4(),
attributes: {}
}
}
})
assert.equal(statusCode, 200)
let { returns } = body.data.attributes
assert.deepEqual(returns, 'hey')
}
// Use custom scope
{
let { statusCode, body } = yield request({
url: `${baseUrl}/api/scoped/admin/user/destroy`,
method: 'POST',
json: true,
body: {
data: {
type: 'invocations',
id: uuid.v4(),
attributes: {
params: [ 'foo', 'bar' ]
}
}
}
})
assert.equal(statusCode, 200)
let { returns } = body.data.attributes
assert.deepEqual(returns, { success: false })
}
yield asleep(300)
yield server.close()
}))
it('Command', () => co(function * () {
let configuration = require.resolve('../misc/mocks/mock-Apemanfile')
let server = yield apemanApi({
port,
configuration
})
assert(server)
let client = new Client(`${baseUrl}/api/rpc`)
assert.ok(client)
// Use default scope api
{
let spec = yield client.describe('sign')
assert.ok(spec)
let sign = yield client.connect('sign')
let result = yield sign.signin()
assert.deepEqual(result, { success: true })
}
// Use default scope api with camel case names
{
let hogeHoge = yield client.connect('hogeHoge')
let result = yield hogeHoge.sayHey()
assert.deepEqual(result, 'hey')
}
// Use custom scope api
{
let admin = client.of('@admin')
let user = yield admin.connect('user')
let result = yield user.destroy()
assert.ok(result)
}
// Use server send event
{
let spec = yield client.describe('sse')
let eventSource = client.eventSource('sse')
eventSource.addEventListener('error', (err) => {
console.error(err)
})
eventSource.addEventListener('tick', (ev) => {
let { type, data } = ev
data = JSON.parse(data)
assert.equal(type, 'tick')
let { count } = data
if (count === 1) {
eventSource.close()
}
assert.ok(data)
})
asleep(500)
}
// Try to reach
{
let reached = yield client.reach()
assert.ok(reached)
}
yield asleep(300)
yield server.close()
}))